选择排序(2)——堆排序（heap sort）

前期概念：
二叉树 完全二叉树 左序遍历 中序遍历 右序遍历 堆 小根堆 大根堆

堆排序(Heapsort)是指利用堆积树（堆）这种数据结构所设计的一种排序算法，它是选择排序的一种。可以利用数组的特点快速定位指定索引的元素。堆分为大根堆和小根堆，是完全二叉树。大根堆的要求是每个节点的值都不大于其父节点的值，即A[PARENT[i]] >= A[i]。在数组的非降序排序中，需要使用的就是大根堆，因为根据大根堆的要求可知，最大的值一定在堆顶。

Heapify (A, i)

l← left [i]
r← right [i]
if l ≤ heap-size [A] and A[l] > A[i]
then largest ← l
else largest ← i
if r ≤ heap-size [A] and A[i] > A[largest]
then largest ← r
if largest ≠ i
then exchange A[i] ↔ A[largest]
Heapify (A, largest)

堆的概念

在介绍堆排序之前，首先需要说明一下，堆是个什么玩意儿。

堆是一棵顺序存储的完全二叉树。

其中每个结点的关键字都不大于其孩子结点的关键字，这样的堆称为小根堆。

其中每个结点的关键字都不小于其孩子结点的关键字，这样的堆称为大根堆。

举例来说，对于n个元素的序列{R0, R1, ... , Rn}当且仅当满足下列关系之一时，称之为堆：

(1) Ri <= R2i+1 且 Ri <= R2i+2 (小根堆)

(2) Ri >= R2i+1 且 Ri >= R2i+2 (大根堆)

其中i=1,2,…,n/2向下取整;

要点：

首先，按堆的定义将数组R[0..n]调整为堆（这个过程称为创建初始堆），交换R[0]和R[n]；

然后，将R[0..n-1]调整为堆，交换R[0]和R[n-1]；

如此反复，直到交换了R[0]和R[1]为止。

以上思想可归纳为两个操作：

（1）根据初始数组去构造初始堆（构建一个完全二叉树，保证所有的父结点都比它的孩子结点数值大）。

（2）每次交换第一个和最后一个元素，输出最后一个元素（最大值），然后把剩下元素重新调整为大根堆。

当输出完最后一个元素后，这个数组已经是按照从小到大的顺序排列了。

先通过详细的实例图来看一下，如何构建初始堆。

—————————————————————————————————————————————————————

//代码
public class HeapSort {
private static int[] sort = new int[] { 1, 0, 10, 20, 3, 5, 6, 4, 9, 8, 12, 17, 34, 11 };

public static void main(String[] args) {
System.out.println("Before sort: " + Arrays.toString(sort));

// 没有子节点的才需要创建最大堆，从最后一个的父节点开始
int startIndex = ((sort.length - 1) - 1) >> 1;
// 从尾端开始创建最大堆，每次都是正确的堆
for (int i = startIndex; i >= 0; i--) {
    maxHeapify(sort, sort.length, i);
}

// 排序，最大值放在末尾，data虽然是最大堆，在排序后就成了递增的
// 末尾与头交换，交换后调整最大堆
for (int i = sort.length - 1; i > 0; i--) {
    int temp = sort[0];
    sort[0] = sort[i];
    sort[i] = temp;
    maxHeapify(sort, i, 0);
}

System.out.println("After Heapsort : " + Arrays.toString(sort));

}

/**

• 创建最大堆
  */
  private static void maxHeapify(int[] data, int heapSize, int index) {
  // 当前点与左右子节点比较
  int left = (index << 1) + 1;
  int right = (index << 1) + 2;

  int largest = index;
  if (left < heapSize && data[index] < data[left]) {
  largest = left;
  }
  if (right < heapSize && data[largest] < data[right]) {
  largest = right;
  }
  // 得到最大值后可能需要交换，如果交换了，其子节点可能就不是最大堆了，需要重新调整
  if (largest != index) {
  int temp = data[index];
  data[index] = data[largest];
  data[largest] = temp;
  maxHeapify(data, heapSize, largest);
  }
  }

}

//// end

备注：
参考链接地址：https://wenku.baidu.com/view/af5705ea856a561252d36f71.html