算法排序算法之桶排序

Posted 玩户外的IT人

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了算法排序算法之桶排序相关的知识，希望对你有一定的参考价值。

在前几回我们已经对、、、、、、、计数排序做了说明分析。本回，将对桶排序进行相关说明分析。

一、排序算法系列目录说明

  • 冒泡排序（Bubble Sort）

  • 插入排序（Insertion Sort）

  • 希尔排序（Shell Sort）

  • 选择排序（Selection Sort）

  • 快速排序（Quick Sort）

  • 归并排序（Merge Sort）

  • 堆排序（Heap Sort）

  • 计数排序（Counting Sort）

  • 桶排序（Bucket Sort）

  • 基数排序（Radix Sort

二、桶排序（BucketSort）

桶排序（Bucket sort）或所谓的箱排序，是一个排序算法，工作的原理是将数组分到有限数量的桶里。每个桶再个别排序（有可能再使用别的排序算法或是以递归方式继续使用桶排序进行排序），最后依次把各个桶中的记录列出来记得到有序序列。桶排序是鸽巢排序的一种归纳结果。当要被排序的数组内的数值是均匀分配的时候，桶排序使用线性时间（Θ(n)）。但桶排序并不是比较排序，他不受到O(n log n)下限的影响。

1.基本思想

桶排序的思想近乎彻底的分治思想。

桶排序假设待排序的一组数均匀独立的分布在一个范围中，并将这一范围划分成几个子范围（桶）。

然后基于某种映射函数f ，将待排序列的关键字 k 映射到第i个桶中 (即桶数组B 的下标i) ，那么该关键字k 就作为 B[i]中的元素 (每个桶B[i]都是一组大小为N/M 的序列 )。

接着将各个桶中的数据有序的合并起来 : 对每个桶B[i] 中的所有元素进行比较排序 (可以使用快排)。然后依次枚举输出 B[0]….B[M] 中的全部内容即是一个有序序列。

补充：映射函数一般是 f = array[i] / k; k^2 = n; n是所有元素个数

为了使桶排序更加高效，我们需要做到这两点：

  1. 在额外空间充足的情况下，尽量增大桶的数量

  2. 使用的映射函数能够将输入的 N 个数据均匀的分配到 K 个桶中

同时，对于桶中元素的排序，选择何种比较排序算法对于性能的影响至关重要。

2.实现逻辑

  • 设置一个定量的数组当作空桶子。

  • 寻访序列，并且把项目一个一个放到对应的桶子去。

  • 对每个不是空的桶子进行排序。

  • 从不是空的桶子里把项目再放回原来的序列中。

3.动图演示

分步骤图示说明：设有数组 array = [63, 157, 189, 51, 101, 47, 141, 121, 157, 156, 194, 117, 98, 139, 67, 133, 181, 13, 28, 109]，对其进行桶排序：

4.复杂度分析

  • 平均时间复杂度：O(n + k)

  • 最佳时间复杂度：O(n + k)

  • 最差时间复杂度：O(n ^ 2)

  • 空间复杂度：O(n * k)

  • 稳定性：稳定

桶排序最好情况下使用线性时间O(n)，桶排序的时间复杂度，取决于对各个桶之间数据进行排序的时间复杂度，因为其它部分的时间复杂度都为O(n)。很显然，桶划分的越小，各个桶之间的数据越少，排序所用的时间也会越少。但相应的空间消耗就会增大。

5.代码实现

假设数据分布在[0，100)之间，每个桶内部用链表表示，在数据入桶的同时插入排序。然后把各个桶中的数据合并。

 
   
   
 
    
  
    
    
  
  1. #include<iterator>
    2. 
  
    
    
  
  2. #include<iostream>
    3. 
  
    
    
  
  3. #include<vector>
    4. 
  
    
    
  
  4. using namespace std;
    5. 
  
    
    
  
  5. const int BUCKET_NUM = 10;
    6. 
  
    
    
  
  6. struct ListNode{
    7. 
  
    
    
  
  7.  explicit ListNode(int i=0):mData(i),mNext(NULL){}
    8. 
  
    
    
  
  8.  ListNode* mNext;
    9. 
  
    
    
  
  9.  int mData;
    10. 
  
    
    
  
  10. };
    11. 
  
    
    
  
  11. ListNode* insert(ListNode* head,int val){
    12. 
  
    
    
  
  12.  ListNode dummyNode;
    13. 
  
    
    
  
  13.  ListNode *newNode = new ListNode(val);
    14. 
  
    
    
  
  14.  ListNode *pre,*curr;
    15. 
  
    
    
  
  15.  dummyNode.mNext = head;
    16. 
  
    
    
  
  16.  pre = &dummyNode;
    17. 
  
    
    
  
  17.  curr = head;
    18. 
  
    
    
  
  18.  while(NULL!=curr && curr->mData<=val){
    19. 
  
    
    
  
  19.  pre = curr;
    20. 
  
    
    
  
  20.  curr = curr->mNext;
    21. 
  
    
    
  
  21.  }
    22. 
  
    
    
  
  22.  newNode->mNext = curr;
    23. 
  
    
    
  
  23.  pre->mNext = newNode;
    24. 
  
    
    
  
  24.  return dummyNode.mNext;
    25. 
  
    
    
  
  25. }
    26. 
  
    
    
  
  26. ListNode* Merge(ListNode *head1,ListNode *head2){
    27. 
  
    
    
  
  27.  ListNode dummyNode;
    28. 
  
    
    
  
  28.  ListNode *dummy = &dummyNode;
    29. 
  
    
    
  
  29.  while(NULL!=head1 && NULL!=head2){
    30. 
  
    
    
  
  30.  if(head1->mData <= head2->mData){
    31. 
  
    
    
  
  31.  dummy->mNext = head1;
    32. 
  
    
    
  
  32.  head1 = head1->mNext;
    33. 
  
    
    
  
  33.  }else{
    34. 
  
    
    
  
  34.  dummy->mNext = head2;
    35. 
  
    
    
  
  35.  head2 = head2->mNext;
    36. 
  
    
    
  
  36.  }
    37. 
  
    
    
  
  37.  dummy = dummy->mNext;
    38. 
  
    
    
  
  38.  }
    39. 
  
    
    
  
  39.  if(NULL!=head1) dummy->mNext = head1;
    40. 
  
    
    
  
  40.  if(NULL!=head2) dummy->mNext = head2;
    41. 
  
    
    
  

    42. 
  
    
    
  
  42.  return dummyNode.mNext;
    43. 
  
    
    
  
  43. }
    44. 
  
    
    
  
  44. void BucketSort(int n,int arr[]){
    45. 
  
    
    
  
  45.  vector<ListNode*> buckets(BUCKET_NUM,(ListNode*)(0));
    46. 
  
    
    
  
  46.  for(int i=0;i<n;++i){
    47. 
  
    
    
  
  47.  int index = arr[i]/BUCKET_NUM;
    48. 
  
    
    
  
  48.  ListNode *head = buckets.at(index);
    49. 
  
    
    
  
  49.  buckets.at(index) = insert(head,arr[i]);
    50. 
  
    
    
  
  50.  }
    51. 
  
    
    
  
  51.  ListNode *head = buckets.at(0);
    52. 
  
    
    
  
  52.  for(int i=1;i<BUCKET_NUM;++i){
    53. 
  
    
    
  
  53.  head = Merge(head,buckets.at(i));
    54. 
  
    
    
  
  54.  }
    55. 
  
    
    
  
  55.  for(int i=0;i<n;++i){
    56. 
  
    
    
  
  56.  arr[i] = head->mData;
    57. 
  
    
    
  
  57.  head = head->mNext;
    58. 
  
    
    
  
  58.  }
    59. 
  
    
    
  
  59. }
    60.

三、总结

桶排序是计数排序的变种，它利用了函数的映射关系，高效与否的关键就在于这个映射函数的确定。把计数排序中相邻的m个”小桶”放到一个”大桶”中，在分完桶后，对每个桶进行排序（一般用快排），然后合并成最后的结果。

算法思想和散列中的开散列法差不多，当冲突时放入同一个桶中；可应用于数据量分布比较均匀，或比较侧重于区间数量时。

桶排序最关键的建桶，如果桶设计得不好的话桶排序是几乎没有作用的。通常情况下，上下界有两种取法，第一种是取一个10^n或者是2^n的数，方便实现。另一种是取数列的最大值和最小值然后均分作桶.

下一篇预告：基数排序（Radix Sort）。欲知详情，且听下回分解。

以上是关于算法排序算法之桶排序的主要内容，如果未能解决你的问题，请参考以下文章

排序算法专题之桶排序

排序算法之桶排序

算法：排序之桶排序和基数排序

十大排序算法之桶排序

经典算法之桶排序

重温基础算法内部排序之桶排序法