Introduce to algorithm--------pseudo code to C/C++ code(Chapter 8)

计数排序：

顾名思义，基数排序的中心思想是“计数”。该排序算法需要额外的两组array分别来存储计数信息和输出信息。

算法概述如下： 算法计算每个元素出现的次数，将次数按元素大小顺序保存。然后将每个出现次数更改为包

含自身次数以前的所有次数和。所以若元素5的累计次数为8，则元素5的最后一个排序位置（可能有多个元素5）应

该在数组中下标为7的位置处。（0-based index）必须要提的一点是计数排序的前提是非常重要的，即：假设n个输

入元素中的每一个都是在0到k区间内的一个整数，其中k为某个整数。（摘自算法导论）

 //
 //  A: input array
 //  B: output array
 //  n1:number of elements both in A and B arrays
 //  C: auxiliary array
 //  n2:number of elements in array C(the same as k + 1 said above)
 /
 template <typename T>
 void counting_sort (T* A, T* B, int n1, T* C, int n2)
 {
     //init auxiliary with 0
     for (int i = 0; i < n2; ++i)
         C[i] = static_cast (0);

     //counting number and save in array C with value located at A[i]
     for (int i = 0; i < n1; ++i)
         ++C[A[i]];

     //accumulate counting numbers
     for (int i = 1; i < n2; ++i)
         C[i] += C[i - 1];

     //input also sort
     for (int i = n1 - 1; i >= 0; --i)
         B[C[A[i]] - 1] = A[i],
         --C[A[i]];
 }

举例： 排序A[] = { 2,3,5,1 }

输出数组：B；     辅助数组： C

第一个for循环：

B[] = { ?,?,?,? }

C[5] = { 0,0,0,0,0 }

第二个for循环：

B[] = { ?,?,?,? }

C[] = { 0,1,1,1,0,1 } 因为存在一个元素2，所以C[2]递增。其他元素一样处理。

第三个for循环：

B[] = { ?,?,?,? }

C[] = { 0,1,2,3,3,4 } 累计所有当前出现次数之前的所有出现次数的累加值（包括当前次数），用于定位元素的正确排序位置

第四个for循环：

B[] = { 1,2,3,5 }

基数排序：

顾名思义，基数排序基于“基数”这个概念。如果说数值为10进制数，则这些数值的基数为10，若数值为8进制数，则基数

为8.核心思想是根据数据的每位上的数值大小进行排序。以下图片描述的很清楚(摘自算法导论)：


桶排序：
算法概念以“桶”为中心。以下为“桶”的概念：桶排序假设输入是由一个随机过程产生，该过程将元素均匀、独立的分布在[0，1)

上，桶排序则将[0，1）划分为n个相同大小的子区间，称为桶。实际上，“桶”就是所有数据的一个块。桶排序分散在各个“桶”里进行。

但是输出各个桶排序后的数据时，只是简单的顺序遍历桶，所以在将数据分割成桶时，必须保证每个桶已按大小整体排序。



    由于实际上的应用，多数情况下是将基数排序与桶排序相结合以获得良好的运行时间，当然，是以相应的空间代价换来的。由于

桶排序是稳定排序，即排序时保持数据的原有相对顺序，所以将桶排序应用在技术排序中是完全可行的。以下为基数排序代码（内部

以桶排序实现）：

 ///
 //  function description:
 //      radix sort uses buckets to make stable sort
 //  parameter:
 //      A:          array name
 //      n:          array size
 //      bitCount:       max bit number of value
 ///
 template <typename T>
 void radix_sort (T* A, int n, int bitCount)
 {
     //bucket sort in bit order
     for (int i = 1; i <= bitCount; ++i)
         bucket_sort<int> (A, n, bitCount);
 }

 #define BaseNum     10

 template <typename T>
 void bucket_sort (T* A, int num, int bitNum)
 {
     //allocate bucket memory
     node*      bucket[BaseNum];

     //init
     for (int i = 0; i < BaseNum; ++i)
         bucket[i] = static_cast *> (nullptr);

     //sort using buckets
     int         temp = 1;
     for (int i = 0; i < bitNum - 1; ++i)
         temp *= BaseNum;

     for (int i = 0; i < num; ++i)
         insertValue (&bucket[A[i] / temp % BaseNum], A[i]);

     //output in sequence order of buckets
     for (int i = 0, j = 0; i < BaseNum; ++i)
     {
         node*  ptr = bucket[i];
         while (ptr)
             A[j++] = ptr->value,
             ptr = ptr->next;
     }
 }

 template <typename T>
 struct node
 {
     T       value;
     node       *next;
 };

 //head is the bucket pointer
 template <typename T>
 void insertToNullList (node** head, T value)
 {
     *head = (node*) malloc (sizeof (node));
     (*head)->next = nullptr;
     (*head)->value = value;
 }

 template <typename T>
 void insertBetween (node** left, node* right, T value)
 {
     (*left)->next = (node *) malloc (sizeof  (node));
     (*left)->next->next = right;
     (*left)->next->value = value;
 }

 template <typename T>
 void insertValue (node** head, T value)
 {
     //insert into empty list
     if (*head == nullptr)
         return insertToNullList (head, value);

     //if value in head node is greater, insert before it
     if ((*head)->value > value)
     {
         node*  ptr = *head;
         *head = (node*)malloc (sizeof (node));
         (*head)->next = ptr;
         (*head)->value = value;
         return;
     }

     //locate the appropriate place
     node   *ptr = *head;
     while (ptr->next && ptr->next->value <= value)
         ptr = ptr->next;

     //insert into tail
     if (ptr->next == nullptr)
         insertToNullList (&ptr->next, value);
     else
         //insert inside list
         insertBetween (&ptr, ptr->next, value);
 }

虽然出于代码复用的考虑用模板来实现了，但仅限于int，long等类似类型，不适用于unsigned，float等类型。还有，作为一个算法函数

而言，个人觉得应这样实现该是不推荐的。当时实现的时候自己太过关注代码的重用，并且有一部分是出于熟练模板的使用与设计。虚心请

球批评指正。

For more details,  see Introduce to algorithm.