动态数组------双端栈的实现

最新推荐文章于 2022-07-13 17:53:32 发布

原创最新推荐文章于 2022-07-13 17:53:32 发布 · 236 阅读

0 ·

CC 4.0 BY-SA版权

数据结构与算法专栏收录该内容

51 篇文章

订阅专栏

本文详细介绍了一种名为ArrayDoubleEndStack的双端栈数据结构的实现方法，该结构允许从两端进行入栈和出栈操作，同时具备自动扩容和缩容功能，以适应不同场景下的需求。

在这里插入图片描述

ArrayDoubleEndStack实现类

package shixianClass;

import java.util.Arrays;

public class ArrayDoubleEndStack<E> {
    private E[] data;  //存元素的容器
    private int ltop;  //左端栈的栈顶   ltop==-1表示左端栈为空    ltop+1==表示左端栈的个数
    private int rtop;//右端栈的栈顶  rtop==length表示右端栈为空   length-rtop表示右端栈的个数
    private static int DEFAULT_SIZE=10;//双端栈的默认容量


    public ArrayDoubleEndStack(){
        data=(E[])new Object[DEFAULT_SIZE];
        ltop=-1;
        rtop=data.length;
    }


    //入栈操作
    public void push(E elemennt,int stackId){
        if(ltop+1==rtop){   //双端栈已经满了
            resize(data.length*2);
        }
        switch (stackId){
            case 0:        //向左端栈 入栈
                data[++ltop]=elemennt;
                break;
            case 1:       //向右端栈 入栈
                data[--rtop]=elemennt;
                break;
        }
    }

    //出栈
    public E pop(int stackId){
        if(isEmpty(stackId)){
            throw new  NullPointerException("stack is null");
        }
        E ret=null;
        switch (stackId){
            case 0:
                ret=data[ltop--];
                break;
            case 1:
                ret=data[rtop++];
                break;
        }
        //如果元素个数<=length/4&&>length>DEFAULT_SIZE  缩容
        if(size(0)+size(1)<=data.length/4 && data.length>DEFAULT_SIZE){
            resize(data.length/2);
        }
        return ret;
    }


    //扩容缩容
    private void resize(int newLength) {
        E [] newData=(E[])new Object[newLength];
        //先处理左端
        for(int i=0;i<=ltop;i++){
            newData[i]=data[i];
        }
        //在处理右端
        int index=rtop;
        for(int i=newLength-size(1);i<=newLength-1;i++){
            newData[i]=data[index++];
        }
        rtop=newLength-size(1);
        data=newData;
    }

    //获取有效元素个数
    public int size(int stackId){
        switch (stackId){
            case 0:
                return ltop+1;
            case 1:
                return data.length-rtop;
        }
        return -1;
    }


    //判断某一端栈是否为空
    public boolean isEmpty(int stackId){
        switch (stackId){
            case 0:
                return ltop==-1;
            case 1:
                return rtop==data.length;
        }
        return false;
    }
    //获取栈顶
    public E peek(int stackId){
        switch (stackId){
            case 0:
                return data[ltop];
            case 1:
                return data[rtop];
        }
        return null;
    }
//清空
    public void clear(int stackId){
        switch (stackId){
            case 0:
                ltop=-1;
                break;
            case 1:
                rtop=data.length;
        }
    }

    @Override
    public String toString() {
        StringBuilder sb=new StringBuilder(String.format("ArrarDoubleEndStack:%d/%d\n",size(0)+size(1),data.length));
        if(isEmpty(0)){
            sb.append("leftStack:[]\n");
        }else {
            sb.append("leftStack[");
            for (int i=0;i<=ltop;i++){
                sb.append(data[i]);
                if(i==ltop){
                    sb.append(']');
                    sb.append('\n');
                }else {
                    sb.append(',');
                }
            }
        }
        if(isEmpty(1)){
            sb.append("rightStack:[]");
        }else {
            sb.append("rightStack:[");
            for (int i=data.length-1;i>=rtop;i--){
                sb.append(data[i]);
                if(i==rtop){
                    sb.append(']');
                    sb.append('\n');
                }else {
                    sb.append(',');
                }
            }
        }
        return sb.toString();
    }
}

测试类

package ceshi;

import shixianClass.ArrayDoubleEndStack;

public class TestArrayDoubleEndStack {
    public static void main(String[] args) {
        ArrayDoubleEndStack<Integer> stack=new ArrayDoubleEndStack<Integer>();
        System.out.println(stack);
        for(int i=1;i<=6;i++){
            stack.push(i,0);
        }
        System.out.println(stack);
        for(int i=7;i<=12;i++){
            stack.push(i,1);
        }
        System.out.println(stack);
        for (int i=0;i<4;i++){
            System.out.println(stack.pop(0));
            System.out.println(stack.pop(1));
        }
        System.out.println(stack);
    }

}

执行结果

ArrarDoubleEndStack:0/10
leftStack:[]
rightStack:[]
ArrarDoubleEndStack:6/10
leftStack[1,2,3,4,5,6]
rightStack:[]
ArrarDoubleEndStack:12/20
leftStack[1,2,3,4,5,6]
rightStack:[7,8,9,10,11,12]

6
12
5
11
4
10
3
9
ArrarDoubleEndStack:4/10
leftStack[1,2]
rightStack:[7,8]