代码随想录第十三天 | 队列的应用：单调队列（leetcode 239），优先级队列（leetcode 347），栈和队列总结

1、队列的应用：单调队列

1.1 leetcode 239

超时了，使用vector做出队列，每次进一个元素出一个，循环每次的队列内元素找出最大值（暴力法）

第一遍代码

class Solution {
public:
    int getMax(vector<int>& myqueue) {//用vector做出队列，返回队列最大值
        int m = myqueue[0];
        for(int i = 0; i < myqueue.size(); i++) {
            if(myqueue[i] > m) {
                m = myqueue[i];
            }
        }
        return m;
    }
    vector<int> maxSlidingWindow(vector<int>& nums, int k) {
        vector<int> result;
        vector<int> myqueue;
        for(int i = 0; i < k; i++) {
            myqueue.push_back(nums[i]);
        }
        int m = getMax(myqueue);
        result.push_back(m);
        for(int i = k; i < nums.size(); i++) {
            myqueue.push_back(nums[i]);
            myqueue.erase(myqueue.begin());
            result.push_back(getMax(myqueue));
        }
        return result;
    }
};

这是使用单调队列的经典题目

难点是如何求一个区间里的最大值呢？ （第一次代码暴力超时了）
暴力方法，遍历一遍的过程中每次从窗口中再找到最大的数值，这样很明显是O(n × k)的算法

如果想用一个大顶堆（优先级队列）来存放这个窗口里的k个数字，这样就可以知道最大的最大值是多少了， 但是问题是这个窗口是移动的，而大顶堆每次只能弹出最大值，我们无法移除其他数值，这样就造成大顶堆维护的不是滑动窗口里面的数值了。所以不能用大顶堆

如果要找最大的几个元素且非滑动窗口可以使用小顶堆，见leetcode 347

堆与二叉树的区别
结构不同：堆是一种特殊的完全二叉树，而二叉树可以是完全二叉树、满二叉树、二叉搜索树等多种类型
用途不同：堆主要用于实现优先队列，以快速找到最大或最小元素；二叉树通常用于数据的存储和查找，尤其是二叉搜索树，可以高效地实现有序数据的操作
性质不同：堆的节点必须满足堆性质（最大堆或最小堆的要求），而二叉树通常没有这样的要求，二叉搜索树则有特定的排序要求

最大堆中删除根节点的过程
1）删除根节点：
根节点是最大堆中的最大值，直接将其删除
为了保持堆的完全二叉树性质，用最后一个节点的值替换根节点的值

2）调整堆的结构（堆化 down）：
将最后一个节点移到根位置之后，可能会破坏堆的性质。需要进行调整，使其重新满足最大堆的性质
从根节点开始，与其左右子节点进行比较，选择值最大的子节点进行交换，确保父节点大于子节点
重复上述步骤，直到新插入根节点的元素到达合适的位置（即父节点的值大于或等于子节点的值）

       50
      /  \
    30    40
   /  \   /  \
  10  5  20  35

删除根节点，用最后一个节点（即值为 35 的节点）替换根节点。新的堆结构如下：

       35
      /  \
    30    40
   /  \   /  
  10  5  20  

堆化（调整堆结构）：

       40
      /  \
    30    35
   /  \   /  
  10  5  20  

具体代码实现（数组实现）

#include <iostream>
#include <vector>

using namespace std;

void heapify(vector<int>& heap, int n, int i) {
    /**
     * 维持最大堆性质的函数，调整堆以保持最大堆的性质。
     * @param heap: 堆数组
     * @param n: 堆中元素数量
     * @param i: 当前需要调整的节点索引
     */
    int largest = i; // 初始化最大值为根节点
    int left = 2 * i + 1; // 左子节点索引
    int right = 2 * i + 2; // 右子节点索引

    // 如果左子节点存在且大于当前最大值，则更新最大值索引
    if (left < n && heap[left] > heap[largest]) {
        largest = left;
    }

    // 如果右子节点存在且大于当前最大值，则更新最大值索引
    if (right < n && heap[right] > heap[largest]) {
        largest = right;
    }

    // 如果最大值不是根节点，则进行交换并递归调整受影响的子树
    if (largest != i) {
        swap(heap[i], heap[largest]);
        heapify(heap, n, largest);
    }
}

void deleteRoot(vector<int>& heap) {
    /**
     * 删除最大堆的根节点函数。
     * @param heap: 堆数组
     */
    int n = heap.size();
    if (n == 0) {
        cout << "Heap is empty" << endl;
        return;
    }

    // 将最后一个元素移动到根位置，然后删除最后一个元素
    heap[0] = heap[n - 1];
    heap.pop_back(); // 删除最后一个元素

    // 调整堆以维持最大堆性质
    heapify(heap, heap.size(), 0);
}

int main() {
    // 示例堆数组（最大堆）
    vector<int> heap = {50, 30, 40, 10, 5, 20, 35};
    cout << "初始堆: ";
    for (int val : heap) {
        cout << val << " ";
    }
    cout << endl;

    // 删除根节点
    deleteRoot(heap);
    cout << "删除根节点后的堆: ";
    for (int val : heap) {
        cout << val << " ";
    }
    cout << endl;

    return 0;
}

此时我们需要自己设计一个队列，这个队列呢，放进去窗口里的元素，然后随着窗口的移动，队列也一进一出，每次移动之后，队列告诉我们里面的最大值是什么

class MyQueue {
public:
    void pop(int value) {
    }
    void push(int value) {
    }
    int front() {
        return que.front();
    }
};

每次窗口移动的时候，调用que.pop(滑动窗口中移除元素的数值)，que.push(滑动窗口添加元素的数值)，然后que.front就返回我们要的最大值

队列里的元素一定是要排序的，而且要最大值放在出队口，要不然怎么知道最大值呢
但如果把窗口里的元素都放进队列里，窗口移动的时候，队列需要弹出元素，

因为由于数组已知，所以每次要移入或者弹出的元素是什么具体知道，只要能插入/弹出指定具体元素的值就可以实现

那么问题来了，已经排序之后的队列 怎么能把窗口要移除的元素（这个元素可不一定是最大值）弹出呢

其实队列没有必要维护窗口里的所有元素，只需要维护有可能成为窗口里最大值的元素就可以了，同时保证队列里的元素数值是由大到小的

那么这个维护元素单调递减的队列就叫做单调队列，即单调递减或单调递增的队列。C++中没有直接支持单调队列，需要我们自己来实现一个单调队列

Dijkstra 最短路径算法：使用优先队列选择当前距离最短的节点进行处理

不要以为实现的单调队列就是 对窗口里面的数进行排序，如果排序的话，那和优先级队列又有什么区别了呢

例子动图 代码随想录

对于窗口里的元素{2, 3, 5, 1 ,4}，单调队列里只维护{5, 4} 就够了，保持单调队列里单调递减，此时队列出口元素就是窗口里最大元素

对于数据结构，使用deque最为合适，常用的queue在没有指定容器的情况下，deque就是默认底层容器，这个容器可以在队首队尾搞删除和插入

基于刚刚说过的单调队列pop和push的规则，代码随想录代码如下：

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();
    }
};

总体来说：
单调栈是队头到队尾依次递减的队列，因为原数组是完全知道的，所以直接可以知道每次push/pop()的元素是什么

实现push():
1、当需要加入的数比队列尾部的数大时，从队尾开始把所有比待加入元素删除（因为这些元素是之前加入的，生命肯定比带加入元素结束得早，而由于待加入的元素比这些元素大，在待加入元素失效前肯定没这些更小的元素的事了，可以发现这些元素没用了，所以都删了，不维护了）之后再加入该元素
2、当需要加入的数比队尾的数小时，从队尾加入队列（因为可能有用，等队列前面的元素出队了，他就有可能最大的，所以需要维护着）

实现pop():
1、可能在队首出元素，因为有可能队首没那个元素了（push第一条的情况被干掉了），如果队首还有那个元素删了就行

实现getMax():
1、由于push()的实现规则保证了队列中的元素肯定是从队首到队尾从大到小排列的，返回队首元素的值即可

注意：
如[-7,-8,7,5,7,1,6,0] 4，所以push()里面 发现里面有相同的元素 不能删（pop_back），不然 pop 里面会产生误删（因为元素数值相同，把后一个当前一个删掉 了）

按思路写的代码如下：（插入一定要 插入元素，删除 不一定删除元素）

class Solution {
public:
    deque<int> myque;//使用deque来实现单调队列，前方为出口，后方为入口 
    void pop(int value) {
        if(!myque.empty() && myque.front() == value) {
            myque.pop_front();//deque可以弹出开头元素
        }
    }
    // 如果push的数值大于入口元素的数值，那么就将队列后端的数值弹出，直到push的数值小于等于队列入口元素的数值为止。
    // 这样就即保证了元素的一定加入（与pop不一样）保持了队列里的数值是单调从大到小的了。
    void push(int value) {
        while(!myque.empty() && value > myque.back()) {
            myque.pop_back();
        }
        myque.push_back(value);
    }
    int getMax() {
        return myque.front();
    }
    vector<int> maxSlidingWindow(vector<int>& nums, int k) {
        vector<int> result;
        for(int i = 0; i < k; i++) {
            push(nums[i]);
        }
        result.push_back(getMax());
        for(int i = k; i < nums.size(); i++) {
            push(nums[i]);
            pop(nums[i - k]);//可能会有后面相同的元素
            //如[-7,-8,7,5,7,1,6,0] 4，所以push()里面相同的元素不能删，不然pop里面会产生误删（因为元素数值相同，把后一个当前一个删掉了）
            // 这两句语句 push(nums[i]) 和 pop(nums[i - k]) 可以交换顺序，而不会影响算法的正确性。交换这两行代码不会改变程序的输出结果
            // 添加新元素（push(nums[i])）和移除旧元素（pop(nums[i - k])）的操作针对的是不同的元素，它们彼此之间没有直接关联
            result.push_back(getMax());
        }
        return result;
    }
};

使用单调队列的时间复杂度是 O(n)

在队列中 push 元素的过程中，还有 pop 操作呢，感觉不是纯粹的 O(n)
其实，大家可以自己观察一下单调队列的实现，nums 中的每个元素最多也就被 push_back 和 pop_back 各一次，没有任何多余操作，所以整体的复杂度还是 O(n)

空间复杂度因为 定义一个辅助队列，所以是O(k)

要明确的是，题解中单调队列里的pop和push接口，仅适用于本题。单调队列不是一成不变的，而是不同场景不同写法，总之要保证队列里单调递减或递增的原则，所以叫做单调队列。 不要以为本题中的单调队列实现就是固定的写法

C++中deque是stack和queue默认的底层实现容器（这个我们之前已经讲过啦），deque是可以两边扩展的，而且deque里元素并不是严格的连续分布的

2、队列的应用：优先级队列

2.1 leetcode 347

利用multimap 对 key 排序的特性，key 为频数，value 为整数数值
注意：对于遍历 multimap，multimap.end() - 1是非法的，可以用 iter 记下 multimap.end()，再用 iter–

获取 map 中 键最大的元素：
rbegin() 返回一个指向 map 最后一个元素的 逆向迭代器（reverse_iterator），该元素的键就是最大的
或者 std::prev(myMap.end()) end() 返回一个指向容器末尾的迭代器（并不指向实际的元素），使用 std::prev() 可以获取前一个迭代器，即指向最后一个元素
std::map::upper_bound() 可以通过 upper_bound 获取大于最大键的迭代器，然后用 std::prev() 获取最大键的元素

可以 auto iter = --mymap.end();

第一遍代码：

class Solution {
public:
    vector<int> topKFrequent(vector<int>& nums, int k) {
        sort(nums.begin(), nums.end());
        multimap<int, int> mymap;//key为频数，value为整数数值，因为map 的排序是基于键（key），而不是值（value）
        if(nums.size() != 1 && nums[0] != nums[1]) {//避免只有一个值
            mymap.insert(pair<int, int>(1, nums[0]));
        }
        int count = 1;
        for(int i = 1; i < nums.size(); i++) {
            if(nums[i] == nums[i-1]) {
                count++;
            }
            else {
                mymap.insert(pair<int, int>(count, nums[i-1]));
                count = 1;
            }
        }
        mymap.insert(pair<int, int>(count, nums[nums.size() - 1]));
        vector<int> result;
        auto iter = --mymap.end();
        // iter--;
        int n = 1;
        for(;n <= k; iter--) {//不能用mymap.end()-1
            result.push_back(iter->second);
            n++;
        }
        return result;
    }
};

代码随想录思想过程：

这道题目主要涉及到如下三块内容：
1、要统计元素出现频率
2、对频率排序
3、找出前K个高频元素

首先统计元素出现的频率，这一类的问题可以使用 map 来进行统计

然后是对频率进行排序，这里我们可以使用一种 容器适配器就是 优先级队列
优先级队列是一个 披着队列外衣的堆，因为 优先级队列对外接口 只是从队头取元素，从队尾添加元素，再无其他取元素的方式，看起来就是一个队列
而且优先级队列内部元素是 自动依照元素的权值排列。那么它是如何有序排列的呢？

缺省 情况下 priority_queue 利用 max-heap（大顶堆）完成对元素的排序，这个大顶堆是以 vector 为表现形式的 complete binary tree（完全二叉树）
堆 是一棵 完全二叉树，树中每个结点的值 都不小于（或不大于）其左右孩子的值。 如果父亲结点是 大于等于左右孩子就是 大顶堆，小于等于左右孩子就是 小顶堆

如果懒得自己实现的话，就直接用 priority_queue（优先级队列）就可以了，底层实现都是一样的，从小到大排就是小顶堆，从大到小排就是大顶堆

是使用小顶堆呢，还是大顶堆？

定义一个大小为 k 的大顶堆，在每次 移动更新大顶堆 的时候，每次弹出都把 最大的元素弹出去了，那么怎么保留下来前 K 个高频元素呢
而且使用大顶堆就要把所有元素都进行排序，那能不能只排序 k 个元素呢
所以我们要用小顶堆，因为要统计最大前 k 个元素，只有小顶堆每次将最小的元素弹出，最后小顶堆里积累的才是前 k 个最大元素

根据思路实现代码：

public:
    class myComparison {
        public:
            bool operator()(pair<int, int>& map1, pair<int, int>& map2) { 
                return map1.second > map2.second;
            }
    };
    
    vector<int> topKFrequent(vector<int>& nums, int k) {
        unordered_map<int, int> mymap;
        for(int i = 0; i < nums.size(); i++) {
            mymap[nums[i]]++;
        }
        priority_queue<pair<int, int>, vector<pair<int, int>>, myComparison> pq;
        for(auto iter = mymap.begin(); iter != mymap.end(); iter++) {
            pq.push(*iter);
            if(pq.size() > k) {
                pq.pop();
            }
        }
        vector<int> result(k); // 由于priority_queue没有迭代器(队列，只能返回第一个元素)
        for (int i = k - 1; i >= 0; i--) {
            result[i] = pq.top().first;//只有pair&map::iterator有first/second
            //first/second只在pair里面有，而非map本身
            pq.pop();
        }
        return result;
    }

注意对于优先级队列排法的改造：

class myComparison {
        public:
            bool operator()(pair<int, int>& map1, pair<int, int>& map2) {
                return map1.second > map2.second;
            }
    };

priority_queue<pair<int, int>, vector<pair<int, int>>, myComparison> pq;

这样就把优先级队列改成小顶堆（没错，小顶堆），而且是根据pair里面的第二个元素来排序的
比较运算在建堆时是如何应用的，为什么左大于右就会建立小顶堆，反之是建立大顶堆比较困惑
确实 例如我们在写快排的 cmp 函数的时候，return left>right 就是从大到小，return left<right 就是从小到大
优先级队列的定义正好反过来了，可能和优先级队列的源码实现有关（我没有仔细研究），卡哥估计是底层实现上优先队列队首指向后面，队尾指向最前面的缘故

模板参数具体化为：

priority_queue<
    pair<int, int>,             // T：元素类型为 pair<int, int>
    vector<pair<int, int>>,     // Container：底层容器为 vector<pair<int, int>>
    myComparison                // Compare：自定义比较函数 myComparison
> pq;

myComparison
自定义比较函数：myComparison 是一个用于比较两个 pair<int, int> 的函数对象，定义了元素的优先级

class myComparison {
    public:
        bool operator()(pair<int, int>& map1, pair<int, int>& map2) {
            return map1.second > map2.second;
        }
};

重载了 () 运算符，使其成为一个可调用对象（函数对象）。
比较两个 pair<int, int>，根据 second（即频率）进行比较。
注意：这里使用了 map1.second > map2.second，表示当 map1.second 大于 map2.second 时，map1 的优先级 更高

一、第三个模板参数 myComparison 是一个 类型，用于指定比较方式
这个类型必须是一个可以调用的函数对象（仿函数），即具有 operator() 的类或结构体，优先队列内部会 创建一个比较器对象，需要能够默认构造 （仿函数 可以被默认构造，符合优先队列的设计需求）
不能直接使用一个普通函数，如

bool myComparison(pair<int, int>& map1, pair<int, int>& map2) {
    return map1.second > map2.second;
}

二、除非 使用函数指针，但这需要额外的处理：
1）定义 静态比较函数，而且 必须是静态的 / 定义在类外，如果不是静态的，非静态成员函数有一个隐含的 this 指针，必须通过对象来调用，不能作为普通的函数指针使用。因此，编译器报错 会提示 试图引用一个非静态成员函数，而没有提供调用对象

static bool myComparison(pair<int, int>& map1, pair<int, int>& map2) {
    return map1.second > map2.second;
}

2）定义优先队列，指定比较器类型 为函数指针

priority_queue<
    pair<int, int>,
    vector<pair<int, int>>,
    bool(*)(pair<int, int>&, pair<int, int>&)
> pq(myComparison);

1）模板参数中 指定函数指针类型：需要明确指出 比较器的类型是函数指针
2）在构造函数中传入函数指针：因为函数指针 无法默认构造，必须在创建优先队列时传入

三、使用 Lambda 表达式作为比较器（相比于函数指针，可以使用decltype）

// 定义 Lambda 表达式作为比较器
        auto myComparison = [](const pair<int, int>& map1, const pair<int, int>& map2) {
            return map1.second > map2.second;
        };
        priority_queue<
            pair<int, int>,
            vector<pair<int, int>>,
            decltype(myComparison)
        > pq(myComparison);

进一步理解 优先队列如何使用 比较器
std::priority_queue 是基于堆（通常是二叉堆）实现的，每次插入或删除元素时，都需要维护堆的性质。堆的性质要求 父节点的优先级高于子节点，这就需要 比较元素之间的优先级
优先队列在内部需要比较两个元素时，会调用 提供的比较器对象的 operator() 函数，将这两个元素作为参数传入

设优先队列 需要比较两个元素 a 和 b，它会执行以下调用：

bool result = comparator(a, b);

comparator：提供的比较器对象（即 myComparison 的实例）
a 和 b：需要比较的两个元素，类型为 pair<int, int>
result：比较的结果，决定了元素在堆中的位置

priority_queue 没有迭代器。如果想要访问全部的元素，比如说，列出或复制它们，会将队列清空；priority_queue 和 queue 有相同的限制。如果想在进行这样的操作后，还能保存它的元素，需要先把它复制一份，这里可以使用一个不同类型的容器

std::string wrds [] {"one", "two", "three", "four"};
std::priority_queue<std::string, std::deque<std::string>> words {std::begin(wrds), std::end(wrds)}; 

push(const T& obj)：将obj的副本放到容器的适当位置，这通常会包含一个排序操作。
push(T&& obj)：将obj放到容器的适当位置，这通常会包含一个排序操作。
emplace(T constructor args…)：通过调用传入参数的构造函数，在序列的适当位置构造一个T对象。为了维持优先顺序，通常需要一个排序操作

push：将一个元素复制或移动到优先队列中。
emplace：在优先队列中直接构造一个元素，避免了不必要的复制或移动
已经有一个构造好的对象，需要将其加入优先队列时，使用 push，想直接 在优先队列中构造元素，避免不必要的临时对象时，使用 emplace

// 使用 push
#include <iostream>
#include <queue>
#include <vector>

struct MyStruct {
    int x;
    MyStruct(int val) : x(val) {
        std::cout << "构造 MyStruct(" << val << ")\n";
    }
    MyStruct(const MyStruct& other) : x(other.x) {
        std::cout << "复制构造 MyStruct(" << other.x << ")\n";
    }
    bool operator<(const MyStruct& other) const {
        return x < other.x;
    }
};

int main() {
    std::priority_queue<MyStruct> pq;
    MyStruct obj(10);
    pq.push(obj); // 会调用复制构造函数
    return 0;
}

先构造了一个 MyStruct 对象 obj，然后 使用 push 将其加入优先队列
push 需要将 obj 复制到优先队列中，因此 调用了复制构造函数
输出

构造 MyStruct(10)
复制构造 MyStruct(10)

// 使用 emplace
#include <iostream>
#include <queue>
#include <vector>

struct MyStruct {
    int x;
    MyStruct(int val) : x(val) {
        std::cout << "构造 MyStruct(" << val << ")\n";
    }
    bool operator<(const MyStruct& other) const {
        return x < other.x;
    }
};

int main() {
    std::priority_queue<MyStruct> pq;
    pq.emplace(10); // 直接在优先队列中构造对象
    return 0;
}

使用 emplace，直接在优先队列中构造了一个 MyStruct(10)，避免了复制或移动操作
输出

构造 MyStruct(10)

top()：返回优先级队列中第一个元素的引用。
pop()：移除第一个元素。
size()：返回队列中元素的个数。
empty()：如果队列为空的话，返回true。
swap(priority_queue& other)：和参数的元素进行交换，所包含对象的类型必须相同

priority_queue 用法详解

3、栈和队列的总结

栈与队列总结 代码随想录