氣泡排序

寫法:

public static void bubbleSort(int[] arr) {

    if (arr == null || arr.length < 2) {
        return;
    }

    for(int i = arr.length - 1; i > 0; i--) {
        for(int j = 0; j < i; j++) {
            if(arr[j] > arr[j + 1]) {
                swap(arr, j, j + 1);
            }
        }
    }

}

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

特點: 效率低，容易實現。

思想: 每一趟從待排序序列選擇一個最小的元素放到已排好序序列的末尾，剩下的為待排序序列，重複上述步 驟直到完成排序

選擇排序

 @Test
    public void selectSort() {
        int[] arr = {1, 2, 3, 4, 55, 6, 67, 8, 88};

        // 總共要經過 N-1 輪比較
        for (int i = 0; i < arr.length - 1; i++) {
            int min = i;

            // 每輪需要比較的次數 N-i
            for (int j = i + 1; j < arr.length; j++) {
                if (arr[j] < arr[min]) {
                    // 記錄目前能找到的最小值元素的下標
                    min = j;
                }
            }

            // 將找到的最小值和i位置所在的值進行交換
            if (i != min) {
                int tmp = arr[i];
                arr[i] = arr[min];
                arr[min] = tmp;
            }

        }

        System.out.println(Arrays.toString(arr));


//輸出結果為:1 2 3 4 6 8 55 67 88
    }
 

特點: 效率低，容易實現。

思想: 每一趟從待排序序列選擇一個最小的元素放到已排好序序列的末尾，剩下的為待排序序列，重複上述步 驟直到完成排序

插入排序

@Test
    public void insertionSort(){
        int[] arr = {1, 2, 3, 4, 55, 6, 67, 8, 88};

        int i,j,t=0;
        for (i = 1; i < arr.length; i++) {
            if (arr[i] < arr[i-1]){
                t=arr[i];
                for (j=i-1;j>=0 && t < arr[j]; j--){
                    arr[j+1] = arr[j];
                    //插入arr[i]
                    arr[j+1] = t;
                }
            }
        }

     System.out.println(Arrays.toString(arr));

//輸出結果為:1 2 3 4 6 8 55 67 88 
    }
 

特點: 效率低，容易實現。

思想: 將陣列分為兩部分，將後部分元素逐一與前部分元素比較，如果前部分元素比 array[i]小，就將前部 分元素往後移動。當沒有比 array[i]小的元素，即是合理位置，在此位置插入 array[i]

快速排序

public class QuickSort implements IArraySort {

    @Override
    public int[] sort(int[] sourceArray) throws Exception {
        // 對 arr 進行拷貝，不改變引數內容
        int[] arr = Arrays.copyOf(sourceArray, sourceArray.length);

        return quickSort(arr, 0, arr.length - 1);
    }

    private int[] quickSort(int[] arr, int left, int right) {
        if (left < right) {
            int partitionIndex = partition(arr, left, right);
            quickSort(arr, left, partitionIndex - 1);
            quickSort(arr, partitionIndex + 1, right);
        }
        return arr;
    }

    private int partition(int[] arr, int left, int right) {
        // 設定基準值（pivot）
        int pivot = left;
        int index = pivot + 1;
        for (int i = index; i <= right; i++) {
            if (arr[i] < arr[pivot]) {
                swap(arr, i, index);
                index++;
            }
        }
        swap(arr, pivot, index - 1);
        return index - 1;
    }

    private void swap(int[] arr, int i, int j) {
        int temp = arr[i];
        arr[i] = arr[j];
        arr[j] = temp;
    }

}

特點: 高效，時間複雜度為 nlogn。 採用分治法的思想：首先設定一個軸值 pivot，然後以這個軸值為劃分基準將待排序序列分成比 pivot 大和比 pivot 小的兩部分，接下來對劃分完的子序列進行快排直到子序列為一個元素為止。

內容整理自菜鳥教程 --https://www.runoob.com/w3cnote/ten-sorti