排序思想

一.幾種排序思想

 

1.交換排序：冒泡排序與快速排序

 

冒泡排序：

思想：比較相鄰元素，違反排序順序則交換，每次冒出一個最大值，直到所有相對的最大值冒出，完成排序。

最基本的排序，不必多說。

復雜度：最壞：O(n*n)；最好：O(n)；O(n*n)。

 

private static void bubblesort(int[] arr) {
    for (int i = 0; i < arr.length - 1; i++) { // n-1趟
        for (int j = 0; j < arr.length - 1 - i; j++) { // 每趟比n-1-i次
            if (arr[j] > arr[j + 1]) {
                int temp = arr[j + 1]; // 交換
                arr[j + 1] = arr[j];
                arr[j] = temp;
            }
        }
    }
}

 

 快速排序：

思想：

通過一趟排序將要排序的數據分割成獨立的兩部分，其中一部分的所有數據都比另外一部分的所有數據都要小，
然后再按此方法對這兩部分數據分別進行快速排序，整個排序過程可以遞歸進行，以此達到整個數據變成有序序列。

復雜度：最壞：O(n*n)；最好：O(n*logn)；平均：O(n*logn)。

private static void quickSort(int[] arr, int start, int end) {
        if (start > end)// 出口
            return;
        
        int stard = arr[start];// 將數組的首值設為參照值
    
        int low = start;// 記錄需要排序的下標
        int high = end;
        
        while (low < high) {// 循環找出比參照值大和小的數
            while (low < high && stard <= arr[high]) {// 右邊的數比參照大
                high--;
            }            
            arr[low] = arr[high];// 此時跳出內層循環遇到arr[high]<stard；用右邊的數替換左邊的數
            while (low < high && stard >= arr[low]) {// 左邊的數比參照小
                low++;
            }
        arr[high] = arr[low];// 此時arr[low]>atard
        }    
        arr[low] = stard;// 將參照賦給low位置的數
        quickSort(arr, start, low - 1);// 處理所有的小的數字
        quickSort(arr, low + 1, end);// 處理所有的大的數字

    }

 

 

1.插入排序：簡單插排與希爾排序

簡單插排：

思想：

假設待插入元素之前的元素已經是排序完成的，則每一步將一個待排序的元素，按其值的大小插入前面已經排序的序列中適當位置上，直到全部插入完為止。

其中插入具體是指：對於待插入元素temp,如果i位置還不是插入合適的位置，則把i-1位置的元素填到i位置，直到找到合適的位置，或者遍歷到0位置，將temp填在i位置。

復雜度：最壞：O(n*n)；最好：O(n*n)；平均：O(n*n)。

private static void insertSort(int[] arr) {
        for (int i = 1; i < arr.length; i++) {// 從第二個元素開始遍歷
            if (arr[i] < arr[i - 1]) { // 遇到當前元素比前一個元素小的情況
                int temp = arr[i]; // 保存當前元素
                int j;//用於遍歷前面所有的情況
                for (j = i - 1; j >= 0 && arr[j] > temp; j--) { // 往前遍歷，找到合適的插入位置
                    arr[j + 1] = arr[j];
                }
                arr[j + 1] = temp; // 將保存的值存入，即插入到合適的位置，完成排序
            }
        }
    }

 

 

希爾排序：又稱縮小增量排序

思想：

按除2遞減的步長將序列分組，每組使用直接插排，直到每組都進行插排后完成排序。

復雜度：最壞：O(n*logn*logn)；最好：O(n)；平均：取決於間隔序列。

private static void shellSort(int[] arr) {
        // 遍歷步長
        for (int step = arr.length / 2; step > 0; step /= 2) {
            // 每次進行直接插入排序
            for (int i = step; i < arr.length; i += step) {
                if (arr[i] < arr[i - step]) {
                    int temp = arr[i];
                    int j;
                    for (j = i - step; j >= 0 && arr[j] > temp; j -= step) {
                        arr[j + step] = arr[j];
                    }
                    arr[j + step] = temp;
                }
            }
        }
    }

 

 

3.