排序之堆排序

public class HeapSort {
public static void main(String[] args) {
CreateNoOrderArray createNoOrderArray = new CreateNoOrderArray();
int[] array = createNoOrderArray.creat();
System.out.println("Before heap:");
System.out.println(Arrays.toString(array));
heapSort(array);
System.out.println("After heap sort:");
System.out.println(Arrays.toString(array));
}

/**
* 堆排序
* @param array
*/
private static void heapSort(int[] array) {
if (array == null || array.length <= 1) {
return;
}
buildMaxHeap(array);
for (int i = array.length - 1; i >= 1; i--) {
swap(array, 0, i); //每次把最大的换到最后
heapify(array, i, 0); //重新把次大的调整到根节点
}
}

/**
* 构造最大堆
* @param array
*/
private static void buildMaxHeap(int[] array) {
if (array == null || array.length <= 1) {
return;
}
int half = array.length / 2;
for (int i = half; i >= 0; i--) { //从最后一个节点的父节点开始调整，使根节点是最大的
heapify(array, array.length, i);
}
}

/**
* 从index向下调整
* @param array
* @param heapSize
* @param index
*/
private static void heapify(int[] array, int heapSize, int index) {
int left = index * 2 + 1;
int right = index * 2 + 2;
int largest = index;
while(left < heapSize){
if (array[left] > array[index]) {
largest = left;
}

if (right < heapSize && array[right] > array[largest]) {
largest = right;
}

if (index != largest) {
swap(array, index, largest);
}else {
break;
}
index = largest;
left = index * 2 + 1;
right = index * 2 + 2;
}

}
private static void swap(int[] array, int i, int j) {
int temp = array[i];
array[i] = array[j];
array[j] = temp;
}
}