数据结构与算法（第四章 栈）

已于 2023-06-15 15:51:58 修改
阅读量1k 收藏
点赞数
分类专栏： java 数据结构 文章标签： java 数据结构 栈
于 2021-03-23 13:34:30 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45087487/article/details/115050128
版权

4.1栈的一个实际需求
计算一个表达式
计算表达式：【722-5+1-5+3-3】点击计算【如下图】
在这里插入图片描述
此例并不是简单的把算式列出计算，而是考虑计算机是如何对这个式子进行解析并运算的，这就引出问题的关键--------栈。

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

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

4.4栈的快速入门
（1）用数组模拟栈的使用，由于栈是一种有序列表，当然可以使用数组的结构来存存储栈的数据内容，以下是数组模拟栈的出栈，入栈操作。
（2）实现思路如下：
在这里插入图片描述
代码实现：

import java.util.Scanner;

public class ArrayStackDemo {
    public static void main(String[] args) {
         //测试ArrayStack是否正确(定义菜单测试栈)
        ArrayStatck arrayStatck = new ArrayStatck(4);
        String key="";   //接收控制台输入的命令
        boolean flag=true;   //标识是否退出程序
        Scanner scanner = new Scanner(System.in);  //接收控制台输入
        //创建菜单
        while (flag){
            System.out.println("show:展示栈中数据");
            System.out.println("add:向栈中添加数据");
            System.out.println("pop:弹出栈中数据");
            System.out.println("exit:退出程序");
            String str = scanner.next();
            switch (str){
                case "show":
                    arrayStatck.show();
                    break;
                case "add":
                    System.out.println("请输入数据");
                    int value = scanner.nextInt();
                    arrayStatck.push(value);
                    break;
                case "pop":
                    try {
                        int pop = arrayStatck.pop();
                        System.out.printf("出栈的数据为：%d \n",pop);
                        break;
                    }catch (Exception e){
                        System.out.println(e.getMessage());
                    }
                case "exit":
                    scanner.close();
                    flag=false;
                    break;
            }
        }
        System.out.println("退出菜单！");
    }
}

//用数组来模拟栈
class ArrayStatck{
    private int maxSize;  //定义栈的最大空间
    private int[] stack;  //用数组来存放栈中数据
    private int pop=-1;    //将栈顶指针初始化为-1

    //创建构造器，初始化栈
    public ArrayStatck(int maxSize){
        this.maxSize=maxSize;
        stack=new int[maxSize];
    }

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

    //判断栈是否满
    public boolean isFull(){
        return pop==maxSize-1;
    }

    //入栈
    public void push(int data){
        if (isFull()){
            System.out.println("栈满");
            return;
        }
        pop++;     //将指针上移
        stack[pop]=data;  //将数据存入
    }

    //出栈
    public int pop(){
        if (isEmpty()){
            throw new RuntimeException("栈为空");
        }
        int value=stack[pop];   //将出栈的值存入临时变量方便后入弹出
        pop--;              //将指针下移
        return value;
    }

    //遍历栈中元素（注意：从栈顶开始遍历）
    public void show(){
        if (isEmpty()){
            System.out.println("栈为空");
            return;
        }
        //遍历出栈
        for (int i=pop;i>=0;i--){
            System.out.printf("stack[%d]=%d \n",i,stack[i]);
        }
    }
}

4.5栈实现综合计算器（中缀表达式）
@使用栈来实现综合计算器
在这里插入图片描述
@思路分析（图解）
在这里插入图片描述
@代码实现【1.先实现一位数的运算，2.扩展到多位数的运算】

public class Calculator {
    public static void main(String[] args) {
        String expression = "7*2-4"; // 15//如何处理多位数的问题？
        //创建两个栈，数栈，一个符号栈
        ArrayStack2 numStack = new ArrayStack2(10);
        ArrayStack2 operStack = new ArrayStack2(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出两个数,
                    //在从符号栈中pop出一个符号，进行运算，将得到结果，入数栈，然后将当前的操作符入符号栈
                    if(operStack.priority(ch) <= operStack.priority(operStack.peek())) {
                        num1 = numStack.pop();
                        num2 = numStack.pop();
                        oper = operStack.pop();
                        res = numStack.count(num1, num2, oper);
                        //把运算的结果如数栈
                        numStack.push(res);
                        //然后将当前的操作符入符号栈
                        operStack.push(ch);
                    } else {
                        //如果当前的操作符的优先级大于栈中的操作符， 就直接入符号栈.
                        operStack.push(ch);
                    }
                }else {
                    //如果为空直接入符号栈..
                    operStack.push(ch); // 1 + 3
                }
            } else { //如果是数，则直接入数栈

                //numStack.push(ch - 48); //? "1+3" '1' => 1
                //分析思路
                //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.count(num1, num2, oper);
            numStack.push(res);//入栈
        }
        //将数栈的最后数，pop出，就是结果
        int res2 = numStack.pop();
        System.out.printf("表达式 %s = %d", expression, res2);
    }
}

class ArrayStack2{
    private int maxSize;  //定义栈的最大空间
    private int[] stack;  //用数组来存放栈中数据
    private int pop=-1;    //将栈顶指针初始化为-1

    //创建构造器，初始化栈
    public ArrayStack2(int maxSize){
        this.maxSize=maxSize;
        stack=new int[maxSize];
    }

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

    //判断栈是否满
    public boolean isFull(){
        return pop==maxSize-1;
    }

    //入栈
    public void push(int data){
        if (isFull()){
            System.out.println("栈满");
            return;
        }
        pop++;     //将指针上移
        stack[pop]=data;  //将数据存入
    }

    //出栈
    public int pop(){
        if (isEmpty()){
            throw new RuntimeException("栈为空");
        }
        int value=stack[pop];   //将出栈的值存入临时变量方便后入弹出
        pop--;              //将指针下移
        return value;
    }

    //展示栈顶元素（不是弹出）
    public int peek(){
        return stack[pop];
    }

    //遍历栈中元素（注意：从栈顶开始遍历）
    public void show(){
        if (isEmpty()){
            System.out.println("栈为空");
            return;
        }
        //遍历出栈
        for (int i=pop;i>=0;i--){
            System.out.printf("stack[%d]=%d \n",i,stack[i]);
        }
    }

    //判断符号的优先级（由程序员自己设定）
    //数字越大，优先级越大
    public int priority(int ch){
        if (ch=='*' || ch=='/'){
            return 1;
        }else if (ch=='+' || ch=='-'){
            return 0;
        }else {
            return -1;    //目前暂时定义*、/、+、-四种运算符
        }
    }

    //判断字符是否是符号
    public boolean isOper(int ch){
        return ch=='*' || ch=='/' || ch=='+' || ch=='-';
    }

    //两数之间的运算
    public int count(int num1,int num2,int ch){
        int result=0;  //存放数据
        if (ch=='*'){
            result=num1*num2;
        }else if (ch=='/'){
            result=num2/num1;
        }else if (ch=='+'){
            result=num1+num2;
        }else if (ch=='-'){
            result=num2-num1;
        }
        return result;
    }

}

4.6逆波兰计算器
完成一个逆波兰计算器，要求完成如下任务：
（1）输入一个逆波兰表达式（后缀表达式），使用栈（Stack），计算其结果
（2）支持小括号和多位数整数，因为这里我们主要讲的是数据结构，因此计算器进行简化，支持吃对整数的计算。
（3）思路分析

例如: (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，由此得出最终结果

代码实现：

public class PolandNotation {
    public static void main(String[] args) {
        //先定义给逆波兰表达式
        //(30+4)×5-6 => 30 4 + 5 × 6 - => 164
        // 4 * 5 - 8 + 60 + 8 / 2 => 4 5 * 8 - 60 + 8 2 / +
        //测试
        //说明为了方便，逆波兰表达式 的数字和符号使用空格隔开
        //String suffixExpression = "30 4 + 5 * 6 -";
        String suffixExpression = "4 5 * 8 - 60 + 8 2 / +"; // 76
        //思路
        //1. 先将 "3 4 + 5 × 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)接下来是×运算符，因此弹出 5 和 7，计算出 7×5=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());
    }
}

4.7中缀表达式转换为后缀表达式
ps：因为后缀表达式更加适合计算机的运算，所以在开发中，需要将中缀表达式转成后缀表达式
4.7.1具体步骤如下：
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中的元素并输出，结果的逆序即为中缀表达式对应的后缀表达式
4.7.2举例说明：
将中缀表达式“1+（（2+3）X 4）-5”转换为后缀表达式的过程如下
因此结果为：“1 2 3 + 4 X + 5 -”

在这里插入图片描述
4.7.3代码实现中缀表达式转为后缀表达式
@思路分析
在这里插入图片描述
@代码实现

package com.atguigu.stack;

import java.util.ArrayList;
import java.util.List;
import java.util.Stack;

public class PolandNotation {

	public static void main(String[] args) {
		
		
		//完成将一个中缀表达式转成后缀表达式的功能
		//说明
		//1. 1+((2+3)×4)-5 => 转成  1 2 3 + 4 × + 5 –
		//2. 因为直接对str 进行操作，不方便，因此 先将  "1+((2+3)×4)-5" =》 中缀的表达式对应的List
		//   即 "1+((2+3)×4)-5" => ArrayList [1,+,(,(,2,+,3,),*,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 = toInfixExpressionList(expression);
		System.out.println("中缀表达式对应的List=" + infixExpressionList); // ArrayList [1,+,(,(,2,+,3,),*,4,),-,5]
		List<String> suffixExpreesionList = parseSuffixExpreesionList(infixExpressionList);
		System.out.println("后缀表达式对应的List" + suffixExpreesionList); //ArrayList [1,2,3,+,4,*,+,5,–] 
		
		System.out.printf("expression=%d", calculate(suffixExpreesionList)); // ?
	}
	
	
	
	//即 ArrayList [1,+,(,(,2,+,3,),*,4,),-,5]  =》 ArrayList [1,2,3,+,4,*,+,5,–]
	//方法：将得到的中缀表达式对应的List => 后缀表达式对应的List
	public static List<String> parseSuffixExpreesionList(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>(); // 储存中间结果的Lists2
		
		//遍历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)×4)-5";
	public static List<String> toInfixExpressionList(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) {
				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)接下来是×运算符，因此弹出5和7，计算出7×5=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("不存在该运算符" + operation);
			break;
		}
		return result;
	}
	
}

4.8 逆波兰计算器完整版
4.8.1完整版的逆波兰计算器，功能包含
（1）支持 + - * / ()
（2）多位数，支持小数
（3）兼容处理，过滤任何空白字符，包括空格、制表符、换页符

ps:逆波兰计算器完整版考虑的因素较多，下面是完整版代码（思路同上：使用到中缀表达式转为后缀表达式）
代码实现：

package com.atguigu.reversepolishcal;

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Stack;
import java.util.regex.Pattern;

public class ReversePolishMultiCalc {

	 /**
     * 匹配 + - * / ( ) 运算符
     */
    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
     * @return
     */
    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();
        }
    }

}
懒惰的小白521
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
中缀表达式转换为后缀表达式
__七把刀__
09-20 17万+
一、后缀表达式求值 后缀表达式也叫逆波兰表达式，其求值过程可以用到栈来辅助存储。假定待求值的后缀表达式为：6  5  2  3  + 8 * + 3  +  *，则其求值过程如下： 1）遍历表达式，遇到的数字首先放入栈中，此时栈如下所示： 2）接着读到“+”，则弹出3和2，执行3+2，计算结果等于5，并将5压入到栈中。 3）读到8，将其直接放入栈中。 4）读到“*”，弹出8和
python 数据结构与算法(第4章 栈)ppt
02-21
第4章 栈 栈的概念和性质 栈的顺序存储 栈的链式存储 栈的应用
【PAT】出栈序列的合法性 (25 分)
不懂语言的猿
07-15 1320
出栈序列的合法性 (25 分) 过去属于死神，未来属于你自己 ——《吞噬地球》 题目源自PAT浙大版《数据结构学习与实验指导（第2版）》题目集 基础实验3-2.4 出栈序列的合法性 (25 分) 给定一个最大容量为 M 的堆栈，将 N 个数字按 1, 2, 3, …, N 的顺序入栈，允许按任何顺序出栈，则哪些数字序列是不可能得到的？例如给定 M=5、N=7，则我们有可能得到{ 1, 2, 3, 4, 5, 6, 7 }，但不可能得到{ 3, 2, 1, 7, 5, 6, 4 }。 输入格式
数据结构—顺序表
Coulnaut的博客
12-02 1082
先语：前面记录了怎么评判算法好坏的时间复杂度，空间复杂度。下面正式记录一个数据结构，顺序表。在说顺序表的时候，先来说说线性表。因为顺序表属于线性表。线性表通俗的说，就是一根线一样，一连串的。这是逻辑上的。物理存储上的并不是像数组一样一连串的内存空间啊。当然也有物理上是连续的 就是下面要说的顺序表， 线性表（linear list）      概念     n个具有相同特性的数据元素的有...
《数据结构》：中缀表达式转后缀表达式 + 后缀表达式的计算
热门推荐
Amentos的博客
10-07 6万+
《数据结构》实验报告：中缀/后缀/前缀表达式基本概念 + 前缀转后缀 + 后缀表达式的计算 + 完整算法实现
中缀表达式转后缀表达式
学习记录
07-06 4万+
中缀表达式转后缀表达式
北京工业大学 数据结构与算法 （电控学院） 第四章栈和队列作业
03-29
本资源为数据结构与算法第四章（栈和队列）的作业程序代码。包含以下的两个程序： 4.3火车硬软座问题 4.11rear和length表示的循环队列入出队 北工大电控学院《数据结构与算法》课程的其它章节程序实验及作业代码亦已...
【精品课件】数据结构与算法 数据结构与C语言 data structure课程 第3章 栈和队列（共150页）.ppt
11-05
数据结构与算法 数据结构与C语言 第4章 串、数组和广义表（共66页）.ppt 数据结构与算法 数据结构与C语言 第5章 树和二叉树（共95页）.ppt 数据结构与算法 数据结构与C语言 第6章 图（共126页）.ppt 数据结构与算法 ...
DataStruct:张铭-数据结构与算法习题
04-11
:keycap_2: 习题 1 ：是北大张铭《数据结构与算法》教材习题以及对应的《数据结构与算法-学习指导与习题解析》 :keycap_3: 习题 2 ：来自王道教材习题 第一章 概述 第二章 线性表 第三章 栈和队列 :green_book: 第...
中缀表达式转后缀表达式详解
罅隙的博客
08-25 2万+
深入讲解中缀表达式转后缀表达式的基本原理与实现代码
数据结构的中缀表达式转后缀表达式使用C++实现
11-15
数据结构的中缀表达式转后缀表达式，通过C++语言实现。使用堆栈方法进行转换，能正确运算包含括号、加、减、乘、除复合运算，如（1+2）*3-1.8*(18/(7+2)) = 8.2。
数据结构（中缀表达式转后缀表达式）
04-25
/*程序由本人编译，并且经过多次测试，正确无误！目前该转换算法只支持数字在0至9之间的+-*/四元运算转换.*/ /**************程序员信息 ***************东北大学*******************东大很厉害**************** ***************软件学院*******************软件学院更厉害************ ***************08级软件工程***************想了解东大吗?************* ***************www.neu.edu.cn*************************************** ***************个人主页：http://hi.baidu.com/stillrain************** */
[数据结构]中缀(即算术)表达式转后缀
daixd5520的博客
01-02 672
文章摘自知乎 示例表达式：[(A+B)*C]-[E-F] 转化为前缀表达式： 先计算A+B，转化为+AB +AB作为整体与C运算，转化为*+ABC 运算E-F，转化为-EF 将*+ABC与E-F都作为整体执行-运算，转化为-*+ABC-EF 转化为后缀表达式： 先计算A+B，转化为AB+ AB+作为整体与C运算，转化为AB+C* 运算E-F，转化为EF- 将AB+C与EF-作为整体执行-运算，转化为AB+CEF– 用栈实现中缀表达式转化为后缀表达式 算法思想 如果检测到数字，则直接加入到后缀表达式中 如果检
【数据结构与算法】总结篇：中缀表达式转后缀表达式 与 表达式树
qq_61571098的博客
09-12 2918
同样是借助一个栈，然后对表达式进行扫描，如果扫描到是是数字或者字符则直接入栈，如果扫描到的是运算符，则弹出栈顶两个元素，重新构造二叉树。’运算符比‘+’运算符的优先级高，所以循环执行出栈操作，直到运算符优先级小于‘+’。由于’+'的运算符优先级等于‘+’，所以栈内运算符都被弹出，‘扫描到的+’入栈。根据表达式树的前序遍历，中序遍历，后序遍历，我 们分别可以得出常见的三种表达式，前缀表达式，中缀表达式与后缀表达式，然后扫描遇到‘+’号，乘号的运算级高于’+‘号，所以称号直接弹出栈输出,’+'号入栈。
中缀表达式 转成 后缀表达式
zm_miner的博客
03-30 2万+
中缀表达式 将运算符写在两个操作数中间的表达式 eg: (6+3*(7-4))-8/2 后缀表达式 将运算符写在操作数之后, 逆波兰式（Reverse Polish notation，RPN，或逆波兰记法），也叫后缀表达式 eg: 6 3 7 4 - * + 8 2 / - 前缀表达式 将运算符写在两个操作数之前的表达式 eg: - + 6 * 3 - 7 4 / 8 2 中缀表达式转换成后缀表达式 eg. (6+3*(7-4))-8/2 1.直接转换法 确定表达式的运算方式, 加括号, 给每一次能
数据结构 - 中缀表达式转后缀表达式
qq_53568186的博客
09-15 244
数据结构中缀表达式转后缀表达式
数据结构学习：前缀中缀后缀表达式转化
weixin_45632016的博客
07-31 2696
数据结构学习：前缀中缀后缀表达式转化 中缀转后缀的手算方法： ① 确定中缀表达式中各个运算符的运算顺序 ② 选择下一个运算符，按照「左操作数 右操作数 运算符」的方式组合成一个新的操作数 ③ 如果还有运算符没被处理，就继续 ② 由于运算顺序不唯一，因此对应的后缀表达式也不唯一 “左优先”原则：只要左边的运算符能先计算，就优先算左边的 后缀表达式的手算方法： 从左往右扫描，每遇到一个运算符，就让运算符前面最近的两个操作数执行对应运算，合体为一个操作数 用栈实现后缀表达式的计算： ①从左往右扫描下一个元素，
【数据结构】中缀表达式转后缀表达式求值
这里是Mae。
10-12 5964
后缀表达式求值 首先需要将输入的中缀表达式转换成后缀表达式。 后缀表达式中，操作符在后 例如：1+2*(5-3)+4 后缀表达式：1253-*+4+ 1、中缀表达式转换成后缀表达式方法： 首先，需要定义一个操作符栈并且知道各运算符优先级，然后从左往右一次扫描字符(字符前后加#号)，遇到数字直接输出，遇到操作符比较优先级。 栈顶优先级低，入栈； 栈顶优先级高，出栈并且输出； 优先级相等(即左右括号)，出栈(不输出)； 当扫描的字符为#并且栈顶字符为#时，此时输出的字符序列即为后缀表达式 2、后缀表达式求值过程
用c语言实现顺序堆栈
刘克雄
12-29 174
/* * 用c语言实现顺序堆栈 */ #include&lt;stdio.h&gt; #include&lt;stdlib.h&gt; typedef struct stack { //用来保存元素 int *a; //已经保存的元素个数 int index; //最多允许容纳的元素个数 int max; }st; /* * 初始化堆栈 ...
数据结构与算法第ba章笔记整理
最新发布
09-02
数据结构与算法是计算机科学的基础和核心领域之一，第ba章介绍了数据结构的相关内容。 本章主要包括以下几个方面的内容： 1. 线性结构：线性结构是指数据元素之间存在一对一的关系，包括线性表、栈和队列。线性表是最基本的数据结构之一，它分为顺序表和链表两种形式。顺序表使用数组实现，插入和删除操作相对低效。链表使用指针实现，插入和删除操作较为灵活。 2. 树结构：树结构是一种层次结构，由节点和边组成。常见的树结构有二叉树、二叉搜索树和平衡二叉树等。二叉树中每个节点最多有两个子节点，二叉搜索树中左子节点的值小于根节点，右子节点的值大于根节点，查找效率较高。平衡二叉树是一种保持左右子树高度差不大于1的二叉搜索树。 3. 图结构：图结构是由节点和边组成的非线性结构。图分为有向图和无向图。图的表示方法有邻接矩阵和邻接表两种。深度优先搜索和广度优先搜索是图的常用遍历方法，可用于寻找路径、连通分量等问题。 4. 排序算法：排序算法是对一组无序数据进行按照某个规则进行有序排列的算法。第ba章介绍了常见的排序算法，包括冒泡排序、插入排序、选择排序、归并排序、快速排序等。每种排序算法的时间复杂度和空间复杂度不同，选择合适的排序算法可以提高性能。 5. 查找算法：查找算法是在一组数据中搜索某个特定元素的算法。第ba章介绍了顺序查找、二分查找和哈希查找等常见的查找算法。二分查找是在有序数组中应用最广泛的查找算法，通过不断缩小查找范围来快速定位目标值。 通过学习这些内容，我们可以了解不同数据结构的特点和应用场景，以及常见的排序和查找算法。掌握好这些知识，对于解决实际问题和提高程序效率都有很大帮助。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值