排序算法總結

1、冒泡排序

1.1、冒泡排序的基本思想

從無序隊列的頭部開始（當然也可以從尾部開始，兩兩比較，將最小的數交換到隊首），從前往後，將相鄰的兩個數進行兩兩比較，根據大小交換位置，將最大的數交換到無序數列的隊尾，從而成爲有序數列的一部分。下一次繼續這個過程，直到將無序數列變成有序數列。

如下圖所示，每次都把最大的數浮動到隊列的末尾：

1.2、java代碼實現

package BubbleSort;

public class BubbleSort {
    public void bubblesort(int[] array){
        if (array == null || array.length == 0)
            return ;
        for(int i = 0; i < array.length - 1; i++){

            //設定一個標記flag,若爲true,則表示此次循環沒有交換，也就是待排列順序已有序，排序已完成
            boolean flag = true;

            //從隊首開始，將大的數字向後排
            for (int j = 0; j < array.length - i - 1; j++){
                if (array[j] > array[j+1]){
                    int temp = array[j+1];
                    array[j+1] = array[j];
                    array[j] = temp;
                    flag = false;
                }
            }
            if (flag)
                break;
        }
    }

    public static void main(String[] args) {
        BubbleSort bubbleSort = new BubbleSort();

        int array[] = {4,6,1,2,8,7,9,0,3,5};

        bubbleSort.bubblesort(array);
        //遍歷array數組
        for (int x : array){
            System.out.print(x + " ");
        }
    }
}


執行結果：
0 1 2 3 4 5 6 7 8 9 

1.3、性能分析

時間複雜度

根據上面這種冒泡實現，若原數組本身就是有序的（最理想情況），僅需n-1次比較就可以完成，時間複雜度爲O（n）；如果是倒序，比較次數爲：（n-1）+（n-2）+...+1=n（n-1）/ 2，所以其時間複雜度仍爲O（n^2）。

空間複雜度

冒泡排序過程中需要一個臨時變量來進行兩兩交換，所需的額外空間爲1，因此空間複雜度爲O（1）。

穩定性

冒泡排序在排序過程中，元素兩兩交換，相同元素的前後順序沒有改變，所以冒泡排序是一種穩定算法。

2、插入排序

插入排序的基本思想就是從第一個元素開始（該元素可以默認爲已經排好序），每一步將一個待排序的記錄，按照順序插入到前面已經排好序的數列中去，直到插完所有的數。

如下圖所示，中括號內代表已經排好序的數列：

2.2、java代碼實現

package SortDemo;

public class InsertSort {
    public void sort(int[] array){
        for (int i = 1; i < array.length; i++){
            int j = i;
            while (j > 0 && array[j] < array[j-1]){
                int temp = array[j];
                array[j] = array[j-1];
                array[j-1] = temp;
                j--;
            }
        }
    }

    public static void main(String[] args) {
        InsertSort insertSort = new InsertSort();

        int[] array = {4,6,1,2,8,7,9,0,3,5};

        insertSort.sort(array);

        for (int x : array){
            System.out.print(x + " ");
        }
    }
}


執行結果：0 1 2 3 4 5 6 7 8 9 

2.3、性能分析

時間複雜度

最理想情況下，數組爲正序數組，需要比較n-1次，無需交換元素，時間複雜度爲O（n）；

在最壞情況下，時間複雜度仍爲O（n^2）。