[数据结构复习]排序

排序

基本概念

• 排序：给定一组记录的集合{r1, r2, ……, rn}，其相应的关键码分别为{k1, k2, ……, kn}，排序是将这些记录排列成顺序为{rs1, rs2, ……, rsn}的一个序列，使得相应的关键码满足ks1≤ks2≤……≤ksn（称为升序）或ks1≥ks2≥……≥ksn（称为降序）。

• 正序：待排序序列中的记录已按关键码排好序。

• 逆序（反序）：待排序序列中记录的排列顺序与排好序的顺序正好相反。

• 排序算法的稳定性：假定在待排序的记录集中，存在多个具有相同键值的记录，若经过排序，这些记录的相对次序仍然保持不变，即在原序列中，ki=kj且ri在rj之前，而在排序后的序列中，ri仍在rj之前，则称这种排序算法是稳定的；否则称为不稳定的。

• 单键排序：根据一个关键码进行的排序；

• 多键排序：根据多个关键码进行的排序。`

• 设关键码分别为k1, k2, …, km，多键排序有两种方法：

  1. 依次对记录进行m次排序，第一次按k1排序，第二次按k2排序，依此类推。这种方法要求各趟排序所用的算法是稳定的；

  2. 将关键码k1, k2, …, km分别视为字符串依次首尾连接在一起，形成一个新的字符串，然后，对记录序列按新形成的字符串排序。

     思路均是将多键排序转化成单键排序

• 排序的分类

  • 内外排序
    1. 内排序：在排序的整个过程中，待排序的所有记录全部被放置在内存中.(内部排序的过程是一个逐步扩大记录的有序序列长度的过程),大致分为 插入类,交换类,选择类,归并类等.
    2. 外排序：由于待排序的记录个数太多，不能同时放置在内存，而需要将一部分记录放置在内存，另一部分记录放置在外存上，整个排序过程需要在内外存之间多次交换数据才能得到排序的结果。
  • 是否比较
    1. 基于比较：基本操作——关键码的比较和记录的移动，其最差时间下限已经被证明为Ω（nlog2n）。
    2. 不基于比较：根据关键码的分布特征。

• 性能

  • 基本操作

    1. 比较: 关键码之间的比较；
    2. 移动: 记录从一个位置移动到另一个位置.

  • 辅助存储空间

    辅助存储空间是指在数据规模一定的条件下，除了存放待排序记录占用的存储空间之外，执行算法所需要的其他存储空间。

  • 算法本身复杂度

• 存储结构

  排序是线性结构的一种操作，待排序记录可以用顺序存储结构或链接存储结构存储。

插入排序

基本思想

每次将一个待排序的记录按其关键码的大小插入到一个已经排好序的有序序列中，直到全部记录排好序为止。

#define MAXSIZE  1000 // 待排顺序表最大长度
typedef  int  KeyType;  // 关键字类型为整数类型

typedef  struct {
   		// 待排序元素
   KeyType   key;             // 关键字项
    InfoType  otherinfo;  // 其它数据项
} RcdType;                   

typedef  struct {
   		// 待排序数组		
    RcdType    r[MAXSIZE+1]; // r[0]闲置
    int               length;            // 顺序表长度
} SqList;                                

实现“一趟插入排序”可分三步进行：

1. 在R[1..i-1]中查找R[i]的插入位置， R[1..j].key < R[i].key < R[j+1..i-1].key

2. 将R[j+1..i-1]中的所有记录均后移一个位置.

3. 将R[i]插入(复制)到R[j+1]的位置上。

直接插入排序

基本思想

在插入第 i（i＞1）个记录时，前面的i-1个记录已经排好序。

算法

void  insertSort (int  r[ ], int n){
   	// 直接插入排序
    for (i=2; i<=n; i++){
    
        r[0]=r[i]; 		// r[0]用来记录即将插入的元素
        for (j=i-1;r[0]<r[j];j--)
            r[j+1]=r[j];	// 向后移动
        r[j+1]=r[0];	// 插入(复制)
    }
}

复杂度分析

最好情况

完全正序,比较次数 n-1,移动次数2*(n-1)

复杂度O(n)

最坏情况

O(n^2)

平均情况下是O(n^2)

• 直接插入排序算法是一种稳定的排序算法。
• 直接插入排序算法简单、容易实现，适用于待排序记录基本有序或待排序记录较小时。
• 当待排序的记录个数较多时，大量的比较和移动操作使直接插入排序算法的效率降低。

表插入排序

####　概念

利用静态链表进行排序，并在排序完成之后，一次性地调整各个记录相互之间的位置

#define SIZE 100

typedef  struct {
   
    RcdType   rc;            // 记录项
    int     next;            // 指针项
} SLNode;                    // 表结点类型

typedef  struct {
   
    SLNode   r[SIZE]; 		// 0号单元是表头结点
    int     length;          // 链表当前长度
} SLinkListType;             // 静态链表类型

基本思想

    数组0号单元设为表头结点，通过循环链表，依次将下标为```2~n```的结点按关键字非递减有序插入到循环链表中。

与直接插入排序相比只是避免了移动记录的过程（修改各记录结点中的指针域即可），而插入过程中同其它关键字的比较次数并没有改变，所以表插入排序算法的时间复杂度仍是O(n^2)。

有序表的折半查找

重排记录算法：顺序扫描有序链表将链表中的第i个结点移到数组的第i个分量，算法使用了三个指针：

• p 指示第i个记录的当前位置

其中：p指示第i个记录的当前位置

• i 指示第i个记录应在的位置

• q 指示第i+1个记录的当前位置

void Arrange ( Elem SL[ ], int n ) {
   
    p = SL[0].next;   // p指示第一个记录的当前位置
    for ( i=1; i<n; ++i ) {
         
        while (p<i)  p = SL[p].next;
        q = SL[p].next;     // q指示尚未调整的表尾
        if ( p!= i ) {
   
            SL[p]←→SL[i]; // 交换记录，使第i个记录到位
            SL[i].next = p;    // 指向被移走的记录
        }
        p = q;         // p指示尚未调整的表尾，
        // 为找第i+1个记录作准备
    }
} // Arrange

希尔排序

改进的着眼点：

• 若待排序记录按关键码基本有序时，直接插入排序的效率可以大大提高；
• 由于直接插入排序算法简单，则在待排序记录数量n较小时效率也很高。

基本思想

将整个待