堆排序以及TOP K 问题

以leetcode两道例题来讲解
前K个高频元素
前K个高频单词
前K个高频单词相较于前K个高频元素来说，多了一个条件，就是要处理相等的条件
对于这类TOP K问题，如果问的是TOP K大，建立小顶堆时间复杂度小，如果问的是TOP K小，建立大顶堆时间复杂度小
因为如果问的是TOP K大，可以建立小顶堆也可建立大顶堆，如果建立的是小顶堆，每次堆顶都是最小的元素，我们只需要在第K+1个元素入堆的时候进行判断，如果第K+1个元素比堆顶大，只需要将堆顶元素替换，然后调整堆。时间复杂度为O(nlogk),如果建立的是大顶堆，那么需要调整n个元素再删除n-K个元素，时间复杂度为O(nlogn),
因此这类问题只需要分3步：

1. 建立一个K大小的小顶堆
2. 将第K+1个元素与堆顶元素比较，如果第K+1个元素比堆顶元素大，替换堆顶元素，并且调整堆
3. 所有元素都调整完后，堆中剩下的K个元素即为前K大的元素，而且是个小顶堆，但是它还并不是有序的，因此，再对该K个元素大小的堆进行堆调整即可
   下面给出模板：

/*前K个高频元素*/
class Solution {
public:

    void adjust_heap(vector<pair<int, int>>& tmp, int parent, int length)
    {
        for(int child = parent*2+1; child < length; child = child*2+1)
        {
            if(child+1 < length && tmp[child+1].second < tmp[child].second)
                child++;
            if(child < length && tmp[child].second < tmp[parent].second)
            {
                swap(tmp[child], tmp[parent]);
                parent = child;
            }
            else
                break;
        }
    }

    //TOP K问题
    vector<int> topKFrequent(vector<int>& nums, int k) {
        if(nums.size() == 0)
            return {};
        unordered_map<int, int> mp;
        for(int i = 0; i < nums.size(); i++)
        {
            mp[nums[i]]++;
        }
        vector<pair<int, int>> tmp(mp.begin(), mp.end());
        //构建一个K大小的 小顶堆
        for(int i = k/2-1; i >= 0; i--)
        {
            adjust_heap(tmp, i, k);
        }

        //从K大小堆的后面开始添加元素并且调整堆
        for(int i = k; i < tmp.size(); i++)
        {
            if(tmp[i].second > tmp[0].second)
            {
                tmp[0] = tmp[i];
                adjust_heap(tmp, 0, k);
            }
        }
        //上面已经保持了K大的元素都在堆中，且是小顶堆，但是都还是无序的，还需要进行堆调整
        for(int i = k-1; i >= 0; i--)
        {
            swap(tmp[0], tmp[i]);
            adjust_heap(tmp, 0, i);
        }
        //调整完后小元素都在数组后面
        vector<int> res;
        for(int i = 0; i < k; i++)
            res.push_back(tmp[i].first);
        return res;
    }
};

/*
前K个高频单词，需要处理相等的情况
*/
class Solution {
public:
	vector<string> topKFrequent(vector<string>& words, int k) {
		//方法3:维护一个k大的小顶堆
		unordered_map<string, int> mp;
		for (int i = 0; i < words.size(); i++)
		{
			mp[words[i]]++;
		}
		vector<pair<string, int>> tmp(mp.begin(), mp.end());
		create_heap(tmp, k);
		for (int i = k; i < tmp.size(); i++)
		{
			if (tmp[i].second > tmp[0].second)
			{
				tmp[0] = tmp[i];
				adjust_k_heap(tmp, 0, k);
			}
			else if (tmp[i].second == tmp[0].second)
			{
				if (tmp[i].first.compare(tmp[0].first) < 0)
				{
					tmp[0] = tmp[i];
					adjust_k_heap(tmp, 0, k);
				}
			}
		}
		//再进行一次堆排序,但是此时不需要再调整堆
		heap_sort(tmp, k);

		vector<string> res;
		for (int i = 0; i < k; i++)
		{
			res.push_back(tmp[i].first);
		}
		return res;
	}

	void adjust_k_heap(vector<pair<string, int>>& tmp, int parent, int length)
	{
		for (int child = parent * 2 + 1; child < length; child = child * 2 + 1)
		{
            //孩子结点的单词出现次数 小于父节点或者出现次数相等的时候根据字母顺序来找谁是最小的结点
			if (child + 1 < length && (tmp[child + 1].second < tmp[child].second || (tmp[child + 1].second == tmp[child].second && tmp[child + 1].first.compare(tmp[child].first) > 0)))
				child++;
			if (child < length && (tmp[child].second < tmp[parent].second || (tmp[child].second == tmp[parent].second && tmp[child].first.compare(tmp[parent].first) > 0))) //小的情况
			{
				swap(tmp[child], tmp[parent]);
				parent = child;
			}
			else
				break;
		}
	}

	void create_heap(vector<pair<string, int>>& tmp, int k)
	{
		//建堆
		for (int i = k / 2 - 1; i >= 0; i--)
		{
			adjust_k_heap(tmp, i, k);
		}
	}

	void heap_sort(vector<pair<string, int>>& tmp, int k)
	{
		// for (int i = k / 2 - 1; i >= 0; i--)
		// 	adjust_k_heap(tmp, i, k);
		for (int i = k - 1; i >= 0; i--)
		{
			swap(tmp[0], tmp[i]);
			adjust_k_heap(tmp, 0, i);
		}
	}
};