• C++经典排序总结

    　　首先咱们必须要知道算法，

    　　0.1算法分类

    　　　　十种常见的排序算法可以分为两大类：

    　　　　　　非线性时间比较类排序：通过比较来决定元素之间的相对次序，由于其时间复杂度不能突破O（nlogn），因此称为非线性时间类比较类排序。

    　　　　　　线性时间非比较类排序：不通过比较来决定元素之间的次序，它可以突破基于比较排序的下界，以线性时间运行，因此成为线性时间非比较类排序。

     

     0.2算法复杂度

     

     0.3相关概念

    　　　　稳定：如果a原本在b前面，而a=b，排序之后a仍然在b的前面。

    　　　　不稳定：如果a原本在b的前面，而a=b，排序之后 a 可能会出现在 b 的后面。

    　　　　时间复杂度：对排序数据的总的操作次数。反映当n变化时，操作次数呈现什么规律。

    　　　　空间复杂度：是指算法在计算机内执行时所需存储空间的度量，它也是数据规模n的函数。

    二、快速排序

    　　假设我们现在对“6  1  2 7  9  3  4  5 10  8”这个10个数进行排序。首先在这个序列中随便找一个数作为基准数（不要被这个名词吓到了，就是一个用来参照的数，待会你就知道它用来做啥的了）。为了方便，就让第一个数6作为基准数吧。接下来，需要将这个序列中所有比基准数大的数放在6的右边，比基准数小的数放在6的左边，类似下面这种排列：

    ?
    1
    3  1  2 5  4  6  9 7  10  8

     

    　　

    在初始状态下，数字6在序列的第1位。我们的目标是将6挪到序列中间的某个位置，假设这个位置是k。现在就需要寻找这个k，并且以第k位为分界点，左边的数都小于等于6，右边的数都大于等于6，递归对左右两个区间进行同样排序即可。想一想，你有办法可以做到这点吗？这就是快速排序所解决的问题。

    快速排序是C.R.A.Hoare于1962年提出的一种划分交换排序。它采用了一种分治的策略，通常称其为分治法(Divide-and-ConquerMethod)。它的平均时间复杂度为O(nlogn)，最坏时间复杂度为O(n^2).

    首先上图：

     

     

     

     从图中我们可以看到：

    left指针，right指针，base参照数。

    其实思想是蛮简单的，就是通过第一遍的遍历（让left和right指针重合）来找到数组的切割点。

    第一步：首先我们从数组的left位置取出该数（20）作为基准（base）参照物。(如果是选取随机的，则找到随机的哨兵之后，将它与第一个元素交换，开始普通的快排)

    第二步：从数组的right位置向前找，一直找到比（base）小的数，如果找到，将此数赋给left位置（也就是将10赋给20），此时数组为：10，40，50，10，60， left和right指针分别为前后的10。

    第三步：从数组的left位置向后找，一直找到比（base）大的数，如果找到，将此数赋给right的位置（也就是40赋给10），此时数组为：10，40，50，40，60， left和right指针分别为前后的40。

    第四步：重复“第二,第三“步骤，直到left和right指针重合，最后将（base）放到40的位置， 此时数组值为： 10，20，50，40，60，至此完成一次排序。

    第五步：此时20已经潜入到数组的内部，20的左侧一组数都比20小，20的右侧作为一组数都比20大， 以20为切入点对左右两边数按照"第一，第二，第三，第四"步骤进行，最终快排大功告成。

    快速排序代码如下：

    ?
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    //快速排序，随机选取哨兵放前面
    void QuickSort(int* h, int left, int right)
    {
        if(h==NULL) return;
        if(left>=right) return;
         
        //防止有序队列导致快速排序效率降低
        srand((unsigned)time(NULL));
        int len=right-left;
        int kindex=rand()%(len+1)+left;
        Swap(h[left],h[kindex]);
         
        int key=h[left],i=left,j=right;
        while(i<j)
        {
            while(h[j]>=key && i<j) --j;
            if(i<j) h[i]=h[j];
            while(h[i]<key && i<j) ++i;
            if(i<j) h[j]=h[i];
        }
         
        h[i]=key;
         
        //QuickSort(&h[left],0,i-1);
        //QuickSort(&h[j+1],0,right-j-1);
         
        QuickSort(h,left,i-1);
        QuickSort(h,j+1,right);
    }

    　　

    三、冒泡排序

    1.原理

    冒泡排序在扫描过程中两两比较相邻记录，如果反序则交换，最终，最大记录就被“沉到”了序列的最后一个位置，第二遍扫描将第二大记录“沉到”了倒数第二个位置，重复上述操作，直到n-1 遍扫描后，整个序列就排好序了。

     

     

     

     算法实现：

    ?
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    //冒泡排序
    void BubbleSort(int* h, size_t len)
    {
        if(h==NULL) return;
        if(len<=1) return;
        //i是次数，j是具体下标
        for(int i=0;i<len-1;++i)
            for(int j=0;j<len-1-i;++j)
                if(h[j]>h[j+1])
                    Swap(h[j],h[j+1]);
                     
        return;
    }

    　　

    四、选择排序

    选择排序也是一种简单直观的排序算法。它的工作原理很容易理解：初始时在序列中找到最小（大）元素，放到序列的起始位置作为已排序序列；然后，再从剩余未排序元素中继续寻找最小（大）元素，放到已排序序列的末尾。以此类推，直到所有元素均排序完毕。

    注意选择排序与冒泡排序的区别：冒泡排序通过依次交换相邻两个顺序不合法的元素位置，从而将当前最小（大）元素放到合适的位置；而选择排序每遍历一次都记住了当前最小（大）元素的位置，最后仅需一次交换操作即可将其放到合适的位置。

    算法实现：

    ?
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    //选择排序
    void SelectionSort(int* h, size_t len)
    {
        if(h==NULL) return;
        if(len<=1) return;
         
        int minindex,i,j;
        //i是次数，也即排好的个数;j是继续排
        for(i=0;i<len-1;++i)
        {
            minindex=i;
            for(j=i+1;j<len;++j)
            {
                if(h[j]<h[minindex]) minindex=j;
            }
            Swap(h[i],h[minindex]);
        }
         
        return;
    }

    　　

    五、插入排序

    直接插入排序（straight insertion sort），有时也简称为插入排序（insertion sort），是减治法的一种典型应用。其基本思想如下：

    • 对于一个数组A[0,n]的排序问题，假设认为数组在A[0,n-1]排序的问题已经解决了。
    • 考虑A[n]的值，从右向左扫描有序数组A[0,n-1]，直到第一个小于等于A[n]的元素，将A[n]插在这个元素的后面。

    　　很显然，基于增量法的思想在解决这个问题上拥有更高的效率。

    直接插入排序对于最坏情况（严格递减的数组），需要比较和移位的次数为n(n-1)/2；对于最好的情况（严格递增的数组），需要比较的次数是n-1，需要移位的次数是0。当然，对于最好和最坏的研究其实没有太大的意义，因为实际情况下，一般不会出现如此极端的情况。然而，直接插入排序对于基本有序的数组，会体现出良好的性能，这一特性，也给了它进一步优化的可能性。（希尔排序）。直接插入排序的时间复杂度是O(n^2)，空间复杂度是O(1)，同时也是稳定排序。

    下面用一个具体的场景，直观地体会一下直接插入排序的过程：

    场景：

    现有一个无序数组，共7个数：89 45 54 29 90 34 68。

    使用直接插入排序法，对这个数组进行升序排序。

    89 45 54 29 90 34 68

    45 89 54 29 90 34 68

    45 54 89 29 90 34 68

    29 45 54 89 90 34 68

    29 45 54 89 90 34 68

    29 34 45 54 89 90 68

    29 34 45 54 68 89 90

     

    算法实现：

    ?
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    //插入排序
    void InsertSort(int* h, size_t len)
    {
        if(h==NULL) return;
        if(len<=1) return;
         
        int i,j;
        //i是次数，也即排好的个数;j是继续排
        for(i=1;i<len;++i)
            for(j=i;j>0;--j)
                if(h[j]<h[j-1]) Swap(h[j],h[j-1]);
                else break;
                 
        return;
    }

    　　

    六、归并排序

    基本思想

    　　归并排序（MERGE-SORT）是利用归并的思想实现的排序方法，该算法采用经典的分治（divide-and-conquer）策略（分治法将问题分(divide)成一些小的问题然后递归求解，而治(conquer)的阶段则将分的阶段得到的各答案"修补"在一起，即分而治之)。

    分而治之

     

     

     

    可以看到这种结构很像一棵完全二叉树，本文的归并排序我们采用递归去实现（也可采用迭代的方式去实现）。分阶段可以理解为就是递归拆分子序列的过程，递归深度为log2n。

    合并相邻有序子序列

    　　再来看看治阶段，我们需要将两个已经有序的子序列合并成一个有序序列，比如上图中的最后一次合并，要将[4,5,7,8]和[1,2,3,6]两个已经有序的子序列，合并为最终序列[1,2,3,4,5,6,7,8]，来看下实现步骤。

     

     

     

     

     算法实现：

    ?
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    //归并排序
    void  MergeArray(int* arr, size_t left, size_t mid, size_t right, int* temp)
    {
        if(arr==NULL) return;
         
        size_t i=left,j=mid+1,k=0;
        while(i<=mid && j<=right)
        {
            if(arr[i]<=arr[j])
            {
                temp[k++]=arr[i++];
                continue;
            }
             
            temp[k++]=arr[j++];
        }
         
        while(i<=mid)
            temp[k++]=arr[i++];
             
        while(j<=right)
            temp[k++]=arr[j++];
             
        memcpy(&arr[left],temp,k*sizeof(int));
             
        return;
    }
     
    void MMergeSort(int* arr, size_t left, size_t right, int* temp)
    {
        if(left<right)
        {
            size_t mid=(left+right)/2;
            MMergeSort(arr, left, mid, temp);
            MMergeSort(arr, mid+1,right, temp);
            MergeArray(arr,left, mid, right, temp);
        }
    }
     
    void MergeSort(int* h, size_t len)
    {
        if(h==NULL) return;
        if(len<=1) return;
        int* temp=(int*)calloc(len,sizeof(int));
        MMergeSort(h, 0, len-1, temp);
         
        memcpy(h,temp,sizeof(int)*len);
         
        free(temp);
         
        return;
    }

    　　

    七、希尔排序

    希尔排序是希尔（Donald Shell）于1959年提出的一种排序算法。希尔排序也是一种插入排序，它是简单插入排序经过改进之后的一个更高效的版本，也称为缩小增量排序，同时该算法是冲破O(n2）的第一批算法之一。本文会以图解的方式详细介绍希尔排序的基本思想及其代码实现。

    基本思想

    　　希尔排序是把记录按下标的一定增量分组，对每组使用直接插入排序算法排序；随着增量逐渐减少，每组包含的关键词越来越多，当增量减至1时，整个文件恰被分成一组，算法便终止。

    　　简单插入排序很循规蹈矩，不管数组分布是怎么样的，依然一步一步的对元素进行比较，移动，插入，比如[5,4,3,2,1,0]这种倒序序列，数组末端的0要回到首位置很是费劲，比较和移动元素均需n-1次。而希尔排序在数组中采用跳跃式分组的策略，通过某个增量将数组元素划分为若干组，然后分组进行插入排序，随后逐步缩小增量，继续按组进行插入排序操作，直至增量为1。希尔排序通过这种策略使得整个数组在初始阶段达到从宏观上看基本有序，小的基本在前，大的基本在后。然后缩小增量，到增量为1时，其实多数情况下只需微调即可，不会涉及过多的数据移动。

    　　我们来看下希尔排序的基本步骤，在此我们选择增量gap=length/2，缩小增量继续以gap = gap/2的方式，这种增量选择我们可以用一个序列来表示，{n/2,(n/2)/2...1}，称为增量序列。希尔排序的增量序列的选择与证明是个数学难题，我们选择的这个增量序列是比较常用的，也是希尔建议的增量，称为希尔增量，但其实这个增量序列不是最优的。此处我们做示例使用希尔增量。

     

     算法实现：

    ?
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    //希尔排序
    void ShellSort(int* h, size_t len)
    {
        if(h==NULL) return;
        if(len<=1) return;
         
        for(int div=len/2;div>=1;div/=2)
            for(int k=0;k<div;++k)
                for(int i=div+k;i<len;i+=div)
                    for(int j=i;j>k;j-=div)
                        if(h[j]<h[j-div]) Swap(h[j],h[j-div]);
                        else break;
                     
        return;
    }

    　　

     

    八、堆排序

    堆排序实际上是利用堆的性质来进行排序的，要知道堆排序的原理我们首先一定要知道什么是堆。 
    堆的定义： 
    堆实际上是一棵完全二叉树。 
    堆满足两个性质: 
    1、堆的每一个父节点都大于（或小于）其子节点； 
    2、堆的每个左子树和右子树也是一个堆。 
    堆的分类： 
    堆分为两类： 
    1、最大堆（大顶堆）：堆的每个父节点都大于其孩子节点； 
    2、最小堆（小顶堆）：堆的每个父节点都小于其孩子节点；

      

     

     

     堆的存储： 
    一般都用数组来表示堆，i结点的父结点下标就为(i – 1) / 2。它的左右子结点下标分别为2 * i + 1和2 * i + 2。如下图所示：

     

     堆排序： 
    由上面的介绍我们可以看出堆的第一个元素要么是最大值（大顶堆），要么是最小值（小顶堆），这样在排序的时候（假设共n个节点），直接将第一个元素和最后一个元素进行交换，然后从第一个元素开始进行向下调整至第n-1个元素。所以，如果需要升序，就建一个大堆，需要降序，就建一个小堆。 
    堆排序的步骤分为三步: 
    1、建堆（升序建大堆，降序建小堆）； 
    2、交换数据； 
    3、向下调整。 
    假设我们现在要对数组arr[]={8,5,0,3,7,1,2}进行排序（降序）： 
    首先要先建小堆： 

     

     堆建好了下来就要开始排序了：

     

     现在这个数组就已经是有序的了。

    算法实现：

    ?
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    //堆排序
    /*
    大顶堆sort之后，数组为从小到大排序
    */
    //====调整=====
    void AdjustHeap(int* h, int node, int len)  //----node为需要调整的结点编号，从0开始编号;len为堆长度
    {
        int index=node;
        int child=2*index+1; //左孩子，第一个节点编号为0
        while(child<len)
        {
            //右子树
            if(child+1<len && h[child]<h[child+1])
            {
                child++;
            }
            if(h[index]>=h[child]) break;
            Swap(h[index],h[child]);
            index=child;
            child=2*index+1;
        }
    }
     
     
    //====建堆=====
    void MakeHeap(int* h, int len)
    {
        for(int i=len/2;i>=0;--i)
        {
            AdjustHeap(h, i, len);
        }
    }
     
    //====排序=====
    void HeapSort(int* h, int len)
    {
        MakeHeap(h, len);
        for(int i=len-1;i>=0;--i)
        {
            Swap(h[i],h[0]);
            AdjustHeap(h, 0, i);
        }
    }

    　　

    九、基数排序

    基数排序与本系列前面讲解的七种排序方法都不同，它不需要比较关键字的大小。

    它是根据关键字中各位的值，通过对排序的N个元素进行若干趟“分配”与“收集”来实现排序的。 

    1.LSD(低位到高位的排序)

    不妨通过一个具体的实例来展示一下，基数排序是如何进行的。 

    设有一个初始序列为: R {50, 123, 543, 187, 49, 30, 0, 2, 11, 100}。

    我们知道，任何一个阿拉伯数，它的各个位数上的基数都是以0~9来表示的。

    所以我们不妨把0~9视为10个桶。 

    我们先根据序列的个位数的数字来进行分类，将其分到指定的桶中。例如：R[0] = 50，个位数上是0，将这个数存入编号为0的桶中。

     

     

    分类后，我们在从各个桶中，将这些数按照从编号0到编号9的顺序依次将所有数取出来。

    这时，得到的序列就是个位数上呈递增趋势的序列。 

    按照个位数排序： {50, 30, 0, 100, 11, 2, 123, 543, 187, 49}。

    接下来，可以对十位数、百位数也按照这种方法进行排序，最后就能得到排序完成的序列。

    LSD 算法实现：

    ?
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    88
    89
    90
    91
    92
    93
    94
    95
    96
    97
    98
    99
    100
    101
    102
    103
    104
    105
    106
    107
    108
    109
    110
    111
    112
    113
    114
    int GetMaxDight(int* h, int len)
    {
        if(h==NULL) return 0;
        if(len<1) return 0;
         
        int max=h[0];
        for(int i=1;i<len;++i)
        {
            if(h[i]>max) max=h[i];
        }
         
        int digit=1;
        while(max/10!=0)
        {
            max/=10;
            ++digit;
        }
         
        return digit;
    }
     
    int GetReminder(int value,int digit)
    {
        int div=1;
        for(int i=1;i<digit;++i)
            div*=10;
         
        return value/div%10;
    }
     
    void RadixSort_LSD(int* h, int len)
    {
        if(h==NULL) return;
        if(len<=1) return;
         
        int digit=GetMaxDight(h,len);
        //printf("MaxDigit:%d\n", digit);
         
        int count[10]={0};
        int *tmp=(int*)calloc(len,sizeof(int));
         
        for(int d=1;d<=digit;++d)
        {
            memset(count,0,sizeof(count));
             
            for(int i=0;i<len;++i)
            {
                count[GetReminder(h[i],d)]++;
            }
             
            //求右边界
            for(int i=1;i<10;++i)
            {
                count[i]+=count[i-1];
            }
             
            for(int i=len-1;i>=0;--i)
            {
                int r=GetReminder(h[i],d);
                int index=count[r];
                tmp[index-1]=h[i];
                count[r]--;
            }
             
            memcpy(h,tmp,len*sizeof(int));
        }
         
        free(tmp);
    }
     
    void RadixSort_LSD_Reverse(int* h, int len)
    {
        if(h==NULL) return;
        if(len<=1) return;
         
        int digit=GetMaxDight(h,len);
        //printf("MaxDigit:%d\n", digit);
     
        int count[10]={0};
         
        int *tmp=(int*)calloc(len,sizeof(int));
         
        for(int d=1;d<=digit;++d)
        {
            memset(count,0,sizeof(count));
             
            for(int i=0;i<len;++i)
            {
                count[GetReminder(h[i],d)]++;
            }
             
            //printf("haha\n");
             
            //求右边界
            for(int i=8;i>=0;--i)
            {
                count[i]+=count[i+1];
            }
             
             
             
            for(int i=len-1;i>=0;--i)
            {
                int r=GetReminder(h[i],d);
                int index=count[r];
                tmp[index-1]=h[i];
                count[r]--;
            }
             
            memcpy(h,tmp,len*sizeof(int));
        }
         
        free(tmp);
    }

    　　

    2.MSD(高位到低位排序)

    下面我们直接来介绍MSD基数排序的步骤。

    MSD基数排序是从最高位开始对序列进行分组，到最低位为止。但是其实现过程是和LSD基数排序不同的，排序过程中需要用到递归函数。

    待排序序列

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

    我们看到，这里面的最大的数是3位数。所以说我们开始从百位对这些数进行分组

    0: 045, 075, 090,002, 024, 066
    1: 170
    2-7: 空
    8: 802
    9: 空

    从这里开始就和LSD基数排序有差别了。在LSD基数排序中，每次分好组以后开始对桶中的数据进行收集。然后根据下一位，对收集后的序列进行分组。而对于MSD，在这里不会对桶中的数据进行收集。我们要做的是检测每个桶中的数据。当桶中的元素个数多于1个的时候，要对这个桶递归进行下一位的分组。

    在这个例子中，我们要对0桶中的所有元素根据十位上的数字进行分组

    0: 002
    1: 空
    2: 024
    3: 空
    4: 045
    5: 空
    6: 066
    7: 075
    8: 空
    9: 090

    按照上面所说，我们应该再递归的对每个桶中的元素根据个位上的数进行分组。但是我们发现，现在在每个桶中的元素的个数都是小于等于1的。因此，到这一步我们就开始回退了。也就是说我们开始收集桶中的数据。收集完成以后，回退到上一层。此时按照百位进行分组的桶变成了如下的形式

    0: 002, 024, 045,066, 075, 090
    1: 170
    2-7: 空
    8: 802
    9: 空

    然后我们在对这个桶中的数据进行收集。收集起来以后序列如下

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

    整个MSD基数排序就是按照上面的过程进行的。

    在我对MSD基数排序步骤进行叙述的时候，中间递归函数的过程可能叙述的不够清楚。我个人建议对递归函数不了解的可以先了解一下递归函数的原理，然后再回来看这个过程可能对MSD基数排序过程更容易理解。

    算法实现：

    ?
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    88
    89
    90
    91
    92
    93
    94
    95
    96
    97
    98
    99
    100
    101
    102
    103
    104
    105
    106
    107
    108
    109
    110
    111
    112
    113
    114
    115
    116
    117
    118
    119
    120
    121
    122
    123
    124
    125
    126
    127
    128
    129
    130
    131
    132
    133
    134
    135
    136
    137
    138
    139
    140
    141
    142
    143
    144
    145
    146
    147
    148
    149
    150
    151
    152
    153
    154
    155
    int GetMaxDight(int* h, int len)
    {
        if(h==NULL) return 0;
        if(len<1) return 0;
         
        int max=h[0];
        for(int i=1;i<len;++i)
        {
            if(h[i]>max) max=h[i];
        }
         
        int digit=1;
        while(max/10!=0)
        {
            max/=10;
            ++digit;
        }
         
        return digit;
    }
     
    int GetReminder(int value,int digit)
    {
        int div=1;
        for(int i=1;i<digit;++i)
            div*=10;
         
        return value/div%10;
    }
     
    void RRadixSort_MSD(int* h, int begin, int end, int digit)
    {
        if(h==NULL) return;
        if(begin>=end) return;
        if(digit<1) return;
         
        int start[10];
        int count[10]={0};
        int *tmp=(int*)calloc(end-begin+1,sizeof(int));
         
        for(int i=begin;i<=end;++i)
        {
            count[GetReminder(h[i],digit)]++;
        }
         
        memcpy(start,count,sizeof(start));
         
        //求右边界
        for(int i=1;i<10;++i)
        {
            start[i]+=start[i-1];
        }
         
        for(int i=end;i>=begin;--i)
        {
            int r=GetReminder(h[i],digit);
            int index=start[r];
            tmp[index-1]=h[i];
            start[r]--;
        }
         
        /*
        for(int i=0;i<10;++i)
        {
            printf("%d ",start[i]);
        }
         
        printf("\n");
        */
         
        memcpy(&h[begin],tmp,(end-begin+1)*sizeof(int));
         
        for(int i=0;i<10;++i)
        {
            if(count[i]>1)
            {
                RRadixSort_MSD(h, start[i], start[i]+count[i]-1, digit-1);
            }
        }
    }
     
    void RadixSort_MSD(int* h, int len)
    {
        if(h==NULL) return;
        if(len<=1) return;
         
        int digit=GetMaxDight(h,len);
         
        //printf("MaxDigit:%d\n",digit);
         
        RRadixSort_MSD(h, 0, len-1, digit);
    }
     
    void RRadixSort_MSD_Reverse(int* h, int begin, int end, int digit)
    {
        if(h==NULL) return;
        if(begin>=end) return;
        if(digit<1) return;
         
        int start[10];
        int count[10]={0};
        int *tmp=(int*)calloc(end-begin+1,sizeof(int));
         
        for(int i=begin;i<=end;++i)
        {
            count[GetReminder(h[i],digit)]++;
        }
         
        memcpy(start,count,sizeof(start));
         
        //求右边界
        for(int i=8;i>=0;--i)
        {
            start[i]+=start[i+1];
        }
         
        for(int i=end;i>=begin;--i)
        {
            int r=GetReminder(h[i],digit);
            int index=start[r];
            tmp[index-1]=h[i];
            start[r]--;
        }
         
        /*
        for(int i=0;i<10;++i)
        {
            printf("%d ",start[i]);
        }
         
        printf("\n");
        */
         
        memcpy(&h[begin],tmp,(end-begin+1)*sizeof(int));
         
        for(int i=0;i<10;++i)
        {
            if(count[i]>1)
            {
                RRadixSort_MSD_Reverse(h, start[i], start[i]+count[i]-1, digit-1);
            }
        }
    }
     
    void RadixSort_MSD_Reverse(int* h, int len)
    {
        if(h==NULL) return;
        if(len<=1) return;
         
        int digit=GetMaxDight(h,len);
         
        //printf("MaxDigit:%d\n",digit);
         
        RRadixSort_MSD_Reverse(h, 0, len-1, digit);
    }

    　　十、主函数

     

    　　

    ?
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    void Swap(int& a, int& b)
    {
        int t=a;
        a=b;
        b=t;
         
        return;
    }
     
    int main()
    {
        int A[10]={0};
        srand((unsigned)time(NULL));
         
        printf("before:\n");
        for(int i=0;i<10;++i)
        {
            A[i]=rand()%100;
            printf("%d ",A[i]);
        }
        printf("\n");
         
        printf("after:\n");
        //QuickSort(A,0,9);
        //BubbleSort(A,sizeof(A)/sizeof(int));
        //SelectionSort(A,sizeof(A)/sizeof(int));
        //InsertSort(A,sizeof(A)/sizeof(int));
        //MergeSort(A,sizeof(A)/sizeof(int));
        //ShellSort(A,sizeof(A)/sizeof(int));
        //HeapSort(A,sizeof(A)/sizeof(int));
        //RadixSort_LSD(A,sizeof(A)/sizeof(int));
        //RadixSort_MSD(A,sizeof(A)/sizeof(int));
        //RadixSort_LSD_Reverse(A,sizeof(A)/sizeof(int));
        RadixSort_MSD_Reverse(A,sizeof(A)/sizeof(int));
        for(int i=0;i<sizeof(A)/sizeof(int);++i)
        {
            printf("%d ",A[i]);
        }
        printf("\n");
         
        return 0;
    }

    　　

    posted @   WinkJie  阅读(271)  评论(0)  编辑  收藏  举报
    编辑推荐：
    · 开发者必知的日志记录最佳实践
    · SQL Server 2025 AI相关能力初探
    · Linux系列：如何用 C#调用 C方法造成内存泄露
    · AI与.NET技术实操系列（二）：开始使用ML.NET
    · 记一次.NET内存居高不下排查解决与启示
    阅读排行：
    · Manus重磅发布：全球首款通用AI代理技术深度解析与实战指南
    · 被坑几百块钱后，我竟然真的恢复了删除的微信聊天记录！
    · 没有Manus邀请码？试试免邀请码的MGX或者开源的OpenManus吧
    · 园子的第一款AI主题卫衣上架——"HELLO! HOW CAN I ASSIST YOU TODAY
    · 【自荐】一款简洁、开源的在线白板工具 Drawnix

    喜欢请打赏

    扫描二维码打赏

    支付宝打赏

    点击右上角即可分享
    微信分享提示