精华内容
下载资源
问答
  • Java 中缀转后缀

    2017-06-15 14:38:00
    public class Test { /** * 一:非运算符直接输出 * 二:遇到左括号直接入栈 * 三:栈顶符号优先级高于或等于即将入栈的操作符,则将高于和等于的操作符出栈,然后再入栈 ... * 中缀转后缀实例,支...
    public class Test {
    	/**
    	 * 一:非运算符直接输出
    	 * 二:遇到左括号直接入栈
    	 * 三:栈顶符号优先级高于或等于即将入栈的操作符,则将高于和等于的操作符出栈,然后再入栈
    	 * 四:遇右括号,输出栈中的运算符,直到遇到第一个左括号,左括号出栈抛弃
    	 * :乘除优先级相等》 加减优先级相等
    	 * 
    	 * 中缀转后缀实例,支持10以内加减法
    	 * 
    	 * */
    public static void main(String[] args) {
    	String s="2+2*3/((2*(1+2)-4)*5)";
    	char[]chars=s.toCharArray();
    	Stack stack=new Stack<>();
    	ArrayList list=new ArrayList<>();
    	for(int i=0;i<chars.length;i++){
    		char m=chars[i];
    //		System.out.println(m);
    		if(m!='+'&&m!='-'&&m!='*'&&m!='/'&&m!='('&&m!=')'){
    			list.add(m);
    		}else{
    			if(stack.isEmpty()&&m!=')'){
    				stack.push(m);
    			}else{
    				if(m==')'){
    					/**
    					 * 清除一对括号
    					 * */
    					while((char)stack.peek()!='('){
    						list.add(stack.pop());
    					}
    					stack.pop();
    				}else if(m=='('){
    					stack.push(m);	
    				}else{
    					popContinue(m, stack, list);//最多执行两次,除了(左括号外,栈内不会有两个连续权限相等的符号
    					
    				}
    				
    			}
    		}
    	}
    	while(!stack.isEmpty()){
    		list.add(stack.pop());
    	}
    	System.out.println(list.toString());
    	
    	Stack res=new Stack();
    	for(int i=0;i<list.size();i++){
    		char m=(char)list.get(i);
    		if(m!='+'&&m!='*'&&m!='-'&&m!='/'){
    			res.push(Double.parseDouble(m+""));
    		}else{
    			double d1=0,d2=0;
    			if(!res.isEmpty()){
    				d1=(double) res.pop();
    			}
    			if(!res.isEmpty()){
    				d2= (double) res.pop();
    			}
    			
    			double d3 = 0;
    			if(m=='*'){
    				d3=d2*d1;
    			}
    			if(m=='+'){
    				d3=d2+d1;
    			}
    			if(m=='-'){
    				d3=d2-d1;
    			}
    			if(m=='/'){
    				d3=d2/d1;
    			}
    			res.push(d3);
    			
    		}
    		
    	}
    	System.out.println(res.pop());
    	
    }
    public static void popContinue(char m,Stack stack,ArrayList list){
    	int v1=getValues(m);
    	int v2=getValues((char)stack.peek());
    	if(v1>v2){
    		stack.push(m);
    		return ;
    	}else{
    		list.add(stack.pop());
    		if(!stack.isEmpty()){
    			popContinue(m, stack, list);
    			
    		}else{
    			stack.push(m);
    		}
    	}
    }
    public static int getValues(char m){
    	int i=0;
    	if(m=='*'||m=='/'){
    		i=2;
    	}else if(m=='('){
    		i=0;
    	}else{
    		i=1;
    	}
    	return i;
    }
    }

    转载于:https://www.cnblogs.com/qcjd/p/9324908.html

    展开全文
  • Java中缀转后缀表达式

    2017-10-09 11:03:32
    Java中缀转后缀表达式 注释很全,不解释了public class Demo { @Test public void main(){ String hou = zhongTransHou("2+((1-3)*4)-2"); System.out.println(hou); } public String zhongTransHou(S

    Java中缀转后缀表达式
    看了网上其他人写的感觉好复杂,难以理解,我感觉我的实现很简单,容易明白,可以借鉴!哈哈
    注释很全,不解释了

    public class Demo {
    
        @Test
        public void main(){
            String hou = zhongTransHou("2+((1-3)*4)-2");
            System.out.println(hou);
        }
        public String zhongTransHou(String zhong){
    
            //创建一个栈存放运算符使用
            Stack<Character> ysfz = new Stack<Character>();
            StringBuilder hz = new StringBuilder();
    
            //扫描整个运算表达式
            char[] chars = zhong.toCharArray();
    
            for (char c : chars) {
                //当前扫描的是运算符
                if(c == '+' || c== '-' || c== '*' || c=='/'||c==')'||c=='('){
                    //进行优先级和右括号的判断
                    //如果当前元素是右括号的话
                    if(c == ')'){
                        while(ysfz.peek()!='('){//遍历部分栈,只要栈顶不是"("都要出战,并且匹配到"("本身也要出栈
                            char top = ysfz.pop();//移除栈顶元素并返回移除的值
                            hz.append(top);
                        }
                        //执行到这里说明已经清空了所有的在"("上面的运算符,此后将本身也给清楚
                        ysfz.pop();
                    }else if(ysfz.isEmpty()){//当前栈是空的话
                        ysfz.push(c);//直接入栈
                    }else if(curYSFIsGao(c,ysfz)){//当前运算符比栈顶运算符高的话
                        ysfz.add(c);
                    }else if(!curYSFIsGao(c,ysfz)){//当前运算符比栈顶运算符低的话
                        while(!ysfz.isEmpty()){//遍历整个栈
                            char top = ysfz.pop();
                            hz.append(top);
                        }
                        //执行到这里栈已经是空了,现在将当前元素入栈
                        ysfz.push(c);
                    }
                }else{//当前扫描的数字
                    hz.append(c);
                }
            }
            //真个表达式扫描之后,出栈
            while(!ysfz.isEmpty()){
                char top = ysfz.pop();
                hz.append(top);     
            }
            return hz.toString();
    
        }
    
        /**
         * 判断当前元素和栈顶元素的优先级,这里面间接的判断如果是“(”也是入栈(优先级高就入栈)
         * @param c
         * @param ysfz
         * @return
         */
        private boolean curYSFIsGao(char c,Stack<Character> ysfz) {
            boolean isGao = true;//默认是高
            //拿取栈顶元素,和当前传入元素做比较优先级
            char top = ysfz.peek();
            if(c == '+' || c == '-'){
                if(top == '*' || top == '/'){
                    isGao = false;
                }
                //遇到加减或者"("默认高
            }
            //当前是乘除的话默认高,也就是都向栈里面添加
            return isGao;
        }
    }
    展开全文
  • import java.util.Stack; public class LeetCode_middleTransformToReversePolish { /** * @param args */ public static void main(String[] args) { // TODO Auto-generated method stub Strin...
    
    
    import java.util.Stack;
    
    
    public class LeetCode_middleTransformToReversePolish {
    
    	/**
    	 * @param args
    	 */
    	public static void main(String[] args) {
    		// TODO Auto-generated method stub
    		String[] input={"9","+","(","3","-","1",")","*","3","+","10","/","2"};
    		System.out.println(middleToBack(input));
    
    	}
    	
    	public static String middleToBack(String[] input)
    	{
    		int length=input.length;
    		String result="";
    		boolean isHaveleftToken=false;
    		Stack<String> stack=new Stack<>();
    		for(int i=0;i<length;i++)
    		{
    			if(!isOperator(input[i]))
    				result=result+input[i];
    			else {
    				if(stack.isEmpty())
    					stack.push(input[i]);
    				else if(input[i].equals("*")||input[i].equals("/"))
    				{
    					String tempeek=stack.peek();
    					if(isHaveleftToken)
    						stack.push(input[i]);
    					else {
    						if(tempeek.equals("*")||tempeek.equals("/"))
    							result=result+stack.pop();
    						
    						stack.push(input[i]);
    						
    					}
    				}
    				else if(input[i].equals("("))
    				{
    					isHaveleftToken=true;
    					stack.push(input[i]);
    				}
    				else if(input[i].equals(")"))
    				{
    					String temp=stack.pop();
    					while(!temp.equals("("))
    					{
    						result=result+temp;
    						temp=stack.pop();
    						
    					}
    					isHaveleftToken=false;
    					
    				}
    				else {
    					if(isHaveleftToken)
    						stack.push(input[i]);
    					else {
    						while(!stack.isEmpty())
    							result=result+stack.pop();
    						stack.push(input[i]);
    					}
    					
    				}
    						
    				
    			}
    		}
    		//加上栈中还没出栈的元素
    		while(!stack.isEmpty())
    		{
    			result=result+stack.pop();
    		}
    		
    		return result;
    		
    	}
    	
    	 public static boolean isOperator(String s) 
    	 {
    		 if(s.equals("+")||s.equals("-")||s.equals("*")||s.equals("/")||s.equals("(")||s.equals(")"))
    			 return true;
    		 else
    			 return false;
    	 }
    
    }
    
    总体思路是这种:遇到数字的话直接输出,遇到右括号 输出左括号上面的所有元素   ,遇到左括号入栈。遇到乘除符号。进行推断假设栈中有左括号或栈顶元素是加减就入栈其余出栈。遇到加减符号,假设栈中有左括号则入栈,否则将栈中元素所有出栈。做完这些处理后,在将栈中还没出栈的增加到输出结果中。亲測实用
    展开全文
  •  * 中缀表达式 后缀表达式  */ import java.util.ArrayList; import java.util.Iterator; import java.util.List; import java.util.Stack; public class ExpressConvert {    
    package calculator;


    /**
     * 中缀表达式 转 后缀表达式
     */
    import java.util.ArrayList;
    import java.util.Iterator;
    import java.util.List;
    import java.util.Stack;


    public class ExpressConvert {  
     
        /** 
         * 优先级比较 
         * @param operator1 比较值 
         * @param operator2 被比较值 
         * @return 小于等于返回false,大于返回true 
         */  
        public boolean comparePrior(char operator1, char operator2) {  
            if('(' == operator2) {  
                return true;  
            }  
            if ('*' == operator1 || '/' == operator1) {  
                if ('+' == operator2 || '-' == operator2) {  
                    return true;  
                }  
            }  
            return false;  
        }  
      
        /** 
         * 转为后缀表达式: 
         * 1、如果是"("直接压入stack栈。 
         * 2、如果是")",依次从stack栈弹出运算符加到数组newExpressionStrs的末尾,知道遇到"("; 
         * 3、如果是非括号,比较扫描到的运算符,和stack栈顶的运算符。如果扫描到的运算符优先级高于栈顶运算符则,把运算符压入栈。否则的话,就依次把栈中运算符弹出加到数组newExpressionStrs的末尾,直到遇到优先级低于扫描到的运算符或栈空,并且把扫描到的运算符压入栈中。就这样依次扫描,知道结束为止。如果扫描结束,栈中还有元素,则依次弹出加到数组newExpressionStrs的末尾,就得到了后缀表达式。 
         * @param expressionStrs 
         * @return 
         */  
        public List<Character> toSuffixExpression(char[] expressionStrs) {  
            //新组成的表达式  
            List<Character> newExpressionStrs = new ArrayList<Character>(); 
            Stack<Character> stack = new Stack<Character>();  
            for (int i = 0; i < expressionStrs.length; i++) {  
                if ('('==(expressionStrs[i])) { // 如果是左括号,则入栈  
                    stack.push(expressionStrs[i]);  
                } else if ('+'==expressionStrs[i] || '-' == expressionStrs[i] || '*' == expressionStrs[i] || '/' == expressionStrs[i]) {  
               
                    if (!stack.empty()) { // 取出先入栈的运算符  
                    Character s = stack.pop();  
                        if(comparePrior(expressionStrs[i], s)) { //如果栈值优先级小于要入栈的值,则继续压入栈  
                            stack.push(s);  
                        } else {  //否则取出值  
                            newExpressionStrs.add(s);  
                        }  
                    } 
                    
                    stack.push(expressionStrs[i]);  
                } else if (')' == expressionStrs[i]) { //如果是')',则出栈,一直到遇到'('  
                    while (!stack.empty()) {  
                        char s = stack.pop();  
                        if (!('(' == s)) {  
                            newExpressionStrs.add(s);  
                        } else { 
                            break;  
                        }  
                    }  
                } else {  
                    newExpressionStrs.add(expressionStrs[i]);  
                }  
            }  
            while (!stack.empty()) {  
                char s = stack.pop();  
                newExpressionStrs.add(s);  
            }  
            return newExpressionStrs;  
        }  
      
        public static void main(String[] args) {  
     
        String expressionStr = "5+(4-5+1)-4+(6-5+3)+2";
        // 分割成表达式数组 
        char []expressionChrs = expressionStr.toCharArray();
            
            List<Character> newExpressionStrs = new ExpressConvert().toSuffixExpression(expressionChrs);  
            Iterator<Character> iter = newExpressionStrs.iterator();
            while(iter.hasNext()){
            System.out.print(iter.next());
            }
        }  
    }  
    展开全文
  • java 实现中缀转后缀

    2011-12-15 11:05:31
    java 实现中缀转后缀 希望对大家有用
  • 后缀表达式的计算机求值四、中缀转后缀表达式五、逆波兰计算器 一、前缀表达式(波兰表达式) 前缀表达式又称波兰式,前缀表达式的运算符位于操作数之前 举例说明: (3+4)×5-6 对应的前缀表达式就是 - × + 3 4 5 6...
  • java中缀转后缀表达式 主要记录学习 1.规则 a.如果是数直接输出 b.如果不是数 b1.符号为“(”直接插入到符号栈中 b2.符号为“)”,在遇到“(”之前一直出栈并输出;符号"("不输出 if (e.equals(")")) { while ...
  • 主要介绍了Java中缀表达式转后缀表达式实现方法,结合实例形式分析了Java中缀表达式转换成后缀表达式的相关算法原理与具体实现技巧,需要的朋友可以参考下
  • java实现中缀转后缀,后缀计算值

    千次阅读 2017-09-17 20:23:54
    表达式的三种形式中缀表达式与后缀表达式转换算法 一、表达式的三种形式: 中缀表达式:运算符放在两个运算对象中间,如:(2+1)*3。我们从小做数学题时,一直使用的就是中缀表达式。后缀表达式:不包含括号,...
  • 中缀转后缀 前期准备 需要一个堆栈,一个队列 需要一个中缀转后缀的算法 中缀转后缀算法 1.首先对字符串进行遍历 2. <1>如果是数字,则直接加入到队列。 <2>如果是左括号‘(’,则压栈。 < 3>...
  • 中缀转后缀

    2015-10-11 11:34:15
    中缀转后缀java实现,并实现去处分隔符的功能
  • java,中缀表达式转后缀表达式
  • 假设有1+((2+3)*4)-5 要求 将中缀转后缀 方法 初始化两个栈 符号栈S1 中间结果栈S2 从左到右扫描中缀表达式 遇到数时 ,将数字 压到S2中 遇到±*/时 首先item(扫描到的运算符)比较S1栈顶运算符的优先级 如果 ...
  • java中缀表达式转后缀表达式代码和思路 思路: 后缀表达式 (逆波兰表达式) 特点:扫描其表达式是从前往后扫描,运算符都是位于操作数... 中缀转后缀的思路: 、 1:将一个字符串形式的中缀表达式转换成字符数组 ...
  • 中缀表达式 中缀表达式是一个通用的算术或逻辑公式表示方法, 操作符是以中缀形式处于操作数的中间(例:3 + 4),中缀表达式是人们常用的算术表示方法。中缀记法中括号是必需的。计算过程中必须用括号将操作符和...
  • java中缀表达式转后缀表达式并计算结果(可以处理多位数
  • java实现 中缀转后缀

    千次阅读 2011-12-15 11:00:45
    package cn.itcast.action; import java.io.BufferedReader; import java.io.IOException; import java.io.InputStreamReader; import java.util.*; public class Expression {  private Stack stack;
  • import java.util.ArrayList; import java.util.List; import java.util.Stack; public class ... //完成将一个中缀表达式后缀表达式的功能 //说明 //1. 1+((2+3)×4)-5 => 成 1 2 3 + 4
  • 中缀转后缀表达式计算实现源码(C++、Java
  • 在输入界面直接输入计算的表达式,本代码可将其转化成后缀形式并计算(可计算多位数,小数),另有一个方法可判断括号是否匹配。
  • java 中缀表达式转后缀表达式lz在网上百度啦理论知识然后自己实现了代码,有些网友的代码实在。。。。好吧,我们开始1 基本概念在计算机中表达式有三种,前缀表达式(波兰式),中缀表达式,后缀表达式(逆波兰式)...
  • 中缀表达式转后缀表达式 1. 概述 初始化两个栈:运算符栈s1和存储中间结果的栈s2 从左向有扫描中缀表达式 遇到操作数时将其压入s2 遇到运算符时,比较其与s1栈顶运算符的优先级: 如果s1为空,或栈顶元素为’(’,...
  • public class PolandNotation { public static void main(String[] args) { // 完成将一个中缀表达式后缀表达式的功能 // 1. 1+((2+3)*4)-5 => 1 2 3 + 4 * + ...
  • 缺点:目前只实现10以内的四则运算 学到的知识点: StringBuffer如果想char数组,首先String,然后装Char String tem1=st.toString(); char tem[]=tem1.toCharArray(); 如何将字符数字Float要使用...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 727
精华内容 290
关键字:

java中缀转后缀

java 订阅