堆排序及优先队列

堆：一种数据结构，有最大堆和最小堆两种类型，实质上是一个完全二叉树，如果是最大堆，则父节点上的值比子节点上的值大，反之则是最小堆。

ps：这里提及的堆与常说的堆内存区域的堆不一样，此处提及的堆是一种简单的数据结构，而堆内存的实现较复杂。

堆排序：堆排序是一种比较高效的排序方式，时间效率为N*lgN，它利用最大堆的特性完成排序

本人之前的博文中有提到归并排序，与堆排序相比，二者效率相同，但堆排序还有个最大的好处就是，它比较省空间，在归并排序中需要申请额外左右数组空间，内存占用空间大。

堆排序分为三个步骤：

• 创建最大堆
• 确保最大堆中父节点的值比子节点的值都大
• 将根节点与最后一个叶子节点比较，择其大者剔除出堆，再重复第2、3步。

第二步是整个堆排序的关键。

public static void maxHeapify(int[] array, int heapsize, int i){
    int l = 2*i + 1;
    int r = 2*i + 2;
    int large = i;
    if (l < heapsize && array[i] < array[l]) {
        large = l;
    }else {
        large = i;
    }
    if (r < heapsize && array[large] < array[r]) {
        large = r;
    }
    if (large != i) {
        int temp = array[i];
        array[i] = array[large];
        array[large] = temp;
        //因为将最大值和父节点交换了位置，新的子节点并不能保证一定是比它的子节点大
        //所以需要递归，确定交换的子节点比它的子节点都大
        //而没有动的子节点是不需要进行递归的，因为它的数值没有变，如果之前满足最大堆条件，现在就还是满足的
        maxHeapify(array, heapsize, large);
    }
}

maxHeapify过程并不复杂，注意到函数中有参数heapsize，本例中的堆其实是基于数组的，堆大小并不一定等于数组长度的，因为在堆排序的第三步中需要将堆的根节点剔除出堆，所以堆的长度一直在变。

创建最大堆过程：

  public static void buildMaxHeap(int[] array){
    int heapsize = array.length;
    for (int i = heapsize/2; i >= 0; i--) {
        maxHeapify(array,heapsize,i);
    }
}

buildMaxHeap过程，有两点需要注意。

• 堆其实是一个完全二叉树，且是以数组实现的，那么二叉树中i节点的左子节点一定是2_i + 1，右子节点一定是2_i + 2，对应在数组中 array.length/2 到 array.length - 1之间的节点，肯定是叶子节点，没有子节点，因为如果有子节点，则子节点的索引已经大于数组长度了，所以不可能出现。
• 创建堆必须逆序，即必须先确认完全二叉树底层的节点具有最大堆的性质，父节点必须大于子节点，然后再逐层往上，最后才确保根结点具有最大堆性质才行。如果遍历是从0开始，那么整个完全二叉树将不具有最大堆性质。

buildMaxHeap后，完全二叉树中的根结点就一定是整个数组中最大的（因为父节点一定大于子结点的性质）。注意，只能保证根结点的值是最大的，最下方的最后的子结点，则并不一定是最小的值。

heapSort过程，因为知道根结点一定是最大的，所以可以将根结点和数组中最后一位相比较，交换二者的值，然后再将数组中最后一位剔除出堆（此时，数组中最后一位已经是最大值了），再重新确保最大堆特性，持续这个过程，即将完全堆排序。

  public static void heapSort(int[] array){
    int heapsize = array.length;
    for (int i = heapsize - 1; i > 0; i--) {
        if (array[i] < array[0]) {
            int temp = array[0];
            array[0] = array[i];
            array[i] = temp;
            heapsize --;
            maxHeapify(array, heapsize, 0);
        }
    }
}

测试代码：

  public static void main(String[] args) {
    int[] array = {4,1,3,2,16,9,10,14,8,7,5};
    buildMaxHeap(array);
    print(array);
    heapSort(array);
    print(array);
}

堆排序的时间效率计算较为复杂，主要是其中牵涉到递归。一般而言，算法的时间效率仅考虑最差极值情况。maxHeapify过程，根结点的值最小，那么需要将根结点的值一直往树的下层挪，最后根结点的值将变成叶子结点的值，那么挪动的距离则为二叉树的高度，于是maxHeapify的效率与二叉树的高度相关，二叉树的高度为lgN，那么maxHeapify的效率为lgN，在heapSort过程中，遍历N次，每次效率均为lgN，那么整个排序算法的效率为N*lgN。 ps：以上是本人的简单推测算法，详细推算请参考算法导论。

优先队列是一种用来维护由一组元素构成的集合S的数据结构，内部数据排序位置由元素本身决定，通常优先队列首位数据是集合中最大的或最小的一位。

优先队列中首位数据是最大值，则称为最大优先队列。 最大优先队列只是首位最大，并不保证队列中均是由大到小顺序排列。如果是以数组实现，则可保证，但此处是以堆实现，则不能确保从大到小排列，只能保证首位值最大。

优先队列有常见三个操作：

• 获取最大值
• 获取最大值并将值删除出堆
• 更改某个位置值大小

heapMaxNum过程非常简单：

  public static int heapMaxNum(int[] array){
    return array[0];
  }

heapExtractMax：

  public static int heapExtractMax(int[] array){
    if (array.length == 0) {
        System.out.println("heap is empty");
    }
    int i = array.length - 1;
    int max = array[0];
    array[0] = array[i];
    maxHeapify(array, array.length - 1, 0);
    return max;
}

heapExtractMax过程，取出最大值，然后将堆中最后一位放到首位，再执行maxHeapify，检查最大堆性质。

heapIncreaseKey：

  public static void heapIncreaseKey(int[] array, int i, int key){
    if (key < array[i]) {
        System.out.println("the key is small than origin");
        return;
    }
    array[i] = key;
    int parent = getParent(i);
    while (parent != Integer.MIN_VALUE && array[i] > array[parent]) {
        int temp = array[i];
        array[i] = array[parent];
        array[parent] = temp;
        i = parent;
        parent = getParent(parent);
    }
}

heapIncreaseKey过程，需要将当前值与父节点比较，如果大于父节点则交换位置，再从当前父节点往上，循环此过程。

因为父节点一定大于原节点，所以并不需要从原节点再往下循环，确保最大堆性质了。

根据完全二叉树性质，获取父节点代码如下：

  public static int getParent(int i){
    if (i == 0) {
        return Integer.MIN_VALUE;
    }else {
        if (i%2 == 0) {
            return (i-1)/2;
        }else {
            return i/2;
        }
    }
}

使用堆实现优先队列比用纯数组实现更高效，纯数组因为需要保证从大到小排列，则插入效率为N，而堆插入效率为N*lgN

ps：堆一定包含非常重要的属性，堆长度，本例中仅使用数组简单实现。

最后

如果想要成为架构师或想突破20~30K薪资范畴，那就不要局限在编码，业务，要会选型、扩展，提升编程思维。此外，良好的职业规划也很重要，学习的习惯很重要，但是最重要的还是要能持之以恒，任何不能坚持落实的计划都是空谈。

如果你没有方向，这里给大家分享一套由阿里高级架构师编写的《Android八大模块进阶笔记》，帮大家将杂乱、零散、碎片化的知识进行体系化的整理，让大家系统而高效地掌握Android开发的各个知识点。

相对于我们平时看的碎片化内容，这份笔记的知识点更系统化，更容易理解和记忆，是严格按照知识体系编排的。

全套视频资料：

一、面试合集

二、源码解析合集

三、开源框架合集

欢迎大家一键三连支持，若需要文中资料，直接扫描文末CSDN官方认证微信卡片免费领取↓↓↓