数据结构-7-栈的简单应用--混合运算器

栈的简单应用RPN
使用栈动态模拟，混合运算的过程：
38+4*6-25由逆波兰表达式可得到：
{ OP_NUM, 38 },
{ OP_NUM, 6 },
{ OP_NUM, 4 },
{ OP_SYMBOL, OP_MUL },
{ OP_SYMBOL, OP_ADD },
{ OP_NUM, 25 },
{ OP_SYMBOL, OP_SUB },

//栈的实现
#ifndef stack_h
#define stack_h

#include<stdio.h>
#include<Windows.h>
#include<assert.h>
#include<malloc.h>


typedef int DataType;

typedef struct Stack
{
    DataType* _array;
    size_t _top; //栈顶 
    size_t _end;
}Stack;

// 栈的实现接口 
void StackInit(Stack*s, size_t top);
void StackPush(Stack* s, DataType x);
void StackPop(Stack* s);
DataType StackTop(Stack* s);
size_t StackSize(Stack* s);
int StackEmpty(Stack* s);
void Stackcheck(Stack*s);
void StackPrint(Stack*s);

void StackPrint(Stack*s)
{
    size_t i = 0;
    while (i < s->_top)
    {
        printf("%d ", s->_array[i]);
        i++;
    }
}
void Stackcheck(Stack*s)
{
    if (s->_top >= s->_end)
    {
        DataType*array = (DataType*)realloc(s, sizeof(DataType)* 2);
        assert(array);
        s->_array = array;
        s->_end = s->_end * 2;
    }
}
void StackInit(Stack*s, size_t end)
{
    assert(s&&end > 0);
    s->_array = (DataType*)malloc(end*sizeof(DataType));
    assert(s->_array);

    s->_top = 0;
    s->_end = end;
}

void StackPush(Stack* s, DataType x)
{
    Stackcheck(s);
    s->_array[s->_top] = x;
    s->_top++;
}

void StackPop(Stack* s)
{
    s->_array[s->_top - 1] = 0;
    s->_top--;
}

DataType StackTop(Stack* s)
{
    return s->_array[s->_top - 1];
}

size_t StackSize(Stack* s)
{
    return s->_top;
}

int StackEmpty(Stack* s)
{
    if (s->_top == 0)
        return 1;
    else
        return 0;
}

#endif

//运算器函数实现
#ifndef RPN_h
#define RPN_h

#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;//定义每一个操作的单元的类型：数(OP_NUM)还是操作符(OP_SYMBOL)
    int value;//这个操作单元的值
}Cell;

int CountRPN(Cell *rpn, size_t n)//计算函数
{
    assert(rpn);
    Stack s;
    StackInit(&s, 30);
    for (size_t i = 0; i < n; i++)
    {
        if (rpn[i]._type == OP_NUM)
            StackPush(&s, rpn[i].value);//如果是数进行入栈
        else//如果是操作符，取栈顶值作为操作右值，栈顶数据出栈，
        //再取栈顶值作为左值，进行操作后，结果再次入栈，如此最后栈顶只剩最后的结果了
        {
            int right = 0, left = 0;
            right = StackTop(&s);
            StackPop(&s);
            left = StackTop(&s);
            StackPop(&s);
            switch (rpn[i].value)
            {
            case OP_ADD:
                StackPush(&s, left + right);
                break;
            case OP_SUB:
                StackPush(&s, left - right);
                break;
            case OP_MUL:
                StackPush(&s, left * right);
                break;
            case OP_DIV:
                StackPush(&s, left / right);
                break;
            default:
                printf("输入错误！");
                break;
            }
        }
    }
    return StackTop(&s);
}
#endif

//主函数以及测试部分

#include"RPN.h"


void test()
{
    int n = 0;
    Cell rpn[] = {
        { OP_NUM, 38 },
        { OP_NUM, 6 },
        { OP_NUM, 4 },
        { OP_SYMBOL, OP_MUL },
        { OP_SYMBOL, OP_ADD },
        { OP_NUM, 25 },
        { OP_SYMBOL, OP_SUB },

    };
    n = sizeof(rpn) / sizeof(rpn[0]);
    printf("计算结果：%d\n", CountRPN(rpn, n));

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