中綴表達式轉化為後綴表達式[附C++源碼]（原創）

做四則運算的時候，需要將如下的算術表達式轉化為後綴表達式，從而方便運算：

例如：

1+2/(3-4)+5*3           ..............................
(為了表述簡單起見，這裏數字隻能是[0-9]間的單個數字，運算符為"+-*/"，括號"()")

轉化後的結果：1234-/+53*+，轉化為後綴表達式後，顯然括號已經被消除，此時遍曆後綴表達式，每次遇到運算符，取前麵兩個

數字進行運算即可！

中綴表達式轉化為後綴表達式（逆波蘭式）的算法思想如下：

數據結構：

前綴表達式串：const char* infix;

後綴表達式存放的位置： char* postfix;

存放運算符和括號的棧：stack<char> op;

算法步驟：

一、遍曆前綴表達式串infix，對每一個字符ch

1) 當ch為空字符’ ‘, 忽略。

2) 當ch為數字[0-9]，將ch存入後綴表達式postfix。

3) 當ch為運算符”+-*/”，如果符號棧中有優先級大於等於ch的符號，將棧中符號彈出並依次存入後綴表達式，最後將ch存入符號棧；

如果符號棧中沒有先級大於等於ch的符號，直接將ch存入符號棧。

4) 當ch為左括號'(‘，將ch存入符號棧op。

5) 當ch為右括號’)’，將符號棧中的運算符依次出棧並存到後綴表達式中，直到遇到左括號'(‘，並將左括號出棧。

二、如果符號棧op不為空，將op中的符號依次出棧並存到後綴表達式postfix中。

附C++源碼如下：

#include <iostream>
#include <stack>

using namespace std;

int priority(char op)
{
    int r = 0;
    switch(op)
    {

    case '(':

    case ')':

         r = 1;

         break;
    case '+':
    case '-':
        r = 2;
        break;
    case '*':
    case '/':
        r = 3;
        break;
    default:
        break;
    }
    return r;
}

bool is_op(char op)
{
    if(op == '+' || op == '-' || op == '*' || op == '/')
        return true;
    return false;
}

int infix_to_postfix(char* postfix, const char* infix)
{
    stack<char> op;
    const char* ptr = infix;
    char* iter = postfix;
    for(; *ptr != '\0'; ptr++)
    {
        char ch = *ptr;
        if(ch == ' ')//skip whitespace
        {
            continue;
        }
        else if(ch >= '0' && ch <= '9')//number
        {
            *iter++ = ch;
        }
        else if( ch == '(')//left parentheses
        {
            op.push(ch);
        }
        else if( ch == ')')//rigth parentheses
        {
           //pop out all of the operators before left parentheses
            while(1)
            {
                if(op.empty())
                {
                    fprintf(stderr, "match parentheses error!\n");
                    return 0;
                }
                char temp = op.top();
                op.pop();
                if(temp == '(')
                {
                    break;
                }
                else
                {
                    *iter++ = temp;
                }
            }
        }
        else if(is_op(ch))//operators
        {
           //pop out all of the operators which priority is less than the current token!
            while(!op.empty())
            {
                char temp = op.top();
                if(priority(temp) >= priority(ch))
                {
                    op.pop();
                    *iter++ = temp;
                }
                else
                {
                    break;
                }
            }
            op.push(ch);
        }
        else//unexpected token
        {
            fprintf(stderr, "unexpected token:%c!\n", ch);
        }
    }
   //pop out all of the operators left in the stack
    while(!op.empty())
    {
        char ch = op.top();
        op.pop();
        *iter++ = ch;
    }
    return 1;
}


int main(int argc, char** argv)
{
    const char* infix="1+2/(3-4)+5*3";
    char postfix[1024]={0};
    if(infix_to_postfix(postfix, infix))
    {
        printf("%s\n", postfix);
    }
    system("pause");
    return 0;
}