四则运算的中缀转后缀

最新推荐文章于 2022-03-22 21:04:44 发布
最新推荐文章于 2022-03-22 21:04:44 发布
阅读量209 收藏
点赞数
分类专栏： J2SE 文章标签： C C++ C# UP
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/iteye_12959/article/details/81653069
版权 


import java.math.BigDecimal;   
import java.util.ArrayList;   
import java.util.List;   
import java.util.regex.Matcher;   
import java.util.regex.Pattern;   

/**  
 *   
 * 应用：逆波兰表达式  
 *   
 * @author Leon.Chen  
 *   
 */  
public class CalculateString {   

    public BigDecimal calculateString(String str) {   
        char[] strs = str.toCharArray();   
        Stack<String> stack = new Stack<String>();   

        for (int i = 0; i < strs.length; i++) {   
            String stackStr = String.valueOf(strs[i]);   
            stack.push(stackStr);   
            if (")".equals(stack.top())) {   
                String subStr = null;   
                while (!"(".equals(stack.top())) {   
                    stack.pop();   
                    if (!"(".equals(stack.top())) {   
                        subStr = addEnd(subStr, stack.top());   
                    }   
                }   
                String pushStr = CalculateReversePolishExpression(subStr);   
                stack.pop();   
                stack.push(pushStr);   
            }   

        }   
        String resultStr = null;   
        while (stack.count != 0) {   
            resultStr = CalculateReversePolishExpression(stack.toString());   
        }   
        BigDecimal result = null;   
        if (resultStr != null) {   
            result = new BigDecimal(resultStr);   
        } else {   
            result = BigDecimal.ZERO;   
        }   
        return result.setScale(2, BigDecimal.ROUND_HALF_UP);   
    }   

    public String[] matcher(String regex, String str) {   
        Pattern pattern = Pattern.compile(regex);   
        Matcher matcher = pattern.matcher(str);   
        List<String> list = new ArrayList<String>();   
        while (matcher.find()) {   
            list.add(matcher.group());   
        }   
        String[] result = new String[list.size()];   
        return list.toArray(result);   
    }   

    public List<String> createReversePolishExpression(String subStr) {   
        String regex = "\\d+\\.{0,1}\\d*";   
        String[] numbers = matcher(regex, subStr);   
        String changeStr = subStr.replaceAll(regex, "0").replaceAll("\\-\\-0",   
                "-1").replaceAll("\\+\\-0", "+1").replaceAll("\\*\\-0", "*1")   
                .replaceAll("\\/\\-0", "/1");   
        char[] chars = changeStr.toCharArray();   
        int index = 0;   
        List<String> list = new ArrayList<String>();   
        for (int i = 0; i < chars.length; i++) {   
            String str = String.valueOf(chars[i]);   
            if ("0".equals(str)) {   
                list.add(numbers[index++]);   
            } else if ("1".equals(str)) {   
                list.add("-" + numbers[index++]);   
            } else {   
                list.add(str);   
            }   
        }   
        List<String> suffix = new ArrayList<String>();   
        Stack<String> operator = new Stack<String>();   
        for (int i = 0; i < list.size(); i++) {   
            if (!isOperatorType(list.get(i))) {   
                suffix.add(list.get(i));   
            } else {   
                if (operator.count == 0) {   
                    operator.push(list.get(i));   
                } else {   
                    while (operator.count != 0&&compare(operator.top(), list.get(i)) >= 0) {   
                        String top = operator.top();   
                        operator.pop();   
                        suffix.add(top);   
                    }    
                    operator.push(list.get(i));   

                }   
            }   
        }   

        while (operator.count != 0) {   
            suffix.add(operator.top());   
            operator.pop();   
        }   
        return suffix;   
    }   

    public String CalculateReversePolishExpression(String subStr) {   
        List<String> suffix = createReversePolishExpression(subStr);   
        Stack<Double> stack = new Stack<Double>();   
        for (int i = 0; i < suffix.size(); i++) {   
            if (!isOperatorType(suffix.get(i))) {   
                stack.push(Double.valueOf(suffix.get(i)));   
            } else {   
                Double current = stack.top();   
                stack.pop();   
                Double previous = null;   
                if (stack.count != 0) {   
                    previous = stack.top();   
                    stack.pop();   
                } else {   
                    previous = new Double(0);   
                }   
                Double result = calculate(suffix.get(i), previous, current);   
                stack.push(result);   
            }   
        }   
        return stack.top().toString();   
    }   

    public String addEnd(String str, String a) {   
        StringBuffer buf = new StringBuffer();   
        buf.append(a);   
        if (str != null) {   
            buf.append(str);   
        }   
        return buf.toString();   
    }   

    public boolean isOperatorType(String str) {   
        if (str.equals("+") || str.equals("-") || str.equals("*")   
                || str.equals("/")) {   
            return true;   
        }   
        return false;   
    }   

    public int compare(String op1, String op2) {   
        Integer iop1 = getOperator(op1);   
        Integer iop2 = getOperator(op2);   
        return iop1.compareTo(iop2);   
    }   

    public Integer getOperator(String op) {   
        if ("+".equals(op) || "-".equals(op)) {   
            return new Integer(0);   
        }   
        if ("*".equals(op) || "/".equals(op)) {   
            return new Integer(1);   
        }   
        return null;   
    }   

    public Double calculate(String op, Double previous, Double current) {   
        if ("+".equals(op)) {   
            return previous + current;   
        }   
        if ("-".equals(op)) {   
            return previous - current;   
        }   
        if ("*".equals(op)) {   
            return previous * current;   
        }   
        if ("/".equals(op)) {   
            return previous / current;   
        }   
        return null;   
    }   

    public static void main(String[] args) {   
        String[] strs = new String[]{"(5+6)*7","(-1)/(-3)","1/(-3)","-1/7","7+(3*5)-(8+20/2)","4-(4-3*5+(2*4)+100)/10"};   
        for(int i=0;i<strs.length;i++){   
            BigDecimal result = new CalculateString().calculateString(strs[i]);   
            System.out.println(result.toString());   
        }   

    }   

}  

package graph;

import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.List;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

/**
 * 
 * 应用：逆波兰表达式
 * 
 * @author Leon.Chen
 * 
 */
public class CalculateString {

	public BigDecimal calculateString(String str) {
		char[] strs = str.toCharArray();
		Stack<String> stack = new Stack<String>();

		for (int i = 0; i < strs.length; i++) {
			String stackStr = String.valueOf(strs[i]);
			stack.push(stackStr);
			if (")".equals(stack.top())) {
				String subStr = null;
				while (!"(".equals(stack.top())) {
					stack.pop();
					if (!"(".equals(stack.top())) {
						subStr = addEnd(subStr, stack.top());
					}
				}
				String pushStr = CalculateReversePolishExpression(subStr);
				stack.pop();
				stack.push(pushStr);
			}

		}
		String resultStr = null;
		while (stack.count != 0) {
			resultStr = CalculateReversePolishExpression(stack.toString());
		}
		BigDecimal result = null;
		if (resultStr != null) {
			result = new BigDecimal(resultStr);
		} else {
			result = BigDecimal.ZERO;
		}
		return result.setScale(2, BigDecimal.ROUND_HALF_UP);
	}

	public String[] matcher(String regex, String str) {
		Pattern pattern = Pattern.compile(regex);
		Matcher matcher = pattern.matcher(str);
		List<String> list = new ArrayList<String>();
		while (matcher.find()) {
			list.add(matcher.group());
		}
		String[] result = new String[list.size()];
		return list.toArray(result);
	}

	public List<String> createReversePolishExpression(String subStr) {
		String regex = "\\d+\\.{0,1}\\d*";
		String[] numbers = matcher(regex, subStr);
		String changeStr = subStr.replaceAll(regex, "0").replaceAll("\\-\\-0",
				"-1").replaceAll("\\+\\-0", "+1").replaceAll("\\*\\-0", "*1")
				.replaceAll("\\/\\-0", "/1");
		char[] chars = changeStr.toCharArray();
		int index = 0;
		List<String> list = new ArrayList<String>();
		for (int i = 0; i < chars.length; i++) {
			String str = String.valueOf(chars[i]);
			if ("0".equals(str)) {
				list.add(numbers[index++]);
			} else if ("1".equals(str)) {
				list.add("-" + numbers[index++]);
			} else {
				list.add(str);
			}
		}
		List<String> suffix = new ArrayList<String>();
		Stack<String> operator = new Stack<String>();
		for (int i = 0; i < list.size(); i++) {
			if (!isOperatorType(list.get(i))) {
				suffix.add(list.get(i));
			} else {
				if (operator.count == 0) {
					operator.push(list.get(i));
				} else {
					while (operator.count != 0&&compare(operator.top(), list.get(i)) >= 0) {
						String top = operator.top();
						operator.pop();
						suffix.add(top);
					} 
					operator.push(list.get(i));

				}
			}
		}

		while (operator.count != 0) {
			suffix.add(operator.top());
			operator.pop();
		}
		return suffix;
	}

	public String CalculateReversePolishExpression(String subStr) {
		List<String> suffix = createReversePolishExpression(subStr);
		Stack<Double> stack = new Stack<Double>();
		for (int i = 0; i < suffix.size(); i++) {
			if (!isOperatorType(suffix.get(i))) {
				stack.push(Double.valueOf(suffix.get(i)));
			} else {
				Double current = stack.top();
				stack.pop();
				Double previous = null;
				if (stack.count != 0) {
					previous = stack.top();
					stack.pop();
				} else {
					previous = new Double(0);
				}
				Double result = calculate(suffix.get(i), previous, current);
				stack.push(result);
			}
		}
		return stack.top().toString();
	}

	public String addEnd(String str, String a) {
		StringBuffer buf = new StringBuffer();
		buf.append(a);
		if (str != null) {
			buf.append(str);
		}
		return buf.toString();
	}

	public boolean isOperatorType(String str) {
		if (str.equals("+") || str.equals("-") || str.equals("*")
				|| str.equals("/")) {
			return true;
		}
		return false;
	}

	public int compare(String op1, String op2) {
		Integer iop1 = getOperator(op1);
		Integer iop2 = getOperator(op2);
		return iop1.compareTo(iop2);
	}

	public Integer getOperator(String op) {
		if ("+".equals(op) || "-".equals(op)) {
			return new Integer(0);
		}
		if ("*".equals(op) || "/".equals(op)) {
			return new Integer(1);
		}
		return null;
	}

	public Double calculate(String op, Double previous, Double current) {
		if ("+".equals(op)) {
			return previous + current;
		}
		if ("-".equals(op)) {
			return previous - current;
		}
		if ("*".equals(op)) {
			return previous * current;
		}
		if ("/".equals(op)) {
			return previous / current;
		}
		return null;
	}

	public static void main(String[] args) {
		String[] strs = new String[]{"(5+6)*7","(-1)/(-3)","1/(-3)","-1/7","7+(3*5)-(8+20/2)","4-(4-3*5+(2*4)+100)/10"};
		for(int i=0;i<strs.length;i++){
			BigDecimal result = new CalculateString().calculateString(strs[i]);
			System.out.println(result.toString());
		}

	}

}


自己写的stack 


public class Stack<T> {   
    public StackNode<T> stackTop;   
    public int count;   
    public void push(T info) {   
        StackNode<T> node = new StackNode<T>();   
        node.info = info;   
        node.link = stackTop;   
        stackTop = node;   
        count++;   
    }    

    public void pop() {   
        if(stackTop == null) {   
            System.out.println("null stack");   
        } else {   
            stackTop = stackTop.link;   
            count--;   
        }   

    }   

    public boolean isEmpty() {   
        return count == 0;   
    }   

    public T top() {   
        if(stackTop == null) {   
            return null;   
        }   
        return stackTop.info;   
    }   

    public String toString(){   
        Stack<T> other = new Stack<T>();   
        while(count != 0){   
            T top = top();   
            pop();   
            other.push(top);   
        }   
        StringBuffer buf = new StringBuffer();   
        while(other.count !=0){   
            buf.append(other.top());   
            other.pop();   
        }   
        return buf.toString();   
    }   

}  


public class Stack<T> {
	public StackNode<T> stackTop;
	public int count;
	public void push(T info) {
		StackNode<T> node = new StackNode<T>();
		node.info = info;
		node.link = stackTop;
		stackTop = node;
		count++;
	} 

	public void pop() {
		if(stackTop == null) {
			System.out.println("null stack");
		} else {
			stackTop = stackTop.link;
			count--;
		}

	}

	public boolean isEmpty() {
		return count == 0;
	}

	public T top() {
		if(stackTop == null) {
			return null;
		}
		return stackTop.info;
	}

	public String toString(){
		Stack<T> other = new Stack<T>();
		while(count != 0){
			T top = top();
			pop();
			other.push(top);
		}
		StringBuffer buf = new StringBuffer();
		while(other.count !=0){
			buf.append(other.top());
			other.pop();
		}
		return buf.toString();
	}

}


stack节点 

public class StackNode<T> {   
    public StackNode<T> link;   
    public T info;   
}  





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

public class Eval {   
   public int eval(String exp){   
       List<String> list = infixExpToPostExp(exp);//转化成后缀表达式   
       return doEval(list);//真正求值   
   }   

   //遇到操作符压栈，遇到表达式从后缀表达式中弹出两个数，计算出结果，压入堆栈   
   private int doEval(List<String> list) {   
      Stack<String> stack =  new Stack<String>();   
      String element;   
      int n1,n2,result;   
      try{   
          for(int i = 0; i < list.size();i++){   
              element = list.get(i);   
              if(isOperator(element)){   
                  n1 = Integer.parseInt(stack.pop());   
                  n2 = Integer.parseInt(stack.pop());   
                  result = doOperate(n1,n2,element);   
                  stack.push(new Integer(result).toString());   
             }else{   
                 stack.push(element);   
             }   
          }   
          return Integer.parseInt(stack.pop());   
      }catch(RuntimeException e){   
          throw new IllegalExpressionException(e.getMessage());          
      }   
   }   

   private int doOperate(int n1, int n2, String operator) {   
      if(operator.equals("+"))   
          return n1 + n2;   
      else if(operator.equals("-"))   
          return n1 - n2;   
      else if(operator.equals("*"))   
          return n1 * n2;   
      else  
          return n1 / n2;   
   }   

   private boolean isOperator(String str){   
       return str.equals("+") || str.equals("-") || str.equals("*") || str.equals("/");   
   }   

   private List<String> infixExpToPostExp(String exp){//将中缀表达式转化成为后缀表达式   
       List<String> postExp = new ArrayList<String>();//存放转化的后缀表达式的链表   
       StringBuffer numBuffer = new StringBuffer();//用来保存一个数的   
       Stack<Character> opStack = new Stack<Character>();//操作符栈   
       char ch,preChar;   
       opStack.push('#');   
       try{   
           for(int i = 0; i < exp.length();){   
               ch = exp.charAt(i);   
               switch(ch){   
                    case '+':   
                    case '-':   
                    case '*':   
                    case '/':   
                        preChar = opStack.peek();   
//              如果栈里面的操作符优先级比当前的大，则把栈中优先级大的都添加到后缀表达式列表中   
                        while(priority(preChar) >= priority(ch)){   
                            postExp.add(""+preChar);   
                            opStack.pop();   
                            preChar = opStack.peek();   
                        }   
                        opStack.push(ch);   
                        i++;   
                        break;   
                    case '(':   
//              左括号直接压栈   
                        opStack.push(ch);   
                        i++;   
                        break;   
                    case ')':   
//              右括号则直接把栈中左括号前面的弹出，并加入后缀表达式链表中   
                        char c = opStack.pop();   
                        while(c != '('){   
                            postExp.add("" + c);   
                            c = opStack.pop();   
                        }   
                        i++;   
                        break;   
//           #号，代表表达式结束，可以直接把操作符栈中剩余的操作符全部弹出，并加入后缀表达式链表中   
                 case '#':   
                     char c1;   
                     while(!opStack.isEmpty()){   
                         c1 = opStack.pop();   
                         if(c1 != '#')   
                           postExp.add("" + c1);   
                     }   
                     i++;   
                     break;   
                              //过滤空白符   
                 case ' ':   
                 case '\t':   
                     i++;   
                     break;   
//               数字则凑成一个整数，加入后缀表达式链表中   
                 default:   
                     if(Character.isDigit(ch)){   
                         while(Character.isDigit(ch)){   
                             numBuffer.append(ch);   
                             ch = exp.charAt(++i);   
                         }   
                         postExp.add(numBuffer.toString());   
                         numBuffer = new StringBuffer();   
                     }else{   
                         throw new IllegalExpressionException("illegal operator");   
                     }   
               }   
           }   
       }catch(RuntimeException e){   
           throw new IllegalExpressionException(e.getMessage());    
       }   
       return postExp;   
   }   

   private int priority(char op){//定义优先级   
        switch(op){   
        case'+':   
        case'-':   
            return 1;   
        case'*':   
        case'/':   
            return 2;   
        case'(':   
        case'#':   
            return 0;   
        }   
        throw new IllegalExpressionException("Illegal operator");   
  }   

   public static void main(String[] args) {   
       Eval eval = new Eval();   
       int result = eval.eval("2+3+55*22+21*2+(3+2)*3+4*3+3*4#");   
       System.out.println(result);   
   }   
}

iteye_12959
关注
专栏目录
中缀转后缀实现字符串四则运算（C++）
Unique_yang博客
06-05 601
“字符串表达式求值的编程实现” #include<iostream> #include<string> #include<iomanip> using namespace std; //堆栈元 class StackEle { public: StackEle() { isop = false; } StackEle(bool n) { isop = ...
四则运算中缀转后缀(C语言)
DFGOMC的博客
10-12 397
四则运算中缀转后缀(C语言) 本文参考自《大话数据结构》 算法思路 遇到数字直接输出，使用栈来存储，通过比较运算符的优先级，判断是否要将栈顶符号输出： 如果栈顶符号优先级不比字符串当前所指符号优先级低，则输出；否则将符号入栈； 括号优先级最高()，遇到 ) 括号则匹配栈中的 **( ** 括号，将括号中所有符号输出； 字符串遍历结束后，将栈中符号全部输出； 原书例题 9+(3-1)*3+10/2： 数字9直接输出，输出结果：9 栈为空，栈中没有符号，此时+号入栈，栈中符号为（左边为栈顶）：+ (
四则运算（中缀转后缀）
12-12
可以对大于十的数字转换。用栈实现的C代码
四则运算表达式part1（中缀表达式转后缀表达式）
qq_39283195的博客
05-24 296
后续利用后缀表达式及代码实现看part2 例子：1+2*3+（4*5+6）-10 利用两个栈数字栈numstack和操作符栈opstack。从左向右遍历四则表达式，遇到数字直接入数字栈，遇到操作符如果操作符栈为空则直接入操作符栈，否则判断操作符栈顶元素优先级是否比当前操作符低。如果低的话就入操作符栈，如果高得话就将操作符栈元素出栈压入数字栈，一直出栈到操作符栈顶元素比当前元素低或者栈顶元素为左...
四则运算的中缀转后缀，逆波兰表达式求值
内牛满面
04-23 191
首先描述问题 [code] 给定一个字符串 example:"4-(4-3*5+(2*4)+100)/10"; 要求输出结果"-5.70";结果四舍五入，保留两位小数 [/code] 首先进行的是括号优先级的处理 [code] public BigDecimal calculateString(String str) { char[] strs = str.toCharAr...
使用栈实现四则运算中缀到后缀的转换
YoungLittleT的博客
05-09 287
使用栈实现四则运算中缀到后缀的转换，代码如下： package com.mytest; import java.util.Stack; public class MyTest { public static void main(String[] args) { String[] infixExpression = { "9", "+", "(", "3", "-", "1", ")", "*", "3", "+", "10", "/", "2" };// 中缀表达式 ...
简易四则运算，利用中缀转后缀表达…
uestc_lxp的专栏
10-31 379
package com.caculate; import java.math.BigDecimal; import java.util.Arrays; import java.util.Stack; public class Caculate {          public static void main(String[] args) {         String str = "9+(3
四则运算——中缀表达式转后缀表达式
ZIV555的博客
05-20 1148
后缀（逆波兰） 规则：从左向右遍历中缀表达式的每个数字和符号，若是数字就输出，即成为后缀表达式的一部分；若是符号，则判断其与栈顶符号的优先级，是右括号或优先级低于栈顶符号（乘除优先于加减）则栈顶元素依次出栈并输出，并将当前符号进栈，直到最终输出后缀表达式为止。 最重要的两步： 1、将中缀表达式转化成后缀表达式（栈用来进出运算的符号）； 2、将后缀表达式进行运算得出结果（栈用来进出运
四则运算之中缀表达式转后缀表达式
include_heqile的博客
01-11 1861
这篇博客参考了博主“石锅拌饭“的文章：http://blog.csdn.net/sgbfblog/article/details/8001651后缀表达式的计算只要把中缀表达式转换为后缀表达式，后续的计算就会方便很多，所谓后缀表达式，其实就是将操作符放在了参与计算的数字后面，然后以这种形式存入了栈中，计算的时候就按照下面这种方式： 比如对于后缀表达式：1 2 3 * + 5 10 + 2 / -
四则运算（中缀表达式到后缀表达式）
03-01
中缀表达式到后缀表达式的转换，再计算四则运算，包括+，-，*，/，（，）
数据结构之栈（中缀转后缀计算四则运算）
tulensa的博客
01-26 764
前面转载了一篇有关栈的基础讲解的文章，所以这篇文章就不再说有关栈的概念性内容了。这篇文章主要的内容，就是用学到的栈的基础操作，来实现一个输入中缀四则运算表达式（+ - * /），转换成后缀表达式，然后计算结果并输出的小程序。表达式中可以有括号，操作数可以是多位整数（不支持小数，不过要修改也很容易）。中缀转后缀方法：1.遇到操作数，直接输出； 2.栈为空时，遇到运算符，入栈； 3.遇到左括号，将其入...
C语言之四则表达式的计算（中缀转后缀）
Dr.Ning的博客
04-16 938
如何通过栈来实现四则运算表达式的计算思路代码结果和总结测试案例总结 思路 通过栈这种数据结构来实现四则运算表达式的计算，是C语言这门课程中一项经典的作业。大一刚上C语言这门课的时候老师给我们的期末大作业就是这道题。总的来说我们需要做的最主要的一项工作就是把中缀表达式转为后缀表达式，这就需要用到栈中数据“先进后出”的特性。中缀、后缀表达式的概念这里不再赘述，后文运算结果截图也有展示。栈有两种形式：顺...
四则运算中缀转后缀兼计算
weixin_61815647的博客
03-22 123
首先举个例子 9+(3-1)×3+10÷2= 这是个中缀表达式 转成后缀表达 为 9 3 1 -3 *+10 2 /+ 那么如何实现转化，转化完后又如何计算呢？ 先讲下计算 从左到右遍历表达式的每个数字和符号，遇到数字就进栈，遇到符号，就将栈顶两个数字出栈，将两者进行运算，运算结果进栈；重复操作，直到遍历完后缀表达式，将得到最终结果。 例如： 9 3 1 -3 *+10 2 /+ 1. 1 3 9 进栈（左边表示栈顶） 2.遇到 - 将栈中两元素弹出，计算结果再压入栈中 即 1 3 9 -&g
中缀/后缀表达式转换-使用四则混合运算表达式生成树
系统运维
12-10 221
很多资料讨论了四则混合运算的中缀表达式和后缀表达式的变换方法，有的很简单，有的很复杂，然而这种简单和复杂只是表现在程序上的，肉眼观察加人工操作完成这样的任何实际上十分简单，因为人脑习惯于于用自己的方式来解决问题，如果要写程序，那么就要迎合电脑的习惯，这种习惯的转换和移风易俗一样困难。 括号的引入加大了复杂度，然而括号的加入实际上使问题更简单了，人们习惯于去掉括号，然而简单的办法却是加上括号，当你加...
中缀计算四则运算表达式
UniversalCode的海贼船
09-25 911
因为最近在学编译原理，老师布置了个恶心的东西就是正则表达式的题目，所以用户到了字符匹配的运算，先温习一下四则运算的栈方法实现 主要是俩个栈 一个用来保存数字 一个用来保存操作符 #include&lt;iostream&gt; #include&lt;stack&gt; #include&lt;cstring&gt; #include&lt;cstdio&gt; using namespac...
栈的应用-处理四则运算-后缀表达式
qq_43685921的博客
10-30 419
栈的应用-处理四则运算-后缀表达式 什么是后缀表达式，正常的四则运算表达式，如： 9 + (3 - 1) * 3 + 10 / 2 这样的四则运算表达式称为中缀表达式，因为运算符号都在两个数字的中间。后缀表达式则是： 9 3 1 - 3 * + 10 2 / + 运算符号在将要运算的数字后面。 规则：从左到右遍历表达式的每个数字和运算符，遇到数字就进栈，遇到符号，就将处于栈顶的两个数字出栈，进...
C语言中缀转后缀四则运算--For初学者
a_52hz的博客
09-26 1816
中缀表达式 百度百科 后缀表达式 百度百科 现在大家都知道了什么是中缀表达式，后缀表达式。好，进正题。本文主要是用C语言，来做简单的编程实现转化功能。 例如，输入 ：(5+3)*2+(6+3) 转化后的结果：5 3 + 2 * 6 3 + +（后附有图） 额，本人能力有限，所以难免有bug，读者在运行代码的时候，括号的输入是英文的（可以自行加上中文），注意输入格式。 代码如下： 编译环境是（Cod...
四则运算的 中缀表达式 转 后缀表达式 思路整理
weixin_42309199的博客
09-01 1375
本次复盘包含有中缀表达式转化为后缀表达式的全部思路。从分析两种表达式的特点开始，思考选用的数据结构，推演运算过程。然后根据运算过程，设计不同运算符优先级的高低。在难度上，从没有括号的四则运算开始，逐步升级，直至完成有括号的四则运算运算符优先级设计。
【数据结构】栈的应用---四则运算表达式求值（中缀表达式与后缀表达式转换）
热门推荐
杨森源的博客
04-29 1万+
用计算机实现带括号的四则运算的方式。这里的困难在于乘除运算的优先级高于加减运算，并且加入了括号，使得问题变得更加困难。20世纪50年代，波兰逻辑学家想到了一种不需要括号的后缀表达法，我们也把它称为逆波兰表示。比如：9+(3-1)*3+10/2，如果用后缀表示法就是9 3 1 - 3 * + 10 2 / +,这样的表达式称为后缀表达式，叫后缀的原因在于所有的符号都是要在运算数字的后面出现。后缀表达式
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值