利用棧將簡單中綴表達式轉爲後綴表達式的測試

/* 通過使用棧將簡單四則運算中綴表達式轉換爲後綴表達式
 * '+', '-', '*', '/', '(', ')'共六種符號
 * 原理:
   1. 運算優先級規則是從左至右, 先乘除後加減, 有括號先算括號
   2. 逐個掃描表達式, 將遇到的操作數都按原樣輸出, 碰到操作符時, 轉3.
   3. 掃描到的操作符與棧頂元素比較優先級, 棧頂元素的優先級大於等於掃描的操作符時,
      棧頂操作符出棧輸出, 繼續重複該步驟, 直到優先級小於的條件, 將當前掃描的操作
      符進棧.
   4. 重複2和3步驟, 直到掃描結束, 依次將棧內操作符元素退棧到站空狀態即止.
   注意: 當遇到'('時, 優先級是最高的, 此時進棧, 遇到')'時, 需要退棧至'('.
*/

#include <stack>
#include <stdio.h>
#include <string.h>
#include <stdlib.h>

static bool is_operator(const char c);
static int priority_compare(const char operator1, const char operator2);

//中綴表達式轉後綴表達式
static void infix_express_to_suffix_express(const char *infix_express, int infix_len,
                                            char *suffix_express, int suffix_len)
{
    int i, j = 0;
    std::stack<char> operator_stack;
    int flag;
    const char *p = infix_express;

    for (i = 0; i<infix_len; ++i)
    {
        flag = 0;
        if (!is_operator(p[i]))
        {
            suffix_express[j++] = p[i];
        }
        else
        {
            if (p[i] == ')')
            {
                while (!operator_stack.empty() && flag == 0)
                {
                    if ('(' == operator_stack.top())
                    {
                        flag = 1;
                    }
                    else
                    {
                        suffix_express[j++] = operator_stack.top();
                    }
                    operator_stack.pop();
                }
                if (flag == 0)
                {
                    printf("1. express invalid, exit. \n");
                    exit(-1);
                }
                continue;
            }
            else
            {
                while (!operator_stack.empty())
                {
                    int priority_ret = -1;
                    if ((priority_ret = priority_compare(operator_stack.top(), p[i])) == -1)
                    {
                        printf("2. invalid express, exit.\n");
                        exit(-2);
                    }
                    if (priority_ret == 1)
                    {
                        suffix_express[j++] = operator_stack.top();
                        operator_stack.pop();
                    }
                    else
                        break;

                }
                operator_stack.push(p[i]);
            }
        }
    }
    while (!operator_stack.empty())
    {
        suffix_express[j++] = operator_stack.top();
        operator_stack.pop();
    }
    suffix_express[j] = '\0';
}

static bool is_operator(const char c)
{
    if (c == '+'
        || c == '-'
        || c == '*'
        || c == '/'
        || c == '('
        || c == ')')
    return true;
    return false;
}

static int priority_compare(const char operator1, const char operator2)
{
    switch (operator1)
    {
        case '+':
        case '-':
        {
            switch (operator2)
            {
                case '+':
                case '-':
                    return 1;
                break;

                case '*':
                case '/':
                case '(':
                    return 0;
                break;
                default:
                    return -1;
                break;
            }
        }
        break;
        case '*':
        case '/':
        {
            switch (operator2)
            {
                case '+':
                case '-':
                case '*':
                case '/':
                    return 1;
                break;

                case '(':
                    return 0;
                break;
                default:
                    return -1;
                break;
            }
        }
        break;
        case '(':
        {
            switch (operator2)
            {
                case '+':
                case '-':
                case '*':
                case '/':
                case '(':
                    return 0;
                default:
                    return -1;
                    break;
            }
        }
        break;
        default:
            return -1;
        break;
    }
    return -1;
}

int main(void)
{
    const int MAX_EXPRESS_LENGTH = 256;
    char express_infix[MAX_EXPRESS_LENGTH] = {'\0'};
    char express_suffix[MAX_EXPRESS_LENGTH] = {'\0'};

    printf("Input infix express('+', '-', '*', '/', '(', ')')\n");
    scanf("%s", express_infix);
    infix_express_to_suffix_express(express_infix, strlen(express_infix),
                                    express_suffix, MAX_EXPRESS_LENGTH);
    printf("suffix express=%s\n", express_suffix);
    return 0;
}

輸入：a+b*c+(d*e+f)*g

輸出：suffix express=abc*+de*f+g*+