栈的应用，中缀表达式转后缀，迷宫回朔，递归，八皇后问题

最新推荐文章于 2022-07-06 13:00:50 发布
最新推荐文章于 2022-07-06 13:00:50 发布
阅读量2.3k 收藏 1
点赞数
文章标签： java 数据结构 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45750255/article/details/108922165
版权

栈

栈的介绍：

补充：线性表：数据逻辑结构是线性的，但物理结构不一定是线性的，所以线性表有顺序表和链式表的区别。

Stack

  1. 栈是一个先入后出(FILO)的有序列表
  2. 栈是限制线性表中元素的出入和删除只能在线性表的同一端进行操作的一种特殊线性表，允许插入和删除的一端为变化的一端，称为栈顶(Top)，另一端为固定的一端，称为栈底(Bottom)
  3. 最先放入的元素在栈底，最后放入的元素在栈底。入栈push，出栈pop

栈的应用场景:

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

2.处理递归调用：在存储下一条指令的地址的时候，还存储了参数，区域变量等数据存入堆栈中

3.表达式的转换【中缀表达式转后缀表达式】与求值

4.二叉树的遍历

5.图形的深度优先遍历(depth-first)搜索法

用数组模拟栈代码实现：

这个比较简单，基本赏识知道就行

package stack;

public class ArrayStackDemo {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		ArrayStack arrayStack = new ArrayStack(3);
		arrayStack.push(1);
		arrayStack.push(2);
		arrayStack.push(3);
		arrayStack.list();

	}


}
//数组模拟栈
class ArrayStack {
	public int size;
	public int[] stack;
	public int top=-1;
	public ArrayStack(int size) {
		this.size=size;
	    stack=new int[size];
		
	}
	//判断栈是否为空
	public boolean isEmpty() {
		return top==-1;
	}
	//判断栈是否满了
	public boolean isFull() {
		return top==size-1;
	}
	
	//添加数据到栈
	public void push(int data) {
		if(isFull()) {
		System.out.println("栈已经满了，不能添加数据了");
		return;}
		   top++;
		   stack[top]=data;
	}
	//出栈
	public int pop() {
		int data=0;
		if(isEmpty()) {
			System.out.println("栈是空的");
			throw new RuntimeException();
		}
		data=stack[top];
		top--;
		return data;
		
	}
	//展示栈中的数据
	public void list() {
		if(isEmpty()) {
			System.out.println("栈中没有数据");
			return;
		}
		for(int i=top;i>=0;i--) {
			System.out.println(stack[i]);
		}
	}
	   
	
}

用链表来模拟栈:

思路：用的头插法，即新添加进来的元素是头，这样的话就很好将top指针和head指针用同一个表示，遍历和去数据的时候也很方便。

//链表来模拟栈
class ListStack{
   public LinkNode top;
   //栈空
   public boolean isEmpty() {
	   return top==null; 
   }
   //线性表可以不断的增加，因此无须判断栈满的情况
   //入栈,采用头插法，这样链表头指针和栈的top指针，可以代表同一个意思，是不是很巧妙，否则，top指针可能并不需要
	public void push(LinkNode node) {
		//第一次插入栈底元素，不需要为top当前指定的元素指定一个节点，因为top此时为null,会报空指针异常的
		if(isEmpty()) {
				top=node;
		}else {
			//新添加的元素为头节点
			node.next=top;
			top=node;
			
		}
	}
	//出栈
	public int pop(LinkNode node) {
		if(isEmpty()) {
			throw new RuntimeException("当前栈内没有数据");
		}
		//头指针下移,要出栈的元素进行剔除
		int data=top.no;
		 top.next=null;
         top=top.next;	
		return data;
		
	}
	//展示栈内数据
	public void list() {
		if(isEmpty()) {	
			throw new RuntimeException("当前栈内没有数据");}

		LinkNode cur=top;
		while(cur!=null) {
			System.out.println(cur.no);
		   cur=cur.next;	
		}
		
	}
	
	
}
class LinkNode{
	LinkNode(int no){
		this.no=no;
		
	}
	public int no;
	public LinkNode next;
}

栈的应用场景

  1. 计算表达式

思路：利用两个栈，一个用来存放数字，一个用来存放操作符，在入符号栈如果遇到当前操作符小于等于栈顶的元素，进行一次运算，即数字栈弹出两个数字，操作栈弹出一个操作符，再将结果入栈，但是因为栈是先进后出的，要注意- 和/的时候的顺序，思路挺简单，就是循环多，这里的表达式是一个中缀表达式：

package stack;

import java.util.Stack;

public class CalculateStack {
	
	public static void main(String[] args) {
		//数字栈
		Stack numStack = new Stack();
		//符号栈
		Stack operStack=new Stack();
		//定义一个表达式
		String expression="300+2*6-1";
		//遍历用的
		int index=0;
		int num1=0;
		int num2=0;
		char oper=0;
		int result=0;
		String numMore="";
		//用来存放临时扫描的临时变量
		char ch=' ';
		while(true) {
			ch=expression.substring(index, index+1).charAt(0);
			if(isOper(ch)) {
				//如果栈是空的
				if(operStack.isEmpty()) {
					operStack.push(ch);
				}else{
					//比较优先级
					if(getPrority(ch)<=getPrority((char)operStack.peek())) {
						num1 = (int)numStack.pop();
						num2=(int)numStack.pop();
						oper=(char)operStack.pop();
						result = calculate(num1, num2, oper);
						//将结果入栈，并且将当前遍历到的操作符也入栈
						numStack.push(result);
						operStack.push(ch);
						
					}else {
						operStack.push(ch);
					}
					  
				}
			}else {
				numMore+=ch;
				//如果ch是最后一位了，会引起数组越界异常
				if(index==expression.length()-1) {
					numStack.push(Integer.parseInt(numMore));
				}else {
				//如果是多位数的解决方案，看下一位是不是符号位，是的话，进行拼接,如果下一位还是数字，继续拼接,即继续执行numMore+=ch
				if(isOper(expression.substring(index+1, index+2).charAt(0))) {
					numStack.push(Integer.parseInt(numMore));
					numMore="";
				}

				}

			}
			//index+1,判断是否扫描到最后
			index++;
			if(index>=expression.length()) {
				break;
			}
		}
		//栈内剩余的数据进行顺序操作
		while(true) {
			//如果符号栈为空,则计算到最后的结果了,数栈中只有一个数字,
			if(operStack.isEmpty()) {
				break;
			}
			num1=(int)numStack.pop();
			num2=(int)numStack.pop();
			oper=(char)operStack.pop();
			result=calculate(num1, num2, oper);
			numStack.push(result);

		}
		System.out.printf("表达式："+expression+"=%d\n",numStack.pop());
	}
	
	//判断是不是运算符的优先级
	public static int getPrority(char oper) {
		 if(oper=='*'||oper=='/') {
			 return 1;
		 }
		 
		 else if(oper=='+'||oper=='-'){
			 return 0; 
		 }
		 else {
			 return -1;
		 }
	}
	//判断是否是一个运算符
	public static  boolean isOper(char val) {
	  return val=='*'||val=='/'||val=='+'||val=='-';
	}
    //计算
	public static int calculate(int num1,int num2,char 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;
	}
}

逆波兰计算器：

后缀表达式：

从左到右扫描，遇到数字，讲数字压入堆栈，遇到运算符，弹出栈顶的两个数，用运算符对他们进行相应的运算，并讲结果入栈，重复过程直到到达表达式最右端。

package stack;

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

public class PrefixExpression {

	public static void main(String[] args) {
	  //给定波兰表达式(3+4)*5-6=>3 4 + 5 * 6 -
		String suffixExpression="3 4 + 5 * 6 - ";
		List<String>rpnlist=new ArrayList<String>();
		String[] split = suffixExpression.split(" ");
		for(String s:split) {
			rpnlist.add(s);
		}
		System.out.println(caculate(rpnlist));
			
	}
	public static int caculate(List<String> list) {
		String prefixExpression="";
		Stack<String> stack=new Stack<String>();
		for(String s:list) {
			//如果匹配的是多位数，这里利用了正则，需要了解的看我的博客:https://blog.csdn.net/qq_45750255/article/details/108912638
			if(s.matches("\\d+")) {
				stack.push(s);
			}else {
				int num1 = Integer.parseInt(stack.pop());
				int num2 = Integer.parseInt(stack.pop());
				int res=0;
				if(s.equals("+")) {
					res=num1+num2;
				}else if(s.equals("-")) {
					res=num2-num1;
				}else if(s.equals("*")) {
					res=num1*num2;
				}else if(s.equals("/")) {
					res=num2/num1;
				}else {
					throw new RuntimeException("你输入的符号不正确");
				}
				//把res入栈
				stack.push(""+res);
			}
		}
		return Integer.parseInt(stack.pop());
	}

}

中缀表达式转后缀表达式

思路：是死的，理解就好了，我认为就是把括号单独放出来作为一种情况来比较，几种操作符一种情况，遇到数是一种情况，借助中间栈和操作数栈不断地进行操作，直到操作数栈中没有数据。不要过于纠结原理，因为这是别人设计好的。

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

普通表达式转中缀：

public static List<String> toInfixExpression(String s){
		//定义一个List存放中缀表达式对应的内容
		List<String>ls=new ArrayList<String>();
		String  str="";
		char c;//存放每次遍历出来的字符的
		for(int i=0;i<s.length();) {
			//说明不是数字
		   if((c=s.charAt(i))<48||(c=s.charAt(i))>57){
			   ls.add(""+c);
			   i++;
		   }else {
				   //先将str置为空
				   str="";
				   while(i<s.length()&&(c=s.charAt(i))>=48&&(c=s.charAt(i))<=57) {
					   str+=c;
					   i++;
				   }
				   ls.add(str);
			   }
		   }
		   return ls;
		}

中缀转后缀：

//中缀转后缀	
	public static List<String> toSuffixExpression(List<String> ls){
		Stack<String> stack1=new Stack();//符号栈
		//因为第二个栈根本没有出栈的操作，还要逆序输出使用ArrayList()就可以了
		List<String> list1=new ArrayList<String>();
		//遍历ls
		for(String s:ls) {
			//如果是一个数，就加入
			if(s.matches("\\d+")) {
				list1.add(s);
			}else if(s.equals("(")){
				stack1.push(s);
			}else if(s.equals(")")) {
				while(!stack1.peek().equals("(")) {
					list1.add(stack1.pop());
				}
				stack1.pop();//弹出左括号
			}
			else {
				//当s的优先级小于等于栈顶的优先级
				while(stack1.size()!=0&&getPriority(stack1.peek())>=getPriority(s)) {
					list1.add(stack1.pop());
				}
				//讲s压入栈中
				stack1.push(s);
			}
		}
		//将stack1中剩余的运算符加入list
		while(stack1.size()>0) {
			list1.add(stack1.pop());
		}
		return list1;
	}  
    //比较优先级
	public static int getPriority(String operation) {
		int result=0;
		switch(operation) {
		case "+":
			result=1;break;
		case "-":
			result=1;break;
		case "*":
			result=2;break;
		case "/":
			result=2;break;
		default:
			System.out.println("不存在该运算符");
			break;
		}
		return result;
	}

递归：

以前没学好，现在又学，递归就是开辟了一个新栈调用原来的自己嘛，这样理解豁然开朗

递归调用原则很重要：

1.当程序执行到一个方法时，就会开辟一个独立的空间（栈）

2.每个空间的数据（局部变量），是独立的

迷宫回朔问题：

真的很精妙，尤其是那个回朔，1,2,3的含义，不说了，上代码：

package recursion;

public class MiGongProblem {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		int [][] map=new int[8][7];
		for(int i=0;i<8;i++) {
			map[i][0]=1;
			map[i][6]=1;
		}
		for(int j=0;j<7;j++) {
			map[0][j]=1;
			map[7][j]=1;
		}
		map[3][1]=1;
		map[3][2]=1;
		getWay(map, 1, 1);
		for(int i=0;i<8;i++) {
			for(int j=0;j<7;j++) {
				System.out.print(map[i][j]+" ");
			}
			System.out.println();
		}
	}
	public static boolean getWay(int[][] map,int i,int j) {
		//按照指定的策略去走，比如说下右上左
		if(map[6][5]==2) {
			//说明已经走通了
			return true;
		}else {
			if(map[i][j]==0) {
				//进行找路嘛,回朔，假定这条路能走
				map[i][j]=2;
				if(getWay(map,i+1,j)) {
					return true;
				}else if(getWay(map,i,j+1)) {
					return true;
				}else if(getWay(map,i-1,j)) {
					return true;
				}else if(getWay(map,i,j-1)) {
					return true;
				}else {
					//说明假定失败，没有一个能够走通
					map[i][j]=3;
					return false;
				}
			}else {
				//如果map[i][j]不为0,即为1,2,3
				//1是挡板，2是走过了，3是走不通
				return false;
			}
		}
	
	}

}

八皇后问题：（非常经典）

虽然代码很简单，但是我却有点看不懂，我太笨了，又看了一下午

不会的原因：没有深入理解递归和回朔的意义，仔细一想，代码明白了。其实理解了真的很容易

public void check(int n){
    if(n==maxsize){
        print();
        return;
    }
    for(int i=0;i<maxsize;i++){
        array[n]=i;
        if(judge(n)){
            check(n+1);
        }
    }
}
//判断第n个皇后和第n-1个皇后是否有冲突
public boolean judge(int n){
    for(int i=0;i<n;i++){
        if(array[i]==n||(Math.abs(n-i)==Math.ads(array[n]-array[i])){
            return false;
        }
    }
           return true;
    
}
//print打印八个皇后的位置
  public void print(){
      for(int i=0;i<maxsize;i++){
          System.out.printf(array[i]+" ");
      }
      System.out.println();
  }

下面是完整的代码：

package recursion;

public class QueueEightProblem {
	int maxsize=8;
	public  int array[]=new int[maxsize];

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		QueueEightProblem queue=new QueueEightProblem();
		queue.check(0);

	}

	public   void check(int n ) {
		if(n==maxsize) {
			print();
			return;
		}
		//依次放入,并判断是否冲突,注意，这里是放的列了
		for(int i=0;i<maxsize;i++) {
			//先把这个皇后n,放到该行的第0列
			array[n]=i;
			//判断当前放置第n个皇后放到第i列时,是否冲突
			if(judge(n)) { 
				//不冲突
				//接着放n+1个皇后，开始递归
				check(n+1);
			}
		}
		
	}
	public  boolean judge(int n) {
		
		for(int i=0;i<n;i++) {
			//检查第n个皇后和第n-1个是否有冲突
		if(array[i]==array[n]||Math.abs(n-i)==Math.abs(array[n]-array[i])) {
		
			return false;
		}
	}
		return true;
	}
	public void print(){
		for(int i=0;i<array.length;i++) {
			System.out.printf(array[i]+" ");
		}
		System.out.println();
	}
}
qq_45750255
关注
Qz学算法-数据结构篇(表达式、递归)
Code_LeeQZ的博客
02-28 389
从右至左扫描表达式，遇到数字时，将数字压入堆栈，遇到运算符时，弹出栈顶的两个数，用运算符对它们做相应的计算（栈顶元素和次顶元素），并将结果入栈：重复上述过程直到表达式最左端，最后运算得出的值即为表达式的结果。扫描表达式，遇到数字时，将数字压入堆栈，遇到运算符时，弹出栈顶的两个数，用运算符对它们做相应的计算（次顶元素和栈顶元素），并将结果入栈：重复上述过程直到表达式最右端，最后运算得出的值即为表达式的结果。支持小括号和多位数整数，因为这里我们主要讲的是数据结构，因此计算器进行简化，只支持对整数的计算。
编译原理中缀转后缀表达式（递归下降及出错提示）
03-29
一个编译原理中缀转后缀表达式（递归下降翻译成AST，后序遍历得到后缀）的 Java 程序，读取文件中的中缀表达式（每个表达式以分号结束，文件中可以有多个表达式）并转换为等价的后缀表达式后输出到屏幕上， 表达式中的运算量可以是任意整数或者小数，支持加、减、乘、除、取负运算以 及小括号，若用户输入的表达式有误，则提示用户错误的位置。譬如两个运算量之间缺少运 算符、或运算符缺少左（或右）运算量等。 为以上的 Java 程序提供一个随机测试数据发生器（用 Java 语言来写），读取若干随机的正确表达式和不正确表达式。
数据结构（十四）：递归
weixin_47560260的博客
09-21 94
递归的概念：自己调用自己，每次调用时传入不同变量，让代码变简洁。 递归调用规则： 1.当程序执行到一个方法时，就会开辟一个独立的空间（栈） 2.局部变量相互独立，不会相互影响 3.递归必须设置退出条件（收敛） 4.执行完毕，返回 打印问题 test(4) public static void test(int n){ if(n>2){ test(n-1); } system.out.println("n"+n) } 输出：n=2 ...
表达式转换（中缀表达式转后缀表达式） 递归算法
m0_59048867的博客
10-10 1168
圆括号可以嵌套，左圆括号后面又是表达式，形成表达式的递归定义。 圆括号具有最高优先级，其次是乘除，最后是加减。 最外层看成操作数1和操作数2及操作符+或-的组合表达式；第二层看成操作数1和操作数2及操作符*或/的组合表达式，最内层为圆括号括起来的表达式。 最内层返回第二层，第二层返回第一层，与计算逻辑相符。 后缀表达式为操作数+操作数+操作符，操作数可以是后缀表达式。 如有问题请指出，谢谢~ bool IsOpOrNum(string str) { char c = str[0]; if
后缀表达式(4)-——中缀表达式到后缀表达式的转换，递归实现
汪星人来地球的博客
10-16 3789
本篇是介绍的是后缀表达式最难，也是最基本的一个问题。即如何将一个中缀表达式转化为后缀表达式。在网上可以找到许多非递归实现的示例代码，它们比本节介绍的代码要简洁且高效，可是不利于理解。本节舍近求远，介绍后缀表达式的递归实现方式，为的是把变换的中心思想解释清楚。 问题描述 输入: 是一串字符串，它表示的是包含加减乘除四则运算以及括号运算的中缀表达式。为了简单起见，我们假设表达式中的
【Java数据结构与算法】 基础篇(3)：栈、四则表达式运算、中缀表达式转后缀表达式、递归
qq_44366571的博客
03-15 281
本篇文章： 主要是关于java数据结构与算法的一些基本知识：栈的学习、栈实现四则运算、栈实现带符号的四则运算、中缀表达式转后缀表达式、递归解决迷宫问题、回溯解决8皇后问题。 栈应用一：栈实现带符号的四则运算 栈应用二：栈实现中缀表达式转后缀表达式 递归应用一：递归实现迷宫问题 递归应用二：8皇后问题
ccc.rar_数据结构 栈的应用
09-21
1. **表达式求值**：在计算数学表达式时，如中缀表达式转后缀表达式（逆波兰表示法）的过程中，栈起到关键作用。我们用栈来保存运算符，遇到数字就直接输出，遇到运算符则与栈顶运算符比较优先级，根据规则决定是...
ysbd.rar_数据结构_栈的应用
09-20
6. **回溯算法**：在解决组合优化问题如八皇后问题、迷宫问题等，回溯算法会使用栈来保存中间状态，当当前路径无法找到解决方案时，回溯到上一步继续尝试。 7. **URL编码与解码**：在HTTP协议中，URL编码会将非...
数据结构试验6-栈及其应用
11-02
1. **表达式求值**：通过中缀表达式转后缀表达式（逆波兰表示法），然后用栈计算后缀表达式的值。 2. **括号匹配**：检查编程语言中的括号是否配对正确，每次遇到开括号就压栈，遇到闭括号就与栈顶元素比较。 3. **...
数据结构课件：堆栈在迷宫问题中的应用
3. 算术运算式的转换，如中缀表达式转后缀表达式，常使用堆栈辅助处理。 4. 子程序调用，堆栈用来保存函数调用的上下文信息。 5. 中断处理，系统在处理中断时会将当前状态压入堆栈，以便恢复。 6. 编译错误处理，...
数据结构学习：前缀中缀后缀表达式转化
weixin_45632016的博客
07-31 2945
数据结构学习：前缀中缀后缀表达式转化 中缀转后缀的手算方法： ① 确定中缀表达式中各个运算符的运算顺序 ② 选择下一个运算符，按照「左操作数 右操作数 运算符」的方式组合成一个新的操作数 ③ 如果还有运算符没被处理，就继续 ② 由于运算顺序不唯一，因此对应的后缀表达式也不唯一 “左优先”原则：只要左边的运算符能先计算，就优先算左边的 后缀表达式的手算方法： 从左往右扫描，每遇到一个运算符，就让运算符前面最近的两个操作数执行对应运算，合体为一个操作数 用栈实现后缀表达式的计算： ①从左往右扫描下一个元素，
经典迷宫问题BFS
That
10-14 2万+
给定一个迷宫，入口为左上角，出口为右下角，问是否有路径从入口到出口，若有则输出一条这样的路径。注意移动可以从上、下、左、右、上左、上右、下左、下右八个方向进行。迷宫输入0表示可走，输入1表示墙。易得可以用1将迷宫围起来避免边界问题。 本题采用BFS算法给出解。注意，利用BFS算法给出的路径必然是一条最短路径。 /* 迷宫问题（八方向） input: 1 6 8 0 1 1 1 0 1 1 1
中缀表达式转换为后缀表达式
热门推荐
__七把刀__
09-20 17万+
一、后缀表达式求值 后缀表达式也叫逆波兰表达式，其求值过程可以用到栈来辅助存储。假定待求值的后缀表达式为：6  5  2  3  + 8 * + 3  +  *，则其求值过程如下： 1）遍历表达式，遇到的数字首先放入栈中，此时栈如下所示： 2）接着读到“+”，则弹出3和2，执行3+2，计算结果等于5，并将5压入到栈中。 3）读到8，将其直接放入栈中。 4）读到“*”，弹出8和
详解如何将中缀表达式转化为后缀表达式
Dacyuan的学习笔记
04-14 4万+
本文我将从两种角度来解析如何将中缀表达式转化为后缀表达式一、从应对考试角度来（在最快的时间内得出最准确的答案）首先我们应该知道，要想将中缀转化为后缀，需要借助堆栈实现。（不准备画图了，画图有点浪费时间）我会用最简单明了的语言使读者弄懂。[举个例子吧：比如将:2*（9+6/3-5）+4转化为后缀表达式2 9 6 3 / +5 -  * 4 +    ]1、任何中缀表达式都由运算数，运算符，括号（大，...
中缀表达式转后缀表达式
学习记录
07-06 4万+
中缀表达式转后缀表达式
中缀表达式转后缀表达式（非常简单易懂）
qq_29462849的博客
06-25 2万+
前言 数据结构与算法中经常遇到中缀表达式转前缀表达式的题目，网上的教程大都很不直观，自己学的时候，也走了很多弯路，现在把一个简单易懂的算法教程分享出来。 中缀转后缀 举个例子，一个式子： (5+20+1∗3)/14(5+20+1*3)/14(5+20+1∗3)/14 如何把该式子转换成后缀表达式呢？其实就是分三步： 1、按运算符优先级对所有运算符和它的运算数加括号，（原本的括号不用加） 2、把运算...
数据结构中缀表达式转后缀表达式与后缀表达式的求值实训报告_数据结构碎碎念（一）
weixin_39593354的博客
11-23 596
碎碎念在大一学习C语言的时候，举过一个用栈实现的括号匹配算法，当时觉得很难，不过现在回顾起来，这个算法也算是比较简单的一个关于栈的应用了。而现在所常见的算法问题也都是什么中缀表达式转后缀表达式，双栈找最小值之类的。难度比之括号匹配稍有提升，不过倒也算是必须要掌握的算法。上述所说的表达式求值在程序设计语言中是一个最基本的问题，也是栈的实现的一个典型范例。为什么说是最基本？ 我们知道，中缀表达式对于人...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值