排序算法：堆排序

1. 基本介绍

• 堆排序是利用堆这种数据结构而设计的一种排序算法，堆排序是一种选择排序，它的最坏，最好，平均时间复杂度均为O(nlogn)，它也是不稳定排序。
• 堆是具有以下性质的完全二叉树：每个节点的值都大于或等于其左右孩子节点的值，称为大顶堆，但不要求节点的左孩子的值和右孩子的值的大小关系。
• 每个节点的值都小于或等于其左右孩子节点的值，称为小顶堆。

2. 大顶堆举例

• 我们对堆中的结点按层进行编号，映射到数组中就是下面这个样子:

• 大顶堆特点：arr[i] >= arr[2*i+1] && arr[i] >= arr[2*i+2] // i 对应节点的序号，i从0开始编号
• 如果 i 是最后一个非叶子节点，说明数组长度 length=2*i+2，则 i=length/2-1，这个值在后面堆排序中会用到

3. 小顶堆举例

• 小顶堆：arr[i] <= arr[2*i+1] && arr[i] <= arr[2*i+2] // i 对应节点序号，i从0开始编号

4. 堆排序基本思想

• 一般升序采用大顶堆，降序采用小顶堆

1. 将待排序序列构造成一个大顶堆
2. 此时，整个序列的最大值就是堆顶的根节点。
3. 将其与末尾元素进行交换，此时末尾就为最大值。
4. 然后将剩余 n-1个元素重新构造成一个堆，这样会得到n个元素的次小值。如此反复执行，便能得到一个有序序列了。

• 可以看到在构建大顶堆的过程中，元素的个数逐渐减少，最后就得到一个有序序列了

5. 图解说明

• 数组 {4,6,8,5,9} , 要求使用堆排序法，将数组升序排序，对应的堆结构如下

5.1 步骤一

• 叶子节点不用调整，从第一个非叶子节点调整，arr.length/2-1=5/2-1=1，也就是数值为6的节点，从左往右，从下往上进行调整

• 找到第2个非叶子节点4，由于[4,9,8]中9最大，4和9交换

• 这时子树[4,5,6]结构混乱，继续调整，4和6交换

• 此时得到一个大顶

5.2 步骤二

• 将堆的首尾元素进行交换，末端元素变为最大。然后继续调整结构，再将堆的首尾元素交换，得到第2大元素。如此反复此过程，交换、重建、交换，最终使整个序列有序。
• 9和4交换

• 重新调整，变成大顶堆

• 8和5交换，得到第2大元素

• 重复上面的过程，最终使得整个序列有序

6. 代码实现

import java.util.Arrays;

public class HeapSort {


    public static void main(String[] args) {
        int[] arr = {4, 6, 8, 5, 9};
        System.out.println(Arrays.toString(arr));
        heapSort(arr);
        System.out.println(Arrays.toString(arr));
    }

    // 堆排序
    public static void heapSort(int[] arr) {
        int temp = 0;
        System.out.println("堆排序开始~~~");
        // 1.从最后一个叶子节点开始向上遍历各个节点，来构建大顶堆
        for (int i = arr.length / 2 - 1; i >= 0; i--) {
            adjustHeap(arr, i, arr.length);
        }
        // 2.将堆顶元素与末尾元素交换，将最大元素下换到数组末端
        // 3.从0位置开始，重新调整结构，并且每次调整的元素个数-1，再次变为大顶堆
        // 反复进行2和3，即变大顶堆+首尾元素交换的过程，直到整个数组有序
        for (int i = arr.length - 1; i > 0; i--) {
            //交换
            temp = arr[i];
            arr[i] = arr[0];
            arr[0] = temp;
            adjustHeap(arr, 0, i);
        }
    }

    /**
     * 将以 i 对应的非叶子节点的树调整成大顶堆，将大的值向上移动，小的值向下移动
     * {4, 6, 8, 5, 9}
     * i=1第一遍调整后为{4, 9, 8, 5, 6}
     * i=0第二遍调整后为{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];
        // 将i节点与i节点的左子节点和右子节点进行比较
        for (int k = i * 2 + 1; k < length; k = k * 2 + 1) {
            // 找出左子节点和右子节点中大的那个节点，赋值给k
            if (k + 1 < length && arr[k] < arr[k + 1]) {
                k++;
            }
            // 如果子节点大于父节点，就交换；否则退出循环
            if (arr[k] > temp) {
                arr[i] = arr[k];
                i = k;
            } else {
                break;
            }
        }
        // 退出循环后，说明以i为父节点的树，i位置的值为最大值
        // 将原始i节点的值赋给i变化后的位置，完成交换
        arr[i] = temp;
    }

}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66