必須知道的八大種排序算法【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 ; // 返回中軸的位置
    }

 

二、 遞歸形式的分治排序算法：

　　  /**
     * 
     * @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); //對高字段表進行遞歸排序
        }
    
    }

 

三、快速排序提供方法調用

　　 /**
     * 快速排序
     * @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

 　　

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