算法与数据结构 - 堆

堆、二叉堆、最大堆、最小堆
二叉堆是一个完全二叉树，且二叉堆中的所有父总是>=（或<=）子。

一般将二叉堆就简称为堆。

父总大于或等于子的堆叫最大堆，父总小于或等于子的堆叫最小堆。

堆和数组

一般用数组来表示堆。

i的父是(i – 1) / 2，左儿子是2 * i + 1，右儿子是2 * i + 2。

堆化数组

现有数组 array = {9, 12, 17, 30, 50, 20, 60, 65, 4, 49};

其对应的堆的数据结构：

但它还不是一个堆，因为它不满足最大堆或最小堆的性质。我们需要每个结点对应的值。

注意，叶子结点必然是一个合法的堆：20，60， 65， 4， 49。

所以，堆的调整，只要从array.length/2开始即可。

堆排序

堆排序与快速排序、归并排序一样都是时间复杂度为O(N*logN)的排序方法。

堆排序的思路

1、构建最大堆

2、将堆顶元素与最后一个元素交换，即将最大的元素放在最后，然后将最后一个元素剔除出堆。

3、步骤2的交换破环了最大堆的性质，需要使用沉降法来调整堆。

4、堆顶元素与倒数第二个元素交换 - 将倒数第二个元素剔除出堆 - 调整堆

......

public class HeapSort {

    public void heapSort(int[] array) {
	// 特殊情况判断
	if (array == null || array.length <= 1)
	    return;
	buildMaxHeap(array);
	for (int i = array.length - 1; i >= 1; i--) { // 易错：i>=0
	    swap(array, 0, i);
	    maxHeap(array, i, 0); // 易错:i+1
	}
    }

    public void buildMaxHeap(int[] array) {
        // 特殊情况判断
        if (array == null || array.length <= 1)
	    return;
	// 从第一个非叶子结点开始调整数组
	int half = array.length / 2;
	for (int i = half; i >= 0; i--) {
	    maxHeap(array, array.length, i);
	}
    }

    public void maxHeap(int[] array, int heapSize, int index) {
	// 确定左右孩子的下标
	int left = 2 * index + 1;
	int right = 2 * index + 2;
	// 记录父和儿子中的最大者
	int largest = index;
	// 左孩子在堆的调整范围内且左孩子目前最大
	if (left < heapSize && array[left] > array[largest])
    	    largest = left;
	// 右孩子在堆的调整范围内且右孩子目前最大
	if (right < heapSize && array[right] > array[largest])
	    largest = right;
	// 父不是最大的值时交换父与最大子的值 - 在最大子的位置上需要继续向下调整
	if (largest != index) {
	    swap(array, index, largest);
	    maxHeap(array, heapSize, largest);
	}
    }

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

    public static void main(String[] args) {
	int[] arrays = new int[] { 1, 9, 2, 8, 3, 7, 4, 6, 5 };
	new HeapSort().heapSort(arrays);
	for (int i = 0; i < arrays.length; i++)
   	    System.out.print(arrays[i] + " ");
    }

}