【数据结构学习笔记】一些排序算法和它们的优化

记一下一些排序算法，有一些算法之后会补充

灰色的表示待排序的数组，白色表示已经排序完成的。

选择排序

选择排序通过找出最大的元素，把它移到a[n-1]，然后在余下的n-1个元素中继续找到最大的元素，移到a[n-2]，一直循环，直到剩下一个元素。例

第一行是初始数组，第一次对a[0:5]进行循环，先找到最大数字8在a[2]，将其移到a[5]；然后第二次对a[0:4]进行循环，找到最大的数字6在a[0]，将其移到a[4]，一直循环到最后只剩下a[0]=1。

程序：

template<class T>
void selectionSort(T a[], int n)
{
    //给数组a[0:n-1]的n个元素排序
    for(int size=n;size>1;size--)
    {
        int indexOfMax=0;
        //找到a[0:size-1]之间最大的那个数
        for(int i=1;i<size;i++)
            if(a[indexOfMax]<=a[i])
                indexOfMax=i;
        swap(a[indexOfMax],a[size-1]);
    }
}

优化

选择排序有一个缺点：即使元素已经有序，程序仍然会继续运行。为了去除不必要的迭代，我们可以在查找最大元素时，同时检查数组是否已经有序，用一个标志位即可。

程序：

template<class T>
void selectionSort(T a[], int n)
{
    //及时终止的选择排序
    bool sorted=false;//标志位
    for(int size=n;(size>1) && !sorted;size--)
    {
        int indexOfMax=0;
        sorted=true;//已经有序
        //找到a[0:size-1]之间最大的那个数
        for(int i=1;i<size;i++)
            if(a[indexOfMax]<=a[i])
                indexOfMax=i;
            else
                sorted=false;//无序
        swap(a[indexOfMax],a[size-1]);
    }
}

我们从a[0:size-1]中查找最大数的下标时，比原来多了个else条件，当我们一直只执行if条件，else条件将无法执行，即数组中每个数都小于它后面的数，就证明了它已经是有序了。

冒泡排序

冒泡排序是一种简单的排序方法，它通过相邻两个值的比较，将最大的元素移到序列最右端

例：

可以看出来，对于同一数组，尽管最后的结果和选择排序一样，但中间的排序过程是不一样的，选择排序只要把最大的数和最右边的数交换位置即可，而冒泡排序是从头开始比较相邻的数来进行“冒泡”。

程序：

template<class T>
void bubble(T a[],int n)
{
    //将a[0:n-1]中最大元素移到最右边
    for(int i=0;i<n-1;i++)
        if(a[i]>a[i+1])
            swap(a[i],a[i+1]);
}

template<class T>
void bubbleSort(T a[],int n)
{
    //冒泡排序
    for(int i=n;i>1;i--)
        bubble(a,i);
}

和选择排序一样，第一次要排序的是a[0:n-1]，第二次是a[0:n-2]，一直到最后只剩下a[0]。

优化

和选择排序同样的缺陷：如果排序中途已经没有发生元素互换，那么已经说明数组已经有序，我们要去除不必要的迭代，提前终止排序。

template<class T>
bool bubble(T a[],int n)
{
    //将a[0:n-1]中最大元素移到最右边
    bool swapped=false;//未移动
    for(int i=0;i<n-1;i++)
        if(a[i]>a[i+1])
        {
            swap(a[i],a[i+1]);
            swapped=true;//交换
        }
    return swapped;
}

template<class T>
void bubbleSort(T a[],int n)
{
    //及时终止的冒泡排序
    for(int i=n;(i>1) && bubble(a,i);i--)
}

插入排序

一个数组如果只有一个元素，称为单元数组，单元数组肯定是有序数组，所以对n个元素的数组，可以从第一个元素构成的单元数组开始，不断做插入操作。插入第二个元素，得到2个元素的有序数组，一直插入，最终得到n个元素的有序数组。

程序：

template<class T>
void insertionSort(T a[],int n)
{
    //插入排序
    for(int i=1;i<n;i++)
    {
        //把a[i]插入a[0:i-1]
        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;
    }
}

第二个循环是在a[0:i-1]中，从第i-1个数开始找，找到刚刚好大于a[i]的值，同时把大于a[i]的值都往后移一位，最后将a[i]插入到合适的位置。

二路归并排序

归并排序是用了分而治之的方法来设计的排序算法，把n个元素按非递减顺序排列，若n为1，则终止；否则，将序列划分为k个子序列（k是不小于2的整数）。先对每个子序列排序，然后将有序子序列归并为一个序列。而二路归并排序首先将两个相邻的大小为1的子序列归并，然后将每个相邻的大小为2的子序列归并，循环直到只剩下一个有序序列。

例子：

初始段：【8】【4】【5】【6】【2】【1】【7】【3】

归并：   【4 8】【5 6】【1 2】【3 7】

归并：   【4 5 6 8】【1 2 3 7】

归并：   【1 2 3 4 5 6 7 8】

程序：

//归并排序
template <class T>
void mergeSort(T a[],int n)
{
    T *b=new T[n];//用来装载归并排序好后生成的序列
    int segmentSize=1;//子序列的大小，从大小为1的子序列开始归并
    while(segmentSize<n)
    {
        mergePass(a,b,segmentSize);//从a到b的归并
        segmentSize*=2;//每次子序列的大小都翻倍，即1,2,4,8...
        mergePass(b,a,n,segmentSize);//从b到a的归并
        segmentSize*=2;
    }
    delete[] b;//归并完成后，删除多余的b
}

//把相邻的子序列从x到y归并
template <class T>
void mergePass(T x[],T y[],int n,int segmentSize)
{
    int i=0;//下一个子序列的起点
    //当序列有超过2个以上的子序列
    while(i<=n-2*segmentSize)
    {
        merge(x,y,i,i+segmentSize-1,i+2*segmentSize-1);
        i=i+2*segmentSize;
    }
    //当序列少于2个满子序列
    if(i+segmentSize<n)
        //剩下有两个子序列
        merge(x,y,i,i+segmentSize-1,n-1);
    else
        //只剩下一个子序列，复制到y
        for(int j=i;j<n;j++)
            y[j]=x[j];
}

//把相邻的数据段从c到d归并
template <class T>
void merge(T c[],T d[], int startOfFirst,int endOfFirst,int endOfSecond)
{
    int first=startOfFirst;//第一个子序列的索引
    int second=endOfFirst+1;//第二个子序列的索引
    int result=startOfFirst;//归并序列的索引
    //直到有一个子序列归并到d
    while((first<=endOfFirst)&&(second<=endOfSecond))
        if(c[first]<=c[second])
            d[result++]=c[first++];
        else
            d[result++]=c[second++];
    //归并剩余元素
    if(first>endOfFirst)
        for(int q=second;q<=endOfSecond;q++)
            d[result++]=c[q];
    else
        for(int q=first;q<=endOfFirst;q++)
            d[result++]=c[q];
}

快速排序

快速排序也是用了分而治之的思想，把n个元素分为三段：左段left、中间段middle和右段right。中间段只有一个元素。左段的元素都不大于中间段的元素，右段的元素都不小于中间段的元素。然后在左段和右段继续进行快速排序。中间段元素称为支点或分割元素。

程序：

template <class T>
void quickSort(T a[],int leftEnd,int rightEnd)
{
    //归并排序
    if(leftEnd>=rightEnd) return;
    int leftCursor=leftEnd;//从左到右移动的索引
    int rightCursor=rightEnd+1;//从右到左移动的索引
    T pivot=a[leftEnd];
    //将位于左侧不小于支点的元素和位于右侧不大于支点的元素交换
    while(true)
    {
        do
        {//寻找左侧不小于支点的元素
            leftCursor++；
        }while(a[leftCursor]<pivot);
        do
        {//寻找右侧不大于支点的元素
            rightCursor--;
        }while(a[rightCursor]>pivot);

        if(leftCursor>=rightCursor) break;//没有找到交换的元素对
        swap(a[leftCursor],a[rightCursor]);
    }
    //放置支点
    a[leftEnd]=a[rightCursor];
    a[rightCursor]=pivot;

    quickSort(a,leftEnd,rightCursor-1);//对左侧数段排序
    quickSort(a,rightCursor+1,rightEnd);//对右侧的数段排序
}

优化

对快速排序可以进行优化，因为当要排序的序列是个非递增的有序序列时，快速排序就变成了冒泡排序，复杂度为n^2。所以我们可以使用三值取中来对快速排序进行优化。三值取中就是在三个元素a[leftEnd]、a[(leftEnd+rightEnd)/2]和a[rightEnd]中选择大小居中的中指元素作为支点元素。最简单的方法是将中值位置上的元素与元素a[leftEnd]交换，然后继续使用普通的快速排序方法。

各个排序的负责度表

排序算法	最坏情况下的性能	平均性能
冒泡排序	n^2	n^2
计数排序	n^2	n^2
插入排序	n^2	n^2
选择排序	n^2	n^2
堆排序	nlogn	nlogn
归并排序	nlogn	nlogn
快速排序	n^2	nlogn