我們在學習java的程序中，肯定會遇到過很多的排序演算法，今天我們就來講講常用的排序中的：插入排序，選擇排序，冒泡排序以及快速排序吧！

一、插入排序

（一）插入排序的原理

我從網上找到的圖片：

插入演算法其實我是這么理解的：

將陣列中的數從左往右依次取出，然后用取出的數和它左邊的數進行比較，如果取出的數大于它左邊的數就互換位置，一直回圈，直到取出的這個數的左邊的數比它小或者到達陣列的最左邊才結束回圈，不再互換，

（二）插入排序的實作

    /**
     * 插入演算法
     *將陣列中的數從左往右依次取出，然后用取出的數和它左邊的數進行比較，
     * 如果取出的數大于它左邊的數就互換位置，一直回圈，
     * 直到取出的這個數的左邊的數比它小或者到達陣列的最左邊才結束回圈，不再互換,
     * 進入下一個數的回圈，
     */
    public static void InsertionSort(int[] arrs){
        //從左往右依次取出arrs中陣列的一個數
        for (int i = 0 ; i < arrs.length ; i ++){
            //設定一個temp幫助交換
            int temp;
            //依次取出i左邊的所有數
            for (int j = i ; j > 0 ; j --){
                //只要num比這個數小就交換
                if(arrs[j] < arrs[j-1]){
                    temp = arrs[j-1];
                    arrs[j-1] = arrs[j];
                    arrs[j] = temp;
                }else{ 
                    //遇到比num小的數，我們就可以不用再回圈了，后面的數都比num小
                    break;
                }
            }
        }
        System.out.print("插入排序結果： ");
        for (int i = 0 ; i < arrs.length ; i ++){
            System.out.print(arrs[i] + " ");
        }
    }


    public static void main(String[] args) {
        int[] arrs = {15,45,10,6,81,54,71};
        InsertionSort(arrs);
    }

結果：

二、選擇排序

（一）選擇排序原理

網上的圖片：

選擇排序我的理解是這樣：

其實簡單選擇排序很簡單，就是遍歷陣列選擇一個最小的數放第一位，然后把第一位之后的所有數當成一個新的陣列再遍歷選出最小的放在這個新陣列的第一位，一直回圈，直至最后只剩一位數，

（二）選擇排序實作

  /**
     *其實簡單選擇排序很簡單，就是遍歷陣列選擇一個最小的數放第一位，
     * 然后把第一位之后的所有數當成一個新的陣列再遍歷選出最小的放在這個新陣列的第一位，
     * 一直回圈，直至最后只剩一位數，
     */
 public static void SelectionSort(int[] arrs){
        for (int i = 0 ; i < arrs.length ; i ++){
            for (int j = i + 1 ; j < arrs.length ; j ++) {
                if (arrs[i] < arrs[j]) {
                    int temp = arrs[j];
                    arrs[j] = arrs[i];
                    arrs[j] = temp;
                }
            }
        }
        System.out.print("選擇排序結果： ");
        for (int i = 0 ; i < arrs.length ; i ++){
            System.out.print(arrs[i] + " ");
        }
    }


    public static void main(String[] args) {
        int[] arrs = {15,45,10,6,81,54,71,1};
        SelectionSort(arrs);
    }

結果：

三、冒泡排序

（一）冒泡排序原理：

先看網圖：

我的理解是這樣：

一輪冒泡排序的流程包含陣列元素個數次回圈，每次回圈都從左往右依次取一個數，并把取出的數A和它右邊的數B進行比較，如果A>B就交換兩個數的位置，然后一直回圈到取出的數右邊沒有數為止，一輪結束，回圈輪數為陣列元素個數，

（二）冒泡排序的實作

 /**
     * 一輪冒泡排序的流程包含陣列元素個數次回圈，
     * 每次回圈都從左往右依次取一個數，
     * 并把取出的數A和它右邊的數B進行比較，
     * 如果A>B就交換兩個數的位置，
     * 然后一直回圈到取出的數右邊沒有數為止，
     * 一輪結束，
     * 回圈輪數為陣列元素個數，
     * @param arrs
     */
 public static void bubbleSort(int[] arrs){
        //回圈次數等于陣列元素個數
        for (int i = 0 ; i < arrs.length ; i++){
            //設定一個狀態判斷這次回圈中是否有交換，如果全程沒有交換，就證明已經排序好了，可以跳出回圈了
            int changeState = 0;
            for (int j = 0 ; j < arrs.length-1 ; j++){
                if(arrs[j] > arrs[j+1]){
                    int temp = arrs[j];
                    arrs[j] = arrs[j+1];
                    arrs[j+1] = temp;
                    changeState = 1;
                }
            }
            if(changeState == 0){
                System.out.println("現在是第"+ i +"次，排序完了跳出回圈");
                break;
            }
        }
        System.out.print("冒泡排序結果： ");
        for (int i = 0 ; i < arrs.length ; i ++){
            System.out.print(arrs[i] + " ");
        }
    }

    public static void main(String[] args) {
        int[] arrs = {15,45,10,6,81,54,71,1};
//        InsertionSort(arrs);
//        SelectionSort(arrs);
        bubbleSort(arrs);
    }

結果：

四、快速排序（好東西）

（一）快速排序原理

說下我對整個流程理解：

假設我們有這么一個陣列：

①首先我們需要取一個值做為比較值，比如選中陣列最左邊的值，然后就把最左邊的元素選中（找個變數存著），把這個元素的位置設定為空值（用于后面新的值的交換），

②然后我們有兩個指標，分別指向最左邊和最右邊，左邊的指標負責找比choice選中的比較值大的數丟到右邊去，右邊的指標負責找比choice選中的比較值小的數丟到左邊去，

③指標J先開始移動，然后它指向了1，判斷出1比choice的值15小，所以要放在15的左邊，所以，將1放到指標i所在的位置

④右邊指標j完成交換后，要輪到左邊指標i進行移動，指標i向右移動指向45，判斷45>choice，所以要將45放到指標j所在位置，也就是比較值的右邊：

⑤然后指標i結束，輪到指標j向左移動，指向71，71>choice不移動，54>choice不移動，81>choice不移動，直到指向6,6<choice，將6移到指標i所在位置:

⑥指標j移動結束，輪到指標i向右移動，10<choice 不移動，然后直到指向指標j所指向的位置，發生第一次接觸碰頭，然后我們就可以看到i和j所指向的位置的左邊都是比choice小的數，右邊都是比choice大的數，所以現在i和j共同所指向的位置便是第一次執行完后choice的值15所在的位置，

⑦然后choice的左邊和右邊看成是兩個子陣列，分別重復上述步驟：

然后最終就能得到：

所以這就是我理解的整個快速排序的流程！

（二）代碼實作：

    public static class QuickSort {
        public static void sort(int arr[], int low, int high) {
            int l = low;
            int h = high;
            int povit = arr[low];

            while (l < h) {
                while (l < h && arr[h] >= povit)
                    h--;
                if (l < h) {
                    arr[l] = arr[h];
                    l++;
                }

                while (l < h && arr[l] <= povit)
                    l++;

                if (l < h) {
                    arr[h] = arr[l];
                    h--;
                }
            }
            arr[l] = povit;
            for (int i = 0; i < arr.length; i++) {
                System.out.print(arr[i] + " ");
            }
            System.out.print("l=" + (l + 1) + "h=" + (h + 1) + "povit=" + povit + "\n");
            if (l - 1 > low)
                sort(arr, low, l - 1);
            if (h + 1 < high)
                sort(arr, h + 1, high);
        }
    }

    public static void main(String[] args) {

        int[] arr = {15,45,10,6,81,54,71,1 };
        int low = 0;
        //不至于為什么-1都要我說吧 arr[arr.length]你看看你越不越界
        int high = arr.length-1;

        QuickSort.sort(arr, low, high);
    }

好的，時間有限今天就寫到這吧，萬分感謝！