氣泡排序

　　氣泡排序是一種簡單的排序演算法。它重複地走訪過要排序的數列，一次比較兩個元素，如果他們的順序錯誤就把他們交換過來。走訪數列的工作是重複地進行直到沒有再需要交換，也就是說該數列已經排序完成。這個演算法的名字由來是因為越小的元素會經由交換慢慢“浮”到數列的頂端。

　　氣泡排序的示例：

氣泡排序的演算法實現如下:【排序後，陣列從小到大排列】

　　　/**
     * 氣泡排序
     * 比較相鄰的元素。如果第一個比第二個大，就交換他們兩個。  
     * 對每一對相鄰元素作同樣的工作，從開始第一對到結尾的最後一對。在這一點，最後的元素應該會是最大的數。  
     * 針對所有的元素重複以上的步驟，除了最後一個。
     * 持續每次對越來越少的元素重複上面的步驟，直到沒有任何一對數字需要比較。 
     * 
 
@param numbers 需要排序的整型陣列
     */
    public static void bubbleSort(int[] numbers)
    {
        int temp = 0;
        int size = numbers.length;
        for(int i = 0 ; i < size-1; i ++)
        {
        for(int j = 0 ;j < size-1-i ; j++)
        {
            if(numbers[j] > numbers[j+1])  //
 
交換兩數位置
            {
            temp = numbers[j];
            numbers[j] = numbers[j+1];
            numbers[j+1] = temp;
            }
        }
        }
    }

快速排序

快速排序的基本思想：

         通過一趟排序將待排序記錄分割成獨立的兩部分，其中一部分記錄的關鍵字均比另一部分關鍵字小，則分別對這兩部分繼續進行排序，直到整個序列有序。

快速排序的示例：

（a）一趟排序的過程：

（b）排序的全過程

　　把整個序列看做一個數組，把第零個位置看做中軸，和最後一個比，如果比它小交換，比它大不做任何處理；交換了以後再和小的那端比，比它小不交換，比他大交換。這樣迴圈往復，一趟排序完成，左邊就是比中軸小的，右邊就是比中軸大的，然後再用分治法，分別對這兩個獨立的陣列進行排序。

程式碼實現如下：

1.查詢中軸（最低位作為中軸）所在位置

　　　/**
     * 查找出中軸（預設是最低位low）的在numbers陣列排序後所在位置
     * 
     * @param numbers 帶查詢陣列
     * @param low   開始位置
     * @param high  結束位置
     * @return  中軸所在位置
     */
    public static int getMiddle(int[] numbers, int low,int high)
    {
        int temp = numbers[low]; //陣列的第一個作為中軸
        while(low < high)
        {
        while(low < high && numbers[high] > temp)
        {
            high--;
        }
        numbers[low] = numbers[high];//比中軸小的記錄移到低端
        while(low < high && numbers[low] < temp)
        {
            low++;
        }
        numbers[high] = numbers[low] ; //比中軸大的記錄移到高階
        }
        numbers[low] = temp ; //中軸記錄到尾
        return low ; // 返回中軸的位置
    }

2、 遞迴形式的分治排序演算法：

　　  /**
     * 
     * @param numbers 帶排序陣列
     * @param low  開始位置
     * @param high 結束位置
     */
    public static void quickSort(int[] numbers,int low,int high)
    {
        if(low < high)
        {
        　　int middle = getMiddle(numbers,low,high); //將numbers陣列進行一分為二
        　　quickSort(numbers, low, middle-1);   //對低欄位表進行遞迴排序
        　　quickSort(numbers, middle+1, high); //對高欄位表進行遞迴排序
        }
    
    }

3、快速排序提供方法呼叫

　　 /**
     * 快速排序
     * @param numbers 帶排序陣列
     */
    public static void quick(int[] numbers)
    {
        if(numbers.length > 0)   //檢視陣列是否為空
        {
        quickSort(numbers, 0, numbers.length-1);
        }
    }

分析：

　　快速排序是通常被認為在同數量級（O(nlog2n)）的排序方法中平均效能最好的。但若初始序列按關鍵碼有序或基本有序時，快排序反而蛻化為氣泡排序。為改進之，通常以“三者取中法”來選取基準記錄，即將排序區間的兩個端點與中點三個記錄關鍵碼居中的調整為支點記錄。快速排序是一個不穩定的排序方法。

 方法測試

列印函式：

　　public static void printArr(int[] numbers)
    {
        for(int i = 0 ; i < numbers.length ; i ++ )
        {
        System.out.print(numbers[i] + ",");
        }
        System.out.println("");
    }

測試：

　　public static void main(String[] args) 
    {
        int[] numbers = {10,20,15,0,6,7,2,1,-5,55};
        System.out.print("排序前：");
        printArr(numbers);
        
        bubbleSort(numbers);
        System.out.print("氣泡排序後：");
        printArr(numbers);
        
        
        quick(numbers);
        System.out.print("快速排序後：");
        printArr(numbers);
    }

結果：

排序前：10,20,15,0,6,7,2,1,-5,55,
氣泡排序後：-5,0,1,2,6,7,10,15,20,55,
快速排序後：-5,0,1,2,6,7,10,15,20,55,

　　致謝：感謝您的耐心閱讀！