线性时间排序算法

线性时间排序算法列表

线性时间排序
Name	Average	Worst	Memory	Stable	Description
计数排序 （Counting Sort）	n + k	n + k	n + k	Stable	Indexes using key values.
基数排序 （Radix Sort）	n * k	n * k	n + k	Stable	Examines individual bits of keys.
桶排序 （Bucket Sort）	n + k	n2	n * k	Stable	Examine bits of keys.

给定含 n 个元素的输入序列，任何比较排序在最坏情况下都需要 Ω(n log n) 次比较来进行排序。合并排序和堆排序在最坏情况下达到上界 O(n log n)，它们都是渐进最优的排序算法，快速排序在平均情况下达到上界 O(n log n)。

本文介绍的三种以线性时间运行的算法：计数排序、基数排序和桶排序，都用非比较的一些操作来确定排序顺序。因此，下界 Ω(n log n) 对它们是不适用的。

计数排序（Counting Sort）

计数排序（Counting Sort）假设 n 个输入元素中的每一个都是介于 0 到 k 之间的整数，此处 k 为某个整数。

计数排序的基本思想就是对每一个输入元素 x，确定出小于 x 的元素个数。有了这一信息，就可以把 x 直接放到它在最终输出数组中的位置上。

例如：有 10 个年龄不同的人，统计出有 8 个人的年龄比 A 小，那 A 的年龄就排在第 9 位，用这个方法可以得到其他每个人的位置，也就排好了序。当然，年龄有重复时需要特殊处理（保证稳定性），这就是为什么最后要反向填充目标数组，以及将每个数字的统计减去 1 的原因。

算法描述

算法的步骤如下：

1. 找出待排序的数组中最大和最小的元素；
2. 统计数组中每个值为 i 的元素出现的次数，存入数组 C 的第 i 项；
3. 对所有的计数累加（从 C 中的第一个元素开始，每一项和前一项相加）；
4. 反向填充目标数组，将每个元素 i 放在新数组的第 C(i) 项，每放一个元素就将 C(i) 减去 1；

算法复杂度

• 最差时间复杂度 O(n + k)
• 平均时间复杂度 O(n + k)
• 最差空间复杂度 O(n + k)

计数排序不是比较排序，排序的速度快于任何比较排序算法。

计数排序的一个重要性质就是它是稳定的：具有相同值的元素在输出数组中的相对次序与它们在输入数组中的次序相同。

之所以说计数排序的稳定性非常重要，还有一个原因是因为计数排序经常用作基数排序算法的一个子过程，其稳定性对于基数排序的正确性来说非常关键。

代码示例

  class Program
  {
    static void Main(string[] args)
    {
      int[] unsorted = 
        { 
          5, 9, 3, 9, 10, 9, 2, 4, 13, 10
        };

      OptimizedCountingSort(unsorted);

      foreach (var key in unsorted)
      {
        Console.Write("{0} ", key);
      }

      Console.Read();
    }

    static int[] CountingSort(int[] unsorted)
    {
      // find min and max value
      int min = unsorted[0], max = unsorted[0];
      for (int i = 1; i < unsorted.Length; i++)
      {
        if (unsorted[i] < min) min = unsorted[i];
        else if (unsorted[i] > max) max = unsorted[i];
      }

      // creates k buckets
      int k = max - min + 1;
      int[] C = new int[k];

      // calculate the histogram of key frequencies
      for (int i = 0; i < unsorted.Length; i++)
      {
        C[unsorted[i] - min]++;
      }

      // recalculate
      C[0]--;
      for (int i = 1; i < C.Length; i++)
      {
        C[i] = C[i] + C[i - 1];
      }

      // sort the array
      int[] B = new int[unsorted.Length];
      for (int i = unsorted.Length - 1; i >= 0; i--)
      {
        // keep stable
        B[C[unsorted[i] - min]--] = unsorted[i];
      }

      return B;
    }

    static void OptimizedCountingSort(int[] unsorted)
    {
      // find min and max value
      int min = unsorted[0], max = unsorted[0];
      for (int i = 1; i < unsorted.Length; i++)
      {
        if (unsorted[i] < min) min = unsorted[i];
        else if (unsorted[i] > max) max = unsorted[i];
      }

      // creates k buckets
      int k = max - min + 1;
      int[] C = new int[k];

      // calculate the histogram of key frequencies
      for (int i = 0; i < unsorted.Length; i++)
      {
        C[unsorted[i] - min]++;
      }

      // copy to output array,
      // preserving order of inputs with equal keys
      int increment = 0;
      for (int i = min; i <= max; i++)
      {
        for (int j = 0; j < C[i - min]; j++)
        {
          // in place, may not stable if you care
          unsorted[increment++] = i;
        }
      }
    }
  }

基数排序（Radix Sort）

基数排序（Radix Sort）是一种非比较型整数排序算法，其原理是将整数值按相同的有效位进行分组，然后在有效位区间内进行排序。

算法描述

每个元素值首先被放入一个该值的最右位所对应的桶中，桶内会保持被放入元素值最初的顺序。这使得桶的数量和值的数量能够根据其最右位建立一对一的关系。然后，通过相同的方式重复处理下一位，直到所有的位都已被处理。

1. 获得值的最右侧的最小的位。
2. 根据该位的值将数组内的元素值进行分组，但仍然保持元素的顺序。(以此来保持算法稳定性)
3. 重复上述分组过程，直到所有的位都已被处理。

上述第 2 步中通常可以使用桶排序（Bucket Sort）或计数排序（Counting Sort）算法，因为它们在元素较少时拥有更好的效率。

基数排序中可以选择采用最低有效位基数排序（LSD Radix Sort：Least Significant Digit Radix Sort）或最高有效位基数排序（MSD Radix Sort：Most Significant Digit Radix Sort）。LSD 的排序方式由值的最低位也就是最右边开始，而 MSD 则相反，由值的最高位也就是最左边开始。

例如，如下这个无序的数列需要排序：

　　170, 45, 75, 90, 802, 2, 24, 66

使用 LSD 方式从最低位开始（个位）排序的结果是：

　　170, 90, 802, 2, 24, 45, 75, 66

再继续从下一位（十位）继续排序的结果是：

　　802, 2, 24, 45, 66, 170, 75, 90

再继续从下一位（百位）继续排序的结果是：

　　2, 24, 45, 66, 75, 90, 170, 802

算法复杂度

• 最差时间复杂度 O(k*n)
• 最差空间复杂度 O(k*n)

代码示例

  class Program
  {
    static void Main(string[] args)
    {
      int[] unsorted = 
        { 
          15, 19, 13, 19, 10, 33, 12, 14, 13, 10,
        };

      RadixSort(unsorted);

      foreach (var key in unsorted)
      {
        Console.Write("{0} ", key);
      }

      Console.Read();
    }

    static void RadixSort(int[] unsorted)
    {
      // our helper array 
      int[] t = new int[unsorted.Length];

      // number of bits our group will be long 
      // try to set this also to 2, 8 or 16 to see if it is quicker or not
      int r = 4;

      // number of bits of a C# int 
      int b = 32;

      // counting and prefix arrays
      // (note dimensions 2^r which is the number of 
      // all possible values of a r-bit number) 
      int[] count = new int[1 << r];
      int[] pref = new int[1 << r];

      // number of groups 
      int groups = (int)Math.Ceiling((double)b / (double)r);

      // the mask to identify groups 
      int mask = (1 << r) - 1;

      // the algorithm: 
      for (int c = 0, shift = 0; c < groups; c++, shift += r)
      {
        // reset count array 
        for (int j = 0; j < count.Length; j++)
          count[j] = 0;

        // counting elements of the c-th group 
        for (int i = 0; i < unsorted.Length; i++)
          count[(unsorted[i] >> shift) & mask]++;

        // calculating prefixes 
        pref[0] = 0;
        for (int i = 1; i < count.Length; i++)
          pref[i] = pref[i - 1] + count[i - 1];

        // from a[] to t[] elements ordered by c-th group 
        for (int i = 0; i < unsorted.Length; i++)
          t[pref[(unsorted[i] >> shift) & mask]++] = unsorted[i];

        // a[]=t[] and start again until the last group 
        t.CopyTo(unsorted, 0);
      }
      // a is sorted 
    }
  }

桶排序（Bucket Sort）

桶排序（Bucket Sort）的工作原理是将数组分解到有限数量的桶里，每个桶再分别进行排序。桶内排序有可能使用其他排序算法或是以递归的方式继续使用桶排序。

算法描述

桶排序的步骤：

1. 在数组中查找数值的最大值和最小值；
2. 初始化一个数组当作空桶，长度为 (MaxValue - MinValue + 1)。
3. 遍历被排序数组，并把数值逐个放入对应的桶中。
4. 对每个不是空的桶进行排序。
5. 从不是空的桶里把数值再放回原来的数组中。

算法复杂度

• 最差时间复杂度 O(n²)
• 平均时间复杂度 O(n+k)
• 最差空间复杂度 O(n*k)

当要被排序的数组中的数值是均匀分布时，桶排序的运行时间为线性时间 Θ(n)。桶排序不是比较排序，它不受 Ω(n log n) 下界的影响。

代码示例

  class Program
  {
    static void Main(string[] args)
    {
      int[] unsorted = 
        { 
          15, 19, 13, 19, 10, 33, 12, 14, 13, 10,
        };

      BucketSort(unsorted);

      foreach (var key in unsorted)
      {
        Console.Write("{0} ", key);
      }

      Console.Read();
    }

    static void BucketSort(int[] unsorted)
    {
      // find the maximum and minimum values in the array
      int max = unsorted[0]; //start with first element
      int min = unsorted[0];

      // start from index 1
      for (int i = 1; i < unsorted.Length; i++)
      {
        if (unsorted[i] < min) min = unsorted[i];
        else if (unsorted[i] > max) max = unsorted[i];
      }

      // create a temporary "buckets" to store the values in order
      // each value will be stored in its corresponding index
      // scooting everything over to the left as much as possible
      // e.g. 34 => index at 34 - minValue
      List<int>[] buckets = new List<int>[max - min + 1];

      // initialize the buckets
      for (int i = 0; i < buckets.Length; i++)
      {
        buckets[i] = new List<int>();
      }

      // move items to bucket
      for (int i = 0; i < unsorted.Length; i++)
      {
        buckets[unsorted[i] - min].Add(unsorted[i]);
      }

      // move items in the bucket back to the original array in order
      int k = 0; //index for original array
      for (int i = 0; i < buckets.Length; i++)
      {
        if (buckets[i].Count > 0)
        {
          for (int j = 0; j < buckets[i].Count; j++)
          {
            unsorted[k] = buckets[i][j];
            k++;
          }
        }
      }
    }
  }

参考资料

• Sorting Algorithms
• Counting Sort Radix Sort Bucket Sort
• C# Counting Sort Algorithm Implementation
• Radix Sorting Implementation with C#
• Algorithm Implementation/Sorting/Radix sort
• Category:Algorithm Implementation
• Counting Sort and Radix Sort
• Data Structures and Algorithms with Object-Oriented Design Patterns in C++

本篇文章《线性时间排序算法》由 Dennis Gao 发表自博客园，任何未经作者同意的爬虫或人为转载均为耍流氓。