数据结构笔记八：排序

排序

排序的基本概念

排序（Sort）,就是重新排列表中的元素，使表中的元素满足按关键字有序的过程

排序算法的评价指标

时间复杂度，空间复杂度
算法的稳定性。若待排序中有两个元素(R_i)和(R_j),其对应的关键字相同即(key_i=key_j)，且在排序前(R_i)在(R_j)的前面，若使用某一排序算法排序后，(R_i)仍然在(R_j)的前面，则称这个排序算法是稳定的，否则称排序算法是不稳定的。

排序算法的分类

内部排序——数据都在内存中
外部排序——数据太多，无法全部放入内存

插入排序

算法思想

每次将一个待排序的记录按其关键字大小插入到前面已排好序的子序列中，直到全部记录插入完成。

//直接插入排序
void InsertSort(int A[],int n)
{
    int i,j,temp;
    for(i=1;i<n;i++)			//将各元素插入已排好序的序列中
    {
        if(A[i]<A[i-1])			//若A[i]关键字小于前驱
        {
            temp=A[i];			//temp暂存A[i];
            for(j=i-1;i>=0&&A[j]>temp;--j)	//检查所有前面已排好序的元素
                A[j+1]=A[j];	//所有大于temp的元素都向后挪位
            A[j+1]=temp;		//复制到插入位置
        }
    }
}


//直接插入排序(带哨兵)
void InsertSort(int A[],int n)
{
    int i,j;
    for(i=2;i<n;i++)			//将各元素插入已排好序的序列中
    {
        if(A[i]<A[i-1])			//若A[i]关键字小于前驱
        {
            A[0]=A[i];			//复制为哨兵，A[0]不存发元素
            for(j=i-1;A[0]<A[j];--j)	//检查所有前面已排好序的元素
                A[j+1]=A[j];	//所有大于temp的元素都向后挪位
            A[j+1]=A[0];		//复制到插入位置
        }
    }
}

空间复杂度：(O(1))

最好时间复杂度（全部有序）：(O(n))

最坏时间复杂度（全部逆序）：(O(n^2))

平均时间复杂度：(O(n^2))

算法稳定性：稳定

优化——折半插入排序

先用折半查找找到应该插入的位置，再移动元素

当low>high时折半查找停止，应将[low,i-1]内的元素全部右移，并将A[0]复制到low所指位置；

当A[mid]==A[0]时,为了保证算法的“稳定性”，应继续在mid所指位置右边寻找插入位置

//折半插入排序
void InsertSort(int A[],int n)
{
    int i,j，low,high,mid;
    for(i=2;i<n;i++)			//将各元素插入已排好序的序列中
    {
        A[0]=A[i];			//复制为哨兵，A[0]不存发元素
        low=1;high=i-1;		//设置折半查找的范围
        while(low<high)		//折半查找（默认递增有序）
        {
            mid=(low+high)/2;	//取中间点
            if(A[mid]>A[0])
                high=mid-1;		//查找左半子表
            else
                low=mid+1;		//查找右半子表
        }
        for(j=i-1;j>=high+1;--j)
            A[j+1]=A[j];		//统一后移元素，空出插入位置
        A[high+1]=A[0];			//插入操作
    }
}

比起"直接插入排序"，比较关键字的次数减少了，但是移动元素的次数没变，整体来看时间复杂度依然是(O(n^2))

对链表进行插入排序

移动元素的次数变少了，但是关键字对比的次数依然时(O(n^2))数量级，整体来看时间复杂度依然是(O(n^2))

希尔排序

算法思想

先将待排序表分割成若干形如(L[i,i+d,i+2d,...i+kd])的“特殊”子表，对各个子表分别进行直接插入排序。缩小增量(d)，重复上述过程，直到(d=1)为止

//希尔排序
void ShellSort(int A[],int n)
{
    int d,i,j;
    //A[0]只是暂存单元，不是哨兵，当j<=0时，插入位置已到
   	for(d=n/2;d>=1;d=d/2)		//步长变化
    {
        for(i=d+1;i<=n;++i)
        {
            if(A[i]<A[i-d])		//将A[i]插入有序增量子表
            {
             	A[0]=A[i];		//暂存在A[0]
                for(j=i-d;j>0&&A[0]<A[j];j-=d)
                {
                    A[j+d]=A[j];			//记录后移
                }
                A[j+d]=A[0];				//插入
            }
        }
    }
}

算法性能分析

空间复制度：(O(1))

时间复杂度：最坏时间复杂度(O(n^2)),当n在某个范围内时，可达(O(n^{1.3}))

稳定性：不稳定

适用性：仅适用于顺序表，不适用于链表

冒泡排序

算法思想

从后往前（从前往后）两两比较相邻的元素，若为逆序（即A[i-1]>A[i]），则交换他们，直到序列比较完。称这样过程为“一趟”冒泡排序，总共需进行(n-1)趟冒泡

//交换
void swap(int &a,int &b)
{
    int temp=a;
    a=b;
    b=temp;
}
//冒泡排序
void BubbleSort(int A[],int n)
{
    for(int i=0;i<n-1;i++)
    {
        bool flag=false;			//表示本堂冒泡是否发生交换的标志
        for(int j=n-1;j<i;j--)
        {
            if(A[j-1]>A[j])
            {
                swap(A[j-1],A[j]);	//交换
                flag=true;
            }
        }
        if(flag==false)
            return;					//若本趟遍历后没有发生交换，说明表已经有序
    }
}

算法性能分析

空间复制度：(O(1))

时间复杂度：

有序：最好时间复杂度(O(n))
逆序：最坏时间复杂度(O(n^2))
平均：时间复杂度(O(n^2))

稳定性：稳定

适用于链表

快速排序

算法思想

在待排序表(L[1...n])中任取一个元素pivot作为枢轴（基准，通常取首元素），通过一趟排序将待排序表划分为独立的两个(L[1...k-1])和(L[k+1...n]),使得(L[1...k-1])中的所有元素小于pivot，中的所有(L[k+1...n])元素大于等于pivot，则pivot放在了其最终位置(L(k))上，这个过程称为一次“划分”。然后分别递归对两个子表重复上述过程，直至每部分内只有一个元素或空为止，即所有元素放在了其最终位置上。

//用第一个元素将待排序序列划分成左右两部分
int Partition(int A[],int low,int high)
{
    int pivot=A[low];		//用第一个元素作为枢轴
    while(low<high)
    {
        while(low<high&&A[high]>=pivot)
            --high;
        A[low]=A{high];			//比枢轴小的元素移动到左端
        while(low<high&&A[low]<=pivot)
            ++low;
        A[low]=A{high];			//比枢轴小的元素移动到左端
    }
    A[low]=pivot;				//将枢轴元素存放到最终位置
   	return low;					//返回存储枢轴的最终位置 
}
//快速排序（递归）
void QuickSort(int A[],int low,int high)
{
    if(low<high)
    {
        int pivotpos=Partition(A,low,high);		//划分
        QuickSort(A，low,pivotpos-1);		   //划分左子表
        QuickSort(A,pivotpos+1,high);		    //划分右子表
    }
}

算法效率分析

若每一次选中的“枢轴”将待排序序列划分为均匀的两部分，则递归深度最小，算法效率最高。

快递排序算法优化思路：尽量选择可以把数据中分的枢轴元素

选头，中，尾三个位置的元素，取中间值作为枢轴元素
随机选一个元素作为枢轴元素

稳定性：不稳定

简单选择排序

选择排序

算法思路

每一趟在待排序元素中选取关键字最小的元素加入有序子序列

//简单选择排序
void SelectSort(int A[],int n)
{
    for(int i=0;i<n-1;i++)
    {
        int min=i;
        for(int j=i+1;j<n;i++)		//在A[i...n-1]中选择最小的元素
            if(A[j]<A[mid])
                min=j;
        if(min!=j)
            swap(A[i],A[mid]);
    }
}

算法性能分析

空间复制度：(O(1))

时间复杂度：(O(n^2))

稳定性：不稳定

适用于链表

堆排序

堆

若n个关键字序列(L[1...n])满足下面某一条性质，则称为堆（Heap）

若满足：(L(i)ge L(2i))且(L(i)ge L(2i+1)) ((1le ile n/2))——大根堆（大顶堆）((根ge 左、右))
若满足：(L(i)le L(2i))且(L(i)le L(2i+1)) ((1le ile n/2))——**小根堆（小顶堆）((根le 左、右))

大根堆（堆排序）

//建立大根堆
void BuildMaxHeap(int A[],int len)
{
    for(int i=len/2;i>0;i--)
        HeadAdjust(A,i,len);
}
//将以k为根的子树调整为大根堆
void HeadAdjust(int A[],int k,int len)
{
    A[0]=A[k];						//A[0]暂存子树的根结点
    for(int i=2;i<len;i*=2)			 //沿key较大的子结点向下选择
    {
        if(i<len&&A{i]<A[i+1])
            i++;					//取key较大的子结点的下标
       	if(A[0]>=A[i])
            break;					//筛选结束
        else
        {
            A[k]=A[i];				//将A[j]调整到双亲结点上
            k=i;				    //修改k值，以便继续向下筛选
        }
    }
    A[k]=K[0];						//被筛选结点的值放入最终位置
}

基于大根堆进行选择排序

//堆排序
void HeapSort(int A[],int len)
{
    BuildMaxHeap(A,len);			//出书建堆
    for(int i=len;i>1;i--)			//n-1趟交换和建堆过程
    {
        swap(A[i],A[1]);			//堆顶元素和堆底元素交换
        HeadAdjust(A,1，i-1);		//把剩余的待排序元素整体成堆
    }
}

堆排序：每一趟将堆顶元素加入有序子序列（与待排序序列中的最后一个元素交换），并将待排序元素序列再次调整为大根堆（小元素不断“下坠”）

算法效率分析

结论：一个结点，每“下坠”一层，最多只需对比关键字两次

若树高为h，某结点在第i层，则将这个结点向下调整最多最多只需“下坠”(h-i)层，关键字对比次数不超过(2(h-i))

第I层最多有(2^{i-1})个结点，而只有第(i)~((h-1))层的结点才有可能需要“下坠”调整

将整棵树调整为大根堆，关键字对比次数不超过(sum_{i=h-1}^12^{i-1}2(h-i)le sum_{j=1}^{h-1}frac{j}{2^j}le4n)

建堆的过程，关键字对比次数不超过4n,建堆时间复杂度=(O(n))

根节点最多“下坠”(h-1)层，每“下坠”一层

每“下坠”一层，最多只需对比关键2次，每一趟排序算法不超过(O(h)=O(log_2n))

共(n-1)趟，总的时间复杂度=(O(nlog_2n))

时间复杂度：(O(n)+O(nlog_2n))

空间复制度：(O(1))

稳定性：不稳定

堆的插入删除

在堆中插入新元素

对于小根堆，新元素放到表尾，与父节点对比，若新元素比****父节点更小**，则将二者互换。新元素就这样一路”上升“，直到无法继续上升为止。

在堆中删除元素

被删除元素用堆底元素替代，然后让孩子元素不断”下坠“，直到无法下坠为止。

归并排序

算法思想

归并：把两个或多个已经有序的序列合并成一个

m路归并，每选出一个元素需要对比关键字(m-1)次

int *B=(int*)malloc(n*sizeof(int));		//辅助数组B

//A[low...mid]和A[mid+1...high]各自有序，将两个部分合并
void Merge(int A[],int low,int mid,int high)
{
    int i,j,k;
    for(k=low;k<=high;k++)
        B[k]=A[k];						//将A中所有元素复制到B中
    for(i=low,j=mid+1,k=i;i<=mid&&j<=high;k++)
    {
        if(B[i]<=B[j])
            A[k]=B[i++];				//将较小值复制到A中
        else
            A[k]=B[j++];
    }
    while(i<=mid)	A[k++]=B[i]++;
    while(j<=high)	A[k++]=B[j]++;
}

void MergeSort(int A[],int low,int high)
{
    if(low<high)
    {
        int mid=(low+high)/2;			//从中间划分
        MergeSort(A,low,mid);			//对左半部分归并排序
        MergeSort(A,mid+1,high);		//对右半部分归并排序
        Merge(A,low,mid,high);			//归并
    }
}