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

    2012-07-29 10:33:30
    不用堆栈,简单的数组递归实现高效高效Java表达式后缀转中缀
  • java 实现中缀转后缀

    2011-12-15 11:05:31
    java 实现中缀转后缀 希望对大家有用
  • * 后缀表达式转中缀表达式 * 使用数据结构:栈 * 思路: * 碰到非操作符就压入栈 * 配到操作符就取出栈顶两个元素 x、y 执行 (x op y)将这个结果入栈 * 追后即可得到结果 * 缺陷:会有很多无用的(),但结果并...
    package com.daelly.algorithm.stack.express;
    
    import java.util.Stack;
    
    /**
     * 后缀表达式转中缀表达式
     * 使用数据结构:栈
     * 思路:
     * 碰到非操作符就压入栈
     * 配到操作符就取出栈顶两个元素 x、y 执行 (x op y)将这个结果入栈
     * 追后即可得到结果
     * 缺陷:会有很多无用的(),但结果并不影响表达式的正确性。
     * @author daelly
     *
     */
    public class Postfix2InfixExp {
    	
    	public static String postfix2infix(String exp) {
    		Stack<String> stack = new Stack<>();
    		for(int i=0;i<exp.length();i++) {
    			char ch = exp.charAt(i);
    			if(isOperator(ch)) {
    				String temp = '(' + stack.pop() + ch + stack.pop() + ')';
    				stack.push(temp);
    			} else {
    				stack.push(ch+"");
    			}
    		}
    		return stack.pop();
    	}
    	
    	/**
    	 * 是否是操作符
    	 * @param ch
    	 * @return
    	 */
    	public static boolean isOperator(char ch) {
    		return ch=='+' || ch=='-' || ch=='*' || ch=='/' || ch=='(' || ch==')';
    	}
    
    	public static void main(String[] args) {
    		String exp = "abc*+";
    		System.out.println(postfix2infix(exp));
    		exp = "abc+*";
    		System.out.println(postfix2infix(exp));
    		exp = "abc*+defg*+h-*-";
    		System.out.println(postfix2infix(exp));
    	}
    
    }
    

    展开全文
  • 中缀转后缀 前期准备 需要一个堆栈,一个队列 需要一个中缀转后缀的算法 中缀转后缀算法 1.首先对字符串进行遍历 2. <1>如果是数字,则直接加入到队列。 <2>如果是左括号‘(’,则压栈。 < 3>...

    中缀转后缀

    前期准备

    • 需要一个堆栈,一个队列
    • 需要一个中缀转后缀的算法

    中缀转后缀算法

    1.首先对字符串进行遍历

    2.

    <1>如果是数字,则直接加入到队列。
    <2>如果是左括号‘(’,则压栈。
    < 3>如果是右括号’)‘,则依次将栈中元素弹出,并加入到队列中,直到遇到左括号。将左括号弹出。
    <4>如果是运算符
    会遇到四种情况:

    1.空栈
    2.栈顶元素为左括号
    3.栈顶元素为数字
    4.栈顶元素为运算符

    前三种情况可以直接将运算符压栈,第四种情况,需要判断两个运算符的优先级:

    1.若栈顶运算符优先级大于该运算符,则将栈顶运算符弹出,加到队列中,
    2.若栈顶运算符优先级小于该运算符,则将该运算符压栈。

    3. 遍历结束后,将栈中剩余元素弹出并加到队列中去。

    4.注意事项

    1. Java有内置的栈和队列(ArrayList,Stack),不过需要调用以下两个类
    import java.util.ArrayList;
    import java.util.Stack;
    

    2.在判断运算符优先级的时候,最好写一个方法或是类来判断。便于调用。

    5.具体代码

           说明:因为作业需要,所以没有调用Java内置的栈,而是自己写了一个栈,仅仅是为了应付这个问题,所以可能会有一些缺漏和不完整。如有不足,还请海涵和指点!谢谢!
    

    堆栈代码

    //将堆栈封装成一个类
    class Stack {
        private int temp ; //判断标志,起到指针的作用
        private int stackMaxSize; //栈的最大存储空间
        private char[] stackMemory; //字符数组
    
        //构造方法建栈
        public Stack(int stackMaxSize) {
            this.temp=-1; //统一规定指针初始值为-1
            this.stackMaxSize = stackMaxSize;
            this.stackMemory = new char[this.stackMaxSize - 1];
        }
    
        //判断栈是否为空
        public boolean isEmpty() {
            if (this.temp == -1) {
                System.out.println("栈空!");
                return true;
            } else {
                System.out.println("栈非空!");
                return false;
            }
        }
    
        //判断栈是否为满
        public boolean isFull() {
            if (this.temp == this.stackMaxSize - 1) {
                System.out.println("栈满!");
                return true;
            } else {
                System.out.println("栈非满!");
                return false;
            }
        }
    
        //添加元素
        public void add(char c) {
            if (isFull()) {
                System.out.println("栈满!不能添加!");
            } else {
                this.temp++; //指针上移
                stackMemory[this.temp]=c;
            }
        }
    
        //弹出栈顶元素
        public char pop() {
            int temp;
            if (isEmpty()) {
                System.out.println("栈空!不能删除!");
                return 0;
            } else {
                temp = this.temp;
                this.temp--; //指针下移
                return this.stackMemory[temp];
            }
        }
    
        //返回栈顶元素
        public char get() {
            if (isEmpty()) {
                System.out.println("栈空!没有元素!");
                return 0;
            } else
            return this.stackMemory[this.temp];
        }
    
        //打印栈中元素
        public void display()
        {
            for(int i=this.temp;i>=0;i--)
            {
                System.out.println(stackMemory[i]);
            }
        }
    }
    

    判断运算符优先级方法代码

      //判断优先级
        public static int judge(char c1)
        {
            switch(c1)
            {
                case '+':
                    return 1;
                case'-':
                    return 1;
                case'*':
                    return 2;
                case'/':
                    return 2;
                default:
                    break;
            }
            return 0;
        }
    }
    

    中缀转后缀方法代码

     //中缀转后缀
        public static void infixTosuffix(String S) {
            int i = 0;
            ArrayList<Character> l2 = new ArrayList<Character>(); //引入队列l2
            for (i = 0; i < S.length(); i++) { //对字符串进行遍历
                //如果是数字,则直接加入到队列l2中
                if (S.charAt(i) >= 48 && S.charAt(i) <= 57) {
                    l2.add(S.charAt(i));
                }
                //如果是左括号,则直接压入栈中
                else if (S.charAt(i) == 40) {
                    stack.add(S.charAt(i));
                }
                //如果是右括号,则依次弹出栈中元素并加到队列中
                else if (S.charAt(i) == 41) {
                    //直到遇到左括号
                    while (!(stack.get() == 40)) {
                        l2.add(stack.pop());
                    }
                    stack.pop(); //把左括号弹出
                }
                //如果是运算符,则判断他们的优先级
                else {
                    //第四种情况:若运算符小于栈顶运算符,则把栈顶运算符弹出并加到队列中
                    while (!stack.isEmpty() && judge(S.charAt(i)) <= judge(stack.get())) {
                        l2.add(stack.pop());
                    }
                    //前三种情况
                    stack.add(S.charAt(i));
                }
            }
            //遍历结束后,把栈中剩余元素弹出并加到队列中去
            while(!stack.isEmpty())
            {
                l2.add(stack.pop());
            }
            //输出后缀形式的字符串
            System.out.println(l2);
    
        }
    

    主函数代码

    import java.util.ArrayList;
    import java.util.Scanner;
    
    public class 实验4_1 {
    
        static Stack stack = new Stack(100); //实例化对象
    
          public static void main(String[] args) {
              System.out.println("请输入要转换的字符串: ");
              Scanner in = new Scanner(System.in);
              String S = in.next();
              System.out.println("转换后的字符串如下: ");
              infixTosuffix(S);
        }
    

    如有问题,还望点出,相互学习,共同进步,谢谢!!!

    展开全文
  • 最近一直在看数据结构这本书,我相信,对于每个程序员来说,数据结构都尤为重要。... 直入主题:将中缀表达式转为...关于后缀转中缀中缀转后缀的理论介绍,请先阅读其互的理论知识,或者我转发的这篇文章,这里不再累

    最近一直在看数据结构这本书,我相信,对于每个程序员来说,数据结构都尤为重要。为什么要学,可以看看这位博友的认识http://blog.csdn.net/sdkfjksf/article/details/54380659

    直入主题:将缀表达式转为后缀表达式 以及后缀表达式转为前缀表达式的实现。

    关于后缀转中缀,中缀转后缀的理论介绍,请先阅读其互转的理论知识,或者我转发的这篇文章,这里不再累赘,最好参考《数据结构与算法描述java语言版》,接下来将会用java写。


    一、首先,怎么实现缀表达式转为后缀表达式

    缀表达式转为后缀表达式相对较为简单,对于中缀表达式转后缀,其思想是将 运算符(+-*/)往栈中放,数字就直接输出,然后通过每次扫描遇到的运算符优先级来判断出栈与入栈。直接上代码吧,代码中也有解释!

    package com.liyongdada.cn;
    
    import java.util.Scanner;
    import java.util.Stack;
    
    public class StackTest {
    	
    	public static void main(String[] args) {
    		// TODO Auto-generated method stub
    		Character token;
    		String exep;
    		int i=0;
    		//下面一句需要jre1.5
    		Stack<Character> s=new Stack<Character>();
    		Scanner sc=new Scanner(System.in);
    		exep=sc.next();
    		while((token=exep.charAt(i++))!='='){
    			if(token>='a' && token<='z'){
    				System.out.print(token+" ");
    			}else{
    				switch(token){
    				case '+' :
    					//省略掉的同时没写break;是因为,只要是小于或者等于的都会出栈,因此,继续执行下面语句
    				case '-' :
    					while(!s.isEmpty() && s.peek()!='('){
    						System.out.print(s.pop()+" ");
    					}
    					s.push(token);
    					break;
    				case '*' :
    				case '/' :
    					while(!s.isEmpty() && s.peek()!='(' && s.peek()!='+' && s.peek()!='-'){
    						System.out.print(s.pop()+" ");
    					}
    					s.push(token);
    					break;
    				case '(' :
    					s.push(token);
    					break;
    				case ')' :
    					while (!s.isEmpty() && s.peek()!='('){
    						System.out.print(s.pop()+" ");
    					}
    					s.pop();
    					break;
    				case '^' :
    					while (!s.isEmpty() && !(s.peek()=='(' || s.peek()=='^')){
    						System.out.print(s.pop()+" ");
    					}
    					s.push(token);
    					break;
    				}
    			}
    		}
    		//最后检测,将剩余的全部出栈
    		while (!s.isEmpty()){
    			System.out.print(s.pop()+" ");
    		}
    	}
    
    }

    二、后缀表达式转换为中缀表达式代码

    首先,区别一下,这个后缀表达式转换为中缀表达式与前面不同,这里进行出入栈操作的是数字,而不是运算符。自己在网上找了很久,没发现有人写出这种转法的java代码,也许是没人放出来吧。于是,自己动手写了一个。思想与中缀表达式转换为后缀表达式有点不同。具体看代码吧!

    首先,我的思想是,将一个表达式中的运算符取出并用一个数组存储,对于怎么自动加括号,通过判断下一个运算符优先级。

    (假如: 有   6523+8*+3+*      我们很容易计算得到其中缀表达式为   ((3+2)*8+5+3)*6,所以,由第一个运算符  ”+“的下一个运算符 "*", 便可以知道,其 3+2 需要用括号括起来。其他方式也是,具体看代码。 )。最后,算法不是特别完美,欢迎指正!

    package com.liyongdada.cn;
    
    import java.util.Scanner;
    import java.util.Stack;
    
    public class HouToZhong {
    
    	/**
    	 * @param args
    	 */
    	public static void main(String[] args) {
    		// TODO Auto-generated method stub
    		String expp;// 接收输入的表达式
    		String token;
    		int i = 0;
    		int ssLength = 0;// 记录运算符数组的大小
    		int charIndex = 0; // 用于记录已输出运算符的个数
    		Scanner sc = new Scanner(System.in);
    		expp = sc.next();
    		//计算表达式中,有多少个运算符
    		for (int j = 0; j < expp.length(); j++) {
    			if (!Character.isDigit(expp.charAt(j))) {
    				ssLength += 1;
    			}
    		}
    		//定义大小
    		char[] ss = new char[ssLength];
    		int sj = 0;
    		//依次赋值
    		for (int j = 0; j < expp.length(); j++) {
    			if (!Character.isDigit(expp.charAt(j))) {
    				ss[sj++] = expp.charAt(j);
    			}
    		}
    		//泛型为String类型,这可以避免每次复写掉
    		Stack<String> s = new Stack<String>();
    		String pop1, pop2;//用于接收每次取出的栈顶字符串
    		while (!(token = expp.substring(i, ++i)).equals("=")) {
    			if (token.matches("[0-9]?")) {
    				s.push(token);
    			} else {
    				// 只有jre1.7才能使用字符串作为switch中的值
    				switch (token.charAt(0)) {
    				case '+':
    					if (charIndex < ssLength - 1) {
    						pop1 = s.pop();
    						pop2 = s.pop();
    						if (ss[charIndex + 1] == '*'
    								|| ss[charIndex + 1] == '/') {
    							//调用自定义方法
    							s.push(mixExpp(pop2, pop1, "+"));
    						} else
    							s.push(pop2 + "+" + pop1);
    					} else {
    						System.out.println("执行错误!+!");
    						return;
    					}
    					charIndex++;
    					break;
    				case '-':
    					if (charIndex < ssLength - 1) {
    						pop1 = s.pop();
    						pop2 = s.pop();
    						if (!(ss[charIndex + 1] != '*' || ss[charIndex + 1] != '/')) {
    							s.push(mixExpp(pop2, pop1, "-"));
    						} else
    							s.push(pop2 + "-" + pop1);
    					} else {
    						System.out.println("执行错误!-!");
    						return;
    					}
    					charIndex++;
    					break;
    				case '*':
    					pop1 = s.pop();
    					pop2 = s.pop();
    					s.push(pop2 + "*" + pop1);
    					charIndex++;
    					break;
    				case '/':
    					pop1 = s.pop();
    					pop2 = s.pop();
    					s.push(pop1 + "/" + pop2);
    					charIndex++;
    					break;
    				case '^':
    					pop1 = s.pop();
    					pop2 = s.pop();
    					s.push(pop2 + "^" + pop1);
    					charIndex++;
    					break;
    				}
    			}
    		}
    		// 取出最后一个
    		System.out.println(s.pop());
    	}
    
    	// 用于拼接括号的方法
    	public static String mixExpp(String one, String two, String fuhao) {
    		String str = "(" + one + fuhao + two + ")";
    		return str;
    	}
    
    }


    展开全文
  • 主要介绍了Java中缀表达式转后缀表达式实现方法,结合实例形式分析了Java中缀表达式转换成后缀表达式的相关算法原理与具体实现技巧,需要的朋友可以参考下
  • java中缀转后缀表达式 主要记录学习 1.规则 a.如果是数直接输出 b.如果不是数 b1.符号为“(”直接插入到符号栈中 b2.符号为“)”,在遇到“(”之前一直出栈并输出;符号"("不输出 if (e.equals(")")) { while ...

    java中缀转后缀表达式

    主要记录学习
    1.规则
    a.如果是数直接输出
    b.如果不是数
    b1.符号为“(”直接插入到符号栈中
    b2.符号为“)”,在遇到“(”之前一直出栈并输出;符号"("不输出

    if (e.equals(")")) {
    						while (true) {
    							if (stack.peek().equals("("))
    								{stack.pop();
    								break;}
    							res = res + stack.pop();
    						}
    						continue;
    					}
    

    b3.如果符号是"±*/"则看他们的优先级
    比较当前字符和栈顶字符
    如果当前字符的优先级大于栈顶直接入栈
    如果当前字符的优先级小于或者等于栈顶字符则在栈空或者当前字符的优先级大于栈顶字符前一直出栈并输出,最后当前字符入栈

    		
    					if (comparePriority(e,stack.peek())){
    						stack.push(e);
    					}else{
    						while(true){
    							if(stack.isEmpty()){
    								stack.push(e);
    								break;
    							}else{
    								if(comparePriority(e, stack.peek())){
    									stack.push(e);
    									break;
    								}
    							}							
    								res = res + stack.pop();								
    							}
    							
    							
    						
    					}
    

    demo

    public class qianzhui2houzhui {
    	public static void main(String[] args) {
    		Stack<String> stack = new Stack<String>();
    		String expression = "1 + 2 * 3 + ( 4 * 5 + 6 ) * 7";
    		String[] temp_arr = expression.split(" ");
    		List<String> elist = new ArrayList<String>(Arrays.asList(temp_arr));
    		String res = "";
    		for (String e : elist) {
    			if (e.matches("\\d+")) {
    				res = res + e;
    			} else {
    				if (stack.isEmpty())
    					stack.push(e);
    				else {
    					if (e.equals(")")) {
    						while (true) {
    							if (stack.peek().equals("("))
    								{stack.pop();
    								break;}
    							res = res + stack.pop();
    						}
    						continue;
    					}
    					
    					if (e.equals("(")) {
    						stack.push("(");
    						continue;
    					}
    					
    					
    					if (comparePriority(e,stack.peek())){
    						stack.push(e);
    					}else{
    						while(true){
    							if(stack.isEmpty()){
    								stack.push(e);
    								break;
    							}else{
    								if(comparePriority(e, stack.peek())){
    									stack.push(e);
    									break;
    								}
    							}							
    								res = res + stack.pop();								
    							}
    							
    							
    						
    					}
    					
    				}
    			}
    		
    
    		}
    		
    		for(String e:stack){
    			res = res+e;
    		}
    		System.out.println(res);
    	}
    	
    	static int isPriority(String str){
    		if(str.equals("*")||str.equals("/")) return 1;
    		if(str.equals("+")||str.equals("-")) return 0;
    		return -1;
    	}
    	
    	//比较优先级
    	static boolean comparePriority(String e1,String e2){
    		return isPriority(e1)>isPriority(e2);
    	}
    	
    }
    
    
    展开全文
  • java 中缀表达式转后缀表达式lz在网上百度啦理论知识然后自己实现了代码,有些网友的代码实在。。。。好吧,我们开始1 基本概念在计算机中表达式有三种,前缀表达式(波兰式),中缀表达式,后缀表达式(逆波兰式)...
  • 主要为大家详细介绍了java实现中缀表达式转后缀的表达式方法,具有一定的参考价值,感兴趣的小伙伴们可以参考一下
  • java,中缀表达式转后缀表达式
  • 本文先给出思路与方法,最后将给出...1.中缀表达式要转后缀表达式,首先需要两个Stack(栈),其中一个应用于存放字符,另一个用于存放数字。 2.读到数字直接存入数字栈中,读到字符时,要咸鱼栈内前一元素(字符)...
  • 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
  • 因为所有的运算符号都在两数字的中间,现在我们的问题就是中缀后缀的转化。 【5+4*6/2+3+(4*5)/5】->【5 4 6 * 2 / + 3 + 4 5 *5 / +】思路 首先定义两个集合,一个用于存储最后的结果,一个用于存储转换过程中...
  • Java前缀表达式、中缀表达式、后缀表达式前言示例中缀表达式转后缀表达式中缀表达式前缀表达式与转后缀的区别代码实现计算前缀表达式总结 前言 前两天有兴趣看看一些老算法,自己动手做了做,记一下过程中的小...
  • 基于前述文章,将代码改写,把中缀表达式转为后缀表达式package com.后缀表达式;import java.util.ArrayList; import java.util.Stack;public class 生成后缀表达式 { public static void main(String[] args) { ...
  • Java 中缀转后缀

    2017-06-15 14:38:00
    public class Test { /** * 一:非运算符直接输出 * 二:遇到左括号直接入栈 * 三:栈顶符号优先级高于或等于即将入栈的操作符,则将高于和等于的操作符出栈,然后再入栈 ... * 中缀转后缀实例,支...
  • 对于计算机来讲,通常后缀表达式更容易计算,因为它不用考虑优先规则和括号。表达式中的数值和操作符的顺序就足以确定计算...中缀转后缀的思路如下:    1)如果遇到操作数,我们就直接将其输出。  2)如果遇
  • java中缀表达式转后缀表达式并计算结果(可以处理多位数
  • 一、中缀转后缀 逆波兰表达式 中缀–>后缀 思路:两个栈一个保存符号 21,一个存数字 s2,左到右遍历中缀表达式。 遇到数字时压入s2中;遇到运算符时: 若s1为空,或者 栈顶运算符为“(”,则直接入栈 若优先级...
  • 中缀表达式 中缀表达式是一个通用的算术或逻辑公式表示方法, 操作符是以中缀形式处于操作数的中间(例:3 + 4),中缀表达式是人们常用的算术表示方法。中缀记法中括号是必需的。计算过程中必须用括号将操作符和...
  • 先了解一下什么是中缀后缀表达式中缀表达式就是我们平常写的算式,比如2*(3+4)-8/2,它对应的后缀表达式是234+*82/-。不要着急,接下来我们看看是怎么得到后缀表达式的。当遇到数字时,直接输出,遇到符号入栈,...
  • Java编程:中缀表达式转后缀表达式

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 5,226
精华内容 2,090
关键字:

java后缀是转中缀

java 订阅