算法——优先级队列（堆）

最后一块石头的重量

最后一块石头的重量

题目解析

每一回合，从中选出两块** 最重的** 石头，然后将它们一起粉碎。假设石头的重量分别为 x 和 y，且 x <= y。那么粉碎的可能结果如下：

• 如果 x == y，那么两块石头都会被完全粉碎；
• 如果 x != y，那么重量为 x 的石头将会完全粉碎，而重量为 y 的石头新重量为 y-x。

最后，最多只会剩下一块石头。返回此石头的重量。如果没有石头剩下，就返回 0。

算法原理

解法：用堆模拟该过程
拿到数组后先创建一个大根堆，将数组中的数字全部丢入大根堆里，先后两次拿出堆顶元素，让其碰撞，将碰撞后的结果重新放入大根堆中，

代码实现

class Solution 
{
public:
    int lastStoneWeight(vector<int>& stones) 
    {
        // 1. 创建⼀个⼤根堆（C++中默认大根堆）
    priority_queue<int> heap;

    // 2. 将所有元素丢进这个堆⾥⾯
    for(auto x : stones) heap.push(x);

    // 3. 模拟这个过程
    while(heap.size() > 1)
        {
        int a = heap.top(); heap.pop();
        int b = heap.top(); heap.pop();
        if(a > b) heap.push(a - b);
        }
    
     return heap.size() ? heap.top() : 0;
    }
};

数据流中第K大元素（TOP—k）

数据流中第K大元素

题目解析

排序后第K大的元素，包括相同的元素也统计进去。

算法原理

解法：堆

1. 创建一个大小为k的堆（如果问第K大，用小根堆；问第K小，用大根堆）
2. 循环：
   1. 元素依次进堆
   2. 判断堆的大小是否超过k
      

代码实现

class KthLargest 
{
    // 创建⼀个⼤⼩为 k 的⼩跟堆
    priority_queue<int, vector<int>, greater<int>> heap;
    int _k;

public:
    KthLargest(int k, vector<int>& nums) 
    {
        _k = k;
        for(auto x : nums)
        {
        heap.push(x);
        if(heap.size() > _k) heap.pop();
        }

    }
    
    int add(int val) 
    {
        heap.push(val);
        if(heap.size() > _k) heap.pop();
        return heap.top();
    }
};

/**
 * Your KthLargest object will be instantiated and called as such:
 * KthLargest* obj = new KthLargest(k, nums);
 * int param_1 = obj->add(val);
 */

前K个高频单词

前K个高频单词

题目解析

给定一个单词列表 words 和一个整数 k ，返回前 k_ _个出现次数最多的单词。
返回的答案应该按单词出现频率由高到低排序。如果不同的单词有相同出现频率， 按字典顺序 排序。

算法原理

TOP—K问题的拓展
解法：利用堆解决TOP-K问题

1. 预处理一下原始的字符串数组：用一个哈希表，统计每个单词出现的次数。
2. 创建一个大小为K的堆
   • 频次（小根堆）
   • 字典序（当频次相同时，（字典序是从低到高）大根堆）
3. 循环：
   1. 元素依次进堆
      • 一种方式是字符串进堆，创建一个string
      • 另一种方式是定义一个pair<string,int>，将字符串和出线的次数绑定一起进堆。
   2. 判断：当堆的个数大于K就把堆顶元素删掉
4. 提取结果
   1. 堆顶元素是前K个中出现次数最少的，所以说从堆顶拿出放入数组中后，还要逆序。（也可以拿出堆顶元素后倒着放）
      

代码实现

class Solution 
{
    typedef pair<string, int> PSI;
    struct cmp
    {
        bool operator()(const PSI& a, const PSI& b)
        {
                if(a.second == b.second) // 频次相同，字典序按照⼤根堆的⽅式排列
                {
                    return a.first < b.first;
                }
                return a.second > b.second;
        }
    };
public:
    vector<string> topKFrequent(vector<string>& words, int k) 
    {
        // 1. 统计⼀下每⼀个单词的频次
        unordered_map<string, int> hash;
        for(auto& s : words) hash[s]++;
        
        // 2. 创建⼀个⼤⼩为 k 的堆
        priority_queue<PSI, vector<PSI>, cmp> heap;

        // 3. TopK 的主逻辑
        for(auto& psi : hash)
        {
            heap.push(psi);
            if(heap.size() > k) heap.pop();
        }

        // 4. 提取结果
        vector<string> ret(k);
        for(int i = k - 1; i >= 0; i--)
        {
            ret[i] = heap.top().first;  //只要pair里的string，所以用first
            heap.pop();
        }
        
        return ret;
    }
};

数据流的中位数

数据流的中位数

题目解析

返回当前数组中的中位数，数组中会一个个添加数字

算法原理

1. 解法一：直接sort
   1. 先创建一个空数组，添加数字直接尾插到空数组中，接着无论来几个数，直接sort排序。即来一次数组，接受一次并排序。

2. 解法二：插入排序的思想
   1. 每次进入一个数字，就让他变得有序。即每次添加一个数字，就从后往前扫描找到自己合适插入的位置。插入（add）操作所消耗的时间复杂度为O(n),插入完之后整个数组是有序的，查找（find）插入操作，中间元素个数/2就能找到，查找所消耗的时间复杂度为O(1)。

可以将解法三当做成概念记住

3. 解法三：大小堆来维护数据流中的中位数
   1. 假设此时一堆数字已经按照从小到大的顺序排好序了，之前想找中间这个数字时，直接拿两端元素下标除以2即可。这里我们将前半部分（整个数组中的一半的前半部分）数字都放入大根堆里，将后半部分数字存到小根堆里面。
   2. 此时我们寻找中间值也很方便，因为左半部分数字都是较小的数字，较小的数字放入大根堆里面，那你的堆顶元素就是右边最大的值；同理，右边这一半都是较大的数字，把他们放入小根堆里面，较大的数字的堆顶元素就是最左边的数。此时我们只需根据整个数组中数字的个数就能求出中位数，如果个数是偶数个，那正好两边各方一半，如果是奇数个，我们人为规定左边多一个。此时的中位数就是左边大根堆堆顶元素。

4. 细节问题：add函数。设左边的堆为x，右边的堆为y。当进来一个数后，要么进入大根堆，要么进入小根堆。此时m和n有两种情况，一种情况是m和n相等；另一种情况是m比n多一个，但此时num进入可能会破坏这个情况，所以我们需要动态维护这个堆的个数关系。
   

代码实现

class MedianFinder 
{
    priority_queue<int> left; // ⼤根堆
    priority_queue<int, vector<int>, greater<int>> right; // ⼩根堆
public:
    MedianFinder() 
    {}
    
    void addNum(int num) 
    {
    // 分类讨论即可
    if(left.size() == right.size()) // 左右两个堆的元素个数相同
    {
        if(left.empty() || num <= left.top()) // 放 left ⾥⾯
        {
            left.push(num);
        }
        else
        {
            right.push(num);
            left.push(right.top());
            right.pop();
        }
    }

    else
    {
        if(num <= left.top())
        {
            left.push(num);
            right.push(left.top());
            left.pop();
        }
        else
        {
        right.push(num);
        }
    }
}
    
    double findMedian() 
    {
        if(left.size() == right.size()) 
            return (left.top() + right.top()) / 2.0;
        else return left.top();
    }
};

/**
 * Your MedianFinder object will be instantiated and called as such:
 * MedianFinder* obj = new MedianFinder();
 * obj->addNum(num);
 * double param_2 = obj->findMedian();
 */