[ 数据结构与算法 ] 栈: 中缀表达式

栈

栈的一个实际需求:将字符串对应的表达式(中缀表达式)运算得到结果

介绍

1. 栈的英文为(stack)
2. 栈是一个 先入后出(FILO-First In Last Out) 的有序列表。
3. 栈(stack) 是限制线性表中元素的插入和删除只能在线性表的同一端进行的一种特殊线性表。 。 允许插入和删除的一端，为 变化的一端，称为栈顶(Top) ，另一端为 固定的一端，称为栈底(Bottom) 。
4. 根据栈的定义可知 ， 最先放入栈中元素在栈底 ， 最后放入的元素在栈顶 ， 而删除元素刚好相反 ， 最后放入的元
   素最先删除，最先放入的元素最后删除
5. 图解方式说明出栈(pop) 和入栈(push)

应用场景

1. 子程序的调用：在跳往子程序前，会先将下个指令的地址存到堆栈中，直到子程序执行完后再将地址取出，以
   回到原来的程序中。
2. 处理递归调用：和子程序的调用类似，只是除了储存下一个指令的地址外，也将参数、区域变量等数据存入堆
   栈中。
3. 表达式的转换[中缀表达式转后缀表达式]与求值(实际解决)。
4. 二叉树的遍历。
5. 图形的深度优先(depth 一 first)搜索法。

数组模拟栈

public class ArrayStackDemo {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println();
        String key = "";
        boolean loop = true;
        ArrayStack stack = new ArrayStack(4);
        while (loop) {
            System.out.println("show:显示栈");
            System.out.println("push:压栈");
            System.out.println("pop:出栈");
            System.out.println("exit:退出程序");
            System.out.println("请输入你的选择:");
            key = sc.next();
            switch (key) {
                case "show":
                    stack.list();
                    break;
                case "push":
                    System.out.println("请输入压栈的数字:");
                    int value = sc.nextInt();
                    stack.push(value);
                    break;
                case "pop":
                    try {
                        System.out.println("出栈数字为:"+stack.pop());
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                    break;
                case "exit":
                    loop = false;
                    break;
                default:
                    System.out.println("你会不会啊~");
                    break;
            }
        }
    }

}

class ArrayStack {
    private int maxSize;
    private int top=-1;
    private int[] array;

    public ArrayStack(int maxSize) {
        this.maxSize = maxSize;
        array = new int[maxSize];
    }

    public void push(int num) {
        if (isFull()) {
            System.out.println("栈满");
            return;
        }
        top++;
        array[top] = num;
    }

    public int pop() {
        if (isEmpty()) {
            throw new RuntimeException("栈空");
        }
        int num = array[top];
        top--;
        return num;
    }

    public void list() {
        if (isEmpty()) {
            System.out.println("栈空");
            return;
        }
        for (int i = top; i >=0 ; i--) {
            System.out.println(array[i]);
        }
    }

    public boolean isEmpty() {
        return top == -1;
    }

    public boolean isFull() {
        return top == maxSize - 1;
    }

}

应用:中缀表达式

使用模拟栈来实现综合计算器:

思路分析(图解)

关键点提示:

• 运算符入符号栈时,通过和栈顶的运算优先级对比,相应做出不同动作

• 先完成一位数的运算(长度为1的数字字符),一位数可以直接入栈

• 再扩展到多位数的运算(长度大于1的字符串) :

  将下一位为非运算符的字符反复追加到上一个字符后,即可完成一个多位数的入栈

思考:

如果中缀表达式里有括号,怎么办?(后缀表达式)

代码实现

//使用模拟栈计算中缀表达式
public class Calculater {
    public static void main(String[] args) {
        Stack operas = new Stack(10);//数字栈:存放数字的解析后的值
        Stack nums = new Stack(10);//运算符栈:存放运算符对应 ascll码值
        String cal = "";//接收输入的表达式字符串
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入表达式:");
        cal = scanner.next();

        int index = 0;//用于遍历表达式字符串的索引
        char ch;//指向扫描到的字符
        String keepNum="";//指向多位的数字
        int num1;//用于计算准备的变量
        int num2;
        int opera;
        while (true) {
            if (index>=cal.length()) {//扫描完毕退出循环
                break;
            }
            ch = cal.charAt(index);//扫描到的字符
            index++;//迭代
            if (isOpera(ch)) {//字符为运算符
                if (operas.isEmpty()) {//运算符栈空
                    operas.push(ch);//第一个运算符压入空栈
                }else {
                    //判断待入栈的运算符优先级是否小于或等于栈顶的运算符
                    //满足<=,数字栈取出两个数字,运算符栈取出一个运算符,将计算结果存入数字栈
                    //新的运算符入栈
                    if (priority(ch) <= priority(operas.peek())) {
                        num1 = nums.pop();
                        num2 = nums.pop();
                        opera = operas.pop();
                        nums.push(calcu(num1, num2, opera));
                    }
                    operas.push(ch);//优先级高于栈顶的元素
                }
            }else {//字符为数字

                keepNum+=ch;//追加字符
                //判断索引越界或者下一个字符是运算符
                //-->将字符串解析成数字压栈
                //-->重置字符串
                if (index==cal.length()||isOpera(cal.charAt(index))) {
                    nums.push(Integer.parseInt(keepNum));
                    keepNum = "";
                }
            }
        }
        //以上程序结束表示遍历并入栈完毕
        //循环取出一组元素运算并将结果放入数字栈
        //当运算符栈为空表示运算完毕
        while (true) {
            if (operas.isEmpty()) {
                System.out.println("运算结果为:"+nums.pop());
                break;
            }
            num1 = nums.pop();
            num2 = nums.pop();
            opera = operas.pop();
            nums.push(calcu(num1, num2, opera));
        }

    }

    //判断是否运算符
    public static boolean isOpera(char ch) {
        return ch == '+' || ch == '-' || ch == '*' || ch == '/';
    }

    //计算两个数间的运算结果
    public static int calcu(int num1,int num2,int opera) {
        int result = 0;
        switch (opera) {
            case '+':
                result = num2 + num1;
                break;
            case '-':
                result = num2 - num1;
                break;
            case '*':
                result = num2 * num1;
                break;
            case '/':
                result = num2 / num1;
                break;
        }
        return result;
    }

    //返回操作符的优先级
    public static int priority(int opera) {
        if (opera == '*' || opera == '/') {
            return 1;
        }else if (opera == '+' || opera == '-') {
            return 0;
        }
        return -1;
    }
}
class Stack {
    private int maxSize;
    private int top=-1;
    private int[] array;

    public Stack(int maxSize) {
        this.maxSize = maxSize;
        array = new int[maxSize];
    }

    //入栈
    public void push(int num) {
        if (isFull()) {
            System.out.println("栈满");
            return;
        }
        top++;
        array[top] = num;
    }

    //检查栈顶元素
    public int peek() {
        return array[top];
    }

    //出栈
    public int pop() {
        if (isEmpty()) {
            throw new RuntimeException("栈空");
        }
        int num = array[top];
        top--;
        return num;
    }

    //从栈顶往栈底遍历
    public void list() {
        if (isEmpty()) {
            System.out.println("栈空");
            return;
        }
        for (int i = top; i >=0 ; i--) {
            System.out.println(array[i]);
        }
    }

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

    //栈满
    public boolean isFull() {
        return top == maxSize - 1;
    }

}