排序算法小结

 

转自：http://blog.csdn.net/caryaliu/article/details/8280647

从以下几个方面来比较排序算法：

1. 算法的时间和空间复杂度

2. 排序的稳定性

3. 算法结构的复杂度

4. 参加排序的数据规模


排序的稳定性：

稳定排序方法: 插入排序、冒泡排序、二路归并排序、基数排序是稳定排序算法；

不稳定排序方法: 选择排序、谢尔排序、快速排序、堆积排序是不稳定排序算法。


算法复杂度比较：

 

各种内排序算法的时间、空间复杂度
排序方法平均时间最坏情况辅助空间
插入排序 O(n*n) O(n*n) O(1)
谢尔排序 O(n*log2n) O(n*log2n) O(1)
泡排序 O(n*n) O(n*n) O(1)
快速排序 O(n*log2n) O(n*n) O(log2n)
选择排序 O(n*n) O(n*n) O(1)
堆积排序 O(n*log2n) O(n*log2n) O(1)
归并排序 O(n*log2n) O(n*log2n) O(n)
基数排序 O(d*(n+r)) O(d*(n+r)) O(n+r)

有结论如下：

1. 平均情况下，谢尔排序、快速排序、堆积排序、归并排序都能达到较快的排序速度，快速排序最快，堆积排序空间消费最省。

2. 平均情况下，插入排序和泡排序的排序速度较慢，但当参加排序的序列开始就局部有序时，这两种排序算法就能够达到较快的排序速度。最后情况下速度为 O(n), 比情况 1 中叙述的4中方法都好，辅助空间消费也少。所以当 n 较小或者序列开始就局部有序时，可选择这两种方法。

3. 基数排序方法消费的辅助空间较多，但其时间复杂度可简化为O(dn); 当元素的位数较少时，可继续简化为O(n), 这种情况下也能达到较快的排序速度，另外，归并排序需要的辅助空间也较多。

4. 从算法结构的简单性来看，插入排序、泡排序、选择排序比较简单和直接；而谢尔排序、快速排序、堆积排序以及归并排序都可以看做对某一种排序算法的进一步改进，相对而言，改进后的算法都比较复杂。

5. 从参加排序的数据序列的规模大小来看，n越小，采用简单排序方法就越合适；n越大，采用改进的排序方法越合适。这是因为n越小，n*n 与 log2n 的差距越小。


以下是在考虑内排序算法的优缺点后，在某些情况下比较适合的算法选择：

1. 当参加排序的数据规模较大，关键字元素分布比较随机，并且不要求排序稳定性时，宜采用快速排序法。

2. 当参加排序的数据规模较大，内存空间又允许，并且有排序稳定性要求，宜采用归并排序法。

3. 当参加排序的数据规模较大，元素分布可能出现升序或者逆序的情况，并且对排序的稳定性无要求时，宜采用插入排序方法。

4. 当参加排序的数据规模较小（如小于100），元素基本有序（升序），或者分布也比较随机，并且有排序稳定性要求时，宜采用插入排序方法。

5. 当参加排序的数据规模n较小，对排序稳定性又不要求时，宜采用选择排序。


插入排序、选择排序、归并排序都比较容易在链表上实现，当利用链表作为存储结构时，可以避免将大量时间花费在元素的位置移动上。


算法描述：

1. 插入排序：

 

[cpp] view plaincopyprint?
  1. /* 简单插入排序 
  2.  * |data|中存储数组元素 
  3.  * |len|是数组大小 
  4.  * 1.  
  5.  *  需要 |len - 1| 趟排序，每一趟排序将未排序的序列中第一个元素插入到已排序的序列中 
  6.  * 2. 
  7.  *  每一趟排序寻找插入位置的比较次数不定，但是至少需要一次 
  8.  * 3. 
  9.  *  最好的情况，原序列已是升序排列，则需要|n-1|趟排序，每一趟排序进行一次元素间的比较，时间复杂度O(n) 
  10.  * 4. 
  11.  *  最坏的情况，原序列是降序排列，同样需要|n-1|趟排序，第 i（i>=1 && i<len）趟排序需进行 i 次元素间比较，时间复杂度O(n*n) 
  12.  * 5. 
  13.  *  平均时间复杂度O(n*n) 
  14.  * 6. 
  15.  *  插入排序是稳定性排序 
  16.  * */  
  17. void simple_insert(int *data, int len)  
  18. {  
  19.     if(data == NULL || len < 1)  
  20.         return;  
  21.   
  22.     int temp, i, j;  
  23.     for(i = 1; i < len; ++i) {  
  24.         temp = data[i];  
  25.         j = i - 1;  
  26.         while(j >= 0 && temp < data[j]) {  
  27.             data[j+1] = data[j--];  
  28.         }  
  29.         data[j+1] = temp;  
  30.     }  
  31. }  
  32.   
  33. /* 折半插入排序 
  34.  * 与简单插入排序相比 
  35.  *  1. 折半插入排序减少了寻找插入位置时的元素之间的比较次数 
  36.  *  2. 并未减少元素的移动次数和排序所需的趟数 
  37.  *  3. 时间复杂度降为O(n*log2n) 
  38.  */  
  39. void binary_insert(int *data, int len)  
  40. {  
  41.     if(data == NULL || len < 1)  
  42.         return;  
  43.   
  44.     int temp, i, j, low, mid, high;  
  45.     for(i = 1; i < len; ++i) {  
  46.         temp = data[i];  
  47.         low = 0;  
  48.         high = i - 1;  
  49.         while(low <= high) {  
  50.             mid = (low + high)/2;  
  51.             if(temp < data[mid])  
  52.                 high = mid - 1;  
  53.             else  
  54.                 low = mid + 1;  
  55.         }  
  56.   
  57.         for(j = i; j > low; --j)  
  58.             data[j] = data[j-1];  
  59.   
  60.         data[low] = temp;  
  61.     }  
  62. }  


2. 谢尔排序

 

[cpp] view plaincopyprint?
  1. /* 谢尔排序，又称缩小增量排序法，是对直接插入排序法的一种改进 
  2.  * 1. 
  3.  *  时间复杂度在O(n*log2n) 和 O(n*n)之间 
  4.  * 2. 
  5.  *  谢尔排序是一种不稳定排序，不适合在链表结构上实现的排序算法 
  6.  * */  
  7. void shellSort(int *data, int len)  
  8. {  
  9.     if(data == NULL || len < 1)  
  10.         return;  
  11.   
  12.     unsigned int gap = len;  
  13.     int i,j,temp;  
  14.     while(gap > 0) {  
  15.         gap >>= 1;  
  16.         for(i = gap; i < len; ++i) {  
  17.             j = i - gap;  
  18.             temp = data[i];  
  19.             while(j >= 0 && temp < data[j]) {  
  20.                 data[j+gap] = data[j];  
  21.                 j -= gap;  
  22.             }  
  23.   
  24.             data[j+gap] = temp;  
  25.         }  
  26.     }  
  27. }  


3. 泡排序

 

[cpp] view plaincopyprint?
  1. /* 冒泡排序 
  2.  * 1. 
  3.  *  至少需要进行一趟排序，此时是原始序列已经升序排列的情况，需进行|len - 1|次元素间的比较，时间复杂度O(n) 
  4.  * 2. 
  5.  *  最多进行|len - 1|趟排序（最小值处于原始序列最后），第 i(i>=1 && i<=len-1) 趟排序需要进行|len - i|次元素间的比较, 时间复杂度O(n*n) 
  6.  * 3. 
  7.  *  平均时间复杂度是O(n*n) 
  8.  * 4. 
  9.  *  冒泡排序是稳定性排序，适用于参加排序的数据量较小并且序列的初始状态为基本有序的情况 
  10.  * */  
  11. void bubbleSort(int *data, int len)  
  12. {  
  13.     if(data == NULL || len < 1)  
  14.         return;  
  15.   
  16.     int flag = 1;  
  17.     int i, j, temp;  
  18.     i = len - 1;  
  19.     while(i > 0 && flag == 1) {  
  20.         flag = 0;  
  21.         for(j = 0; j < i; ++j) {  
  22.             if(data[j] > data[j+1]) {  
  23.                 temp = data[j];  
  24.                 data[j] = data[j+1];  
  25.                 data[j+1] = temp;  
  26.   
  27.                 flag = 1;  
  28.             }  
  29.         }  
  30.   
  31.         --i;  
  32.     }  
  33. }  


4. 快速排序

 

[cpp] view plaincopyprint?
  1. /* randomInRange函数： 
  2.  * 产生[start, end] 之间的随机数，包括start, end两个数 
  3.  * */  
  4. int randomInRange(int start, int end)  
  5. {  
  6.     srand(time(NULL));  
  7.   
  8.     return start + rand()%(end-start+1);  
  9. }  
  10.   
  11. /*  
  12.  * 交换elem1, elem2的值 
  13.  */  
  14. void swapElem(int *elem1, int *elem2)  
  15. {  
  16.     int temp = *elem1;  
  17.     *elem1 = *elem2;  
  18.     *elem2 = temp;  
  19. }  
  20.   
  21. /* partition函数： 
  22.  * 在data序列的[start, end]之间随机选取一个元素值作为分界元素vp， 
  23.  * 该分界元素vp左边的值都小于等于vp, 右边的值都大于等于vp, 
  24.  * 函数返回该分界元素在序列中的索引位置 
  25.  * */  
  26. int partition(int *data, int len, int start, int end)  
  27. {  
  28.     if(data == NULL || len < 1 || start < 0 || end >= len) {  
  29.         printf("invalid parameters.");  
  30.         exit(1);  
  31.     }  
  32.   
  33.     int index = randomInRange(start, end);  
  34.     swapElem(&data[index], &data[end]);  
  35.     int small = start - 1;  
  36.   
  37.     for(index = start; index < end; ++index) {  
  38.         if(data[index] < data[end]) {  
  39.             ++small;  
  40.             if(small != index)  
  41.                 swapElem(&data[index], &data[small]);  
  42.         }  
  43.     }  
  44.     swapElem(&data[++small], &data[end]);  
  45.   
  46.     return small;  
  47. }  
  48.   
  49. /* 快速排序递归算法： 
  50.  * 1.  
  51.  *  时间复杂度是O(n*log2n) 
  52.  * 2.  
  53.  *  快速排序是不稳定排序，不适合在链表结构上实现的排序算法 
  54.  * 3. 
  55.  *  每次排序时如果各个部分的分界元素恰好就是最大值元素时，快速排序就会倒退为"慢速排序", 此时并未把序列分界为两个子序列 
  56.  * */  
  57. void quickSort(int *data, int len, int start, int end)  
  58. {  
  59.     if(start == end)  
  60.         return;  
  61.   
  62.     int index = partition(data, len, start, end);  
  63.     if(index > start)  
  64.         quickSort(data, len, start, index - 1);  
  65.     if(index < end)  
  66.         quickSort(data, len, index + 1, end);  
  67. }  


5. 选择排序

 

[cpp] view plaincopyprint?
  1. /* 选择排序 
  2.  * 1.  
  3.  *  总共需要|len - 1|趟排序，且第 i（i>=1 && i<=len-1) 趟排序需要进行 |len - i|次元素间的比较 
  4.  * 2. 
  5.  *  时间复杂度与初始序列的状态无关，都是O(n*n) 
  6.  * 3. 
  7.  *  选择排序是不稳定排序，例如(49, 38, 65, 97, 49, 13, 27) 
  8.  * */  
  9. void selectSort(int *data, int len)  
  10. {  
  11.     if(data == NULL || len < 1)  
  12.         return;  
  13.   
  14.     int i, j, minIndex;  
  15.     for(i = 0; i < len - 1; ++i) {  
  16.         minIndex = i;  
  17.         j = i + 1;  
  18.         while(j < len) {  
  19.             if(data[j] < data[minIndex])  
  20.                 minIndex = j;  
  21.             ++j;  
  22.         }  
  23.   
  24.         if(minIndex != i) {  
  25.             int temp = data[i];  
  26.             data[i] = data[minIndex];  
  27.             data[minIndex] = temp;  
  28.         }  
  29.     }  
  30. }  


6. 堆积排序

 

[cpp] view plaincopyprint?
  1. /* adjust函数： 
  2.  * |len| 数组序列的大小 
  3.  * |root| 数组中某一元素的索引 
  4.  * 以结点root为根结点的子树不是堆积，但结点root的左右子树都是堆积， 
  5.  * adjust函数将把第root个结点作为根结点的子树调整为一个新的堆积 
  6.  * */  
  7. void adjust(int *data, int len, int root)  
  8. {  
  9.     int temp = data[root];  
  10.     int i = root * 2;  
  11.   
  12.     while(i <= len) {  
  13.         if(i < len && data[i] < data[i + 1])  
  14.             ++i;  
  15.   
  16.         if(temp >= data[i])  
  17.             break;  
  18.   
  19.         data[i/2] = data[i];  
  20.         i *= 2;  
  21.     }  
  22.   
  23.     data[i/2] = temp;  
  24. }  
  25.   
  26. /* 堆排序： 
  27.  * |len| data序列中最后一个元素的索引号, 也是参加排序的元素个数, 
  28.  * 注意不是data序列的元素个数 
  29.  * 1.  
  30.  *  data序列中第1个元素（data[0]）不参加排序 
  31.  * 2.  
  32.  *  总共执行|len - 1|趟排序，每一趟排序确定未排序序列中的最大值的位置，并执行一次adjust函数 
  33.  * 3. 
  34.  *  无论是最坏情况还是平均情况，堆积排序的时间复杂度都是O(n*log2n) 
  35.  * 4. 
  36.  *  堆积排序的空间复杂度是O(1), 适合于len较大的序列排序 
  37.  * 5. 
  38.  *  堆积排序不适合在链表上实现 
  39.  * 6. 
  40.  *  堆积排序是不稳定排序，例如(5, 4, 3, 2, 2, 2, 1) 
  41.  */  
  42. void heapSort(int *data, int len)  
  43. {  
  44.     if(data == NULL || len < 1)  
  45.         return;  
  46.   
  47.     int i;  
  48.     for(i = len/2; i > 0; --i) {  
  49.         adjust(data, len, i);  
  50.     }  
  51.   
  52.     int temp;  
  53.     for(i = len; i > 1; --i) {  
  54.         temp = data[1];  
  55.         data[1] = data[i];  
  56.         data[i] = temp;  
  57.   
  58.         adjust(data, i-1, 1);  
  59.     }  
  60. }  


7. 归并排序

 

[cpp] view plaincopyprint?
  1. /* merge函数： 
  2.  * 将source[start..mid]和source[mid+1..end]中的元素归并有序序列des[start..end] 
  3.  * 
  4.  * */  
  5. void merge(int *source, int *des, int start, int mid, int end)  
  6. {  
  7.     int i = start;  
  8.     int j = mid + 1;  
  9.     int k = start;  
  10.   
  11.     while(i <= mid && j <= end) {  
  12.        // if(source[i] <= source[j])  
  13.        //     des[k++] = source[i++];  
  14.        // else  
  15.        //     des[k++] = source[j++];  
  16.         des[k++] = source[i] <= source[j] ? source[i++] : source[j++];  
  17.     }  
  18.   
  19.     while(i <= mid)  
  20.         des[k++] = source[i++];  
  21.     while(j <= end)  
  22.         des[k++] = source[j++];  
  23. }  
  24.   
  25. /* mpass函数： 
  26.  * 将参加排序的序列分成若干个长度为t的，且各自按值有序的子序列， 
  27.  * 然后多次调用归并子算法merge将所有两两相邻成对的子序列合并成 
  28.  * 若干个长度为2t的，且各自按值有序的子序列。 
  29.  *  
  30.  * 若最后一趟排序时，剩下的元素不足2t个元素： 
  31.  * 1. 
  32.  *  若剩余元素个数大于t，则再调用一次merge算法将剩余的两个不等长子序列合并为一个子序列 
  33.  * 2. 
  34.  *  若剩余元素个数小于等于t，则直接将所有剩余元素依次复制到前一个子序列的后面 
  35.  * */  
  36. void mpass(int *source, int *des, int len, int t)  
  37. {  
  38.     int i = 0;  
  39.     if(len - i >= 2*t) {  
  40.         merge(source, des, i, i + t - 1, i + 2 * t - 1);  
  41.         i += 2 * t;  
  42.     }  
  43.   
  44.     if(len - i > t)  
  45.         merge(source, des, i, i + t - 1, len - 1);  
  46.     else {  
  47.         for(; i < len; ++i)  
  48.             des[i] = source[i];   
  49.     }  
  50. }  
  51.   
  52. /* mergeSort排序： 
  53.  * |flag|，若flag = -1，则表示输入参数错误； 
  54.  * 若flag = 1， 则表示排好序的元素存放于data序列中 
  55.  * 若flag = 0，则表示排好序的元素存放于des序列中 
  56.  * 1.  
  57.  *  总共会进行log2n趟排序，每趟排序调用mpass函数，mpass的时间复杂度为O(n)，二路归并排序的时间复杂度为O(nlog2n) 
  58.  * 2. 
  59.  *  排序过程中需要同原始序列同等大小的辅助空间，空间复杂度为O(n) 
  60.  * 3. 
  61.  *  二路归并排序是稳定性排序 
  62.  * 4. 
  63.  *  二路归并排序的时间复杂度与序列的初始状态无关 
  64.  */  
  65. int mergeSort(int *data, int *des, int len)  
  66. {  
  67.     int flag = -1;  
  68.     if(data == NULL || len < 1)  
  69.         return flag;  
  70.   
  71.     int t = 1;  
  72.     flag = 1;  
  73.     while(t < len) {  
  74.         mpass(data, des, len, t);  
  75.         flag = 0;  
  76.   
  77.         t *= 2;  
  78.         if(t < len) {  
  79.             mpass(des, data, len, t);  
  80.             t *= 2;  
  81.             flag = 1;  
  82.         }  
  83.     }  
  84.   
  85.     return flag;  
  86. }  


8. 基数排序

[cpp] view plaincopyprint?
    1. /* 
    2.  * 定义的存储数据元素的结点 
    3.  */  
    4. typedef struct Node {  
    5.     int data;  
    6.     struct Node *next;  
    7. }QLink;  
    8.   
    9. /* maxDig函数： 
    10.  * 找出data序列所有元素中最长的位数maxd并返回 
    11.  * */  
    12. int maxDig(int *data, int len)  
    13. {  
    14.     int maxd = 0;  
    15.     int maxCurD = 1;  
    16.   
    17.     int base = 10;  
    18.     for(int i = 0; i < len; ++i) {  
    19.         maxCurD = 1;  
    20.         base = 10;  
    21.         while(data[i] >= base) {  
    22.             ++maxCurD;  
    23.             if(maxd < maxCurD)  
    24.                 maxd = maxCurD;  
    25.             base *= 10;  
    26.         }  
    27.     }  
    28.   
    29.     return maxd;  
    30. }  
    31.   
    32. /* 
    33.  * 将data序列中所有元素均存储到链表中，并返回链表头结点head 
    34.  */  
    35. QLink* transferArrToQLink(int *data, int len)  
    36. {  
    37.     if(data == NULL || len < 1)  
    38.         return NULL;  
    39.   
    40.     QLink *head = NULL;  
    41.     QLink *rear = NULL;  
    42.   
    43.     for(int i = 0; i < len; ++i) {  
    44.         QLink *cur = (QLink *)malloc(sizeof(QLink));  
    45.         cur->data = data[i];  
    46.         cur->next = NULL;  
    47.         if(head == NULL)  
    48.             head = cur;  
    49.         else  
    50.             rear->next = cur;  
    51.         rear = cur;  
    52.     }  
    53.   
    54.     return head;  
    55. }  
    56.   
    57. /* 
    58.  * 释放链表中所有元素结点 
    59.  */  
    60. void freeQLink(QLink *phead)  
    61. {  
    62.     QLink *toFree = NULL;  
    63.     while(phead != NULL) {  
    64.         toFree = phead;  
    65.         phead = phead->next;  
    66.         free(toFree);  
    67.     }  
    68. }  
    69.   
    70. /* 
    71.  * 获取num 中从右边数第index位的数字，index从0 开始计数 
    72.  * 
    73.  */  
    74. int getCurPlaceV(int num, int index)  
    75. {  
    76.     int placeValue;  
    77.     int i = 0;  
    78.     while(i <= index) {  
    79.         placeValue = num%10;  
    80.         num /= 10;  
    81.         ++i;  
    82.     }  
    83.   
    84.     return placeValue;  
    85. }  
    86.   
    87. /* 
    88.  * |data| 数据元素序列，|len|数据元素的个数，|radix|是基数 
    89.  */  
    90. void radixSort(int *data, int len, int radix)  
    91. {  
    92.     int maxd = maxDig(data, len);  
    93.     printf("maxd = %d\n", maxd);  
    94.     QLink *phead = transferArrToQLink(data, len);  
    95.   
    96.     QLink *Front[radix], *End[radix];  
    97.     QLink *q, *rear;  
    98.     int i, j, curplaceV;  
    99.     for(i = 0; i < maxd; ++i) {  
    100.         printf("the %d times sort\n", i);  
    101.         for(j = 0; j < radix; ++j)  
    102.             Front[j] = End[j] = NULL;  
    103.   
    104.         q = phead;  
    105.         while(q != NULL) {  
    106.             curplaceV = getCurPlaceV(q->data, i);  
    107.             if(Front[curplaceV] == NULL)  
    108.                 Front[curplaceV] = q;  
    109.             else  
    110.                 End[curplaceV]->next = q;  
    111.             End[curplaceV] = q;  
    112.   
    113.             q = q->next;  
    114.         }  
    115.   
    116.         j = 0;  
    117.         while(Front[j] == NULL)  
    118.             ++j;  
    119.   
    120.         phead = Front[j];  
    121.         rear = End[j];  
    122.         ++j;  
    123.         for(; j < radix; ++j) {  
    124.             if(Front[j] != NULL) {  
    125.                 rear->next = Front[j];  
    126.                 rear = End[j];  
    127.             }  
    128.         }  
    129.         rear->next = NULL;  
    130.     }  
    131.   
    132.     q = phead;  
    133.     i = 0;  
    134.     while(q != NULL) {  
    135.         data[i++] = q->data;  
    136.         q = q->next;  
    137.     }  
    138.   
    139.     freeQLink(phead);  
    140.     phead = NULL;  
    141. } 
posted on 2014-04-06 17:11  猿人谷  阅读(2385)  评论(0)  编辑  收藏  举报

Powered by: 博客园 Copyright © 2024 猿人谷
Powered by .NET 8.0 on Kubernetes