大话数据结构读书笔记 7(终结篇)---排序

大话数据结构读书笔记 7(终结篇)—排序

数据结构 读书笔记

---

排序的基本概念与分类

假设含有n个记录的序列为{r1,r2,….,rn},使得序列成为一个按该序列各元素对应的关键字有序的序列，这样的操作就称为排序
排序的依据就是关键字之间的大小关系

排序的稳定性

假设ki=kj（1<=i,j<=n,i!=j）,且在排序前的序列中ri领先于rj（即i小于j），如果排序后ri仍领先rj，则称所用的排序方法是稳定的，否则就是不稳定的（只要有一组关键字不满足，就是不稳定的）。

内排序和外排序

内排序就是在排序的整个过程中，待排序的所有记录全部被放置在内存中。
外排序就是待排序的记录个数太多，不能同时放置在内存中，整个排序的过程需要内外存之间多次的数据交换。
排序算法的性能主要受三个方面的影响：
*时间性能
*辅助空间
*算法的复杂性

冒泡排序

冒泡排序的基本思想：两两比较相邻记录的关键字，如果反序则交换，直到没有反序的记录为止

最简单的排序实现

/对顺序表L作交换排序（冒泡排序初级版）
void BubbleSort0(SqList *L)
{
    int i,j;
    for(i=1;i<L->lengtj;i++)
    {
        for(j=i+1;j<=L->length;j++)
        {   
            if(L->r[i]>L->r[j])
            {
                swap(L,i,j);//交换L->r[i]与L->r[j]，这里没有给出具体的代码
            }
        }
    }
}
//这个算法不算正宗的冒泡排序，这个算法的效率是很低的



//正宗的冒泡排序算法
void BubbleSort(SqList *L)
{
    int i,j;
    for(i=1;i<L->length;i++)
    {
        for(j=L->length;j>=i;j--)//j从后往前循环
        {
            if(L->r[j]>L->r[j+1])//若前者大于后者，则交换
            {
                swap(L,j,j+1);
            }
        }
    }
}

//冒泡排序的优化（在排序的过程之中，当没有任何数据交换的时候，说明此序列已经有序，所以不需要再进行后面的循环）

//对顺序表L作改进冒泡算法
void BubbleSort2（SqList *L）
{
    int i,j;
    Status flag=TRUE;//设置一个标志位
    for(i=1;i<L->length&&flag;i++)
    {
        flag=FALSE;
        for(j=L->length;j>=i;j--)
        {
            if(L->r[j]>L->r[i])
            {
                swap(L,j,j+1)；
                flag=TRUE;//如果有数据交换，则flag为TRUE;
            }
        }
    }
}

时间复杂度O（n^2），(最好的情况是排序表本身就是有序的，此时时间复杂度为O（n）,最坏的情况是排序表本身是逆序的，则时间复杂度为O(n^2))
稳定排序

简单选择排序

选择排序的基本思想是每一趟在n-i+1(i=1，2，3…,n-1)个记录中选取关键字最小的记录作为有序序列的第i个记录。

void SelectSort(SqList *L)
{
    int i,j,min;
    for(i=1;i<L->length;i++)
    {
        min=i;//将当前下标定为最小值的下标
        for(j=i+1;j<=L->length;j++)
        {
            if(L->r[min]>L->r[j])
            min=j;//将此关键字的下标给min
        }
    if(i！=min)//判断是否找到最小值
        swap(L,i,min)//若找到最小值，则交换
    }
}

选择排序减少了交换的次数（最少交换0次，最多交换n-1次）,交换的次数变少了，从而提高了效率。
时间复杂度O(n^2)（选择排序无论最好与最坏的情况，其总的比较次数都是n-1+n+2+n-3+…+3+2+1=n*(n-1)/2次，交换次数最少为0，最多为n-1次）
空间复杂度O(1)
稳定排序

直接插入排序

直接插入排序的基本操作就是将一个记录插入到已经排好序的有序表中，从而得到一个新的，记录ushi数增1的操作

//对顺序表L作直接插入排序
void InsertSort(SqList *L)
{
    int i,j;
    for(i=2;i<=L->length;i++)
    {
        if(L->r[i]<L->r[i-1])
        {
            L->r[0]=L->r[i];//设置哨兵
            for(j=i-1;L->r[j]>L->r[0];j--)
                L->r[j+1]=L->r[j]//记录后移
            L->r[j+1]=L->r[0];//插入到正确位置
        }
    }
}

时间复杂度O(n^2)
空间复杂度O(1)，需要一个辅助空间即r[0]
稳定排序

希尔排序

希尔排序的原理

如果记录本身就是基本有序的（小的关键字基本在前面，大的基本在后面。不大不小基本在中间），这样只需很少的插入操作就可以完成整个记录的排序工作，从而提高了性能。

//对顺序表L作希尔排序
void ShellSort（SqList *L）
{
    int i,j;
    int increment=L->length;
    do
    {
        increment=increment/3+1;//增量序列
        for(i=increment+1;i<L->length;i++)
        {
            if(L->r[i]<L->r[i-increment])
            {
                L->r[0]=L->r[i];//暂时存在r[0]
                for(j=i-increment;j>0&&L->r[0]<L->r[j];j-=increment)
                    L->r[j+increment]=L->r[j];//记录后移，找到插入位置
                L->r[j+increment]=L->r[0];//插入
            }
        }
    }
    while(increment>1);
}

只有采取跳跃分隔的策略（算法中的increment增量），将相距某个“增量”的记录组成一个子序列，这样才能保证在子序列分别进行直接插入排序后的得到的结果是基本有序的而不是局部有序.

希尔排序将相隔某个增量的记录组成一个子序列，实现跳跃式的移动，而不是一步步移动，从而提高了效率。
其时间复杂度为O（n^(3/2)）（最坏情况O（n^2））
空间复杂度O(1)
希尔排序是不稳定排序（因为采用跳跃式的移动）
希尔排序的增量选取很关键，这样才能最大的效率（但最后一增量必须等于1）

堆排序

堆是具有下列性质的完全二叉树：
*每个结点的值都大于或等于其左右孩子结点的值，称为大顶堆；或者每个结点的值都小于或等于其左右孩子的值，称为小顶堆。

如果按照层序遍历的方式给结点从1开始编号，则堆的结点有以下关系：
大顶堆：ki>=k2i,ki>=k2i+1
小顶堆：ki<=k2i,ki<=k2i+1
i都满足 1<=i<=[n/2] ([n/ 2]在这表示不大于n/2的最大整数)

堆排序算法

堆排序就是利用堆(这里假设利用大顶堆)进行排序的算法；
基本思想就是:将待排序的的序列构成一个大顶堆。此时，整个序列的最大值就是堆顶的根结点。将它移走（其实就是与堆数组末尾的元素交换，此时末尾元素就是最大值），然后将剩余的n-1个序列重新构成一个堆，这样就会得到n个元素的次大值。反复如此执行，就能得到一个有序序列了。

//对顺序表L进行堆排序
void HeapSort（SqList *L）
{
    int i;
    for(i=L->length/2;i>0;i--)//这里为什么事length/2,以及为什么是下从大到小排列的，因为我们的排序过程其实就是从上往下，从右到左，将每一个非终端节点当作根结点，将其和其子树比较并调整成大顶堆的过程。
        HeapAdjust(L,i,L->length);//把L中的r构建成一个大顶堆
    for(i=L->length;i>1;i--)
    {
        swap(L,1,i);//将堆顶的记录和当前未经排序的子序列的最后一个记录交换。
        HeapAdjust(L,1,i-1);//将L->r[1..i-1]重新调整为大顶堆
    }
}




//已知L->r[s..m]中记录的关键字除L->r[s]之外军满足堆的定义
//本函数调整L->r[s]的关键字，使L->r[s..m]成为一个大顶堆
void HeapAdjust(SqList *L,int s,int m)
{
    int temp,j;
    temp=L->r[s];
    for(j=2*s;j<=m;j*=2)//沿关键字较大的孩子结点向下筛选
    {
        if(j<m&&L->r[j]<L->r[j+1])
        ++j;//说明右孩子比左孩子大，因此指向右孩子
        if(temp>=L->r[j])
        break;
        L->r[s]=L->r[j];
        s=j;
    }
    L->r[s]=temp;//插入
}

堆排序的复杂度分析：
堆排序是从最下层最右边的非终端结点开始构建的，将它与其孩子比较，若有必要就交换。对于每个非终端结点来说，其实最多进行两次比较和互换操作，因此整个构建堆的复杂度的分析，
正式排序时，第i次取堆顶记录需要O(logi)的时间,并且需要取n-1次的堆顶记录，因此重建堆的复杂度为O(nlogn)。
所以总的来说，堆排序的时间时间复杂度为O(nlogn)（无论最好，最坏还是平均的情况）
空间复杂度 O（1）
堆排序是不稳定的排序（由于记录的比较和互换是跳跃式的进行）
不适合排序序列个数较少的情况（由于初始构建堆需要比较的次数较多）

归并排序

归并排序就是利用归并的思想实现的排序方法。
基本原理就是：假设初始序列含有n个记录，则可以看成是n个有序的子列，每个子列的长度是1，然后两两归并，得到长度为2或1的新的有序的子列，然后再两两归并，….,直到得到一个长度为n的有序序列为止。这种方法叫做2路归并排序。（这里只讲2路归并排序）

//对顺序表作归并排序
void MergeSort(SqList *L)
{
    Msort(L->r,L->r,L->length);
}

//将SR[s..t]归并排序为TR1[s..t]
void MSort(int SR[],int TR1[],int s,int t)
{
    int m;
    int TR2[MAXSIZE+1];
    if(s==t)
        TR1[s]=SR[s];
    else
    {
        m=(s+t)/2;//将SR[s..t]平分为SR[s..m]和SR[m+1..t]
        MSort(SR,TR2,s,m);//递归将SR[s..m]归并为有序的TR2[s..m]
        MSort(SR,TR2,m+1,t);//递归将SR[m+1..t]归并为有序的TR2[m+1..t]
        Merge(TR2,TR1,s,m,t);//将TR2[s..m]和TR2[m+1..t]归并为有序的TR1[s..t]
    }
}

//将有序的SR[i..m]和SR[m+1..n]归并为有序的TR1[i..n]
void Merge(int SR[],int TR[],int i,int m,int n)
{
    int j,k,l;
    for(j=m+1,k=i;i<=m&&j<n;K++)//将SR中的记录由小到大归并入TR
    {
        if(SR[i]<SR[j])
            TR[k]=SR[i++];
        else
        TR[k]=SR[j++];
    }
    if(i<=m)
    {
        for(l=0;l<=m-i;l++)
            TR[k+1]=SR[i+1];//将剩余的SR[i..m]复制到TR
    }
    if(i<=n)
    {
        for(l=0;l<=n-j;l++)
        TR[k+1]=SR[j+1];//将剩余的SR[j..n]复制到TR
    }
}

非递归实现归并排序

//非递归实现归并排序
void MergeSort2(SqList *L)
{
    int *TR=(int *)malloc(L->length*sizeof(int));
    int k=1;
    while(k<L->length)
    {
        MergePass(L->r,TR,k,L->length);
        k=2*k;// 子序列长度加倍
        MergePass(TR,L->r,k,L->length);
        k=2*k;//子序列长度加倍
    }
}

//将SR[]中相邻长度为s的子序列两两归并到TR[]
void MergePass(int SR[],int TR[],int s,int n)
{
    int i=1;
    int j;
    while(i<n-2*s+1)
    {
        Merge(SR,TR,i,i+s-1,i+2*s-1);//两两归并
        i=i+2*s;
    }
    if（i<n-s+1）//归并最后两个序列
        Merge(SR,TR,i,i+s-1,n);
    else//若最后只剩下单个子序列
        for(j=1;j<=n;j++)
            TR[j]=SR[j];
}

非递归的迭代方法，避免了递归时深度为logn的栈空间，空间只是用到申请并临时用的TR数组，因此空间复杂度为O(n)（递归实现的空间复杂度为O(logn +n)）,使用归并排序，尽量考虑用非递归方法

归并排序时间复杂度O(nlogn)(最好，最坏，平均时间性能都是O(nlogn))
空间复杂度O(n)
归并排序属于稳定排序

快速排序

快速排序其实就是冒泡排序的升级，快速排序增大了记录比较和移动的Julia，将关键字较大的记录从前面直接移动到后面，关键字较小的记录直接移动到前面，从而减少了总的比较次数和移动交换次数。

快速排序算法

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

//对顺序表L进行快速排序
void QuickSort(SqList *L)
{
    QSort(L,1,L->length);
}

//对顺序表L中的子序列L->r[low,high]作快速排序
void QSort(SqList *L,int low,int high)
{
    int pivot;//枢轴
    if(low<high)
    {
        pivot=Partition(L.low,high);//将L->r[low,high]一分为二
        QSort(L,low,pivot-1);//对低子表递归排序
        QSort(L,pivot+1,high);//对高子表递归排序
    }
}

//交换顺序表L中子表的记录，使枢轴记录到位，并返回其所在位置
//此时在它的前（后）的记录均不大（小）于它
int Partition(SqList *L,int low,int high)
{
    int pivotkey;
    pivotkey=L->r[low];
    while(low<high)
    {
        while(low<high&&L->r[high]>=pivotkey)
            high--;
        swap(L,low,high)//将比枢轴记录小的记录交换到低端
        while(low<high&&L->r[low]<=pivotkey)
            low++;
        swap(L.low,high);//将比枢轴记录大的记录交换到高端
    }
    return low;//返回枢轴所在位置
}

Partition函数，其实就是将选取的pivotkey 不断交换，将比它小的记录换到它的左边,比它大的记录换到它的右边，它也在交换中不断更改自己的位置，直到完全满足这个要求为止

快速排序的复杂度分析

快速排序的时间性能取决于快速排序递归的深度，可以用递归树来描述递归算法的执行情况。如果选取的pivotkey值比较合理（是待排序的序列的中间值）那递归树是平衡的，时间性能也比较好，此时递归树的深度就是[logn]+1([logn]在这里表示不大于logn的最大整数)，此时整个排序的复杂度为O(nlogn)。

最坏的情况，待排序的序列为正序或者逆序，每次划分只得到一个比上一次划分少一个记录的子序列，这样整个递归树就是一棵斜树，此时的时间复杂度为O（n^2）

空间复杂度，主要是递归造成的栈空间的使用，最好的情况，递归树的深度为logn,其空间复杂度也为O(logn),最坏的情况，需要n-1次递归调用，其空间复杂度为O(n)，平均情况，空间复杂度为O（logn）

不稳定排序

快速排序优化

1优化选取枢轴
选取的枢轴越接近整个序列中间位置，（此时整个递归树越接近平衡），那么时间性能越好。
可以采取三数取中，甚至九数取中的方式，使选取的首个pivotkey接近中间值的概率最大

//三数取中的算法
int pivotkey
int m=low+(high-low)/2;//计算数组中间元素的下标
if(L->r[low]>L->r[high])
    swap(L,low,high);//交换左端与右端数据，保证左端较小
if(L->r[m]>L->r[high])
    swap(L,high,m);//交换中间与右端数据，保证中间较小
if(L-r[m]>L->r[low])
    swap(L,m,low);//交换中间与左端数据，此时L.r[low]已经为整个序列左中右三个关键字的中间值
pivotkey=L->r[low]

2优化不必要的交换

//快速排序优化算法
int Paritition1(SqList *L,int low,int high)
{
    int pivotkey;
    //这里省略三数取中的代码
    pivotkey=L->r[low];
    L->r[0]=pivotkey;//将枢轴关键字备份到L->r[0]
    while(low<high)
    {
        while(low<high&&L->r[high]>pivotkey)
            high--;
        L->r[low]=L->r[high];//采用替换而不是交换的方式进行操作
        while(low<high&&L->r[low]<=pivotkey)
            low++;
        L->r[high]=L->r[low];//采用替换而不是交换的方式进行操作
    }
    L->r[low]=L->r[0]//将枢轴的值替换回L.r[low]
    return low;
}
//采用替换而不是交换的操作，减少了不必要的交换次数，使得性能提高

3优化小数组的排序方案
快速排序由于采用了递归的操作，在对数量较少的记录排序时，其递归带来的性能损耗已经大于其排序带来的性能优势，所以对于数量较少的记录排序时，可以采用直接插入排序等简单算法，当数量超过某个最大值时才使用快速排序算法

4优化递归操作

void QSort(SqList *L,int low,int high)
{
    int pivot;
    if(high>low)>MAX_LENGTH_INSERT_SORT)//记录数量大于某个值时才采用快速排序
    {
        while(low<high)
        {
            pivot=Parition(L,low,high);
            QSort1(L,low,pivot-1);
            low=pivot+1;//采用迭代而不是递归，减少了一次递归的次数
        }
    }
    else
        InsertSort(L);
}

递归的次数太多的话，会降低性能，而且容易使递归栈满而发生溢出，所以降低递归次数可以提升性能

排序总结

本章讲的全部都是内排序的算法
排序分为：

插入排序类：->直接插入排序和希尔排序

选择排序类：->简单选择排序和堆排序

交换排序类：->冒泡排序和快速排序

归并排序类：->归并排序

从算法简单性上分类：
简单算法：冒泡，简单选择，直接插入
改进算法：希尔，堆，归并，快速
(如果待排序列是基本有序的，就不应该考虑改进算法)
(待排序列的记录个数越少，选择简单算法越合适)