中序表达式转逆波兰表达式（你嫌弃波兰~抛弃疗窝喔~）个位数简化版

将一个中序表达式转化成为逆波兰表达式。

       首先维护的是两个栈，我们这里暂且称为S1和S2，S1中的结果最后存的就是逆波兰表达式，S2中将用于暂时存放运算符并且在最终形成逆波兰表达式的时候，该栈是会清空的。下面我们看看怎样具体的形成逆波兰表达式。

       在此首先定义一下运算符的优先级关系，从小到达排序，相同优先级没有用逗号隔开：（，+-，*\，负号，）。

       从左至右遍历一个给定的中序表达式，也就是我们常规的数学计算的表达式。

（1）如果遇到的是数字，我们直接加入到栈S1中；

（2）如果遇到的是左括号，则直接将该左括号加入到栈S2中；

（3）如果遇到的是右括号，那么将栈S2中的运算符一次出栈加入到栈S1中，直到遇到左括号，但是该左括号出栈S2并不加入到栈S1中；

（4）如果遇到的是运算符，包括单目运算符和双目运算符，我们按照下面的规则进行操作：

          （1）如果此时栈S2为空，则直接将运算符加入到栈S2中；

          （2）如果此时栈S2不为空，当前遍历的运算符的优先级大于等于栈顶运算符的优先级，那么直接入栈S2；

          （3）如果此时栈S2不为空，当前遍历的运算符的优先级小于栈顶运算符的优先级，则将栈顶运算符一直出栈加入到栈S1中，直到栈为空或者遇到一个运算符的优先级小于等于当前遍历的运算符的优先级，此时将该运算符加入到栈S2中；

（5）直到遍历完整个中序表达式之后，栈S2中仍然存在运算符，那么将这些运算符依次出栈加入到栈S1中，直到栈为空。

来源：http://blog.csdn.net/geniusluzh/article/details/8192780

运算那部分有问题，转逆波兰表达式没有问题

package NiBoLan;
import java.util.ArrayList;
public class StackList {
	public Node head;
	public Node pointer;
	public Node top;
  public StackList()
  {
	  head=new Node();
	  top=head.next();
  }
  public void InStack(Node node)
  {
	pointer=head.next();
	if(pointer==null)
	{
	
	 head.LinkNext(node);	
	 top=node;
	}
	else
	{
    top.LinkNext(node);
    top=node;
	}
  }
  public void OutStack()
  {
	  pointer=head.next(); 
	  Node q=head;
	  if(pointer==null)
	  {
		 System.out.println("STACK IS EMPTY");
	  }
	  else
	  {
	    while(pointer.next()!=null)
	    {
		   q=pointer;
		   pointer=pointer.next();
	    }
	   top=q;
	   q.LinkNext(null);
	  
  }
  }
  public void PrintList()
  {
	  pointer=head.next();
	  if(pointer==null)
	  {
		  System.out.println("STACK IS EMPTY");
	  }
	  else
	  {
	  while(pointer!=top)
	  {
		  System.out.print(pointer.getValue());
		  pointer=pointer.next();
	  }
	  System.out.print(top.getValue());
	  System.out.println();
  }
  }
  public void YunSuan()
  {
   BoLan bolan=new BoLan();
   Node elem=head;
   Node elem1=elem.next();
   Node elem2=elem1.next();
   pointer=elem2.next();
   while(bolan.IsChar(pointer.getValue())==false)
   {
	 elem=elem1;
	 elem1=elem2;
	 elem2=pointer;
	 pointer=pointer.next();
   }
   int result=0;
   if(pointer.getValue()=='+')
	   result=(int)elem1.getValue()-48+(int)elem2.getValue()-48;
   if(pointer.getValue()=='-')
	   result=((int)elem1.getValue()-48)-((int)elem2.getValue()-48);
   if(pointer.getValue()=='*')
	   result=((int)elem1.getValue()-48)*((int)elem2.getValue()-48);
   if(pointer.getValue()=='/')
	   result=((int)elem1.getValue()-48)/((int)elem2.getValue()-48);
   elem.LinkNext(pointer.next());
   elem=head;
   while(elem!=null)
   {
	 pointer=head.next();
	 elem1=pointer;
	 while(bolan.IsChar(pointer.getValue())==false)
	 {   
		 elem=elem1;
		 elem1=pointer;
		 pointer=pointer.next();
	 }
	 if(pointer.getValue()=='+')
		   result=result+(int)elem1.getValue()-48;
	   if(pointer.getValue()=='-')
		   result=result-((int)elem1.getValue()-48);
	   if(pointer.getValue()=='*')
		   result=result*((int)elem1.getValue()-48);
	   if(pointer.getValue()=='/')
		   result=result/((int)elem1.getValue()-48);
	   
   }
   System.out.println(result);
   }
   
  }
class Node
{
	Node next;
	char value;
	public Node(){}
	public Node(char value)
	{
		this.value=value;
	}
	public Node next()
	{
		return this.next;
	}
	public void LinkNext(Node node)
	{
		this.next=node;
	}
	public char getValue()
	{
		return this.value;
	}
	public void setValue(char value)
	{
		this.value=value;
	}
}

package NiBoLan;
import java.util.Scanner;
public class BoLan {
   public static int sumshu=0;
	public static void main(String[] args)
	{
	 
	  Scanner input=new Scanner(System.in);
	  StackList stack1=new StackList();//用来存字符
	  StackList stack2=new StackList();//用来存最终的逆波兰表达式
	  System.out.println("请输入中序表达式：");
	  String s=input.next();
	  int i=0;
	  while(i

请输入中序表达式：
4*(6-3)+8/2
463-*82/+