栈

一、栈的概述

1.1 什么是栈

栈的英文为(stack) ，栈是一个先入后出(FILO-First In Last Out)的有序列表。 栈(stack)是限制线性表中元素的插入和删除只能在线性表的同一端进行的一种特殊线性表。

1.2 出栈（pop）和入栈（push）的理解

允许插入和删除的一端，为变化的一端，称为栈顶(Top)，另一端为固定的一端，称为栈底(Bottom)。

最先放入栈中元素在栈底，最后放入的元素在栈顶，而删除元素刚好相反，最后放入的元素最先删除，最先放入的元素最后删除。

1.3 栈的应用

1.3.1 子程序的调用：

在跳往子程序前，会先将下个指令的地址存到堆栈中，直到子程序执行完后再将地址取出，以回到原来的程序中。

1.3.2 处理递归调用：

和子程序的调用类似，只是除了储存下一个指令的地址外，也将参数、区域变量等数据存入堆栈中。

1.3.3 表达式的转换：

[中缀表达式转后缀表达式]与求值(实际解决)。

1.3.4 二叉树的遍历

1.3.5 图形的深度优先(depth一first)搜索法

二、数组模拟栈

使用数组的结构来储存栈的数据内容

思路：

1. 定义一个top，值为-1
2. 入栈的操作：当有数据加入到栈top++，stack [ top ] = data
3. 出栈的操作：int value = stack[top]; top–; return value;

代码实现：

package stack;

public class Calculator {
    public static void main(String[] args) {
        String exp = "30+2*6-2";
        CalStack NumStack = new CalStack(10);
        CalStack OperStack = new CalStack(10);
        int index = 0;//用于扫描
        int num1;
        int num2;
        int oper;
        int res;
        char ch;//将每次扫描到的char保存到ch
        String keepNum = "";//拼接多位数
        while(true){
            //遍历表达式
            ch = exp.substring(index,index + 1).charAt(0);
            //判断ch是字符还是数字
            if(NumStack.isOper(ch)){//如果是运算符
                //判断当前符号栈是不是为空栈
                if(!OperStack.isEmpty()){//不是空栈，处理
                    //当符号栈有操作符时，且当前操作符的优先级小于或者等于栈中的操作符的优先级
                    if(OperStack.priority(ch) <= OperStack.priority(OperStack.peek())){
                        num1 = NumStack.pop();
                        num2 = NumStack.pop();
                        oper = OperStack.pop();
                        res = NumStack.cal(num1,num2,oper);
                        NumStack.push(res);
                        OperStack.push(ch);
                    }else{//当前操作符优先级大于栈中的操作符优先级
                        OperStack.push(ch);
                    }
                }else{//是空栈，就压入
                    OperStack.push(ch);
                }
            }else{//如果是数字，则直接入数栈
                //如果是多位数,应该向exp的后一位多看一位，判断
                // 如果后一位是运算符才直接入数栈

                //处理多位数
                keepNum += ch;
                //判断ch是不是最后一位
                if(index == exp.length() - 1){
                    NumStack.push(Integer.parseInt(keepNum));
                }else{
                    //判断下一位是否是数字
                    if(OperStack.isOper(exp.substring(index + 1,index + 2).charAt(0))){//如果是数字就继续扫描，如果是运算符就入栈
                        NumStack.push(Integer.parseInt(keepNum));
                        //清空keepnum
                        keepNum = "";
                    }
                }

            }
            //让index + 1，判断是否扫描到exp的最后
            index++;
            if(index >= exp.length()){
                break;
            }
        }
        while(true){
            //如果符号栈为空，则计算结果到最后，且数栈中只有一个结果
            if(OperStack.isEmpty()){
                break;
            }
            num1 = NumStack.pop();
            num2 = NumStack.pop();
            oper = OperStack.pop();
            res = NumStack.cal(num1,num2,oper);
            NumStack.push(res);
        }
        System.out.println(exp + "的结果是" + NumStack.pop());
    }
}

//表示栈结构
class CalStack{
    int maxSize;//栈的大小
    int[] stack;//数组，数组模拟栈
    int top = -1;

    //构造器
    public CalStack(int maxSize) {
        this.maxSize = maxSize;
        stack = new int[this.maxSize];
    }

    //返回栈顶的值
    public int peek(){
        return stack[top];
    }
    //栈满
    public boolean isFull(){

        return top == maxSize - 1;
    }
    //栈空
    public boolean isEmpty(){

        return top == -1;
    }
    //入栈
    public void push(int value){
        if(isFull()){
            throw new RuntimeException("栈满，无法再加入");
        }else{
            top++;
            stack[top] = value;
        }
    }
    //出栈
    public int pop(){
        if(isEmpty()){
            throw new RuntimeException("栈空，没有数据");
        }else{
            int value = stack[top];
            top--;
            return value;
        }
    }

    //遍历,从栈顶开始显示
    public void list(){
        if(isEmpty()){
            System.out.println("没有数据");
        }
        for(int i = top;i >= 0;i--){
            System.out.println("stack[" + i + "] =" + stack[i]);
        }
    }

    //判断运算符的优先级
    public int priority(int oper){
        if(oper == '*'||oper == '/'){
            return 1;
        }
        else if(oper == '+'||oper == '-'){
            return 0;
        }else{
            return -1;
        }
    }
    //判断是不是一个运算符
    public boolean isOper(char val){
        return val == '+' || val =='-' || val =='*' || val == '/';
    }
    //计算方法
    public int cal(int num1,int num2,int oper){
        int res = 0;//用于存放计算结果
        switch (oper){
            case '+':
                res = num1 + num2;
                break;
            case '-':
                res = num2 - num1;
                break;
            case '*':
                res = num1*num2;
                break;
            case '/':
                res = num2 / num1;
                break;
            default:
                break;
        }
        return res;
    }
}

运行结果：