常見的幾種排序方法

冒泡排序

冒泡排序是把較小的數據往前調或者把較大的數據往后調。主要是通過對相鄰兩個元素進行大小的比較，根據比較結果和算法規則對該二元素的位置進行交換，這樣逐個依次進行比較和交換，就能達到排序目的。

//冒泡排序
    public static void bubbleSort(int[] arr) {
        for (int i = 0; i < arr.length - 1; i++) {
            for (int j = 0; j < arr.length - 1 - i; j++) {
                if (arr[j] > arr[j + 1]) {
                    int temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                }
            }
        }
    }

 

插入排序

將一個記錄插入到已排好序的序列中，從而得到一個新的有序序列，將序列的第一個數據看成是一個有序的子序列，然后從第二個記錄逐個向該有序的子序列進行有序的插入，直至整個序列有序

//直接插入排序
    public 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 && temp < arr[j]; j--) {
                    //把滿足條件的數字向后移位
                    arr[j + 1] = arr[j];
                }
                //不滿足條件則表示當前數字比臨時變量的數字小
                arr[j + 1] = temp;
            }
        }
    }

 

 

選擇排序

選擇排序是為每一個位置選擇當前最小的元素。首先從第1個位置開始對全部元素進行選擇，選出全部元素中最小的給該位置，再對第2個位置進行選擇，在剩余元素中選擇最小的給該位置即可；以此類推，重復進行“最小元素”的選擇，直至完成第(n-1)個位置的元素選擇，則第n個位置就只剩唯一的最大元素，此時不需再進行選擇。

 //選擇排序
    public static void selectSort(int[] arr) {
        //遍歷所有元素
        for (int i = 0; i < arr.length; i++) {
            //記錄最小值得下標
            int minIndex = i;
            //與后面每個元素進行比較
            for (int j = i + 1; j < arr.length; j++) {
                //如果有元素比minIndex還小
                if (arr[minIndex] > arr[j]) {
                    //則當前元素就位minIndex
                    minIndex = j;
                }
            }
            //如果當前下標和minIndex不相等，說明它比minIndex還小，那么就移位
            if (i != minIndex) {
                int temp = arr[i];
                arr[i] = arr[minIndex];
                arr[minIndex] = temp;
            }
        }
    }

 

快速排序

通過一次排序將要排序的數據分割成獨立的兩部分，其中一部分的所有數據都比另外一不部分的所有數據都要小，然后再按次方法對這兩部分數據分別進行快速排序

 

//快速排序
    public static void QuickSort(int[] arr, int start, int end) {
        //記錄基准數
        int stard = arr[start];
        //低位起始下標
        int low = start;
        //高位起始下標
        int higt = end;
        //滿足start<end保證數據不會多余重復比較
        if (start < end) {
            //低位下標小於高位下標，開始比較
            while (low < higt) {
                //低位下標小於高位下標,並且高位數大於等於基准數
                while ((low < higt) && stard <= arr[higt]) {
                    //高位數依次向前比較
                    higt--;
                }
                //不滿足條件時，當前高位數覆蓋當前低位數，第一次覆蓋時低位數是基准數
                arr[low] = arr[higt];
                //低位下標小於高位下標,並且低位數小於等於基准數
                while ((low < higt && arr[low] <= stard)) {
                    //低位數依次向后比較
                    low++;
                }
                //不滿足條件時，當前低位數覆蓋當前高位數
                arr[higt] = arr[low];
            }
            //比較完成后，高位數下標和低位數下標重合，把基准數賦值給重合的位置
            arr[higt] = stard;
            //繼續遞歸排序低位數
            QuickSort(arr, start, low);
            //繼續遞歸排序高位數
            QuickSort(arr, low + 1, end);
        }
    }

 

歸並排序

歸並排序是把集合遞歸划分成為兩個短集合，再將兩個集合各自再分成兩組組。依次類推，當分出來的一個集合只有一個數據時，可以認為這個集合內已經達到了有序，然后再合並相鄰的二個集合就可以了。這樣通過先遞歸的分解集合，再合並集合就完成了歸並排序。

 

 //歸並排序
    public static void mergeSort(int[] arr, int low, int high) {
        int middle = (low + high) / 2;
        if (low < high) {
            //處理左邊
            mergeSort(arr, low, middle);
            //處理右邊
            mergeSort(arr, middle + 1, high);
            //歸並
            merge(arr, low, middle, high);
        }
    }

    public static void merge(int[] arr, int low, int middle, int high) {
        //臨時數組
        int[] temp = new int[high - low + 1];
        //臨時數組下標記錄
        int index = 0;
        //第一組需要遍歷的起始下標
        int i = low;
        //第二組需要遍歷的起始下標
        int j = middle + 1;
        //遍歷兩個數組，取出最小數放入臨時數組
        while (i <= middle && j <= high) {
            if (arr[i] <= arr[j]) {
                temp[index] = arr[i];
                i++;
            } else {
                temp[index] = arr[j];
                j++;
            }
            index++;
        }
        //處理多余的數據
        while (j <= high) {
            temp[index] = arr[j];
            j++;
            index++;
        }
        while (i <= middle) {
            temp[index] = arr[i];
            i++;
            index++;
        }
        //把臨時數組中的數據重新放入原數組
        for (int k = 0; k < temp.length; k++) {
            arr[k + low] = temp[k];

        }
    }