逆波兰表达式求值

//先出栈的是右操作数，后出栈的是左操作数
typedef struct lnode {
    int data;
    struct lnode* next;
} node, *stack;

void Push(stack* p, int a) {
    stack cur = (stack)malloc(sizeof(node));
    if (cur == NULL) return;
    cur->data = a;
    cur->next = *p;
    *p = cur;
}
void Pop(stack* p) {
    if (*p != NULL) *p = (*p)->next;
}

int Add(int x, int y) {
    return x + y;
}
int Sub(int x, int y) {
    return x - y;
}
int Mul(int x, int y) {
    return x * y;
}
int Div(int x, int y) {
    return x / y;
}
int Signal(char* s) {
    if (strcmp(s, "+") == 0) return 1;
    else if (strcmp(s, "-") == 0) return 2;
    else if (strcmp(s, "*") == 0) return 3;
    else if (strcmp(s, "/") == 0) return 4;
    else return 0;
}

int evalRPN(char** tokens, int tokensLen ) {
    // write code here
    int j = 0;
    stack s = NULL;
    int(*cal[5])(int, int) = {0, Add, Sub, Mul, Div};
    for (int i = 0; i < tokensLen; i++) {
        char* str =
            tokens[i];//在使用（*tokens）+i赋值变量时程序结果错误
        j = Signal(str);
        if (j) {//遇到运算符出栈运算并将结果入栈
            int right = s->data;
            Pop(&s);
            int left = s->data;
            Pop(&s);
            int z = (*cal[j])(left, right);//使用了函数指针数组
            Push(&s, z);
        } else {//非运算符，将字符串转换成整形入栈
            int m = atoi(str);
            Push(&s, m);
        }
    }
    return s->data;
}

/**
 * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
 *
 *
 * @param tokens string字符串一维数组
 * @param tokensLen int tokens数组长度
 * @return int整型
 *
 * C语言声明定义全局变量请加上static，防止重复定义
 */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
typedef struct {
    char *p;
    int num;
}data_t;

typedef struct stack {
    data_t data[10000];
    int top;
}stack_t;

data_t error = {NULL, -1};

stack_t *stack_create(void)
{
    stack_t *stack = (stack_t *)malloc(sizeof(stack_t));
    memset(stack, 0, sizeof(stack_t));
    stack->top = -1;
    return stack;
}

void stack_push(stack_t *stack, data_t data)
{
    stack->data[++stack->top] = data;
}

int is_empty(stack_t *stack)
{
    return stack->top == -1;
}

data_t stack_top(stack_t *stack)
{
    if(is_empty(stack))
        return error;
    return stack->data[stack->top];
}

data_t stack_pop(stack_t *stack)
{
    if(is_empty(stack)) {
        return error;
    }
    return stack->data[stack->top--];
}
int dataprocess(stack_t *stack, int sign)
{
        int a, b, result;
        data_t temp = {NULL, 0};
        temp = stack_pop(stack);
        if(temp.p)
            a = atoi(temp.p);
        else
            a = temp.num;       
        temp = stack_pop(stack);
        if(temp.p)
            b = atoi(temp.p);
        else
            b = temp.num;
        switch (sign) {
            case 0:
                result = b + a;
                break;
            case 1:
                result = b - a;
                break;
            case 2:
                result = b * a;
                break;
            case 3:
                result = b / a;
                break;
        }
        return result;
}

int evalRPN(char** tokens, int tokensLen ) {
    int i;
    stack_t *stack = stack_create();
    for(i = 0; i < tokensLen; i++) {
        data_t temp = {NULL, 0};
        if(!strcmp(tokens[i], "+")) {
 
            temp.num = dataprocess(stack, 0);
            stack_push(stack, temp);
            
        }else if(!strcmp(tokens[i], "-")) {
            temp.num = dataprocess(stack, 1);
            stack_push(stack, temp);
            
        }else if(!strcmp(tokens[i], "*")) {
            temp.num = dataprocess(stack, 2);
            stack_push(stack, temp);
            
        }else if(!strcmp(tokens[i], "/")) {
            temp.num = dataprocess(stack, 3);
            stack_push(stack, temp);
        }else {
            temp.p = tokens[i];
            stack_push(stack, temp);
        }
    }
    data_t result = stack_pop(stack);
    if(result.p)
        return atoi(result.p);
    else
        return result.num;
}