Algorithm之排序之堆排序（Heap Sort）

[color=green][size=medium][b]Algorithm之排序之堆排序（Heap Sort）[/b][/size][/color]

[size=medium][b]一、什么是堆[/b][/size]

在讲述堆之前，首先看一下二叉树。

二叉树：
每个节点最多有两个子节点，且这两个子节点有左右次序之分。


[b]1、满二叉树[/b]
二叉树的所有非叶子节点都被填满。
因此：一颗深度为 K 的满二叉树，其节点总数为：2的k次方 - 1

= 1 + 2 + 4 + 8 + ... + 2 pow(k-1)

= 2(0) + 2(1) + 2(2) + 2(3) + ... + 2(k-1) = 2pow(k) - 1

图（深度为 3 的满二叉树）：
[img]http://dl2.iteye.com/upload/attachment/0122/7202/db4bf4a1-5d42-3b9b-8083-e163fc10dc50.png[/img]


[b]2、完全二叉树[/b]
有 n 个节点，深度为 k 的二叉树，
当且仅当，这 n 个节点的排列序号，与深度为 k 的满二叉树中
序号为 1 至 n 的节点一一对应时，称之为完全二叉树。

即：
- 除了最外层，其它层都是有序且填满的。
- 上一层没有排完，不能排下一层。


图（深度为 3 的完全二叉树）：
[img]http://dl2.iteye.com/upload/attachment/0122/7204/99f07258-3bee-3841-b21e-fbdecfd698e6.png[/img]


[b]3、堆[/b]
仅从数据结构角度看：符合完全二叉树的数据结构称之为：堆。
且，所有父节点比其下子节点都大（或小），
但，堆不要求每层中左右子节点的大小顺序。

将根节点最大的堆叫做最大堆或大根堆，根节点最小的堆叫做最小堆或小根堆。


[size=medium][b]二、堆的操作方法[/b][/size]

[b]1、插入节点[/b]
每次插入都是将新数据放在数组最后。然后依次向上调整。
直至符合：父节点比子节点都大（或小）。

[b]2、删除节点[/b]
按定义，堆中每次都只能删除最顶层的那个节点（数组中索引为0的元素）。
为了便于重建堆，实际的操作是将数组最末尾的元素与根节点位置调换。
然后再只需调整根节点使其符合堆特性即可。（其它节点是已调整好的）

以最小堆为例：
调整根节点时先在左右子结点中找最小的，如果根结点比这个最小的子结点还小说明不需要调整了，
反之将父结点和它交换后，还需要再考虑后面的结点。相当于从根结点将一个数据的“下沉”过程。


[size=medium][b]三、堆与数组的关系[/b][/size]
基于：数组的索引是从 0 开始（Zero-Based）：
[img]http://dl2.iteye.com/upload/attachment/0122/7224/d0bf9796-34c0-316a-8f05-ee06ef9a229b.png[/img]

从上图中可以发现，以数组表示的堆，其数据结构中的每个节点的索引值存在这样的特点：

父节点：parent(i) = (i - 1) >> 1;

子节点（左）：leftChild(i) = i * 2 + 1;

子节点（右）：rightChild(i) = i * 2 + 2;


任何一个数组，附以上述规则，那么这个数组就可以被看作是一个堆。
也就是说，堆可以用数组表示。反之：任何一个数组，都是一个堆。

堆的逻辑结构：完全二叉树
堆的存储结构：数组（内存中一块地址连续的空间），或：一堆空间。

既于，数组具天然有序索引这一特性：数组的索引就是一个排好序的堆。
那么，只需要按照数组的索引将其值放置为符合堆的规则即可——堆排序。


[size=medium][b]四、堆排序的过程[/b][/size]

堆排序共分两步：

[b]第一步：将数组堆化[/b]

把数组的每个节点，调整为具有堆的该特性：所有的父节点都比子节点大（或小）。

方法：遍历数组的每个节点

1、遍历的方向：从最外层向内层遍历（自底向上）

2、从哪里开始：从后向前数，从第一个非叶子节点开始遍历。
没有必要从叶子节点开始。（
叶子节点可以看作是已符合堆特点的节点。
因为它没有子节点，所以作为父节点，它就是最大的。）

第一个非叶子节点的索引值可以根据最后一个元素的索引值求得：
lastNodeIndex = (lastLeafIndex - 1) >> 1 = (arr.length - 2) >> 1;

3、每步遍历的规则：
虽然堆的子节点是不要求有大小顺序的，但是因为我们要对堆进行排序，
故：对于每个节点和它的子节点都要相互比较大小，
对于大堆，最大的那个排在父节点的位置。
对于小堆，最小的那个排在父节点的位置。

4、每步遍历多少次：如果子节点与父节点交换了位置，则交换位置后的父节点仍需要向下验证。


[img]http://dl2.iteye.com/upload/attachment/0122/7306/83565875-f4ca-3150-a0d7-a69e63e7b01b.png[/img]
[img]http://dl2.iteye.com/upload/attachment/0122/7304/ccf70294-16ed-3d35-9d3e-f31b9471c09a.png[/img]


[b]第二步：将堆化数组排序[/b]

堆排序的过程就是，不断移出最顶层（数组的第一个）元素的过程。
1、把移出的顶层元素与数组最后一个元素交换位置。
2、同时遍历的长度减 1，
3、然后从新调整剩余的数据，使其符合堆的特性。（
此时只需要调整最顶层元素即可，其它层都是已经被初始化好的）

重复该过程，直至需要遍历的数组长度为 0 。


[img]http://dl2.iteye.com/upload/attachment/0122/7310/7f9fb25f-fc14-3cf1-8f36-b31c1a817e3a.png[/img]
[img]http://dl2.iteye.com/upload/attachment/0122/7312/b5bdead8-3b40-31b2-9ebd-b06efda63c1a.png[/img]


排好序的堆就是一颗完全二叉树了：
1、所有的父节点都比子节点小（或大）
2、同一节点的左子节点比右子节点小（或大）

[img]http://dl2.iteye.com/upload/attachment/0122/7314/e9d92ee0-6dfe-3fcd-8f55-9f36cd70fb2f.png[/img]


排序动画：
[img]http://dl2.iteye.com/upload/attachment/0122/7316/1c3804d9-cf1f-3c93-a665-f00971c88a95.gif[/img]


Javascript代码实现：

function heapSort(arr){

    // step 1. heapify array
    var len = arr.length - 1;
    var lastNodeIndex = (len - 1) >> 1;
    for(var i = lastNodeIndex; i >= 0; i--){
        maxHeapify(arr, i, len);
    }

    // step 2. reduce heap
    for(var i = 0; i < len; i++){
        swap(arr, 0, len - i);
        maxHeapify(arr, 0, len - i - 1);
    }

    return arr;
}

function swap(arr, i, j){
    var temp = arr[i];
    arr[i] = arr[j];
    arr[j] = temp;
}


function maxHeapify(arr, index, len){
    var li = (index << 1) + 1,    // left child index.
        ri = li + 1,              // right child index.
        cMax = li;                // default Child Max valule.

    if(li > len) return;               // left child is out of range.             
    if(ri <= len && arr[ri] > arr[li]) // choose the bigger one.
        cMax = ri;            
    if(arr[cMax] > arr[index]){        // if
        swap(arr, index, cMax);        // swapped, 
        maxHeapify(arr, cMax, len);    // next check should be executed.
    }
}

/*

// alternative method for maxHeapify();
function maxHeapify2(array, index, len) {
    var iLeft, iRight, iMax;        
    while (true) {
      iLeft = (index << 1) + 1;
      iRight = iLeft + 1;
      iMax = iLeft;

      if(iLeft > len) break;
      if(iRight <= len && array[iRight] > array[iLeft])
          iMax = iRight;
      if(array[iMax] <= array[index]) break;
      swap(array, iMax, index);
      index = iMax;
    }
}

*/

测试：

var arr = [1,23,14,8,10,9,235,21,45,56,4,32,79,15,56,985,343];

heapSort(arr);

// [1, 4, 8, 9, 10, 14, 15, 21, 23, 32, 45, 56, 56, 79, 235, 343, 985]

Java 版本：

import java.util.Arrays;

public class HeapSort {

    private int[] arr;

    public HeapSort(int[] arr){
        this.arr = arr;
    }

    /**
     * 堆排序的主要入口方法，共两步。
     */
    public void sort(){
        /*
         *  第一步：将数组堆化
         *  beginIndex = 第一个非叶子节点。
         *  从第一个非叶子节点开始即可。无需从最后一个叶子节点开始。
         *  叶子节点可以看作已符合堆要求的节点，根节点就是它自己且自己以下值为最大。
         */
        int len = arr.length - 1;
        int beginIndex = (len - 1) >> 1; 
        for(int i = beginIndex; i >= 0; i--){
            maxHeapify(i, len);
        }

        /*
         * 第二步：对堆化数据排序
         * 每次都是移出最顶层的根节点A[0]，与最尾部节点位置调换，同时遍历长度 - 1。
         * 然后从新整理被换到根节点的末尾元素，使其符合堆的特性。
         * 直至未排序的堆长度为 0。
         */
        for(int i = len; i > 0; i--){
            swap(0, i);
            maxHeapify(0, i - 1);
        }
    }

    private void swap(int i,int j){
        int temp = arr[i];
        arr[i] = arr[j];
        arr[j] = temp;
    }

    /**
     * 调整索引为 index 处的数据，使其符合堆的特性。
     * 
     * @param index 需要堆化处理的数据的索引
     * @param len 未排序的堆（数组）的长度
     */
    private void maxHeapify(int index,int len){
        int li = (index << 1) + 1; // 左子节点索引
        int ri = li + 1;           // 右子节点索引
        int cMax = li;             // 子节点值最大索引，默认左子节点。

        if(li > len) return;       // 左子节点索引超出计算范围，直接返回。
        if(ri <= len && arr[ri] > arr[li]) // 先判断左右子节点，哪个较大。
            cMax = ri;
        if(arr[cMax] > arr[index]){
            swap(cMax, index);      // 如果父节点被子节点调换，
            maxHeapify(cMax, len);  // 则需要继续判断换下后的父节点及其以下的子节点，是否符合堆的特性。
        }
    }

    /**
     * 测试用例
     * 
     * 输出：
     * [0, 0, 0, 1, 1, 1, 2, 2, 2, 3, 3, 3, 4, 4, 4, 5, 5, 5, 6, 6, 6, 7, 7, 7, 8, 8, 8, 9, 9, 9]
     */
    public static void main(String[] args) {
        int[] arr = new int[]{3,5,3,0,8,6,1,5,8,6,2,4,9,4,7,0,1,8,9,7,3,1,2,5,9,7,4,0,2,6};        
        new HeapSort(arr).sort();        
        System.out.println(Arrays.toString(arr));
    }

}

[size=medium][b]五、堆排序分析[/b][/size]


堆排序与归并排序一样，是一种时间复杂度为O(N * logN)的算法，
同时和插入排序一样，是一种就地排序算法(不需要额外的存储空间)。


-
转载请注明，
原文出处：http://lixh1986.iteye.com/blog/2354246


-
引用：

堆_(数据结构)
https://zh.wikipedia.org/wiki/堆_(数据结构)

常见排序算法 - 堆排序 (Heap Sort)
http://bubkoo.com/2014/01/14/sort-algorithm/heap-sort/

堆排序详解
http://blog.csdn.net/daiyudong2020/article/details/52529791

堆排序详解
http://www.cnblogs.com/hdk1993/p/4635923.html

堆排序 - 维基百科
https://zh.wikipedia.org/wiki/堆排序