一、 排序演算法 之 氣泡排序

氣泡排序

重複地走訪過要排序的元素列，依次比較兩個相鄰的元素，如果他們的順序（如從大到小、首字母從A到Z）錯誤就把他們交換過來。走訪元素的工作是重複地進行直到沒有相鄰元素需要交換，也就是說該元素已經排序完成。

例子：

複雜度：

時間複雜度

時間複雜度 為 O(n^2)
最佳時間複雜度是O(n)

空間複雜度

最差為 O(n)
空間複雜度為 O(1)

穩定排序

程式碼實現(JAVA)

package com.ldj.sort;


/**
 * 氣泡排序
 * 比較相鄰的元素。如果第一個比第二個大，就交換他們兩個。
 * 對每一對相鄰元素作同樣的工作，從開始第一對到結尾的最後一對。在這一點，最後的元素應該會是最大的數。
 * 針對所有的元素重複以上的步驟，除了最後一個。
 * 持續每次對越來越少的元素重複上面的步驟，直到沒有任何一對數字需要比較。
 * */
public class BubbleSort {


    public static void main(String[] args) {
        int[] arr = new int[]{32,34,55,12,32,10};
        bubbleSort(arr);
        for (int i : arr) {
            System.out.println(i);
        }

    }

    private static void bubbleSort(int[] arr) {
        for (int i = 0 ; i < arr.length ; i++) {
            for (int j = 0 ; j < arr.length - 1 - i; j++ ) {
                // j = 0, 1, 2, 3... arr.length -1
                // ..
                // j = 0
                if (arr[j] > arr[j + 1]) {
                    int temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                }
           }
    }
// 優化
private static void bubbleSort2(int[] arr) {
        for (int i = 0 ; i < arr.length ; i++) {
            boolean change = false;
            for (int j = 0 ; j < arr.length - 1 - i; j++ ) {
                if (arr[j] > arr[j + 1]) {
                    change = true;
                    int temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                }
            }
            //  假如沒有更換則說明已經排序
            if (!change) {
                break;
            }
        }
    }
}
 

二、 排序演算法 之 快速排序

快速排序：

快速排序是對氣泡排序的一種優化，通過一趟排序將要排序的資料分割成獨立的兩部分，其中一部分的所有資料都比另外一部分的所有資料都要小，然後再按此方法對這兩部分資料分別進行快速排序，整個排序過程可以遞迴進行，以此達到整個資料變成有序序列。

例子：

複雜度：

時間複雜度：

快速排序最優的情況下時間複雜度為：O( nlogn )
最差情況下時間複雜度為：O(n^2)
平均時間複雜度為 O(nlogn)

空間複雜度：

最優的情況下空間複雜度為：O(logn) ；每一次都平分陣列的情況
最差的情況下空間複雜度為：O( n ) ；退化為氣泡排序的情況

不穩定的排序

程式碼實現(JAVA)

public class QuickSort {


    public static void main(String[] args) {
        int[] arr = new int[]{32,34,55,12,32,10};
        quickSort(arr);
        for (int i : arr) {
            System.out.println(i);
        }

    }

    public static void quickSort(int[] numbers) {
        quickSort(numbers, 0, numbers.length - 1);
    }

    /**
     * 遞迴排序， 分治法遞迴排序
     * */
    private static void quickSort(int[] numbers, int low, int high) {
        if (low < high) {
            int middle = middleSort(numbers, low, high);
            quickSort(numbers, low, middle - 1);
            quickSort(numbers, middle + 1, high);
        }
    }

    /**
     * 根據第一個獲取中軸進行分治， 分成兩部分， 左邊都是小的， 右邊都是大的。
     * */
    private static int middleSort(int[] numbers, int low, int high) {
        int temp = numbers[low];
        while (low < high) {
            while (low < high && temp <= numbers[high]) {
                high--;
            }
            numbers[low] = numbers[high];
            while( low < high && temp >= numbers[low]) {
                low ++;
            }
            numbers[high] = numbers[low];
        }
        numbers[low] = temp;
        return low;
    }

}