数据结构&算法--04栈的使用及实际应用-前缀、中缀、后缀表达式（逆波兰表达式）

最新推荐文章于 2024-10-16 12:19:08 发布
最新推荐文章于 2024-10-16 12:19:08 发布
阅读量146 收藏 1
点赞数
分类专栏： 数据结构与算法 文章标签： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44389456/article/details/104366491
版权

程序 = 数据结构 + 算法
数据结构分类：

  1. 线性结构：数组，队列，栈，链表
  2. 非线性结构：二维数组，多维数组，广义表，树结构，图结构

什么是栈（stack）

  1. 栈是后**先入后出（FIFO-first in last out）**的有序列表
  2. 栈是限制线性表中元素的插入和删除只能在线性表中的同一端进行的一种特殊线性表
  3. 栈顶：变化的一端（Top）
  4. 栈底：固定的一端（Bottom）

    在这里插入图片描述
    在这里插入图片描述
实现栈的思路分析
  1. 使用数组来模拟栈
  2. 定义一个 top 来表示栈顶，初始化 为 -1
  3. 入栈的操作，当有数据加入到栈时， top++; stack[top] = data;
  4. 出栈的操作， int value = stack[top]; top–, return value
示例代码：
public class ArrayStackDemo {
	
	public static void main(String[] args) {
		// 测试
		// 先创建一个栈对象
		ArrayStack stack = new ArrayStack(4);
		String key = "";
		boolean loop = true;	// 控制是否退出菜单
		Scanner scan = new Scanner(System.in);
		while(loop) {
			System.out.println("show:显示栈");
			System.out.println("push:入栈");
			System.out.println("pop:出栈");
			System.out.println("exit:退出");
			System.out.println("请输入你的选择");
			key = scan.next();
			switch(key) {
			case "show":
				stack.list();
				break;
			case "push":
				System.out.println("请输入一个数");
				int value = scan.nextInt();
				stack.push(value);
				break;
			case "pop":
				try {
					int res = stack.pop();
					System.out.println("出栈的数据是：" + res);
				} catch (Exception e) {
					System.out.println(e.getMessage());
				}
				break;
			case "exit":
				scan.close();
				loop = false;
				break;
			default:
					break;
			}
		}
		System.out.println("程序已退出");
	}
	
}

class ArrayStack{
	private int maxSize;	// 栈的大小
	private int[] stack;	// 数组，数组模拟栈，数据接放在该数组
	private int top = -1;	// top 表示栈顶，初始值为-1
	public ArrayStack(int maxSize) {
		super();
		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("栈满");
			return ;
		}
		top++;
		stack[top] = value;
	}
	//出栈-pop, 将栈顶的数据返回
	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]);
		}
	}
}

栈的实际使用

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

3+2*6-2  
30+2*6-2 
7*2*2-5+1-5+3-4
思路图示：

在这里插入图片描述

代码实现：
public class Calculator {
	
	public static void main(String[] args) {
		
		String expression = "70+2*6-2";
		// 创建两个栈，数栈，符号栈
		ArrayStack2 numStack2 = new ArrayStack2(10);
		ArrayStack2 operStack2 = 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(operStack2.isOper(ch)) {	// 如果是运算符
				// 判断当前符号栈是否为空
				if(!operStack2.isEmpty()) {
					// 如果符号栈有操作符，就进行比较，如果当前的操作符的优先级小于或等于栈中的操作符 就需要从数栈中pop出两个数,
					// 在从符号栈中pop出一个符号，进行运算，将得到结果，入数栈，然后将当前的操作符入符号栈， 如果当前的操作符的优先级大于栈中的操作符， 就直接入符号栈.
					if(operStack2.priority(ch) <= operStack2.priority(operStack2.peak())) {
						// 从数栈pop 出两个数
						num1 = numStack2.pop();
						num2 = numStack2.pop();
						oper = operStack2.pop();
						res = numStack2.cal(num1, num2, oper);
						// 把运算的结果入数栈
						numStack2.push(res);
						// 然后将当前的操作符入符号栈
						operStack2.push(ch);
					}else {
						// 如果当前的操作符的优先级大于栈中的操作符，就直接入符号栈
						operStack2.push(ch);
					}
				}else {
					// 如果为空直接入栈 
					operStack2.push(ch);	// 1 + 3
				}
			}else {	// 如果是数，则直接入数栈
//				numStack2.push(ch - 48);
				// 1.当处理多位数时，不能发现是一个数就直接入栈，因为可能是多位数
				// 2.在处理数时，需要向expression的表达式的index 后再看一位，如果是符号则入栈
				// 3.因此我们需要定义一个变量字符串用于拼接
				
				// 处理多位数
				keepNum += ch;
				
				// 如果ch 已经是expression的最后一位，就直接入栈
				if(index == expression.length()-1) {
					numStack2.push(Integer.parseInt(keepNum));
				}else {
					// 判断下一个字符是不是数字，如果是数字，则继续扫描， 如果是运算符，则入栈
					// 注：只是看后一位， 不是index++
					if(operStack2.isOper(expression.substring(index+1, index+2).charAt(0))) {
						// 如果后一位是运算符，则入栈 keepNum="1", 或“123”
						numStack2.push(Integer.parseInt(keepNum));
						// 重要的， keepNum清空
						keepNum = "";
					}
				}
			}
			// 让index+1, 并判断是否扫描到expression最后
			index++;
			if(index >= expression.length()) {
				break;
			}
		}
		// 当表达式扫描完毕，就顺序的从 数栈和符号栈中pop出相应的数和符号，并运行
		while(true) {
			// 如果符号栈为空，则计算到最后的结果，数栈中只有一个数字
			if(operStack2.isEmpty()) {
				break;
			}
			num1 = numStack2.pop();
			num2 = numStack2.pop();
			oper = operStack2.pop();
			res = numStack2.cal(num1, num2, oper);
			numStack2.push(res); // 入栈
		}
		// 将数栈的最后数，pop出， 就是结果
		int res2 = numStack2.pop();
		System.out.printf("表达式:%s = %d", expression, res2);
	}
	
}

// 先创建一个栈
class ArrayStack2{
	private int maxSize;	// 栈的大小
	private int[] stack;	// 数组，数组模拟栈，数据接放在该数组
	private int top = -1;	// top 表示栈顶，初始值为-1
	// 构造器
	public ArrayStack2(int maxSize) {
		super();
		this.maxSize = maxSize;
		stack = new int[this.maxSize];	// 数组需初始化才能向里面放数据
	}
	// 增加一个方法，可以返回当前栈顶的值，但是不是真正pop
	public int peak() {
		return stack[top];
	}
	
	// 栈满
	public boolean isFull() {
		return top == maxSize-1;
	}
	// 栈空
	public boolean isEmpty() {
		return top == -1;
	}
	// 入栈
	public void push(int value) {
		// 先判断栈是否满
		if(isFull()) {
			System.out.println("栈满");
			return ;
		}
		top++;
		stack[top] = value;
	}
	//出栈-pop, 将栈顶的数据返回
	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 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;	// 用于存放计算的结果
		switch (oper) {
		case '+':
			res = num1 + num2;
			break;
		case '-':
			res = num2 - num1;
			break;
		case '*':
			res = num1 * num2;
			break;
		case '/':
			res = num1/num2;
			break;
		default:
			break;
		}
		return res;
	}
}

前缀、中缀、后缀表达式

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

天涯海角寻寻觅
关注
专栏目录
【数据结构】栈的两个典型应用
Shawn's Redemption
11-06 519
求1位数的四则运算，用括号来控制优先级 比如如果是（1+2）* 3 / 4
栈的数据的--新增、删除、输出
那时初见 的专栏
05-16 548
栈的数据的–新增、删除、输出#include<stdio.h> #include<stdlib.h> #include<conio.h>#define MAX 100 void push_f(void); //入栈函数 void pop_f(void); //出栈函数 void list_f(void); //输出函数char item[MAX][2
数据结构（二）——栈
weixin_43732570的博客
11-20 302
一、什么是栈？ 说的术语一点就是一种只能在一端进行插入和删除操作的线性表，可以用数组实现也可以用链表实现。说的白话一点，栈就像一个玻璃杯，只有一个杯口可以进水，倒水的时候，水也是从唯一的杯口倒出。而且后来倒入的水在上面会先倒出去。 二、实现的基本操作 // 将数据入栈 // 弹出栈顶数据 // 访问栈顶数据 // 判断栈是否为空 // 扩大栈容量 // 显示栈内元素 三、数组实现栈： // 初...
栈的入栈，出栈，扩容，获取长度等操作
weixin_43854256的博客
05-18 1770
创建stack.h #pragma once //栈：一种访问受限的线性表，只能在一端进行数据操作，能操作 //顺序栈，栈顶设计在顺序表的表尾处，因为顺序表尾插和尾删都是O（1） #define INIT_SIZE 10 typedef struct SeqStack { int *elem;//保存动态内存的地址，用于存放栈数据 int top;//栈顶指针，当前可以存放数据的下标，类似顺序表的有效数据个数 int stacksize;//栈容量 }SeqStack,*PSeqStack; /
数据结构之栈
xiaotai1234的博客
09-29 303
数据结构之栈 一、概述 二、栈的应用场景 三、数组模拟栈 package com.atguigu.stack; import java.util.Scanner; public class ArrayStackDemo { public static void main(String[] args) { //测试一下ArrayStack 是否正确 //先创建一个ArrayStack对象->表示栈 ArrayStack stack = new ArrayStack(4);
数据结构与算法--Python栈 栈实现综合计算器和逆波兰计算器 前缀表达式 中缀表达式 后缀表达式 逆波兰表达式
storyfull
12-19 1107
Python栈 栈实现综合计算器和逆波兰计算器
前缀表达式、中缀表达式和后缀表达式 - 乘月归 - 博客园.pdf
03-15
前缀表达式、中缀表达式和后缀表达式是编程中常见的三种表达式表示方法，它们在计算机程序设计和算法中扮演着重要的角色。中缀表达式是最常见的一种，例如在普通的算术运算中就广泛使用。而后缀表达式和前缀表达式则...
数据结构与算法day10-栈的运用之前缀表达式、中缀表达式、后缀表达式(逆波兰表达式)
深耕java的博客
12-20 366
前缀表达式(波兰表达式) 1.前缀表达式又称波兰式，前缀表达式的运算符号位于操作数之前 2.举例说明：(3+4)x5-6这个中缀对应的前缀表达式就是 - x + 3 4 5 6 前缀表达式的计算机求值： 从右至左扫描表达式，遇到数字时，将数字压如堆栈，遇到运算符时，弹出栈顶的 两个数，用运算符对他们做相应的计算(栈顶元素和次顶元素)，并将结果入栈，重复 上述过程直到表达式最左端，最后运算得出的值即为表达式的结果 例如：(3+4)x5-6对应的前缀表达式就是 - x + 3 4 5 6 1
中缀表达式转换为后缀表达式及逆波兰式求值
01-10
后缀表达式在计算和解析上更为高效，尤其是通过栈数据结构进行求值。 **中缀表达式转后缀表达式**： 这个过程通常涉及到一个称为“操作符栈”的数据结构。遍历中缀表达式的每个字符，如果遇到操作数，则直接输出；...
数据结构之链栈的基本操作（出栈，入栈，显示，求栈的长度）
weixin_30815469的博客
03-22 2699
//将12345依次入栈，取栈顶元素，将6，7入栈，求栈中元素个数，将7出栈，将6出栈，将5出栈，最后全部出栈依次输出 #include<iostream>#include<stdio.h>#include<malloc.h>#include<stdlib.h>#define maxsize 100using namespace ...
算法-栈的出栈个数
Vivinia的博客
03-18 2542
import java.math.BigInteger; /** 问题描述： n个元素的出栈次序 f(n)=f(0)*f(n-1)+f(1)*f(n-2)...+f(n-2)*f(1)+f(n-1)*f(0) 输出样例： 0:1 1:1 2:2 3:5 4:14 5:42 6:132 7:429 8:1430 9:4862 10:16796 11:58786 12:208012 13:742
数据结构复习：堆栈
CrownP的博客
03-15 1524
1、堆栈的抽象数据类型描述 堆栈(Stack)：具有一定操作约束的线性表。只在一端（栈顶，Top）做插入、删除 插入数据：入栈（push） 删除数据：出栈（pop） 后入先出：Last In First Out（LIFO） 数据对象集：一个有0个或多个元素的有穷线性表 操作集：长度为MaxSize的堆栈S属于Stack，堆栈元素item属于ElementType Stack Creat...
线性数据结构和非线性数据结构（java版）
xiaoxiao66668的博客
11-06 1174
线性数据结构和非线性数据结构 数据结构包括 线性数据结构 和 非线性数据结构。 数据结构 线性数据结构作为最常用的数据结构，其特点是数据元素之间存在一对一的线性关系。 线性结构有两种不同的存储结构，即顺序存储结构和链式存储结构。顺序存储的线性表称为 顺序表，顺序表中的存储元素是连续的。 链式存储的线性表称为 链表，链表中的存储元素不一定是连续的，元素结点中存放数据元素以及相邻元素的地址信息。 线性结构常有：数组，队列，链表和栈。 非线性结构 非线性结构包括：二维数组，多维数组，广义表，树结构，图结构。
数据结构与算法-栈
咏樟的博客
08-06 137
数据结构与算法-栈栈介绍应用场景用数组模拟栈思路分析代码实现用链表模拟栈思路分析代码实现 栈 介绍 栈是一个先入后出（FILO-First In Last Out）的有序列表。 栈（stack）是限制线性表中元素的插入和删除只能在线性表的同一端进行的一种特殊线性表。允许插入和删除的一端，为变化的一段，称为栈顶（top），另一端为固定的一端，称为栈底（bottom）。 最先放入栈中的元素在栈底，最后放入的元素在栈顶，而删除元素刚好相反，最后放入的元素最先删除，最先放入的元素最后删除。 入栈push 出栈
【数据结构】时间复杂度与空间复杂度
最新发布
qq_53706413的博客
10-16 1198
本篇博客我们进入了数据结构的世界，详细介绍了时间复杂度和空间复杂度，通过几个例子加深了我们对时间复杂度空间复杂度的理解。
数据结构-5.9.树的存储结构
ADCvbV的博客
10-15 901
上述图片增加一个结点M在结点H下，顺序存储在第12个位置即数组下标为11，结点M的父结点为H，结点H在数组中下标为7，因此结点M的结点指针parent为7：此时数组中数据元素的排列顺序表面像是层序规则排列，但在插入新结点时并不需要遵守层序的规则即不需要同一层中必须先从最左边添加，然后依次添加到最右边，而是可以随意添加在某个结点下，比如再插入一个L结点在E结点下：比如删除G结点，有两种方案：方案一：把G结点的双亲指针改为-1(因为双亲指针的值就是对应结点的父结点在数组中的位置，此时G结点不存在了，即在该树中没
82.【C语言】数据结构之顺序表的初始化和销毁
2401_85828611的博客
10-15 596
在软件开发中,存储列表常用顺序表或链表。定义:n个具有相同特性的数据元素的有限序列(相当于一条直线)(用数组存储),要求数据依次存储静态顺序表：使用定长数组存储元素动态顺序表:使用与动态内存管理有关的函数
Java实现：前缀-中缀-后缀表达式转换及求值详解
总结来说，本篇文章涵盖了前缀、中缀和后缀表达式的概念、特点、求值方法以及它们在计算机编程中的实际应用，特别是如何通过数据结构（如栈）来实现高效的算法。这对于理解和处理复杂的数学计算问题，尤其是在Java...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值