第八章 排序

6 6 6 6 j 6 第 二 趟 第 一 趟
3 i t
9 j 9
1 i t 1 i t 1
3
8 j 8 j
6
3
9
6
3
9 i t
8 j
6
第 三 趟
简单选择排序
算法 void select(int *a,int n) {int i,j,k; for(i=0;i<n;i++) {k=i; for(j=i+1;j<n;j++) if(a[j]<a[k]) k=j; if(k!=i) swap(&a[k],&a[i]); }
时间复杂度：O(log2n)
例一趟快排序过程示例
r[1] r[2] r[3] r[4] r[5] r[6] r[7] r[8] r[9] r[10] 存储单元 49 14 38 74 96 65 8 49 55 27 记录中关键码 low=1；high=10； 设置两个搜索指针， □= r[0].ke65 8 49 55 27 ↑ ↑ low high 第一次搜索交换: 从high向前搜索小于r[0].key的记录，将r[high] 与□交换得到结果: 27 14 38 74 96 65 8 49 55 □ ↑ ↑ low high 从 low向 后搜索 ,修 改low 指 针 ,使low=low+1,找到第 一个大于 r[0].key的记录，将r[low]与□交换得到结果 27 14 38 □ 96 65 8 49 55 74 ↑ ↑ low high
第二次搜索交换 从high向前搜索,修改high指针使high=high-1,找到第一个小于r[0].key的记 录，将r[high]与□交换,得到结果 27 14 38 8 96 65 □ 49 55 74 ↑ ↑ low high 从low向后搜索,使low=low+1,找到第一个大于r[0].key的记录，将r[low]与 □交换，得到结果 27 14 38 8 □ 65 96 49 55 74 ↑ ↑ low high 第三次搜索交换 从high向前搜索,修改high指针使high=high-1,找到第一个小于r[0].key的记录 ，直到high=low为止，得到结果 27 14 38 8 □ 65 96 49 55 74 ↑↑ low high 从 low 向 后 搜 索 使 low=low+1, 找 到 第 一 个 大 于 r[0].key 的 记 录 ， 直 到 high=low为止,得到结果 27 14 38 8 □ 65 96 49 55 74 ↑↑ low high low=high，划分结束，填入支点记录, 27 14 38 8 49 65 96 49 55 74, 再以49为界分为左右两边继续快速排序.左边序列为27 14 38 8 ,选27 为关键码,右边序列为65 96 49 55 74,以65作为关键码继续排序
8.3.2 快速排序 (对冒泡排序的改进）
思想：通过一趟排序将待排序列分成两部分，使其中一部分记 录的关键字均比另一部分小，再分别对这两部分排序，以达到 整个序列有序。 关键字通常取第一个记录的值为基准值。 做法： ① low=p；high=q； r[0]=r[low]；
② 若low=high，支点空位确定，即为low。 r[low]=r[0]； 否则，low<high，搜索需要交换的记录，并交换之 ③ 若low<high且r[high].key≥r[0].key high=high-1；转③ r[low]=r[high]； ④ 若low<high且r[low].key<r[0].key low=low+1；转④ r[high]=r[low]； 转② //继续寻找支点空位
改进的冒泡程序： void bubble(int *a,int n) {int t,i,j,flag=1; for(i=0;i<n&&flag;i++) {flag=0; for(j=n-1;j>i;j--) if(a[j-1]>a[j]) {t=a[j-1];a[j-1]=a[j];a[j]=t;flag=1;} } }
思想：小的 浮起，大的 沉底。从后 面开始比， 第一次得到 最小的放第 一位，第二 次排序得到 第二小的放 第二位…
25 56 49 78 11 65 41 36
初 始 关 键 字
11 25 56 49 78 36 65 41
第 一 趟 排 序 后
25 36 56 49 78 41 65
第 二 趟 排 序 后
对于有n个数 据元素的待排 序列，插入操 作要进行n-1 次
第三次排序： [15 27 36 53] 69 42
第四次排序： [15 27 36 53 69] 42
第五次排序： [15 27 36 42 53 69]
直接插入排序示例
该算法适合于n 较 小的情况，时间复 杂度为O(n2).
插入算法如下： 方法:Ki与Ki-1,K i-2,…K1依次比较,直到找到应插入的位置。
8.2 插入排序
直接插入
1、直接插入排序: 基本思想：从数组的第2号元素开 始，顺序从数组中取出元素，并将 该元素插入到其左端已排好序的数 组的适当位置上。
8.2 插入排序
直接插入
直接插入排序: 基本思想：从数组的第2号元素开始，顺序从数组中取出元素， 并将该元素插入到其左端已排好序的数组的适当位置上 待排元素序列：[53] 27 36 15 69 42 第一次排序： 第二次排序： [27 53] 36 15 69 42 [27 36 53] 15 69 42
24
36
24
85 91 36 85 12
47 24
30
53 12
85
47 24
30
53
91 47 30 (c) 53 12
36
85 47 91 (d)
30
53
（4）由无序序列建初始堆的过程(最小值在最上面) 53 53 53 36 30 36 30 36 12 85 47 12 24 91 47 12 24 85 47 30 24 (a)无序序列 (c): 30被筛选 91 (b): 91被筛选后的状态 85 n=8, int(n/2)=4开始 91 后的状态 53 36 85 47 30 12 24 85 36 47 30 12 53 24 85 36 47 30 12 24 53
8.2.2.希尔排序 改进的直接插入排序算法: ① 选择一个步长序列t1，t2，…，tk，其中ti>tj，tk=1； ② 按步长序列个数k，对序列进行k趟排序； ③ 每趟排序，根据对应的步长ti，将待排序列分割成若干长 度为m的子序列，分别对各子表进行直接插入排序。仅步 长因子为1时，整个序列作为一个表来处理，表长度即为整 个序列的长度。
(b):堆顶元素取最小值
（1） 如何由一个无序序列按关键码建成一个堆？
（2） 输出堆顶元素后，如何将剩余元素调整成一个新的堆？
(3) 输出堆顶元素并调整建新堆的过程(筛选) 把自堆顶至叶子的调整过程称为“筛选‘。从一个无序序 列建堆的过程就是一个反复”筛选“的过程。 91 12 (a) (b)
36
n个记录进行冒泡排序的算法如下 : 1) i=0； /*从0个记录的表开始*/ 2) 若i≥n，排序结束. 3) j=n-1； /*一趟冒泡，设置从第n-1个记录开 始进行两两比较*/ 4) 若j≤i;一趟冒泡结束，i=i+1；，转 2) 5) 比较r[j-1].key与r[j].key，若r[j-1].key≤r[j].key， 不交换，转7) 6) 当r[i-1].key>r[j].key时， 将r[j-1]与r[j]交换 7) j=j-1； 调整对下两个记录进行两两比较，转4)
10
76
24
33
4
15
5
1 2 3 r[0] = 10 m=5 i=1
堆排序算法
void heapsort(int *r,int n) {int i; for(i=n/2;i>=1;i--) sift(r,i,n); for(i=n;i>=2;i--) {r[0]=r[1]; r[1]=r[i]; r[i]=r[0]; sift(r,1,i-1); } }
8.4.2 堆排序 也是一种选择排序。是具有特定条件的顺序 存储的完全二叉树，其特定条件是：任何一个非叶子结点的关 键字大于等于（或小于等于）子女的关键字的值。 11 89 (1) 堆的示例 76 24 25 36
33
15
10
56
49
78
(a):堆顶元素取最大值 (2) 实现堆排序需解决两个问题：
36 41 56 49 78 65
第 三 趟 排 序 后
41 49 56 65 78
第 四 趟 排 序 后
49 56 65 78
第 五 趟 排 序 后
冒泡排序算法： void bubble(int *a,int n) {int i,j; for(i=0;i<n;i++) for(j=n-1;j>i;j--) if(a[j-1]>a[j]) swap(&a[j-1],&a[j]); }
待排序列为 39，80，76，41，13，29，50，78，30，11， 100，7，41，86用希尔排序方法进行排序。
8.3 交 换 排 序
交换排序的特点在于交换。有冒泡和快速排序两种。 8.3.1、冒泡排序（起泡排序） 小的浮起。从右端开始比较。 第一趟：第n-1个与第n个比较，大则交换；第n-2个与第n-1个 比较， 大则交换，……关键字最小的记录交换到第一个位置 上； 第二趟：对后n-1个记录进行同样的操作，关键字次小的记录交 换 到第2个位置上； 依次类推，则完成排序。 正序：时间复杂度为O(n) 逆序：时间复杂度为O(n2) 适合于数据较少的情况。 排序n个记录的文件最多需要n-1趟冒泡排序。