排序算法汇总

1.冒泡排序
2.选择排序
3.插入排序
4.交换排序
5.归并排序
6.快速排序
7.堆排序

8.希尔排序

9.双向冒泡排序
10.计数排序

11.基数排序

 

一、简单排序算法 

1.冒泡法： 
这是最原始，也是众所周知的最慢的算法了。他的名字的由来因为它的工作看来象是冒泡： 

 // 冒泡法排序（升序）：O(n^2)
 // 思想：倒序，把比前一个元素小的与前一个交换，就相当于气泡上升。
 void BubbleSort(int* pData,int Count)
 {
     int iTemp;
     for(int i=1; i < Count; i++) // i，气泡上升顶点，
     {
         for(int j = Count-1; j >= i; j--) // 气泡上升过程
         {
             if(pData[j]<pData[j-1])
             {
                 iTemp = pData[j-1];
                 pData[j-1] = pData[j];
                 pData[j] = iTemp;
             }
         }
     }
 }

倒序(最糟情况)  
第一轮：10,9,8,7->10,9,7,8->10,7,9,8->7,10,9,8(交换3次)  
第二轮：7,10,9,8->7,10,8,9->7,8,10,9(交换2次)  
第一轮：7,8,10,9->7,8,9,10(交换1次)  
循环次数：6次  
交换次数：6次  

其他：  
第一轮：8,10,7,9->8,10,7,9->8,7,10,9->7,8,10,9(交换2次)  
第二轮：7,8,10,9->7,8,10,9->7,8,10,9(交换0次)  
第一轮：7,8,10,9->7,8,9,10(交换1次)  
循环次数：6次  
交换次数：3次  

上面我们给出了程序段，现在我们分析它：这里，影响我们算法性能的主要部分是循环和交换，  
显然，次数越多，性能就越差。从上面的程序我们可以看出循环的次数是固定的，为1+2+...+n-1。  
写成公式就是1/2*(n-1)*n。  

现在注意，我们给出O方法的定义： 
   若存在一常量K和起点n0，使当n>=n0时，有f(n)<=K*g(n),则f(n) = O(g(n))。

从程序后面所跟的表可以看到，两种情况的循环相同，交换不同。其实交换本身同数据源的 
有序程度有极大的关系，当数据处于倒序的情况时，交换次数同循环一样（每次循环判断都会交换）， 
复杂度为O(n*n)。当数据为正序，将不会有交换。复杂度为O(0)。乱序时处于中间状态。正是由于这样的 
原因，我们通常都是通过循环次数来对比算法。 

2.交换法： 
交换法的程序最清晰简单，每次用当前的元素一一的同其后的元素比较并交换。 

 // 交换法排序（升序）：O(n^2)
 // 思想：对于每一个元素，如果其后面的元素比它小，立刻与之交换，继续与之后的元素比较，交换
 void ExchangeSort(int* pData,int Count)
 {
     int iTemp;
     for(int i=0;i<Count-1;i++)
     {
         for(int j=i+1;j<Count;j++)
         {
             if(pData[j]<pData[i])
             {
                 iTemp = pData[i];
                 pData[i] = pData[j];
                 pData[j] = iTemp;
             }
         }
     }
 }

倒序(最糟情况)  
第一轮：10,9,8,7->9,10,8,7->8,10,9,7->7,10,9,8(交换3次)  
第二轮：7,10,9,8->7,9,10,8->7,8,10,9(交换2次)  
第一轮：7,8,10,9->7,8,9,10(交换1次)  
循环次数：6次  
交换次数：6次  

其他：  
第一轮：8,10,7,9->8,10,7,9->7,10,8,9->7,10,8,9(交换1次)  
第二轮：7,10,8,9->7,8,10,9->7,8,10,9(交换1次)  
第一轮：7,8,10,9->7,8,9,10(交换1次)  
循环次数：6次  
交换次数：3次  

从运行的表格来看，交换几乎和冒泡一样糟。事实确实如此。循环次数和冒泡一样  
也是1/2*(n-1)*n，所以算法的复杂度仍然是O(n*n)。由于我们无法给出所有的情况，所以  
只能直接告诉大家他们在交换上面也是一样的糟糕（在某些情况下稍好，在某些情况下稍差）。  

3.选择法：  
现在我们终于可以看到一点希望：选择法，这种方法提高了一点性能（某些情况下）  
这种方法类似我们人为的排序习惯：从数据中选择最小的同第一个值交换，在从剩下的部分中  
选择最小的与第二个交换，这样往复下去。  

 // 选择法排序（升序）：O(n^2)
 // 思想：从前往后，对于每一个元素，均从其与之后所有元素中选择最小的一个交换这个元素
 void SelectSort(int* pData,int Count)
 {
     int iTemp;
     int iPos;
     for(int i=0;i<Count-1;i++)
     {
         iTemp = pData[i];
         iPos = i;
         for(int j=i+1;j<Count;j++) // 从其后找最小的一个
         {
             if(pData[j]<iTemp)
             {
                 iTemp = pData[j];
                 iPos = j;
             }
         }
         pData[iPos] = pData[i]; // 交换最小的元素
         pData[i] = iTemp;
     }
 }

倒序(最糟情况)  
第一轮：10,9,8,7->(iTemp=9)10,9,8,7->(iTemp=8)10,9,8,7->(iTemp=7)7,9,8,10(交换1次)  
第二轮：7,9,8,10->7,9,8,10(iTemp=8)->(iTemp=8)7,8,9,10(交换1次)  
第一轮：7,8,9,10->(iTemp=9)7,8,9,10(交换0次)  
循环次数：6次  
交换次数：2次  

其他：  
第一轮：8,10,7,9->(iTemp=8)8,10,7,9->(iTemp=7)8,10,7,9->(iTemp=7)7,10,8,9(交换1次)  
第二轮：7,10,8,9->(iTemp=8)7,10,8,9->(iTemp=8)7,8,10,9(交换1次)  
第一轮：7,8,10,9->(iTemp=9)7,8,9,10(交换1次)  
循环次数：6次  
交换次数：3次  
遗憾的是算法需要的循环次数依然是1/2*(n-1)*n。

 

所以算法复杂度为O(n*n)。 
我们来看他的交换。由于每次外层循环只产生一次交换（只有一个最小值）。所以f(n)<=n 
所以我们有f(n)=O(n)。所以，在数据较乱的时候，可以减少一定的交换次数。 

4.插入法： 
插入法较为复杂，它的基本工作原理是抽出牌，在前面的牌中寻找相应的位置插入，然后继续下一张 

 // 插入法排序：O(n^2)
 // 思想：把数组分为有序区和无序区两个部分，初始以起始第一个元素为有序区
 // 每次取出无序区的第一个元素，相当于把有序区容量加1，把取出的元素与有序区元素倒序比较
 // 如果取出的元素较小，则把该有序区元素后移，同时继续比较，直到其不小于有序区该位置元素
 // 把取出的元素，写入到该位置的下一位。
 // 由于空位一直随着比较迁移，不要再做其他移动工作。
 // 就相当于码扑克牌，从排队里抓起一张，然后插入到合适的位置，同时也把比它大的牌后移。
 void InsertSort(int* pData,int Count)
 {
     int iTemp;
     int iPos;
     for(int i=1;i<Count;i++)
     {
         iTemp = pData[i];
         iPos = i-1;
         while((iPos>=0) && (iTemp<pData[iPos]))   // 找寻要插入的位置
         {
             pData[iPos+1] = pData[iPos];        // 要插入的位置还在前面，要把当前元素后移，留出空位
             iPos--;
         }
         pData[iPos+1] = iTemp; // 插入
     }
 }

倒序(最糟情况)  
第一轮：10,9,8,7->9,10,8,7(交换1次)(循环1次)  
第二轮：9,10,8,7->8,9,10,7(交换1次)(循环2次)  
第一轮：8,9,10,7->7,8,9,10(交换1次)(循环3次)  
循环次数：6次  
交换次数：3次  

其他：  
第一轮：8,10,7,9->8,10,7,9(交换0次)(循环1次)  
第二轮：8,10,7,9->7,8,10,9(交换1次)(循环2次)  
第一轮：7,8,10,9->7,8,9,10(交换1次)(循环1次)  
循环次数：4次  
交换次数：2次  

上面结尾的行为分析事实上造成了一种假象，让我们认为这种算法是简单算法中最好的，其实不是，  
因为其循环次数虽然并不固定，我们仍可以使用O方法。从上面的结果可以看出，循环的次数f(n)<=  
1/2*n*(n-1)<=1/2*n*n。所以其复杂度仍为O(n*n)（这里说明一下，其实如果不是为了展示这些简单  
排序的不同，交换次数仍然可以这样推导）。现在看交换，从外观上看，交换次数是O(n)（推导类似  
选择法），但我们每次要进行与内层循环相同次数的‘=’操作。正常的一次交换我们需要三次‘=’  
而这里显然多了一些，所以我们浪费了时间。  

二、高级排序算法：

5、归并排序：

归并（Merge）排序法是将两个（或两个以上）有序表合并成一个新的有序表，即把待排序序列分为若干个子序列，每个子序列是有序的。然后再把有序子序列合并为整体有序序列。

 

归并排序具体工作原理如下（假设序列共有n个元素）：

1. 将序列每相邻两个数字进行归并操作，形成floor(n / 2)个序列，排序后每个序列包含两个元素
2. 将上述序列再次归并，形成floor(n / 4)个序列，每个序列包含四个元素
3. 重复步骤2，直到所有元素排序完毕

 

 

 // 归并排序--归并函数
 void Merge(int* pData, int first, int mid, int last)
 {
     //申请空间，使其大小为两个已经排序序列之和，该空间用来存放合并后的序列
     int *pTemp = new int[last-first+1];
     int begin1 = first, begin2 = mid + 1;
     int i;
     for(i = 0; begin1 <= mid && begin2 <= last; ++i)
     {
         //比较两个指针所指向的元素，选择相对小的元素放入到合并空间，并移动指针到下一位置
         if(pData[begin1] <= pData[begin2])
             pTemp[i] = pData[begin1++];
         else
             pTemp[i] = pData[begin2++];
     }
     //若有剩余，直接拷贝出来粘到合并序列尾
     if(begin1 <= mid)
         memcpy_s(pTemp + i, (last-first+1)*sizeof(int), pData + begin1, (mid-begin1+1)*sizeof(int));
     else if(begin2 <= last)
         memcpy_s(pTemp + i, (last-first+1)*sizeof(int), pData + begin2, (last-begin2+1)*sizeof(int));
     //将排序好的序列拷贝回数组中
     memcpy_s(pData + first, (last-first+1)*sizeof(int), pTemp, (last-first+1)*sizeof(int));
     delete pTemp;
 }
 // 归并排序
 // 思路：分组排序，把排序后的数组归并
 void MergeSort(int* pData, int first, int last)
 {
     int mid = 0;
     if(first < last)
     {
         mid = (first+last)/2;
         MergeSort(pData, first, mid);
         MergeSort(pData, mid+1, last);
         Merge(pData, first, mid, last);
     }
 }

 

比较操作的次数介于(nlogn) / 2和nlogn − n + 1。 赋值操作的次数是(2nlogn)。 归并算法的空间复杂度为：Θ (n)

6、快速排序：
首先我们选择一个中间值middle程序中我们使用数组中间值，然后 
把比它小的放在左边，大的放在右边（具体的实现是从两边找，找到一对后交换）。然后对两边分别使 
用这个过程（最容易的方法——递归）。 

 #include <utility>
 // 快速排序，递归算法
 // 思路：取数组中间值作为划分元素，使该值左端元素均不大于它，右端元素均不小于它。该值在排序后的位置就定了。
 void QuickSort1(int* pData, int left, int right)    // left和right表示要排序的范围
 {
     int i,j;
     int middle,iTemp;
     i = left;
     j = right;
     middle = pData[(left+right)/2]; //求中间值 ，作为划分元素
     do
     {
         while((pData[i]<middle) && (i<right)) //从左扫描大于中值的数
             i++;
         while((pData[j]>middle) && (j>left)) //从右扫描大于中值的数
             j--;
         if(i<=j) //找到了一对值
         {
             //交换，使左端元素均不大于划分元素，右端元素均不小于划分元素
             std::swap(pData[i], pData[j]);
             i++;
             j--;
         }
     }while(i<=j);//如果两边扫描的下标交错，就停止（完成一次）
     //当左边部分有值(left<j)，递归左半边
     if(left<j)
         QuickSort1(pData,left,j);
     //当右边部分有值(right>i)，递归右半边
     if(right>i)
         QuickSort1(pData,i,right);
 }
 // 快速排序，非递归算法
 // 思路：同上
 // 优化：1、当划分组元素个数较少时，直接使用插入法排序，提高效率。
 //       2、选择左、中、右三个元素中处于中间的那个元素为划分元素，防止仅选择中间元素作为换分元素时，中间元素恰好为最小或最大值的情况。
 void QSort(int* pData, int nCount, int m = -1)
 {
     static const int M=7, NSTACK=64;    // M是使用直接插入法排序的子数组大小，NSTACK是所需的辅助存储器
     int i,ir,j,jstack=-1,l=0;           // i，j为循环算子，ir为当前分组右端，l当前为分组左端，jstack为当前栈数组滑标
     int a;
     int istack[NSTACK];                 // 堆栈，存放分组范围，i存放分组范围左端，i+1存放分组范围右端
     if (m > 0) nCount = min(m,nCount);  // m是可选参数，如果m>0,标识只对前m个元素排序
     ir=nCount-1;                        // 初始分组，ir为最右端位置，l为起始点位置
     for (;;)
     {
         if (ir-l < M)                // 当子数组足够小时，插入法排序
         {
             for (j=l+1;j<=ir;j++)    // 插入法排序算法
             {
                 a=pData[j];
                 for (i=j-1;i>=l;i--)
                 {
                     if (pData[i] <= a) break;
                     pData[i+1]=pData[i];
                 }
                 pData[i+1]=a;
             }
             if (jstack < 0) break;   // 堆栈为NULL，数组已经排序完成
              // 弹出堆栈，并开始新一轮划分
             ir=istack[jstack--];    // 右端
             l=istack[jstack--];     // 左端
         }
         else        // 快速排序核心算法
         {
             int k=(l+ir) >> 1;        // k为当前分组范围的中点
             std::swap(pData[k],pData[l+1]);     // 先把中间元素存放在第二位置
             // 挑选左、中、右三元素的中值作为划分元素a
             // 同时重新排列以使a[l]<=a[l+1]<=a[ir]
             if (pData[l] > pData[ir])
             {
                 std::swap(pData[l],pData[ir]);
             }
             if (pData[l+1] > pData[ir])
             {
                 std::swap(pData[l+1],pData[ir]);
             }
             if (pData[l] > pData[l+1])
             {
                 std::swap(pData[l],pData[l+1]);
             }
             i=l+1; // 为划分初始化指针，左指针
             j=ir;  // 右指针
             a=pData[l+1]; // 取划分元素
             for (;;) // 开始内循环
             {
                 do i++; while (pData[i] < a); // 从数组首部向后寻找大于a的元素
                 do j--; while (pData[j] > a); // 从数组尾部向前寻找小于a的元素
                 if (j < i) break;              // 指针交汇，划分结束
                 std::swap(pData[i],pData[j]); // 各自找到元素，交换元素
             } // 结束内循环，此时j左端的均元素均小于j右端的元素，且j位置的元素小于当前划分元素a.
             pData[l+1]=pData[j]; // 插入划分元素，此时该元素位置已定
             pData[j]=a;
             // 准备入栈，此时各指针顺序：[l...ji...ir],j处元素就是以排好序的划分元素a
             jstack += 2;
             // 将指针压入堆栈中更大的数组，立刻处理较小的数组
             if (jstack >= NSTACK) throw("NSTACK too small in sort.");
             if (ir-i+1 >= j-l)       // 右端较长，压入右端部分
             {
                 istack[jstack]=ir;
                 istack[jstack-1]=i;
                 ir=j-1;             // 修改右端指针
             }
             else                    // 压入左端部分入栈
             {
                 istack[jstack]=j-1;
                 istack[jstack-1]=l;
                 l=i;                // 修改左端指针
             }
         }
     }
 }

这里我没有给出行为的分析，因为这个很简单，我们直接来分析算法：首先我们考虑最理想的情况  
1.数组的大小是2的幂，这样分下去始终可以被2整除。假设为2的k次方，即k=log2(n)。  
2.每次我们选择的值刚好是中间值，这样，数组才可以被等分。  
第一层递归，循环n次，第二层循环2*(n/2)......  
所以共有n+2(n/2)+4(n/4)+...+n*(n/n) = n+n+n+...+n=k*n=log2(n)*n  
所以算法复杂度为O(log2(n)*n)  
其他的情况只会比这种情况差，最差的情况是每次选择到的middle都是最小值或最大值，那么他将变  
成交换法（由于使用了递归，情况更糟）。

第二种方法采用了一些优化方法，效率要更高，避免了出现最坏的情况 。
如果你担心这个问题，你可以使用堆排序，这是一种稳定的O(log2(n)*n)算法，但是通常情况下速度要慢 
于快速排序（因为要重组堆）。

 

7、堆排序

堆排序的完整实现。代表了一个大公司的整个生存循环：雇佣N/2个工人，雇佣N/2个潜在的管理者，有一个值为升迁的过程，它是一种超级Peter原理的排序；最后按注定的过程：每个原来的雇员被一次提升为总裁。

 

堆排序的过程是：

1. 创建一个堆H[0..n-1]
2. 把堆首（最大值）和堆尾互换
3. 把堆的尺寸缩小1，并调用shift_down,目的是把新的数组顶端数据调整到相应位置，即重建堆
4. 重复步骤2，直到堆的尺寸为1

 

 // 元素提升（上移），从[l,r]的元素中提出最大值作为堆[l,r]的堆顶。
 // 创建堆时：假设堆的形式是公司组织的二叉树结构，首先有N/2个元素作为员工，然后每进入一个元素作为潜在管理者，
 //           选择两个员工作为其直属下级，并从下级中选择较大值作为这两个员工的上级
 //           并把新来的员工插入到被升级的员工的位置上去，直至进入N/4个员工，选出N/4个上层节点；
 //           然后再进入节点时，就作为更高层次的潜在管理者，需要从下一级中找寻较大的作为此位置的真正管理者，如果下级的要升级，要带动更下级的升级
 // 重建堆时：每次从堆顶的直接下一级中选择最大元素晋升为老板，同时带动更下级的升迁。
 // 堆的特点：二叉树的形式，根为最大值（大根堆），节点向上的通路是相对排序的，但横向相邻的元素却没有必然的大小。
 //
 // 把一个线性数组理解为一个二叉树，那么索引i处元素的直接下级的第一个元素为2i+1。同层元素顺序存储
 // 证明：设i所在树的层为a，其在改层第b个节点，则 i = 2^a-1+b， 其直接下级的第一个元素索引 j = 2^(a+1)-1+2b = 2i+1
 void shift_down(int* pData, int l, int r)
 {
     int j, jold;
     int a = pData[l];
     jold = l;       // jold用于存储a归位时的位置
     j = 2 * l + 1;  // j为l的直接下属的第一个元素
     while (j <= r)
     {
         // 与下属中较大的比较，找到比后面相邻的元素较大的元素
         if(j < r && pData[j] < pData[j+1]) j++;
         // 找到a所在的层，停止筛选。否则更新a，继续
         if (a >= pData[j]) break;
         // 把较大的元素提前
         pData[jold] = pData[j];
         jold = j;       // 更新a将要归位的位置
         j = 2 * j + 1;
     }
     pData[jold] = a;        // 将a归位
 }
 // 堆排序
 void HeapSort(int* pData, int nCount)
 {
     // 创建堆
     for(int i = nCount/2-1; i >= 0; i--)
         // 堆创建时，i作为shift_down的左范围从n/2-1 to 0
         shift_down(pData, i, nCount-1);
     // 堆排序
     for(int i = nCount-1; i > 0; i--)
     {
         // 堆选择时，shift_down的右范围从n-2 to 0
         std::swap(pData[0], pData[i]);  // 在数组尾部清出一个空间，使堆顶弹出并存入其中
         shift_down(pData, 0, i-1);      // 重建堆
     }
 }

堆排序的平均时间复杂度为O(nlogn)，空间复杂度为Θ(1)。

 

8、SHELL排序

 

 // 希尔排序，其中m数组中已有m个元素已排序
 // 思路：直接插入法的变形。选取一个逐渐递减的增量序列，按此增量对数组进行分组按直接插入法排序，然后减小增量再分组排序
 void ShellSort(int* pData, int nCount, int m)
 {
     int i, j, inc, n = nCount;
     int v;
     if (m > 0) n = min(m, n);
     inc = 1; // 确定初始增量
     do
     {
         inc *= 3;
         inc++;
     } while (inc <= n);
     do
     {
         // 部分排序的循环
         inc /= 3;       // 减小增量
         for (i = inc; i < n; i++)
         { // 直接插入法的外循环
             v = pData[i];
             j = i;
             while (pData[j - inc] > v)
             { // 直接插入法的内循环
                 pData[j] = pData[j - inc];
                 j -= inc;
                 if (j < inc) break;
             }
             pData[j] = v;
         }
     } while (inc > 1);
 }

 

三、其他排序 

9、双向冒泡： 又叫鸡尾酒排序
通常的冒泡是单向的，而这里是双向的，也就是说还要进行反向的工作。 
代码看起来复杂，仔细理一下就明白了，是一个来回震荡的方式。 

 // 双向冒泡排序
 void Bubble2Sort(int* pData, int nCount)
 {
     int i;
     int left = 1;
     int right =nCount -1;
     int t;
     do
     {
         //正向的部分
         for (i = right; i >= left; i--)
         {
             if(pData[i] < pData[i-1])
             {
                 std::swap(pData[i], pData[i-1]);
                 t = i;
             }
         }
         left = t+1;
         //反向的部分
         for(i = left; i < right + 1; i++)
         {
             if(pData[i] < pData[i-1])
             {
                 std::swap(pData[i], pData[i-1]);
                 t = i;
             }
         }
         right = t-1;
     }while(left <= right);
 }

双向冒泡排序最糟或是平均所花费的次数都是O(n²)，但如果序列在一开始已经大部分排序过的话，会接近O(n)。

 

10、计数排序

 

算法的步骤如下：

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

 

 // 计数排序
 void CountSort(int* pData, int nCount)
 {
     int i, j;
     // 计算排序数组的可取值范围
     int minNum = pData[0], maxNum = pData[0];
     for(i = 1; i < nCount; i++)
     {
         if(pData[i] < minNum)
             minNum = pData[i];
         else if(pData[i] > maxNum)
             maxNum = pData[i];
     }
     // 计数数组
     int range = maxNum - minNum + 1;
     int *pTemp = new int[range];
     memset(pTemp, 0, range * sizeof(int));
     // 如果元素存在，对应位置计数加1
     for(i = 0; i < nCount; ++i)
     {
         pTemp[pData[i]-minNum]++;
     }
     // 按顺序输出
     int k = 0;
     for(i = minNum; i <= maxNum; ++i)
         for(j = 0; j < pTemp[i - minNum]; ++j)
             pData[k++] = i;
     delete pTemp;
 }

 

当输入的元素是 n 个 0 到 k 之间的整数时，它的运行时间是 Θ(n + k)。

 

11、基数排序

将所有待比较数值(正整数)统一为同样的数位长度,数位较短的数前面补零. 然后, 从最低位开始, 依次进行一次排序.这样从最低位排序一直到最高位排序完成以后, 数列就变成一个有序序列.
基数排序的方式可以采用LSD（Least significant digital）或MSD（Most significant digital），LSD的排序方式由键值的最右边开始，而MSD则相反，由键值的最左边开始。

 // 基数排序
 // 思路：对数组元素每一位进行排序
 void RadixSort(int* pData, int nCount, int maxDigits)
 {
     const int base = 10;
     int arCountSort[10];
     int* pTemp = new int[nCount];
     int i, j;
     int t = 1;
     // LSD
     for(i = 0; i < maxDigits; ++i)
     {
         // 计数排序算子
         memset(arCountSort, 0, sizeof(int) * 10);
         for(j = 0; j < nCount; ++j)
         {
             arCountSort[pData[j]/t%base]++;
         }
         // 为了定位原元素的位置
         for(j = 1; j < 10; ++j)
         {
             arCountSort[j] += arCountSort[j-1];
         }
         // 按位排序好的数组写入临时数组里
         // 此处要用倒序，因为低位已经排过序，同一组优先进低位排序中靠后的
         for(j = nCount-1; j >= 0; --j)
         {
             int splitDigit = pData[j]/t%base;
             pTemp[arCountSort[splitDigit] - 1] = pData[j];
             arCountSort[splitDigit]--;
         }
         memcpy_s(pData, sizeof(int) * nCount, pTemp, sizeof(int) * nCount);
         t *= base;
     }
 }

 

 

MSD算法代码：

 // MSD法，基数排序+计数排序
 void RadixSort(int* pData, int index, int nCount, int maxDigits)
 {
     if(nCount <= 1 || maxDigits <= 0)
         return;
     const int base = 10;
     int arCountSort[base];      // 各位元素计数数组
     int arCountSortTemp[base];
     int* pTemp = new int[nCount];
     int i;
     int t = (int)pow((float)base, maxDigits-1);

     // 计数排序算子
     memset(arCountSort, 0, sizeof(int) * base);
     for(i = index; i < index + nCount; ++i)
     {
         arCountSort[pData[i]/t%base]++;
     }
     memcpy_s(arCountSortTemp, sizeof(int)*base, arCountSort, sizeof(int)*base);
     // 为了定位原元素的位置,此处每个arCountSort数组存放的是当前位前所有值的个数
     for(i = 1; i < base; ++i)
     {
         arCountSort[i] += arCountSort[i-1];
     }
     for(i = 0; i < base; ++i)
     {
         arCountSort[i] -= arCountSortTemp[i];
     }
     // 正序输出
     for(i = index; i < index + nCount; ++i)
     {
         int splitDigit = pData[i]/t%base;
         // splitDigit也为当前值在arCountSort表示的桶内的索引
         pTemp[arCountSort[splitDigit]] = pData[i];
         arCountSort[splitDigit]++;
     }
     memcpy_s(pData + index, sizeof(int) * nCount, pTemp, sizeof(int) * nCount);
     // 递归
     RadixSort(pData, index, arCountSort[0], maxDigits-1);
     for(i = 1; i < base; ++i)
     {
         RadixSort(pData, index + arCountSort[i-1], arCountSort[i] - arCountSort[i-1], maxDigits-1);
     }
     delete pTemp;
 }
 void RadixSortMSD(int* pData, int nCount, int maxDigits)
 {
     RadixSort(pData, 0, nCount, maxDigits);
     printf_s("基数排序结果：");
     for(int i = 0; i < nCount; i++)
     {
         printf_s("%d ", pData[i]);
     }
     printf_s("/n");
 }