基数排序与计数排序与桶排序。有什么不同？

Question

我正在阅读基数，计数和桶排序的定义，似乎所有这些都只是下面的代码：

public static void sort(int[] a, int maxVal){
    int [] bucket=new int[maxVal+1];

    for (int i=0; i<bucket.length; i++){
        bucket[i]=0;
    }

    for (int i=0; i<a.length; i++){
        bucket[a[i]]++;
    }

    int outPos=0;
    for (int i=0; i<bucket.length; i++){
        for (int j=0; j<bucket[i]; j++){
            a[outPos++]=i;
        }
    }
}

我知道我不对，所以我错过了什么？如果您认为可以帮助在Java或C中进行解释，请显示代码。

Answer 1

让我们从一些用C重写你的代码开始，因为C对我来说比较熟悉。因此，让我们回忆一下你的代码：

int
counting_sort(int a[], int a_len, int maxVal)
{
  int i, j, outPos = 0;
  int bucket_len = maxVal+1;
  int bucket[bucket_len]; /* simple bucket structure */

  memset(bucket, 0, sizeof(int) * bucket_len);

  /* one loop bucket processing */
  for (i = 0; i < a_len; i++)
    {
      bucket[a[i]]++; /* simple work with buckets */
    }

  for (i=0; i < bucket_len; i++)
    {
      for (j = 0; j < bucket[i]; j++)
        {
          a[outPos++] = i;
        }
    }

  return 0;
}

现在让我们为这个人提供一些真实的数据：

[126,348,343,432,316,171,556,223,670,201]

在输出上我们有

[126,171,201,223,316,343,348,432,556,670]

好像一切都好吗？还没。让我们看看maxVal。它是670（！）为了​​对10个元素的数组进行排序，我们使用了670个元素的数组，主要是零。非常。为了解决排序计数问题，我们有两种可能的泛化方法：

1）第一种方式 - 按数字排序。这称为基数排序。让我们展示一些代码，尝试尽可能接近计数排序代码。再看看评论：

int
radix_sort(int a[], int a_len, int ndigits)
{
  int i;
  int b[a_len];
  int expn = 1;

  /* additional loop for digits */
  for (i = 0; i != ndigits; ++i)
    {
      int j;
      int bucket[10] = {0}; /* still simple buckets */

      /* bucket processing becomes tricky */
      for (j = 0; j != a_len; ++j)
        bucket[ a[j] / expn % 10 ]++;

      for (j = 1; j != 10; ++j)
        bucket[j] += bucket[j - 1];

      for (j = a_len - 1; j >= 0; --j)
        b[--bucket[a[j] / expn % 10]] = a[j];

      for (j = 0; j != a_len; ++j)
        a[j] = b[j];

      expn *= 10;
    }
}

我们在N附近交易倍数用于记忆。利润？也许。但在某些情况下，N附近的乘数非常重要。即使两者分别工作1 * O（N）和7 * O（N），程序，每天工作和工作一周与用户视图也大不相同。所以我们要进行第二次概括：

2）第二种方式 - 使桶更复杂。这称为bucket-sort。

让我们再次开始使用一些代码。在哲学论证之前，我更喜欢更多的代码。仍然看看评论，它们是必不可少的。

int
bucket_sort(int a[], int a_len, int maxVal)
{
  int i, aidx;

  typedef struct tag_list {
    int elem;
    struct tag_list *next;
  } list_t, *list_p;

  list_p bucket[10] = {0}; /* sophisticated buckets */

  /* one loop simple processing with one more inner loop 
    to get sorted buckets (insert-sort on lists, Cormen-style) */
  for (i = 0; i != a_len; ++i)
    {
      int bnum = (10 * a[i]) / maxVal;
      list_p bptr = bucket[bnum];
      list_p belem = malloc(sizeof(list_t));
      belem->elem = a[i];
      if (bptr == 0)
        {
          bucket[bnum] = belem;
          belem->next = 0;
          continue;
        }
      else if (a[i] <= bptr->elem)
        {
          belem->next = bptr;
          bucket[bnum] = belem;
          continue;
        }
      else
        {
          while (bptr != 0)
            {
              if ((bptr->elem <= a[i]) && ((bptr->next == 0) || (bptr->next->elem > a[i])))
                {
                  belem->next = bptr->next;
                  bptr->next = belem;
                  break;
                }
               bptr = bptr->next;
            }
         }
    }

  /* one loop (looks as two) to get all back */
  aidx = 0;

  for (i = 0; i != 10; ++i)
    {
      list_p bptr = bucket[i];
      while (bptr)
        {
          list_p optr = bptr;
          a[aidx] = bptr->elem;
          aidx += 1;
          bptr = bptr->next;
          free(optr);
        }
    }

  return 0;
}

那么我们在这里有什么？我们正在交易一些复杂的桶结构和动态分配内存的要求，但赢得了静态内存，并且平均在N附近乘以。

现在让我们回想一下我们在代码中看到的内容：

1. 计数排序 - 简单存储桶，简单处理，内存开销
2. 基数排序 - 简单的存储桶，复杂的处理，高速开销（并且仍然需要额外的静态存储器）
3. 铲斗分类 - 复杂的铲斗，简单的处理，需要动态记忆，平均水平
因此，Radix和bucket排序是计数排序的两个有用的概括。他们在计算排序方面有很多共同点，但在每种情况下我们都会失去一些东西并赢得一些东西。软件工程是在这些机会之间取得平衡。

Answer 2

  

Radix sort vs Counting sort vs Bucket sort。有什么区别？

Bucket sort将要排序的键或元素放入存储桶中。它们在桶中的位置是任意的，可以是复合键的一部分，也可以是您喜欢的任何分布。各个桶可能需要进一步分类。

在内存中排序比在磁盘上排序更快。但是，如果您有更多数据而不是内存，则需要另一个选项。您可以做的是一个桶排序，其中桶足够小以适应内存。即每个桶中有大量条目。这些可以单独快速排序。

基数排序是特定类型的桶排序。它从顶部的n位或n位开始，可以使用基数排序等对这些桶进行排序，直到每个条目都被排序。

计数排序就像使用基数排序，除非您使用整个值。它不是记录每个对象，而是为每个对象提供一个存储桶，它只计算出现次数。当您拥有有限数量的可能密钥并且有许多重复项时，这种方法很有效。

Answer 3

您的代码是计数排序的简单变体，没有数据，只有键。

基数排序是基于此方法的排序。计数排序的问题是内存要求：int [] bucket=new int[maxVal+1];。基数排序解决了这个问题。这个想法是使用计数排序几次，首先是较低的数字，然后是较高的数字。例如，要对32位整数进行排序，可以使用：

sort(a, 65535) using lower half as key
sort(a, 65535) using higher half as key

它有效，因为计数排序是稳定的 - 它使用相同的键保持数据的顺序。这就像在电子表格中排序一样：sort by B; sort by A为您提供按A排序的元素，以及当As相等时按B排序的元素。

Bucket sort是计数排序的概括。您可以使用它从一些可预测的概率分布中对实数进行排序（例如，统一(0,1)）。我们的想法是使用计数排序（使用floor(x*N_BUCKETS)作为密钥），然后仅对每个存储桶进行独立排序。

Answer 4

根据Geekviewpoint：

基数：http://www.geekviewpoint.com/java/sorting/radixsort

  

基数排序，如计数排序和桶排序，是基于整数的算法（即，假设输入数组的值是整数）。因此，理论上，基数排序是最快的排序算法之一。基数排序的特殊区别是它为每个密码（即数字）创建一个桶;因此，类似于桶排序，基数排序中的每个桶必须是可以允许不同密钥的可增长列表。

Bucket：http://www.geekviewpoint.com/java/sorting/bucketsort

  

考虑到计数排序合理地说它的上限，桶排序实际上是非常好的。计数排序非常快。存储桶排序的特殊区别在于它使用散列函数对输入数组的键进行分区，因此多个键可以散列到同一个存储桶。因此，每个桶必须有效地成为可增长的列表;类似于基数排序。

计数：http://www.geekviewpoint.com/java/sorting/countingsort

  

计数排序的特殊区别在于它为每个值创建一个存储桶并在每个存储桶中保留一个计数器。然后，每次在输入集合中遇到值时，相应的计数器都会递增。因为计数排序为每个值创建一个存储桶，所以强制限制是输入数组中的最大值事先是已知的。

他们在网站上详细解释了这一点。

编辑：

• 如果您使用基数排序且您的数字是小数，那么您需要10个桶，每个数字一个，从0到9。

• 如果您使用的是计数排序，那么您需要为输入中的每个唯一值设置一个存储桶（实际上，您需要为0到最大值之间的每个值设置一个存储桶）。

• 如果您使用的是bucketsort，则不知道您将使用多少个存储桶。无论您使用何种哈希函数，都将决定存储桶的数量。

Answer 5

首先让我们看一下Radix Sort和Bucket Sort之间的区别，因为这通常是一个令人困惑的事情，因为这个想法似乎是一样的。然后我们看看Counting Sort，它就像这两个的主要版本以及计数排序的问题导致其他两个问题被使用

Radix和Bucket排序的初始传递是相同的。元素放在'Buckets'中，即0-10,11-20，......等等，这取决于最大数字中的数字位数，即基数。但是，在下一次传递中，存储桶排序会对这些“存储桶”进行排序并将它们附加到一个数组中。但是，基数排序方法会在没有进一步排序的情况下附加存储桶，并根据数字的第二个数字（十位）对其进行“重新存储”。因此，Bucket排序对于'Dense'数组更有效，而Radix Sort可以很好地处理稀疏数组。 好吧把桶排序为这个

假设你有一个n个记录的列表，每个记录都有一个从1到k的数字的密钥（我们将问题概括一点，因此k不一定等于n）。

我们可以通过制作一系列链表来解决这个问题。我们将每个输入记录移动到数组的适当位置的列表中，然后按顺序将所有列表连接在一起。

 bucket sort(L)
    {
    list Y[k+1]
    for (i = 0; i <= k; i++) Y[i] = empty
    while L nonempty
    {
        let X = first record in L
        move X to Y[key(X)]
    }
    for (i = 0; i <= k; i++)
    concatenate Y[i] onto end of L
    }

当k很大时该怎么办？想想一个数字的十进制表示     x = a + 10 b + 100 c + 1000 d + ...... 其中a，b，c等都在0..9范围内。这些数字很容易小到可以进行存储桶排序。

   radix sort(L):
    {
    bucket sort by a
    bucket sort by b
    bucket sort by c
    ...
    }

或更简单

radix sort(L):
{
while (some key is nonzero)
{
    bucket sort(keys mod 10)
    keys = keys / 10
}
}

为什么我们先做最重要的数字呢？就此而言，为什么我们要做多个桶排序，因为最后一个是将所有东西放到位的？ 答：如果我们试图手工排序，我们倾向于做一些不同的事情：首先进行一个桶排序，然后递归排序共享一个共同的第一个数字的值。这可行，但效率较低，因为它将问题分解为许多子问题。相比之下，基数排序从不分割列表;它只是将桶排序多次应用到同一个列表中。 在基数排序中，桶排序的最后一遍是对整体订单影响最大的一次。所以我们希望它是使用最重要数字的那个。之前的存储桶排序过程仅用于处理两个项目在最后一次传递中具有相同键（mod 10）的情况。

现在我们已经完成了所有Counting排序的工作，它保留了一个带有k个元素的辅助数组C，全部初始化为0.

  

我们通过输入数组A和A中的每个元素i进行一次传递   我们看到，我们将C [i]递增1.在我们迭代n之后   A和更新C的元素，C的索引j处的值对应   j在A中出现了多少次。这一步需要O（n）次迭代   通过A.一旦我们有了C，我们就可以构建A的排序版本了   迭代C并插入每个元素j总共C [j]次   进入一个新的列表（或A本身）。迭代C需要O（k）时间   最终结果是排序的A，总共需要O（n + k）时间。

计算排序的缺点是，如果元素的范围太大，它可能不太实用。例如，如果我们需要排序的n个元素的范围是从1到n 3，然后简单地创建辅助数组C将花费O（n ^ 3）时间并且计数排序将渐渐地比插入排序更糟糕。这也需要O（n ^ 3）空间，这比我们迄今为止学到的任何其他排序算法所使用的任何空间都要大。基数排序有助于通过逐位对元素进行排序来解决此问题

注意：答案和进一步阅读的来源：

  

http://htmltolatex.sourceforge.net/samples/sample4.html

     

第一个回答：What is the difference between bucket sort and radix sort?

Answer 6

基数排序使用计数排序的形式作为子程序（好的，可以使用，但通常它会计算排序）。

Countingsort是一种特殊形式的桶式排序，正如kasavbere所回答的那样。

Bucketsort将密钥分成桶，然后分别对桶进行排序。

Answer 7

使用count sort对数组进行排序：

#define MAX_INPUT 1000

void sort(int arr[100], int n)
{
    static int hash[MAX_INPUT], i, j;

    memset(hash, 0, sizeof hash);

    for (i = 0; i < n; ++i) ++hash[arr[i]];

    j = 0;
    for (i = 0; i < MAX_INPUT; ++i)
        while (hash[i]--)
           arr[j++] = i;
}

这只是O(MAX_INPUT)，因此按线性时间排序。对于铲斗排序，它是非常不同的。这是an implementation