四、栈的快速入门

已于 2022-11-28 11:08:24 修改
阅读量293 收藏
点赞数
分类专栏： 数据结构 文章标签： 数据结构
于 2022-11-14 16:57:16 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/AsiaLYF/article/details/127850563
版权
本文介绍了栈的基本概念，包括其先入后出的特点和在子程序调用、参数递归、表达式转换中的应用。通过代码示例展示了如何用数组和链表模拟栈，并详细阐述了如何使用栈实现中缀表达式到后缀表达式的转换以及计算器功能。此外，还探讨了前缀、中缀和后缀表达式及其相互转换的方法。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

介绍

  • 栈的英文为(stack)
  • 栈是一个先入后出（FIFO——First In Last Out）的有序列表
  • 栈（stack）是限制线性表中元素的插入和删除只能在线性表的同一端进行的一种特殊的线性表。允许插入和删除的一端，为变化的一端，称为栈顶（Top），另一端为固定的一端，称为栈底（Bottom）
  • 根据栈的定义可知，最先放入栈中元素在栈底，最后放入的元素在栈顶；而删除元素刚好相反，最后放入的元素最先删除，最先放入的元素最后删除

栈的应用场景

  • 子程序的调用：在跳往子程序前，会先将下个指令的地址存到堆栈中，直到子程序执行完后再将地址取出，以回到原来的程序中
  • 处理参数递归调用：和子程序的调用类似，只是除了存储下一个指令的地址外，也将参数、区域变量等数据存入堆栈中
  • 表达式的转换【中缀表达式转后缀表达式】和求值（实际解决）
  • 图形的深度优先（depth——first）搜索法

代码实现

1、用数组模拟栈
public class ArrayStackDemo {

	public static void main(String[] args) {
		ArrayStack arrayStack = new ArrayStack(4);
		String key = "";
		boolean loop = true;
		Scanner scanner = new Scanner(System.in);System.out.println("show：表示显示栈");
		System.out.println("exit：表示退出程序");
		System.out.println("push：表示添加数据到栈（入栈）");
		System.out.println("pop：表示从栈取出数据（出栈）");
		while (loop) {
			System.out.println("请输入你的选择：");
			key = scanner.next();
			switch (key) {
			case "show":
				arrayStack.list();
				break;
			case "push":
				System.out.println("请输入一个数字：");
				int value = scanner.nextInt();
				arrayStack.push(value);
				break;
			case "pop":
				try {
					int res = arrayStack.pop();
					System.out.printf("出栈的数据是%d\n", res);
				} catch (Exception e) {
					e.printStackTrace();
				}
				break;
			case "exit":
				scanner.close();
				loop = false;
				break;

			default:
				break;
			}
		}
		System.out.println("程序退出~~");

	}

}

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

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

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

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

	/**
	 * 入栈
	 * @param value
	 */
	public void push(int value) {
		if (isFull()) {
			System.out.println("栈满");
			return;
		}
		top++;
		stack[top] = value;
	}

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

	/**
	 * 显示栈的情况，遍历时需要从栈顶开始显示数据
	 */
	public void list() {
		if (isEmpty()) {
			System.out.println("栈空");
			return;
		}
		for (int i = top; i >= 0; i--) {
			System.out.printf("stack[%d]= %d\n", i,stack[i]);
		}

	}
}
2、用单链表模拟栈
public class LinkedStackDemo {

	public static void main(String[] args) {
		LinkedStack stack = new LinkedStack(5);
		String key = "";
		boolean loop = true;//用于控制是否退出
		Scanner scanner = new Scanner(System.in);
		while (loop){
			System.out.println("show:表示显示栈");
			System.out.println("exit:退出程序");
			System.out.println("push:表示添加元素到栈(入栈)");
			System.out.println("pop:表示从栈取出数据(出栈)");

			System.out.println("请输入你的选择:");
			key = scanner.next();

			switch (key){
			case "show":
				stack.show();
				break;
			case "exit":
				scanner.close();
				loop = false;
				break;
			case "push":
				System.out.println("请输入一个数字");
				int i = scanner.nextInt();
				stack.push(i);
				break;
			case "pop":
				try{
					int pop = stack.pop();
					System.out.println("出栈的数据:"+pop);
				} catch (Exception e){
					System.out.println(e.getMessage());
				}
				break;
			default:
				break;
			}

		}
		System.out.println("程序退出~~");
	}
}

class LinkedStack{
	private int maxSize;
	private LinkedStackNode head;
	private int top = -1;

	public LinkedStack(int maxSize) {
		this.maxSize = maxSize;
	}

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

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

	/**
	 * 入栈
	 * @param value
	 */
	public void push(int value) {
		//1、判断栈是否满了
		if (isFull()) {
			System.out.println("栈满");
			return;
		}
		//2、新创建一个节点，用于添加到链表上
		LinkedStackNode node = new LinkedStackNode(value);

		//3、将top++,表示链表中的元素新增了一个
		top++;
		//4、判断头元素是否为null,如果是null,代表是第一个元素,则直接让新元素当第一个元素
		if (head == null) {
			head = node;
			return;
		}
		//5.如果头元素不是null,则证明，此时链表中已经有元素，则将新元素添加上即可
		//5.1获取到链表的尾部
		LinkedStackNode temp = head;
		while (temp.getNext() != null) {
			temp = temp.getNext();
		}
		//5.2将链表添加上去
		temp.setNext(node);
	}

	/**
	 * 出栈
	 * @return
	 */
	public int pop() {
		//1.判断栈是否为null
		if (isEmpty()) {
			throw new RuntimeException("栈空");
		}
		//2.将链表的数量减一
		top--;
		//3.如果链表中是否只有一个元素
		if (head.getNext() == null) {
			LinkedStackNode popNode = head;
			head = null;
			return popNode.getNo();
		}
		//4.如果链表中有不只一个元素
		//4.1.定义一个中间变量，让他指向链表的最后一个元素，即最后要出栈的元素
		LinkedStackNode lastNode = head;
		//4.2.定义一个中间变量，用来获取到lastNode的前一个元素
		//因为是单向链表，出栈后，要置空指向最后一个元素的指针，所以需要找到最后一个元素的前一个元素进行操作
		LinkedStackNode beforeLastNode = null;
		while (lastNode.getNext() != null) {
			//将lastNode给到beforeLastNode
			//然后lastNode向后移动
			//此时就构造出 beforeLastNode在lastNode前一个位置的情况
			beforeLastNode = lastNode;
			lastNode = lastNode.getNext();
		}
		//4.3.此时将最后一个元素的前一个元素的next指针变成null,则相当于舍弃掉了最后一个元素
		beforeLastNode.setNext(null);
		//4.3.返回lastNode的编号
		return lastNode.getNo();
	}

	public void show() {
		//判断栈是否为null
		if (isEmpty()) {
			System.out.println("栈空");
			return;
		}
		//定义一个新的链表节点
		LinkedStackNode newLinkedStackHead = null;

		//正向遍历原始链表，将链表的每一个元素，都放到新的链表的第一个元素
		//因为前面做了判断，所以head不可能为null
		LinkedStackNode oldLinkedStackNode = head;
		while (oldLinkedStackNode != null) {
			LinkedStackNode middleNode =  new LinkedStackNode(oldLinkedStackNode.getNo());

			if (newLinkedStackHead == null) {
				newLinkedStackHead = middleNode;
			}else {
				middleNode.setNext(newLinkedStackHead);
				newLinkedStackHead = middleNode;
			}
			oldLinkedStackNode = oldLinkedStackNode.getNext();
		}

		while (newLinkedStackHead != null) {
			System.out.println(newLinkedStackHead.getNo());
			newLinkedStackHead = newLinkedStackHead.getNext();
		}

	}
}

class LinkedStackNode{
	private int no;
	private LinkedStackNode next;

	public LinkedStackNode(int no) {
		this.no = no;
	}

	public int getNo() {
		return no;
	}
	public void setNo(int no) {
		this.no = no;
	}
	public LinkedStackNode getNext() {
		return next;
	}
	public void setNext(LinkedStackNode next) {
		this.next = next;
	}

}

用栈实现计算器（中缀表达式）

1、思路分析

在这里插入图片描述
1）初始化两个栈，一个【数栈】和一个【符号栈】
2）通过一个index值（索引），来遍历我们的表达式
3）如果发现是一个数字，就直接入【数栈】
4）如果发现是一个运算符，就分情况讨论：
（4.1）如果当前的【符号栈】为空，那就直接入栈
（4.2）如果当前的【符号栈】有操作符，就进行比较
（4.2.1）【当前的操作符】的优先级 <= 【符号栈中操作符】的优先级，就需要从【数栈】中pop出两个数，再从【符号栈】中pop出一个符号，然后进行运算，将得到结果入【数栈】，再递归调用步骤3
（4.2.2）【当前的操作符】的优先级 > 【符号栈中操作符】的优先级，就直接入符号栈
5）当表达式扫描完毕，就顺序的从【数栈】和【符号栈】中pop相应的数和符号，并运算
6）最后【数栈】中只有一个数字就是表达式的结果

2、代码实现
public class Calculator {
	public static void main(String[] args) {
			//
		String expression = "3+2*6-2";
		//创建两个栈  数栈和符号栈
		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
		
		//开始while循环扫描expression
		while (true) {
			//依次得到expression的每一个字符
			ch = expression.substring(index,index + 1).charAt(0);
			if (operStack.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 {
				//如果是数字，直接入数栈   
				//注意 ch是字符 转成int 要-48
				//numStack.push(ch - 48);//这里存在多位数计算不正确的问题
				
				//1、当处理多位数是，不能发现是一个数字就立即入栈，有可能是多位数
				//2、在处理数时，需要向expression的表达式index后面再看一位，如果是数就进行扫描，如果是符号才入栈
				//3、定义一个变量，用于拼接
				//处理多位数
				keepNum += ch;
				//如果ch是expression最后一位
				if (index == expression.length() -1) {
					numStack.push(Integer.parseInt(keepNum));
				}else {
					//判断下一个字符是不是数字,如果是数字就继续扫描，如果是运算符则入栈
					if (operStack.isOper(expression.substring(index + 1,index + 2).charAt(0))) {
						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.printf("表达式：%s = %d",expression,numStack.pop());
	}

}
class ArrayStack2{
	// 栈的大小
	private int maxSize;
	//数组模拟栈，数据就放在该数组
	private int[] stack;
	//top表示栈顶，初始化为-1
	private int top = -1;

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

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

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

	/**
	 * 入栈
	 * @param value
	 */
	public void push(int value) {
		if (isFull()) {
			System.out.println("栈满");
			return;
		}
		top++;
		stack[top] = value;
	}

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

	/**
	 * 显示栈的情况，遍历时需要从栈顶开始显示数据
	 */
	public void list() {
		if (isEmpty()) {
			System.out.println("栈空");
			return;
		}
		for (int i = top; i >= 0; i--) {
			System.out.printf("stack[%d]= %d\n", i,stack[i]);
		}

	}
	/**
	 * 返回当前栈顶的值，不是出栈
	 */
	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 value) {
		return value =='+'|| value =='-'||value =='*'||value =='/';
	}
	
	/**
	 * 计算方法
	 */
	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;
	}
}

缺陷：
1、没有考虑小数
2、没有考虑小括号

前缀、中缀、后缀表达式

1、前缀表达式
1.1、前缀表达式（波兰表达式）
  • 前缀表达式又称波兰式，前缀表达式的运算符位于操作数之前
  • 举例说明：(3+4)*5-6 对应的前缀表达式就是 - * + 3 4 5 6
1.2、前缀表达式的计算机求值

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

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

  • 从右至左扫描，将6、5、4、3压入堆栈
  • 遇到+运算符，因此弹出3和4（3为栈顶元素，4为次顶元素），计算出3+4的值，得7，再将7入栈
  • 接下来是×运算符，因此弹出7和5，计算出7×5=35，将35入栈
  • 最后是-运算符，计算出35-6的值，即29，由此得出最终结果
2、中缀表达式
  • 中缀表达式就是常见的运算表达式，如(3+4)*5-6
  • 中缀表达式的求值是平常最为熟悉的，但是对计算机说却不好操作（前面我们将的案例就能看出这个问题，）因此，在计算结束时，往往会将中缀表达式转成其它表达式来操作（一般是转成后缀表达式）
3、后缀表达式
  • 后缀表达式又称逆波兰表达式,与前缀表达式相似，只是运算符位于操作数之后
  • 举例说明： (3+4)×5-6 对应的后缀表达式就是 3 4 + 5 × 6 –
4、后缀表达式的计算机求值

从左至右扫描表达式，遇到数字时，将数字压入栈，遇到运算符时，弹出栈顶的两个数，用运算符对它们做相应的计算（次顶元素 和 栈顶元素），并将结果入栈；重复上述过程直到表达式最右端，最后运算得出的值即为表达式的结果。
例如: (3+4)×5-6 对应的后缀表达式就是 3 4 + 5 × 6 - , 针对后缀表达式求值步骤如下:

  • 从左至右扫描，将3和4压入栈
  • 遇到+运算符，因此弹出4和3（4为栈顶元素，3为次顶元素），计算出3+4的值，得7，再将7入栈
  • 将5入栈
  • 接下来是×运算符，因此弹出5和7，计算出7×5=35，将35入栈
  • 将6入栈
  • 最后是-运算符，计算出35-6的值，即29，由此得出最终结果
5、逆波兰计算器
  • 输入一个逆波兰表达式(后缀表达式)，使用栈(Stack), 计算其结果
  • 支持小括号和多位数整数，因为这里我们主要讲的是数据结构，因此计算器进行简化，只支持对整数的计算。
  • 代码实现：
public class PolandNotation {

	public static void main(String[] args) {
		// 定义一个逆波兰表达式
		// (3+4)*5-6 => 3 4 + 5 * 6 -
		String suffixExpression = "3 4 + 5 * 6 -";
		// 先将3 4 + 5 * 6 - 放入一个链表ArrayList中，配合栈完成计算
		List<String> list = getListString(suffixExpression);

		int result = calculate(list);
		System.out.println(result + "");
	}

	/**
	 * 将逆波兰表达式的数据和运算符依次放到ArrayList中
	 * 
	 * @param suffixExpression 逆波兰表达式
	 * @return 链表
	 */
	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;

	}

	/**
	 * 计算逆波兰表达式最终结果
	 * 
	 * @param stringList 数据和运算符链表
	 * @return 计算结果
	 */
	public static int calculate(List<String> list) {
		Stack<String> stack = new Stack<String>();
		for (String item : list) {
			// 使用正则表达式来取出数，匹配多位数
			if (item.matches("\\d+")) {
				stack.push(item);
			} else {
				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("运算符错误");
				}
				stack.push(res + "");
			}
		}
		return Integer.parseInt(stack.pop());
	}

}
5、中缀表达式转后缀表达式

后缀表达式适合计算式进行运算，但是人却不太容易写出来，尤其是表达式很长的情况下，因此在开发中，我们需要将 中缀表达式转成后缀表达式。
具体步骤如下:

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

	public static void main(String[] args) {
		// 完成一个中缀表达式转成后缀表达式的功能
		// 1. 1+((2+3)*4)-5 => 1 2 3 + 4 * + 5 -
		// 2. 因为直接对str进行操作不方便，因此先将中缀表达式对应的list 
		// 即1+((2+3)*4)-5 => [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);
		
		List<String> parseSuffixExpressionList = parseSuffixExpressionList(infixExpressionList);
		System.out.println("后缀表达式对应的list:" + parseSuffixExpressionList);
		
		int result = calculate(parseSuffixExpressionList);
		System.out.println("计算结果：" + result);
	}
	
	/**
	 * 將中缀表达式转成后缀表达式对应的list
	 * @param ls
	 * @return
	 */
	public static List<String> parseSuffixExpressionList(List<String> ls) {
		Stack<String> s1 = new Stack<String>(); //符号栈
		//说明：因为s2这个栈，在整个转换过程中，没有pop操作，而且后面我们还需要逆序输出
		//因此比较麻烦，这里就不用Stack<String>，直接使用ArrayList s2
//		Stack<String> s2 = new Stack<String>();
		
		List<String> s2 = new ArrayList<String>();
		for (String item : ls) {
			if (item.matches("\\d+")) {
				s2.add(item);
			}else if (item.equals("(")) {
				s1.push(item);
			}else if (item.equals(")")) {
				while (!s1.peek().equals("(")) {
					s2.add(s1.pop());
				}
				s1.pop();//!!!将"("小括号弹出
			}else {
				//当item的优先级小于等于栈顶运算符,将s1栈顶的运算符弹出并压入到s2中
				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
	 * @param s
	 * @return
	 */
	public static List<String> toInfixExpressionList(String s) {
		// 定义一个list 存放中缀表达式对应的list
		List<String> list = new ArrayList<String>();
		int i = 0;// 这是一个指针，用于遍历中缀表达式
		String str;// 对多位数的拼接
		char c;// 每遍历一个字符 就放入到ch
		do {
			// 如果c是一个非数字，需要加入到list
			if ((c = s.charAt(i)) < 48 || (c = s.charAt(i)) > 57) {
				list.add(c + "");
				i++;
			}else {
				//考虑多位数的问题
				str = "";
				while (i< s.length() && (c = s.charAt(i))>= 48 && (c = s.charAt(i))<= 57) {
					str +=c;
					i++;
				}
				list.add(str);
			}
		} while (i < s.length());
		return list;

	}

	/**
	 * 计算逆波兰表达式最终结果
	 * 
	 * @param stringList 数据和运算符链表
	 * @return 计算结果
	 */
	public static int calculate(List<String> list) {
		Stack<String> stack = new Stack<String>();
		for (String item : list) {
			// 使用正则表达式来取出数，匹配多位数
			if (item.matches("\\d+")) {
				stack.push(item);
			} else {
				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("运算符错误");
				}
				stack.push(res + "");
			}
		}
		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;
	}
	
}
6、逆波兰计算器(完整版)
  • 支持 + - * / ( )
  • 多位数，支持小数
  • 兼容处理, 过滤任何空白字符，包括空格、制表符、换页符
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();
        }
    }

}
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值