數據結構和算法（一）常見的幾種排序算法-插入、選擇、冒泡、快排、堆排等

本文轉載自查看原文 2016-03-10 10:48 1771 算法/ 數據結構和算法/ android/ 數據結構

Java面試寶典系列之基礎排序算法

本文就是介紹一些常見的排序算法。排序是一個非常常見的應用場景，很多時候，我們需要根據自己需要排序的數據類型，來自定義排序算法，但是，在這里，我們只介紹這些基礎排序算法，包括：插入排序、選擇排序、冒泡排序、快速排序（重點）、堆排序、歸並排序等等。看下圖：

給定數組：int data[] = {9,2,7,19,100,97,63,208,55,78}

一、直接插入排序(內部排序、O(n2)、穩定)

原理：從待排序的數中選出一個來，插入到前面的合適位置。

[java] view plain copy

package com.xtfggef.algo.sort;
public class InsertSort {
static int data[] = { 9, 2, 7, 19, 100, 97, 63, 208, 55, 78 };

 public static void insertSort() {  

            for (int i = 1; i < unsorted.Length; i++)
            {
                if (unsorted[i - 1] > unsorted[i])
                {
                    int temp = unsorted[i];
                    int j = i;
                    while (j > 0 && unsorted[j - 1] > temp)
                    {
                        unsorted[j] = unsorted[j - 1];
                        j--;
                    }
                    unsorted[j] = temp;
                }
            }
}

 public static void insertSort() {  
 for (int i = 1; i < data.length; i++) {
 if (data[i] >= data[i - 1]) {
 continue;
 }
 int temp = data[i];
 for (int j = i - 1; j >= 0; j--) {
 if (temp < data[j]) {
 data[j + 1] = data[j];
 if(j==0){
 data[j ] = temp;
 }
 
 } else {
 data[j + 1] = temp;
 break;
 }
 }
}

public static void main(String[] args) {
print();
System.out.println();
insertSort();
System.out.println();
print();
}
static void print() {
for (int i = 0; i < data.length; i++) {
System.out.print(data[i] + " ");
}
}
}

我簡單的講解一下過程：思路上從待排序的數據中選出一個，插入到前面合適的位置，耗時點在插入方面，合適的位置意味着我們需要進行比較找出哪是合適的位置，舉個例子：對於9,2,7,19,100,97,63,208,55,78 這組數，第一個數9前面沒有，不做操作，當第一個數完后，剩下的數就是待排序的數，我們將要從除去9開始的書中選出一個插入到前面合適的位置，拿到2后，放在tmp上，進行注釋中的2處的代碼，2處的代碼就是通過循環找出這個合適的位置，發現比tmp大的數，立即將該數向后移動一位（這樣做的目的是：前面需要空出一位來進行插入），最后通過注釋3處的代碼將數插入。

本排序適合：基本有序的數據

二、選擇排序（O(n2)、不穩定）
與直接插入排序正好相反，選擇排序是從待排序的數中選出最小的放在已經排好的后面，這個算法選數耗時。

[java] view plain copy

package com.xtfggef.algo.sort;
public class SelectSort {
static int data[] = { 9, 2, 7, 19, 100, 97, 63, 208, 55, 78 };
public static void selectSort() {
int i, j, k, tmp = 0;
for (i = 0; i < data.length - 1; i++) {
k = i;
for (j = i + 1; j < data.length; j++)
if (data[j] < data[k])
k = j;
if (k != i) {
tmp = data[i];
data[i] = data[k];
data[k] = tmp;
}
}
}
public static void main(String[] args) {
print();
System.out.println();
selectSort();
System.out.println();
print();
}
static void print() {
for (int i = 0; i < data.length; i++) {
System.out.print(data[i] + " ");
}
}
}

通過循環，找出最小的數的下標，賦值於k，即k永遠保持待排序數據中最小的數的下標，最后和當前位置i互換數據即可。

三、快速排序（O(nlogn)、不穩定）

快速排序簡稱快排，是一種比較快的排序，適合基本無序的數據，為什么這么說呢？下面我說下快排的思路：

設置兩個指針：i和j，分別指向第一個和最后一個，i像后移動，j向前移動，選第一個數為標准（一般這樣做，當然快排的關鍵就是這個“標准”的選取），從后面開始，找到第一個比標准小的數，互換位置，然后再從前面，找到第一個比標准大的數，互換位置，第一趟的結果就是標准左邊的都小於標准，右邊的都大於標准（但不一定有序），分成兩撥后，繼續遞歸的使用上述方法，最終有序！代碼如下：

[java] view plain copy

package com.xtfggef.algo.sort;
public class QuickSortTest {
static class QuickSort {
public int data[];
private int partition(int array[], int low, int high) {
int key = array[low];
while (low < high) {
while (low < high && array[high] >= key)
high--;
array[low] = array[high];
while (low < high && array[low] <= key)
low++;
array[high] = array[low];
}
array[low] = key;
return low;
}
public int[] sort(int low, int high) {
if (low < high) {
int result = partition(data, low, high);
sort(low, result - 1);
sort(result + 1, high);
}
return data;
}
}
static void print(int data[]) {
for (int i = 0; i < data.length; i++) {
System.out.print(data[i] + " ");
}
}
public static void main(String[] args) {
int data[] = { 20, 3, 10, 9, 186, 99, 200, 96, 3000 };
print(data);
System.out.println();
QuickSort qs = new QuickSort();
qs.data = data;
qs.sort(0, data.length - 1);
print(data);
}
}

https://tool.lu/

class Untitled {
   public static void main(String[] args) {

       int data[] = { 9, 2, 7, 19, 100, 97, 63, 208, 55, 78 };

       kuaisu1(data,0,data.length-1);
       for (int k = 0; k < data.length; k++) {
           System.out.println(data[k]);
       }

   }

   public static void kuaisu1(int[] args,int left,int right) {

       if(left<right){
           int center=kuaisu2(args,left,right);
           kuaisu1(args,left,center-1);
           kuaisu1(args,center+1,right);
       }

   }

   public static int kuaisu2(int[] args,int left,int right) {
       int temp=args[left];

       while(left<right){
           while(left<right&&args[right]>=temp){
               right--;
           }

           args[left]=args[right];
           while(left<right&&args[left]<=temp){
               left++;
           }

           args[right]=args[left];

       }
       args[left]=temp;
       return left;

   }
}

看看上面的圖，基本就明白了。

四、冒泡排序（穩定、基本有序可達O(n)，最壞情況為O(n2)）

冒泡排序是一種很簡單，不論是理解還是時間起來都比較容易的一種排序算法，思路簡單：小的數一點一點向前起泡，最終有序。

[java] view plain copy

package com.xtfggef.algo.sort;
public class BubbleSort {
static int data[] = { 9, 2, 7, 19, 100, 97, 63, 208, 55, 78 };
public static void bubbleSort() {
int i, j, tmp = 0;
for (i = 0; i < data.length - 1; i++) {
for (j = data.length - 1; j > i; j--) {
if (data[j] < data[j - 1]) {
tmp = data[j];
data[j] = data[j - 1];
data[j - 1] = tmp;
}
}
}
}
public static void main(String[] args) {
print();
System.out.println();
bubbleSort();
System.out.println();
print();
}
static void print() {
for (int i = 0; i < data.length; i++) {
System.out.print(data[i] + " ");
}
}
}

public static void main(String[] args) {

       int data[] = { 9, 2, 7, 19, 100, 97, 63, 208, 55, 78 };

           for (int i = 0; i < data.length - 1; i++) {
            for (int j =0; j < data.length -i-1; j++) {
                if (data[j] > data[j + 1]) {
                   int tmp = data[j];
                    data[j] = data[j + 1];
                    data[j + 1] = tmp;
                }
            }
        }
          for (int k = 0; k < data.length; k++) {
              System.out.println(data[k]);
          }

   }

五、堆排序

我們這里不詳細介紹概念，堆的話，大家只要記得堆是一個完全二叉樹（什么是完全二叉樹，請不懂的讀者去查資料），堆排序分為兩種堆，大頂堆和小頂堆，大頂堆的意思就是堆頂元素是整個堆中最大的，小頂堆的意思就是堆頂元素是整個堆中最小的，滿足：任何一非葉節點的關鍵字不大於或者不小於其左右孩子節點的關鍵字。堆排序是一個相對難理解的過程，下面我會較為清楚、詳細的講解一下堆排序。堆排序分為三個過程：

建堆：從一個數組順序讀取元素，建立一個堆（完全二叉樹）

初始化：將堆進行調整，使得堆頂為最大（最大堆）或者最小（最小堆）的元素

維護：將堆頂元素出堆后，需要將堆的最后一個節點補充到堆頂，因為這樣破壞了堆的秩序，所以需要進行維護。下面我們圖示一下：

一般情況，建堆和初始化同步進行，

最后為如下所示，即為建堆、初始化成功。

我們可以觀察下這個最大堆，看出堆頂是整個堆中最大的元素，而且除葉子節點外每個節點都大於其子節點。下面的過程就是當我們輸出堆頂元素后，對堆進行維護。

過程是這樣：將堆頂元素出堆后，用最后一個元素補充堆頂元素，這樣破壞了之前的秩序，需要重新維護堆，在堆頂元素的左右節點中選出較小的和堆頂互換，然后一直遞歸下去，所以每次出一個元素，需要一次維護，堆排序適合解決topK問題，能將復雜度降到nlogK。下面是代碼：

[java] view plain copy

package com.xtfggef.algo.sort;
public class HeapSort {
private static int[] sort = new int[] { 1, 0, 10, 20, 3, 5, 6, 4, 9, 8, 12,
17, 34, 11 };
public static void main(String[] args) {
buildMaxHeapify(sort);
heapSort(sort);
print(sort);
}
private static void buildMaxHeapify(int[] data) {
// 沒有子節點的才需要創建最大堆，從最后一個的父節點開始
int startIndex = getParentIndex(data.length - 1);
// 從尾端開始創建最大堆，每次都是正確的堆
for (int i = startIndex; i >= 0; i--) {
maxHeapify(data, data.length, i);
}
}
/**
* 創建最大堆
*
* @param data
* @param heapSize
* 需要創建最大堆的大小，一般在sort的時候用到，因為最多值放在末尾，末尾就不再歸入最大堆了
* @param index
* 當前需要創建最大堆的位置
*/
private static void maxHeapify(int[] data, int heapSize, int index) {
// 當前點與左右子節點比較
int left = getChildLeftIndex(index);
int right = getChildRightIndex(index);
int largest = index;
if (left < heapSize && data[index] < data[left]) {
largest = left;
}
if (right < heapSize && data[largest] < data[right]) {
largest = right;
}
// 得到最大值后可能需要交換，如果交換了，其子節點可能就不是最大堆了，需要重新調整
if (largest != index) {
int temp = data[index];
data[index] = data[largest];
data[largest] = temp;
maxHeapify(data, heapSize, largest);
}
}
/**
* 排序，最大值放在末尾，data雖然是最大堆，在排序后就成了遞增的
*
* @param data
*/
private static void heapSort(int[] data) {
// 末尾與頭交換，交換后調整最大堆
for (int i = data.length - 1; i > 0; i--) {
int temp = data[0];
data[0] = data[i];
data[i] = temp;
maxHeapify(data, i, 0);
}
}
/**
* 父節點位置
*
* @param current
* @return
*/
private static int getParentIndex(int current) {
return (current - 1) >> 1;
}
/**
* 左子節點position 注意括號，加法優先級更高
*
* @param current
* @return
*/
private static int getChildLeftIndex(int current) {
return (current << 1) + 1;
}
/**
* 右子節點position
*
* @param current
* @return
*/
private static int getChildRightIndex(int current) {
return (current << 1) + 2;
}
private static void print(int[] data) {
int pre = -2;
for (int i = 0; i < data.length; i++) {
if (pre < (int) getLog(i + 1)) {
pre = (int) getLog(i + 1);
System.out.println();
}
System.out.print(data[i] + " |");
}
}
/**
* 以2為底的對數
*
* @param param
* @return
*/
private static double getLog(double param) {
return Math.log(param) / Math.log(2);
}
}

慢慢理解一下，還是容易明白的！

六、歸並排序

歸並排序是建立在歸並操作上的一種有效的排序算法。該算法是采用分治法（Divide and Conquer）的一個非常典型的應用。
首先考慮下如何將將二個有序數列合並。這個非常簡單，只要從比較二個數列的第一個數，誰小就先取誰，取了后就在對應數列中刪除這個數。然后再進行比較，如果有數列為空，那直接將另一個數列的數據依次取出即可。

[java] view plain copy

package com.xtfggef.algo.sort;
public class SortTest {
// 將有序數組a[]和b[]合並到c[]中
static void MemeryArray(int a[], int n, int b[], int m, int c[]) {
int i, j, k;
i = j = k = 0;
while (i < n && j < m) {
if (a[i] < b[j])
c[k++] = a[i++];
else
c[k++] = b[j++];
}
while (i < n)
c[k++] = a[i++];
while (j < m)
c[k++] = b[j++];
}
public static void main(String[] args) {
int a[] = { 2, 7, 8, 10, 299 };
int b[] = { 5, 9, 14, 20, 66, 88, 92 };
int c[] = new int[a.length + b.length];
MemeryArray(a, 5, b, 7, c);
print(c);
}
private static void print(int[] c) {
for (int i = 0; i < c.length; i++) {
System.out.print(c[i] + " ");
}
}
}

可以看出合並有序數列的效率是比較高的，可以達到O(n)。解決了上面的合並有序數列問題，再來看歸並排序，其的基本思路就是將數組分成二組A，B，如果這二組組內的數據都是有序的，那么就可以很方便的將這二組數據進行排序。如何讓這二組組內數據有序了？可以將A，B組各自再分成二組。依次類推，當分出來的小組只有一個數據時，可以認為這個小組組內已經達到了有序，然后再合並相鄰的二個小組就可以了。這樣通過先遞歸的分解數列，再合並數列就完成了歸並排序。下面是歸並排序代碼：

[java] view plain copy

package com.xtfggef.algo.sort;
public class MergeSort {
private static void mergeSort(int[] data, int start, int end) {
if (end > start) {
int pos = (start + end) / 2;
mergeSort(data, start, pos);
mergeSort(data, pos + 1, end);
merge(data, start, pos, end);
}
}
private static void merge(int[] data, int start, int pos, int end) {
int len1 = pos - start + 1;
int len2 = end - pos;
int A[] = new int[len1 + 1];
int B[] = new int[len2 + 1];
for (int i = 0; i < len1; i++) {
A[i] = data[i + start - 1];
}
A[len1] = Integer.MAX_VALUE;
for (int i = 0; i < len2; i++) {
B[i] = data[i + pos];
}
B[len2] = Integer.MAX_VALUE;
int m = 0, n = 0;
for (int i = start - 1; i < end; i++) {
if (A[m] > B[n]) {
data[i] = B[n];
n++;
} else {
data[i] = A[m];
m++;
}
}
}
private static void print(int[] data) {
for (int i = 0; i < data.length; i++) {
System.out.print(data[i] + " ");
}
}
public static void main(String args[]) {
int data[] = { 8, 16, 99, 732, 10, 1, 29, 66 };
print(data);
System.out.println();
mergeSort(data, 1, data.length);
print(data);
}
}

七、希爾排序（不穩定、O（nlogn））

d1 = n/2，d2 = d1/2 ...

舉例一下：{9,8,7,6,5,4,3,2,1,0} 10個數，現分為5組(9,4),(8,3),(7,2),(6,1),(5,0)，然后分別對每組進行直接插入排序得到：

(4,9),(3,8),(2,7),(1,6),(0,5)，再將這5組分為2組（4,3,2,1,0）,（9,8,7,6,5）分別對這兩組進行直插排序，得：(0,1,2,3,4),(5,6,7,8,9)最終有序。

[java] view plain copy

package com.xtfggef.algo.sort;
public class ShellSort {
static void shellsort(int[] a, int n) {
int i, j, temp;
int gap = 0;
while (gap <= n) {
gap = gap * 3 + 1;
}
while (gap > 0) {
for (i = gap; i < n; i++) {
j = i - gap;
temp = a[i];
while ((j >= 0) && (a[j] > temp)) {
a[j + gap] = a[j];
j = j - gap;
}
a[j + gap] = temp;
}
gap = (gap - 1) / 3;
}
}
static void print(int data[]) {
for (int i = 0; i < data.length; i++) {
System.out.print(data[i] + " ");
}
}
public static void main(String[] args) {
int data[] = { 2, 68, 7, 19, 1, 28, 66, 200 };
print(data);
System.out.println();
shellsort(data, data.length);
print(data);
}
}

八、多路快排

JDK1.8中Arrays.sort()采用的排序算法，具有較快的時間復雜度和穩定性，基本思路為：

1. 選取兩個中軸P1, P2。

2. 假設P1<P2，否則交換。

3. 過程中原數組會分為四個部分：小於中軸1，大於中軸2，介於兩個中軸之間，未排序部分（剛開始除了兩個中軸，其它元素都屬於這部分）。

4. 開始后，從未排序部分選取一個數，和兩個中軸作比較，然后放到合適的位置，一直到未排序部分無數據，結束一趟排序。

5. 遞歸地處理子數組，穩定排序，時間復雜度穩定為O(nlogn)。

詳情可以參見我的另一篇博文《Java之美[從菜鳥到高手演練]之Arrays類及其方法分析》

九、其他排序

下面的一段轉載自博友@清蒸水皮 --- 補充於2015年1月14日

==============================================

計數排序

當輸入的元素是 n 個 0 到 k 之間的整數時，它的運行時間是 O(n + k)。計數排序不是比較排序，排序的速度快於任何比較排序算法。

由於用來計數的數組C的長度取決於待排序數組中數據的范圍（等於待排序數組的最大值與最小值的差加上1），這使得計數排序對於數據范圍很大的數組，需要大量時間和內存。例如：計數排序是用來排序0到100之間的數字的最好的算法，但是它不適合按字母順序排序人名。但是，計數排序可以用在基數排序中的算法來排序數據范圍很大的數組。

算法的步驟如下：

找出待排序的數組中最大和最小的元素
統計數組中每個值為i的元素出現的次數，存入數組C的第i項
對所有的計數累加（從C中的第一個元素開始，每一項和前一項相加）
反向填充目標數組：將每個元素i放在新數組的第C(i)項，每放一個元素就將C(i)減去1

貼上代碼：

[cpp] view plain copy

#include <stdio.h>
#include <stdlib.h>
#include <time.h>
//對於排序的關鍵字范圍，一定是0-99
#define NUM_RANGE (100)
void print_arr(int *arr, int n)
{
int i;
for(i=0; i<n; i++){
if(!i){
printf("%d", arr[i]);
}else{
printf(" %d", arr[i]);
}
}
printf("\n");
}
/*
算法的步驟如下：
1.找出待排序的數組中最大和最小的元素
2.統計數組中每個值為i的元素出現的次數，存入數組C的第i項
3.對所有的計數累加（從C中的第一個元素開始，每一項和前一項相加）
4.反向填充目標數組：將每個元素i放在新數組的第C(i)項，每放一個元素就將C(i)減去1
*/
void counting_sort(int *ini_arr, int *sorted_arr, int n)
{
int *count_arr = (int *)malloc(sizeof(int) * NUM_RANGE);
int i, j, k;
//統計數組中，每個元素出現的次數
for(k=0; k<NUM_RANGE; k++){
count_arr[k] = 0;
}
for(i=0; i<n; i++){
count_arr[ini_arr[i]]++;
}
for(k=1; k<NUM_RANGE; k++){
count_arr[k] += count_arr[k-1];
}
for(j=n-1 ; j>=0; j--){
int elem = ini_arr[j];
int index = count_arr[elem]-1;
sorted_arr[index] = elem;
count_arr[elem]--;
}
free(count_arr);
}
int main(int argc, char* argv[])
{
int n;
if(argc < 2){
n = 10;
}else{
n = atoi(argv[1]);
}
int i;
int *arr = (int *)malloc(sizeof(int) * n);
int *sorted_arr = (int *)malloc(sizeof(int) *n);
srand(time(0));
for(i=0; i<n; i++){
arr[i] = rand() % NUM_RANGE;
}
printf("ini_array: ");
print_arr(arr, n);
counting_sort(arr, sorted_arr, n);
printf("sorted_array: ");
print_arr(sorted_arr, n);
free(arr);
free(sorted_arr);
return 0;
}

桶排序

桶排序的基本思想

假設有一組長度為N的待排關鍵字序列K[1....n]。首先將這個序列划分成M個的子區間(桶) 。然后基於某種映射函數，將待排序列的關鍵字k映射到第i個桶中(即桶數組B的下標 i) ，那么該關鍵字k就作為B[i]中的元素(每個桶B[i]都是一組大小為N/M的序列)。接着對每個桶B[i]中的所有元素進行比較排序(可以使用快排)。然后依次枚舉輸出B[0]....B[M]中的全部內容即是一個有序序列。假如待排序列K= {49、 38 、 35、 97 、 76、 73 、 27、 49 }。這些數據全部在1—100之間。因此我們定制10個桶，然后確定映射函數f(k)=k/10。則第一個關鍵字49將定位到第4個桶中(49/10=4)。依次將所有關鍵字全部堆入桶中，並在每個非空的桶中進行快速排序。

桶排序代價分析
桶排序利用函數的映射關系，減少了幾乎所有的比較工作。實際上，桶排序的f(k)值的計算，其作用就相當於快排中划分，已經把大量數據分割成了基本有序的數據塊(桶)。然后只需要對桶中的少量數據做先進的比較排序即可。

對N個關鍵字進行桶排序的時間復雜度分為兩個部分：
(1) 循環計算每個關鍵字的桶映射函數，這個時間復雜度是O(N)。
(2) 利用先進的比較排序算法對每個桶內的所有數據進行排序，其時間復雜度為 ∑ O(Ni*logNi) 。其中Ni 為第i個桶的數據量。

很顯然，第(2)部分是桶排序性能好壞的決定因素。盡量減少桶內數據的數量是提高效率的唯一辦法(因為基於比較排序的最好平均時間復雜度只能達到O(N*logN)了)。因此，我們需要盡量做到下面兩點：
(1) 映射函數f(k)能夠將N個數據平均的分配到M個桶中，這樣每個桶就有[N/M]個數據量。
(2) 盡量的增大桶的數量。極限情況下每個桶只能得到一個數據，這樣就完全避開了桶內數據的“比較”排序操作。當然，做到這一點很不容易，數據量巨大的情況下，f(k)函數會使得桶集合的數量巨大，空間浪費嚴重。這就是一個時間代價和空間代價的權衡問題了。

對於N個待排數據，M個桶，平均每個桶[N/M]個數據的桶排序平均時間復雜度為：
O(N)+O(M*(N/M)*log(N/M))=O(N+N*(logN-logM))=O(N+N*logN-N*logM)
當N=M時，即極限情況下每個桶只有一個數據時。桶排序的最好效率能夠達到O(N)。

總結：桶排序的平均時間復雜度為線性的O(N+C)，其中C=N*(logN-logM)。如果相對於同樣的N，桶數量M越大，其效率越高，最好的時間復雜度達到O(N)。當然桶排序的空間復雜度為O(N+M)，如果輸入數據非常龐大，而桶的數量也非常多，則空間代價無疑是昂貴的。此外，桶排序是穩定的。
我個人還有一個感受：在查找算法中，基於比較的查找算法最好的時間復雜度也是O(logN)。比如折半查找、平衡二叉樹、紅黑樹等。但是Hash表卻有O(C)線性級別的查找效率(不沖突情況下查找效率達到O(1))。大家好好體會一下：Hash表的思想和桶排序是不是有一曲同工之妙呢?

基數排序

上面的問題是多關鍵字的排序，但單關鍵字也仍然可以使用這種方式。
比如字符串“abcd” “aesc” "dwsc" "rews"就可以把每個字符看成一個關鍵字。另外還有整數 425、321、235、432也可以每個位上的數字為一個關鍵字。

基數排序的思想就是將待排數據中的每組關鍵字依次進行桶分配。比如下面的待排序列：
278、109、063、930、589、184、505、269、008、083
我們將每個數值的個位，十位，百位分成三個關鍵字： 278 -> k1(個位)=8 ，k2(十位)=7 ，k3=(百位)=2。
然后從最低位個位開始(從最次關鍵字開始)，對所有數據的k1關鍵字進行桶分配(因為，每個數字都是 0-9的，因此桶大小為10)，再依次輸出桶中的數據得到下面的序列。
930、063、083、184、505、278、008、109、589、269
再對上面的序列接着進行針對k2的桶分配，輸出序列為：
505、008、109、930、063、269、278、083、184、589
最后針對k3的桶分配，輸出序列為：
008、063、083、109、184、269、278、505、589、930

性能分析
很明顯，基數排序的性能比桶排序要略差。每一次關鍵字的桶分配都需要O(N)的時間復雜度，而且分配之后得到新的關鍵字序列又需要O(N)的時間復雜度。假如待排數據可以分為d個關鍵字，則基數排序的時間復雜度將是O(d*2N) ，當然d要遠遠小於N，因此基本上還是線性級別的。基數排序的空間復雜度為O(N+M)，其中M為桶的數量。一般來說N>>M，因此額外空間需要大概N個左右。

但是，對比桶排序，基數排序每次需要的桶的數量並不多。而且基數排序幾乎不需要任何“比較”操作，而桶排序在桶相對較少的情況下，桶內多個數據必須進行基於比較操作的排序。因此，在實際應用中，基數排序的應用范圍更加廣泛。

=============================================

文章最后，給大家推薦一個數據結構學習的網站，有flash演示的：http://www.tyut.edu.cn/kecheng1/site01/index.asp

借鑒：http://blog.csdn.net/zhangerqing/article/details/8831542

免責聲明！

本站轉載的文章為個人學習借鑒使用，本站對版權不負任何法律責任。如果侵犯了您的隱私權益，請聯系本站郵箱yoyou2525@163.com刪除。

猜您在找 Java常見的幾種排序算法-插入、選擇、冒泡、快排、堆排等排序算法合集（冒泡，選擇，插入，堆排，快排） JS數據結構與算法 - 排序（冒泡、選擇、插入、歸並、快排）常見排序算法總結與實現(冒泡、插入、選擇、希爾、堆排序、歸並、快排) 基本排序算法（冒泡，快排，插入，希爾，選擇，歸並）排序算法之冒泡和快排《數據結構與算法之美》——冒泡排序、插入排序、選擇排序重學數據結構和算法（四）之冒泡排序、插入排序、選擇排序在路上---學習篇（一）Python 數據結構和算法 (2) -- 冒泡排序、選擇排序、插入排序 Java數據結構和算法（三）——冒泡、選擇、插入排序算法

數據結構和算法 （一）常見的幾種排序算法-插入、選擇、冒泡、快排、堆排等

免責聲明！

數據結構和算法（一）常見的幾種排序算法-插入、選擇、冒泡、快排、堆排等