• 数据结构与算法3-栈

    栈

    英文stack
    1)栈是一个先入后出的有序列表
    2)栈是限制线性表中元素的插入和删除只能在线性表的统一端进行的一种特殊线性表。允许插入和删除的一端，为变化的一端，称为栈顶（top），另一端为固定的一端，称为栈底（bottom）
    3)根据栈的定义可知，最先放入栈中的元素在栈底，最后放入的元素在栈顶，而删除元素刚好相反，最后放入的元素最先删除，最先放入的元素最后删除。
    一般的，添加元素称为入栈（push），取出元素称为出栈（pop）。
    link
    栈的应用场景
    1.子程序的调用：在跳往子程序前，会先将下个指令的地址存到堆栈中，直到子程序执行完后再将地址取出，以回到原来的程序中。
    2.处理递归调用：和子程序的调用类似，只是除了储存下一个指令的地址外，也将参数、区域变量等数据存入栈中。
    3.表达式的转换（中缀表达式转后缀表达式）与求值。
    4.二叉树的遍历。
    5.图形的深度优先搜索法。

    数组模拟栈的使用
    在这里插入图片描述
    思路分析：
    1.定义一个top表示栈顶，初始值为-1
    2.入栈：当有数据加入时，top++;stack[top]=newValue;
    3.出栈：当取出栈中数据时，int val=stack[top];top–; return val;

    用数组模拟一个栈，具体代码如下（没有测试代码）：

    class ArrayStack{
    int size;//表示模拟栈的大小
    int top=-1;//表示栈的顶部，初始化为1
    int[] stack;//用数组模拟栈
    //进行栈的初始化
    public ArrayStack(int size){
        this.size = size;
        stack=new int[size];
    }

    //判断栈是否满
    public boolean isFull(){
//        System.out.println(top+"="+size);
        return top==size-1;
    }

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

    //给栈中添加元素（入栈）
    public void push(int num){
        if(isFull()){
            System.out.println("栈已满，不能添加");
            return;
        }
//        top++;
        stack[++top]=num;
    }

    //取出元素（出栈）
    public int pop(){
        if(isEmpty()){
            System.out.println("栈已空");
            return -10000000;
        }
        return stack[top--];
    }

    //遍历栈中的元素（从top开始）
    public void show(){
//        System.out.println("top:"+top);
        if(isEmpty()){
            System.out.println("栈已空");
            return;
        }
        for(int i=top;i>=0;i--){
            System.out.println(i+"-----"+stack[i]);
        }
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52

    栈实现一个综合计算器（中缀表达式）

    定义两个栈，一个数栈，存放数栈，一个符号栈，存放运算符
    思路分析：

    1. 通过一个index值（索引），遍历表达式
    2. 如果发现是数字，就直接入数栈（多位数这里需要加判断）
    3. 如果扫描到一个符号：
      （1）如果当前的符号栈为空，就直接入栈；
      （2）如果当前的符号栈不为空，就进行比较。如果当前的操作符的优先级小于或等于栈顶的操作符，就需要从数栈中pop出两个数，再从符号栈中pop出一个符号，进行运算。将得到的结果放入数栈，然后将当前的操作符放入符号栈。如果当前的操作符的优先级大于栈顶的操作符，就直接放入符号栈。
    4. 当表达式扫描完毕，就顺序的从数栈和符号栈中pop出相应的数和符号，并运行
    5. 最后数栈中只有一个数字时，就是表达式的结果。

    具体代码如下：

    public class Calculator {
    public static void main(String[] args) {
        int index=0;
        int num1=0;//定义第一个数
        int num2=0;//定义第二个数
        int oper;//定义操作符
        int res=0;//结果
        char ch;
        String changNum="";
        boolean loop=true;

        //定义数栈和符号栈
        ArrayStack2 numberStack = new ArrayStack2(10);
        ArrayStack2 operStack = new ArrayStack2(10);
        String str="7*2-12+5*10";

        while (true){
            ch=str.charAt(index);
//            if(ch>=48&&ch<=57){}
            //扫描到是数字，直接入数栈
            if(!numberStack.isOper(ch)){
                changNum+=ch;
                if(index==str.length()-1){
                    //如果是最后一位，直接添加
                    numberStack.push(Integer.parseInt(changNum));
                }else {
                    //不是最后一位的话，判断下一位是符号还是数字
                    //是符号就添加，是数字则继续判断
                    if(numberStack.isOper(str.charAt(index+1))){
                        numberStack.push(Integer.parseInt(changNum));
                        changNum="";
                    }
                }

            }//扫描到是符号，分情况
            else{//如果当前符号栈为空，直接入栈
                if(operStack.isEmpty()){
                    operStack.push(ch);
                }else {
                    //比较优先级
                    if(operStack.priority(ch) <= operStack.priority(operStack.peek())){
                        //如果当前的操作符的优先级小于或等于栈顶的操作符，就需要从数栈中pop出两个数，再从符号栈中pop出一个符号，进行运算
                        //将得到的结果放入数栈，然后将当前的操作符放入符号栈
                        num1=numberStack.pop();
                        num2=numberStack.pop();
                        oper= operStack.pop();
                        res=numberStack.cal(num1,num2,oper);
                        numberStack.push(res);
                        operStack.push(ch);
                    }else {
                        //如果当前的操作符的优先级大于栈顶的操作符，就直接放入符号栈
                        operStack.push(ch);
                    }
                }
            }
            index++;
            if(index==str.length()){
//                System.out.println(str+"="+res);
                break;
            }
        }
        while (true){
            if(operStack.isEmpty()){
                break;
            }
            num1=numberStack.pop();
            num2=numberStack.pop();
            oper= operStack.pop();
            res=numberStack.cal(num1,num2,oper);
            //最后的结果一定要放回栈中
            numberStack.push(res);
        }
        int result=numberStack.pop();
        System.out.println(str+"="+result);
    }
}

class ArrayStack2{
    int size;//表示模拟栈的大小
    int top=-1;//表示栈的顶部，初始化为1
    int[] stack;//用数组模拟栈

    public ArrayStack2(int size){
        this.size = size;
        stack=new int[size];
    }

    //判断栈是否满
    public boolean isFull(){
//        System.out.println(top+"="+size);
        return top==size-1;
    }

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

    //给栈中添加元素（入栈）
    public void push(int num){
        if(isFull()){
            System.out.println("栈已满，不能添加");
            return;
        }
//        top++;
        stack[++top]=num;
    }

    //取出元素（出栈）
    public int pop(){
        if(isEmpty()){
//            System.out.println("栈已空");
            throw new RuntimeException("栈空，没有数据");
        }
        return stack[top--];
    }

    //遍历栈中的元素（从top开始）
    public void show(){
//        System.out.println("top:"+top);
        if(isEmpty()){
            System.out.println("栈已空");
            return;
        }
        for(int i=top;i>=0;i--){
            System.out.println(i+"-----"+stack[i]);
        }
    }
    //看一下栈顶的数据
    public int peek(){
        return stack[top];
    }
    //判断是否是符号
    public boolean isOper(char val){
        return val=='*'||val=='/'||val=='+'||val=='-';
    }
    //定义符号的优先级
    public int priority(int oper){
        if(oper=='*'||oper=='/'){
            return 1;
        }else if(oper=='+'||oper=='-'){
            return 0;
        }else {
            return -1;
        }
    }
    //进行计算
    public int cal(int a,int b,int oper){
        int res=0;
        switch (oper){
            case '*':
                res=a*b;
                break;
            case '/':
                res=b/a;
                break;
            case '+':
                res=a+b;
                break;
            case '-':
                res=b-a;
                break;
            default:
                break;
        }
        return res;
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57
    • 58
    • 59
    • 60
    • 61
    • 62
    • 63
    • 64
    • 65
    • 66
    • 67
    • 68
    • 69
    • 70
    • 71
    • 72
    • 73
    • 74
    • 75
    • 76
    • 77
    • 78
    • 79
    • 80
    • 81
    • 82
    • 83
    • 84
    • 85
    • 86
    • 87
    • 88
    • 89
    • 90
    • 91
    • 92
    • 93
    • 94
    • 95
    • 96
    • 97
    • 98
    • 99
    • 100
    • 101
    • 102
    • 103
    • 104
    • 105
    • 106
    • 107
    • 108
    • 109
    • 110
    • 111
    • 112
    • 113
    • 114
    • 115
    • 116
    • 117
    • 118
    • 119
    • 120
    • 121
    • 122
    • 123
    • 124
    • 125
    • 126
    • 127
    • 128
    • 129
    • 130
    • 131
    • 132
    • 133
    • 134
    • 135
    • 136
    • 137
    • 138
    • 139
    • 140
    • 141
    • 142
    • 143
    • 144
    • 145
    • 146
    • 147
    • 148
    • 149
    • 150
    • 151
    • 152
    • 153
    • 154
    • 155
    • 156
    • 157
    • 158
    • 159
    • 160
    • 161
    • 162
    • 163
    • 164
    • 165
    • 166
    • 167
    • 168
    数据结构与算法分析--C语言描述_数据结构与算法_
    zip 0星 超过10%的资源 38.15MB
    下载

    逆波兰表达式

    （1）输入一个逆波兰表达式（后缀表达式），使用栈（Stack）计算其结果；
    （2）支持小括号和多位数整数，因为这里我们主要讲的是数据结构，因此计算器进行简化，只支持对整数的计算。

    后缀表达式的计算

    从左至右扫描表达式，遇到数字时，将数字压入堆栈，遇到运算符时，弹出栈顶的两个数，用运算符对它们做相应的计算（次顶元素 和 栈顶元素），并将结果入栈；重复上述过程直到表达式最右端，最后运算得出的值即为表达式的结果。

    eg：
    （3+4）*5-6 对应的后缀表达式是3 4 + 5 * 6 -，其计算步骤如下：
    （1）从左至右扫描，将3和4压入堆栈；
    （2）遇到+运算符，因此弹出4和3（4为栈顶元素，3为次顶元素），计算出3+4的值，得7，再将7入栈；
    （3）将5入栈；
    （4）接下来是×运算符，因此弹出5和7，计算出7×5=35，将35入栈；
    （5）将6入栈；
    （6）最后是-运算符，计算出35-6的值，即29，由此得出最终结果。

    中缀表达式转换为后缀表达式

    具体步骤：

    1. 初始化两个栈：运算符栈s1和储存中间结果的栈s2；
    2. 从左至右扫描中缀表达式；
    3. 遇到操作数时，将其压s2；
    4. 遇到运算符时，比较其与s1栈顶运算符的优先级：
      （1）如果s1为空，或栈顶运算符为左括号“(”，则直接将此运算符入栈；
      （2）否则，若优先级比栈顶运算符的高，也将运算符压入s1；
      （3）否则，将s1栈顶的运算符弹出并压入到s2中，再次转到(4-1)与s1中新的栈顶运算符相比较；
    5. 遇到括号时：
      (1) 如果是左括号“(”，则直接压入s1
      (2) 如果是右括号“)”，则依次弹出s1栈顶的运算符，并压入s2，直到遇到左括号为止，此时将这一对括号丢弃
    6. 重复步骤2至5，直到表达式的最右边
    7. 将s1中剩余的运算符依次弹出并压入s2
    8. 依次弹出s2中的元素并输出，结果的逆序即为中缀表达式对应的后缀表达式

    注：栈s2仅仅用来存放中间结果，因为此栈没有出栈操作，故也可以用集合来表示，并且得到最终结果时，集合不用翻转
    具体代码如下：

    public class MidTransferSuffix {
    public static void main(String[] args) {
        //1.将中缀表达式放入集合中，即将“1+((2+3)*4)-5”转换为[1,+,(,(,2,+,3,),*,4,),-,5]的格式
        //2.将得到的中缀表达式对应的list转化为后缀表达式对应的list
        String str = "1+((2+3)*4)-5";
        List infixList = getList(str);
        System.out.println(infixList);
        List suffixList=getSuffixList(infixList);
        System.out.println(suffixList);
    }

    //将表达式字符串放置到集合中
    public static List getList(String string) {
        char ch;//存的是遍历到的元素
        String s = "";//放置多位数字
        List list = new ArrayList();//中缀表达式对应的list
        for (int i = 0; i < string.length(); i++) {
            ch = string.charAt(i);
            if (ch < 48 || ch > 57) {//遇到的是符号，直接加入
                list.add(ch + "");
            } else {//遇到的是数字，可能是多位数，也可能是单位数
                s += ch;
                if (i == string.length() - 1) {//遍历到最后一位，直接添加
                    list.add(s);
                } else if (string.charAt(i + 1) < 48 || string.charAt(i + 1) > 57) {//遍历到中间，如果下一位是符号，就添加
                    list.add(s);
                    s = "";
                }
            }
        }
        return list;
    }

    //将中缀表达式集合转化成后缀表达式集合
    //即将[1,+,(,(,2,+,3,),*,4,),-,5]转换成[1,2,3,+,4,*,+,5,-]
    public static List getSuffixList(List<String> list) {
        Stack<String> s1 = new Stack();//用来存放运算符
        List<String> s2 = new ArrayList();//用来存放中间结果，因为此栈没有出栈操作，故也可以用集合来表示，并且得到最终结果时，集合不用翻转
        for (String item : list) {
            if (item.matches("\\d+")) {//匹配的是数字//(2)遇到操作数时，将其压s2
                s2.add(item);
            } else if (item.equals("(")) {//如果是左括号“(”，则直接压入s1
                s1.push(item);
            } else if (item.equals(")")) {//如果是右括号“)”，则依次弹出s1栈顶的运算符，并压入s2，直到遇到左括号为止，此时将这一对括号丢弃
//                System.out.println(s1);
                while (!s1.peek().equals("(")) {
                    s2.add(s1.pop());
                }
                s1.pop();//丢弃“(”
            } else {//遇到了操作符
//                b loop=tr
                while (true){
                    if (s1.size() == 0) {//如果s1为空，则直接将此运算符入栈；
                        s1.push(item);
                        break;
                    } else if (getPriority(item) > getPriority(s1.peek())) {//若优先级比栈顶运算符的高，也将运算符压入s1；
                        s1.push(item);
                        break;
                    }else {//否则，将s1栈顶的运算符弹出并压入到s2中，再次转到(4-1)与s1中新的栈顶运算符相比较；
                        s2.add(s1.pop());
                    }
                }

            }
        }
        while (s1.size()>0){
            s2.add(s1.pop());//将s1中剩余的运算符依次弹出并压入s2
        }
        return s2;
    }

    //定义一个获取运算符优先级的方法
    public static int getPriority(String s) {
        int p = -1;
        switch (s) {
            case "+":
                p = 0;
                break;
            case "-":
                p = 0;
                break;
            case "*":
                p = 1;
                break;
            case "/":
                p = 1;
                break;
            default:
                break;
        }
        return p;
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57
    • 58
    • 59
    • 60
    • 61
    • 62
    • 63
    • 64
    • 65
    • 66
    • 67
    • 68
    • 69
    • 70
    • 71
    • 72
    • 73
    • 74
    • 75
    • 76
    • 77
    • 78
    • 79
    • 80
    • 81
    • 82
    • 83
    • 84
    • 85
    • 86
    • 87
    • 88
    • 89
    • 90
    • 91
    • 92
    • 93
  • 相关阅读:
    MySQL零基础从入门到精通（函数篇）
    MySQL和SQLserver中group by的区别
    2.Java泛型指南-泛型擦除、泛型表达式、类型边界、通配符、无限制通配符、上界通配符下界通配符、泛型作用域、类型上限、?类型泛型、构造函数泛型，泛型使用规则
    XSS-labs靶场实战（三）——第7-8关
    基于有限时间干扰观测器的多智能体系统的协同控制
    Docker搭建Plex流媒体服务并播放自己本地视频
    2304: 【递推】铺瓷砖
    读高性能MySQL（第4版）笔记20_Performance Schema和其他
    Vue History模式的Nginx配置
    【CSS】一文搞懂 em、px、rem、vh、vw 的区别！
  • 原文地址：https://blog.csdn.net/qq_45142938/article/details/126141184