氣泡排序

public class BubbleSort {
    /*
       基本思想：
       通過對待排序序列從前往後（從下標較小的元素開始），依次比較相鄰兩元素的值，若發現逆序則交換，
       使值較大的元素逐漸從前面移向後部。
       以從小到大為例：每一趟都確定一個當前最大數的位置，共走n-1趟。
     */
    public static  void bubbleSort(int[] arr){
        //臨時變數，用來交換陣列不同位置的兩個數
        int temp = 0;
        //優化效率的一個標誌
        boolean
 
 flag= false;

        for(int i=0;i<arr.length-1;i++){
            for (int j = 0; j <arr.length-1-i; j++) {
                //“-i"每一輪冒泡以後最大數已經就位，沒有必要重複比較
                if(arr[j]>arr[j+1]){
                    temp=arr[j];
                    arr[j]=arr[j+1];
                    arr[j+1]=temp;
                    
 
//在該輪中如果進行過交換則將flag更改為true
                    // （如果flag一次都沒有進行過交換則為false，證明此時陣列已經是一個有序陣列，可以直接退出程式）
                    flag=true;
                }
            }
            if(!flag){
                break;
            }else {
                flag=false;
            }
        }
    }
}

選擇排序

/*
    基本思想：
        第一次從arr[0]-—arr[n-1]中找到最小的數與arr[0]交換；第二次從arr[1]--arr[n-1]
    中找到最小的數與arr[1]交換，以此類推，直到完成排序。
    說明：
    1.選擇排序一共有陣列大小-1次排序；
    2.每一輪排序都是一個迴圈
        2.1先假定當前這個數最小；
        2.2然後和後面的每個數進行比較，如發現比前面更小的數就重新確定最小數並確定下標；
        2.3當打到最後時，就找到了本輪的最小數；
        2.4進行交換。
     
 
*/
    //時間複雜度O（n2）
    public static void selectSort(int[] arr){
        for(int i=0;i<arr.length-1;i++){
            int minIndex = i;
            int min = arr[i];
            //（i+1）從上一輪的下一個開始選擇
            for(int j=i+1;j<arr.length;j++){
                if(min>arr[j]){
                    //找到本輪的最小數和他的下標
                    min=arr[j];
                    minIndex=j;
                }
            }
            //交換
            if(minIndex!=i){
                arr[minIndex] = arr[i];
                arr[i]=min;
            }

        }
    }
}

插入排序

 /*
    基本思想：
        第一次從arr[0]-—arr[n-1]中找到最小的數與arr[0]交換；第二次從arr[1]--arr[n-1]
    中找到最小的數與arr[1]交換，以此類推，直到完成排序。
    說明：
    1.選擇排序一共有陣列大小-1次排序；
    2.每一輪排序都是一個迴圈
        2.1先假定當前這個數最小；
        2.2然後和後面的每個數進行比較，如發現比前面更小的數就重新確定最小數並確定下標；
        2.3當打到最後時，就找到了本輪的最小數；
        2.4進行交換。
     */
    //時間複雜度O（n2）
    public static void selectSort(int[] arr){
        for(int i=0;i<arr.length-1;i++){
            int minIndex = i;
            int min = arr[i];
            //（i+1）從上一輪的下一個開始選擇
            for(int j=i+1;j<arr.length;j++){
                if(min>arr[j]){
                    //找到本輪的最小數和他的下標
                    min=arr[j];
                    minIndex=j;
                }
            }
            //交換
            if(minIndex!=i){
                arr[minIndex] = arr[i];
                arr[i]=min;
            }

        }
    }
}

希爾排序

/*
    也是一種插入排序
    簡單插入排序的問題:如果較小的數排在後面，那麼厚儀的次數明顯增加，會影響效率

    希爾排序的基本思想：
        把陣列按下標的一定增量分組，對每一組使用直接插入排序演算法排序；隨著增量
     逐漸減少，每組包含的關鍵詞與來越多，當增量減少到1時，完成最後一次簡單插入排序
     演算法結束。
     */

    //交換法
    public static void shellSort(int[] arr) {
        int temp = 0;
        for(int gap = arr.length / 2; gap > 0; gap /= 2) {
            for(int i = gap; i < arr.length; ++i) {
                for(int j = i - gap; j >= 0; j -= gap) {
                    if (arr[j] > arr[j + gap]) {
                        temp = arr[j];
                        arr[j] = arr[j + gap];
                        arr[j + gap] = temp;
                    }
                }
            }
        }
    }
    //位移法{（效率較高）
    public static void shellSort2(int[] arr) {
        //所謂的增量就是分為幾組，在這裡就是gap在逐步減小
        for(int gap = arr.length / 2; gap > 0; gap /= 2) {

            //遍歷各組中的所有元素，一改組下標最大的元素為起點
            for(int i = gap; i < arr.length; i++) {
                int j = i;
                int temp = arr[i];
                if (arr[i] < arr[i - gap]) {
                    while(j - gap >= 0 && temp < arr[j - gap]) {
                        arr[j] = arr[j - gap];
                        j -= gap;
                    }
                    arr[j] = temp;
                }
            }
        }

    }
}