堆结构与堆排序

一、堆的定义

堆其实就是一颗完全二叉树。

先说满二叉树，满二叉树就是除了最后一层结点没有孩子，其余的的节点都有左孩子和右孩子。

完全二叉树包含满二叉树，也就是说完全二叉树是每个子树的孩子是从左往右补齐的。一颗满二叉树同时也是一颗完全二叉树。

这张图片中，第三个树的孩子不是从左向右补齐的，如果变成这样，就是一颗完全二叉树。

二、堆的分类

堆分为大根堆和小根堆。

大根堆：一颗完全二叉树的每颗子树的最大值就是它的头部。

小根堆：一颗完全二叉树的每颗子树的最小值就是它的头部。

三、如何用数组模拟堆结构

我们可以使用数组模拟堆结构，数组中下标为 i 的数，它的左孩子下标为 2 * i + 1，右孩子下标为 2 * i + 2，父节点下标 ( i - 1 ) / 2。（在不越界的情况下），这样数组就可以被看做一颗完全二叉树。

四、怎么将数组（堆）调成大根堆

总结起来就是：每新增一个结点，判断是否大于它的头部

（1）大于，交换两个结点。来到新位置后，继续和它的父结点比较

（2）小于等于，位置不变，继续增加新的结点。

五、堆排序

（一）、堆排序的实现理论

1. 有一个数组，长度为 n。
2. 用这 n 个结点，形成一个大根堆。
3. 大根堆的顶部与大根堆的最后一个数作交换，将堆的结点数减 1。获得最大值。
4. 继续用剩下的结点形成一个大根堆。
5. 继续 3 、 4 步骤 ，直到堆内没有结点。

（二）、堆排序的代码实现

import java.util.Arrays;

public class HeapSort {
	public static void heapSort(int[] arr) {
		if (arr==null || arr.length < 2)
			return;

		for (int i = 0; i < arr.length; i++) {			// 将数组变成大根堆
			heapInsert(arr, i);
		}

		int size = arr.length;
		while (size > 0) {
			heapify(arr, 0, size);					// 结点值发生变换，重新生成大根堆
			swap(arr, 0, --size);							// 交换头部和最后一个数，堆结点数量减 1
		}


	}

	// 数组调整为大根堆
	public static void heapInsert(int[] arr, int index) {
		// 当前结点值大于它的父结点值，交换位置，继续在新的位置和父结点比较
		while (arr[index] > arr[(index-1) / 2]) {
			swap(arr, index, (index-1) / 2);
			index = (index - 1) / 2;
		}
	}

	// 结点值发生变换，重新生成大根堆
	public static void heapify(int[] arr, int index, int heapSize) {
		int left = 2 * index + 1;						// 左孩子下标
		while (left < heapSize) {
			// 判断左孩子和右孩子谁最大
			int largset = left + 1 < heapSize && arr[left + 1] > arr[left] ? left + 1 : left;
			// 两个孩子中的最大值和当前位置比较
			largset = arr[largset] > arr[index] ? largset : index;
			// 如果最大值就是自己，不需要进行调整
			if (largset == index) {
				break;
			}
			// 最大值不是自己，交换位置
			swap(arr, largset, index);
			// 交换后，需要继续与父结点进行比较，直到形成大根堆为止
			index = largset;
			// 更新左孩子的下标
			left = 2 * index + 1;
		}

	}

	// 交换两个数的位置
	public static void swap(int[] arr, int i, int j) {
		int temp = arr[i];
		arr[i] = arr[j];
		arr[j] = temp;
	}
	
	public static void main(String[] args) {
		int[] a = {1, 2 ,4, 5, 4, 10, 2};
		System.out.println(Arrays.toString(a));
		heapSort(a);
		System.out.println(Arrays.toString(a));
	}
}

（三）、堆排序的时间复杂度

堆排序的时间复杂度为 O(N*logN)