堆类典型题目的常规思路—Leetcode-thinking_record05

最新推荐文章于 2023-09-21 19:18:03 发布

恋蛩音

最新推荐文章于 2023-09-21 19:18:03 发布

阅读量307

点赞数

分类专栏： leetcode算法应对思路精进

本文链接：https://blog.csdn.net/qq_17846375/article/details/104686991

版权

leetcode算法应对思路精进专栏收录该内容

12 篇文章 3 订阅

订阅专栏

预备知识

二叉堆属性

最（大）小二叉堆，最（大）小值先出的完全二叉树。

最大（小）堆最重要的操作就是可以知道堆中的最大（小）值是多少。

时间复杂度O (nlogn)

STL优先级队列（实现二叉堆）

二叉堆：最小（大）值先出的完全二叉树。

数组中第K大的数（Easy）

LeetCode 215.Kth Largest Element in an Array

已知一个未排序的数组，求这个数组中第K大的数字。如，array = [3,2,1,5,6,4], k =2, return 5

总体思路

这就是一个简单的按带返回位置的大小值排序的问题，但是，一般情况下的排列时间复杂度都是开销比较大的。那么用堆来维护时间复杂度会变小的，维护一个K大小的最小堆，堆中元素个数小于K时，新元素直接进入堆；否则，当堆顶小于新元素时，弹出堆顶，将新元素加入堆。

由于堆是最小堆，堆顶是堆中最小元素，新元素都会保证比堆顶小（否则新元素替换堆顶），故堆中K个元素是已扫描的元素里最大的K个；堆顶即为第K大的数。

细节设计

设数组长度为N，求第K大的数，时间复杂度：N*logK

如，array = [3,2,1,5,6,4]：

代码实现

#include <stdio.h>

#include <vector>
#include <queue>
class Solution {
public:
    int findKthLargest(std::vector<int>& nums, int k) {
        std::priority_queue<int, std::vector<int>, std::greater<int> > Q;
        for (int i = 0; i < nums.size(); i++){
        	if (Q.size() < k){
	        	Q.push(nums[i]);
	        }
	        else if (Q.top() < nums[i]){
        		Q.pop();
	        	Q.push(nums[i]);
	        }
        }
        return Q.top();
    }
};

int main(){
	std::vector<int> nums;
	nums.push_back(3);
	nums.push_back(2);
	nums.push_back(1);
	nums.push_back(5);
	nums.push_back(6);
	nums.push_back(4);
	Solution solve;
	printf("%d\n", solve.findKthLargest(nums, 2));	
	return 0;
}

经验总结

在取大小排序后序列第几个大的问题上，二叉堆的时间复杂度是最小的。

寻找中位数(Hard)

设计一个数据结构，该数据结构动态维护一组数据，且支持如下操作：

添加元素：void addNum(int num)，将整型num添加至数据结构中。
返回数据的中位数：double findMedian()，返回其维护的数据的中位数。

中位数定义：

若数据个数位奇数，中位数是该组数排序后中间的数。 [1,2,3]->2
若数据个数为偶数，中位数是该组数排序后中间的两个数字的平均值。 [1，2，3，4]->2.5

总体思路

用传统的最直观的插入排序的方式排的话，在存储结构使用数组，每次添加元素或查找中位数时堆数组排序，再计算结果。那这样所造成的时间复杂度：

若添加元素时排序，addNum复杂度O(n)，findMedian复杂度O（1）
若查询中位数时排序，addNum复杂度O(1),findMedian复杂度O(nlogn)

如果添加元素或查询中位数是随机的操作，共n次操作，按上述思想，整体复杂度最佳的情况下为O(n^2)，但这样的时间复杂度开销太大了，是不符合的。

实际上这类问题用最大最小堆组合来实现会更好，动态维护一个最大堆与一个最小堆，最大堆存储一半数据，最小堆存储一半数据，维持最大堆的堆顶比最小堆的堆顶小（这样保证最大堆里面的每个元素都比最小堆里面的每个元素要小）。

这样的话，最后的中位数肯定就是出自最大堆或最小堆的堆顶了，或者是它俩的平均，就只需要根据元素的个数来区分情况讨论中位数了。

细节设计

情况1：最大堆与最小堆元素个数相同

情况2：最大堆比最小堆多一个元素

情况3：最大堆比最小堆少一个元素

三种情况汇总，求中位数:

代码实现

#include <stdio.h>

#include <queue>

class MedianFinder {
public:
    MedianFinder() {
    }
    void addNum(int num) {
    	if (big_queue.empty()){
	    	big_queue.push(num);
	    	return;
	    }
        if (big_queue.size() == small_queue.size()){
        	if (num < big_queue.top()){
	        	big_queue.push(num);
	        }
	        else{
        		small_queue.push(num);
        	}
        }
        else if(big_queue.size() > small_queue.size()){
        	if (num > big_queue.top()){
	        	small_queue.push(num);
	        }
	        else{
        		small_queue.push(big_queue.top());
        		big_queue.pop();
        		big_queue.push(num);
        	}
        }
        else if(big_queue.size() < small_queue.size()){
        	if (num < small_queue.top()){
	        	big_queue.push(num);
	        }
	        else{
        		big_queue.push(small_queue.top());
        		small_queue.pop();
        		small_queue.push(num);
        	}
        }
    }
    double findMedian(){
    	if (big_queue.size() == small_queue.size()){
        	return (big_queue.top() + small_queue.top()) / 2;
        }
        else if (big_queue.size() > small_queue.size()){
        	return big_queue.top();
        }
        return small_queue.top();
    }
private:
	std::priority_queue<double> big_queue;
	std::priority_queue<double, std::vector<double>,
					std::greater<double> > small_queue;
};

int main(){
	MedianFinder M;
	int test[] = {6, 10, 1, 7, 99, 4, 33};
	for (int i = 0; i < 7; i++){
		M.addNum(test[i]);
		printf("%lf\n", M.findMedian());
	}
	return 0;
}