打卡 DAY 34 逆波兰表达式求值

力扣原题链接

一、题目描述

二、思路

遍历字符串数组，遇到数字则入栈，遇到运算符就将前两个数字进行相应的运算，并把计算结果压入栈，遍历完字符串数组后输出栈中的数字。

三、解题过程

• 实现数字入栈运算符计算接口函数

• 先定义左右操作数 left 和 right；
• 当栈长度大于2时对 left 和 right 赋值；
• 定义字符串的ASCII值 num，若字符串为数字则直接将数字压入栈；若字符串为运算符，则对左右操作数进行相应的运算：

void count(int* stack, char* val, int* top){
    int left, right;
    if(*top > 1){
        left = stack[(*top) - 2];
        right = stack[(*top) - 1];
    }
    int num = *val;
    if(*val == '0' || atoi(val)){
        num = atoi(val);
        stack[(*top)++] = num;
        return;
    }
    switch(num){
        case '+':
            stack[(*top) - 2] = left + right;
            (*top)--;
            break;
        case '-':
            stack[(*top) - 2] = left - right;
            (*top)--;
            break;
        case '*':
            stack[(*top) - 2] = left * right;
            (*top)--;
            break;
        case '/':
            stack[(*top) - 2] = left / right;
            (*top)--;
            break;
    }
}

• 初始化栈

    int* stack = (int*)malloc(sizeof(int) * tokensSize);

• 对所给字符串数组进行计算

    int top = 0;
    for(int i = 0; i < tokensSize; i++){
        count(stack, tokens[i], &top);
    }

• 返回栈中唯一剩下的元素

• 当计算结束时栈中剩下的元素就是计算结果：

    return stack[0];

四、代码

void count(int* stack, char* val, int* top){
    int left, right;
    if(*top > 1){
        left = stack[(*top) - 2];
        right = stack[(*top) - 1];
    }
    int num = *val;
    if(*val == '0' || atoi(val)){
        num = atoi(val);
        stack[(*top)++] = num;
        return;
    }
    switch(num){
        case '+':
            stack[(*top) - 2] = left + right;
            (*top)--;
            break;
        case '-':
            stack[(*top) - 2] = left - right;
            (*top)--;
            break;
        case '*':
            stack[(*top) - 2] = left * right;
            (*top)--;
            break;
        case '/':
            stack[(*top) - 2] = left / right;
            (*top)--;
            break;
    }
}

int evalRPN(char ** tokens, int tokensSize){
    int* stack = (int*)malloc(sizeof(int) * tokensSize);
    int top = 0;
    for(int i = 0; i < tokensSize; i++){
        count(stack, tokens[i], &top);
    }
    return stack[0];
}

时间复杂度：O(n)，空间复杂度：O(n)。