1、介绍
堆排序（Heapsort）是指利用堆这种数据结构所设计的一种排序算法。堆结构，在前面有单独的介绍过，可以进去了解一下。这种排序方法的时间复杂度非常稳定，是 ，并且它还是原地排序。
2、分析
堆排序的过程，大致分解成两个大的步骤，建堆和排序。
- 先让整个数组都变成大根堆结构，建立堆的过程，有两种方法:
- 从上到下的方法，时间复杂度为
- 从下到上的方法，时间复杂度为
- 把堆的最大值和堆末尾的值交换，然后减少堆的大小之后，再去调整堆，一直周而复始，时间复杂度为
- 堆的大小减小成0之后，排序完成
3、实现
import java.util.Arrays;
/**
* @description: 堆排序
* @author: erlang
* @since: 2020-09-12 00:18
*/
public class HeapSort {
public static void heapSort(int[] arr) {
if (arr == null || arr.length < 2) {
return;
}
// 建堆
for (int i = arr.length - 1; i >= 0; i--) {
heapify(arr, i, arr.length);
}
int heapSize = arr.length;
// 排序
ArraySortUtils.swap(arr, 0, --heapSize);
while (heapSize > 0) {
heapify(arr, 0, heapSize);
ArraySortUtils.swap(arr, 0, --heapSize);
}
}
public void heapSort2(int[] arr) {
if (arr == null || arr.length < 2) {
return;
}
// 建堆
for (int i = 0; i < arr.length; i++) {
heapInsert(arr, i);
}
int heapSize = arr.length;
// 排序
ArraySortUtils.swap(arr, 0, --heapSize);
while (heapSize > 0) {
heapify(arr, 0, heapSize);
ArraySortUtils.swap(arr, 0, --heapSize);
}
}
/**
* 从下往上
*
* @param arr
* @param index
*/
public void heapInsert(int[] arr, int index) {
while (arr[index] > arr[parentIndex(index)]) {
int parent = parentIndex(index);
ArraySortUtils.swap(arr, index, parent);
index = parent;
}
}
/**
* 从上往下堆化
*
* @param arr
* @param index
* @param heapSize
*/
public static void heapify(int[] arr, int index, int heapSize) {
int left = leftIndex(index);
while (left < heapSize) {
int right = rightIndex(index);
int largest = right < heapSize && arr[right] > arr[left] ? right : left;
largest = arr[largest] > arr[index] ? largest : index;
if (index == largest) {
break;
}
ArraySortUtils.swap(arr, largest, index);
index = largest;
left = leftIndex(index);
}
}
public static int leftIndex(int index) {
return index * 2 + 1;
}
public static int rightIndex(int index) {
return index * 2 + 2;
}
public static int parentIndex(int index) {
return (index - 1) / 2;
}
public static void main(String[] args) {
ArraySortUtils.testSort(HeapSort::heapSort, 100, 100);
}
}
4、工具类
ArraySortUtils
import java.util.Arrays;
import java.util.function.Consumer;
/**
* @description: 数组排序工具
* @author: erlang
* @since: 2020-08-29 10:49
*/
public class ArraySortUtils {
public static void swap(int[] arr, int i, int j) {
int temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
/**
* 随机生成待测试的数组
*
* @param maxSize 数组最大长度
* @param maxValue 数组中最大的值
* @return 返回生成的数组
*/
public static int[] generateRandomArray(int maxSize, int maxValue) {
int[] arr = new int[(int) ((maxSize + 1) * Math.random())];
for (int i = 0; i < arr.length; i++) {
arr[i] = (int) ((maxValue + 1) * Math.random()) - (int) (maxValue * Math.random());
}
return arr;
}
/**
* 输出数组的元素
*
* @param arr 数组
*/
public static void printArray(int[] arr) {
System.out.println("");
System.out.println("+++++++++++++++++++++++++++++++++++++++++++++++++++START");
for (int value : arr) {
System.out.print(value + " ");
}
System.out.println("");
System.out.println("+++++++++++++++++++++++++++++++++++++++++++++++++++END");
}
public static void comparator(int[] arr) {
Arrays.sort(arr);
}
/**
* 重新复制一个新数组
*
* @param arr 待复制的数组
* @return 返回复制的新数组
*/
public static int[] copyArray(int[] arr) {
if (arr == null) {
return null;
}
int[] res = new int[arr.length];
System.arraycopy(arr, 0, res, 0, arr.length);
return res;
}
/**
* 比较两个数组的元素是否相等
*
* @param arr1 待比较的数组 1
* @param arr2 待比较的数组 2
* @return 返回校验结果 true/false
*/
public static boolean isEqual(int[] arr1, int[] arr2) {
if (arr1 == null && arr2 == null) {
return true;
}
if (arr1 == null || arr2 == null) {
return false;
}
if (arr1.length != arr2.length) {
return false;
}
for (int i = 0; i < arr1.length; i++) {
if (arr1[i] != arr2[i]) {
return false;
}
}
return true;
}
/**
* 测试排序方法的排序结果是否正确
*
* @param consumer 回调用户自定义的排序方法
* @param maxSize 数组最大长度
* @param maxValue 数组中最大的数，即 0 - maxValue
*/
public static void testSort(Consumer<int[]> consumer, int maxSize, int maxValue) {
int testTime = 5000;
boolean succeed = true;
for (int i = 0; i < testTime; i++) {
// 生成新数组
int[] arr1 = ArraySortUtils.generateRandomArray(maxSize, maxValue);
// 复制新数组
int[] arr2 = copyArray(arr1);
// 回调用户自定义的排序方法，对 arri1 排序
consumer.accept(arr1);
// 使用系统自带的排序方法，对 arr2 排序
comparator(arr2);
// 比较两种处理结果是否一致
if (!isEqual(arr1, arr2)) {
succeed = false;
printArray(arr1);
printArray(arr2);
break;
}
}
// 输出测试结果
System.out.println(succeed ? "Nice!" : "Fail!");
}
}
