有中缀表达式转换为后缀表达式并求值

 

/*将中缀表达式转化为后缀表达式的算法思想
首先需要分配两个栈，一个作为临时存储运算符的栈s1（含一个结束符号），一个作为输入后缀表达式的栈S2(空栈），是栈可以先放入优先级最低的运算符#,注意
中缀式应以最低优先级的运算符结束，可以指定其他字符，不一定非#不可。从中缀表达式的左端开始取字符，程序步骤如下
（1）若取出的是数字，将改运算数直接送入S2栈
（2）若取出的字符是运算符，则将该运算符与S1栈站定元素优先级比较，
如果该运算符的优先级大于S1栈栈顶运算符的优先级，则将该运算符进S1栈，
否则将S1栈栈顶运算符弹出，送入S2栈中直至S1栈栈顶运算符优先级低于（不包括等于）该运算符优先级，则将该运算符送入S1栈
（3）若取出的字符是‘（’，则直接送入S1栈栈顶，
（4）若取出的字符是‘）’，则将距离S1栈栈顶最近的‘（’之间的运算符，逐个出栈，依次送入S2栈，此时抛弃‘（’；
（5）重复上面的1~4步骤，直至处理完所有的输入字符
（6）若取出的字符是‘#’则将S1栈内的所有元素出栈（不包括‘#’）依次送入S2栈

完成以上步骤，S2栈便为后缀表达式的输出结果，不过S2应作逆序处理，便可以便可以照做后缀表示计算了

  */

#include<iostream>
#include<string.h>
using namespace std;
const int maxsize=100;
template<class T>

class stack
{
public:
 stack()
 {
  top=0;
 }
bool isEmpty()
 {
  if(top==0)
   return true;
  else
   return false;
 }
 void push(T x)
 {
 
  s[++top]=x;
 }
void pop()
 {
 
 top--;
 }
 T gettop()
 {
  return s[top];
 }

private:
 T s[maxsize];
 int top;
};
//将中缀表达式转化为后缀表达式
void zhuanhua(char inorder[],char post[],int &m)
{
 int n=strlen(inorder);
 stack<char>czf;
 for(int i=0;i<n;i++)
 {
  if(inorder[i]>'0'&&inorder[i]<'9')
  {
   post[m]=inorder[i];
   m++;
  }
  if(inorder[i]=='(')
   czf.push(inorder[i]);
  if(inorder[i]=='+')
  {
   if(!czf.isEmpty()&&(czf.gettop()=='*'||czf.gettop()=='/'||czf.gettop()=='-'))
   {
    post[m++]=czf.gettop();
    czf.pop();
    czf.push(inorder[i]);
   }
    else
    {
     czf.push(inorder[i]);
    }
   }
    if(inorder[i]=='-')
    {
     if(!czf.isEmpty()&&(czf.gettop()=='*'||czf.gettop()=='/'))
     {
      post[m++]=czf.gettop();
      czf.pop();
      czf.push(inorder[i]);
     }
      else
      {
       czf.push(inorder[i]);
      }
     }
    if(inorder[i]=='*'||inorder[i]=='/')
    {

     czf.push(inorder[i]);
    }
    if(inorder[i]==')')
    {
     while(czf.gettop()!='(')
     {
      post[m++]=czf.gettop();
      czf.pop();
     }
     czf.pop();//弹出(
    }
   }
    while(!czf.isEmpty())
    {
     post[m++]=czf.gettop();
     czf.pop();
    }

   }
  int yunsuan(char post[],int n)
  {
   stack<int>ss;//定义int型堆栈存放操作数每次运算的结果
   int a,b,c,result;
   for(int i=0;i<n;i++)
   {
    if(post[i]>'0'&&post[i]<'9')
    {
     ss.push(post[i]-'0');
    }
    if(post[i]=='-')
    {
     b=ss.gettop();
     ss.pop();
     b=ss.gettop();
     ss.pop();
     c=a-b;
     ss.push(c);
    }
    if(post[i]=='+')
    {
     b=ss.gettop();
     ss.pop();
     a=ss.gettop();
     ss.pop();
     c=a+b;
     ss.push(c);
    }
    if(post[i]=='*')
    {
              b=ss.gettop();
     ss.pop();
     a=ss.gettop();
     ss.pop();
     c=a*b;
     ss.push(c);

    }
    if(post[i]=='/')
    {
     b=ss.gettop();
     ss.pop();
     a=ss.gettop();
     ss.pop();
     c=a/b;
     ss.push(c);
    }
   }
   result=ss.gettop();
   ss.pop();
   return result;
  }

  void main()
   {
   char c;
 char ss[100];
 char post[100];
 int m=0;
 int j=0;
 cout<<"输入中缀表达的值,以#结束"<<endl;
 while(c!='#')
 {cin>>c;
 ss[j]=c;
 j++;
 }
 zhuanhua(ss,post,m);
 cout<<"转换后的后缀表达式的值"<<endl;
 for(int i=0 ;i<m;i++)
 {
  cout<<post[i];
 }
 cout<<endl;
 cout<<"后缀表达式的值"<<endl;
 cout<<yunsuan(post,m);
 }