求后缀表达式转中缀表达式的代码，请各位大神用栈来解，其他的如树等太过高深，蒟蒻一只不会用。拜托拜托！感激不尽！
从左至右扫描表达式，遇到数字时，将数字压入堆栈，遇到运算符时，弹出栈顶的两个数，用运算符对它们做相应的计算（次顶元素 op 栈顶元素），并将结果入栈；重复上述过程直到表达式最右端，最后运算得出的值即为表达式的结果。
例如后缀表达式 “3 4 + 5 × 6 -”：
(1) 从左至右扫描，将 3和4 压入堆栈；
(2) 遇到 +运算符，因此弹出4和 3（4 为栈顶元素， 3为次顶元素，注意与前缀表达式做比较），计算出 3+4的值，得7 ，再将7入栈；
(3) 将5入栈；
(4) 接下来是 ×运算符，因此弹出5和 7，计算出7×5=35 ，将35入栈；
(5) 将6入栈；
(6) 最后是 -运算符，计算出35-6的值，即 29，由此得出最终结果。
// 计算后缀表达式的结果
public static int toValue(StringBuffer postfix){
Stack<Integer> stack = new Stack<Integer>();
for(int i=0;i<postfix.length();i++){
char ch = postfix.charAt(i);
if(ch>='0' && ch<='9'){
String value ="";
while(ch!= ' '){
value += ch;
ch = postfix.charAt(++i);
}
stack.push(Integer.parseInt(value));
}
else{
if(ch!= ' '){
int y = stack.pop();
int x = stack.pop();
switch(ch){
case '+':stack.push(x+y); break;
case '-': stack.push(x-y) ; break;
case '*': stack.push(x*y); break;
case '/' : stack.push(x/y);break;
}
}
}
}
return stack.pop();
}
如果只是为了将后缀表达式转为中缀表达式，在以上流程中将出栈的数值和符号按照中缀表达式的格式打印出来（或储存为字符串就可以了）；
//后缀表达式转化为中缀表达式
public static String postfixToInfix(StringBuilder postfix){
Stack<String> stack = new Stack<String>(); //记录操作数
char sign； //记录前一个操作码
for(int i=0;i<postfix.length();i++){
char ch = postfix.charAt(i);
if(ch>='0' && ch<='9'){
String value ="";
while(ch!= ' '){
value += ch;
ch = postfix.charAt(++i);
}
stack.push(value);
}
else{
if(ch!= ' '){
String y = stack.pop(); //两个操作数出栈
String x = stack.pop();
if((ch == '*' || ch == '/') && (sign == '+' || sign == '-')){
stack.push("("+x+")"+ch+y);
}else{
stack.push(x+ch+y)
}
sign = ch;
}
}
}
}
return stack.pop();
}
之前学数据结构时候弄的，，，没有c++ide了。。你运行试试，不过感觉像是中转后的，，找了会当时课件，，没找到。。
#include<iostream>
#include<exception>
#include<string.h>
using namespace std;
class Out_Bounds:exception{};
class no_means:exception{};
template<class T>
class Stack {
private:
int top;
int MaxTop;
T *stack;
public:
Stack(int Max = 100);
~Stack( ) {delete [ ] stack;}
bool Empty( ) const {return top == -1;}
bool Full( ) const {return top == MaxTop;}
T Top() const;
Stack<T>& Push(const T& x);
Stack<T>& Pop(T& x);
};
template<class T>
Stack<T>::Stack( int Max)
{
MaxTop=Max-1;
stack=new T[Max];
top=-1;
}
template<class T>
T Stack<T>::Top( ) const
{
if(Empty()) throw Out_Bounds();
else return stack[top];
}
template<class T>
Stack<T>& Stack<T>::Push(const T& x)
{
if (Full()) throw no_means( );
stack[++top] = x;
return *this;
}
template<class T>
Stack<T>& Stack<T>::Pop(T& x)
{
if (Empty( )) throw Out_Bounds();
x = stack[top --];
return *this;
}
double Operarte(double b,char op,double a)
{
double c;
switch(op)
{
case '+':
c=b+a;break;
case '-':
c=b-a;break;
case '*':
c=b*a;break;
case '/':
c=b/a;break;
}
return c;
}
bool IsOperator(char c)
{
if(c=='+'||c=='-'||c=='*'||c=='/'||c=='('||c==')'||c=='#')
return true;
else
return false;
}
char Precede(char a,char b)
{
char c;
switch(a)
{
case '+':
if(b=='+'||b=='-'||b==')'||b=='#')
{
c='>';return c;
}
else if(b=='*'||b=='/'||b=='(')
{
c='<';return c;
}
break;
case '-':
if(b=='+'||b=='-'||b==')'||b=='#')
{
c='>';return c;
}
else if(b=='*'||b=='/'||b=='(')
{
c='<';return c;
}
break;
case '*':
if(b=='+'||b=='*'||b=='-'||b=='/'||b==')'||b=='#')
{
c='>';return c;
}
else if(b=='(')
{
c='<';return c;
}
break;
case '/':
if(b=='+'||b=='/'||b=='-'||b=='*'||b==')'||b=='#')
{
c='>';return c;
}
else if(b=='(')
{
c='<';return c;
}
break;
case '(':
if(b=='+'||b=='-'||b=='*'||b=='/')
{
c='<';return c;
}
else if(b==')')
{
c='=';return c;
}
break;
case '#':
if(b=='+'||b=='-'||b=='*'||b=='/'||b=='('||b==')')
{
c='<';return c;
}
else if(b=='#')
return '=';
break;
}
}
double atof(char c)
{
return c-'0';
}
double EvaluateExpression(string s)
{
Stack<char> optr;
optr.Push('#');
Stack<float> opnd;
char c=s[0],x,op;
int i=0;
float a,b;
while(c!='#'||optr.Top()!='#')
{
if(!IsOperator(c))
{
opnd.Push(atof(c));cout<<c;
c=s[++i];
}
else
switch(Precede(optr.Top(),c))
{
case '<':
optr.Push(c);
cout<<c;c=s[++i];break;
case '=':
optr.Pop(x);cout<<c;c=s[++i];break;
case '>':
optr.Pop(op);
opnd.Pop(a);
opnd.Pop(b);
opnd.Push(Operarte(b,op,a));
break;
}
}
cout<<'=';
return opnd.Top();
}
void transform(string &suffix, string exp)
{
Stack<char>S;
S.Push('#');
int i = 0,j = 0;
char c;
while(!S.Empty())
{
if(!IsOperator(exp[i])) suffix[j++] = exp[i++];
else
{
switch (exp[i])
{
case '(' :
S.Push(exp[i]); break;
case ')' :
S.Pop(c);
while (c!= '(' )
{
suffix[j++] = c; S.Pop( c) ;
}
break;
default :
c=S.Top();
while(S.Top()&&(Precede(c,exp[i])))
{
suffix[j++] = c;
S.Pop(c);
}
if(exp[i] != '#' ) S.Push(exp[i]);
}
if(exp[i] != '#' ) i++;
else S.Pop(exp[i]);
}
}
}
double EvalateSuffix(string suffix)
{
Stack<double> S;
int i = 0;
double e1,e2,e3;
while(suffix[i])
{
if(!IsOperator(suffix[i]))
S.Push( atof(suffix[i++]));
else
{
e3 = Operarte(e2,suffix[i], e1);
S.Push(e3);
i++;
}
}
return e3;
}
int main()
{
int b;
double c,d;
string suffix, exp;
string a="(2+3)*6-4#";
c=EvaluateExpression(a);
cout<<c<<endl;
transform(suffix, a);
d=EvalateSuffix(suffix);
cout<<d<<endl;
return 0;
}