堆排序原理详解和Java实现代码

当面试的时候被问到，你对堆有没有做过一些了解？？

当时我我反问了一下：您是指堆数据结构还是JVM里面存储对象等信息的堆时？？

当时感觉自己还挺高端的，居然可以反问，但是当面试官说是堆排序的时候我就傻眼了，

不会，只记得个大概，于是今天花了点时候把堆排序搞懂了！！

详解如下：

对于一个数组：

int a[] = { 0, 4, 1, 3, 2, 16, 9, 10, 14, 8, 7 };

他可以用来表示堆，堆是一颗完全二叉树，分大值堆和小值堆，最后得出的分别是从大到小的排列顺序和从小到达的排列顺序，看你要排序的顺序觉定大小堆！

0(1)

4 (2) 1(3)

3(4) 2(5) 16(6) 9(7)

10(8) 14(9) 8(10) 7(11)

存在一个如上图的关系，

left[i] = 2* i ;

right[i] = 2+i +1;

知道这个关系后，我们就可以开始建堆了：

从 a.length/2 到第一个元素 开始对每个元素进行建堆（递归），使每个元素下的树都维持最小值堆的特性；

a.length/2+1 到 a.length 个元素都是叶子节点，所以不需要维持最小值堆操作，因为已经是最小值堆了！！

代码如下：

public static void max_heapify(int[] a, int i) {

int left = leftChild(i);

int right = rightChild(i);

int largest = 0;

if (left < heap_size && a[i] < a[left]) {

largest = left;

} else {

largest = i;

}

if (right < heap_size && a[right] > a[largest]) {

largest = right;

}

if (largest == i) {

return;

} else {

int temp = a[i];

a[i] = a[largest];

a[largest] = temp;

max_heapify(a, largest);

}

}

上一步骤理解了，那么之后的操作就很简单了。

建好最小值堆后，每次取堆顶元素和数组最后一个元素（最后第n个元素，n为交换次数）交换，剩下的元素采用维持堆性质的操作，

循环至最后堆只剩下一个元素即可，代码如下：

public static void heapSort(int[] a) {

build_max_heap(a);

for (int i = a.length - 1; i >= 2; i--) {

int temp = a[1];

a[1] = a[i];

a[i] = temp;

heap_size--;

max_heapify(a, 1);

}

}

时间复杂度为O(N*logN)。

至此，堆排序讲解完毕！希望大家可以明白堆排序的原理了！

附上完整可运行代码：

package ddl.com;

public class HeapSort {

public static int heap_size;

// 双亲编号

public static int parent(int i) {

return i / 2;

}

// 左孩子编号

public static int leftChild(int i) {

return 2 * i;

}

// 右孩子编号

public static int rightChild(int i) {

return 2 * i + 1;

}

/**

* 堆排序：首先使用建立最大堆的算法建立好最大堆，然后将堆顶元素（最大值）与最后一个值交换，同时使得堆的长度减小1

* ，调用保持最大堆性质的算法调整，使得堆顶元素成为最大值，此时最后一个元素已被排除在外、

*/

public static void heapSort(int[] a) {

build_max_heap(a);

for (int i = a.length - 1; i >= 2; i--) {

int temp = a[1];

a[1] = a[i];

a[i] = temp;

heap_size--;

max_heapify(a, 1);

}

}

/**

* 建立最大堆。在数据中，a.length/2+1一直到最后的元素都是叶子元素，也就是平凡最大堆，因此从其前一个元素开始，一直到

* 第一个元素，重复调用max_heapify函数，使其保持最大堆的性质

*

* @param a

*/

public static void build_max_heap(int[] a) {

for (int i = a.length / 2; i >= 1; i--) {

max_heapify(a, i);

}

}

/**

* 保持最大堆的性质

*

* @param a

* ，堆中的数组元素

* @param i

* ，对以该元素为根元素的堆进行调整，假设前提：左右子树都是最大堆

*

* 由于左右孩子都是最大堆，首先比较根元素与左右孩子，找出最大值，假如不是根元素，则调整两个元素的值；

* 由于左孩子（右孩子）的值与根元素交换，有可能打破左子树（右子树）的最大堆性质，因此继续调用，直至叶子元素。

*/

public static void max_heapify(int[] a, int i) {

int left = leftChild(i);

int right = rightChild(i);

int largest = 0;

if (left < heap_size && a[i] < a[left]) {

largest = left;

} else {

largest = i;

}

if (right < heap_size && a[right] > a[largest]) {

largest = right;

}

if (largest == i) {

return;

} else {

int temp = a[i];

a[i] = a[largest];

a[largest] = temp;

max_heapify(a, largest);

}

}

public static void main(String[] args) {

int a[] = { 0, 4, 1, 3, 2, 16, 9, 10, 14, 8, 7 };

heap_size = a.length;

heapSort(a);

for (int i = 0; i < a.length; i++) {

System.out.print(a[i] + " ");

}

}

}