什麼是二叉堆？什麼是堆排序？什麼是優先佇列？
一.什麼是二叉堆？
二叉堆本質上是一種完全二叉樹，它分為兩個型別：
1.最大堆
2.最小堆
什麼是最大堆呢？最大堆任何一個父節點的值，都大於等於它左右孩子節點的值。
什麼是最小堆呢？最小堆任何一個父節點的值，都小於等於它左右孩子節點的值。
二叉堆的根節點叫做堆頂。
最大堆和最小堆的特點，決定了在最大堆的堆頂是整個堆中的最大元素；最小堆的堆頂是整個堆中的最小元素。
堆的自我調整
對於二叉堆，如下有幾種操作：
插入節點
刪除節點
構建二叉堆
這幾種操作都是基於堆的自我調整。
下面讓我們以最小堆為例，看一看二叉堆是如何進行自我調整的。
1.插入節點
二叉堆的節點插入，插入位置是完全二叉樹的最後一個位置。比如我們插入一個新節點，值是 0。
這時候，我們讓節點0的它的父節點5做比較，如果0小於5，則讓新節點“上浮”，和父節點交換位置。
繼續用節點0和父節點3做比較，如果0小於3，則讓新節點繼續“上浮”。
繼續比較，最終讓新節點0上浮到了堆頂位置。
2.刪除節點
二叉堆的節點刪除過程和插入過程正好相反，所刪除的是處於堆頂的節點。比如我們刪除最小堆的堆頂節點1。
這時候，為了維持完全二叉樹的結構，我們把堆的最後一個節點10補到原本堆頂的位置
接下來我們讓移動到堆頂的節點10和它的左右孩子進行比較，如果左右孩子中最小的一個（顯然是節點2）比節點10小，那麼讓節點10“下沉”。
繼續讓節點10和它的左右孩子做比較，左右孩子中最小的是節點7，由於10大於7，讓節點10繼續“下沉”。
這樣一來，二叉堆重新得到了調整。
3.構建二叉堆
構建二叉堆，也就是把一個無序的完全二叉樹調整為二叉堆，本質上就是讓所有非葉子節點依次下沉。
我們舉一個無序完全二叉樹的例子：
首先，我們從最後一個非葉子節點開始，也就是從節點10開始。如果節點10大於它左右孩子中最小的一個，則節點10下沉。
接下來輪到節點3，如果節點3大於它左右孩子中最小的一個，則節點3下沉。
接下來輪到節點1，如果節點1大於它左右孩子中最小的一個，則節點1下沉。事實上節點1小於它的左右孩子，所以不用改變。
接下來輪到節點7，如果節點7大於它左右孩子中最小的一個，則節點7下沉
節點7繼續比較，繼續下沉。
這樣一來，一顆無序的完全二叉樹就構建成了一個最小堆。
堆的程式碼實現
在擼程式碼之前，我們還需要明確一點：
二叉堆雖然是一顆完全二叉樹，但它的儲存方式並不是鏈式儲存，而是順序儲存。換句話說，二叉堆的所有節點都儲存在陣列當中。
陣列中，在沒有左右指標的情況下，如何定位到一個父節點的左孩子和右孩子呢？
像圖中那樣，我們可以依靠陣列下標來計算。
假設父節點的下標是parent，那麼它的左孩子下標就是 2*parent+1；它的右孩子下標就是2*parent+2 。
比如上面例子中，節點6包含9和10兩個孩子，節點6在陣列中的下標是3，節點9在陣列中的下標是7，節點10在陣列中的下標是8。
7 = 3*2+1
8 = 3*2+2
剛好符合規律。
有了這個前提，下面的程式碼就更好理解了：
1.二叉堆的程式碼實現（原文中有錯誤之處，已修正）
public class HeapOperator {
/**
* 上浮調整
* @param array 待調整的堆
*/
public static void upAdjust(int[] array) {
int childIndex = array.length-1;
int parentIndex = (childIndex-1)/2;
// temp儲存插入的葉子節點值，用於最後的賦值
int temp = array[childIndex];
while (childIndex > 0 && temp < array[parentIndex]){
//無需真正交換，單向賦值即可
array[childIndex] = array[parentIndex];
childIndex = parentIndex;
parentIndex = (parentIndex-1) / 2;
}
array[childIndex] = temp;
}
/**
* 下沉調整
* @param array 待調整的堆
* @param parentIndex 要下沉的父節點
* @param parentIndex 堆的有效大小
*/
public static void downAdjust(int[] array, int parentIndex, int length) {
// temp儲存父節點值，用於最後的賦值
int temp = array[parentIndex];
int childIndex = 2 * parentIndex + 1;
while (childIndex < length) {
// 如果有右孩子，且右孩子小於左孩子的值，則定位到右孩子
if (childIndex + 1 < length && array[childIndex + 1] < array[childIndex]) {
childIndex++;
}
// 如果父節點小於任何一個孩子的值，直接跳出
if (temp <= array[childIndex])
break;
//無需真正交換，單向賦值即可
array[parentIndex] = array[childIndex];
parentIndex = childIndex;
childIndex = 2 * childIndex + 1;
}
array[parentIndex] = temp;
}
/**
* 構建堆
* @param array 待調整的堆
*/
public static void buildHeap(int[] array) {
// 從最後一個非葉子節點開始，依次下沉調整
for (int i = (array.length-2 )/ 2; i >= 0; i--) {
downAdjust(array, i, array.length);
}
}
public static void main(String[] args) {
int[] array = new int[] {1,3,2,6,5,7,8,9,10,0};
upAdjust(array);
System.out.println(Arrays.toString(array));
array = new int[] {7,1,3,10,5,2,8,9,6};
buildHeap(array);
System.out.println(Arrays.toString(array));
}
}
插入時上浮，刪除時下沉，構建時下沉
---------------------------------------------------------------------
二.什麼是堆排序？
讓我們回顧一下二叉堆和最大堆的特性：
1.二叉堆本質上是一種完全二叉樹
2.最大堆的堆頂是整個堆中的最大元素
當我們刪除一個最大堆的堆頂（並不是完全刪除，而是替換到最後面），經過自我調節，第二大的元素就會被交換上來，成為最大堆的新堆頂。
正如上圖所示，當我們刪除值為10的堆頂節點，經過調節，值為9的新節點就會頂替上來；當我們刪除值為9的堆頂節點，經過調節，值為8的新節點就會頂替上來.......
由於二叉堆的這個特性，我們每一次刪除舊堆頂，調整後的新堆頂都是大小僅次於舊堆頂的節點。那麼我們只要反覆刪除堆頂，反覆調節二叉堆，所得到的集合就成為了一個有序集合，過程如下：
刪除節點9，節點8成為新堆頂：
刪除節點8，節點7成為新堆頂：
刪除節點7，節點6成為新堆頂：
刪除節點6，節點5成為新堆頂：
刪除節點5，節點4成為新堆頂：
刪除節點4，節點3成為新堆頂：
刪除節點3，節點2成為新堆頂：
到此為止，我們原本的最大堆已經變成了一個從小到大的有序集合。之前說過二叉堆實際儲存在陣列當中，陣列中的元素排列如下：
由此，我們可以歸納出堆排序演算法的步驟：
1. 把無序陣列構建成二叉堆。
2. 迴圈刪除堆頂元素，移到集合尾部，調節堆產生新的堆頂。
2.程式碼實現堆排序
public class HeapOperator2 {
/**
* 下沉調整
* @param array 待調整的堆
* @param parentIndex 要下沉的父節點
* @param parentIndex 堆的有效大小
*/
public static void downAdjust(int[] array, int parentIndex, int length) {
// temp儲存父節點值，用於最後的賦值
int temp = array[parentIndex];
int childIndex = 2 * parentIndex + 1;
while (childIndex < length) {
// 如果有右孩子，且右孩子大於左孩子的值，則定位到右孩子
if (childIndex + 1 < length && array[childIndex + 1] > array[childIndex]) {
childIndex++;
}
// 如果父節點大於任何一個孩子的值，直接跳出
if (temp >= array[childIndex])
break;
//無需真正交換，單向賦值即可
array[parentIndex] = array[childIndex];
parentIndex = childIndex;
childIndex = 2 * childIndex + 1;
}
array[parentIndex] = temp;
}
/**
* 堆排序
* @param array 待調整的堆
*/
public static void heapSort(int[] array) {
// 1.把無序陣列構建成二叉堆。
for (int i = (array.length-2)/2; i >= 0; i--) {
downAdjust(array, i, array.length);
}
System.out.println("二叉堆："+Arrays.toString(array));
// 2.迴圈刪除堆頂元素，移到集合尾部，調節堆產生新的堆頂。
for (int i = array.length - 1; i > 0; i--) {
// 最後一個元素和第一元素進行交換
int temp = array[i];
array[i] = array[0];
array[0] = temp;
// 下沉調整最大堆
downAdjust(array, 0, i);
}
}
public static void main(String[] args) {
int[] arr = new int[] {1,3,2,6,5,7,8,9,10,0};
heapSort(arr);
System.out.println("排序後："+Arrays.toString(arr));
}
}
二叉堆的節點下沉調整（downAdjust 方法）是堆排序演算法的基礎，這個調節操作本身的時間複雜度是多少呢？
假設二叉堆總共有n個元素，那麼下沉調整的最壞時間複雜度就等同於二叉堆的高度，也就是O（logn）。
我們再來回顧一下堆排序演算法的步驟：
1. 把無序陣列構建成二叉堆。
2. 迴圈刪除堆頂元素，移到集合尾部，調節堆產生新的堆頂。
第一步，把無序陣列構建成二叉堆，需要進行n/2次迴圈。每次迴圈呼叫一次downAdjust方法，所以第一步的計算規模是n/2 * logn，時間複雜度 O（nlogn）。
第二步，需要進行n-1次迴圈。每次迴圈呼叫一次downAdjust方法，所以第二步的計算規模是（n-1） * logn ，時間複雜度O（nlogn）。
第二步，需要進行n-1次迴圈。每次迴圈呼叫一次downAdjust方法，所以第二步的計算規模是（n-1） * logn ，時間複雜度O（nlogn）。
兩個步驟是並列關係，所以整體的時間複雜度同樣是O（nlogn）。
------------------------------------------------
三：優先佇列
佇列的特點是什麼？
聰明的小夥伴們都知道，是先進先出（FIFO）。
入佇列：
出佇列：
那麼，優先佇列又是什麼樣子呢？
優先佇列不再遵循先入先出的原則，而是分為兩種情況：
最大優先佇列，無論入隊順序，當前最大的元素優先出隊。
最小優先佇列，無論入隊順序，當前最小的元素優先出隊。
比如有一個最大優先佇列，它的最大元素是8，那麼雖然元素8並不是隊首元素，但出隊的時候仍然讓元素8首先出隊：
要滿足以上需求，利用線性資料結構並非不能實現，但是時間複雜度較高，最壞時間複雜度O（n），並不是最理想的方式。
至於為什麼最壞時間複雜度是O（n），大家可以思考下。
讓我們回顧一下二叉堆的特性：
1.最大堆的堆頂是整個堆中的最大元素
2.最小堆的堆頂是整個堆中的最小元素
因此，我們可以用最大堆來實現最大優先佇列，每一次入隊操作就是堆的插入操作，每一次出隊操作就是刪除堆頂節點。
入隊操作：
1.插入新節點5
2.新節點5上浮到合適位置。
出隊操作：
1.把原堆頂節點10“出隊”
2.最後一個節點1替換到堆頂位置
3.節點1下沉，節點9成為新堆頂
3.程式碼實現優先佇列
package com.ch.interfacemanager.controller;
import java.util.Arrays;
public class PriorityQueue {
private int[] array;
private int size;
public PriorityQueue(){
//佇列初始長度32
array = new int[32];
}
/**
* 入隊
* @param key 入隊元素
*/
private void enQueue(int key) {
//佇列長度超出範圍，擴容
if(size >= array.length){
resize();
}
array[size++] = key;
upAdjust();
}
/**
* 出隊
*/
private int deQueue() throws Exception {
if(size <= 0){
throw new Exception("the queue is empty !");
}
//獲取堆頂元素
int head = array[0];
//最後一個元素移動到堆頂
array[0] = array[--size];
downAdjust();
return head;
}
/**
* 上浮調整
*/
private void upAdjust() {
int childIndex = size-1;
int parentIndex = (childIndex-1)/2;
// temp儲存插入的葉子節點值，用於最後的賦值
int temp = array[childIndex];
while (childIndex > 0 && temp > array[parentIndex])
{
//無需真正交換，單向賦值即可
array[childIndex] = array[parentIndex];
childIndex = parentIndex;
parentIndex = (parentIndex-1) / 2;
}
array[childIndex] = temp;
}
/**
* 下沉調整
*/
private void downAdjust() {
// temp儲存父節點值，用於最後的賦值
int parentIndex = 0;
int temp = array[parentIndex];
int childIndex = 1;
while (childIndex < size) {
// 如果有右孩子，且右孩子大於左孩子的值，則定位到右孩子
if (childIndex + 1 < size && array[childIndex + 1] > array[childIndex]) {
childIndex++;
}
// 如果父節點大於任何一個孩子的值，直接跳出
if (temp >= array[childIndex])
break;
//無需真正交換，單向賦值即可
array[parentIndex] = array[childIndex];
parentIndex = childIndex;
childIndex = 2 * childIndex + 1;
}
array[parentIndex] = temp;
}
/**
* 下沉調整
*/
private void resize() {
//佇列容量翻倍
int newSize = this.size * 2;
this.array = Arrays.copyOf(this.array, newSize);
}
public static void main(String[] args) throws Exception {
PriorityQueue priorityQueue = new PriorityQueue();
priorityQueue.enQueue(3);
priorityQueue.enQueue(5);
priorityQueue.enQueue(10);
priorityQueue.enQueue(2);
priorityQueue.enQueue(7);
System.out.println("出隊元素：" + priorityQueue.deQueue());
System.out.println("出隊元素：" + priorityQueue.deQueue());
System.out.println("出隊元素：" + priorityQueue.deQueue());
System.out.println("出隊元素：" + priorityQueue.deQueue());
System.out.println("出隊元素：" + priorityQueue.deQueue());
}
}
程式碼中採用陣列來儲存二叉堆的元素，因此當元素超過陣列範圍的時候，需要進行resize來擴大陣列長度。
詳細原理請檢視程式設計師小灰：