代码随想录算法训练营第十一天 | 20. 有效的括号，1047. 删除字符串中的所有相邻重复项，150. 逆波兰表达式求值[栈与队列篇]

LeetCode 20. 有效的括号

题目链接：20. 有效的括号
文章讲解：代码随想录#20. 有效的括号
视频讲解：栈的拿手好戏！| LeetCode：20. 有效的括号

题目描述

给定一个只包括 ‘(’，‘)’，‘{’，‘}’，‘[’，‘]’ 的字符串 s ，判断字符串是否有效。
有效字符串需满足：

• 左括号必须用相同类型的右括号闭合。
• 左括号必须以正确的顺序闭合。
• 每个右括号都有一个对应的相同类型的左括号。

示例1

输入：s = “()”
输出：true

示例2

输入：s = “()[]{}”
输出：true

示例3

输入：s = “(]”
输出：false

提示

• 1 <= s.length <= 10^4
• s 仅由括号 ‘()[]{}’ 组成

思路

括号匹配是一道典型的使用栈结构解决的问题。
经过分析，括号不匹配存在以下三种情况：

• 字符串中左边括号多余
• 字符串中右边括号多余
• 字符串中两边括号个数相等，但类型不匹配

大体思路如下：
首先循环遍历字符串，
当遍历左括号时，则向栈中push对应的右括号，主要是为了后面匹配右括号进行比较。
当遍历右括号时，如果栈为空，则返回false，如果栈不为空，则依次从栈中取出之前存入的右括号与之进行对比，如果相等，则pop，如果不相等，则返回false。
当字符串遍历完成后，对栈进行判断，如果栈不为空，则返回fasle，否则返回true。

当然了这道题还可以进行减枝，因为是括号匹配，则字符肯定为偶数个，如果是奇数，则直接可以返回false了。

参考代码

typedef struct {
    int Idx;
    char stack[10000]; // 最多元素是10000个，可以使用数组
} Stack;

Stack *stackCreate() {
    Stack *obj = (Stack *)malloc(sizeof(Stack));
    obj->Idx = 0;
    memset(&obj->stack[0], 0, 10000 * sizeof(char));

    return obj;
}

void stackPush(Stack* obj, char x) {
    obj->stack[obj->Idx++] = x;
}

void stackPop(Stack* obj) {
    obj->Idx--;
}

char stackPeek(Stack* obj) {
    if (obj->Idx == 0) {
        return -1;
    }
    return obj->stack[obj->Idx - 1];
}

bool isStackEmpty(Stack* obj) {
    if (obj->Idx == 0) {
        return true;
    }
    return false;
}


bool isValid(char* s) {
    int len = strlen(s);
    if (len % 2 != 0) {
        return false; // 减枝，匹配的符号需要是偶数个
    }

    Stack *obj = stackCreate();

    for (int i = 0; i < len; i++) {
        if (s[i] == '(' || s[i] == '[' || s[i] == '{') { // 比较左括号
            if (s[i] == '(') {
                stackPush(obj, ')');
            } else if (s[i] =='[') {
                stackPush(obj, ']');
            } else {
                stackPush(obj, '}');
            }
        } else {
            if (isStackEmpty(obj) || s[i] != stackPeek(obj)) {
                return false;
            }
            stackPop(obj);
        }
    }
    return isStackEmpty(obj);
}

总结

1. 栈数据结构只能解决特定的问题，一般是固定顺序的相邻元素是否相同的问题。

---

LeetCode 1047. 删除字符串中的所有相邻重复项

题目链接：1047. 删除字符串中的所有相邻重复项
文章讲解：代码随想录#1047. 删除字符串中的所有相邻重复项
视频讲解：栈的好戏还要继续！| LeetCode：1047. 删除字符串中的所有相邻重复项

题目描述

给出由小写字母组成的字符串 S，重复项删除操作会选择两个相邻且相同的字母，并删除它们。
在 S 上反复执行重复项删除操作，直到无法继续删除。
在完成所有重复项删除操作后返回最终的字符串。答案保证唯一。

示例1

输入：“abbaca”
输出：“ca”
解释：
例如，在 “abbaca” 中，我们可以删除 “bb” 由于两字母相邻且相同，这是此时唯一可以执行删除操作的重复项。之后我们得到字符串 “aaca”，其中又只有 “aa” 可以执行重复项删除操作，所以最后的字符串为 “ca”。

提示

• 1 <= S.length <= 20000
• S 仅由小写英文字母组成

思路

思路还是和上道题一样，采用栈结构可以完美地解决这道题。
循环遍历整个字符串，依次判断当前字符与栈顶元素，如果相等，则pop，如果不相等，则继续遍历。
遍历结束后，输出栈中的元素，注意顺序。因为我用的是数组模拟栈，所以输出比较方便。

参考代码

typedef struct {
    int Idx;
    char stack[100000]; // 最多元素是100000个，可以使用数组
} Stack;

Stack *stackCreate() {
    Stack *obj = (Stack *)malloc(sizeof(Stack));
    obj->Idx = 0;
    memset(&obj->stack[0], 0, 1000000 * sizeof(char));

    return obj;
}

void stackPush(Stack* obj, char x) {
    obj->stack[obj->Idx++] = x;
}

void stackPop(Stack* obj) {
    obj->Idx--;
}

char stackPeek(Stack* obj) {
    if (obj->Idx == 0) {
        return -1;
    }
    return obj->stack[obj->Idx - 1];
}

bool isStackEmpty(Stack* obj) {
    if (obj->Idx == 0) {
        return true;
    }
    return false;
}

char* removeDuplicates(char* s) {
    Stack *obj = stackCreate();
    int len = strlen(s);

    for (int i = 0; i < len; i++) {
        if (s[i] == stackPeek(obj)) {
            stackPop(obj);
        } else {
            stackPush(obj, s[i]);
        }
    }

    obj->stack[obj->Idx] = '\0'; // 重新设置字符数组
    return obj->stack;
}

总结

1. 用例提示中明明写了，字符串最多20000个，所以我在构造数组元素时只定义了20000个。结果力扣上有个极端用例，大小是100000，导致用例没有通过。
   好在我的数组是char型的，即使定义成100000级别大小的数组，也没有内存溢出。在我的意识中，像这种万以上级别的数组大小，肯定不能声明数组了，需要从堆中动态分配内存了。

---

LeetCode 150. 逆波兰表达式求值

题目链接：150. 逆波兰表达式求值
文章讲解：代码随想录#150. 逆波兰表达式求值
视频讲解：栈的最后表演！ | LeetCode：150. 逆波兰表达式求值

题目描述

给你一个字符串数组 tokens ，表示一个根据 逆波兰表示法 表示的算术表达式。
请你计算该表达式。返回一个表示表达式值的整数。

注意：

• 有效的算符为 ‘+’、‘-’、‘*’ 和 ‘/’ 。
• 每个操作数（运算对象）都可以是一个整数或者另一个表达式。
• 两个整数之间的除法总是 向零截断 。
• 表达式中不含除零运算。
• 输入是一个根据逆波兰表示法表示的算术表达式。
• 答案及所有中间计算结果可以用 32 位 整数表示。

示例1

输入：tokens = [“2”,“1”,“+”,“3”,“*”]
输出：9
解释：该算式转化为常见的中缀算术表达式为：((2 + 1) * 3) = 9

示例2

输入：tokens = [“4”,“13”,“5”,“/”,“+”]
输出：6
解释：该算式转化为常见的中缀算术表达式为：(4 + (13 / 5)) = 6

示例3
.>输入：tokens = [“10”,“6”,“9”,“3”,“+”,“-11”,““,”/“,””,“17”,“+”,“5”,“+”]

输出：22
解释：该算式转化为常见的中缀算术表达式为：
((10 * (6 / ((9 + 3) * -11))) + 17) + 5
= ((10 * (6 / (12 * -11))) + 17) + 5
= ((10 * (6 / -132)) + 17) + 5
= ((10 * 0) + 17) + 5
= (0 + 17) + 5
= 17 + 5
= 22

提示

• 1 <= tokens.length <= 104
• tokens[i] 是一个算符（“+”、“-”、“*” 或 “/”），或是在范围 [-200, 200] 内的一个整数

思路

首先得明白什么是逆波兰表达式？
逆波兰表达式是一种后缀表达式，所谓后缀就是指算符写在后面。
平常使用的算式则是一种中缀表达式，如 ( 1 + 2 ) * ( 3 + 4 ) 。
该算式的逆波兰表达式写法为 ( ( 1 2 + ) ( 3 4 + ) * ) 。

逆波兰表达式主要有以下两个优点：

• 去掉括号后表达式无歧义，上式即便写成 1 2 + 3 4 + * 也可以依据次序计算出正确结果。
• 适合用栈操作运算：遇到数字则入栈；遇到算符则取出栈顶两个数字进行计算，并将结果压入栈中

这道题的思路是使用栈结构，遍历字符串，如果是数字的话，就入栈，如果是符号的话，就pop出邻近两个数组进行运算，并将结果再次push到栈中，直到字符串遍历完，此时再pop出栈中的数字。

参考代码

typedef struct {
    int Idx;
    int stack[10000]; // 最多元素是10000个，可以使用数组
} Stack;

Stack *stackCreate() {
    Stack *obj = (Stack *)malloc(sizeof(Stack));
    obj->Idx = 0;
    memset(&obj->stack[0], 0, 10000 * sizeof(char));

    return obj;
}

void stackPush(Stack* obj, int x) {
    obj->stack[obj->Idx++] = x;
}

int stackPop(Stack* obj) {
    obj->Idx--;
    return obj->stack[obj->Idx];
}

int evalRPN(char** tokens, int tokensSize) {
    Stack *obj = stackCreate();

    for (int i = 0; i < tokensSize; i++) {
        if (!strcmp(tokens[i], "+") || !strcmp(tokens[i], "-") ||
            !strcmp(tokens[i], "*") || !strcmp(tokens[i], "/")) {
            int numb = stackPop(obj);
            int numa = stackPop(obj);
            int nums;
            if (!strcmp(tokens[i], "+")) {
                nums = numa + numb;
            } else if (!strcmp(tokens[i], "-")) {
                nums = numa - numb;
            } else if (!strcmp(tokens[i], "*")) {
                nums = numa * numb;
            } else {
                nums = numa / numb;
            }
            stackPush(obj, nums);
        } else {
            stackPush(obj, atoi(tokens[i]));
        }
    }
    return stackPop(obj);
}

总结

1. 忽然觉得自己实现栈的操作过程挺有趣的，也没有办法，对C语言来说，尽可能自己动手，库函数真是少得可怜啊。