必須知道的八大種排序算法【java實現】（一） 冒泡排序、快速排序

冒泡排序

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

　　冒泡排序的示例：

 

冒泡排序的算法實現如下:【排序后，數組從小到大排列】

　　　/**
     * 冒泡排序
     * 比較相鄰的元素。如果第一個比第二個大，就交換他們兩個。  
     * 對每一對相鄰元素作同樣的工作，從開始第一對到結尾的最后一對。在這一點，最后的元素應該會是最大的數。  
     * 針對所有的元素重復以上的步驟，除了最后一個。
     * 持續每次對越來越少的元素重復上面的步驟，直到沒有任何一對數字需要比較。 
     * @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,

 

選擇排序、插入排序、希爾排序可查看：http://www.cnblogs.com/0201zcr/p/4764427.html

歸並排序、堆排序可查看：http://www.cnblogs.com/0201zcr/p/4764705.html

 　　

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