算法——Java實現棧

棧

 定義：

棧是一種先進后出的數據結構，我們把允許插入和刪除的一端稱為棧頂，另一端稱為棧底，不含任何元素的棧稱為空棧

 

棧的java代碼實現：

基於數組：

import org.junit.jupiter.api.Test;

/**
 *  用數組實現棧
 * @author wydream
 *
 */

public class ArrayStack<T> {

    private T data[];
    private int maxSize;
    private int top;
    
    
    //初始化棧
    public ArrayStack(int maxSize) {
        this.maxSize=maxSize;
        data=(T[])new Object[maxSize];
        this.top=-1;
    }
    
    //判斷棧是否為空
    public boolean isEmpty() {
        return (top==-1);
    }
    
    //判斷棧是否已經滿了
    public  boolean isFull() {
        return (top==maxSize-1);
    }
    
    
    //壓棧
    public boolean push(T value) {
        if(isFull()) {
            return false;
        }
        top++;
        data[top]=value;
        return true;
    }
    
    
    //取出棧頂元素
    public T pop() {
        if(isEmpty()) {
            return null;
        }
        T tmp=data[top];
        data[top]=null;
        top--;
        return tmp;
    }
    
    //============測試代碼============
    public static void main(String[] args) {
        ArrayStack<String> as=new ArrayStack<String>(4);
        as.push("anhui");
        as.push("shanghai");
        as.push("beijing");
        as.push("nanj");
        //測試棧已經滿了的情況
        System.out.println(as.push("aa"));
        for(int i=0;i<4;i++) {
            System.out.println(as.pop());
        }
    }
        
}

 

基於鏈表：

import org.junit.jupiter.api.Test;

/**
 *   基於鏈表實現的棧
 * @author wydream
 *
 */

public class NodeStack<T> {
    
    private Node<T> top=null;//棧頂
    public NodeStack() {
        this.top=null;
    }
    
    //判斷棧是否為空
    public boolean isEmpty() {
        if(top!=null) {
            return false;
        }
        return true;
    }
    
    //壓棧
    public boolean push(T value) {
        Node<T> node=new Node<T>(value);
        node.setNext(top);
        top=node;
        return true;
    }
    
    //出棧
    public T pop() {
        if(top==null) {
            return null;
        }
        T tmp=top.data;
        top=top.getNext();
        return tmp;
    }
    //取出棧頂的值
    public T peek() {
        if(isEmpty()) {
            return null;
        }
        return top.data;
    }
    
    
    class Node<T>{
        private T data;//數據
        private Node<T> next;//指向下一個節點的指針
        //初始化鏈表
        public Node(T data) {
            this.data=data;
        }
        //獲取下一個節點
        public Node<T> getNext(){
            return this.next;
        }
        //設置下一個節點
        public void setNext(Node<T> n) {
            this.next=n;
        }
        //獲取節點數據
        public T getData() {
            return this.data;
        }
        //設置節點數據
        public void setData(T d) {
            this.data=d;
        }
        
    }
    
    public static void main(String[] args) {
        
        NodeStack<String> ns=new NodeStack<String>();
        
        //測試是否為空
        System.out.println("=======是否為空======");
        System.out.println(ns.isEmpty());
        System.out.println("=============");
        //壓棧測試
        System.out.println("=======壓棧======");
        ns.push("北京");
        ns.push("上海");
        ns.push("深證");
        ns.push("廣州");
        //是否為空
        System.out.println("=======是否為空======");
        System.out.println(ns.isEmpty());
        System.out.println("=============");

        System.out.println("=======出棧=======");
        //出棧
        System.out.println(ns.pop());
        System.out.println(ns.pop());
        System.out.println(ns.pop());
        System.out.println(ns.pop());
        System.out.println(ns.pop());
        
        //是否為空
        System.out.println("=======是否為空======");
        System.out.println(ns.isEmpty());
        System.out.println("=============");
        
        
    }
}

 

兩棧共享空間： 

棧有個缺陷，必須事先確定數組的大小，這樣如果棧滿了的話，想在存儲元素就必須通過編程手段來擴充數組的容量，這樣就很麻煩。於是我們就設計一個數組，里面存放着兩個棧，共享這一個數組空間，這樣就可以充分利用空間。數組有兩個端點，兩個棧有兩個棧底，讓一個棧的棧底為數組的0下標，另一個棧的棧為數組的長度n-1處

 

代碼實現：

import javax.crypto.Mac;

/**
 *   兩棧共享空間
 * @author wydream
 *
 */

public class DoubleStatk {

    private final static int MAXSIZE=20;
    private int[] stackElem;
    private int top1; //將top1設置為指向棧1棧頂元素的存儲位置即數組下標0
    private int top2; //將top2設置為指向棧2棧頂元素的存儲位置即數組下標n-1
    
    public DoubleStatk() {
        top1=-1;
        top2=MAXSIZE;
        stackElem=new int[MAXSIZE];
    }
    
    //是否是空棧
    public boolean isEmptyStack() {
        if(top1==-1&&top2==MAXSIZE) {
            return true;
        }
        return false;
    }
    
    //清空棧
    public void clearStack() {
        top1=-1;
        top2=MAXSIZE;
    }
    
    //棧的長度
    public int lengthStak() {
        return (top1+1)+(MAXSIZE-top2);
    }
    
    //獲取top1的元素
    public int getTop1Elem() {
        if(top1==-1) {
            return -1;
        }
        return stackElem[top1];
    }
    
    //獲取top2的元素
    public int getTop2Elem() {
        if(top2==MAXSIZE) {
            return -1;
        }
        return stackElem[top2];
    }
    
    //壓棧
    public void stackPush(int stackNumber,int e) {
        //如果棧已經滿了
        if(top1+1==top2) {
            System.out.println("棧已滿");
            return;
        }
        if(stackNumber==1) {
            top1+=1;
            stackElem[top1]=e;
            return;
        }
        if(stackNumber==2) {
            top2-=1;
            stackElem[top2]=e;
            return;
        }
        
    }
    
    //出棧
    public int stackPop(int stackNumber) {
        int rs;
        if(isEmptyStack()) {
            System.out.println("棧為空");
            return -1;
        }
        if(stackNumber==1) {
            rs= stackElem[top1];
            top1--;
        }else if(stackNumber==2) {
            rs=stackElem[top2];
            top2++;
        }else {
            System.out.println("輸入數據有誤");
            return -1;
        }
        return rs;
    }
    
    public void stackTraverse() {
        System.out.println("此時，棧中的元素為：");
        int i=0;
        while(i<=top1) {
            System.out.println(stackElem[i++]+" ");
        }
        i=top2;
        while(i<MAXSIZE) {
            System.out.println(stackElem[i++]+" ");
        }
        System.out.println();
    }
    
    
    public static void main(String[] args) {
        DoubleStatk seqStack=new DoubleStatk();
        
        //1壓棧
        for(int j=1;j<=5;j++) {
            seqStack.stackPush(1,j);
        }
        //2壓棧
        for(int i=MAXSIZE;i>=MAXSIZE-2;i--) {
            seqStack.stackPush(2, i);
        }
        //輸出
        seqStack.stackTraverse();
        System.out.println("棧的長度為："+seqStack.lengthStak());
        
        seqStack.stackPop(2);
        seqStack.stackTraverse();
        System.out.println("棧1的棧頂元素為: " + seqStack.getTop1Elem());
        System.out.println("棧2的棧頂元素為: " + seqStack.getTop2Elem());
        System.out.println("棧的長度為: " + seqStack.lengthStak());
        
        for (int i = 6; i <= MAXSIZE-2; i++) {
            seqStack.stackPush(1,i);
        }
        seqStack.stackTraverse();
        System.out.println("棧1的棧頂元素為: " + seqStack.getTop1Elem());
        System.out.println("棧2的棧頂元素為: " + seqStack.getTop2Elem());
        System.out.println("棧頂元素為: " + seqStack.getTop2Elem());
        System.out.println("棧的長度為: " + seqStack.lengthStak());
        
        System.out.println("棧是否為空: " + seqStack.isEmptyStack());
        seqStack.clearStack();
        System.out.println("棧是否為空: " + seqStack.isEmptyStack());
    }
        

}