数据结构与算法 ------ 打卡第四天 栈

最新推荐文章于 2021-03-13 06:29:27 发布
最新推荐文章于 2021-03-13 06:29:27 发布
阅读量325 收藏
点赞数
分类专栏： 数据结构与算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41547882/article/details/111563122
版权

1. 栈 stack

1.1 介绍

栈：是一个 先入后出 (FILO-First In Last Out)的 有序列表。

栈是一种 只能在线性表的同一端进行 元素的插入和删除的 特殊线性表。

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

栈的应用场景：

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

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

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

  4. 二叉树的遍历。

  5. 图形的深度优先(depth一first)搜索法。

1.2 栈的操作

  • 入栈：把新元素放入栈中， 只允许从栈顶一侧放入元素， 新元素的位置将会成为新的栈顶。

  • 出栈：把元素从栈中弹出， 只有栈顶元素才允许出栈， 出栈元素的前一个元素将会成为新的栈顶。

注意：入栈和出栈只会影响到最后一个元素， 不涉及其他元素的整体移动， 所以无论是以数组还是以链表实现， 入栈、 出栈的时间复杂度都是O(1)。

出栈（pop) 和 入栈（push）的图解：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-mJqda98F-1608630317907)(数据结构与算法img/出栈和入栈.png)]

1.2.1 数据模拟栈

思路分析：

  1. 定义一个 top 来表示栈顶，初始化 为 -1；
  2. 入栈的操作，当有数据加入到栈时， top++; stack[top] = data;
  3. 出栈的操作， int value = stack[top]; top–, return value;

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-h0tjgd4u-1608630317913)(数据结构与算法img/数组模拟栈.png)

通俗一点的图解：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-T7QYUCmL-1608630317915)(数据结构与算法img/数组模拟栈1.png)]

具体代码：

import java.util.Scanner;

public class ArrayStackDemo {
    public static void main(String[] args) {
        // 先创建一个ArrayStack对象 表示栈
        ArrayStack stack=new ArrayStack(4);
        String key="";
        boolean loop=true;   //控制是否退出菜单
        Scanner scanner=new Scanner(System.in);

        while (loop){
            System.out.println();
            System.out.println("--------------------------------------------------------------------------");
            System.out.println("show：表示显示栈");
            System.out.println("exit：退出程序");
            System.out.println("push：表示添加数据到栈（入栈）");
            System.out.println("pop：表示从栈取出数据（出栈）");
            System.out.println("--------------------------------------------------------------------------");
            System.out.println("请输入你的选择：");

            key=scanner.next();
            switch (key){
                case "show":
                    stack.list();
                    break;
                case "push":
                    System.out.println();
                    System.out.println("请输入一个数：");
                    int value=scanner.nextInt();
                    stack.push(value);
                    break;
                case "pop":
                    try{
                        int res=stack.pop();
                        System.out.println();
                        System.out.println("出栈的数据是"+res);
                    }catch (Exception e){
                        System.out.println(e.getMessage());
                    }
                    break;
                case "exit":
                    scanner.close();
                    loop=false;
                    break;
                default:
                    break;
            }
        }
        System.out.println();
        System.out.println("程序退出了~~~");
    }
}


// 定义一个 ArrayStack 表示栈
class ArrayStack{
    private int maxSize;  // 栈的大小
    private  int[] stack;   // 数组，数组模拟栈，数据放在该数组中
    private int top = -1;  // top 表示栈顶，初始化为 -1

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

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

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

    //  入栈
    public void push(int value){
        // 先判断栈是否满
        if(isFull()){
            System.out.println();
            System.out.println("栈满了~~");
            return;
        }
        top++;
        stack[top]=value;
    }

    // 出栈 - pop，将栈顶的数据返回
    public int pop(){
        // 先判断栈是否空
        if(isEmpty()){
            // 抛出异常
            System.out.println();
            throw new RuntimeException("栈空，没有数据~~");
        }
        int value=stack[top];
        top--;
        return value;
    }

    ///  遍历栈，遍历时需要从栈顶开始显示数据
    public void list(){
        //  判断栈是否为空
        if(isEmpty()){
            System.out.println();
            System.out.println("栈空，没有数据~~");
            return;
        }
        // 需要从栈顶开始显示数据
        for(int i=top;i>=0;i--){
            System.out.println("stack["+i+"] = "+stack[i]);
        }
    }
}
1.2.2. 链表模拟栈

思路分析：

  1. 定义一个 头节点head 来表示栈顶，初始化 为 -1；
  2. 入栈的操作，对链表采用头插法， 要判断该是否为空：为空，则 head.next=new LinkList(value); 否则 LinkList newStack=new LinkList(value); newStack.next=head.next; head.next=newStack;
  3. 出栈的操作，int value=head.next.data; head.next=head.next.next;

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-sphHpw2O-1608630317919)(数据结构与算法img/链表模拟栈.png)]

具体代码：

package roselin.stack;

import java.util.Scanner;

public class LinkStackDemo {
    public static void main(String[] args) {
        // 先创建一个LinkStack对象 表示栈
        LinkStack stack=new LinkStack();
        String key="";
        boolean loop=true;   //控制是否退出菜单
        Scanner scanner=new Scanner(System.in);

        while (loop){
            System.out.println();
            System.out.println("--------------------------------------------------------------------------");
            System.out.println("show：表示显示栈");
            System.out.println("exit：退出程序");
            System.out.println("push：表示添加数据到栈（入栈）");
            System.out.println("pop：表示从栈取出数据（出栈）");
            System.out.println("--------------------------------------------------------------------------");
            System.out.println("请输入你的选择：");

            key=scanner.next();
            switch (key){
                case "show":
                    stack.list();
                    break;
                case "push":
                    System.out.println();
                    System.out.println("请输入一个数：");
                    int value=scanner.nextInt();
                    stack.push(value);
                    break;
                case "pop":
                    try{
                        int res=stack.pop();
                        System.out.println();
                        System.out.println("出栈的数据是"+res);
                    }catch (Exception e){
                        System.out.println(e.getMessage());
                    }
                    break;
                case "exit":
                    scanner.close();
                    loop=false;
                    break;
                default:
                    break;
            }
        }
        System.out.println();
        System.out.println("程序退出了~~~");
    }
}


// 定义一个 LinkStack 表示栈
class LinkStack{
    //  先初始化一个头结点，头结点，不存放具体的数据
    private LinkList head=new LinkList(-1);   //表示栈顶，初始化为 -1

    // 栈空
    public boolean isEmpty(){
        return head.next==null;
    }

    //  入栈   链表模拟栈，根据栈的特点：先进后出，故这里链表采用 头插法 进行入栈操作
    public void push(int value){
        // 先判断栈是否满
        if(isEmpty()){   //  栈为空，则直接在其后面添加数据（入栈）
            head.next=new LinkList(value);
        }else{   //  否则，链表的最前端插入数据
            LinkList newStack=new LinkList(value);
            newStack.next=head.next;
            head.next=newStack;
        }
    }

    // 出栈 - pop，将栈顶的数据返回
    public int pop(){
        // 先判断栈是否空
        if(isEmpty()){
            // 抛出异常
            System.out.println();
            throw new RuntimeException("栈空，没有数据~~");
        }
        int value=head.next.data;
        head.next=head.next.next;
        return value;
    }

    ///  遍历栈，遍历时需要从栈顶开始显示数据
    public void list(){
        //  判断栈是否为空
        if(isEmpty()){
            System.out.println();
            System.out.println("栈空，没有数据~~");
            return;
        }
        // 需要从栈顶开始显示数据
        LinkList cur =head.next;
        int i=0;
       while (cur!=null){
           System.out.println("stack["+i+"] = "+cur.data);
           i++;
           cur=cur.next;
       }
    }
    
    // 节点
    class LinkList{
        private int data;    //  栈值
        private LinkList next;   // 指向下一个栈节点

        //  构造器
        public LinkList(int data){
            this.data=data;
        }
    }
}

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

  • 效果：

    请输入一个表达式
计算式： [7*2*2-5+1-5+3-3]  点击计算

  • 思路分析（图解）

    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-exxoDrmm-1608630317920)(数据结构与算法img/栈实现综合计算器1.png)]

  • 具体代码：

    public class Calculator {
    public static void main(String[] args) {
        String expression = "10+2*6-2";
        //  创建两个栈，数值栈 和 符号栈
        ArrayStack1 numStack = new ArrayStack1(10);
        ArrayStack1 operStack = new ArrayStack1(10);

        // 定义需要的相关变量
        int index = 0;  // 用于扫描
        int num1 = 0;
        int num2 = 0;
        int oper = 0;
        int res = 0;
        char ch = ' ';   // 将每次扫描的char（符号） 保存到ch
        String keepNum = "";  // 用于拼接 多位数

        // 开始while循环的扫描 expression
        while (true) {
            //  依次得到 expression 的每一个字符
            ch = expression.substring(index, index + 1).charAt(0);
            // 判断ch是什么，然后做相应的处理
            if (operStack.isOper(ch)) {  // 如果是运算符
                // 判断当前的符号栈是否为空
                if (!operStack.isEmpty()) {
                    //  如果符号栈有操作符，就进行比较，如果当前的操作符的优先级小于等于栈中的操作符，就需要从数值栈中 婆婆出两个数，
                    //  再从符号栈中 pop 出一个符号，进行运算，将得到的结果，入数值栈，然后将当前的操作符入符号栈
                    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);  // 1 + 3
                }
            } else {
//                int num=Integer.parseInt(String.valueOf(ch));   // 将char型转化为int型
//                numStack.push(num);
                //  1. 当处理多位数时，不能发现是一个数就立即入栈，因为它可能是多位数
                //  2. 在处理数，需要向expression的表达式的index 后再看一位，如果是数就进行扫描，如果是符号才入栈
                //  3. 因此需要定义一个变量 字符串，用于拼接

                //  处理多位数
                keepNum += ch;

                // 如果ch 已经是expression的最后一位，就直接入栈
                if (index == expression.length() - 1) {
                    numStack.push(Integer.parseInt(keepNum));
                } else {
                    // 判断下一个字符是不是数字，如果是数字，就继续扫描，如果是运算符，则入栈
                    //  注意是看后一位，而不是index++
                    if (operStack.isOper(expression.substring(index + 1, index + 2).charAt(0))) {
                        // 如果后一位是运算符，则入栈 keepNum="1" 或者 "123"
                        numStack.push(Integer.parseInt(keepNum));
                        //  重要的！！！！！   keepNum要清空
                        keepNum="";
                    }
                }
            }

            // 让 index+1，并判断是否扫描到expression最后
            index++;
            if (index >= expression.length()) {
                break;
            }
        }

        // 当表达式扫描完毕，就顺序的从 数栈和符号栈中pop出相应的数和符号，并运行
        while (true) {
            //  如果符号栈为空，则计算到最后的结果，数值栈中只有一个数字 【结果】
            if (operStack.isEmpty()) {
                break;
            }
            num1 = numStack.pop();
            num2 = numStack.pop();
            oper = operStack.pop();
            res = numStack.cal(num1, num2, oper);
            numStack.push(res);   //  入栈
        }
        // 将数值栈的最后的数pop出，就是结果
        System.out.println("表达式 " + expression + " = " + numStack.pop());
    }
}


// 定义一个 ArrayStack1 表示栈
class ArrayStack1 {
    private int maxSize;  // 栈的大小
    private int[] stack;   // 数组，数组模拟栈，数据放在该数组中
    private int top = -1;  // top 表示栈顶，初始化为 -1

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

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

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

    //  入栈
    public void push(int value) {
        // 先判断栈是否满
        if (isFull()) {
            System.out.println();
            System.out.println("栈满了~~");
            return;
        }
        top++;
        stack[top] = value;
    }

    // 出栈 - pop，将栈顶的数据返回
    public int pop() {
        // 先判断栈是否空
        if (isEmpty()) {
            // 抛出异常
            System.out.println();
            throw new RuntimeException("栈空，没有数据~~");
        }
        int value = stack[top];
        top--;
        return value;
    }

    ///  遍历栈，遍历时需要从栈顶开始显示数据
    public void list() {
        //  判断栈是否为空
        if (isEmpty()) {
            System.out.println();
            System.out.println("栈空，没有数据~~");
            return;
        }
        // 需要从栈顶开始显示数据
        for (int i = top; i >= 0; i--) {
            System.out.println("stack[" + i + "] = " + stack[i]);
        }
    }

    // 可显示当前栈顶的值，而不是pop出来的
    public int peek() {
        return stack[top];
    }

    // 返回运算符的优先级，优先级是程序员来确定，优先级使用数字表示
    // 数字越大，则优先级就越大
    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;   // res 用于存放计算结果
        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;
    }
}

1.4 前缀表达式（波兰表达式）

一般正常的表达式就是 中缀表达式，适合我们人去看和理解，但计算机就比较难看懂中缀表达式。因此，在计算结果时，往往会将中缀表达式转成其它表达式来操作 (一般转成后缀表达式)

原理（运算符位于操作数之前）：

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

例如: (3+4)×5-6 对应的前缀表达式就是 - × + 3 4 5 6 
先要从普通表达式转化为前缀表达式：3 + 4 x 5 - 6   ---->  - × + 3 4 5 6

然后针对前缀表达式求值步骤如下:

1. 从右至左扫描，将6、5、4、3压入堆栈
2. 遇到+运算符，因此弹出3和4（3为栈顶元素，4为次顶元素），计算出3+4的值，得7，再将7入栈
3. 接下来是×运算符，因此弹出7和5，计算出7×5=35，将35入栈
4. 最后是-运算符，计算出35-6的值，即29，由此得出最终结果

1.5 后缀表达式（逆波兰表达式）

后缀表达式又称 逆波兰表达式，与前缀表达式相似，只是运算符位于操作数之后。

举例说明： (3+4)×5-6 对应的后缀表达式就是 3 4 + 5 × 6 –

再比如：

正常的表达式         |         逆波兰表达式
a+b 			   |	   	 a b +
a+(b-c)            |         a b c - +
a+(b-c)*d          |         a b c - d * +
a+d*(b-c)          |         a d b c - * +
a=1+3              |         a 1 3 + =

原理：

支持小括号和多位数整数，只支持 对整数 的计算。

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

例如: (3+4)×5-6 对应的后缀表达式就是 3 4 + 5 × 6 - , 针对后缀表达式求值步骤如下:

从左至右扫描，将3和4压入堆栈；
1. 遇到+运算符，因此弹出4和3（4为栈顶元素，3为次顶元素），计算出3+4的值，得7，再将7入栈；
2. 将5入栈；
3. 接下来是×运算符，因此弹出5和7，计算出7×5=35，将35入栈；
4. 将6入栈；
5. 最后是-运算符，计算出35-6的值，即29，由此得出最终结果

具体代码：

public class PolandNotation {
    public static void main(String[] args) {
        //  先定义 逆波兰表达式
        // (3+4)x5-6   =>3 4 + 5 x 6 -
        //  逆波兰表达式 的数字和符号使用空格隔开
        String suffixExpression ="3 4 + 5 * 6 -";
        // 思路
        // 1. 先将 “3 4 + 5 x 6 - ”  ==》 放到ArrayList中
        // 2. 将 ArrayList 传递给一个方法，遍历 ArrayList 配合栈 完成计算

        List<String> list=getListString(suffixExpression);
        System.out.println("rpnList="+list);
        int res=calculate(list);
        System.out.println("计算结果是="+res);
    }

    // 将一个逆波兰表达式，依次将数据和运算符 放到 ArrayList中
    public static List<String> getListString(String suffixExpression){
        // 将 suffixExpression 分割
        String[] split = suffixExpression.split(" ");
        List<String> list=new ArrayList<String>();
        for(String ele:split){
            list.add(ele);
        }
        return list;
    }

    //  完成对 逆波兰表达式的运算
    /*
    1.  从左至右扫描，将 3 和 4 压入堆栈；
    2. 遇到 + 运算符，因此弹出 4 和 3 （4为栈顶元素，3为次顶元素），计算 ‘3+4’ 的值，得7，再将7入栈；
    3. 将 5 入栈；
    4. 接下来是 x 运算符，因此弹出 5 和 7 ，计算得出 7x5=35，将 35 入栈；
    5. 将6入栈
    6. 最后是 - 运算符，计算得出 35-6的值，即29，由此得出最终结果
     */
    public static int calculate(List<String> ls){
        // 创建一个栈
        Stack<String> stack=new Stack<String>();

        // 遍历 ls
        for(String item:ls){
            //  这里使用正则表达式来取出数
            if(item.matches("\\d+")) {   //  匹配的是多位数
                // 入栈
                stack.push(item);
            }else {
                // pop 出两个数，并运算，再入栈
                int num2 = Integer.parseInt(stack.pop());
                int num1 = Integer.parseInt(stack.pop());
                int res = 0;
                if (item.equals("+")) {
                    res = num1 + num2;
                }else if(item.equals("-")){
                    res=num1-num2;
            }else if(item.equals("*")){
                    res=num1*num2;
                }else if(item.equals("/")){
                    res=num1/num2;
                }else{
                    throw new RuntimeException("运算符有误");
                }
                // 把res 入栈
                stack.push(""+res);
            }
        }
        //  最后留在 stack 中的数据是运算结果
        return Integer.parseInt(stack.pop());
    }
}

1.6 中缀 转 后缀 表达式

步骤如下：

  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中的元素并输出，结果的逆序即为中缀表达式对应的后缀表达式；

举例说明：

将中缀表达式 “1+((2+3)×4)-5“ 转换为后缀表达式的过程如下

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-e9ZnEFl2-1608630317922)(数据结构与算法img/中缀转后缀表达式.png)]

因此结果为 "1 2 3 + 4 × + 5 –"

具体代码：

public class PolandNotation {
    public static void main(String[] args) {
        // 完成将一个中缀表达式转成后缀表达式的功能
        // 说明
        // 1.  1+((2+3)x4)-5  =>  转成 1 2 3 + 4 x + 5 -
        // 2. 因为直接对 str 进行操作不方便，因此，先将 “ 1+((2+3)x4)-5 ” => 中缀的表达式对应的List
        //     即 “ 1+((2+3)x4)-5 ”  =>  ArrayList [1,+,(,(,2,+,3,),x,4,),-,5]

        // 3. 将得到的中缀表达式对应的List =》 后缀表达式对应的List
        //  即 ArrayList[1,+,(,(,2,+,3,),*,4,),-,5]  =》 ArrayList[1,2,3,+,4,*,+,5,-]


        String expression="1+((2+3)*4)-5";
        List<String> infixExpressionList= toInfixExpression(expression);
        System.out.println(infixExpressionList);  // ArrayList [ 1,+,(,(,2,+,3,),*,4,),-,5]
        List<String> suffixExpressionList=parseSuffixExpressionList(infixExpressionList);
        System.out.println("后缀表达式对应的 List"+suffixExpressionList);   // ArrayList[1,2,3,+,4,*,+,5,-]

        System.out.printf("expression=%d",calculate(suffixExpressionList));
    }


    // 即 ArrayList[1,+,(,(,2,+,3,),*,4,),-,5]   =》  ArrayList[1,2,3,+,4,*,+,5,-]
    // 方法：将得到的 中缀表达式对应的List  =》 后缀表达式对应的List
    public static List<String> parseSuffixExpressionList(List<String> ls){
        // 定义两个栈
        Stack<String> s1=new Stack<String>();   // 符号栈
        // 说明：因为s2 这个栈，再整个转换过程中，没有pop操作，而且后面我们还需要逆序输出
        //  因此比较麻烦，这里我们就不用 Stack<String> 直接使用 List<String>s2
        //   Stack<String>s2= new Stack<String>();   // 储存中间结果的栈s2
        List<String> s2 =new ArrayList<String>();      //  储存中间结果的List2

        // 遍历 ls
        for(String item:ls){
            // 如果是一个数，加入 s2
            if(item.matches("\\d+")){
                s2.add(item);
            }else if(item.equals("(")){
                s1.push(item);
            }else if(item.equals(")")){
                //  如果是右括号 “）” ，则依次弹出s1栈顶的运算符，并压入s2，直到遇到左括号为止，此时将这一对括号丢弃
                while (!s1.peek().equals("(")){
                    s2.add(s1.pop());
                }
                s1.pop();  // 将 （ 弹出 s1栈，消除小括号
            }else{
                // 当item 的优先级小于等于s1栈顶运算符，将 s1 栈顶的运算符弹出并加入到 s2 中，再次转到 步骤4.1 与s1中新的栈顶运算符相比较
                while(s1.size()!=0&&Operation.getValue(s1.peek())>=Operation.getValue(item)){
                    s2.add((s1.pop()));
                }
                // 还需要将item压入栈
                s1.push(item);
            }
        }

        // 将 s1 中剩余的运算符依次弹出并加入 s2
        while (s1.size()!=0){
            s2.add(s1.pop());
        }
        return s2 ; // 注意：因为是存放到List，因此按顺序输出就是对应的后缀表达式对应的List
    }



    // 将 中缀表达式转成对应的List
    //  s="1+((2+3)x4)-5";
    public static List<String> toInfixExpression(String s){
        // 定义一个List，存放 中缀表达式 对应的内容
        List<String> ls= new ArrayList<String>();
        int i=0;   // 这是一个指针，用于遍历 中缀表达式 字符串
        String str;  // 对多位数的拼接
        char c;   // 每遍历到一个字符，就放入到c
        do{
           // 如果 c 是一个非数字，我需要加入到 ls
            if((c=s.charAt(i))<48||(c=s.charAt(i))>57){  //ASCII码：   ‘0’【48】---》‘9’【57】
                ls.add(""+c);
                i++;  // i 需要后移
            }else{  // 如果是一个数，需要考虑多位数
                str="";   // 先将str 置成 “ ‘0’【48】---》‘9’【57】 ”
                while (i<s.length()&&(c=s.charAt(i))>=48&&(c=s.charAt(i))<57){
                    str+=c;  // 拼接
                    i++;
                }
                ls.add(str);
            }
        }while (i<s.length());
        return ls;
    }



    // 将一个逆波兰表达式，依次将数据和运算符 放到 ArrayList中
    public static List<String> getListString(String suffixExpression){
        // 将 suffixExpression 分割
        String[] split = suffixExpression.split(" ");
        List<String> list=new ArrayList<String>();
        for(String ele:split){
            list.add(ele);
        }
        return list;
    }

    //  完成对 逆波兰表达式的运算
    /*
    1.  从左至右扫描，将 3 和 4 压入堆栈；
    2. 遇到 + 运算符，因此弹出 4 和 3 （4为栈顶元素，3为次顶元素），计算 ‘3+4’ 的值，得7，再将7入栈；
    3. 将 5 入栈；
    4. 接下来是 x 运算符，因此弹出 5 和 7 ，计算得出 7x5=35，将 35 入栈；
    5. 将6入栈
    6. 最后是 - 运算符，计算得出 35-6的值，即29，由此得出最终结果
     */
    public static int calculate(List<String> ls){
        // 创建一个栈
        Stack<String> stack=new Stack<String>();

        // 遍历 ls
        for(String item:ls){
            //  这里使用正则表达式来取出数
            if(item.matches("\\d+")) {   //  匹配的是多位数
                // 入栈
                stack.push(item);
            }else {
                // pop 出两个数，并运算，再入栈
                int num2 = Integer.parseInt(stack.pop());
                int num1 = Integer.parseInt(stack.pop());
                int res = 0;
                if (item.equals("+")) {
                    res = num1 + num2;
                }else if(item.equals("-")){
                    res=num1-num2;
            }else if(item.equals("*")){
                    res=num1*num2;
                }else if(item.equals("/")){
                    res=num1/num2;
                }else{
                    throw new RuntimeException("运算符有误");
                }
                // 把res 入栈
                stack.push(""+res);
            }
        }
        //  最后留在 stack 中的数据是运算结果
        return Integer.parseInt(stack.pop());
    }
}


// 编写一个类 Operation 可以返回一个运算符  对应的优先级
class Operation {
    private static int ADD=1;
    private static int SUB=1;
    private static int MUL=2;
    private  static int DIV=2;

    // 写一个方法：返回对应的优先级数字
    public  static int getValue(String operation){
        int result=0;
        switch (operation){
            case "+":
                result=ADD;
                break;
            case "-":
                result=SUB;
                break;
            case "*":
                result=MUL;
                break;
            case "/":
                result=DIV;
                break;
            default:
                System.out.println("不存在该运算符");
                break;
        }
        return result;
    }
}

1.7 逆波兰计算器完整版

功能包括：

  1. 支持 + - * / ( )

  2. 多位数，支持小数,

  3. 兼容处理, 过滤任何空白字符，包括空格、制表符、换页符；

具体代码：

public class ReversePolishMultiCale {
    /**
     * 匹配 + - * /  (  ) 运算符
     */
    static final String SYMBOL="\\+|-|\\*|/|\\(|\\)";   //  正则表达式： ‘\\’起转义作用，‘+|-’匹配 + 或 -

    static final String LEFT="(";
    static final String RIGHT=")";
    static final String ADD="+";
    static final String MINUS="-";
    static final String TIMES="*";
    static final String DIVISION="/";

    /**
     * 加减 + -
     */
    static final int LEVEL_01=1;

    /**
     * 乘除 * /
     */
    static final int LEVEL_02=2;

    /**
     * 括号
     */
    static final int LEVEL_HIGH=Integer.MAX_VALUE;

    static Stack<String> stack=new Stack<>();
    static List<String> data= Collections.synchronizedList(new ArrayList<String>());

    /**
     * 去除所有空白符
     * @param s
     * @return
     */
    public static String replaceAllBlank(String s){
        //  \\s+  匹配任何空白字符，包括空格、制表符、换页符等等，等价于[\f\n\r\t\v]
        return s.replaceAll("\\s+","");
    }

    /**
     * 判断是不是数字  int double long float
     * @param s
     * @return
     */
    public static boolean isNumber(String s){
        Pattern pattern=Pattern.compile("^[-\\+]?[.\\d]*$");
        return pattern.matcher(s).matches();
    }

    /**
     * 判断是不是运算符
     * @param s
     * @retuen
     */
    public static boolean isSymbol(String s){
        return s.matches(SYMBOL);
    }

    /**
     * 匹配运算等级
     * @param s
     * @return
     */
    public static int calcLevel(String s){
        if("+".equals(s)||"-".equals(s)){
            return LEVEL_01;
        }else if("*".equals(s)||"/".equals(s)){
            return LEVEL_02;
        }
        return LEVEL_HIGH;
    }

    /**
     * 匹配
     * @param s
     * @throws Exception
     */
    public static List<String> doMatch(String s) throws  Exception{
        if(s==null||"".equals(s.trim())) throw new RuntimeException("data is empty");
        if(!isNumber(s.charAt(0)+"")) throw new RuntimeException("data illeagle,start not with a number");

        s=replaceAllBlank(s);

        String each;
        int start =0;

        for (int i=0;i<s.length();i++){
            if(isSymbol(s.charAt(i)+"")){
                each=s.charAt(i)+"";

                // 栈为空   或者   操作符为“（”    或者   操作符优先级大于栈顶优先级  并且 操作符优先级不是（）的优先级，则不能直接入栈
                if(stack.isEmpty()||LEFT.equals(each)||((calcLevel(each)>calcLevel(stack.peek()))&&calcLevel(each)<LEVEL_HIGH)){
                    stack.push(each);
                }else if(!stack.isEmpty()&&calcLevel(each)<=calcLevel(stack.peek())){
                    // 栈非空 并且 操作符优先级小于等于栈顶优先级时，出栈入列，直到栈为空，或者遇到了“（”，最后操作符入栈
                    while (!stack.isEmpty()&&calcLevel(each)<=calcLevel(stack.peek())){
                        if(calcLevel(stack.peek())==LEVEL_HIGH){
                            break;
                        }
                        data.add(stack.pop());
                    }
                    stack.push(each);
                }else if(RIGHT.equals(each)){
                     //  匹配到 “）”操作符，则依次出栈入列直到空栈  或者 遇到了第一个 “）”操作符，此时“）”出栈
                    while (!stack.isEmpty()&&LEVEL_HIGH>=calcLevel(stack.peek())){
                        if(LEVEL_HIGH==calcLevel(stack.peek())){
                            stack.pop();
                            break;
                        }
                        data.add(stack.pop());
                    }
                }
                start=i;   // 前一个运算符的位置
            }else if(i==s.length()-1||isSymbol(s.charAt(i+1)+"")){
                each =start==0?s.substring(start,i+1):s.substring(start+1,i+1);
                if (isNumber(each)) {
                    data.add(each);
                    continue;
                }
                throw new RuntimeException("data not match number");
            }
        }

        //  如果栈里还有元素，此时元素需要依次出栈入列，可以想象栈里剩下栈顶为 /（除）,栈底为 +（加），应该依次出栈入列，可以直接翻转整个 stack 添加到队列
        Collections.reverse(stack);
        data.addAll(new ArrayList<>(stack));

        System.out.println(data);
        return data;
    }

    /**
     * 算出结果
     * @param list
     * @return
     */
    public static Double doCalc(List<String> list){
        Double d=0d;
        if(list==null||list.isEmpty()){
            return null;
        }
        if(list.size()==1){
            System.out.println(list);
            d=Double.valueOf(list.get(0));
            return d;
        }
        ArrayList<String> list1=new ArrayList<>();
        for(int i=0;i<list.size();i++){
            list1.add(list.get(i));
            if(isSymbol(list.get(i))){
                Double d1=doTheMath(list.get(i-2),list.get(i-1),list.get(i));
                list1.remove(i);
                list1.remove(i-1);
                list1.set(i-2,d1+"");
                list1.addAll(list.subList(i+1,list.size()));
                break;
            }
        }
        doCalc(list1);
        return d;
    }

    /**
     * 运算
     * @param s1
     * @param s2
     * @param symbol
     * @return
     */
    public static Double doTheMath(String s1,String s2,String symbol){
        Double result;
        switch (symbol){
            case ADD:
                result=Double.valueOf(s1)+Double.valueOf(s2);
                break;
            case MINUS:
                result=Double.valueOf(s1)-Double.valueOf(s2);
                break;
            case TIMES:
                result=Double.valueOf(s1)*Double.valueOf(s2);
                break;
            case DIVISION:
                result=Double.valueOf(s1)/Double.valueOf(s2);
                break;
            default:
                result=null;
        }
        return result;
    }

    public static void main(String[] args) {
        // String math="9+(3-1)*3+10/2";
        String math="12.8+(2-3.55)*4+10/5.0";
        try{
            doCalc(doMatch(math));
        }catch (Exception e){
            e.printStackTrace();
        }
    }
}
roseLin...
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java使用d3_[Java教程]一个初学者的指南，使用D3做数据绑定
weixin_33524659的博客
02-27 187
[Java教程]一个初学者的指南，使用D3做数据绑定0 2016-07-03 13:00:09一个初学者的指南，使用D3做数据绑定D3.js 是个强大的数据可视化库，可以做出惊艳的图表。比如：气泡图，线图和条形图－－只需要很少行的代码随着初学者对JavaScript的理解，可以将数组或者对象转换成一个五彩缤纷的显示效果。然而，每一个初学者的比较纠结的是一开始理解如何将数据绑定在实际的...
数据结构之栈
xiaotai1234的博客
09-29 288
数据结构之栈 一、概述 二、栈的应用场景 三、数组模拟栈 package com.atguigu.stack; import java.util.Scanner; public class ArrayStackDemo { public static void main(String[] args) { //测试一下ArrayStack 是否正确 //先创建一个ArrayStack对象->表示栈 ArrayStack stack = new ArrayStack(4);
java d3_java-D3
weixin_29223603的博客
02-26 177
--------------------------------------装--------------------------------------订------------------------------线----------------------------------------荆州理工职业学院JA V A课程考试试卷课程名称：《Java：使用Java语言深入理解程序逻辑》(A)...
D3树图数据结构例子
01-12
D3树图数据结构例子，用于理解treemap layout
d3.js学习笔记（五）——将数据结构化为D3.js可处理的
dbrd89655的博客
01-13 226
目标 在这一章，你将会理解如何对数据进行结构化，来更好的使用D3.js。 我们将会回顾我们之前已经学习的，学习D3.js如何使用选集（selections），JavaScript对象基础，以及如何最优的结构化数据。 到目前我们已经学到了哪些？ 到目前，我们使用D3.js完成的例子都包含一个定义在最上方的数据集： var spaceCircles = [30,70,110]; ...
蓄水池算法leetcode-leetcode-js:leetcode打卡
06-30
题中不需要会员的数据结构与算法题目(数据库与 shell 除外)进行分类，并推荐一个刷题的顺序。 完全零基础可以刷题吗？ 不能，至少要基本掌握一门计算机语言的语法。但现在在网上随便搜一下就能搜到许多关于计算机...
打卡第三天(Task03)—-移除元素
12-22
在给定的题目“打卡第三天(Task03)—-移除元素”中，我们面临的问题是在一个数组（nums）中移除特定值（val）的所有实例，而无需创建新的数组，并且要求在O(1)的额外空间复杂度下完成。这是一个典型的原地修改数组的...
leetcode卡-leetcode:使用JavaScript打卡leetCode题目
07-06
在IT行业中，LeetCode是一个非常受欢迎的在线平台，它提供了大量的编程题目，旨在帮助开发者提升算法和数据结构技能。这个“leetcode卡”很可能是某个开发者为了整理和实践LeetCode上的JavaScript题目而创建的一个...
leetcode卡-Programming:编程
07-06
leetcode卡 Programming 课程设计：光城 、LeoLRH 组队学习说明：利用自己所熟知的编程语言，具有一定...)（选做）（注意：在第四天会进行继续学习） 练习： Three Sum（求三数之和） Majority Element（求众数） Missi
Datawhale&kesci&伯禹教育-深度学习-第二次打卡2梯度消失和爆炸
01-20
深度学习是现代人工智能领域的重要组成部分，它通过模拟人脑神经网络的工作原理，处理复杂的数据问题。在构建深度学习模型时，经常会遇到两个关键问题：梯度消失（vanishing gradient）和梯度爆炸（exploding ...
Java / D3-开源
05-12
第一部分是组成套接字服务器的D3程序的集合。 第二部分专门介绍可以调用此服务器的客户端程序。 当前有适用于Java和PHP的客户端
Java_ArrayStack:使用数组简单地实现堆栈。 从算法第四版。 第1.3节
05-02
#Array Stack已移至： 使用调整大小的数组可以简单地实现堆栈。 从 第1.3节
JAVAEE--jQuery ----D3
BraveChalleng的博客
12-10 136
d3des库 java,D3，最受欢迎的前端数据可视化库
weixin_33057949的博客
03-13 262
第一个浏览器只能渲染静态页面，所谓交互性仅限于单击链接。1996年，Netscape在浏览器中内置了JavaScript解释器，从而让浏览器在加载页面时，能够解释执行这门脚本语言编写的代码。这个举措并没有它后来引发的巨变那么惊心动魄，但却让浏览器从被动的显示，进入了交互在线处理动态画面的新时代。这一历史性转变成就了我们今天的页面内交互的Web。如果没有JavaScript，就不会有D3，而基于We...
java d3.js_[译] D3.js 之 d3-shap 简介
weixin_39612733的博客
02-23 103
[译] D3.js 之 d3-shap 简介译者注原文: 来自 D3.js 作者 Mike Bostock 的 Introducing d3-shape译者: ssthouse 联系译者: 邮箱(ssthouse@163.com) & 微信(wssst123456789)译文假设你现在想创建一个用于学习特定数据集的工具, 你最容易想到的呈现方式是什么呢? 一个可以自定义的 chart? 一...
java学习D3-标识符、关键字、字面值
Ni2cole的博客
09-25 248
/* java语言当中的标识符 1、什么是标识符 -在java源程序当中方式程序员有权利自己命名的单词都是标识符 -标识符可以表示什么元素呢？ *类名 *方法名 *变量名 *接口名 *常量名 … 2、标识符的命名规则 *一个合法的标识符只能由 数字、字母、下划线、美元符号构成 *不能以数字开头 *严格区分大小写 *关键字不能做标志符 *理论上无长度限制，但是不要太长 3、标识符的命名规范【只是一种...
java使用d3_D3 快速入门指北
weixin_28958239的博客
02-27 733
这是一篇 D3的入门概述，目的是为了理清对D3的认识，也希望能帮助大家入门。1. D3是什么？D3(Data-Driven Document)翻译成中文“数据驱动文档”，是一个基于数据操作 DOM 的Javascript库。理解起来，D3 跟 jQuery 很像，不过D3是面向数据可视化的，数据驱动操作DOM；而 jQuery 是面向 web 开发的，直接操作 DOM。D3 是 javaScrip...
java d3.js_[Java教程][D3.js] SVG
weixin_32103331的博客
02-19 90
[Java教程][D3.js] SVG0 2015-03-17 23:02:50D3的坐标轴组件会自动显示刻度的参考线。这可以让你只专注于数据的显示，而让坐标轴组件去帮你绘制坐标轴和标记刻度。AxisD3的轴组件是为D3的quantitative,time和ordinal标度所设计的。# d3.svg.axis()新建一个默认的坐标轴。# aixs...
初学d3
风烟
10-07 1173
最近再做一个应用，然后需要做一些表格，其中有柱状图和饼状图，柱状图感觉还可以用div模拟，然是饼状图就不知道了，想了半天，css我是实现不了了。 我想起来，现在前端可视化有好多的库，我刚好可以趁这个机会学习一下，然后上网一搜，频率出现的比较多的就是d3了，想来，数据可视化的东西库应该是一类东西，学习其中一个比较经典的，其他的以后就算要用，应该思想是差不多的，就和当初学jquery一样，jquery
第6章-数据结构与算法教学课件PPT文档.pptx
最新发布
12-03
第4页详细介绍了基本数据结构，包括线性结构和非线性结构。线性结构的逻辑特征是：若结构是非空集，则有且仅有一个开始结点和一个终端结点，并且所有结点都最多只有一个直接前趋和一个直接后继。而非线性结构的逻辑...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值