必須知道的排序算法—Java實現(xiàn)

1 冒泡排序

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

冒泡排序動畫演示

冒泡排序的算法實現(xiàn)如下:

/**
 * 冒泡排序
 * 比較相鄰的元素。如果第一個比第二個大，就交換他們兩個。
 * 對每一對相鄰元素作同樣的工作，從開始第一對到結(jié)尾的最后一對。
 * 在這一點，最后的元素應(yīng)該會是最大的數(shù)。
 *
 * 針對所有的元素重復(fù)以上的步驟，除了最后一個。
 * 持續(xù)每次對越來越少的元素重復(fù)上面的步驟，直到?jīng)]有任何一對數(shù)字需要比較。
 * @param numbers 需要排序的整型數(shù)組
 */
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])   // 交換兩數(shù)位置
            {
                temp = numbers[j];
                numbers[j] = numbers[j+1];
                numbers[j+1] = temp;
            }
        }
    }
}

2 快速排序

快速排序的基本思想： 通過一趟排序?qū)⒋判蛴涗浄指畛瑟毩⒌膬刹糠郑渲幸徊糠钟涗浀年P(guān)鍵字均比另一部分關(guān)鍵字小，則分別對這兩部分繼續(xù)進行排序，直到整個序列有序。

快速排序動畫演示

RANDOM QUICK SORT動畫演示

快速排序的算法實現(xiàn)如下:

/**
 * 查找出中軸（默認是最低位low）的在numbers數(shù)組排序后所在位置
 * @param numbers  待排序數(shù)組
 * @param low 開始位置
 * @param high 結(jié)束位置
 * @return 中軸所在位置
 */
public static int getMiddle(int[] numbers, int low,int high)
{
    int temp = numbers[low];  // 數(shù)組的第一個作為中軸
    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 待排序數(shù)組
 * @param low  開始位置
 * @param high 結(jié)束位置
 */
public static void quickSort(int[] numbers,int low,int high) {
    if(low < high) {
        int middle = getMiddle(numbers,low,high);  // 將numbers數(shù)組進行一分為二
        quickSort(numbers, low, middle-1);   // 對低字段表進行遞歸排序
        quickSort(numbers, middle+1, high);   // 對高字段表進行遞歸排序
    }
}

/**
 * 快速排序提供方法調(diào)用
 * @param numbers 待排序數(shù)組
 */
public static void quick(int[] numbers) {
    // 查看數(shù)組是否為空
    if(numbers.length > 0) {
        quickSort(numbers, 0, numbers.length-1);
    }
}

3 選擇排序

基本思想：在要排序的一組數(shù)中，選出最小的一個數(shù)與第一個位置的數(shù)交換；然后在剩下的數(shù)當中再找最小的與第二個位置的數(shù)交換，如此循環(huán)到倒數(shù)第二個數(shù)和最后一個數(shù)比較為止。

選擇排序動畫演示

算法實現(xiàn)

/**
 * 選擇排序算法
 * 在未排序序列中找到最小元素，存放到排序序列的起始位置;
 * 再從剩余未排序元素中繼續(xù)尋找最小元素，然后放到排序序列末尾。
 * 以此類推，直到所有元素均排序完畢。
 * @param numbers
 */
public static void selectSort(int[] numbers) {

    int size = numbers.length; // 數(shù)組長度
    int temp = 0 ;             // 中間變量

    for(int i = 0 ; i < size ; i++) {
        int k = i;   // 待確定的位置

        // 選擇出應(yīng)該在第i個位置的數(shù)
        for(int j = size -1 ; j > i ; j--) {
            if(numbers[j] < numbers[k]) {
                k = j;
            }
        }

        // 交換兩個數(shù)
        temp = numbers[i];
        numbers[i] = numbers[k];
        numbers[k] = temp;

    }
}

4 堆排序

堆排序（Heap Sort）是由J.Williams在1964年提出的，它是在選擇排序的基礎(chǔ)上發(fā)展起來的，比選擇排序的效率要高，因此也可以說堆排序是選擇排序的升級版。堆排序除了是一種排序方法外，還涉及到方法之外的一些概念：堆和完全二叉樹。這里主要說說什么是堆？
如果將堆看成一棵完全二叉樹，則這棵完全二叉樹中的每個非葉子節(jié)點的值均不大于（或不小于）其左、右孩子節(jié)點的值。由此可知，若一棵完全二叉樹是堆，則根節(jié)點一定是這棵樹的所有節(jié)點的最小元素或最大元素。非葉子節(jié)點的值大于其左、右孩子節(jié)點的值的堆稱為大根堆，反之則稱為下小根堆。

堆排序動畫演示

算法實現(xiàn)

/**
 * 構(gòu)建大頂堆
 * @param R
 * @param low
 * @param high
 */
public static void sift(int[] R,int low,int high) {
    int i=low,j=i*2;
    int temp = R[i];
    while(j<=high) {
        if(j<high&&R[j]<R[j+1]) {
            j++;
        }
        if(temp<R[j]) {
            R[i]=R[j];
            i=j;
            j=2*i;
        } else {
            break;
        }
    }
    R[i]=temp;
}

/**
 * 堆排序
 * @param R
 */
public static void heapSort(int[] R) {
    int i,j;
    int n = R.length-1;
    int temp;
    for(i=n/2;i>=1;--i) { //初始化（大根）堆
        sift(R,i,n);
    }

    // 堆排序
    for(j=n;j>=2;j--) {
        temp=R[1];
        R[1]=R[j];
        R[j]=temp;
        sift(R,1,j-1);
    }
}

5 插入排序

基本思想：每步將一個待排序的記錄，按其順序碼大小插入到前面已經(jīng)排序的字序列的合適位置（從后向前找到合適位置后），直到全部插入排序完為止。

插入排序動畫演示

算法實現(xiàn)

/**
 * 插入排序
 *
 * 從第一個元素開始，該元素可以認為已經(jīng)被排序
 * 取出下一個元素，在已經(jīng)排序的元素序列中從后向前掃描
 * 如果該元素（已排序）大于新元素，將該元素移到下一位置
 * 重復(fù)步驟3，直到找到已排序的元素小于或者等于新元素的位置
 * 將新元素插入到該位置中
 * 重復(fù)步驟2
 * @param numbers 待排序數(shù)組
 */
public static void insertSort(int[] numbers) {
    int size = numbers.length;
    int temp = 0 ;
    int j =  0;

    for(int i = 0 ; i < size ; i++) {
        temp = numbers[i];
        // 假如temp比前面的值小，則將前面的值后移
        for(j = i ; j > 0 && temp < numbers[j-1] ; j --) {
            numbers[j] = numbers[j-1];
        }
        numbers[j] = temp;
    }
}

6 希爾排序

希爾排序是D.L.Shell于1959年提出來的一種排序算法，在這之前排序算法的時間復(fù)雜度基本都是O(n *n)的，希爾排序算法是突破這個時間復(fù)雜度的第一批算法之一，它是直接插入排序的升級版。希爾排序的基本思想是：將待排序的記錄分成幾組，從而減少參與直接插入排序的數(shù)據(jù)量，當經(jīng)過幾次分組之后，記錄的排列已經(jīng)基本有序，這時再對所有記錄實施直接插入排序。

希爾排序的主要特點是排序的每一趟均以不同的間隔數(shù)對子序列進行排序，當間隔數(shù)很大時，被移動的元素是以跳躍式進行的。而當間隔數(shù)=1時，序列則幾乎已經(jīng)有序，只需要進行很少的元素移動，就能最終達到排序的目的。

希爾排序動畫演示

算法實現(xiàn)

 /**
 *
 * 希爾排序是加強版的插入排序
 *
 * 希爾排序的原理:
 * 根據(jù)需求，如果你想要結(jié)果從大到小排列，它會首先將數(shù)組進行分組，然后將較大值移到前面，較小值
 * 移到后面，最后將整個數(shù)組進行插入排序，
 * 這樣比起一開始就用插入排序減少了數(shù)據(jù)交換和移動的次數(shù)，可以說希爾排序是加強版的插入排序
 * 拿數(shù)組5, 2, 8, 9, 1, 3，4來說，數(shù)組長度為7，當increment為3時，數(shù)組分為兩個序列
 * 5，2，8和9，1，3，4，第一次排序，9和5比較，1和2比較，3和8比較，
 * 4和比其下標值小increment的數(shù)組值相比較
 * 此例子是按照從大到小排列，所以大的會排在前面，第一次排序后數(shù)組為9, 2, 8, 5, 1, 3，4
 * 第一次后increment的值變?yōu)?/2=1,此時對數(shù)組進行插入排序，
 * 實現(xiàn)數(shù)組從大到小排
 */
public static void shellSort01(int[] data) {
    int j = 0;
    int temp = 0;

    // 每次將步長縮短為原來的一半
    for (int increment = data.length / 2; increment > 0; increment /= 2) {
        for (int i = increment; i < data.length; i++) {
            temp = data[i];

            for (j = i; j >= increment; j -= increment) {

                /**
                 * 如想從小到大排只需修改這里
                if(temp > data[j - increment]) {

                    data[j] = data[j - increment];
                }
                else {
                    break;
                }
                 */

                if (temp < data[j]) {
                    data[j + increment] = data[j];
                } else {
                    break;
                }

            }
            data[j] = temp;
        }
    }
}

/**
 * 希爾排序
 * @param arr
 */
public static void shellSort02(int[] arr) {
    int j;
    int len = arr.length;
    for(int val=len>>1; val>0; val>>=1) {
        // 下面是對本次的所有分組做直接插入排序
        for(int i=val; i<len; i++) {

            /**
             * 為什么每次都用temp比較呢？
             * 因為直接插入就是找到temp的合適位置。
             * 為什么temp<arr[j-val]這個條件可以放在for內(nèi)呢？
             * 因為原來的組內(nèi)數(shù)據(jù)已經(jīng)有序，找到位置就停止便是。
             * 不甚理解的去看直接插入排序吧。
             */
            int temp = arr[i];

            for(j=i; j>=val&&temp<arr[j-val]; j-=val) {

                /**
                 * 為什么是arr[j-val]不是arr[j]呢？
                 * 因為j=i開始的，而且條件是j>=val&&temp<arr[j-val]
                 */
                arr[j] = arr[j-val];
            }

            /**
             * 注意不是arr[i] = temp
             * 直接插入排序也是這樣的。
             * 為什么呢？
             * 因為j是位置，i是待插入元素
             */
            arr[j] = temp;
        }

    }

}

總結(jié)：Shell排序適用于待排序記錄數(shù)量較大的情況，在此情況下，Shell排序一般要比直接插入排序要快（從直接插入排序結(jié)果的1061ms到希爾排序的21ms）。1971年，斯坦福大學(xué)的兩位教授在大量實驗的基礎(chǔ)上推導(dǎo)出Shell排序的時間復(fù)雜度約為O(n1.3)，使得我們終于突破了慢速排序的時代（超越了時間復(fù)雜度為O(n2)）。

7 歸并排序

基本思想：歸并（Merge）排序法是將兩個（或兩個以上）有序表合并成一個新的有序表，即把待排序序列分為若干個子序列，每個子序列是有序的。然后再把有序子序列合并為整體有序序列。

歸并排序動畫演示

算法實現(xiàn)

/**
 * 將數(shù)組中l(wèi)ow到high位置的數(shù)進行排序
 * @param nums 待排序數(shù)組
 * @param low 待排的開始位置
 * @param mid 待排中間位置
 * @param high 待排結(jié)束位置
 */
public static void merge(int[] nums, int low, int mid, int high) {
    int[] temp = new int[high - low + 1];
    int i = low;     // 左指針
    int j = mid + 1; // 右指針
    int k = 0;

    // 把較小的數(shù)先移到新數(shù)組中
    while (i <= mid && j <= high) {
        if (nums[i] < nums[j]) {
            temp[k++] = nums[i++];
        } else {
            temp[k++] = nums[j++];
        }
    }

    // 把左邊剩余的數(shù)移入數(shù)組
    while (i <= mid) {
        temp[k++] = nums[i++];
    }

    // 把右邊邊剩余的數(shù)移入數(shù)組
    while (j <= high) {
        temp[k++] = nums[j++];
    }

    // 把新數(shù)組中的數(shù)覆蓋nums數(shù)組
    for (int k2 = 0; k2 < temp.length; k2++) {
        nums[k2 + low] = temp[k2];
    }
}


/**
 * 歸并排序
 * 將兩個（或兩個以上）有序表合并成一個新的有序表
 * 即把待排序序列分為若干個子序列，每個子序列是有序的。
 * 然后再把有序子序列合并為整體有序序列
 * @param nums 待排序數(shù)組
 * @param low 待排序數(shù)組的第一個元素索引
 * @param high 待排序數(shù)組的最后一個元素索引
 * @return 輸出有序數(shù)組
 */
public static int[] sort(int[] nums, int low, int high) {
    int mid = (low + high) / 2;
    if (low < high) {
        // 左邊
        sort(nums, low, mid);
        // 右邊
        sort(nums, mid + 1, high);
        // 左右歸并
        merge(nums, low, mid, high);
    }
    return nums;
}

/**
 * 歸并排序
 * @param data 待排序數(shù)組
 */
public static void mergeSort(int[] data) {
    sort(data,0,data.length-1);
}

8 桶排序

基數(shù)排序(radix sort)又稱桶排序（bucket sort），相對于常見的比較排序，基數(shù)排序是一種分配式排序，即通過將所有數(shù)字分配到應(yīng)在的位置最后再覆蓋到原數(shù)組完成排序的過程。

桶排序適用數(shù)據(jù)范圍
桶排序可用于最大最小值相差較大的數(shù)據(jù)情況，比如[9012,19702,39867,68957,83556,102456]。
但桶排序要求數(shù)據(jù)的分布必須均勻，否則可能導(dǎo)致數(shù)據(jù)都集中到一個桶中。比如[104,150,123,132,20000], 這種數(shù)據(jù)會導(dǎo)致前4個數(shù)都集中到同一個桶中。導(dǎo)致桶排序失效。

過程分析

桶排序的基本思想是：把數(shù)組 arr 劃分為n個大小相同子區(qū)間（桶），每個子區(qū)間各自排序，最后合并。
計數(shù)排序是桶排序的一種特殊情況，可以把計數(shù)排序當成每個桶里只有一個元素的情況。

基數(shù)排序動畫演示

1. 找出待排序數(shù)組中的最大值max、最小值min；
2. 我們使用 動態(tài)數(shù)組ArrayList 作為桶，桶里放的元素也用 ArrayList 存儲。桶的數(shù)量為(max-min)/arr.length+1；
3. 遍歷數(shù)組 arr，計算每個元素 arr[i] 放的桶；
4. 每個桶各自排序；
5. 遍歷桶數(shù)組，把排序好的元素放進輸出數(shù)組。

算法實現(xiàn)

/**
 * 桶排序
 * @param arr 待排序數(shù)組
 */
public static void bucketSort(int[] arr) {

    int max = Integer.MIN_VALUE;
    int min = Integer.MAX_VALUE;
    for(int i = 0; i < arr.length; i++) {
        max = Math.max(max, arr[i]);
        min = Math.min(min, arr[i]);
    }

    // 桶數(shù)
    int bucketNum = (max - min) / arr.length + 1;
    ArrayList<ArrayList<Integer>> bucketArr = new ArrayList<>(bucketNum);
    for(int i = 0; i < bucketNum; i++) {
        bucketArr.add(new ArrayList<Integer>());
    }

    // 將每個元素放入桶
    for(int i = 0; i < arr.length; i++) {
        int num = (arr[i] - min) / (arr.length);
        bucketArr.get(num).add(arr[i]);
    }

    // 對每個桶進行排序
    for(int i = 0; i < bucketArr.size(); i++) {
        Collections.sort(bucketArr.get(i));
    }

}

9 計數(shù)排序

計數(shù)排序適用數(shù)據(jù)范圍

計數(shù)排序需要占用大量空間，它僅適用于數(shù)據(jù)比較集中的情況。比如 [0_{100]，[10000}19999] 這樣的數(shù)據(jù)。

過程分析

計數(shù)排序的基本思想是：對每一個輸入的元素arr[i]，確定小于 arr[i] 的元素個數(shù)。
所以可以直接把 arr[i] 放到它輸出數(shù)組中的位置上。假設(shè)有5個數(shù)小于 arr[i]，所以 arr[i] 應(yīng)該放在數(shù)組的第6個位置上。

計數(shù)排序動畫演示

• 算法流程（1）
  需要三個數(shù)組:
  待排序數(shù)組 int[] arr = new int[]{4,3,6,3,5,1};
  輔助計數(shù)數(shù)組 int[] help = new int[max - min + 1]; //該數(shù)組大小為待排序數(shù)組中的最大值減最小值+1
  輸出數(shù)組 int[] res = new int[arr.length];

1. 求出待排序數(shù)組的最大值max=6， 最小值min=1
2. 實例化輔助計數(shù)數(shù)組help，help數(shù)組中每個下標對應(yīng)arr中的一個元素，help用來記錄每個元素出現(xiàn)的次數(shù)
3. 計算 arr 中每個元素在help中的位置 position = arr[i] - min，此時 help = [1,0,2,1,1,1]; （3出現(xiàn)了兩次，2未出現(xiàn)）
4. 根據(jù) help 數(shù)組求得排序后的數(shù)組，此時 res = [1,3,3,4,5,6]

/**
 * 計數(shù)排序
 * @param arr 待排序數(shù)組
 * @return
 */
public static int[] countSort1(int[] arr) {
    if (arr == null || arr.length == 0) {
        return null;
    }

    int max = Integer.MIN_VALUE;
    int min = Integer.MAX_VALUE;

    // 找出數(shù)組中的最大最小值
    for(int i = 0; i < arr.length; i++){
        max = Math.max(max, arr[i]);
        min = Math.min(min, arr[i]);
    }

    /**
     * 輔助計數(shù)數(shù)組
     * 該數(shù)組大小為待排序數(shù)組中的最大值減最小值+1
     */
    int help[] = new int[max];

    // 找出每個數(shù)字出現(xiàn)的次數(shù)
    for(int i = 0; i < arr.length; i++){
        int mapPos = arr[i] - min;
        help[mapPos]++;
    }

    int index = 0;
    for(int i = 0; i < help.length; i++) {
        while(help[i]-- > 0) {
            arr[index++] = i+min;
        }
    }

    return arr;
}

• 算法流程（2）
  需要三個數(shù)組:
  待排序數(shù)組 int[] arr = new int[]{4,3,6,3,5,1};
  輔助計數(shù)數(shù)組 int[] help = new int[max - min + 1]; //該數(shù)組大小為待排序數(shù)組中的最大值減最小值+1
  輸出數(shù)組 int[] res = new int[arr.length];

1. 求出待排序數(shù)組的最大值max=6， 最小值min=1
2. 實例化輔助計數(shù)數(shù)組help，help用來記錄每個元素之前出現(xiàn)的元素個數(shù)
3. 計算 arr 每個數(shù)字應(yīng)該在排序后數(shù)組中應(yīng)該處于的位置，此時 help = [1,1,4,5,6,7];
4. 根據(jù) help 數(shù)組求得排序后的數(shù)組，此時 res = [1,3,3,4,5,6]

/**
 * 計數(shù)排序
 * @param arr 待排序數(shù)組
 * @return
 */
public static int[] countSort2(int[] arr) {
    int max = Integer.MIN_VALUE;
    int min = Integer.MAX_VALUE;

    // 找出數(shù)組中的最大最小值
    for(int i = 0; i < arr.length; i++){
        max = Math.max(max, arr[i]);
        min = Math.min(min, arr[i]);
    }

    int[] help = new int[max - min + 1];

    // 找出每個數(shù)字出現(xiàn)的次數(shù)
    for(int i = 0; i < arr.length; i++){
        int mapPos = arr[i] - min;
        help[mapPos]++;
    }

    // 計算每個數(shù)字應(yīng)該在排序后數(shù)組中應(yīng)該處于的位置
    for(int i = 1; i < help.length; i++){
        help[i] = help[i-1] + help[i];
    }

    // 根據(jù)help數(shù)組進行排序
    int res[] = new int[arr.length];
    for(int i = 0; i < arr.length; i++){
        int post = --help[arr[i] - min];
        res[post] = arr[i];
    }

    return res;
}

各種算法的時間復(fù)雜度

排序?qū)Ρ?/div>

各種算法的時間復(fù)雜度

對應(yīng)語言的實現(xiàn)代碼下載

• 排序算法C#語言的實現(xiàn)
• 排序算法JavaScript語言的實現(xiàn)