中缀表达式求值以及由中缀表达式生成RPN算法

        如下代码主要参考清华大学邓俊辉所编写的《数据结构C++版》实现，实际上这段代码仅仅是对源代码包进行进一步整理以及改写，需要注意的是，其中的main函数涉及到了一个从 const char * 类型到 char *类型之间的转换，不得不提及的是，这种语法一般来讲是不提倡的，而且这种语法直到C++11版本问世之后才新加入的特性(直到目前为止仍有少部分编译器不对其进行支持)，如果你对这种写法感到别扭或者生疏，不妨略将其略过，并且将数据以命令行的方式传入，其具体方式请参考其他资料，这里从略.

#pragma once
#define _CRT_SECURE_NO_WARNINGS
#include"Stack.h"

using namespace std;

#define N_OPTR 9 //运算符总数
typedef enum 
{
    ADD, SUB, MUL, DIV, POW, FAC, L_P, R_P, EOE,
} Operator; //运算符集合


//加、减、乘、除、乘方、阶乘、左括号、右括号、起始符与终止符
const char pri[N_OPTR][N_OPTR] = 
{ //运算符优先等级 [栈顶] [当前]
   /*              |-------------------- 当 前 运 算 符 --------------------| */
   /*              +      -      *      /      ^      !      (      )      \0 */
    /* --  + */    '>',   '>',   '<',   '<',   '<',   '<',   '<',   '>',   '>',
    /* |   - */    '>',   '>',   '<',   '<',   '<',   '<',   '<',   '>',   '>',
    /* 栈  * */    '>',   '>',   '>',   '>',   '<',   '<',   '<',   '>',   '>',
    /* 顶  / */    '>',   '>',   '>',   '>',   '<',   '<',   '<',   '>',   '>',
    /* 运  ^ */    '>',   '>',   '>',   '>',   '>',   '<',   '<',   '>',   '>',
    /* 算  ! */    '>',   '>',   '>',   '>',   '>',   '>',   ' ',   '>',   '>',
    /* 符  ( */    '<',   '<',   '<',   '<',   '<',   '<',   '<',   '=',   ' ',
    /* |   ) */    ' ',   ' ',   ' ',   ' ',   ' ',   ' ',   ' ',   ' ',   ' ',
    /* -- \0 */    '<',   '<',   '<',   '<',   '<',   '<',   '<',   ' ',   '='
};

void readNumber(char*& p, Stack<double>& stk)
{ //将起始于p的子串解析为数值，并存入操作数栈
    stk.push((double)(*p - '0')); //当前数位对应的数值进栈
    while (isdigit(*(++p))) //只要后续还有紧邻的数字（即多位整数的情况），则
    {
        stk.push(stk.pop() * 10 + (*p - '0')); //弹出原操作数并追加新数位后，新数值重新入栈
    }
    if ('.' != *p)
    {
        return; //此后非小数点，则意味着当前操作数解析完成
    }
    float fraction = 1; //否则，意味着还有小数部分
    while (isdigit(*(++p))) //逐位加入
    {
        stk.push(stk.pop() + (*p - '0') * (fraction /= 10)); //小数部分
    }
}

void append(char*& rpn, double opnd) 
{ //将操作数接至RPN末尾
    char buf[64];
    if (0.0 < opnd - (int)opnd)
    {
        sprintf(buf, "%f \0", opnd); //浮点格式，或
    }
    else
    {
        sprintf(buf, "%d \0", (int)opnd); //整数格式
    }
    rpn = (char*)realloc(rpn, sizeof(char) * (strlen(rpn) + strlen(buf) + 1)); //扩展空间
    strcat(rpn, buf); //RPN加长
}

void append(char*& rpn, char optr) 
{ //将运算符接至RPN末尾
    int n = strlen(rpn); //RPN当前长度（以'\0'结尾，长度n + 1）
    rpn = (char*)realloc(rpn, sizeof(char) * (n + 3)); //扩展空间
    sprintf(rpn + n, "%c ", optr); 
    rpn[n + 2] = '\0'; //接入指定的运算符
}


Operator optr2rank(char op) 
{ //由运算符转译出编号
    switch (op) 
    {
        case '+': 
        {
            return ADD; //加
        }
        case '-':
        {
            return SUB; //减
        }
        case '*': 
        {
            return MUL; //乘
        }
        case '/': 
        {
            return DIV; //除
        }
        case '^':
        {
            return POW; //乘方
        }
        case '!': 
        {
            return FAC; //阶乘
        }
        case '(': 
        {
            return L_P; //左括号
        }
        case ')':
        {
            return R_P; //右括号
        }
        case '\0': 
        {
            return EOE; //起始符与终止符
        }
        default:
        {
            exit(-1); //未知运算符
        }
    }
}

char orderBetween(char op1, char op2) //比较两个运算符之间的优先级
{
    return pri[optr2rank(op1)][optr2rank(op2)];
}

__int64 facI(int n) 
{ 
    __int64 f = 1;
    while (n > 1)
    {
        f *= n--;
    }
    return f;
} //阶乘运算（迭代版）

double calcu(double a, char op, double b) 
{ //执行二元运算
    switch (op) 
    {
        case '+': 
        {
            return a + b;
        }
        case '-': 
        {
            return a - b;
        }
        case '*':
        {
            return a * b;
        }
        case '/': 
        {
            if (0 == b)
            {
                exit(-1);
            }
            else
            {
                return a / b; //注意：如此判浮点数为零可能不安全
            }
        }
        case '^':
        {
            return pow(a, b);
        }
        default:
        {
            exit(-1);
        }
    }
}

double calcu(char op, double b) 
{ //执行一元运算
    switch (op) 
    {
        case '!':
        {
            return (double)facI((int)b); //目前仅有阶乘，可照此方式添加
        }
        default: 
        {
            exit(-1);
        }
    }
}


double evaluate(char* S, char*& RPN)
{ //对（已剔除白空格的）表达式S求值，并转换为逆波兰式RPN
    Stack<double> opnd; 
    Stack<char> optr; //运算数栈、运算符栈 /*DSA*/任何时刻，其中每对相邻元素之间均大小一致
    char* expr = S;
    optr.push('\0'); //尾哨兵'\0'也作为头哨兵首先入栈
    while (!optr.empty()) 
    { //在运算符栈非空之前，逐个处理表达式中各字符
        if (isdigit(*S))
        { //若当前字符为操作数，则
            readNumber(S, opnd);
            append(RPN, opnd.top()); //读入操作数，并将其接至RPN末尾
        }
        else //若当前字符为运算符，则
        {
            switch (orderBetween(optr.top(), *S)) 
            { //视其与栈顶运算符之间优先级高低分别处理
                case '<': //栈顶运算符优先级更低时
                {
                    optr.push(*S); S++; //计算推迟，当前运算符进栈
                    break;
                }
                case '=': //优先级相等（当前运算符为右括号或者尾部哨兵'\0'）时
                {
                    optr.pop(); S++; //脱括号并接收下一个字符
                    break;
                }
                case '>':
                { //栈顶运算符优先级更高时，可实施相应的计算，并将结果重新入栈
                    char op = optr.pop(); append(RPN, op); //栈顶运算符出栈并续接至RPN末尾
                    if ('!' == op) 
                    { //若属于一元运算符
                        double pOpnd = opnd.pop(); //只需取出一个操作数，并
                        opnd.push(calcu(op, pOpnd)); //实施一元计算，结果入栈
                    }
                    else
                    { //对于其它（二元）运算符
                        double pOpnd2 = opnd.pop(), pOpnd1 = opnd.pop(); //取出后、前操作数 /*DSA*/提问：可否省去两个临时变量？
                        opnd.push(calcu(pOpnd1, op, pOpnd2)); //实施二元计算，结果入栈
                    }
                    break;
                }
                default:
                {
                    exit(-1); //逢语法错误，不做处理直接退出
                }
            }

        }
    }
    return opnd.pop(); //弹出并返回最后的计算结果
}


char* removeSpace ( char* s )
{ //剔除s[]中的白空格
   char* p = s, *q = s;
   while ( true )
   {
       while (isspace(*q))
       {
           q++;
       }
      if ( '\0' == *q ) 
      { 
          *p = '\0';
          return s; 
      }
      *p++ = *q++;
   }
}


//教材实例代码包中的测试用例
//值得注意的是这里所使用的测试用例需要在VS2019中点击属性然后手动设置命令参数


/*
int main(int argc, char* argv[])
{ //表达式求值（入口）

    for (int i = 1; i < argc; i++)
    { //逐一处理各命令行参数（表达式）
        system("cls");
        printf("\nPress any key to evaluate: [%s]\a\n", argv[i]);
        getchar();
        char* rpn = (char*)malloc(sizeof(char) * 1);
        rpn[0] = '\0'; //逆波兰表达式
        double value = evaluate(removeSpace(argv[i]), rpn); //求值
        printf("EXPR\t: %s\n", argv[i]); //输出原表达式
        printf("RPN\t: [ %s]\n", rpn); //输出RPN
        printf("Value\t= %f = %d\n", value, (int)value); //输出表达式的值
        free(rpn);
        rpn = NULL;
        getchar();
    }


    system("pause");
    return 0;
}
*/


int main()
{
    char* rpn = (char*)malloc(sizeof(char) * 1);
    rpn[0] = '\0'; //逆波兰表达式
    double value = evaluate(const_cast < char*>("(1+2^3!-4)*(5!-(6-(7-(89-0!))))"), rpn); //求值
    cout << value << endl;
    cout << "the rpn is:" << rpn;
    free(rpn);
    rpn = NULL;

    system("pause");
    return 0;
}

      希望恰巧看到这段代码的你能够理解那张精妙的运算符优先级表（其解释从略！）