數據結構與算法(4)——優先隊列和堆
前言：題圖無關，接下來開始簡單學習學習優先隊列和堆的相關數據結構的知識；java
前序文章：node
- 數據結構與算法(1)——數組與鏈表（https://www.jianshu.com/p/7b93b3570875）
- 數據結構與算法(2)——棧和隊列(https://www.jianshu.com/p/5087c751cb42)
- 數據結構與算法(3)——樹（二叉、二叉搜索樹）(https://www.jianshu.com/p/4ef1f50d45b5)
什麼是優先隊列？
聽這個名字就能知道，優先隊列也是一種隊列，只不過不一樣的是，優先隊列的出隊順序是按照優先級來的；在有些狀況下，可能須要找到元素集合中的最小或者最大元素，能夠利用優先隊列ADT來完成操做，優先隊列ADT是一種數據結構，它支持插入和刪除最小值操做（返回並刪除最小元素）或刪除最大值操做（返回並刪除最大元素）；git
這些操做等價於隊列的enQueue和deQueue操做，區別在於，對於優先隊列，元素進入隊列的順序可能與其被操做的順序不一樣，做業調度是優先隊列的一個應用實例，它根據優先級的高低而不是先到先服務的方式來進行調度；github
若是最小鍵值元素擁有最高的優先級，那麼這種優先隊列叫做升序優先隊列（即老是先刪除最小的元素），相似的，若是最大鍵值元素擁有最高的優先級，那麼這種優先隊列叫做降序優先隊列（即老是先刪除最大的元素）；因爲這兩種類型時對稱的，因此只須要關注其中一種，如升序優先隊列；web
優先隊列ADT
下面操做組成了優先隊列的一個ADT；面試
1.優先隊列的主要操做
優先隊列是元素的容器，每一個元素有一個相關的鍵值；算法
insert(key, data)：插入鍵值爲key的數據到優先隊列中，元素以其key進行排序；deleteMin/deleteMax：刪除並返回最小/最大鍵值的元素；getMinimum/getMaximum：返回最小/最大劍指的元素，但不刪除它；
2.優先隊列的輔助操做api
第k最小/第k最大：返回優先隊列中鍵值爲第k個最小/最大的元素；大小（size）：返回優先隊列中的元素個數；堆排序（Heap Sort）：基於鍵值的優先級將優先隊列中的元素進行排序；
優先隊列的應用
- 數據壓縮：赫夫曼編碼算法；
- 最短路徑算法：Dijkstra算法；
- 最小生成樹算法：Prim算法；
- 事件驅動仿真：顧客排隊算法；
- 選擇問題：查找第k個最小元素；
- 等等等等....
優先隊列的實現比較
| 實現 | 插入 | 刪除 | 尋找最小值 |
|---|---|---|---|
| 無序數組 | 1 | n | n |
| 無序鏈表 | 1 | n | n |
| 有序數組 | n | 1 | 1 |
| 有序鏈表 | n | 1 | 1 |
| 二叉搜索樹 | logn(平均) | logn(平均) | logn(平均) |
| 平衡二叉搜索樹 | logn | logn | logn |
| 二叉堆 | logn | logn | 1 |
堆和二叉堆
什麼是堆
堆是一顆具備特定性質的二叉樹，堆的基本要求就是堆中全部結點的值必須大於或等於（或小於或等於）其孩子結點的值，這也稱爲堆的性質；堆還有另外一個性質，就是當 h > 0 時，全部葉子結點都處於第 h 或 h - 1 層（其中 h 爲樹的高度，徹底二叉樹），也就是說，堆應該是一顆徹底二叉樹；數組
在下面的例子中，左邊的樹爲堆（每一個元素都大於其孩子結點的值），而右邊的樹不是堆（由於5大於其孩子結點2）微信
二叉堆
在二叉堆中，每一個結點最多有兩個孩子結點，在實際應用中，二叉堆已經足夠知足需求，所以接下來主要討論二叉最小堆和二叉最大堆；
堆的表示：在描述堆的操做前，首先來看堆是怎樣表示的，一種可能的方法就是使用數組，由於堆在形式上是一顆徹底二叉樹，用數組來存儲它不會浪費任何空間，例以下圖：
用數組來表示堆不只不會浪費空間還具備必定的優點：
- 每一個結點的左孩子爲下標i的2倍：
left child(i) = i * 2；每一個結點的右孩子爲下標i的2倍加1：right child(i) = i * 2 + 1 - 每一個結點的父親結點爲下標的二分之一：
parent(i) = i / 2，注意這裏是整數除，2和3除以2都爲1，你們能夠驗證一下； - 注意：這裏是把下標爲0的地方空出來了的，主要是爲了方便理解，若是0不空出來只須要在計算的時候把i值往右偏移一個位置就好了（也就是加1，你們能夠試試，下面的演示也採起這樣的方式）；
二叉堆的相關操做
堆的基本結構
public class MaxHeap<E extends Comparable<E>> {
private Array<E> data;
public MaxHeap(int capacity){ data = new Array<>(capacity); }
public MaxHeap(){ data = new Array<>(); }
// 返回堆中的元素個數
public int size(){ return data.getSize(); }
// 返回一個布爾值, 表示堆中是否爲空
public boolean isEmpty(){ return data.isEmpty(); }
// 返回徹底二叉樹的數組表示中，一個索引所表示的元素的父親節點的索引
private int parent(int index){
if(index == 0)
throw new IllegalArgumentException("index-0 doesn't have parent.");
return (index - 1) / 2;
}
// 返回徹底二叉樹的數組表示中，一個索引所表示的元素的左孩子節點的索引
private int leftChild(int index){ return index * 2 + 1; }
// 返回徹底二叉樹的數組表示中，一個索引所表示的元素的右孩子節點的索引
private int rightChild(int index){ return index * 2 + 2; }
}
向堆中添加元素和Sift Up
當插入一個元素到堆中時，它可能不知足堆的性質，在這種狀況下，須要調整堆中元素的位置使之從新變成堆，這個過程稱爲堆化（heapifying）；在最大堆中，要堆化一個元素，須要找到它的父親結點，若是不知足堆的基本性質則交換兩個元素的位置，重複該過程直到每一個結點都知足堆的性質爲止，下面咱們來模擬一下這個過程：
下面咱們在該堆中插入一個新的元素26：
咱們經過索引（上面的公式）能夠很容易地找到新插入元素的父親結點，而後比較它們的大小，若是新元素更大則交換兩個元素的位置，這個操做就至關於把該元素上浮了一下：
重複該操做直到26到了一個知足堆條件的位置，此時就完成了插入的操做：
對應的代碼以下：
// 向堆中添加元素
public void add(E e){
data.addLast(e);
siftUp(data.getSize() - 1);
}
private void siftUp(int k){
while(k > 0 && data.get(parent(k)).compareTo(data.get(k)) < 0 ){
data.swap(k, parent(k));
k = parent(k);
}
}
取出堆中的最大元素和Sift Down
若是理解了上述的過程，那麼取出堆中的最大元素（堆頂元素）將變得容易，不過這裏運用到一個小技巧，就是用最後一個元素替換掉棧頂元素，而後把最後一個元素刪除掉，這樣一來元素的總個數也知足條件，而後只須要把棧頂元素依次往下調整就行了，這個操做就叫作Sift Down（下沉）：
用最後元素替換掉棧頂元素，而後刪除最後一個元素：
而後比較其孩子結點的大小：
若是不知足堆的條件，那麼就跟孩子結點中較大的一個交換位置：
重複該步驟，直到16到達合適的位置：
完成取出最大元素的操做：
對應的代碼以下：
// 看堆中的最大元素
public E findMax(){
if(data.getSize() == 0)
throw new IllegalArgumentException("Can not findMax when heap is empty.");
return data.get(0);
}
// 取出堆中最大元素
public E extractMax(){
E ret = findMax();
data.swap(0, data.getSize() - 1);
data.removeLast();
siftDown(0);
return ret;
}
private void siftDown(int k){
while(leftChild(k) < data.getSize()){
int j = leftChild(k); // 在此輪循環中,data[k]和data[j]交換位置
if( j + 1 < data.getSize() &&
data.get(j + 1).compareTo(data.get(j)) > 0 )
j ++;
// data[j] 是 leftChild 和 rightChild 中的最大值
if(data.get(k).compareTo(data.get(j)) >= 0 )
break;
data.swap(k, j);
k = j;
}
}
Replace 和 Heapify
Replace這個操做其實就是取出堆中最大的元素以後再新插入一個元素，常規的作法是取出最大元素以後，再利用上面的插入新元素的操做對堆進行Sift Up操做，可是這裏有一個小技巧就是直接使用新元素替換掉堆頂元素，以後再進行Sift Down操做，這樣就把兩次O(logn）的操做變成了一次O(logn)：
// 取出堆中的最大元素，而且替換成元素e
public E replace(E e){
E ret = findMax();
data.set(0, e);
siftDown(0);
return ret;
}
Heapify翻譯過來就是堆化的意思，就是將任意數組整理成堆的形狀，一般的作法是遍歷數組從0開始添加建立一個新的堆，可是這裏存在一個小技巧就是把當前數組就看作是一個徹底二叉樹，而後從最後一個非葉子結點開始進行Sift Down操做就能夠了，最後一個非葉子結點也很好找，就是最後一個結點的父親結點，你們能夠驗證一下：
從22這個節點開始，依次開始Sift Down操做：
重複該過程直到堆頂元素：
完成堆化操做：
將n個元素逐個插入到一個空堆中，算法複雜度是O(nlogn)，而heapify的過程，算法複雜度爲O(n)，這是有一個質的飛躍的，下面是代碼：
public MaxHeap(E[] arr){
data = new Array<>(arr);
for(int i = parent(arr.length - 1) ; i >= 0 ; i --)
siftDown(i);
}
基於堆的優先隊列
首先咱們的隊列仍然須要繼承咱們以前將隊列時候聲明的哪一個接口Queue，而後實現這個接口中的方法就能夠了，之類簡單寫一下：
public class PriorityQueue<E extends Comparable<E>> implements Queue<E> {
private MaxHeap<E> maxHeap;
public PriorityQueue(){ maxHeap = new MaxHeap<>(); }
@Override
public int getSize(){ return maxHeap.size(); }
@Override
public boolean isEmpty(){ return maxHeap.isEmpty(); }
@Override
public E getFront(){ return maxHeap.findMax(); }
@Override
public void enqueue(E e){ maxHeap.add(e); }
@Override
public E dequeue(){ return maxHeap.extractMax(); }
}
Java中的PriorityQueue
在Java中也實現了本身的優先隊列java.util.PriorityQueue，與咱們本身寫的不一樣之處在於，Java中內置的爲最小堆，而後就是一些函數名不同，底層仍是維護了一個Object類型的數組，你們能夠戳戳看有什麼不一樣，另外若是想要把最小堆變成最大堆能夠給PriorityQueue傳入本身的比較器，例如：
// 默認爲最小堆
PriorityQueue<Integer> pq = new PriorityQueue<>();
pq.add(5);
pq.add(2);
pq.add(1);
pq.add(10);
pq.add(3);
while (!pq.isEmpty()) {
System.out.println(pq.poll() + ", ");
}
System.out.println();
System.out.println("————————————————————————");
// 使用Lambda表達式傳入本身的比較器轉換成最大堆
PriorityQueue<Integer> pq2 = new PriorityQueue<>((a, b) -> b - a);
pq2.add(5);
pq2.add(2);
pq2.add(1);
pq2.add(10);
pq2.add(3);
while (!pq2.isEmpty()) {
System.out.println(pq2.poll() + ", ");
}
LeetCode相關題目整理
23. 合併K個排序鏈表
參考答案：（85ms）
public ListNode mergeKLists(ListNode[] lists) {
if (lists == null || lists.length == 0) return null;
PriorityQueue<ListNode> q = new PriorityQueue<>(Comparator.comparing(node -> node.val));
for (int i = 0; i < lists.length; i++) {
if (lists[i] != null) {
q.add(lists[i]);
}
}
ListNode dummy = new ListNode(0);
ListNode tail = dummy;
while (!q.isEmpty()) {
tail.next = q.poll();
tail = tail.next;
if (tail.next != null) {
q.add(tail.next);
}
}
return dummy.next;
}
215. 數組中的第K個最大元素
個人答案：（75ms）
public int findKthLargest(int[] nums, int k) {
// 正確性判斷
if (0 == nums.length || null == nums || k <= 0 || k > nums.length) {
return -1;
}
// 構造優先隊列,默認爲最小堆,傳入自定義的比較器轉換成最大堆
PriorityQueue<Integer> pq = new PriorityQueue<>((a, b) -> b - a);
for (Integer num : nums) {
pq.add(num);
}
for (int i = 0; i < k - 1; i++) {
pq.remove();
}
return pq.peek();
}
參考答案：（5ms）
public int findKthLargest(int[] nums, int k) {
if (nums.length == 1) {
return nums[0];
}
int max = nums[0];
int min = nums[0];
for (int i : nums) {
max = i > max ? i : max;
min = i < min ? i : min;
}
int[] arrs = new int[max - min + 1];
for (int i : nums) {
arrs[max - i]++;
}
int pos = 0;
for (int i = 0; i < arrs.length; i++) {
pos += arrs[i];
if (pos >= k) {
return max - i;
}
}
return nums[0];
}
還看到一個簡單粗暴的，也是服了：（4ms）
public int findKthLargest(int[] nums, int k) {
Arrays.sort(nums);
return nums[nums.length - k];
}
並且我隨機生成了一個100萬數據的隨機數組，來測試這個簡單粗暴的方法的效率，發現當數據量上去以後，排序這個操做變得繁瑣，我本身測試的時候，上面三個方法，第三個大概比第一個（我本身寫的方法）多花僅4倍的時間；
239. 滑動窗口最大值（相似劍指Offer面試題59）
參考答案：（88ms）
public int[] maxSlidingWindow(int[] nums, int k) {
if (nums == null || k <= 0) return new int[0];
int[] res = new int[nums.length - k + 1];
ArrayDeque<Integer> deque = new ArrayDeque<Integer>();
int index = 0;
for (int i = 0; i < nums.length; i++) {
while (!deque.isEmpty() && deque.peek() < i - k + 1) // Ensure deque's size doesn't exceed k
deque.poll();
// Remove numbers smaller than a[i] from right(a[i-1]) to left, to make the first number in the deque the largest one in the window
while (!deque.isEmpty() && nums[deque.peekLast()] < nums[i])
deque.pollLast();
deque.offer(i);// Offer the current index to the deque's tail
if (i >= k - 1)// Starts recording when i is big enough to make the window has k elements
res[index++] = nums[deque.peek()];
}
return res;
}
參考答案2：（9ms）
public int[] maxSlidingWindow(int[] nums, int k) {
/*
思想：依次遍歷數組，有效範圍在長度k內尋找當前最大值，在用result數組來依次存儲當前長度K內的最大值；
若在當前輪中出現新增的nums[end]大於curMax,直接替換便可；
若是當前輪curMax不是新增的nums[end]，在新的範圍內重置curMax.
*/
if (nums.length == 0 || k <= 0)
return new int[0];
int curMax = Integer.MIN_VALUE;
for (int i = 0; i < k; i++) {
if (nums[i] > curMax)
curMax = nums[i];
}
int[] ans = new int[nums.length - k + 1];
ans[0] = curMax;
for (int start = 1; start + k - 1 < nums.length; start++) {
int end = start + k - 1;
if (nums[end] > curMax)
curMax = nums[end];
else if (nums[start - 1] == curMax) {//新增的不大於curMax，新範圍內重置
curMax = Integer.MIN_VALUE;
for (int i = start; i <= end; i++) {
if (nums[i] > curMax)
curMax = nums[i];
}
}
ans[start] = curMax;
}
return ans;
}
264. 醜數 II（劍指Offer面試題49）
參考答案：（7ms）
public int nthUglyNumber(int n) {
// 正確性判斷
if (n < 1 || n > 1690) {
return -1;
}
int[] ugly = new int[n];
ugly[0] = 1;
int index2 = 0, index3 = 0, index5 = 0;
int factor2 = 2, factor3 = 3, factor5 = 5;
for (int i = 1; i < n; i++) {
int min = Math.min(Math.min(factor2, factor3), factor5);
ugly[i] = min;
if (factor2 == min)
factor2 = 2 * ugly[++index2];
if (factor3 == min)
factor3 = 3 * ugly[++index3];
if (factor5 == min)
factor5 = 5 * ugly[++index5];
}
return ugly[n - 1];
}
若是採用逐個判斷每一個整數是否是醜數的解法，直觀但不夠高效，因此咱們就須要換一種思路，個人第一反應就是這其中必定有什麼規律，可是嘗試着找了一下，沒找到...看了看答案才幡然醒悟，前面提到的算法之因此效率低，很大程度上是由於無論一個數是否是醜數，咱們都要對它進行計算，接下來咱們試着找到一種只計算醜數的方法，而不在非醜數的整數上花費時間，根據醜數的定義，醜數應該是另外一個醜數乘以二、3或者5的結果（1除外），所以，咱們能夠建立一個數組，裏面的數字是排好序的醜數，每一個醜數都是前面的醜數乘以二、3或者5獲得的，也就是上面的算法了..
295.數據流的中位數（劍指Offer面試題41）
參考答案：（219ms）
public class MedianFinder {
PriorityQueue<Integer> maxHeap;
PriorityQueue<Integer> minHeap;
/**
* initialize your data structure here.
*/
public MedianFinder() {
maxHeap = new PriorityQueue<>(Collections.reverseOrder());
minHeap = new PriorityQueue<>();
}
public void addNum(int num) {
maxHeap.add(num);
minHeap.add(maxHeap.poll());
if (minHeap.size() - maxHeap.size() > 0) {
maxHeap.add(minHeap.poll());
}
}
public double findMedian() {
if (maxHeap.size() == minHeap.size()) {
return (maxHeap.peek() + minHeap.peek()) / 2.0;
} else {
return maxHeap.peek();
}
}
}
思路：這道題的實現思路有不少，好比咱們能夠在插入的時候就將每一個元素插入到正確的位置上，這樣返回中位數的時候就會是一個O(1)的操做，下面列舉一張表來講明不一樣實現的複雜度具體是多少：
數據結構 插入的時間複雜度 獲得中位數的時間複雜度 沒有排序的數組 O(1) O(n) 排序的數組 O(n) O(1) 排序的鏈表 O(n) O(1) 二叉搜索樹 平均O(logn)，最差O(n) 平均O(logn)，最差O(n) AVL樹 O(logn) O(logn) 最大堆和最小堆 O(logn) O(logn) AVL樹是一種很高效的數據結構，可是在大多數的語言中都沒有現成的實現，因此考慮用最大堆和最小堆，對於一個已經排好序的數據容器，咱們能夠從中間分開分紅兩個部分，其中拿P1指向左半部分最大的元素，拿P2指向有半部分最小的元素，若是可以保證數據容器左邊的數據都小於右邊的數據，那麼即便左、右兩邊內部的數據沒有排序，咱們仍然能夠根據左邊最大的數和右邊最大的數獲得中位數：
如何快速從一個數據容器中找出最大數呢？咱們可使用最大堆來實現這個數據容器，由於堆頂的元素就是最大的元素；一樣咱們可使用最小堆來快速找出一個數據容器中最小數。所以按照這個思路咱們就可使用一個最大堆實現左邊的數據容器，使用一個最小堆實現右邊的數據容器，可是須要注意的是這兩個容器的大小差值不能超過1；
347. 前K個高頻元素（相似劍指Offer面試題40）
參考答案：（131ms）
public List<Integer> topKFrequent(int[] nums, int k) {
TreeMap<Integer, Integer> map = new TreeMap<>();
// 保存頻率
for (int num : nums) {
if (map.containsKey(num)) {
map.put(num, map.get(num) + 1);
} else {
map.put(num, 1);
}
}
PriorityQueue<Integer> pq = new PriorityQueue<>(Comparator.comparingInt(map::get));
for (int key : map.keySet()) {
if (pq.size() < k) {
pq.add(key);
} else if (map.get(key) > map.get(pq.peek())) {
pq.remove();
pq.add(key);
}
}
LinkedList<Integer> res = new LinkedList<>();
while (!pq.isEmpty()) {
res.add(pq.remove());
}
return res;
}
692. 前K個高頻單詞
參考答案：（72ms）
public List<String> topKFrequent(String[] words, int k) {
Map<String, Integer> count = new HashMap();
for (String word: words) {
count.put(word, count.getOrDefault(word, 0) + 1);
}
List<String> candidates = new ArrayList(count.keySet());
Collections.sort(candidates, (w1, w2) -> count.get(w1).equals(count.get(w2)) ?
w1.compareTo(w2) : count.get(w2) - count.get(w1));
return candidates.subList(0, k);
}
這道題相似於上面的第347題，可是問題出在返回的順序上，須要本身來定義一個比較器來排序..而後也學到一個寫法，就是上面的第一個for循環裏，
getOrDefault()方法，get√..
參考答案2：（91ms）
public List<String> topKFrequent(String[] words, int k) {
Map<String, Integer> count = new HashMap();
for (String word: words) {
count.put(word, count.getOrDefault(word, 0) + 1);
}
PriorityQueue<String> heap = new PriorityQueue<String>(
(w1, w2) -> count.get(w1).equals(count.get(w2)) ?
w2.compareTo(w1) : count.get(w1) - count.get(w2) );
for (String word: count.keySet()) {
heap.offer(word);
if (heap.size() > k) heap.poll();
}
List<String> ans = new ArrayList();
while (!heap.isEmpty()) ans.add(heap.poll());
Collections.reverse(ans);
return ans;
}
這個解法就有點兒相似於上面的347題，實際上是大同小異，就是本身不會靈活使用比較器而已，學習到了學習到了√...
簡單總結
今天算是頗有收穫的一天，由於這兩種數據結構都是本身特別不熟悉的，特別是在刷了一些LeetCode相關題目以後，對這兩種數據有了很不同的認識，特別是堆的應用，這是一種特別適合用來找第k小/大的特殊的數據結構，而且在Java中竟然有直接的實現，這可太棒了，並且今天的效率還算挺高的，知足；
歡迎轉載，轉載請註明出處！
簡書ID：@我沒有三顆心臟
github：wmyskxz 歡迎關注公衆微信號：wmyskxz_javaweb 分享本身的Java Web學習之路以及各類Java學習資料
- 1. 數據結構與算法(4)——優先隊列和堆
- 2. python 數據結構與算法——優先隊列和堆
- 3. 數據結構——優先隊列與堆
- 4. 【數據結構】堆和優先隊列
- 5. 數據結構 | 優先隊列和堆
- 6. 數據結構-堆和優先隊列
- 7. 數據結構與算法：優先隊列（堆）
- 8. 數據結構與算法分析之優先隊列(堆)
- 9. 數據結構與算法分析-優先隊列 堆（heap）
- 10. 【數據結構與算法分析】05：優先隊列（堆）
- 更多相關文章...
- • C# 隊列（Queue） - C#教程
- • Rust 結構體 - RUST 教程
- • 算法總結-廣度優先算法
- • 算法總結-深度優先算法
-
每一个你不满意的现在，都有一个你没有努力的曾经。
- 1. eclipse設置粘貼字符串自動轉義
- 2. android客戶端學習-啓動模擬器異常Emulator: failed to initialize HAX: Invalid argument
- 3. android.view.InflateException: class com.jpardogo.listbuddies.lib.views.ListBuddiesLayout問題
- 4. MYSQL8.0數據庫恢復 MYSQL8.0ibd數據恢復 MYSQL8.0恢復數據庫
- 5. 你本是一個肉體，是什麼驅使你前行【1】
- 6. 2018.04.30
- 7. 2018.04.30
- 8. 你本是一個肉體，是什麼驅使你前行【3】
- 9. 你本是一個肉體，是什麼驅使你前行【2】
- 10. 【資訊】LocalBitcoins達到每週交易比特幣的7年低點