数据结构 第10章-内排序

0
1
2
3ቤተ መጻሕፍቲ ባይዱ
4
5
6
7
j
算法要求A[n]=+∞，防止i超界。
程序10-4 快速排序 template <class T> void QSort(T A[],int left,int right) { int i,j; if ( left<right ) { i=left; j=right+1; do { do i++; while (A[i]<A[left]); do j--; while (A[j]>A[left]); if (i<j) Swap(A[i],A[j]); }while (i<j); Swap(A[left],A[j]); QSort(A,left,j-1); QSort(A,j+1,right); }//endif 继续 }
10.2.2 直接插入排序
基本思想：将序列中第1个元素作为一个有序序列，然 后将剩下的n-1个元素按关键字大小依次插入该有序序列， 经过n-1趟排序后即成为有序序列。
temp = 36 68 12 72 36 12
i
i之前是有序区;排序开 始的时候i=1;
48 36 68 72 12 48 02
A' A B
template <class T> void QuickSort(T A[],int n) { A[n]=maxnum； QSort(A,0,n-1); } 从上述快速排序算法中可以看出，经过每一趟排序后
，若被分割成两个大小相近的子序列时，快速排序的效
率最好，时间复杂度为O(nlog2n)；反之，若每次分割的 两个子序列中有一个为空，即初始序列有序(顺序或逆序 )，则效率最低，时间复杂度为O(n2)。 快速排序是不稳定的排序方法。
i 48 left 36 68 72 12 48
j
02 ∞ right
找到小于A[left] 接下来会分别把 交换以后,只要 i 和 j 准 的元素(02), 尚未相遇,就 A[left]元素两侧 此时,i和j已经“相遇”过,扫描结束 继续各自的扫描以及交换操作; 备和A[i]交换; 的序列作为排序对 ,下面要把A[left]和A[j]交换,实现 和right“指针”指出了 其目的是把较A[left]小的元素放到 象递归整个算法过 了各元素按“左边小右边大”的原则 左边,较A[left]大的元素放到右边; 待排序的元素序列； 程;(过程略) 分布在A[left]两侧;
程序 10-1 简单选择排序 template <class T> void SelectSort(T A[], int n) { int small; for (int i=0; i<n-1; i++ ) // n-1趟 { small=i; for (int j=i+1; j<n; j++) if (A[j]<A[small]) small=j; Swap(A[i],A[small]); } //endfor } //函数Swap(T &a, T &b)交换两个元素 时间复杂度按比较次数衡量为O(n2)。
10.2.1 简单选择排序
基本思想：第1趟在初始序列(A[0]A[n-1])中找一 个最小值，与序列中第一个元素A[0]交换，这样子序列 (A[0])有序。 下一趟排序在子序列(A[1]A[n-1])中进行。
第i趟排序在子序列(A[i-1]A[n-1])中找最小值元
素与子序列中的第一个元素A[i-1]交换。经过n-1趟排 序后使得初始序列有序。
10.3 快速排序
基本思想：对任意给定的序列中元素Rs(关键字为Ks)， 经过一趟排序后，将原序列分割成两个子序列，其中，前一 个子序列中的所有元素的关键字均小于等于Ks,后一个子序
列中元素的关键字均大于等于Ks。
称元素Rs 为分割元素。 以后只需对2个子序列分别进行快速排序，直到子序列
为空或只有一个元素时得到有序序列。
第一趟 排序;
48
36
j1
68
72
j2
12
48
02
i1
i2
size=2
36
48
68
72
12
Temp
48
02
此时的状态,适 第三趟排序;过程同前 合展示排序的 第二趟 (略);每一趟size以2倍增加,当 先按从小到大的顺 细节,请注意! 排序;
为避免发生最坏情况，选择分割元素时可作三种处理： (1)将A[(left+right)/2]作为分割元素,与A[left]交换； (2)选left到right间的随机整数k，将A[k]与A[left]交换； (3)取A[left]、A[(left+right)/2]和A[right]之中间值与 A[left]交换。 对于快速排序： (1)为提高快速排序的效率，将递归程序改为非递归的； (2)为减小栈空间，先对较小的子序列排序，将较大的子 序列进栈；
10.4 两路合并排序
基本思想：将有n个元素的序列看成是n个长度为1 的有序子序列，然后两两合并子序列，得到n/2个长度 为2或1的有序子序列；再两两合并，…，直到得到一个 长度为n的有序序列时结束。
3
j1 i1
j2 i2
此时i1+size<n的 条件已经不满足, 第一趟扫描结束;
size=1
temp中存放新的欲处 j 理元素； j是扫描 “指针”; 向前寻找插入的位置 ；
程序 10-2 直接插入排序 template <class T> void InsertSort(T A[], int n) { for(int i=1; i<n; i++ ) { int j=i; T temp=A[i]; while(j>0 && temp<A[j-1]) { A[j]=A[j-1]; j--; } A[j]=temp; } }
的次序排列为：
( Rp(0),Rp(1),…,Rp(n-1))
序列中两个元素Ri和 Rj (i<j),且 Ki=Kj，排 序后，Ri 仍然排在 Rj 之前，则称所用的排序算 法是稳定的。反之，称该排序算法是不稳定的。 3,1,3=>1,3,3 3,1,3=>1,3,3 如果待排序元素总数相对于内存而言较小，整 个排序过程可以在内存中进行，则称之为内部排序 ；反之，如果待排序元素总数较多，不能全部放入 内存，排序过程中需访问外存，则称之为外部排序 。 本章讨论内部排序。 本章采用顺序存储方式，即用一个一维数组 A[n+1](n为序列中元素个数)存储序列中各元素的 关键字，忽略元素的其它部分，把精力集中在排序 算法上。
0 1 2 3 4 5 6
（48， 36，68，72，12，48，02） （02）,（36，68，72，12，48，48）
i指向无序区 的开始位置
i
small变量用来记录无序 区中最小元素的索引值;
small= 0 6 14
48 02
36
j
68
72
12
48
02 48
整个无序序列的 最小值02被放到i 位置后,第一遍扫 j为扫描“指针 描结束,进入第二 ”; 遍扫描;
该算法必须进行n-1趟，每趟进行n-i-1次比较，这样 总的比较次数为
n( n 1) ( n i 1) i 0 2
n 2
时间复杂度按比较次数衡量为O(n2)。另外，还需移
动元素3(n-1)次或交换元素（n-1）次。简单选择排序是
不稳定的排序方法。 关于稳定性问题： 3,1,3进行简单选择排序： 1,3,3 3,3,1进行简单选择排序： 1,3,3 1,3,3 (似乎是稳定的) 1,3,3
冒泡排序最好情况(已有序)下只需进行一趟排序，n-1 次比较，因此最好情况下的时间复杂度是O(n)。 最坏进行n-1趟，第i趟比较(n-i)次，移动元素3(n-i) 次，这样比较次数为，
1 ( n i ) n( n 1) i 1 2
n 1
移动元素次数为3n(n-1)/2。 最坏情况下的时间复杂度为O(n2)。 冒泡排序是稳定的排序方法。
果在某一趟排序中未交换元素，说明子序列已经有序，则
不再进行下一趟排序。
0 1 2 3 4 5 6
（72, 12，36，48，48，68，02） （02, 12，36，48，48，68）72 （02, 12，36，48，48，68）72
（48，36，68，72，12，48，02） （36，48，68，72，12，48，02） （36，48，68，72，12，48，02） （36，48，68，72，12，48，02） （36，48，68，12，72，48，02） （36，48，68，12，48，72，02） （36，48，68，12，48，02，72） （36，48，68，12，48，02） （36，48，12，48，02）68， （36，12，48，02）48，68， （12，36，02）48，48，68， （12，02）36，48，48，68， （02）12，36，48，48，68， 72 72 72 72 72 72
[2],3,1,3： [2,3],1,3 为何变成了不稳定的？ [1,2,3],3 [1,2,3,3]
10.2.3 冒泡排序
基本思想：第1趟在序列(A[0]A[n-1])中从前往后进 行两个相邻元素的比较，若后者小，则交换，比较n-1次。 第1趟排序结束，最大元素被交换到A[n-1]中(即沉底)。 下一趟排序只需在子序列(A[0]A[n-2])中进行。如
2.1 简单排序算法 本节介绍三种简单的排序 算法： 简单选择排序 直接插入排序 冒泡排序 它们的时间复杂度在 最坏情况下均为O(n2)。