数据结构与算法 05 栈与逆波兰表达式

正在学习数据结构与算法，学习资料是小甲鱼的《数据结构和算法》，记录日志

#include "data.h"
#include <stdio.h>
#include <stdlib.h>

int main() {
    LinkStack* L = CreateLinkStack();
    char* p = "12-45+*";
    char* s = (char*)malloc(sizeof(char));

    int* i = (int*)malloc(sizeof(int));
    int* j = (int*)malloc(sizeof(int));
    int* k = (int*)malloc(sizeof(int));
    while(*p != '\0') {
        switch(*p) {
        case '-':
            Pop(L, i);
            Pop(L, j);
            *k = *j - *i;
            Push(L, k);
            break;
        case '+':
            Pop(L, i);
            Pop(L, j);
            *k = *i + *j;
            Push(L, k);
            break;
        case '*':
            Pop(L, i);
            Pop(L, j);
            *k = *i * *j;
            Push(L, k);
            break;
        default:
            *s = *p;
            // 这块不能直接用p，实验是用p不能得到正确的i值
            *i = atof(s);
            Push(L, i);
            break;
        }
        printf("%c\n", *p);
        p++;
    }

    Pop(L, i);
    printf("%d\n", *i);

    return 0;
}

#define OK 1;

typedef struct StackNode{
    int data;
    struct StackNode* next;
} StackNode;

typedef struct LinkStack{
    StackNode* top;
    int count;
} LinkStack;

LinkStack* CreateLinkStack(void);
int Push(LinkStack* L, int* e);
int Pop(LinkStack* L, int* e);

#include "data.h"
#include <stdlib.h>

LinkStack* CreateLinkStack(void){
    LinkStack* L = (LinkStack*)malloc(sizeof(LinkStack));
    L->count = 0;
    L->top = NULL;

    return L;
}

int Push(LinkStack* L, int* e){
    StackNode* p = (StackNode*)malloc(sizeof(StackNode*));
    p->data = *e;
    p->next = L->top;

    L->top = p;
    L->count++;

    return OK;
}

int Pop(LinkStack* L, int* e){
    StackNode* s = L->top;

    *e = s->data;
    L->top = s->next;
    L->count--;
    free(s);

    return OK;
}