数据结构：史上最全排序算法合集

计数排序

计数排序是利用元素在序列中的名次，将元素移动到与其名次对应的位置。
我们先来看看代码：

template <class T>
void rank(T a[],int n,int r[])
{//给数组a排出名次，写到数组r中
    for(int i=0;i<n;i++)
        r[i]=0;
    //比较所有元素对
    for(int i=0;i<n-1;i++)
        for(int j=i+1;j<n;j++)
            if(a[j]>=a[i]) r[j]++;
            else r[i]++;
}
template <class T>
void rearrange(T a[],int n,int r[])
{//使用一个附加数组使元素排序
    T *u[] = new T[n];//创建附加数组

    for(int i=0;i<n;i++)//将a中的元素按顺序排入数组u中
        u[i] = a[r[i]];
    for(int i=0;i<n;i++)//将u中的元素复制进数组a中
        a[i] = u[i];
    delete []u;
}

假设调用new操作符分配空间的操作是成功的，那么执行函数rearrange，完成排序需要(n-1)n/2次比较与2n次移动，复杂度是Q(n²)。
如果我们不想使用附加数组，那我们来试试原地重排，代码如下：

template <class T>
void rearrange2(T a[],int n,int r[])
{//原地重排
    for(int i=0;i<n;i++)
        while (r[i]!=i)
        {
            swap(a[i],a[r[i]]);
            swap(r[i],r[r[i]]);
        }
}

在优化后的算法中，我们易知，交换次数最少为0，最多为2(n-1)（应为每次交换会使得至少一个元素在正确的位置上，所以会交换(n-1)次），由此可见，优化后的算法复杂度为Q(n-1)，而且程序所需内存减少了。

选择排序

选择排序是指首先找到最大的元素，把它移到最高位，然后在找到其余元素中最大的元素，把它移到次高位。如此进行下去，直到剩下一个元素。
看看代码吧：

template <class T>
int indexOfMax(T a[],int n)
{//查找数组的最大元素
    int indexOfMax = 0;
    for(int i = 1;i<n;i++)
        if(a[indexOfMax]<a[i])
            indexOfMax = i;
    return indexOfMax;
}
template <class T>
void selectionSort(T a[],int n)
{//选择排序
    for(int i=n;i>1;i--) {
        int j = indexOfMax(a, i);
        swap(a[j], a[i - 1]);
    }
}

在这个算法中，我们需要比较(n-1)n/2次，元素的移动次数3(n-1)次，这样我们的比较次数与计数排序相同，但是移动次数更多，那么我们为了降低时间复杂度，我们看下一种选择排序算法：

template <class T>
void selectionSort2(T a[],int n)
{//及时终止的选择排序
    bool sort = false;//判断数列是否有序
    for(int i=n;!sort&&(i>1);i--){
        int indexOfMax = 0;
        sort = true;
        //查找最大的元素
        for(int j=1;j<i;j++) {
            if (a[indexOfMax] <= a[j]) indexOfMax = j;
            else sort = false;
        }
        swap(a[indexOfMax],a[i-1]);
    }
}

对于及时终止的选择排序，最好的情况是一开始数组元素有序，这是外部的for循环只运行一次，数组元素的比较次数为(n-1)次，最坏的情况是外部的for循环直到i=1使才停止，比较次数为(n-1)n/2。

冒泡排序

冒泡排序是一种简单的排序算法，它使用一种“冒泡策略”，把最大的元素一道序列的最右端。
在一次冒泡中，，相邻的元素比较，如果左边的元素大于右边的元素，则交换，反之，无需交换。
一次冒泡完成后，我们得到一个新的序列，在这个序列中，最大的元素已经到了序列最右端，我们只需要将除去最大数的序列再进行冒泡过程，反复至最后一个元素，则排序完成。
我们来看看代码：

template <class T>
void bubbleSort(T a[],int n)
{//对数组元素使用冒泡排序
    for(int i=n;i>1;i--){
        for(int j=0;j<i-1;j++)
            if(a[j]>a[j+1])
                swap(a[j],a[j+1]);
    }
}

这段代码结构十分的简单，嵌套的循环为一个序列的一次冒泡过程。在冒泡排序中，长度为n的序列，我们共需要比较n(n-1)/2次，所需交换次数最多为n(n-1)/2次，最少为0次。时间复杂度为Q(n²)。

插入排序

插入排序是采用一中插入策略，通过例子我们应该会比较好理解：
我们将3这个数插入有序数列：2,4,6,8,9,12,15；我们会如何做呢？我们通过数组基本的操作遍历，从数组最右端开始连续把一些元素向右移动一些位置，知道为新元素找到位置，将元素放入就可以了。在我们这个数组中我们要将2以后的数字向后移动一位，然后将3插入第二个位置。
当我们明白了一次插入的方法后，就要考虑插入排序了。我们先来看看代码：

template <class T>
void insertSort(T a[],int n)
{
    for(int i=1;i<n+1;i++){
        T t = a[i];
        int j;
        for (j = i-1; j >= 0 && t < a[j]; j--)
            a[j+1] = a[j];
        a[j+1] = t;
    }
}

在这段代码中，我们明显的可以看到，我们将一个数字取出，虽然开始时为乱序，但我们的插入策略是插入到比自己打的数前面，具体实现为：

for (j = i-1; j >= 0 && t < a[j]; j--)

但我们将所有的数字遍历完成后，就会变为有序的数列。
现在我们来进行程序性能分析，在这种排序方法中，最好的比较次数是n-1，最坏的比较次数是n(n-1)/2，数组的移动最坏为n(n-1)/2，效率相对其他集中来讲比较低，但是逻辑简单，特别是一次有序插入，用处比较多。

基数排序

基数排序实际上是对数据结构中箱子排序的扩展，时间复杂度仅为Q(n)，就可以对0~n^c之间的n个整数进行排序，它不直接对数进行排序，而是把数按照某个基数分解为数，例如我们说1024=110³+010²+2*10+4；就是把1024按照10为基数进行排序。为了更好地进行理解，我们来看一道例题：
无需数列： 99,1,28,64,1024,2346,57,3;
1.我们要利用基数排序将其变为由小到大的有序数列，那我们先从低位由基数取数字，分别为：9,1,8,4,4,6,7,3，将其对应的数排序后得：1,3,64,1024,2346,57,28,99;
2.之后，我们在取十位的数字：0,0,6,2,4,5,2,9;将其对应得数进行排序可得：1,3,1024,28,2346,57,64,99；
3.然后，我们再取百位的数字：0,0,0,0,3,0,0,0，将其对用的数进行排序可得：
1,3,1024,28,57,64,99,2346；
4，最后，大家想必也猜到了，取千位的数字：0,0,1,0,0,0,0,2；将其对应的数进行排序：1,3,28,57,64,99,1024,2346
最终，我们得到了有序的数列。
在基数排序中，我们的基本思路就是将0~9作为十个桶，将位上的数字分别放入这十个桶中再取出，通过每一位的排序，最终可以得到有序的序列。
接下来，我们来看看代码：

int bitMaxNum(int a[],int n)
{
    int maxNum = 0;
    for(int i=0;i<n;i++){
        int temp = a[i];
        int max = 0;
        while (temp!=0){
            temp=temp/10;
            max++;
        }
        if(max>maxNum)
            maxNum = max;
    }
    return maxNum;
}

这个函数是用来确定数列中数的最大的位数，那么我们再来看看基数排序的函数部分：

void bucketSort(int a[],int bitMaxNum,int n)
{
    int bit = 1;//确定计算的数位
    for(int i=0;i<bitMaxNum;i++){
        int temp = 0;
        int bucket[10][n];//定义十个桶
        int count[10];//每个桶中元素个数
        for(int j=0;j<10;j++)//初始化
            count[j] = 0;
        for(int j=0;j<10;j++)//初始化
            for(int k=0;k<n;k++)
                bucket[j][k] = 0;
        for(int j=0;j<n;j++){
            int num = a[j]/bit;//确定数位
            int bucketNum = num%10;//取该位上的数字
            bucket[bucketNum][count[bucketNum]] = a[j];//放入桶
            count[bucketNum]++;
        }
        for(int j=0;j<10;j++){//从桶中取出数
            if(count[j]>0)
                for(int k=0;k<count[j];k++){
                    a[temp] = bucket[j][k];
                    temp++;
                }
        }
        bit = bit*10;//取更高位
    }
}

由此，我们可以完成了基数排序。

题外话：稳定排序

先来讲讲稳定排序的概念：当我们说一个排序算法能保证同值元素的相对位置不变，我们就说这个排序算法是稳定的。通俗的说，例如a₁=a₂ ，排序完成后，a₁，a₂的相对顺序没有变，那么这个排序算法是稳定的。
那我们来看看我们刚说的几种排序算法：
基数排序，冒泡排序无疑是稳定的，而选择排序，计数排序，插入排序是不稳定的。
当然了，事无绝对，我们对算法进行改进，不稳定的算法也可以变为稳定的，这里就不多赘述了。

（由于学艺不精，可能不全的以后会补上…）