public class BinarySearch1 {  
    public static void main(String args[])  
    {  
        int array[]={49,38,65,97,76,13,27};  
        binarySort(array,array.length);  
        System.out.println(Arrays.toString(array));  
    }  
      
    //二分查詢  
    public static int binarySearch(int array[],int
 
 low,int high,int temp)  
    {  
        int mid=0;  
        while(low<=high)  
        {  
            mid=(low+high)/2;  
            if(array[mid]<temp&&temp<=array[mid+1])  
                return (mid+1);  
            else if(array[mid]<temp)  
                low = mid + 1;  
            else
 
  
                high = mid -1;  
        }  
        return high;  
    }  
      
    //二分排序  
    public static void binarySort(int array[],int size)  
    {  
        int i,j,k,temp;  
        for(i=1;i<size;i++)  
        {  
            temp=array[i];  
            if(array[i]<array[0])  
                k=0;  
            else
 
  
                k = binarySearch(array,0,i,temp);  
              
            for(j=i;j>k;j--)  
            {  
                array[j]=array[j-1];  
            }  
            array[k]=temp;  
            System.out.println(Arrays.toString(array));  
        }  
    }  
}

冒泡法                                                                                         

第1趟：依次比較0和1、1和2、2和3...n-2和n-1索引處的元素，發現前面的大於後面的，就交換它們，這樣一趟下來，最大的元素排到了最後面。

第2趟：繼續按照第1趟的做法再做一遍，一趟下來，第二大的元素排到了最後面。

　......

這樣經過n-1趟比較、交換，n個數據排序完畢。如果某一趟沒有交換，表明已經排序完畢，可提前結束排序。

程式碼                                                                                            

int size = arr.length;
        for (int i = 0; i < size - 1; i++) {
            for (int j = 0; j < size - i - 1; j++) {

                if arr[j] > arr[j + 1]) {
                    int temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                }

         }

氣泡排序最好的時間複雜度O(N);氣泡排序的最壞時間複雜度為O(N²)。

綜上，因此氣泡排序總的平均時間複雜度為O(N²)。

氣泡排序

氣泡排序也被稱為下沉排序，是一個簡單的排序演算法，通過多次重複比較每對相鄰的元素，並按規定的順序交換他們，最終把數列進行排好序。一直重複下去，直到結束。該演算法得名於較小元素“氣泡”會“浮到”列表頂部。由於只使用了比較操作，所以這是一個比較排序。

氣泡排序演算法的運作如下：

1.    比較相鄰的元素。如果第一個比第二個大，就交換他們兩個。

2.    對每一對相鄰元素作同樣的工作，從開始第一對到結尾的最後一對。這步做完後，最後的元素會是最大的數。

3.    針對所有的元素重複以上的步驟，除了最後一個。

4.    持續每次對越來越少的元素重複上面的步驟，直到沒有任何一對數字需要比較。

由於它的簡潔，氣泡排序通常被用來對於程式設計入門的學生介紹演算法的概念。但同樣簡單的插入排序比氣泡排序效能更好，所以有些人認為不需要再教氣泡排序了。

直接插入法                                                                                  

第一趟：把第2個元素拿出來跟第1個元素對比，小的在前面、大的在後面。

第二趟：把第3個元素拿出來插入到前2個元素中，使他們有序。

第三趟：把第4個元素拿出來插入到前3個元素中，使他們有序。

......

第n-1趟：把第n個元素拿出來插入到前n-1個元素中，排序完成。

程式碼                                                                                           

int size = arr.length;
        // 從第二個開始，遍歷每一個數組元素
        for (int i = 1; i < size; i++) {
            // 取出來
            int temp = arr[i];
            // 從後往前遍歷，找到插入位置
            int j;
            for (j = i - 1; j >= 0 && temp < arr[j]; j--) {
                arr[j + 1] = arr[];
            }
            // 由於上面的迴圈完畢之後執行了j--,所以這裡給arr[j+1]賦值
            arr[j + 1] = temp;
         }

直接插入排序屬於穩定的排序，最壞時間複雜性為O(N²)，空間複雜度為O(1)。

插入排序

插入排序的工作原理是通過構建有序序列，對於未排序資料，在已排序序列中從後向前掃描，找到相應位置並插入。插入排序在實現上，通常採用in-place排序（即只需用到O(1)的額外空間的排序），因而在從後向前掃描過程中，需要反覆把已排序元素逐步向後挪位，為最新元素提供插入空間。

具體演算法描述如下：

1.    從第一個元素開始，該元素可以認為已經被排序

2.    取出下一個元素，在已經排序的元素序列中從後向前掃描

3.    如果該元素（已排序）大於新元素，將該元素移到下一位置

4.    重複步驟3，直到找到已排序的元素小於或者等於新元素的位置

5.    將新元素插入到該位置後

6.    重複步驟2~5

快速排序法                                                                                  

快速排序是對氣泡排序的一種改進。

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

一趟快速排序的演算法是：

1）設定兩個變數i、j，排序開始的時候：i=0，j=N-1；

2）以第一個陣列元素作為關鍵資料，賦值給key，即key=A[0]；

3）從j開始向前搜尋，即由後開始向前搜尋(j--)，找到第一個小於key的值A[j]，將A[j]賦給A[i]；

4）從i開始向後搜尋，即由前開始向後搜尋(i++)，找到第一個大於key的A[i]，將A[i]賦給A[j]；

5）重複第3、4步，直到i=j； (3,4步中，沒找到符合條件的值，即3中A[j]不小於key,4中A[i]不大於key的時候改變j、i的值，使得j=j-1，i=i+1，直至找到為止。找到符合條件的值，進行交換的時候i， j指標位置不變。另外，i==j這一過程一定正好是i+或j-完成的時候，此時令迴圈結束）。

程式碼                                                                                            

public class Main {
    /**
     * @param pData
     *            需要排序的陣列
     * @param left
     *            左邊的位置,初始值為0
     * @param right
     *            右邊的位置,初始值為陣列長度
     */
    public static void QuickSort(int[] pData, int left, int right) {
        int i, j;
        int first, temp;
        i = left;
        j = right;
        first = pData[left]; // 這裡選其他的數也行，不過一般選第一個
        // 一趟快速排序
        while (true) {
            // 從第二個數開始找大於中樞的數 ,從前面開始找大於pData[left]的數
            while ((++i) < right - 1 && pData[i] < first)
                ;
            // 從最後一個數開始找第一個小於中樞pData[left]的數
            while ((--j) > left && pData[j] > first)
                ;
            if (i >= j)
                break;
            // 交換兩邊找到的數
            temp = pData[i];
            pData[i] = pData[j];
            pData[j] = temp;

        }
        // 交換中樞
        pData[left] = pData[j];
        pData[j] = first;
        // 遞迴快排中樞左邊的資料
        if (left < j)
            QuickSort(pData, left, j);
        // 遞迴快排中樞右邊的資料
        if (right > i)
            QuickSort(pData, i, right);
    }

    public static void main(String[] args) {

        int[] pData = new int[5];
        for (int i = 0; i < 5; i++)
            pData[i] = (int) (Math.random() * 100);// Produce 10 random integers

        for (int i = 0; i < pData.length; i++) {
            System.out.print(pData[i] + " ");
        }
        Main.QuickSort(pData, 0, pData.length);

        System.out.println("\n***********************");

        for (int i = 0; i < pData.length; i++) {
            System.out.print(pData[i] + " ");
        }
    }
}

快速排序

快速排序採用分而治之的策略，把一個列表劃分為兩個子列表。步驟是：

·        從列表中，選擇一個元素，稱為基準（pivot）。

·        重新排序列表，把所有數值小於樞軸的元素排到基準之前，所有數值大於基準的排基準之後(相等的值可以有較多的選擇)。在這個分割槽退出之後，該基準就處於數列的中間位置。這個稱為分割槽（partition）操作。

·        分別遞迴排序較大元素的子列表和較小的元素的子列表。

遞迴的結束條件是列表元素為零或一個，即已不需要排序。