中缀表达式转后缀表达式算法及实现

 1 //MyStack.h
 2 
 3 #include <iostream>
 4 using namespace std;
 5 
 6 template <class ElemType> class MyStack
 7 {
 8 public:
 9     const static  int MAXSIZE =100;
10     ElemType data[MAXSIZE];
11     int top;
12 
13 public:
14     void init();            // 初始化栈
15     bool empty();            // 判断栈是否为空
16     ElemType gettop();        // 读取栈顶元素(不出栈)
17     void push(ElemType x);    // 进栈
18     ElemType pop();            // 出栈
19 };
20 
21 
22 template<class T> void MyStack<T>::init()
23 {
24     this->top = 0;
25 }
26 
27 template<class T> bool MyStack<T>::empty()
28 {
29     return this->top == 0? true : false;
30 }
31 
32 template<class T> T MyStack<T>::gettop()
33 {
34     if(empty())
35     {
36         cout << "栈为空！\n";
37         exit(1);
38     }
39     return this->data[this->top-1];
40 }
41 
42 template<class T> void MyStack<T>::push(T x)
43 {
44     if(this->top == MAXSIZE)
45     {
46         cout << "栈已满！\n";
47         exit(1);
48     }
49     this->data[this->top] =x;
50     this->top ++;
51 }
52 
53 template<class T> T MyStack<T>::pop()
54 {
55     if(this->empty())
56     {
57         cout << "栈为空! \n";
58         exit(1);
59     }
60 
61     T e =this->data[this->top-1];
62     this->top --;
63     return e;
64 }

// PrefixToPostfix.h

#include <vector>
using namespace std;

bool isoperator(char op);                          // 判断是否为运算符
int priority(char op);                                // 求运算符优先级
void postfix(char pre[] , char post[],int &n);    // 把中缀表达式转换为后缀表达式
double read_number(char str[],int *i);              // 将数字字符串转变成相应的数字
double postfix_value(char post[]);                  // 由后缀表达式字符串计算相应的中值表达式的值    

View Code

// PrefixToPostfix.cpp

#include "MyStack.h"
#include "PrefixToPostfix.h"

#include <iostream>
using namespace std;

void main()
{
    MyStack<int> stack ;
    stack.init();

    //char pre[] ="22/(5*2+1)#";
    char exp[100];
    cout << "输入表达式(中缀，以#结束)：";
    cin >> exp;

    char post[100] ;
    //cout <<"中缀表达式为："<< pre << endl;

    int n =0;            // 返回后缀表达式的长度
    postfix(exp,post,n);
    cout <<"后缀表达式为：";
    for( int i =0 ;i < n ;i++)
        cout << post[i] ;

    cout << "\n由后缀表达式计算出的数值结果:  ";
    cout << postfix_value(post) << endl;

    system("pause");
}

bool isoperator(char op)
{
    switch(op)
    {
    case '+':
    case '-':
    case '*':
    case '/':
        return 1;
    default : 
        return 0;
    }
}


int priority(char op)
{
    switch(op)
    {
    case '#':
        return -1;
    case '(':
        return 0;
    case '+':
    case '-':
        return 1;
    case '*':
    case '/':
        return 2;
    default :
        return -1;
    }
}

//     把中缀表达式转换为后缀表达式，返回后缀表达式的长度（包括空格）
void postfix(char pre[] ,char post[],int &n)
{
    int i = 0 ,j=0;
    MyStack<char> stack;
    stack.init();        // 初始化存储操作符的栈

    stack.push('#');    // 首先把结束标志‘#’放入栈底

    while(pre[i]!='#')
    {
        if((pre[i]>='0' && pre[i] <='9')||pre[i] =='.') // 遇到数字和小数点直接写入后缀表达式
        {
            post[j++] = pre[i];
            n++;
        }
        else if (pre[i]=='(')    // 遇到“（”不用比较直接入栈
            stack.push(pre[i]);
        else if(pre[i] ==')')  // 遇到右括号将其对应左括号后的操作符（操作符栈中的）全部写入后缀表达式
        {
            while(stack.gettop()!='(')
            {
                post[j++] = stack.pop();
                n++;
            }
            stack.pop(); // 将“（”出栈，后缀表达式中不含小括号
        }
        else if (isoperator(pre[i]))
        {
            post[j++] = ''; // 用空格分开操作数(
            n++;
            while(priority(pre[i]) <= priority(stack.gettop())) 
            {
                // 当前的操作符小于等于栈顶操作符的优先级时，将栈顶操作符写入到后缀表达式，重复此过程
                post[j++] = stack.pop();
                n++;
            }

            stack.push(pre[i]);    // 当前操作符优先级大于栈顶操作符的优先级，将该操作符入栈
        }

        i++;
    }
    while(stack.top) // 将所有的操作符加入后缀表达式
    {
        post[j++] = stack.pop();
        n++;
    }
}

double read_number(char str[],int *i)
{
    double x=0.0;
    int k = 0;
    while(str[*i] >='0' && str[*i]<='9')  // 处理整数部分
    {
        x = x*10+(str[*i]-'0');
        (*i)++;
    }

    if(str[*i]=='.') // 处理小数部分
    {
        (*i)++;
        while(str[*i] >= '0'&&str[*i] <='9')
        {
            x = x * 10 + (str[*i]-'0');
            (*i)++;
            k++;
        }
    }
    while(k!=0)
    {
        x /= 10.0;
        k--;
    }

    return x;
}

double postfix_value(char post[])
{
    MyStack<double> stack;    // 操作数栈
    stack.init();

    int i=0 ;
    double x1,x2;

    while(post[i] !='#')
    {
        if(post[i] >='0' && post[i] <='9')
            stack.push(read_number(post,&i));
        else if(post[i] == '')
            i++;
        else if (post[i] =='+')
        {
            x2 = stack.pop();
            x1 = stack.pop();
            stack.push(x1+x2);
            i++;
        }
        else if (post[i] =='-')
        {
            x2 = stack.pop();
            x1 = stack.pop();
            stack.push(x1-x2);
            i++;
        }
        else if (post[i] =='*')
        {
            x2 = stack.pop();
            x1 = stack.pop();
            stack.push(x1*x2);
            i++;
        }
        else if (post[i] =='/')
        {
            x2 = stack.pop();
            x1 = stack.pop();
            stack.push(x1/x2);
            i++;
        }
    }
    return stack.gettop();
}