【leecode】6-栈与队列

chongdada

已于 2023-02-04 21:28:51 修改

阅读量125

点赞数

分类专栏：春招文章标签： leetcode 算法

于 2022-12-19 21:19:40 首次发布

本文链接：https://blog.csdn.net/chongdada/article/details/128211288

版权

春招专栏收录该内容

6 篇文章 0 订阅

订阅专栏

基础知识

1. 栈与队列
 2. 优先队列
刷题参考：代码随想录

1-用栈实现队列

链接: 232

使用栈实现队列的下列操作：
push(x) – 将一个元素放入队列的尾部。
pop() – 从队列首部移除元素。
peek() – 返回队列首部的元素。
empty() – 返回队列是否为空。
说明: 你只能使用标准的栈操作 – 也就是只有 push to top, peek/pop from top, size, 和 is empty 操作是合法的。你所使用的语言也许不支持栈。你可以使用 list 或者 deque（双端队列）来模拟一个栈，只要是标准的栈操作即可。假设所有操作都是有效的（例如，一个空的队列不会调用 pop 或者 peek 操作）。

class MyQueue {
public:
    stack<int> stIn;
    stack<int> stOut;
    /** Initialize your data structure here. */
    MyQueue() {

    }
    /** Push element x to the back of queue. */
    void push(int x) {
        stIn.push(x);
    }

    /** Removes the element from in front of queue and returns that element. */
    int pop() {
        // 只有当stOut为空的时候，再从stIn里导入数据（导入stIn全部数据）
        if (stOut.empty()) {
            // 从stIn导入数据直到stIn为空
            while(!stIn.empty()) {
                stOut.push(stIn.top());
                stIn.pop();
            }
        }
        int result = stOut.top();
        stOut.pop();
        return result;
    }

    /** Get the front element. */
    int peek() {
        int res = this->pop(); // 直接使用已有的pop函数
        stOut.push(res); // 因为pop函数弹出了元素res，所以再添加回去
        return res;
    }

    /** Returns whether the queue is empty. */
    bool empty() {
        return stIn.empty() && stOut.empty();
    }
};

2-用队列实现栈

链接: 225

使用队列实现栈的下列操作：
push(x) – 元素 x 入栈
pop() – 移除栈顶元素
top() – 获取栈顶元素
empty() – 返回栈是否为空
注意:你只能使用队列的基本操作-- 也就是 push to back, peek/pop from front, size, 和 is empty 这些操作是合法的。你所使用的语言也许不支持队列。你可以使用 list 或者 deque（双端队列）来模拟一个队列 , 只要是标准的队列操作即可。你可以假设所有操作都是有效的（例如, 对一个空的栈不会调用 pop 或者 top 操作）

class MyStack {
public:
    queue<int> m_queue;
    queue<int> m_queue_tmp;
    MyStack() {
    }
    
    void push(int x) {
        m_queue.push(x);
    }
    
    int pop() {
        while(m_queue.size() > 1)
        {
            m_queue_tmp.push(m_queue.front());
            m_queue.pop();
        }
        int res = m_queue.front();
        m_queue.pop();
        m_queue = m_queue_tmp;            // 再将que2赋值给que1
        while (!m_queue_tmp.empty()) { // 清空que2
            m_queue_tmp.pop();
        }
        return res;
    }
    
    int top() {
        return m_queue.back();
    }
    
    bool empty() {
        return m_queue.empty();
    }
};

/**
 * Your MyStack object will be instantiated and called as such:
 * MyStack* obj = new MyStack();
 * obj->push(x);
 * int param_2 = obj->pop();
 * int param_3 = obj->top();
 * bool param_4 = obj->empty();
 */

3-有效的括号

链接: 20

给定一个只包括 ‘(’，‘)’，‘{’，‘}’，‘[’，‘]’ 的字符串，判断字符串是否有效。有效字符串需满足：左括号必须用相同类型的右括号闭合。左括号必须以正确的顺序闭合。注意空字符串可被认为是有效字符串。
示例 1: 输入: “()”，输出: true
示例 2: 输入: “()[]{}”，输出: true
示例 3: 输入: “(]”，输出: false
示例 4: 输入: “([)]”，输出: false
示例 5: 输入: “{[]}”，输出: true

时间复杂度 O(n)：正确的括号组合需要遍历 1 遍 s；
空间复杂度 O(n)：栈使用线性的空间大小。

class Solution {
public:
    bool isValid(string s) {
        if (s.size() % 2 != 0) return false; // 如果s的长度为奇数，一定不符合要求
        stack<char> st;
        for (int i = 0; i < s.size(); i++) {
            if (s[i] == '(') st.push(')');
            else if (s[i] == '{') st.push('}');
            else if (s[i] == '[') st.push(']');
            // 第三种情况：遍历字符串匹配的过程中，栈已经为空了，没有匹配的字符了，说明右括号没有找到对应的左括号 return false
            // 第二种情况：遍历字符串匹配的过程中，发现栈里没有我们要匹配的字符。所以return false
            else if (st.empty() || st.top() != s[i]) return false;
            else st.pop(); // st.top() 与 s[i]相等，栈弹出元素
        }
        // 第一种情况：此时我们已经遍历完了字符串，但是栈不为空，说明有相应的左括号没有右括号来匹配，所以return false，否则就return true
        return st.empty();
    }
};

4-删除字符串中的所有相邻重复项

链接: 1047

给出由小写字母组成的字符串 S，重复项删除操作会选择两个相邻且相同的字母，并删除它们。在 S 上反复执行重复项删除操作，直到无法继续删除。在完成所有重复项删除操作后返回最终的字符串。答案保证唯一。
示例：输入：“abbaca”，输出：“ca”
解释：例如，在 “abbaca” 中，我们可以删除 “bb” 由于两字母相邻且相同，这是此时唯一可以执行删除操作的重复项。之后我们得到字符串 “aaca”，其中又只有 “aa” 可以执行重复项删除操作，所以最后的字符串为 “ca”。
提示：1 <= S.length <= 20000，S 仅由小写英文字母组成。

解法一：栈

由于 std::string 类本身就提供了类似「入栈」和「出栈」的接口，因此我们直接将需要被返回的字符串作为栈即可。

时间复杂度：O(n)。
空间复杂度：O(1)。返回值不计入空间复杂度。

class Solution {
public:
    string removeDuplicates(string s) {
        string stgRet = "";
        for(char c:s)
        {
            if(stgRet.empty() || stgRet.back() != c)
            {
                stgRet += c;
            }
            else
            {
                stgRet.pop_back();
            }
        }
        return stgRet;
    }
};

解法二：双指针

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

class Solution {
public:
    string removeDuplicates(string s) {
        if(s.size() < 2)
        {
            return s;
        }
        int slow = 0;
        int fast = 0;
        while(fast < s.size())
        {
            s[slow] = s[fast];
            if(slow > 0 && s[slow] == s[slow - 1])
            {
                slow--;
            }
            else
            {
                slow++;
            }
            fast++;
        }
        return s.substr(0, slow);
    }
};

5-逆波兰表达式求值

链接: 150

根据逆波兰表示法，求表达式的值。有效的运算符包括 + , - , * , / 。每个运算对象可以是整数，也可以是另一个逆波兰表达式。
说明：整数除法只保留整数部分。给定逆波兰表达式总是有效的。换句话说，表达式总会得出有效数值且不存在除数为 0 的情况。
示例 1：
输入: [“2”, “1”, “+”, “3”, " * "]，输出: 9
解释: 该算式转化为常见的中缀算术表达式为：((2 + 1) * 3) = 9
示例 2：输入: [“4”, “13”, “5”, “/”, “+”]，输出: 6
解释: 该算式转化为常见的中缀算术表达式为：(4 + (13 / 5)) = 6
示例 3：输入: [“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 + 2 ) * ( 3 + 4 ) 。
该算式的逆波兰表达式写法为 ( ( 1 2 + ) ( 3 4 + ) * ) 。
逆波兰表达式主要有以下两个优点：
去掉括号后表达式无歧义，上式即便写成 1 2 + 3 4 + * 也可以依据次序计算出正确结果。
适合用栈操作运算：遇到数字则入栈；遇到算符则取出栈顶两个数字进行计算，并将结果压入栈中

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

class Solution {
public:
    int evalRPN(vector<string>& tokens) {
        stack<long long> st;
        for(string s:tokens)
        {
            if(s == "+" || s == "-" || s == "*" || s == "/")
            {
                long long val1 = st.top();
                st.pop();
                long long val2 = st.top();
                st.pop();
                if(s == "+")
                {
                    st.push(val2 + val1);
                }
                else if(s == "-")
                {
                    st.push(val2 - val1);
                }
                else if(s == "*")
                {
                    st.push(val2 * val1);
                }
                else
                {
                    st.push(val2 / val1);
                }
            }
            else
            {
                st.push(stoll(s));
            }
        }
        return st.top();
    }
};

6-滑动窗口最大值

链接: 239

给定一个数组 nums，有一个大小为 k 的滑动窗口从数组的最左侧移动到数组的最右侧。你只可以看到在滑动窗口内的 k 个数字。滑动窗口每次只向右移动一位。返回滑动窗口中的最大值。进阶：你能在线性时间复杂度内解决此题吗？
示例 1：输入：nums = [1,3,-1,-3,5,3,6,7], k = 3 输出：[3,3,5,5,6,7]
解释：
滑动窗口的位置最大值
[1 3 -1] -3 5 3 6 7 =3
1 [3 -1 -3] 5 3 6 7 =3
1 3 [-1 -3 5] 3 6 7 =5
1 3 -1 [-3 5 3] 6 7 =5
1 3 -1 -3 [5 3 6] 7 =6
1 3 -1 -3 5 [3 6 7] =7
示例 2：输入：nums = [1], k = 1 输出：[1]

解法一：优先队列

时间复杂度：O(nlogn)，其中 n 是数组 nums 的长度。在最坏情况下，数组 nums 中的元素单调递增，那么最终优先队列中包含了所有元素，没有元素被移除。由于将一个元素放入优先队列的时间复杂度为 O(logn)，因此总时间复杂度为O(nlogn)。
空间复杂度：O(n)，即为优先队列需要使用的空间。这里所有的空间复杂度分析都不考虑返回的答案需要的 O(n) 空间，只计算额外的空间使用。

class Solution {
public:
    vector<int> maxSlidingWindow(vector<int>& nums, int k) {
        priority_queue<pair<int, int>> q;
        vector<int> ret;
        for(int i = 0; i < k; i++)
        {
            q.emplace(nums[i], i);
        }
        ret.push_back(q.top().first);
        for(int i = k; i < nums.size(); i++)
        {
            q.emplace(nums[i], i);
            while(q.top().second < i - k + 1)
            {
                q.pop();
            }
            ret.push_back(q.top().first);
        }
        return ret;
    }
};

解法二：单调队列

时间复杂度：O(n)，nums 中的每个元素最多也就被 push_back 和 pop_back 各一次，没有任何多余操作，所以整体的复杂度还是 O(n)。
空间复杂度：O(k)。

class Solution {
private:
    class MyQueue { //单调队列（从大到小）
    public:
        deque<int> que; // 使用deque来实现单调队列
        // 每次弹出的时候，比较当前要弹出的数值是否等于队列出口元素的数值，如果相等则弹出。
        // 同时pop之前判断队列当前是否为空。
        void pop(int value) {
            if (!que.empty() && value == que.front()) {
                que.pop_front();
            }
        }
        // 如果push的数值大于入口元素的数值，那么就将队列后端的数值弹出，直到push的数值小于等于队列入口元素的数值为止。
        // 这样就保持了队列里的数值是单调从大到小的了。
        void push(int value) {
            while (!que.empty() && value > que.back()) {
                que.pop_back();
            }
            que.push_back(value);

        }
        // 查询当前队列里的最大值 直接返回队列前端也就是front就可以了。
        int front() {
            return que.front();
        }
    };
public:
    vector<int> maxSlidingWindow(vector<int>& nums, int k) {
        MyQueue que;
        vector<int> result;
        for (int i = 0; i < k; i++) { // 先将前k的元素放进队列
            que.push(nums[i]);
        }
        result.push_back(que.front()); // result 记录前k的元素的最大值
        for (int i = k; i < nums.size(); i++) {
            que.pop(nums[i - k]); // 滑动窗口移除最前面元素
            que.push(nums[i]); // 滑动窗口前加入最后面的元素
            result.push_back(que.front()); // 记录对应的最大值
        }
        return result;
    }
};

7-前 K 个高频元素

链接: 347

给定一个非空的整数数组，返回其中出现频率前 k 高的元素。
示例 1: 输入: nums = [1,1,1,2,2,3], k = 2，输出: [1,2]
示例 2: 输入: nums = [1], k = 1，输出: [1]
提示：你可以假设给定的 k 总是合理的，且 1 ≤ k ≤ 数组中不相同的元素的个数。你的算法的时间复杂度必须优于 O(nlog n) , n 是数组的大小。题目数据保证答案唯一，换句话说，数组中前 k 个高频元素的集合是唯一的。你可以按任意顺序返回答案。

时间复杂度：O(nlogk)，将一个元素放入优先队列的时间复杂度为 O(logk)
空间复杂度：O(n)
注意public必须有！！！！

class Solution {
public:
    // 小顶堆
    class mycomparison {
    public:
        bool operator()(const pair<int, int>& lhs, const pair<int, int>& rhs) {
            return lhs.second > rhs.second;
        }
    };
    vector<int> topKFrequent(vector<int>& nums, int k) {
        // 要统计元素出现频率
        unordered_map<int, int> map; // map<nums[i],对应出现的次数>
        for (int i = 0; i < nums.size(); i++) {
            map[nums[i]]++;
        }

        // 对频率排序
        // 定义一个小顶堆，大小为k
        priority_queue<pair<int, int>, vector<pair<int, int>>, mycomparison> pri_que;

        // 用固定大小为k的小顶堆，扫面所有频率的数值
        for (unordered_map<int, int>::iterator it = map.begin(); it != map.end(); it++) {
            pri_que.push(*it);
            if (pri_que.size() > k) { // 如果堆的大小大于了K，则队列弹出，保证堆的大小一直为k
                pri_que.pop();
            }
        }

        // 找出前K个高频元素，因为小顶堆先弹出的是最小的，所以倒序来输出到数组
        vector<int> result(k);
        for (int i = k - 1; i >= 0; i--) {
            result[i] = pri_que.top().first;
            pri_que.pop();
        }
        return result;

    }
};