對於平時我們書寫的算術表示式是

12 * ( 3 + 4 ) - 6 + 8 / 2

這種習慣的寫法是中綴表示式
但是計算機一般執行方式是字尾表示式，從左向右依次執行

12 3 4 + * 6 - 8 2 / +

這就是字尾表示式

這個是如何轉換的呢

有兩種
1.根據樹的遍歷
2.利用棧

今天主要說的是利用棧的轉換

中綴表示式轉換為字尾表示式

1.建立棧
2.從左向右順序獲取中綴表示式

a.數字直接輸出
b.運算子

遇到’ ( ‘直接入棧，遇到’ ) ‘將棧中‘ ( ‘之後入棧的全部輸出，同時‘ ( ‘出棧但是不輸出。其他符號將符號棧中的元素依次出棧並輸出，直到遇到比當前符號優先順序更低

的符號或者’ ( ‘，將當前符號入棧。

3.獲取完後，將棧中剩餘的符號依次輸出

例如：12 * (3 + 4) - 6 + 8 / 2
依次獲取：
12 ，是數字，直接輸出

字尾表示式:12
符號棧：

’ * ’ ，是運算子，入棧

字尾表示式:12
符號棧:*

’ ( ‘,左括號，直接入棧

字尾表示式：12
符號棧: * (

3 , 數字 ，輸出

字尾表示式：12 3
符號棧: * (

‘ + ’，運算子 ，入棧

字尾表示式：12 3
符號棧: * ( +

4 ，數字，輸出

字尾表示式：12 3 4
符號棧: * ( +

‘ ）’，右括號，棧中元素依次出棧並輸出知道遇到左括號,並且左括號也要出棧且不輸出

字尾表示式：12 3 4 +
符號棧: *

‘ - ’，操作符，減號的優先順序低於乘號所以乘號出棧並輸出，此時站內沒有符號，減號入棧

字尾表示式：12 3 4 + *
符號棧: -

6 ，數字，輸出

字尾表示式：12 3 4 + * 6
符號棧: -

’ + ‘,操作符 ，優先順序與減號相同（也就是說沒有減號的優先順序高）所以減號出棧輸出，加號入棧

字尾表示式：12 3 4 + * 6 -
符號棧: +

8 ，數字 ，輸出

字尾表示式：12 3 4 + * 6 - 8
符號棧: +

‘ / ’，操作符，比減號的優先順序高直接入棧

字尾表示式：12 3 4 + * 6 - 8
符號棧: + /

2 ，數字，輸出

字尾表示式：12 3 4 + * 6 - 8 2
符號棧: + /
中綴表示式獲取完後，將棧中剩餘元素依次出棧輸出
字尾表示式：12 3 4 + * 6 - 8 2 / +
符號棧:

以上就是中綴表示式轉字尾表示式
轉換了之後也要知道字尾表示式是怎麼計算的
還是要利用棧

• 依次遍歷
• 檢測是否是數字，是數字就壓棧，是操作符從棧中依次取出當前運算元的右運算元和左運算元與當前操作符進行運算，結果壓棧。

• 遍歷結束，執行結果就是棧頂元素。

  比如：12 3 4 + * 6 - 8 2 / +

• 數字入棧

  棧：12 3 4

• ’ + ’ ,遇到運算子從棧中依次取出當前運算元的右運算元和左運算元與當前操作符進行運算，結果壓棧 ，3 +4 =7

  棧：12 7

• ’ * ’ , 運算子 ，12 * 7 =84

  棧：84

• 6 ，入棧

  棧：84 6

• ’ - ’ ,運算子 ，84 -6 =78

  棧：78

• 8 2 ，入棧

  棧 ： 78 8 2

• ’ / ’ ,運算子 ， 8 /2 =4

  棧：78 4

• ’ + ’ ,運算子 78+4 =82

  棧：82

最後的結果就是：82

下面是一個關於字尾表示式計算的函式，可以參考：

結構體定義：

#define max 100
typedef char DataType;
typedef struct Stack //棧
{
    int top;
    DataType stack[max];
}Stack;

enum {Data,Add,Sub,Mul,Div}operate; //列舉

typedef struct Cell  
{
    enum operate op;
    int data;
}cell;

主要函式：

void StackInit(Stack* p) //棧的初始化
{
    assert(p);
    p->top = 0;
}
void StackPush(Stack* p, DataType data) //入棧
{
    assert(p);
    if (p->top <= max)
    {
        p->stack[p->top] = data;
        p->top++;
    }
    else
    {
        printf("stack fill\n");
    }
}
int StackPop(Stack* p)//出棧
{
    //int ch;
    assert(p);
    if (p->top != 0)
    {
        p->top--;
        //ch = p->stack[p->top];
        return p->stack[p->top];
    }

}
int StackTop(Stack* p)//取棧頂元素
{
    int n;
    assert(p);
    if(p->top)
    {
        n = p->top;
        return p->stack[n-1];
    }

    return 0;
}
int CalRPN(cell* RPN, int sz)//逆波蘭表示式（字尾表示式）
{
    int i = 0;
    Stack s;
    assert(RPN);
    StackInit(&s);
    for (; i < sz; i++)  //依次遍歷
    {
        int left = 0;//左運算元
        int right = 0;//右運算元
        switch (RPN[i].op) //swatch語句判斷表示式是數字還是字元，並跳轉到相應操作
        {
        case Data:
            StackPush(&s, RPN[i].data);      //入棧
            break;
        case Add:                             //加法
            right = StackPop(&s);             //從棧中獲取運算元
            left = StackPop(&s);
            StackPush(&s, right + left);      //結果入棧
            break;
        case Sub:                               //減法
            right = StackPop(&s);
            left = StackPop(&s);
            StackPush(&s, left - right);
            break;
        case Mul:                            //乘法
            right = StackPop(&s);
            left = StackPop(&s);
            StackPush(&s, left * right);
            break;
        case Div:                            //除法
            right = StackPop(&s);
            left = StackPop(&s);
            if (0 == right)
                printf("除數非法\n");
            else
                StackPush(&s, left / right);
            break;
        }
    }
    return StackTop(&s);
}

測試：

void RPNTest()
{   //這個陣列是cell型別的在上面有相應的結構體，結構體有兩個成員，一個是列舉型別的變數，一個是整形變數；
    cell RPN[] = { {Data,12},{Data,3},{Data,4},{Add,0},{Mul,0},{Data,6},
                   {Sub,0},{Data,8},{Data,2},{Div,0},{Add,0} };
    int sz = sizeof(RPN) / sizeof(RPN[0]);
    int ret = CalRPN(RPN, sz);
    printf("%d\n", ret);
}