LeetCode中用堆做的题:
1、Top K Frequent Elements
- Given a non-empty array of integers, return the k most frequent
- 题目要求:这道题给了我们一个数组,让我们统计前k个高频的数字。
- 题目分析:对于这类的统计数字的问题,首先应该考虑用HashMap来做,建立数字和其出现次数的映射,然后再按照出现次数进行排序。我们可以用堆排序来做,使用一个最大堆来按照映射次数从大到小排列,在C++中使用priority_queue来实现,默认是最大堆。
class Solution {
public:
vector<int> topKFrequent(vector<int>& nums, int k) {
vector<int> res;
map<int, int> hash;
priority_queue<pair<int, int>> heap;
for(auto num : nums) hash[num]++;
for(auto it : hash) heap.push({it.second, it.first});
for(int i = 0; i < k; i++){
res.push_back(heap.top().second);
heap.pop();
}
return res;
}
};
2、Find K Pairs with Smallest Sums
- Given scores of N athletes, find their relative ranks and the people with the top three highest scores, who will be awarded medals: "Gold Medal", "Silver Medal" and "Bronze Medal".
- 题目要求:这道题给了我们一组分数,让我们求相对排名,前三名分别是金银铜牌,后面的就是名次数。
- 题目分析:利用堆来排序,建立一个优先队列,把分数和其坐标位置放入队列中,会自动按其分数高低排序,然后我们从顶端开始一个一个取出数据,由于保存了其在原数组的位置,我们可以直接将其存到结果res中正确的位置,用一个变量cnt来记录名词,前三名给奖牌,后面就是名次数。
class Solution {
private:
struct Tuple
{
int x;
int y;
int sum;
Tuple(int xx,int yy,int ss) :x(xx),y(yy),sum(ss)
{}
};
class myCompare
{
public:
bool operator() (Tuple &t1,Tuple &t2)
{
return t1.sum>t2.sum;
}
};
public:
vector<vector<int>> kSmallestPairs(vector<int>& nums1, vector<int>& nums2, int k) {
vector<vector<int>> res;
if(nums1.empty()||nums2.empty())
return res;
vector<Tuple> init;
for(int i=0;i<nums1.size();++i)
{
init.push_back(Tuple(i,0,nums1[i]+nums2[0]));
}
priority_queue<Tuple,vector<Tuple>,myCompare> minHeap(init.begin(),init.end());
int c=0;
while(c<k&&!minHeap.empty())
{
Tuple t=minHeap.top();
int i=t.x,j=t.y,sum=t.sum;
res.push_back(vector<int>{nums1[i],nums2[j++]});
c++;
minHeap.pop();
while(c<k&&j<nums2.size())
{
sum=nums1[i]+nums2[j];
if(sum<=minHeap.top().sum)
{
res.push_back(vector<int>{nums1[i],nums2[j++]});
c++;
}
else
{
t.y=j;
t.sum=sum;
minHeap.push(t);
break;
}
}
}
return res;
}
};
-
Heap是一种数据结构具有以下的特点:
1)完全二叉树;Heap通常是完全二叉树(因为效率高),但没有要求一定是完全二叉树
2)heap中存储的值是偏序; -
Min-heap: 父节点的值小于或等于子节点的值;——父节点的值最小
-
Max-heap: 父节点的值大于或等于子节点的值;——父节点的值最大
-
堆的存储:
一般都用数组来表示堆,i结点(i=0,1,2,3....)的父结点下标就为(i–1)/2。它的左右子结点下标分别为2 * i + 1和2 * i + 2。 -
堆的操作:insert
插入一个元素:新元素被加入到heap的末尾,然后更新树以恢复堆的次序。
每次插入都是将新数据放在数组最后。可以发现从这个新数据的父结点到根结点必然为一个有序的数列,现在的任务是将这个新数据插入到这个有序数据中——这就类似于直接插入排序中将一个数据并入到有序区间中。 -
堆的操作:Removemax
按定义,堆中每次都删除第0个数据。为了便于重建堆,实际的操作是将最后一个数据的值赋给根结点,然后再从根结点开始进行一次从上向下的调整。调整时先在左右儿子结点中找最大的,如果父结点比这个最小的子结点还大说明不需要调整了,反之将父结点和它交换后再考虑后面的结点。相当于从根结点将一个数据的“下沉”过程。 -
堆的操作:buildHeap 堆化数组
对于叶子节点,不用调整次序,根据满二叉树的性质,叶子节点比内部节点的个数多1.所以i=n/2 -1 ,不用从n开始。 -
堆排序
堆建好之后堆中第0个数据是堆中最大的数据。取出这个数据再执行下堆的删除操作。这样堆中第0个数据又是堆中最大的数据,重复上述步骤直至堆中只有一个数据时就直接取出这个数据。
转载自作者:WangC.W
寻找数组中最小的k个数(快排和堆排)
思路1:利用快排的思想,寻找第k个位置上正确的数,k位置前面的数即是比k位置小的数组,k后面的数即是比k位置元素大的数组。
public ArrayList<Integer> GetLeastNumbers_Solution(int [] input, int k) {
ArrayList<Integer> res = new ArrayList<Integer>();
if (input==null||input.length==0||input.length<k||k<=0) {
return res;
}
int start = 0;
int end = input.length-1;
int index = partition(input, start, end);
//一直循环知道找到第k个位置正确的数。
while (index != k - 1) {
if (index > k - 1) {
end = index-1;
index = partition(input, start, end);
} else {
start = index+1;
index = partition(input, start, end);
}
}
for (int i = 0; i < k; i++) {
res.add(input[i]);
}
return res;
}
static int partition(int input[], int start, int end) {
int tmp = input[start];
while (start < end) {
while (start < end && input[end] >= tmp) {
end--;
}
input[start] = input[end];
while (start < end && tmp >= input[start]) {
start++;
}
input[end] = input[start];
}
input[start] = tmp;
return start;
}
思路2:利用堆排序,特别适用于海量数据中寻找最大或者最小的k个数字。即构建一个大堆容器,初始化大小为k,变量初始数,如初始数组大小小于等于k直接返回,如果大于k,则选择数组的前k个元素,填充堆,然后调整为最大堆。调整完之后,继续从初始数组中拿出一个元素,如果该元素比大堆的堆顶小,则替换堆顶,继续调整为最大堆,如果大于等于堆顶则直接丢弃,不作调整。
PS:大堆还是小堆的选择很重要,不是寻找最小的k个元素就要选择小堆,而且恰恰相反。寻找最小的k个数,其实就是寻找第k个大的元素,即寻找k个数中最大的,不断调整堆,堆得元素个数是k,堆顶是最大值,遍历完初始数组后,堆中存在的元素即使我们所要寻找的k个最小元素。
//堆排序:构建堆,不断调整的过程,从最后一个不是叶子节点的节点开始。
static public ArrayList<Integer> GetLeastNumbers_Solution1(int[] input, int k) {
ArrayList<Integer> res = new ArrayList<Integer>();
if (input==null||input.length==0||input.length<k) {
return res;
}
int []maxHeap = new int[k];
//初始化堆
for (int i = 0; i < maxHeap.length; i++) {
maxHeap[i] = input[i];
}
//将初始化的堆调整为最大堆
for (int i = (maxHeap.length-1)/2; i >=0 ; i--) {
adjustHeap(maxHeap, i);
}
//遍历初始数组不断调整最大堆
for (int i = k; i <input.length ; i++) {
if (maxHeap[0]>input[i]) {
maxHeap[0] = input[i];
adjustHeap(maxHeap, 0);
}
}
for (int i = 0; i < maxHeap.length; i++) {
res.add(maxHeap[i]);
}
return res;
}
static void adjustHeap(int maxHeap[],int i){
int index = i;
int lchild=2*i+1; //i的左孩子节点序号
int rchild=2*i+2; //i的右孩子节点序号
if(index<=(maxHeap.length-1)/2) {
//寻找子节点中最大的节点
if (lchild<maxHeap.length&&maxHeap[index]<maxHeap[lchild]) {
index = lchild;
}
if (rchild<maxHeap.length&&maxHeap[index]<maxHeap[rchild]) {
index = rchild;
}
if (i!=index) {
//将节点与最大的子节点交换
int tmp = maxHeap[index];
maxHeap[index] = maxHeap[i];
maxHeap[i] = tmp;
//交换后,子树可能不满足最大推,递归调整。
adjustHeap(maxHeap, index);
}
}
优缺点:
- 思路1
- 优点:节省空降,时间复杂度平均为O(n)
- 缺点:需要修改原始数组
- 思路2
- 优点:不用修改原始数组,适合海量数据
- 缺点:时间复杂度略高O(nlogk)