优先队列&滑动窗口

239. 滑动窗口最大值

方法：单调队列

class Solution {
private:
    class MyQueue {
    public:
        deque<int> q;
        void pop(int val) {
            if (!q.empty() && val == q.front()) q.pop_front();
        }

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

        int front() {
            return q.front();
        }
    };

public:
    vector<int> maxSlidingWindow(vector<int>& nums, int k) {
        MyQueue q;
        vector<int> res;
        for (int i = 0; i < k; ++i) {
            q.push(nums[i]);
        }
        res.push_back(q.front());

        for (int i = k; i < nums.size(); ++i) {
            q.pop(nums[i-k]);
            q.push(nums[i]);
            res.push_back(q.front());
        }
        return res;
    }
};

$时间复杂度O(n),空间复杂度O(k)

方法：双端队列

class Solution {
public:
    vector<int> maxSlidingWindow(vector<int>& nums, int k) {
        int q[100010], front = 0, back = 0;
        int n = nums.size();
        vector<int>ret(n-k+1, -1);
        for(int i = 0; i < n; ++i) {
            while(front != back && i - q[front] > k-1) {
                ++front;
            }
            while(front != back && nums[q[back-1]] <= nums[i]) {
                --back;
            }
            q[back++] = i;
            if(i - k + 1 >= 0) {
                ret[i - k + 1] = nums[q[front]];
            }
        }
        return ret;
    }
};

$时间复杂度O(n),空间复杂度O(m)

347. 前 K 个高频元素

方法：小顶堆

class Solution {
public:
    typedef pair<int, int> pai;
    class mycomparison{
    public:
        bool operator()(const pai& a, const pai& b) {
            return a.second > b.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<pai, vector<pai>, mycomparison> pre_que;

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

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

$时间复杂度O(n),空间复杂度O(n)

方法：哈希+排序

class Solution {
    unordered_map<int, int>hash;
public:
    vector<int> topKFrequent(vector<int>& nums, int k) {
        int i;
        hash.clear();
        vector<int>ret;
        for(i = 0; i < nums.size(); ++i) {
            ++hash[nums[i]];
        }
        sort(nums.begin(), nums.end(), [&](const auto& a, const auto& b) {
            int cnta = hash[a];
            int cntb = hash[b];
            if(cnta == cntb) {
                return a < b;
            }
            return cnta > cntb;
        });
        ret = {nums[0]};
        --k;
        for(i = 1; i < nums.size() && k; ++i) {
            if(nums[i] == nums[i-1])
                continue;
            ret.push_back(nums[i]);
            --k;
        }
        return ret;
    }
};

$时间复杂度O(n),空间复杂度O(n)