常用排序算法之堆排序

堆，这里指的是二叉堆，即完全二叉树结构。分为最大堆和最小堆。最大堆中，任何节点都比其子节点要大；最小堆中，任何节点都比其子节点要小。

堆排序，是一种二叉树选择排序。通过不断地将二叉树调整成最大堆，取出根节点（最大值）放入二叉树的末节点，实现数组的升序排列。

步骤：

1. 将初始数组构建成最大堆；
2. 交换A[0]和A[n-1]的值；
3. 将剩余A[0]和A[n-2]构成的完全二叉树构建成最大堆；
4. 交换A[0]和A[n-2]的值；
5. 将剩余A[0]和A[n-3]构成的完全二叉树构建成最大堆；
6. 交换A[0]和A[n-3]的值；
7. ……
8. 重复以上操作直到A[0]为最小值。    

     代码实现：

public class HeapSort {

public static void main(String[] args) {

int[] arr={7,6,4,9,0,5,2,8,3,1};

        heapSort(arr);

}

public static void heapSort(int[] arr){

if(arr==null||arr.length<=1){

return;

}

buildMaxHeap(arr);

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

ArrayUtils.exchangeElements(arr, 0, i);

maxHeap(arr,i,0);

ArrayUtils.printArray(arr);

}

}

public static void buildMaxHeap(int[] arr){

if(arr==null||arr.length<=1){

return;

}

int half=arr.length/2-1;

for(int i=half;i>=0;i--){

maxHeap(arr,arr.length,i);

}

}

public static void maxHeap(int[] arr,int heapSize,int index){

int left=index*2+1;

int right=index*2+2;

int largest=index;

if(leftarr[largest]){

largest=left;

}

if(rightarr[largest]){

largest=right;

}

if(largest!=index){

ArrayUtils.exchangeElements(arr, index, largest);

maxHeap(arr,heapSize,largest);

}

}

}

class ArrayUtils{

public static void printArray(int[] arr){

for(int element:arr){

System.out.print(element+" ");

}

System.out.println();

}

public static void exchangeElements(int[] arr,int index1,int index2){

int temp;

temp=arr[index1];

arr[index1]=arr[index2];

arr[index2]=temp;

}

}

过程展示：

8 7 5 6 1 4 2 0 3 9 

7 6 5 3 1 4 2 0 8 9 

6 3 5 0 1 4 2 7 8 9 

5 3 4 0 1 2 6 7 8 9 

4 3 2 0 1 5 6 7 8 9 

3 1 2 0 4 5 6 7 8 9 

2 1 0 3 4 5 6 7 8 9 

1 0 2 3 4 5 6 7 8 9 

0 1 2 3 4 5 6 7 8 9