原博客

1.选择排序(Selection Sort)：

选择最小元素，移动到首位置。

(1)算法描述和实现：

• 首先选择数组中最小的元素，然后与数组的第一个元素交换；

• 再从剩下的数据选择最小的元素，与数组的第二个元素交换；
• 如此往复，直到整个数组排序；

template <class E>
void selectSort(E *arr,int n)
{
    for(int i=0;i<n;i++)
    {
        int minIndex=i;
        for(int j=i+1;j<n;j++)
        {
            if(arr[j]<arr[minIndex])
            {
                minIndex=j;
            }
        }
        if(minIndex!=i) swap(arr[i],arr[minIndex]);
    }
}

(2)选择排序动图演示：

(3)算法分析

时间复杂度：

• 最好情况：Θ(n²)
• 最差情况：Θ(n²)
• 平均情况 ：Θ(n²)

辅佐空间：

• 无

2.冒泡排序（Bubble Sort）

对相邻元素进行比较调整的排序算法。它重复地走过排序的数列，比较相邻元素，如果他们的顺序错误就把他们交换过来。如果没有错误的顺序，说明数列已经排序完成。这个算法名字的由来是因为整个过程就像烧开水一样，较小值像水中的气泡一样往上冒，而每一趟都有一个最大的元素沉底。

（1）算法描述和实现：

• <1>.比较相邻的元素，如果第一个比第二个大，两者交换。

• <2>.对每一对相邻元素做同样的工作，从最开始的一对到最后一对。这样，最后一个元素就是当前序列的最大值。
• <3>.如果中途发现无逆序元素，则排序结束；否则当只剩下两个元素没排时，排完这一趟就结束。

无优化

template <class E>
void bubbleSort(E *arr,int n)
{
    for(int i=1;i<n;i++)//需要排n-1趟
    {
        for(int j=0;j<n-i;j++)
        {
            if(arr[j]>arr[j+1]) swap(arr[j],arr[j+1]);
        }
    }
}

改进冒泡排序 1：设置一个标志work，如果没有逆序对，则说明序列已经有序，算法结束。

template <class E>
void bubbleSort(E *arr,int n)
{
    int work;
    for(int i=1;i<n;i++)//需要排n-1趟
    {
        work=0;
        for(int j=0;j<n-i;j++)
        {
            if(arr[j]>arr[j+1])
            {
                swap(arr[j],arr[j+1]);
                work=1;
            }
        }
        if(!work) break;
    }
}

改进冒泡排序 2：设置标志位pos，用以记录最后一次进行交换的位置。由于pos之后的记录都已经交换到位，故在下一趟排序时只需要扫描到pos位置即可。

template <class E>
void bubbleSort(E *arr,int n)
{
    int pos,i=n-1;
    while(i>0)
    {
        pos=0;//每趟开始时，无交换记录
        for(int j=0;j<i;j++)
        {
            if(arr[j]>arr[j+1])
            {
                swap(arr[j],arr[j+1]);
                pos=j;//记录交换的位置
            }
        }
        i=pos;//为下一趟做准备
    }
}

改进冒泡排序 3：传统冒泡排序中每一趟排序操作只能找到一个最大值或最小值,我们考虑利用在每趟排序中进行正向和反向两遍冒泡的方法一次可以得到两个最终值(最大者和最小者) , 从而使排序趟数几乎减少了一半。

template <class E>
void bubbleSort(E *arr,int n)
{
    int low=0,high=n-1;
    while(low<high)
    {
        for(int i=low;i<high;i++)   //正向冒泡，找到最大值
        {
            if(arr[i]>arr[i+1]) swap(arr[i],arr[i+1]);
        }
        --high;                     //修改high值，前移一位
        for(int j=high;j>low;j--)   //反向冒泡，找到最小值
        {
            if(arr[j]<arr[j-1]) swap(arr[j],arr[j-1]);
        }
        ++low;                      //修改low值，后移一位
    }
}

(2)冒泡排序动图演示：

( 3 )算法分析
时间复杂度：

• 最佳情况：Θ（n）（当输入数据为正序时）
• 最坏情况：Θ（n²）（当输入数据为反序时）
• 平均情况：Θ（n²）

辅佐空间：

• 无

3.插入排序（Insertion Sort )

通常人们整理牌的方法是将每一张牌插入到其他有序的牌中的合适位置，插入排序与此类似。

( 1 )算法描述和实现

• <1>.从第一个元素开始，该元素可以认为已经被排序；

• <2>.取出下一个元素，在已经排序的元素序列中从后向前扫描；
• <3>.如果该元素（已排序）大于新元素，将该元素移到下一位置；
• <4>.重复步骤3，直到找到已排序的元素小于或者等于新元素的位置；
• <5>.将新元素插入到该位置后；
• <6>.重复步骤2~5。

template <class E>
void insertSort(E *arr,int n)
{
    for(int i=1;i<n;i++)
    {
        E key=arr[i];
        int j=i-1;
        while(j>=0&&arr[j]>key)
        {
            arr[j+1]=arr[j];
            j--;
        }
        arr[j+1]=key;
    }
}

改进插入排序：查找合适位置时使用二分查找，这样移动元素就不需要一个个判断大小关系了。二分查找

template <class E>
void insertSort(E *arr,int n)
{
    for(int i=1;i<n;i++)
    {
        E key=arr[i];
        int lef=0,rig=i,mid;
        while(lef<rig)//查找key的上界，即查找第一个大于key的元素，没找到则lef=i
        {
            mid=(lef+rig)/2;
            if(arr[mid]<=key)
            {
                lef=mid+1;
            }
            else rig=mid;
        }
        int j=i-1;
        while(j>=lef)
        {
            arr[j+1]=arr[j];
            j--;
        }
        arr[lef]=key;
    }
}

插入排序动图演示:

(3)算法分析

时间复杂度

• 最佳情况：输入数组按升序排列。T(n) = Θ(n)
• 最坏情况：输入数组按降序排列。T(n) = Θ(n²)
• 平均情况：T(n) = Θ(n²)

辅佐空间：

• 无

4.希尔排序（ Shell Sort）

第一个突破O(n^2)的排序算法；是简单插入排序的改进版；它与插入排序的不同之处在于，它会优先比较距离较远的元素。希尔排序又叫缩小增量排序。希尔排序的核心在于间隔序列的设定。

（1）算法描述和实现

• <1>.选择一个增量序列t1,t2,...tk；其中,tk=1；

• <2>.按增量序列个数k，对序列进行k 趟排序；
• <3>.每趟排序，根据对应的增量ti，将待排序列分割成若干长度为m 的子序列，分别对各子表进行直接插入排序。仅增量因子为1 时，整个序列作为一个表来处理，表长度即为整个序列的长度。

template <class E>
void shellSort(E *arr,int n)
{
    int h=1;
    while(h<n/3) h=3*h+1;
    while(h>=1)
    {
        for(int i=h;i<n;i++)
        {
            E key=arr[i];
            int j=i-h;
            while(j>=0&&arr[j]>key)
            {
                arr[j+h]=arr[j];
                j-=h;
            }
            arr[j+h]=key;
        }
        h/=3;
    }
}

希尔排序图示（图片来源网络）：

（2）算法分析：

时间复杂度

• 最佳情况：T(n) = Θ(n^(1+c1))
• 最坏情况：T(n) = Θ(n^(1+c2))
• 平均情况：T(n) =Θ(n^(1+c3))

辅佐空间：

• 无

5.归并排序（Merge Sort）

和选择排序一样，归并排序的性能不受输入数据的影响，但表现比选择排序好的多，因为始终都是O(n log n）的时间复杂度。代价是需要额外的内存空间。归并排序是建立在归并操作上的一种有效的排序算法。该算法是采用分治法（Divide and Conquer）的一个非常典型的应用。归并排序是一种稳定的排序方法。将已有序的子序列合并，得到完全有序的序列；即先使每个子序列有序，再使子序列段间有序。若将两个有序表合并成一个有序表，称为2-路归并。

( 1 )算法描述和实现

• <1>.把长度为n的输入序列分成两个长度为n/2的子序列；

• <2>.对这两个子序列分别采用归并排序；
• <3>.将两个排序好的子序列合并成一个最终的排序序列。

template <class E>
void merge(E *arr,E *aux,int lef,int mid,int rig)
{
    int i=lef,j=mid+1,k;
    for(k=lef;k<=rig;k++)
    {
        aux[k]=arr[k];
    }
    k=lef;
    while(i<=mid&&j<=rig)
    {
        /*
        if(aux[i]<aux[j]) arr[k++]=aux[i++];//非稳定排序
        else arr[k++]=aux[j++];
        */
        if(aux[i]<=aux[j]) arr[k++]=aux[i++];//稳定排序
        else arr[k++]=aux[j++];
    }
    if(i>mid)
    {
        while(j<=rig)
        {
            arr[k++]=aux[j++];
        }
    }
    if(j>rig)
    {
        while(i<=mid)
        {
            arr[k++]=aux[i++];
        }
    }
}
template<class E>
void mergeSort(E *arr,E *aux,int lef,int rig)
{
    if(rig<=lef) return;//区间长度小于等于1，不需要合并
    int mid=(lef+rig)/2;
    mergeSort(arr,aux,lef,mid);
    mergeSort(arr,aux,mid+1,rig);
    merge(arr,aux,lef,mid,rig);
}
template <class E>
void mergeSort(E *arr,int n)
{
    E *aux=new E[n];
    mergeSort(arr,aux,0,n-1);
}

归并排序动图演示:

(3)算法分析

时间复杂度：

• 最佳情况：T(n) = Θ(nlogn)
• 最差情况：T(n) = Θ(nlogn)
• 平均情况：T(n) = Θ(nlogn)

辅佐空间：

• Θ（n）

6.快速排序（Quick Sort）

快速排序的基本思想：通过一趟排序将待排记录分隔成独立的两部分，其中一部分记录的关键字均比另一部分的关键字小，则可分别对这两部分记录继续进行排序，以达到整个序列有序。

(2)算法描述和实现
快速排序使用分治法来把一个串（list）分为两个子串（sub-lists）。
具体算法描述如下：

• <1>.从数列中挑出一个元素，称为 "基准"（pivot）；

• <2>.重新排序数列，所有元素比基准值小的摆放在基准前面，所有元素比基准值大的摆在基准的后面（相同的数可以到任一边）。在这个分区退出之后，该基准就处于数列的中间位置。这个称为分区（partition）操作；
• <3>.递归地（recursive）把小于基准值元素的子数列和大于基准值元素的子数列排序。

首位置划分

template <class E>
int partition(E *arr,int lef,int rig)
{
    int i=lef,j=rig+1;
    E x=arr[lef];
    while(true)
    {
        while(arr[++i]<x&&i<rig);
        while(arr[--j]>x);
        if(i>=j) break;
        swap(arr[i],arr[j]);
    }
    arr[lef]=arr[j];
    arr[j]=x;
    return j;
}
template <class E>
void quickSort(E *arr,int lef,int rig)
{
    if(lef<rig)
    {
        int q=partition(arr,lef,rig);
        quickSort(arr,lef,q-1);
        quickSort(arr,q+1,rig);
    }
}
template <class E>
void quickSort(E *arr,int n)
{
    quickSort(arr,0,n-1);
}

随机划分：先随机找一个划分点，然后把这个划分点与首位置交换，则其他的代码与上面的一样。

template <class E>
int partition(E *arr,int lef,int rig)
{
    int i=lef,j=rig+1;
    int q=rand()%(rig-lef+1)+lef;
    swap(arr[lef],arr[q]);
    E x=arr[lef];
    while(true)
    {
        while(arr[++i]<x&&i<rig);
        while(arr[--j]>x);
        if(i>=j) break;
        swap(arr[i],arr[j]);
    }
    arr[lef]=arr[j];
    arr[j]=x;
    return j;
}
template <class E>
void quickSort(E *arr,int lef,int rig)
{
    if(lef<rig)
    {
        int q=partition(arr,lef,rig);
        quickSort(arr,lef,q-1);
        quickSort(arr,q+1,rig);
    }
}
template <class E>
void quickSort(E *arr,int n)
{
    srand(int(time(0)));
    quickSort(arr,0,n-1);
}

快速排序动图演示：

( 2 )算法分析

时间复杂度：

• 最佳情况：T(n) = Θ(nlogn)
• 最差情况：T(n) = Θ(n²)
• 平均情况：T(n) = Θ(nlogn)

辅佐空间：

• 无

7.堆排序（Heap Sort）

堆排序（Heapsort）是指利用堆这种数据结构所设计的一种排序算法。堆积是一个近似完全二叉树的结构，并同时满足堆积的性质：即子结点的键值或索引总是小于（或者大于）它的父节点。

( 2 )算法描述和实现

具体算法描述如下：

• <1>.将初始待排序关键字序列(R1,R2....Rn)构建成大顶堆，此堆为初始的无序区；
• <2>.将堆顶元素R[1]与最后一个元素R[n]交换，此时得到新的无序区(R1,R2,......Rn-1)和新的有序区(Rn),且满足R[1,2...n-1]<=R[n]；
• <3>.由于交换后新的堆顶R[1]可能违反堆的性质，因此需要对当前无序区(R1,R2,......Rn-1)调整为新堆，然后再次将R[1]与无序区最后一个元素交换，得到新的无序区(R1,R2....Rn-2)和新的有序区(Rn-1,Rn)。不断重复此过程直到有序区的元素个数为n-1，则整个排序过程完成。

template <class E>
void sink(E *arr,int k,int n)
{
    int j;
    while(2*k+1<n)
    {
        j=2*k+1;
        if(j<n-1&&arr[j]<arr[j+1]) j++;
        if(arr[k]>=arr[j]) break;
        swap(arr[k],arr[j]);
        k=j;
    }
}
template <class E>
void heapSort(E *arr,int n)
{
    for(int i=(n-1)/2;i>=0;i--)//构建堆
    {
        sink(arr,i,n);
    }
    while(n>1)//堆排序
    {
        swap(arr[0],arr[--n]);
        sink(arr,0,n);
    }
}

堆排序动图演示：

( 2 )算法分析

时间复杂度：

• 最佳情况：T(n) = O(nlogn)
• 最差情况：T(n) = O(nlogn)
• 平均情况：T(n) = O(nlogn)

辅佐空间：

• 无

8.计数排序（Counting Sort）

计数排序的核心在于将输入的数据值转化为键存储在额外开辟的数组空间中。
作为一种线性时间复杂度的排序，计数排序要求输入的数据必须是有确定范围的整数。

(1)算法简介

计数排序(Counting sort)是一种稳定的排序算法。计数排序使用一个额外的数组C，其中第i个元素是待排序数组A中值等于i的元素的个数。然后根据数组C来将A中的元素排到正确的位置。它只能对整数进行排序。

(2)算法描述和实现

具体算法描述如下：

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

void countingSort(int *unSort,int *sorted,int n)//假设arr元素的最大值是1000
{
    int c[1000];
    int minVal=0x3f3f3f,maxVal=-0x3f3f3f;
    memset(c,0,sizeof(c));
    for(int i=0;i<n;i++)
    {
        c[unSort[i]]++;
        minVal=minVal>unSort[i]?unSort[i]:minVal;
        maxVal=maxVal<unSort[i]?unSort[i]:maxVal;
    }
    for(int i=minVal;i<maxVal;i++)
    {
        c[i+1]=c[i+1]+c[i];
    }
    for(int i=0;i<n;i++)
    {
       int index=c[unSort[i]]-1;
       sorted[index]=unSort[i];
       c[unSort[i]]--;
    }
}

基数排序动图演示：

(3)算法分析
当输入的元素是n 个0到k之间的整数时，它的运行时间是 O(n + k)。计数排序不是比较排序，排序的速度快于任何比较排序算法。由于用来计数的数组C的长度取决于待排序数组中数据的范围（等于待排序数组的最大值与最小值的差加上1），这使得计数排序对于数据范围很大的数组，需要大量时间和内存。

时间复杂度：

• 最佳情况：T(n) = O(n+k)
• 最差情况：T(n) = O(n+k)
• 平均情况：T(n) = O(n+k)

辅佐空间：

• 需要用一个数组c来记录元数组元素出现的次数，原数组的元素值对应c数组的索引值，所以c的大小取决于原数组的数据范围。

9.桶排序（Bucket Sort）

桶排序是计数排序的升级版。它利用了函数的映射关系，高效与否的关键就在于这个映射函数的确定。

(1)算法简介

桶排序 (Bucket sort)的工作的原理：假设输入数据服从均匀分布，将数据分到有限数量的桶里，每个桶再分别排序（有可能再使用别的排序算法或是以递归方式继续使用桶排序进行排

(2)算法描述和实现

具体算法描述如下：

• <1>.设置一个定量的数组当作空桶；
• <2>.遍历输入数据，并且把数据一个一个放到对应的桶里去；
• <3>.对每个不是空的桶进行排序；
• <4>.从不是空的桶里把排好序的数据拼接起来。

template <class E>
void bucketSort(E *arr,int n,int bucketCount)
{
    E minval=arr[0],maxval=arr[0];
    for(int i=1;i<n;i++)    //找到最大值和最小值
    {
        minval=minval>arr[i]?arr[i]:minval;
        maxval=maxval<arr[i]?arr[i]:maxval;
    }
    //求出每一个桶的数值范围
    double space=(maxval-minval+1)*1.0/bucketCount;//这里必须用double值
     //先创建好每一个桶的空间
    vector<E> *bucket=new vector<E> [bucketCount];
    for(int i=0;i<n;i++)
    {
        int index=(int)((arr[i]-minval)/space);
        if(bucket[index].size()==0) //如果桶里里没有东西，直接放进去
        {
            bucket[index].push_back(arr[i]);
        }
        else                        //否则，进行插入排序
        {
            int j=bucket[index].size()-1;
            bucket[index].push_back(arr[i]);//先把数据加载进桶，防止下面的bucket[index][j+1]出错
            while(j>=0&&bucket[index][j]>arr[i])
            {
                bucket[index][j+1]=bucket[index][j];
                j--;
            }
            bucket[index][j+1]=arr[i];
        }
    }

    //把桶内的结果合并
    for(int i=0,index=0;i<bucketCount;i++)
    {
        for(int j=0;j<bucket[i].size();j++)
        {
            arr[index++]=bucket[i][j];
        }
    }
}

桶排序图示（图片来源网络）：

这里写图片描述

桶排序最好情况下使用线性时间O(n)，桶排序的时间复杂度，取决与对各个桶之间数据进行排序的时间复杂度，因为其它部分的时间复杂度都为O(n)。很显然，桶划分的越小，各个桶之间的数据越少，排序所用的时间也会越少。但相应的空间消耗就会增大。

时间复杂度

• 最佳情况：T(n) = Θ(n+k)
• 最差情况：T(n) = Θ(n+k)
• 平均情况：T(n) = Θ(n²)

辅佐空间：

• Θ（n）

10.基数排序（Radix Sort）

基数排序也是非比较的排序算法，对每一位进行排序，从最低位开始排序，复杂度为O(kn),为数组长度，k为数组中的数的最大的位数；

(1)算法简介

基数排序是按照低位先排序，然后收集；再按照高位排序，然后再收集；依次类推，直到最高位。有时候有些属性是有优先级顺序的，先按低优先级排序，再按高优先级排序。最后的次序就是高优先级高的在前，高优先级相同的低优先级高的在前。基数排序基于分别排序，分别收集，所以是稳定的。

(2)算法描述和实现

具体算法描述如下：

• <1>.取得数组中的最大数，并取得位数；
• <2>.arr为原始数组，从最低位开始取每个位组成radix数组；
• <3>.对radix进行计数排序（利用计数排序适用于小范围数的特点）；

int getDigit(int val,int k)
{
    int arr[] = {1, 1, 10, 100,1000,10000,100000};
    return (val/arr[k]) % 10;
}
void countingSort(int *arr,int *res,int n,int k)
{
    int c[10];
    memset(c,0,sizeof(c));
    for(int i=0;i<n;i++)
    {
        c[getDigit(arr[i],k)]++;
    }
    for(int i=1;i<10;i++)
    {
        c[i]+=c[i-1];
    }
    for(int i=n-1;i>=0;i--)//为了保证准确性，必须从高位开始排
    {
        int j=getDigit(arr[i],k);
        res[c[j]-1]=arr[i];
        c[j]--;
    }
}
void radixSort(int *arr,int n,int maxDigit)
{
    int *a1=arr,*a2=new int[n],*res;
    for(int i=1;i<=maxDigit;i++)
    {
        countingSort(a1,a2,n,i);
        res=a2;
        swap(a1,a2);
    }
    for(int i=0;i<n;i++)
    {
        arr[i]=res[i];
    }
}

基数排序LSD动图演示：

(3)算法分析

时间复杂度：

• 最佳情况：T(n) = Θ(n * k)
• 最差情况：T(n) = Θ(n * k)
• 平均情况：T(n) = Θ(n * k)

辅佐空间：

• Θ（n）