堆Heap、大根堆Min-heap、小跟堆Max-heap

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: 父节点的值大于或等于子节点的值；——父节点的值最大

   

  

1. 堆的存储：
   一般都用数组来表示堆，i结点（i=0,1,2,3....）的父结点下标就为(i–1)/2。它的左右子结点下标分别为2 * i + 1和2 * i + 2。

   

    

2. 堆的操作：insert
   插入一个元素：新元素被加入到heap的末尾，然后更新树以恢复堆的次序。
   每次插入都是将新数据放在数组最后。可以发现从这个新数据的父结点到根结点必然为一个有序的数列，现在的任务是将这个新数据插入到这个有序数据中——这就类似于直接插入排序中将一个数据并入到有序区间中。

   

    

3. 堆的操作：Removemax
   按定义，堆中每次都删除第0个数据。为了便于重建堆，实际的操作是将最后一个数据的值赋给根结点，然后再从根结点开始进行一次从上向下的调整。调整时先在左右儿子结点中找最大的，如果父结点比这个最小的子结点还大说明不需要调整了，反之将父结点和它交换后再考虑后面的结点。相当于从根结点将一个数据的“下沉”过程。

   

    

4. 堆的操作：buildHeap 堆化数组
   对于叶子节点，不用调整次序，根据满二叉树的性质，叶子节点比内部节点的个数多1.所以i=n/2 -1 ，不用从n开始。

   

    

5. 堆排序
   堆建好之后堆中第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)