算法——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());
    }
        

}