Leetcode算法训练日记 | day11

一、有效的括号

1.题目

Leetcode：第 20 题
给定一个只包括 '('，')'，'{'，'}'，'['，']' 的字符串 s ，判断字符串是否有效。
有效字符串需满足：
1.左括号必须用相同类型的右括号闭合。
2.左括号必须以正确的顺序闭合。
3.每个右括号都有一个对应的相同类型的左括号。

示例 1：
输入：s = "()"
输出：true
示例 2：
输入：s = "()[]{}"
输出：true
示例 3：
输入：s = "(]"
输出：false

2.解题思路

1.如果字符串长度是奇数，则不可能是有效的括号匹配。

2.当字符串长度是偶数时，遍历整个字符串，遇到左括号就把对应的右括号压入栈中，
如果遇到右括号，就与栈顶的右括号对比是否相同，相同就弹栈。当找到最后右括号时，栈已经为空，或者与栈顶括号不一样就是匹配失败。

3.遍历所有括号，栈为空，则说明匹配成功。

3.实现代码

#include <iostream>
#include <stack>
using namespace std;

class Solution 
{
public:
    bool isValid(string s) {
        if (s.size() % 2 != 0) {
            return false; // 如果字符串长度是奇数，则不可能是有效的括号匹配，直接返回false
        }
        stack<char> st; // 定义一个栈st，用于存储括号的匹配
        for (int i = 0; i < s.size(); i++) {
            // 遍历字符串s中的每个字符
            if (s[i] == '(') {
                st.push(')'); // 如果当前字符是'('，将其匹配的括号')'压入栈中
            }
            else if (s[i] == '[') {
                st.push(']'); // 如果当前字符是'['，将其匹配的括号']'压入栈中
            }
            else if (s[i] == '{') {
                st.push('}'); // 如果当前字符是'{'，将其匹配的括号'}'压入栈中
            }
            else if (st.top() != s[i] || st.empty()) {
                // 如果当前字符是闭括号且它不匹配栈顶的括号，或者栈为空，则返回false
                return false;
            }
            else {
                st.pop(); // 如果当前字符是闭括号且匹配栈顶的括号，则从栈中弹出栈顶元素
            }
        }
        // 遍历结束后，如果栈为空，说明所有的括号都正确匹配；如果栈不为空，则存在不匹配的括号，返回false
        return st.empty();
    }
};

//测试
int main()
{
    Solution p;
    string s = "()[]{}";
    cout <<"s = " << s << endl;
    if (p.isValid(s))
    {
        cout<<"括号匹配成功" << endl;
    }
    else {
        cout << "括号匹配失败" << endl;
    }
    cout <<endl;
    return 0;
}

二、删除字符串中的所有相邻重复项

1.题目

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

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

2.解题思路

利用栈的原理，初始化一个空字符串result，用于存储结果。通过遍历字符串字符，检查当前字符是否与 result 字符串的最后一个字符相同来实现。
如果不同，就将当前字符添加到 result 中，即末尾，如果相同，就移除 result 中的最后一个字符；
最终返回的 result 字符串中不包含任何连续重复的字符。

3.实现代码

#include <iostream>
#include <stack>
using namespace std;

class Solution 
{
public:
    //removeDuplicates函数用于从字符串s中移除连续重复的字符
    string removeDuplicates(string s) 
    {
        string result; // 初始化一个空字符串result，用于存储结果
        for (char c : s) // 遍历字符串s中的每个字符c
        { 
            if (!result.empty() && result.back() == c) // 如果result不为空，并且result的最后一个字符与当前字符c相同
            {
                result.pop_back(); // 移除result中的最后一个字符，即连续重复的字符
            }
            else 
            {
                result.push_back(c); // 否则，将当前字符c添加到result中
            }
        }
        return result; // 返回结果字符串result
    }
};

//测试
int main()
{
    Solution p;
    string s = "abbaca";
    cout <<"s = " << s << endl;
    cout<<"结果：" <<p.removeDuplicates(s)<< endl;
    cout <<endl;
    return 0;
}

三、逆波兰表达式求值

1.题目

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

2.解题思路

通过使用栈来计算逆波兰表示法的表达式。在遇到操作数时，将其压入栈中；
在遇到运算符时，从栈中弹出两个操作数，进行相应的运算，并将结果压回栈中。
最终，栈顶元素即为整个表达式的结果。

3.实现代码

#include <iostream>
#include <vector>
#include <stack>
#include <string>
using namespace std;

class Solution 
{
public:
    // evalRPN函数用于计算逆波兰表示法（RPN）的表达式
    int evalRPN(vector<string>& tokens) 
    {
        stack<long long> st; // 创建一个长长整型栈st，用于存储数字和进行运算
        for (int i = 0; i < tokens.size(); i++) // 遍历tokens中的每个元素
        { 
            // 如果当前元素是一个运算符
            if (tokens[i] == "+" || tokens[i] == "-" 
                || tokens[i] == "*" || tokens[i] == "/") 
            {
                long long num1 = st.top(); // 获取栈顶元素（第一个操作数）
                st.pop(); // 弹出栈顶元素
                long long num2 = st.top(); // 获取新的栈顶元素（第二个操作数）
                st.pop(); // 弹出新的栈顶元素


                // 根据运算符进行计算，并将结果压入栈中
                if (tokens[i] == "+") st.push(num2 + num1);
                if (tokens[i] == "-") st.push(num2 - num1);
                if (tokens[i] == "*") st.push(num2 * num1);
                if (tokens[i] == "/") st.push(num2 / num1);
            }
            // 如果当前元素是一个操作数
            else 
            {
                st.push(stoll(tokens[i])); // 将字符串转换为长长整数，并压入栈中
            }
        }
        int result = st.top(); // 获取栈顶元素，即最终的计算结果
        st.pop(); // 弹出栈顶元素
        return result; // 返回计算结果
    }
};

//测试
int main()
{
    vector<string>tokens = { "2", "1", "+", "3", "*" };
    for (auto& c : tokens)
    {
        cout << c << " ";
    }
    cout << endl;
    Solution s;
    cout <<"计算结果是："<<s.evalRPN(tokens)<< endl;
    cout <<endl;
    return 0;
}

ps：以上皆是本人在探索算法世界的旅途中的浅薄见解，诚挚地希望得到各位的宝贵意见与悉心指导，若有不足或谬误之处，还请多多指教。