什么是二叉堆？什么是堆排序？什么是优先队列？

什么是二叉堆？什么是堆排序？什么是优先队列？

一.什么是二叉堆？

二叉堆本质上是一种完全二叉树，它分为两个类型：

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来扩大数组长度。

详细原理请查看程序员小灰：

http://www.sohu.com/a/253291836_479559  （什么是二叉堆？）

https://yq.aliyun.com/news/176800 （什么是堆排序？）

http://www.sohu.com/a/256122485_479559 （什么是优先队列？）