第八章学习小结

本章学习了排序这一操作，排序方法分为两大类：

内部排序：不需要访问外存，分为插入类、交换类、选择类、归并类（2-路归并排序）和分配类（基数排序）。    

外部排序：不可能在内存中完成。

（一）插入排序

1、直接插入排序----稳定排序，更适合于初始记录基本有序（正序）的情况

void InsertSort(SqList &L)
{
    for(i=2; i<L.length; ++i)
    if(L.r[i].key<L.r[i-1].key) 
    {
        L.r[0]=L.r[i];     
           L.r[i]=L.r[i-1];      
           for(j=i-2; L.r[0].key<L.r[j].key; --j) 
               L.r[j+1]=L.r[j];    
        L.r[j+1]=L.r[0];    
    }
}

时间复杂度为O(n²)，空间复杂度为O(1)。

2、折半插入排序----稳定排序，只能用于顺序结构，适合初始记录无序、n较大的情况

void BiInsertSort(SqList &L) 
{
    for(i=2; i<=L.length; ++i) 
    {
        L.r[0]=L.r[i];   
        low=l;  high=i-1;     
        while(low<=high)  
        {
            m=(low+high)/2;   
            if(L.r[0].key<L.r[m].key)   high=m-1;    
            else low=m+l;    
        }    //while 
        for(j=i-l;j>=high+l; --j)    
            L.r[j+l]=L.r[j];  
        L.r[high+l]=L.r[0];     
    }
}

时间复杂度为O(n²)，空间复杂度为O(1)。

3、希尔排序----不稳定排序，只能用于顺序结构，最后一个增量值必须等于1，适合初始记录无序、n较大时的情况

void ShellInsert(SqList &L, int dk) 
{//对顺序表L做一趟增量是dk的希尔插入排序 
    for(i=dk+l; i<=L.length; ++i) 
    if(L.r[i].key<L.r[i-dk].key)  
    {
        L.r[0]=L.r[i];    
        for(j=i-dk; j>0 && L.r[0].key<L.r[j].key; j-=dk) 
            L.r[j+dk]=L.r[j];  
        L.r[j+dk]=L.r[0];  
    }  
}
void ShellSort(SqList &L, int dt[], int t) 
{
    for (k=0; k<t; ++k) 
    ShellInsert(L, dt[k]);  
}

时间复杂度为O(n^3/2)，空间复杂度为O(1)。

（二）交换排序

1、冒泡排序----稳定排序，算法平均性能比直接插入排序差

void BubbleSort(SqList &L)
{
    m=L.length-1; flag=1;     //flag用来标记某一趟排序是否发生交换
    while((m>0)&&(flag==1))
    {
        flag=0;   //flag置0，如果本趟排序没有发生交换，则不会执行下一趟排序
        for(j=1; j<=m; j++)
            if(L.r[j].key>L.r[j+1].key)
            {
               flag=1;      //flag置为1，表示本趟排序发生了交换
               t=L.r[j]; L.r[j]=L.r[j+1]; L.r[j+1]=t;//交换
            }
            --m;
    }
}

时间复杂度为O(n²)，空间复杂度为O(1)。

2、快速排序----不稳定排序，适合用于顺序结构，适合初始记录无序、n较大时的情况

int Partition(SqList &L, int low, int high) 
{//对顺序表1中的子表r[low .. high)进行一趟排序，返回枢轴位置 
    L.r[0]=L.r[low];  
    pivotkey=L.r[low].key;    //枢轴记录关键字保存在pivotkey中
    while(low<high)  
    { 
        while(low<high && L.r[high].key>=pivotkey)  --high; 
        L.r[low]=L.r[high];   //将比枢轴记录小的记录移到低端 
        while(low<high && L.r[low].key<=pivotkey)   ++low; 
        L.r[high]=L.r[low];   //将比枢轴记录大的记录移到高端 
    }
    L.r[low]=L.r[0];   
    return low;   
}
void QSort(SqList &L, int low, int high) 
{
    if(low<high) 
    {
        pivotloc=Partition(L, low, high);    
        QSort(L, low, pivotloc-1);     //对左子表递归排序 
        QSort(L, pivotloc+l, high);    //对右子表递归排序 
    }
}
void QuickSort(SqList &L) 
{
    QSort(L, 1, L.length); 
}

平均情况下，快速排序的时间复杂度为O(nlog₂n)。

最好情况下的空间复杂度为O(log₂n)--递归要用到栈空间，最坏情况下为O(n)。

（三）选择排序

1、简单选择排序/直接选择排序----稳定排序，比直接插入排序快

void SelectSort(SqList &L) 
{
    for(i=1; i<L.length; ++i）
    { 
        k=i;  
        for(j=i+l; j<=L.length; ++j) 
        if(L.r[j].key<L.r[k].key)   k=j;   
        if(k!=i) 
            {t=L.r[i; L.r[i]=L.r[k]; L.r[k]=t;}   
    }//for
}

时间复杂度为O(n²)，空间复杂度为O(1)。

2、树形选择排序/锦标赛排序

3、堆排序----不稳定排序，只能用于顺序排序

//1.调整堆----筛选法
void HeapAdjust(SqList &L, int s, int m)
{
    rc=L.r[s];
    for(j=2*s; j<m; j*=2)  
    {
        if(j<m && L.r[j].key<L.r[j+1].key)    ++j;    
            if(rc.key>=L.r[j].key)   break; 
            L.r[s]=L.r[j];   s=j;
    }
    L.r[s]=rc;   
}
//2.初建堆
void CreatHeap(SqList &L) 
{//把无序序列L.r[l..n]建成大根堆 
    n=L.length; 
    for(i=n/2;i>O; --i)  
        HeapAdjust(L,i,n); 
} 
//3.堆排序算法的实现 
void HeapSort(SqList &L) 
{
    CreatHeap(L);  
    for(i=L.length; i>l; --i) 
    {
        x=L.r[1];
        L.r[1]=L.r[i]; 
        L.r[i]=x; 
        HeapAdjust(L, 1, i-1)   
    }
} 

堆排序在最坏的情况下，其时间复杂度也为O(nlog₂n)，空间复杂度为O(1)。

实验研究表明，平均性能接近于最坏性能。

（五）归并排序----稳定排序

void MSort(RedType R[], RedType &T[], int low, int high) 
{ 
    if(low==high)   T[low]=R[low]; 
    else 
    {
        mid=(low+high)/2;   
        MSort(R, S, low, mid); 
        MSort(R, S, mid+l, high);
        Merge(S, T, low, mid, high);
    } 
} 
void MergeSort(SqList &L) 
{
    MSort(L.r, L.r, 1, L.length); 
}

时间复杂度为O(nlog₂n)，空间复杂度为O(n)。

各种内部排序方法的比较：