数据结构Java实现--栈

目录

[1]栈的定义

栈是一种只能在一端进行插入或删除的线性表。表中允许进行插入、删除操作的一端称为栈顶，表的另一端称为栈底，当栈中没有元素时称为空栈，栈的插入操作通常称为进栈或入栈，栈的删除操作通常称为出栈或退栈。
栈的主要特点是后进先出，即后进栈的元素先出栈，每次进栈的数据元素都放在原来栈顶元素之前成为新的栈顶元素，每次出栈的数据元素都是当前栈顶元素。栈也称为后进先出表。
注意：n个不同的元素通过一个栈产生的出战序列的个数为1/(n+1)Cn2n
下面对于栈的基本运算做出java的实现

[2] 栈的实现

• 栈的顺序存储结构及其基本运算实现：
  取一变量作为栈顶指针：top
  栈空的条件：top==-1。
  栈满的条件：top==size-1。
  元素进栈操作：top++，将元素放入top位置。
  出栈操作：先将栈顶指针top处的元素取出，将top- -

package club.leyvan.list.stack;

/**
 * @Auther: http://www.leyvan.club
 * @Date: 2019/9/7
 * @Description: club.leyvan.list.stack
 * @version: 1.0
 */
public class SqStack {
    private int top = -1;
    private int size = 0;
    private int capacity;
    private Object[] stack;

    /**
     * 功能描述：无参构造方法
     * @auther: muzile
     * @date:  2019/9/7
     */
    public SqStack(){
        stack = new Object[16];
        capacity = 16;
    }

    /**
     * 功能描述：可初始化栈容量的构造方法
     * @param: 栈容量
     * @auther: muzile
     * @date:  2019/9/7
     */
    public SqStack(int capacity){
        stack = new Object[capacity];
        this.capacity = capacity;
    }

    /**
     * 功能描述：判空
     * @return: boolean
     * @auther: muzile
     * @date:  2019/9/7
     */
    public boolean isEmpty() {
        return top==-1;
    }

    /**
     * 功能描述：压栈
     * @param: 压栈的值
     * @return: 是否成功
     * @auther: muzile
     * @date:  2019/9/7
     */
    public boolean push(Object val) {
        if(top>=size){
            return false;
        }
        stack[++top] = val;
        size++;
        return true;
    }

    /**
     * 功能描述：出栈
     * @param: none
     * @return: 出栈元素
     * @auther: muzile
     * @date: 2019/9/7
     */
    public Object pop(){
        Object obj = null;
        if(top==-1) {
            return obj;
        }
        obj = stack[top];
        top--;
        size--;
        return obj;
    }

    /**
     * 功能描述：获得栈顶元素
     * @return: 返回栈顶元素
     * @auther: muzile
     * @date:  2019/9/7
     */
    public Object getTop() {
        Object obj = null;
        if(top==-1){
            return obj;
        }
        obj = stack[top];
        return obj;
    }

    /**
     * toString方法
     * @return
     */
    public String toString(){
        String retVal = "[";
        for(int i = 0;i < size-1;i++){
            retVal+=stack[i]+",";
        }
        retVal+=stack[size-1]+"]";
        return retVal;
    }

    /**
     * 测试
     * @param args
     */
    public static void main(String[] args) {
        SqStack stack = new SqStack();
        System.out.println(stack.isEmpty());
        for(int i = 0 ; i < 16 ; i++){
            stack.push(i);
        }
        System.out.println(stack);
        System.out.println(stack.pop());
        System.out.println(stack.isEmpty());
        System.out.println(stack.getTop());
    }

}

结果：

true
[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15]
15
false
14

• 共享栈： 解决"开辟两个相同类型的栈，第一个栈满了，再进栈就溢出，而另一个栈还有很多空闲空间"
  解决方法：在设计共享栈时，由于一个数组有两个端点，两个栈有两个栈底，让一个栈的栈底为数组的起始，另一个栈的栈底为数组的末端。在两个栈中进栈时，栈顶向中间伸展。
  共享栈的4个要素：
  栈空条件：栈1空为top1 == -1；栈2空位top2 == MaxSize
  栈满条件：top1==top2-1
  元素x进栈操作：进栈1，top1++；data[top1]=x；进栈2操作为top2- -；data2[top2]=x
  出栈x操作：出栈1操作：x=data[top1];top1- -；出栈2操作 x=data[top2];top2++

• 栈的链式存储结构及基本运算的实现:
  采用链式存储结构的栈称为链栈，链栈的优点是不存在栈满上溢出的情况。
  链栈的4个要素：
  栈空条件： top.getNext()==null
  栈满条件：内存溢出
  进栈操作：新建一个节点存放元素，采用首插法插入到头节点之后
  出栈操作：去除首结点的data值并将其删除
  Node类：

package club.leyvan.list.stack;

/**
 * @Auther: http://www.leyvan.club
 * @Date: 2019/9/7
 * @Description: club.leyvan.list.stack
 * @version: 1.0
 */
public class Node {
    private Object data;
    private Node next;

    public Object getData() {
        return data;
    }

    public void setData(Object data) {
        this.data = data;
    }

    public Node getNext() {
        return next;
    }

    public void setNext(Node next) {
        this.next = next;
    }
}

链栈类：

package club.leyvan.list.stack;
/**
 * @Auther: http://www.leyvan.club
 * @Date: 2019/9/7
 * @Description: club.leyvan.list.stack
 * @version: 1.0
 */
public class LinkedStack {
    private Node top;
    public LinkedStack(){
        top = new Node();
    }

    public boolean isEmpty(){
        return top.getNext()==null;
    }

    public void push(Object obj){
        Node node = new Node();
        node.setData(obj);
        node.setNext(top.getNext());
        top.setNext(node);
    }

    public Object pop(){
        Node node;
        if(top.getNext()==null){
            return null;
        }
        node = top.getNext();
        top.setNext(node.getNext());
        return node.getData();
    }

    public Object getTop(){
        if(top.getNext()==null){
            return null;
        }
        return top.getNext().getData();
    }

    public String toString(){
        String retVal = "[";
        Node p = top.getNext();
        while(p!=null){
            if(p.getNext()!=null){
                retVal += p.getData()+",";
            }else{
                retVal += p.getData()+"";
            }
            p = p.getNext();
        }
        return retVal+"]";
    }
    
    public static void main(String[] args) {
        LinkedStack stack = new LinkedStack();
        System.out.println(stack.isEmpty());
        for(int i = 0 ; i < 16 ; i++){
            stack.push(i);
        }
        System.out.println(stack);
        System.out.println(stack.pop());
        System.out.println(stack.isEmpty());
        System.out.println(stack.getTop());
    }
}

结果：

true
[15,14,13,12,11,10,9,8,7,6,5,4,3,2,1,0]
15
false
14

[3] 栈的应用

简单表达式的求值：

这里限定的简单表达式求值问题是用户输入一个包含+、-、、/、正整数和圆括号的合法算术表达式，计算该表达式的运算结果。
中缀表达式： 运算符位于两个操作数之间的表达式称为中缀表达式，例如1+23就是一个中缀表达式。
后缀表达式(逆波兰表达式)： 就是在算术表达式中运算符在操作数的后面，入1+23的后缀表达式为 1 2 3 * +。在后缀表达式中已经考虑了运算符的优先级，没有括号，只有操作数和运算符，而且越放在前面的运算符优先级越高。
前缀表达式： 运算符在操作数的前面，称为前缀表达式，如1+23的前缀表达式为+ 1 * 2 3。
由于后缀表达式比较常用，主要描述如何将算术表达式转换成后缀表达式。
算法描述： 算术表达式exp=“2*(1+3)-4”，转换过程是将操作数2存入postexp；遇到’*’，将其进栈；遇到’(’,将其进栈；将操作数1存入postexp；遇到’)’，出栈‘+‘并存入postexp，出栈’(’；遇到‘-’，出栈‘ * '并存入postexp，将‘-’进栈；将操作数4存入postexp；扫描完毕出栈‘-’并存入postexp。数与数之间用#隔开
代码实现：

	public static String tans(String exps) {
        LinkedStack stack = new LinkedStack();
        char[] exp = exps.toCharArray();
        char[] postexp = new char[2*exp.length];
        int i = 0;
        char c;
        for(int j = 0 ;j < exp.length;){
            switch (exp[j]){
                case '(':
                    stack.push(exp[j]);
                    j++;
                    break;
                case ')':
                    c = (char)stack.pop();
//                  若c不为(继续出栈，不需考虑栈中运算符的优先级顺序，栈中的优先级顺序由+、-、*、/判断
//                  操作的是栈内的运算符，当到）时，+、-、*、/这些运算符都已经排好顺序。
                    while(c!='('){
                        postexp[i++] = c;
                        c = (char)stack.pop();
                    }
                    j++;
                    break;
                case '+':
                case '-':
                    //+、-优先级最低所以永远先出栈再将自己进栈
                    //遇到任何运算符都比自己的优先级高
                    while(!stack.isEmpty()){
                        c = (char)stack.getTop();
                        if(c!='('){
                            postexp[i++] = c;
                            stack.pop();
                        }else
                            break;
                    }
                    stack.push(exp[j]);
                    j++;
                    break;
                case '*':
                case '/':
                    while(!stack.isEmpty()){
                        c = (char)stack.getTop();
//                      判断优先级：如果栈中有大于等于*、/优先级的运算符，先让在ch之前的运算符出栈，再将自身进栈
                        if(c=='*'||c=='/'){
                            postexp[i++] = c;
                            stack.pop();
                        }else
                            break;
                    }
                    stack.push(exp[j]);
                    j++;
                    break;
                default:
                    //处理连续的数字
                    while(j<exp.length&&exp[j]>='0'&&exp[j]<='9'){
                        postexp[i++] = exp[j];
                        j++;
                    }
                    postexp[i++] = '#';
            }
        }
        //exp扫描完出栈所有栈内符号
        while(!stack.isEmpty()){
            c = (char)stack.pop();
            postexp[i++] = c;
        }
        return new String(postexp);
    }
    /**
     * 功能描述：处理排好序的后缀表达式，算值
     * @param: 后缀表达式
     * @return: 返回表达式的结果
     * @auther: muzile
     * @date:  2019/9/7
     */
    public static double compute(String postexp){
        double a,b,c,d;
        LinkedStack stack = new LinkedStack();
        char[] exp = postexp.toCharArray();
        for(int i = 0;i<exp.length;){
            switch (exp[i]){
                case '+':
                    a = (double)stack.pop();
                    b = (double)stack.pop();
                    c = b + a;
                    stack.push(c);
                    break;
                case '-':
                    a = (double)stack.pop();
                    b = (double)stack.pop();
                    c = b - a;
                    stack.push(c);
                    break;
                case '*':
                    a = (double)stack.pop();
                    b = (double)stack.pop();
                    c = b * a;
                    stack.push(c);
                    break;
                case '/':
                    a = (double)stack.pop();
                    b = (double)stack.pop();
                    if(a!=0){
                        c = b / a;
                        stack.push(c);
                    }
                    break;
                default:
                    d = 0;
                    boolean flag = false;
                    while(exp[i]>='0'&&exp[i]<='9'){
                        d = 10*d + exp[i]-'0';
                        i++;
                        flag = true;
                    }
                    //未修改的数据不可入站
                    if(flag){
                        stack.push(d);
                    }
                    break;
            }
            i++;
        }
        return (double)stack.getTop();
    }

    public static void main(String[] args) {
        String exps = "25*(12+31)-4";
        String exp = LinkedStack.tans(exps);
        System.out.println("算术表达式："+exps);
        System.out.println("后缀表达式："+exp);
        System.out.println(LinkedStack.compute(exp));

    }

结果：

算术表达式：25*(12+31)-4
后缀表达式：25#12#31#+*4#-          
1071.0