堆排序Java實現

 

堆概念：

是一種完全二叉樹結構，分為大根堆和小根堆，每一個非葉子節點都大於（大根堆是大於，小根堆事小於）它的兩個子節點。

 

堆排序：步驟分為三步：

1 ：初始化大根堆（小根堆也可以，本篇以大根堆為例）

2：交換堆頂最大值和數組最后一位，

3：交換位置后的堆進行大根堆調整

4：循環進行2步驟，交換堆頂和數組倒數第二位，第三位等等直到第一位。。。

 

時間復雜度分析：

初始化堆排序結構時間復雜度需要 N * logN

每一次交換后維護新的大根堆復雜度是logN，進行N次遍歷交換，所以總的時間復雜度：N * logN

代碼如下

import java.util.Arrays;

public class Test {

    public static void swap(int[] arr, int left, int right) {
        int temp = arr[left];
        arr[left] = arr[right];
        arr[right] = temp;
    }

    public static void main(String[] args) {
        int[] arr = new int[7];
        arr[0] = 10;
        arr[1] = 11;
        arr[2] = 12;
        arr[3] = 5;
        arr[4] = 52;
        arr[5] = 1;
        arr[6] = 100;
        System.out.println("before");
        System.out.println(Arrays.toString(arr));

        initBuildHeap(arr, 0, arr.length - 1);
        System.out.println("init");
        System.out.println(Arrays.toString(arr));
        System.out.println("rebuild");
        for (int i = arr.length - 1; i >= 1; i--) {
            swap(arr, i, 0);
            rebuild(arr, 0, i - 1);
            System.out.println(Arrays.toString(arr));
        }
        System.out.println("after");
        System.out.println(Arrays.toString(arr));
    }

    private static void initBuildHeap(int[] num, int index, int end) {

        if (num == null || index > end) {
            return;
        }
        boolean flag = true;
        for (int i = end; i >= index; i--) {
            int parent = (i - 1) / 2;
            if (num[i] > num[parent]) {
                swap(num, i, parent);
                flag = false;
            }
        }
        if (!flag) {
            initBuildHeap(num, index, end);
        }
    }

    public static void rebuild(int[] arr, int begin, int end) {
        if (arr == null || arr.length == 0 || begin >= end) {
            return;
        }
        int left = begin * 2 + 1;
        int right = begin * 2 + 2;
        if (left <= end && arr[begin] < arr[left]) {
            swap(arr, begin, left);
            rebuild(arr, left, end);
        }
        if (right <= end && arr[begin] < arr[right]) {
            swap(arr, begin, right);
            rebuild(arr, right, end);
        }
    }
}

打印結果

before
[10, 11, 12, 5, 52, 1, 100]
init
[100, 52, 12, 5, 11, 1, 10]
rebuild
[52, 10, 12, 5, 11, 1, 100]
[12, 1, 10, 5, 11, 52, 100]
[11, 1, 10, 5, 12, 52, 100]
[10, 1, 5, 11, 12, 52, 100]
[5, 1, 10, 11, 12, 52, 100]
[1, 5, 10, 11, 12, 52, 100]
after
[1, 5, 10, 11, 12, 52, 100]