上一篇總結了交換排序的冒泡排序和快速排序。這一篇要總結的是選擇排序，選擇排序分為直接選擇排序和堆排序，主要從以下幾點進行總結。

1、直接選擇排序及算法實現

2、堆排序及算法實現

1、直接選擇排序及算法實現

直接選擇排序(Straight Select Sort) 是一種簡單的排序方法，它的基本思想是：通過length-1 趟元素之間的比較，從length-i+1個元素中選出最小的元素，並和第i個元素交換位置。直接選擇排序的最壞時間復雜度為O(n²)，平均時間復雜度為O(n²)

下圖展示了直接選擇排序的過程。

1-1、示意圖

1-2、代碼

SelectionSort.java

public class SelectionSort {
    public static void main(String[] args) {
        int[] list = {9, 1, 2, 5, 7, 4, 8, 6, 3, 5};
        System.out.println("************直接選擇排序************");
        System.out.println("排序前：");
        display(list);
        System.out.println("");

        System.out.println(
 
"排序後：");
        selectionSort(list);
        display(list);
    }

    /**
     * 直接選擇排序算法
     */
    public static void selectionSort(int[] list) {
        // 要遍歷的次數（length-1次）
        for (int i = 0; i < list.length - 1; i++) {
            // 將當前下標定義為最小值下標
            int min = i;

            
 
// 遍歷min後面的數據
            for (int j = i + 1; j <= list.length - 1; j++) {
                // 如果有小於當前最小值的元素，將它的下標賦值給min
                if (list[j] < list[min]) {
                    min = j;
                }
            }
            // 如果min不等於i，說明找到真正的最小值
            if (min != i) {
                swap(list, min, i);
            }
        }
    }

    /**
     * 交換數組中兩個位置的元素
     */
    public static void swap(int[] list, int min, int i) {
        int temp = list[min];
        list[min] = list[i];
        list[i] = temp;
    }

    /**
     * 遍歷打印
     */
    public static void display(int[] list) {
        System.out.println("********展示開始********");
        if (list != null && list.length > 0) {
            for (int num :
                    list) {
                System.out.print(num + " ");
            }
            System.out.println("");
        }
        System.out.println("********展示結束********");
    }
}

測試結果：

2、堆排序及算法實現

堆排序(Heap Sort) 利用堆（一般為大根堆）進行排序的方法。它的基本思想是：將待排序的元素構造成一個大根堆。此時，整個序列的最大值就是堆頂的根節點。將它移走（其實就是將它與數組的末尾元素進行交換，此時末尾元素就是最大值），然後將剩余的length-1 個元素重新構造成一個大根堆，這樣就會得到length個元素中的次大值。如此反復執行，便能得到一個有序的序列。

堆是具有下列性質的完全二叉樹：每個節點的值都大於或等於其左右孩子節點的值，稱為大根堆；每個節點的值都小於或等於其左右孩子節點的值，稱為小根堆。

堆排序的最壞時間復雜度為O(n*log₂n)，平均時間復雜度為O(n*log₂n)

2-1、示意圖

圖一：

圖二：

圖三：

圖四：

圖五：

圖六：

2-2、代碼

HeapSort.java

public class HeapSort {
    public static void main(String[] args) {
        int[] list = {1, 3, 4, 5, 2, 6, 9, 7, 8, 0};
        System.out.println("************堆排序************");
        System.out.println("排序前：");
        display(list);
        System.out.println("");

        System.out.println("排序後：");
        heapSort(list);
        display(list);
    }

    /**
     * 堆排序算法
     */
    public static void heapSort(int[] list) {
        // 將無序堆構造成一個大根堆，大根堆有length/2個父節點
        for (int i = list.length / 2 - 1; i >= 0; i--) {
            headAdjust(list, i, list.length);
        }

        // 逐步將每個最大值的根節點與末尾元素交換，並且再調整其為大根堆
        for (int i = list.length - 1; i > 0; i--) {
            // 將堆頂節點和當前未經排序的子序列的最後一個元素交換位置
            swap(list, 0, i);
            headAdjust(list, 0, i);
        }
    }

    /**
     * 構造大根堆
     */
    public static void headAdjust(int[] list, int parent, int length) {
        // 保存當前父節點
        int temp = list[parent];

        // 得到左孩子節點
        int leftChild = 2 * parent + 1;

        while (leftChild < length) {
            // 如果parent有右孩子，則要判斷左孩子是否小於右孩子
            if (leftChild + 1 < length && list[leftChild] < list[leftChild + 1]) {
                leftChild++;
            }
            // 父親節點大於子節點，就不用做交換
            if (temp >= list[leftChild]) {
                break;
            }
            // 將較大子節點的值賦給父親節點
            list[parent] = list[leftChild];
            // 然後將子節點做為父親節點
            parent = leftChild;
            // 找到該父親節點較小的左孩子節點
            leftChild = 2 * parent + 1;
        }
        // 最後將temp值賦給較大的子節點，以形成兩值交換
        list[parent] = temp;
    }

    /**
     * 交換數組中兩個位置的元素
     */
    public static void swap(int[] list, int top, int last) {
        int temp = list[top];
        list[top] = list[last];
        list[last] = temp;
    }

    /**
     * 遍歷打印
     */
    public static void display(int[] list) {
        System.out.println("********展示開始********");
        if (list != null && list.length > 0) {
            for (int num :
                    list) {
                System.out.print(num + " ");
            }
            System.out.println("");
        }
        System.out.println("********展示結束********");
    }
}

測試結果：

歡迎轉載，但請保留文章原始出處

本文地址：http://www.cnblogs.com/nnngu/p/8282291.html

算法2 排序算法：直接選擇排序和堆排序