LeetCode【代码随想录】刷题（栈与队列篇）

于 2024-11-29 10:25:02 发布
阅读量800 收藏 24
点赞数 16
分类专栏： 刷题记录 文章标签： leetcode c++ 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/m0_51507437/article/details/144097311
版权

232.用栈实现队列

力扣题目链接

题目：请你仅使用两个栈实现先入先出队列。队列应当支持一般队列支持的所有操作（push、pop、peek、empty）：

实现 MyQueue 类：

  • void push(int x) 将元素 x 推到队列的末尾
  • int pop() 从队列的开头移除并返回元素
  • int peek() 返回队列开头的元素
  • boolean empty() 如果队列为空，返回 true ；否则，返回 false

说明：

  • 你 只能 使用标准的栈操作 —— 也就是只有 push to top, peek/pop from top, size, 和 is empty 操作是合法的。
  • 你所使用的语言也许不支持栈。你可以使用 list 或者 deque（双端队列）来模拟一个栈，只要是标准的栈操作即可。

思路：模拟即可

通过代码：

class MyQueue {
private:
    stack<int> s1,s2;
    int front;
public:
    MyQueue() {
    }
    
    void push(int x) {
        if(s1.empty())
            front = x;
        s1.push(x);
    }
    
    int pop() {
        int len = s1.size();
        for(int i = 0; i < len - 1; i++)
        {
            s2.push(s1.top());
            s1.pop();
        }
        int val = s1.top();
        s1.pop();
        if(!s2.empty())
        {
            front = s2.top();
            len = s2.size();
            for(int i = 0; i < len; i++)
            {
                s1.push(s2.top());
                s2.pop();
            }
        }
        return val;
    }
    
    int peek() {
        return front;
    }
    
    bool empty() {
        return s1.empty();
    }
};

225. 用队列实现栈

力扣题目链接

题目：请你仅使用两个队列实现一个后入先出（LIFO）的栈，并支持普通栈的全部四种操作（push、top、pop 和 empty）。

实现 MyStack 类：

  • void push(int x) 将元素 x 压入栈顶。
  • int pop() 移除并返回栈顶元素。
  • int top() 返回栈顶元素。
  • boolean empty() 如果栈是空的，返回 true ；否则，返回 false 。

注意：

  • 你只能使用队列的标准操作 —— 也就是 push to back、peek/pop from front、size 和 is empty 这些操作。
  • 你所使用的语言也许不支持队列。 你可以使用 list （列表）或者 deque（双端队列）来模拟一个队列 , 只要是标准的队列操作即可。

思路：模拟即可

通过代码：

class MyStack {
    queue<int> q;
public:
    MyStack() {
    }
    
    void push(int x) {
        q.push(x);
    }
    
    int pop() {
        int len =  q.size();
        for(int i = 0; i < len - 1; i++)
        {
            q.push(q.front());
            q.pop();
        }
        int val = q.front();
        q.pop();
        return val;
    }
    
    int top() {
        int len = q.size();
        for(int i = 0; i < len - 1; i++)
        {
            q.push(q.front());
            q.pop();
        }
        int val = q.front();
        q.push(q.front());
        q.pop();
        return val;
    }
    
    bool empty() {
        return q.empty();
    }
};

20. 有效的括号

力扣题目链接

题目：给定一个只包括 '('，')'，'{'，'}'，'['，']' 的字符串 s ，判断字符串是否有效。

有效字符串需满足：

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

思路：每遇到一个左括号就入栈，遇到右括号的时候看和栈顶的括号是否匹配

通过代码：

class Solution {
public:
    bool isValid(string s) {
        stack<char> stk;
        for(char c : s)
        {
            if(c == '(' || c == '{' || c == '[')
                stk.push(c);
            else
            {
                if(stk.empty())
                    return false;
                char target = stk.top();
                if(target == '(' && c == ')')
                    stk.pop();
                else if(target == '{' && c == '}')
                    stk.pop();
                else if(target == '[' && c == ']')
                    stk.pop();
                else
                    return false;
            }
        }
        return stk.size() == 0;
    }
};

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

力扣题目链接

题目：给出由小写字母组成的字符串 S，重复项删除操作会选择两个相邻且相同的字母，并删除它们。

在 S 上反复执行重复项删除操作，直到无法继续删除。

在完成所有重复项删除操作后返回最终的字符串。答案保证唯一。

思路：栈

通过代码：

class Solution {
public:
    string removeDuplicates(string s) {
        string res;
        for(char c : s)
        {
            if(!res.empty() && res.back() == c)
                res.pop_back();
            else
                res.push_back(c);
        }
        return res;
    }
};

150. 逆波兰表达式求值

力扣题目链接

题目：给你一个字符串数组 tokens ，表示一个根据 逆波兰表示法 表示的算术表达式。

请你计算该表达式。返回一个表示表达式值的整数。

注意：

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

思路：类似上面那道题

通过代码：

class Solution {
public:
    int evalRPN(vector<string>& tokens) {
        stack<int> s;
        for(string str : tokens)
        {
            if(str != "+" && str != "-" && str != "*" && str != "/")
                s.push(stoi(str));
            else
            {
                int b = s.top();
                s.pop();
                int a = s.top();
                s.pop();
                if(str == "+")
                    s.push(a + b);
                else if(str == "-")
                    s.push(a - b);
                else if(str == "*")
                    s.push(a * b);
                else
                    s.push(a / b);
            }
        }
        return s.top();
    }
};

239. 滑动窗口最大值

力扣题目链接

题目：给你一个整数数组 nums，有一个大小为 k 的滑动窗口从数组的最左侧移动到数组的最右侧。你只可以看到在滑动窗口内的 k 个数字。滑动窗口每次只向右移动一位。

返回 滑动窗口中的最大值 。

思路：我们并不用关心所有的元素，只需要关心有可能成为最大值的元素。维护一个单调递减的队列，队首一定是窗口内最大的元素，接下来从大到小是有可能接替队首的元素。因为能接替队首，所以这些元素都是后进入窗口的。所以这个单调队列不仅值从大到小，进入窗口的顺序也是从早到晚的。为了维护这个队列，每当一个新元素进入窗口时，要剔除队列尾部比他小的元素，保持这个新元素在队列中的最后一个位置。当有元素滑出窗口时，只要不是最大值都不会改变结果，所以只有最大值滑出窗口的时候才真正从单调队列里移除队首元素。

通过代码：

class Solution {
public:
    vector<int> maxSlidingWindow(vector<int>& nums, int k) {
        vector<int> res;
        deque<int> dq;
        for(int i = 0; i < k; i++)
        {
            while(!dq.empty() && nums[i] > dq.back())
                dq.pop_back();
            dq.push_back(nums[i]);
        }
        res.push_back(dq.front());
        for(int i = k; i < nums.size(); i++)
        {
            if(dq.front() == nums[i - k])
                dq.pop_front();
            while(!dq.empty() && nums[i] > dq.back())
                dq.pop_back();
            dq.push_back(nums[i]);
            res.push_back(dq.front());
        }
        return res;
    }
};

347.前 K 个高频元素

力扣题目链接

题目：给你一个整数数组 nums 和一个整数 k ，请你返回其中出现频率前 k 高的元素。你可以按 任意顺序 返回答案。

思路：先用一个map统计一下频率，再全部放到一个大顶堆里（由于优先队列的排序规则，放到堆里的时候需要调换一下first和second），依次取出前k个即可。

通过代码：

class Solution {
public:
    vector<int> topKFrequent(vector<int>& nums, int k) {
        map<int, int> m;
        for(int n: nums)
            m[n]++;
        priority_queue<pair<int,int>> heap;
        for(auto iter = m.begin(); iter != m.end(); iter++)
            heap.push({iter -> second, iter -> first});
        vector<int> res;
        for(int i = 0; i < k; i++)
        {
            res.push_back(heap.top().second);
            heap.pop();
        }
        return res;
    }
};
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

h0l10w

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值