堆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)