排序

排序

重点在内部排序

基本概念

• 稳定性：关键字相同的元素，在排序前后的相对位置不变

  稳定性不是衡量算法优劣的标准，只是一个特性，反应算法性能的是算法的时空复杂度

• 内部排序：指在排序期间元素全部存放在内存中的排序

• 外部排序：指在排序期间元素无法全部同时存放在内存中，必须在排序的过程中根据要求不断地在内、外存之间进行移动

内部排序

插入排序

每次将一个待排序的序列插入已经排好序的序列中

直接插入排序

初始L[1]是一个已经排好序的子序列 对于元素L(i)(L(2)-L(n))插入到前面已经排好序的子序列当中：
1）查找出L(i)在L[1…i-1]中的插入位置k
2）将L[k…i-1]中的所有元素全部后移一个位置
3) 将L(i)复制到L(k)

void Insertsort (ElemType A[],int n){
	int i,j;
	for(i=2; i<=n; i++){
		A[0]=A[i]; //A[0]是一个哨兵
		for(j=i-1;A[0].key<A[j].key; j--) 
			A[j+1]=A[j];
		A[j+1]=A[0];
    }
} 

• 空间复杂度：$O(1)$
• 时间复杂度：$O(n^2)$
• 稳定的算法
• 适用于顺序存储和链式存储

折半插入排序

对于直接插入排序的改进，查找时使用折半查找

void BInsertSort(Elemtype, int n){
    int i, j;
    int low, high, mid;
    for(i-2; i<=n; i++){
        A[0]=A[i];
        //折半查找
        low=1;
        high=i-1;
        while(low<=high){
            mid=(low+high)/2;
            if(A[mid].key>A[0].key)
                high=mid-1;
            else
                low=mid+1;
        }
        for(j=i-1; j>=high+1; j--)//此处high+1=low，使用low也可以
            A[j+1]=A[j];
        A[high+1]=A[0];       //此处high+1=low，使用low也可以
    }
}

• 空间复杂度：$O(1)$
• 时间复杂度：$O(n^2)$
• 稳定的算法
• 适用于顺序存储(折半查找的原因)

希尔排序

• 又称缩小增量排序

• 基本思想： 先将排序表分割成d个形如L[i, i+d, i+2d, …, i+kd]的 “特殊" 子表, 分别进行直接插入排序, 然后逐步缩短步长d重复上面的过程，直到最终d=1，再对全体记录进行一次直接插入排序。

• 步长的选取方法：

  ${\mathrm{d}}_1=[\mathrm{n}/2]{\mathrm{d}}_{\mathrm{i}+1}=\lfloor {\mathrm{d}}_{\mathrm{i}}/2\rfloor \text{ 直到最后一个 }{\mathrm{d}}_{\mathrm{k}}=1$

void ShellSort(ElemType A[], int n){
    for(int dk=n/2; dk>=1; dk=dk/2){
        for(int i=dk+1; i<=n; ++i){ //对所有组进行排序
            if(A[i].key<A[i-dk].key){
                A[0]=A[i];
                for(int j=i-dk; j>0&&A[0].key<A[j].key;j-=dk){
                    A[j+dk]=A[j];
                }
                A[j+dk]=A[0];
            }
        }
    }
}
//该程序不是分别对每一组分开进行排序，而是将指标i从dk+1开始不断向后移动，i移动到对应的哪组，就对改组进行直接插入排序。
//之后不断缩减步长，重复上面的过程

• 空间复杂度：$O(1)$
• 时间复杂度：最坏情况$O(n^2)$，多数情况下可达$O(n^{1.3})$
• 不稳定的算法
• 适用于顺序存储(利用数组下标)

交换排序

冒泡排序

• 基本思想： 假设待排序表长为n，从后往前（从前往后）两两比较相邻元素的值, 若为逆序（即A[i-1]>A[i]），则交换他们直到序列比较结束。

• 一次冒泡会将一个元素放到他最终的位置上

• n个元素冒泡n-1次

void BubbleSort(ElemType 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].key>A[j].key){
         	swap(A[j-1], A[j]);
         	flag=true;
         }
       if(flag=false)
           return;
    }
}

• 空间复杂度：$O(1)$
• 时间复杂度：$O(n^2)$
• 稳定的算法（交换的条件是大于）
• 适用于顺序存储和链式存储

快速排序

• 基本思想： 在待排序表L[1…n]中任取一个元素pivot作为基准，通过一趙排序将待排序表划分为具有如下特点的两部分：小于pivot（位于pivot前）和大于pivot的部分（位于pivot后）。

• 一次划分会将一个元素pivot放置到他最终的位置上

• 基本思路： 初始化标记low为划分部分第一个元素的位置, high为最后一个元 素的位置，然后不断地移动两标记并交换元素：

  1. high向前移动找到第一个比pivot小的元素
  2. low向后移动找到第一个比pivot大的元素
  3. 交换当前两个位置的元素
  4. 继续移动标记, 执行1 ) , 2），
  5. 的过程, 直到|ow大于等于 high为止。

int Partition(ElemType A[], int low, int high){ //返回元素最终的位置
    ElemType 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[high]=A[low];
    }
    A[low]=pivot;
    return low;
}
//Partition时间复杂度$O(high-low+1)
void QuickSort(ElemType A[], int low, int high){
    if(low<high){
        int pivotpos=Partition(A, low, high);
        QuickSort(A, low, pivotpos-1);
        QuickSort(A, pivotpos+1, high);
    }
}

• 最好、平均空间复杂度$O(lo{g}_{2}n)$，最坏情况（序列基本有序）$O(n)$
• 最好、平均时间复杂度$O(nlo{g}_{2}n)$，最坏情况（序列基本有序）$O(n^2)$
• 不稳定的算法
• 适用于顺序存储和链式存储

选择排序

• 基本思想： 每一趙在后面n-i+1 (i=1,2,n-1)个待排序元素中选取关键字最小的元素, 作为有序子序列的第i个元素，直到n-1趙做完, 待排序元素只剩下1个。

• 一次排序就将一个元素放在最终的位置

直接选择排序

void SelectSort(ElemType A[]. int n){
    for(int i=0; i<n-1; i++){
        int min=i;
        for(int j=i+1; j<n; j++)
            if(A[j]<A[min])
                min=j;
        if(min!=i)
            sqap(A[i], A[min]);
    }
}

• 空间复杂度：$O(1)$
• 时间复杂度：$O(n^2)$，时间复杂度和初始序列无关
• 不稳定
• 适用于顺序存储和链式存储

堆排序

• n个关键字序列L[1…n]称为堆，当且仅当该序列满足：
  (1) 若$L(i)\le L(2i)$且$L(i)\le L(2i+1)$, 则称该堆为小根堆
  (2) 若$L(i)\ge L(2i)$且$L(i)\ge L(2i+1)$，则称该堆为大根堆

  ($1\le i\le \lfloor n/2\rfloor$)

• 排序过程中将其视为一棵完全二叉树的顺序存储结构，小根堆根节点对应的关键字为最小的关键字，大根堆根节点对应最大的关键字

大堆的初始化

• 对所有具有双亲结点含义编号从大到小 ( $\lfloor \mathrm{n}/2\rfloor \sim 1$) 做出如下调整：
  1）若孩子结点皆小于双亲结点，则该结点的调整结束
  2）若存在孩子结点大于双亲结点，则将最大的孩子结点与双亲结点交换, 并对该孩子结点进行1 ) 、2），直到出现1）或到叶节点为止

void BuildMaxHeap(ElemType A[], int len){
    for(int i=len/2; i>0; i--)
        AdjustDown(A, i, len);
}
void AdjustDown(ElemType A[], int k, int len){
    A[0]=A[k];
    for(int i=2*k; i<=len; i*=2){
        if(i<len && A[i]<A[i+1])
            i++;
        if(A[0]>=A[i])
            break;
        else{
            A[k]=A[i];//没有交换孩子节点和双亲的值，但是将最大的孩子节点赋值给双亲节点；注意到if的判断是比较最初的A[0]，因此算法可以正常执行，并且最后将A[0]放到最终对应的位置上
            k=i;
        }
    }
    A[k]=A[0];
}
//时间复杂度O(h)，h为树的高度
//初始建堆O(n)

• 堆排序：不断输出堆顶元素，并向下调整

void HeapSort(ElemType A[], int len){
    BuildMaxHeap(A, len);
    for(int i=len; i>1; i--){
        Swap(A[i], A[1]);
        //根节点对应当前最大值，输出之后将其与最后位置未输出的元素进行交换，并对交换后的未输出的所有元素进行向下调整，因此向下调整的元素长度为i-1，在不断减少（剩下的未输出的元素不断变少）
        AdjustDown(A, 1, i-1);
    }
}

• 空间复杂度：$O(1)$
• 时间复杂度：$O(nlo{g}_{2}n)$,输出n，每次调整为log2(n）
• 不稳定
• 适用于顺序存储和链式存储

• 堆的插入操作：将新节点放在末端额安厚向上调整

void AdjustUp(ElemType A[], int len){
    A[0]=A[k];
    int i=k/2;
    while(i>0 && A[i]<A[0]){
        A[k]=A[i];
        k=i;
        i=k.2;
    }
    A[k]=A[0];
}

归并排序

• n路归并：每次合并相邻的两个有序序列。下面以2路归并为例讲述代码

• 合并两个有序线性表

ElemType *B=(ElemType *)malloc((n+1)*sizeof(ElemType));
void Merge(ElemType A[], int low, int mid, int high){//合并的使得相邻的有序数组，所以只要传入两个数组的起始和终端位置就可
    for(int k=low; k<=high; k++)
        B[k]=A[k];
    for(int i=low, int j=mid+1, int k=i; i<=mid && j<=high; k++){
        if(B[i]<=B[j])
            A[k]=B[i++];
        else
            A[k]=B[j++];
    }
    while(i<=mid)
        A[k++]=B[i++];
    while(j<=high)
        A[k++]=B[j++];
}
//时间复杂度为O(high-low+1)

• 2路归并排序

void MergeSort(ElemType 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); 
    }
}

• 空间复杂度：$O(n)$
• 时间复杂度：$O(nlo{g}_{2}n)$
• 稳定
• 适用于顺序存储和链式存储

基数排序

• 借助 “分配” 和 “收集" 两种操作对单逻辑关键字进行排序, 分为最高位优先 (MSD) 和最低位优先（LSD）。
  以r为基数的最低位优先基数排序的过程：
  假设线性表由结点序列 $a_0,a_1,\dots ,a_{n-1}$构成每个结点a,的关键字由d元组$\left({\mathrm{k}}_j^{\mathrm{d}-1},{\mathrm{k}}_{\mathrm{j}}^{\mathrm{d}-2},\dots ,{\mathrm{k}}_{{\mathrm{j}}^{\prime }}^1,{\mathrm{k}}_{\mathrm{j}}^0\right)$组成，$0\le k_j^i\le r-1(0\le j<n,0\le i\le d-1)$；在排序时使用r个队列$Q_0,{\mathrm{Q}}_1,\dots ,{\mathrm{Q}}_{r-1}$

  • 分配：开始时，把r个队列Q置空，然后依次考察每个节点的关键字，若$a_j$的关键字中$k_j^i=\mathrm{k}(0\le k\le r-1)$, 就把$a_j$放入队列$Q_k$当中

  • 收集：把$Q_0,{\mathrm{Q}}_1,\dots ,{\mathrm{Q}}_{r-1}$各个队列的节点依次首尾相接，得到新的节点序列，组成线性表。

  • d次分配收集后，序列会排成有序的序列

• 空间复杂度：$O(r)$
• 时间复杂度：$O(d(n+r))$
• 稳定
• 不基于比较

内部排序比较和应用

比较

应用

外部排序

• 外部排序通常采用归并排序方法。

• 首先，根据缓冲区的大小将外存上含有n个记录的文件分成若干长度为h的子文件, 依次读入内存并利用有限的内部排序算法对它们进行排序，并将排序后得到的有序子文件重新写回外存，通常称这些有序子文件为归并段或顺串。然后，对这些归并段进行逐趟归并，使归并段逐渐由小到大直至得到整个有序文件

• 外部排序的总时间=内部排序所需时间+外存信息读写时间+内部归并所需时间

  $\text{ 归并趟数 }=\lceil {\log }_{\mathrm{m}}\mathrm{r}\rceil .$

  m为几路归并（一次归并的子串的个数），r为要归并的子串的总个数——增加m减少r可以减少时间

失败树

• S趟归并总共需要比较的次数

  $S(n-1)(m-1)=\lceil {\log }_m\rceil (n-1)(m-1)$

• 一次m归并时，从m个子串中找到最小的，比较m-1次
• 一共n个关键字n个位置，需要通过比较确定n-1个位置的值
• 总共进行S次归并

失败树 树形选择排序的一种变体, 可视为一棵完全二叉树

• 每个叶结点存放各归并段在归并过程中当前参加比较的记录
• 内部结点用来记忆左右子树中的“失败者"
• 胜利者向上继续 进行比较，直到根结点。

比较次数和输的高度有关，所以总比较次数变为：
$S(n-1)(m-1)=\lceil {\log }_{m}r\rceil (n-1)\lceil {\log }_{2}m]=\lceil {\log }_{2}r\rceil (n-1)$

结果和m无关

置换-选择排序

设初始待排序文件为FI，初始归并段文件为FO，内存工作区为WA，内 存工作区可容纳w个记灵。 算法思想：
1）从待排序文件FI输入w个记录到工作区WA;
2）从内存工作区WA中选出其中关键字取最小值的记录，记为MINIMAX
3) 将MINIMAX记录输出到FO中;
4) 若FI未读完，则从斤输入下一个记录到WA中;
5）从WA中所有关键字比MINIMAX记录的关键字大的记录中选出最小的关 键字记录，作为新的MINIMAX;
6) 重复3） 5），直到WA中选不出新的MINIMAX记录位置，由此得到一
个初始归并段，输出一个归并段的结束标志到FO中;
7) 重复2） 6)，直到WA为空。由此得到全部初始归并段。

产生的归并字段长度不等

最佳归并树

• 归并树用来描述m归并, 并只有度为0和度为m的结点的严格m叉树

• 带权路径长度之和为归并过程中的总读记录数——使带权路径之和最小——哈夫曼树——最佳归并树

• 当叶子节点数目不够时，增加权值为零的节点来构造哈夫曼树

  • 设度为0的结点有$n_0$个，度为m的结点有$n_m$个，则对严格m叉树有$n_0=(\mathrm{m}-1){\mathrm{n}}_{\mathrm{m}}+1$, 即得 $n_m=\frac{n_0-1}{m-1}$。若$(n_0-1)\%(m-1)==0$, 则说明对于这个$n_0$个叶结点（初始归并段) 可以构造m叉树归并树。若$(n_0-1)\%(m-1)=u\ne 0$, 则说明对于这个$n_0$个叶结点（初始归并段 其中有u个叶结点是多余的

  • 多出u个节点，需要补充m-u-1个（需要m-u个节点把剩下的节点变成m叉子树，因为把一个双亲节点从叶子节点变成内部节点，因此再减去1）

内容来源:王道考研——数据结构