逆波兰表达式（栈的应用）

头文件RPN.h
#pragma once

#include "Stack.h"

typedef enum RPN_TYPE//定义枚举型变量
{
    OP_NUM,
    OP_SYMBOL,
    OP_ADD,
    OP_SUB,
    OP_MUL,
    OP_DIV,
}RPN_TYPE;

typedef struct Cell
{
    RPN_TYPE _type;
    int value;
}Cell;

int StackRPN(Cell *rpn, size_t n);//计算函数

源文件RPN.c
#include"RPN.h"

int StackRPN(Cell *rpn, size_t n)//计算函数
{
    assert(rpn);
    Stack Rpn;
    size_t i = 0;
    StackInit(&Rpn);//栈初始化
    for (i; i < n; i++)
    {
        if (OP_NUM == rpn[i]._type)//判断类型是数字还是字符，数字入栈
        {
            StackPush(&Rpn, rpn[i].value);
        }
        else //字符出栈操作
        {
            int right = 0;
            int left = 0;
            right = StackTop(&Rpn);
            StackPop(&Rpn);
            left = StackTop(&Rpn);
            StackPop(&Rpn);
            switch (rpn[i].value)//判断字符类型，并进行操作后再入栈
            {

            case OP_ADD:
                StackPush(&Rpn, left + right);
                break;
            case OP_SUB:
                StackPush(&Rpn, left - right);
                break;
            case OP_MUL:
                StackPush(&Rpn, left * right);
                break;
            case OP_DIV:
                StackPush(&Rpn, left / right);
                break;
            default:
                printf("符号错误，请检查\n");
                break;
            }
        }
    }
    return StackTop(&Rpn);//返回栈顶的值
}

测试源文件Test.c
#include"RPN.h"

Test()
{
    int n = 0;
    Cell rpn[] =
    {
        { OP_NUM, 10 },
        { OP_NUM, 4 },
        { OP_NUM, 6 },
        { OP_SYMBOL, OP_ADD },
        { OP_SYMBOL, OP_DIV },
        { OP_NUM, 6 },
        { OP_NUM, 2 },
        { OP_SYMBOL, OP_MUL },
        { OP_SYMBOL, OP_SUB },
        { OP_NUM, 21 },
        { OP_SYMBOL, OP_ADD },
    };
    n = sizeof(rpn) / sizeof(Cell);
    printf("计算结果：%d\n",StackRPN(rpn, n));

}
int main()
{
    Test();
    system("pause");
    return 0;
}

测试结果：

上面调用的栈函数需要的请戳构建栈和队列