java堆排序

堆排序（Heapsort）是指利用堆这种数据结构所设计的一种排序算法。堆积是一个近似完全二叉树的结构，并同时满足堆积的性质：即子结点的键值或索引总是小于（或者大于）它的父节点。

堆排序的过程描述如下：

1. 将初始待排序关键字序列(R1,R2….Rn)构建成大顶堆，此堆为初始的无序区；
2. 将堆顶元素R[1]与最后一个元素R[n]交换，此时得到新的无序区(R1,R2,……Rn-1)和新的有序区(Rn),且满足R[1,2…n-1]<=R[n]；
3. 由于交换后新的堆顶R[1]可能违反堆的性质，因此需要对当前无序区(R1,R2,……Rn-1)调整为新堆，然后再次将R[1]与无序区最后一个元素交换，得到新的无序区(R1,R2….Rn-2)和新的有序区(Rn-1,Rn)。不断重复此过程直到有序区的元素个数为n-1，则整个排序过程完成。

下面用几幅图来表示上述的排序过程：

1、将数组构造成初始堆（若想升序则建立大根堆，若想降序，则建立小根堆），从最后一个节点开始调整，得到初始堆。

2、交换堆顶的元素和最后一个元素，此时最后一个位置作为有序区（有序区显示为黄色），然后进行其他无序区的堆调整，重新得到大顶堆后，交换堆顶和倒数第二个元素的位置……

3、最后，有序扩展完成即排序完成：

有了上述的图形展示，我们可以分解一下编写代码的思路，

1、第一步，构建大（小）顶堆；
2、调整大顶堆
3、调用大顶堆的排序

整个思路连接起来就是，不断的调整大顶堆，每调整完毕一次，就将最大的元素放到有序区的数组中，然后对剩下的元素进行构建大顶堆的排序操作，依次进行，直到最后只剩下一个元素…

代码如下：

package com.congge.sort.heap;

import java.util.Arrays;

import com.congge.sort.SwapUtils;

/**
 * 堆排序
 * @author asus
 *
 */
public class HeapSort {
	
	static int len;
	public static void main(String[] args) {
		int[] arr = {11,48,15,7,99,45,108,23};
		System.out.println(Arrays.toString(heapSort(arr)));
	}
	
	public static int[] heapSort(int[] arr){
		len = arr.length;
		//1.构建大顶堆。（这个构建大顶堆中有调整的递归方法）
		buildMaxHeap(arr);
		//2. 将顶部的元素，与无序区的最后一个元素交换位置。
		while(len >0){
			SwapUtils.swap(arr, 0, len-1);	// 0表示大顶元素，len-1表示最后一个元素
			len--;// 无序区 的长度减少一位
			changeHeap(arr, 0);//继续调整
		}
		return arr;
	}
	
	/**
	 * 初始化构建一个大顶堆
	 * @param arr
	 */
	public static void buildMaxHeap(int[] arr){
		for (int i =(len/2) ; i >=0; i--) {
			// 不断调整大顶堆
			changeHeap(arr,i);
		}
	}
	
	/**
	 * 调整大顶堆
	 * @param arr
	 * @param i
	 */
	private static void changeHeap(int[] arr, int i) {
		int maxindex = i;
		//如果有左子树。且左子树大于父节点，则将最大指针指向左子树
		if (i*2<len && arr[i*2]> arr[maxindex]) {
			maxindex = i*2;
		}
		//如果有右子树。且右子树大于父节点，则将最大指针指向左子树
		if (i*2+1<len && arr[i*2+1]> arr[maxindex]) {
			maxindex = i*2+1;
		}
		//如果父节点不是最大值，则将父节点与最大值交换，这样才能保证我们的父节点是最大的，构建成为一个大顶堆。
		if (maxindex != i) {
			SwapUtils.swap(arr, maxindex, i);
			changeHeap(arr, maxindex);
		}
		
	}
}

运行一下这段程序，可以看到，对无序数组进行了排序，

堆排序的性能大致如下，大家可以稍作验证，
1、最佳情况：T(n) = O(nlogn)
2、最差情况：T(n) = O(nlogn)
3、平均情况：T(n) = O(nlogn)