堆排序算法一（算法分析与实现）

说明：该算法为堆排序算法，待排序的数据从第二位置开始存放，第一个位置不用。

算法思路：该算法依赖于堆调整这样一个基本过程，一般来说排序过程分为如下两步：

1 建立大顶堆。

2 根据堆来进行排序。

具体如下程序（程序说明部分对算法进行了详细分析）：

package com.sharpandroid.junitTest;

import java.util.Random;

import org.junit.Test;

/**

 * 说明：该算法为堆排序算法，从第二个位置也就是索引为1的位置开始存储排序的数据(第1位置不用)，该算

 * 法依赖于如下堆调整的基本过程：

 * maxHeapIfY(array, i)，该过程以i结点为当前堆调整的树根（该过程假设以i为根的子树已经为最

 * 大堆），目的是把i结点加入到堆中，使堆成为以i为根结点的大顶堆。

 * 堆排序算法依赖于数据结构“堆”，所以在排序之前首先是建立一个堆，所以一般来说堆排序算法的大致过程如

 * 下：

 * 1 建立堆的过程buildMaxHeap：该过程从i = heapSize/2处开始向树根调整，直到i = 1，此

 * 时该堆是以结点i为根的一个大顶堆。

 * 2 堆排序过程heapSort：由大顶堆的性质可知，i = 1处的结点是该前堆中的最大值，所以该过程不断地

 * Exchange(array, i, 1),然后调用基本过程maxHeapIfY(array, 1)不断的以i = 1为根

 * 结点进行大顶堆调整以保持大顶堆的性质，该过程一直到i=2的结点处(此时i = 1的结点与i = 2处的结点

 * 进行最后一次交换及堆调整)。

 * @author xuecheng

 *

 */

public class Sort_HeapSort {
private int [] arrayA = null;
private int heapSize = -1;
private int length = 1000 + 1;//1000个数字，第一个位置不用
@Test
public void insertSort() {
//fail("Not yet implemented");
getData();
printArray(arrayA);
System.out.println("heap sort begin");
long now = System.nanoTime();
doSort(arrayA);
long last = System.nanoTime() - now;
System.out.println("heap sort end, duration = " + last);
printArray(arrayA);
}
private void getData() {
arrayA = new int[length];
Random random = new Random(System.currentTimeMillis());
for (int i = 0; i < length; i++) {
arrayA[i] = random.nextInt(1000) + 1;
} 
}

private void doSort(int array[]) {
heapSort(array);
}

private void heapSort(int array[]) {
buildMaxHeap(array);

for (int i = this.heapSize; i >= 2; i--) {
exchangeValue(array, 1, i);
this.heapSize = this.heapSize - 1;
maxHeapIfY(array, 1);
}
}

private void buildMaxHeap(int array[]) {
this.heapSize = array.length - 1;//由于第一个位置不存储数据，所以这里减了一
for (int i = this.heapSize / 2; i >=1; i--) {
maxHeapIfY(array, i);
}
}

private void maxHeapIfY(int array[], int i) {
int l = this.left(i);
int r = this.right(i);
int largest = -1;
if ((l <= this.heapSize) && (array[i] < array[l])) {
largest = l;
} else {
largest = i;
}

if (r <= this.heapSize && (array[largest] < array[r])) {
largest = r;
}

if (largest != i) {
exchangeValue(array, i, largest);
maxHeapIfY(array, largest);
}
}

private void exchangeValue(int array[], int indexA, int indexB) {
int temp = array[indexB];
array[indexB] = array[indexA];
array[indexA] = temp;
}
private int left(int i) {
return 2 * i;
}

private int right(int i) {
return 2 * i + 1;
}
private int parent(int i) {
return i / 2;
}
private void printArray(int array[]) {
for (int i = 1; i < array.length; i++) {
System.out.print("i = " + i + ", value = " + array[i] + "\n");
}
}

}