代码随想录二刷——栈与队列day13

---

前言

一个本硕双非的小菜鸡，备战24年秋招，计划二刷完卡子哥的刷题计划，加油！
二刷决定精刷了，于是参加了卡子哥的刷题班，训练营为期60天，我一定能坚持下去，迎来两个月后的脱变的，加油！
推荐一手卡子哥的刷题网站，感谢卡子哥。代码随想录

栈与队列知识点

栈是一种后进先出（ LIFO ）的数据结构，它是一种线性的、有序的数据结构。栈的基本操作有两个，即入栈和出栈。入栈指将元素放入栈顶，出栈指将栈顶元素取出。栈的本质是一个容器，它可以存储任何类型的数据，但是栈的大小是固定的，因为它的元素只能在栈顶添加或删除。
队列是一种先进先出（ FIFO ）的数据结构，它与栈相似，也是一种线性的、有序的数据结构。队列的基本操作有三个，即入队、出队和查看队首元素。入队指将元素放入队尾，出队指将队首元素取出。队列的本质也是一个容器，它可以存储任何类型的数据，但是队列的大小也是固定的。

一、 239. 滑动窗口最大值

239. 滑动窗口最大值
Note：实现单调队列

class Solution {
private:
    class Myqueue {
        public:
            deque<int> que;

            void pop(int value) {
                if (!que.empty() && value == que.front())
                    que.pop_front();
            }

            void push(int value) {
                while (!que.empty() && value > que.back())
                    que.pop_back();
                que.push_back(value);
            }

            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++)
            que.push(nums[i]);
        result.push_back(que.front());
        for (int i = k; i < nums.size(); i++) {
            que.pop(nums[i - k]);
            que.push(nums[i]);
            result.push_back(que.front());
        }
        return result;
    }
};

二、347. 前 K 个高频元素

347. 前 K 个高频元素

Note：哈希表解法

class Solution {
public:
    vector<int> topKFrequent(vector<int>& nums, int k) {
        vector<int> res;
        map<int, int> map;

        for (auto iter : nums)
            map[iter]++;

        vector<pair<int, int>> per(map.begin(), map.end());

        sort(per.begin(), per.end(), [](pair<int, int>& a, pair<int, int>& b) {return a.second > b.second;});

        auto a = per.begin();

        while (k--) {
            res.push_back(a->first);
            a++;
        }
        return res;
    }
};

Note：小顶堆

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;
        for (int i = 0; i < nums.size(); i++) {
            map[nums[i]]++;
        }

        priority_queue<pair<int, int>, vector<pair<int, int>>, mycomparison> pri_que;

        for (unordered_map<int, int>::iterator it = map.begin(); it != map.end(); it++) {
            pri_que.push(*it);
            if (pri_que.size() > k)
                pri_que.pop();
        }

        vector<int> result(k);
        for (int i = k - 1; i >= 0; i--) {
            result[i] = pri_que.top().first;
            pri_que.pop();
        }
        return result;
    }
};

总结

栈和队列是两种常见的数据结构,它们分别用于解决不同类型的问题。