Java数据结构与算法———（59）堆排序

堆排序的时间复杂度为O(nlogn)。

一、代码

package tree;

import java.util.Arrays;
/**
 * 堆排序
 * 1. 将待排序序列构造成一个大顶堆（从左向右，从下往上）。此时，整个序列的最大值就是堆顶的根节点。
 * 2. 将其与末尾元素进行交换，此时末尾就为最大值。
 * 3. 然后将剩余n-1个元素重新构造成一个堆（从左向右，从下往上），这样会得到n个元素的次小值。如此反复执行，便能得到一个有序序列了。
 * @author Lee
 *
 */
public class HeapSort {
	/**
	 * 思路
	 * 1. 构造初始堆。将给定无序序列构造成一个大顶堆（一般升序采用大顶堆，降序采用小顶堆)。
	 * 2. 将堆顶元素与末尾元素进行交换，使末尾元素最大。
	 * 3. 然后继续调整堆（从左向右，从下往上），再将堆顶元素与末尾元素交换，得到第二大元素。如此反复进行交换、重建、交换。
	 * @param args
	 */
	
	//思路
	// 1. 将无需序列构建成一个堆，根据升序降序需求选择大顶堆或小顶堆。
	// 2. 将堆顶元素与末尾元素交换，将最大元素"沉"到数组末端。
	// 3. 重新调整结构，使其满足大顶堆堆定义，然后继续交换堆顶元素与当前末尾元素，反复执行调整+交换步骤，直到整个序列有序。
	
	public static void main(String[] args) {
		// 要求将数组进行升序排序，所以采用大顶堆
		int[] arr = {4, 6, 8, 5, 9, 10, -2, 9, 25, 62};
		System.out.println("堆排序前：" + Arrays.toString(arr));
		heapSort(arr);
		System.out.println("堆排序后：" + Arrays.toString(arr));
	}
	
	//方法：堆排序
	public static void heapSort(int[] arr) {
		System.out.println("--------------------开始堆排序堆排序--------------------");
		
		/*
		//分次完成
		//调整最后一个非叶子结点
		adjustHeap(arr, 1, arr.length);
		System.out.println("调整最后一个非叶子结点" + Arrays.toString(arr));
		//调整倒数第二个非叶子结点
		adjustHeap(arr, 0, arr.length);
		System.out.println("调整倒数第二个非叶子结点" + Arrays.toString(arr));
		//只有当上面的两个步骤完成后，才构建了初始堆
		*/
		
		
		// 1. 构造初始堆。将无序序列构建成一个堆，根据升序降序需求选择大顶堆或小顶堆。
		/*
		 * 注意：
		 * 1. 首次构建大顶堆时，是从整个无序序列的最后一个非叶子节点（arr.length / 2 - 1）开始的，然后从左至右，从下往上调整
		 * 2. 只有 for 循环完成后，才意味着完成了一次构建大顶堆的工作，此时 arr[0]是最大值
		 */
		for(int i = arr.length / 2 - 1; i >= 0; i--) {
			adjustHeap(arr, i, arr.length);
		}
		
		// 2. 将堆顶元素 arr[0] 与末尾元素 arr[arr.length - 1] 交换，将最大元素"沉"到数组末端  + 重新调整结构，使其满足大顶堆堆定义
		//    注意：j 是传入的数组的最后一个元素的下标
		for(int j = arr.length - 1; j > 0; j--) {
			// 1. 交换
			// 注意：将无序序列构建成一个堆后，arr[0]存放的就是这个序列中的最大值
			int temp = arr[j];
			arr[j] = arr[0];
			arr[0] = temp;
			
			//2. 重新调整
			//   注意：构造初始堆完成之后的每次重新调整的 i 都是从0开始的，因为i标识需要构造成大顶堆的树的根结点
			adjustHeap(arr, 0, j);
		}
	}
	
	//方法：将一个无序数组调整成大顶堆
	/**
	 * 功能：完成将以 i 对应的非叶子结点的树，调整成大顶堆。i 是这棵树的根结点对应的数组下标
	 * 举例：int[] arr = {4, 6, 8, 5, 9} => i = 1 => adjustHeap(arr, i, arr.length) => arr = {4, 9, 8, 5, 6}
	 *      如果再次调用 adjustHeap，传入的是 i = 0 => ，arr = {4, 9, 8, 5, 6} => arr = {9, 6, 8, 5, 4}（大顶堆）
	 * @param arr 待调整的数组
	 * @param i 非叶子结点在数组中索引（下标）
	 * @param length 待调整数组的长度，即对多少个数组元素进行调整，length是在逐渐减少的
	 */
	public static void adjustHeap(int[] arr, int i, int length) {
		
		int temp = arr[i];//先取出当前元素的值，保存在临时变量temp中
		
		// 开始调整
		// 说明
		// 1. for循环的作用：找到传入的数组中的最大值，并将其放在合适的位置
		// 2. 在调整时，是先找 i 对应结点的左子节点 k，即 k = i * 2 + 1
		// 3. 下一次调整时，是找到 i 对应结点的左子节点的左子节点，即 k = k * 2 + 1
		// 4. 在 for 循环内部已经考虑了右子节点，所以每次循环都是从左子结点开始，然后在循环体中处理右子节点
		// 5. 当整个 for 循环结束时，说明以 i 为父节点的子树中，i 结点的值已经是最大了（局部）
		for(int k = i * 2 + 1; k < length; k = k * 2 + 1) {
			//开始判断
			// 1. 判断 i 结点的左右子节点中的最大值
			// 2. 在判断时，由于i结点的左右子节点是以数组的形式出现，所以要先保证数组下标最大的那个是否越界，即arr[k + 1] < length 
			// 3. 如果左子节点的值小于右子结点的值，就让k指向右子结点
			if(k + 1 < length && arr[k] < arr[k + 1]) {//如果左子节点的值小于右子结点的值，就让k指向右子结点
				k++;//让k指向右子结点
			}
			if(arr[k] > temp) {// 如果子节点大于父节点，将子节点值赋给父节点（不用进行交换）
				arr[i] = arr[k];//将子节点值赋给父节点（不用进行交换）
				i = k;//让 i 指向K，继续循环比较
			}else {//如果 arr[k] <= temp，即当前节点 i 的值（temp）已经是最大的了 
				break;//由于调整顺序是从左至右，从下往上，所以此时不用再考虑左子节点的左子节点
			}
		}
		// 当整个 for 循环结束时，说明以 i 为根节点的子树中，i 结点的值已经是最大了（局部）
		// 由于 for 循环结束后，i 已经指向了 k，所以要将刚开始时的arr[i]的值（用temp保存）赋值给arr[i]，这时才完成了最大元素和末尾元素的交换
		arr[i] = temp;//将 temp 的值放到调整后的位置
	}

}

二、结果

堆排序前：[4, 6, 8, 5, 9, 10, -2, 9, 25, 62]
--------------------开始堆排序堆排序--------------------
堆排序后：[-2, 4, 5, 6, 8, 9, 9, 10, 25, 62]