快速排序算法高校试讲PPT
合集下载
快速排序算法
排序算法比较
2019/2/2 6
University of Science and Technology of China
堆排序
堆排序（heapsort）结合了插入排序与合并排 序的优点。 运行时间与合并排序一致：O(nlgn) 和插入排序都是一种原地排序算法：在排序 输入数组时，只有常数个元素存储在输入数 组之外。
排序算法的稳定性是针对所有输入实例而言的。即在所有可能的
输入实例中，只要有一个实例使得算法不满足稳定性要求，则该
排序算法就是不稳定的。
2019/2/2 5
University of Science and Technology of China
第六讲 排序
内容提要：
排序问题
堆排序算法
快速排序算法 线性时间排序
1 16 2 14 4 8 8 2 9 4 10 1 5 7 6 9 3 10 16 7 3 14 10 8 7 9 3 2 4 1 1 2 3 4 5 6 7 8 9 10
表示堆的数组对象A具有两个性质：
① length[A]：是数组中的元素个数； heap-size[A]: 是存放在A中的堆得元素个数；
堆排序引入了一种算法设计技术：利用了一种 重要的数据结构——“堆”——来管理算法执 行中的信息。
University of Science and Technology of China
堆数据结构
堆数据结构是一种数组对象，可以被视为一棵完全二叉树。树中每个节 点与数组中存放该结点值的那个元素对应。树的每一层都是填满的，最 后一层可能除外（从一个结点的左子树开始填）
堆的分类：
大根堆（最大堆）：除根节点之外的每个节点i，有
5. 5排序算法--快速与归并 课件-2021-2022学年浙教版（2019）高中信息技术选修1
快速排序算法
·快速排序算法(用栈实现)
代码：
def quick_sort(array, l, r): if l >= r: return stack = [] stack.append(l) stack.append(r) while stack: low = stack.pop(0) hight = stack.pop(0) if hight - low <= 0: continue k = array[hight] i = low - 1 for j in range(low, hight):
选修1《数据与数据结构》
第五章 数据结构与算法
5.5 排序算法 --快速与归并
学习目标
快速排序算法 归并排序算法
排序算法
快速排序算法
排序算法
·快速排序的基本思路
快速排序使用分治法策略来把一个串行（list）分为两个子串行（sub-lists）。
算法步骤：
1、 在数组中选一个基准数（通常为数组第一个）。 2、将数组中小于基准数的数据移到基准数左边，大于基准数的移到右边。 3、对于基准数左、右两边的数组，不断重复以上两个过程，直到每个子集只 有一个元素，即为全部有序。
排序算法
k = l #归并子数组的索引 while i < n1 and j < n2:
if L[i] <= R[ j]: arr[k] = L[i] i += 1
else: arr[k] = R[ j] j += 1
k += 1 while i < n1:
arr[k] = L[i] i += 1 k += 1 while j < n2: arr[k] = R[ j] j += 1 k += 1
快速排序ppt课件
在实际项目中的应用
数据库索引
数据库索引的建立和维护可以采用快速排序的思想。通 过快速排序的分区操作，可以将索引分成有序的多个部 分，便于快速查找和定位数据。
搜索引擎
搜索引擎中的网页排名算法可以采用快速排序的思想。 通过对网页进行快速排序，可以将最相关的网页排在前 面，提高搜索结果的准确性和用户体验。
提高效率。
02
快速排序算法原理
分治策略
分治策略是快速排序的核心思想，即将一个复杂的问题分解为若干个较小的、更易 于解决的子问题。
在快速排序中，原数组被选定的基准元素划分为两个子数组，使得一个子数组的所 有元素都比基准元素小，另一个子数组的所有元素都比基准元素大。
通过递归地对这两个子数组进行快速排序，最终得到有序的数组。
05
快速排序的变种
快速三向切分排序
总结词
基于快速排序的变种，将数组分为三个部分进行排序。
详细描述
快速三向切分排序是在快速排序的基础上进行的一种改进。它将待排序的数组分为三个部分，左边的已排序部分、 中间的未排序部分和右边的已排序部分。然后对中间的未排序部分进行快速排序，并将结果与左右两边的已排序 部分进行合并，从而实现整个数组的排序。
pivot = arr[len(arr) // 2]
代码实现
middle = [x for x in arr
01 if x == pivot]
right = [x for x in arr if
03 x > pivot]
return quicksort(left) +
02
middle +
quicksort(right)
VS
详细描述
快速基数排序是一种非比较型整数排序算 法，它将整数按位数切割成不同的数字， 然后按每个位数分别比较。具体实现中， 从最低位开始，对每一位使用稳定的排序 算法（如计数排序）进行排序，直到最高 位。由于只针对整数有效，因此对于浮点 数需要做一些额外处理。
【全版】快速排序推荐PPT
if(pi<ivjo) tpos=Partition(R,i,j);
数据序列划分为左右2个子序列，然后Q通uRi过c[ik+_QS+o]u=rtiR(cR[kj,]i,;_pSivootrpto函s-1数); 的递
归调用对左右2个子序列进行排序，}从w而Qhiul实eiic+(ik<+现_jS;&o快&rtR(速R[i,]p排<iv=o序ptipv功oost能+) 1。,j);
3.涉及知识点
1
数组定义
数据类型说明符 数组名 [常量表达式];
例：int R[MAX];
2
数组引用
数组名[下标]
下标从0开始，如果数组的长度为n，则下标的范围应该界于0和n-1之间。
例： R[ j]<R[k]
3.涉及知识点
3
函数定义
函数类型 函数名 (形参表 列)
{ 函数体 }
void Quick_Sort (int R[],int left,int right) {
int n; scanf("%d",&n);
3 通过循环语句进行排序数据的输入
for(i=0;i<=n-1;i++) scanf("%d",R+i);
4.具体实现
int Partition(int R[],int i,int j)
{
voidinQtupicivko_St=oRrt[(ii]n; t R[],int i,int j)
for(i=0;i<=n-1;i++) 通过循环语句实现排序后数据的输出
printf("%4d",R[i]); 函数类型 函数名 (形参表列 ) while(i<j&&R[j]>=pivot) int pivotpos; 通过循环语句进行排序数据的输入 定义一个数组用于存储输入的数据 3、再对左右区间重复第二步，直到各区间只有一个数。
数据序列划分为左右2个子序列，然后Q通uRi过c[ik+_QS+o]u=rtiR(cR[kj,]i,;_pSivootrpto函s-1数); 的递
归调用对左右2个子序列进行排序，}从w而Qhiul实eiic+(ik<+现_jS;&o快&rtR(速R[i,]p排<iv=o序ptipv功oost能+) 1。,j);
3.涉及知识点
1
数组定义
数据类型说明符 数组名 [常量表达式];
例：int R[MAX];
2
数组引用
数组名[下标]
下标从0开始，如果数组的长度为n，则下标的范围应该界于0和n-1之间。
例： R[ j]<R[k]
3.涉及知识点
3
函数定义
函数类型 函数名 (形参表 列)
{ 函数体 }
void Quick_Sort (int R[],int left,int right) {
int n; scanf("%d",&n);
3 通过循环语句进行排序数据的输入
for(i=0;i<=n-1;i++) scanf("%d",R+i);
4.具体实现
int Partition(int R[],int i,int j)
{
voidinQtupicivko_St=oRrt[(ii]n; t R[],int i,int j)
for(i=0;i<=n-1;i++) 通过循环语句实现排序后数据的输出
printf("%4d",R[i]); 函数类型 函数名 (形参表列 ) while(i<j&&R[j]>=pivot) int pivotpos; 通过循环语句进行排序数据的输入 定义一个数组用于存储输入的数据 3、再对左右区间重复第二步，直到各区间只有一个数。
快速排序PPT课件
目录
快速排序导入 – 冒泡排序分析
49 25 25 21 16 06 06 16 21 25 25 49
从直观上49移动到最终的位置经过了n-1次比较和交换 能不能不经过n-1次比较和交换呢？
不能？这是由于冒泡排序中需要相邻的元素两 两比较、交换
目录
快速排序思想
基本思想： 1）寻找一个中心元素（通常为第一个数）
江西师范大学计算机信息工程学院 – 数据结构
快速排序
作者：杨劲松
内容提要
快速排序导入 快速排序思想 快速排序讲解 快速排序算法分析 练习题 退出
快速排序导入
请同学们使用冒泡排序的方法将下列数据排序： （从小到大）
21 25 49 16 25 06
目录
快速排序导入 – 冒泡排序过程
第初一始次状交态换结束
j--;
}
}while(i<j);
a[i]=temp; //将中心元素t填入最终位置
目录
快速排序讲解
函数头：quicksort(int a[],int left,int right)
①初始化：i=left;j=right;int temp=a[left];
②划分：do{一次划分} while(i<j);
快速排序是不稳定的排序方法
目录
练习题
1）在快速排序方法中，进行每次划分时，是从当前待排序区间 的_两__端__ 向__中_间__依次查找出处于逆序的元素并交换之，最后将 中心元素交换到 一个确定位置，从而以该位置把当前区间划分为前后
2）假定一组记录的关键字为 (46,79,56,38,40,80)，对其进行快速 排 序的一次划分的结果[为38__4_0_]__46__[_5_6__7_9__84_]_。
快速排序导入 – 冒泡排序分析
49 25 25 21 16 06 06 16 21 25 25 49
从直观上49移动到最终的位置经过了n-1次比较和交换 能不能不经过n-1次比较和交换呢？
不能？这是由于冒泡排序中需要相邻的元素两 两比较、交换
目录
快速排序思想
基本思想： 1）寻找一个中心元素（通常为第一个数）
江西师范大学计算机信息工程学院 – 数据结构
快速排序
作者：杨劲松
内容提要
快速排序导入 快速排序思想 快速排序讲解 快速排序算法分析 练习题 退出
快速排序导入
请同学们使用冒泡排序的方法将下列数据排序： （从小到大）
21 25 49 16 25 06
目录
快速排序导入 – 冒泡排序过程
第初一始次状交态换结束
j--;
}
}while(i<j);
a[i]=temp; //将中心元素t填入最终位置
目录
快速排序讲解
函数头：quicksort(int a[],int left,int right)
①初始化：i=left;j=right;int temp=a[left];
②划分：do{一次划分} while(i<j);
快速排序是不稳定的排序方法
目录
练习题
1）在快速排序方法中，进行每次划分时，是从当前待排序区间 的_两__端__ 向__中_间__依次查找出处于逆序的元素并交换之，最后将 中心元素交换到 一个确定位置，从而以该位置把当前区间划分为前后
2）假定一组记录的关键字为 (46,79,56,38,40,80)，对其进行快速 排 序的一次划分的结果[为38__4_0_]__46__[_5_6__7_9__84_]_。
快速排序优秀PPT
}
}while(i<j);
a[i]=temp;
quicksort(a,left,i-1);
quicksort(a,i+1,right);
}
}
21
目录
算法分析
思考：当数据有序的情况下，快速排序的效率如何？
例 06 16 21 25 25 49
快速排序的最坏时间复杂度为O(n2) 快速排序的最好时间复杂度为O(nlog2n) 快速排序的平均时间复杂度为O(nlog2n)
③中心元素填入：a[i]=temp; ④递归地对剩余段作快速排序
quicksort(a,left,i-1); quicksort(a,i+1,right);
目录
19
快速排序完整代码
void quicksort(int a[],int left,int right)
{ int i,j;
if(left<right)
i=1
j=3
i=2
j=3
i=2
j=2
[0]
[1]
[2]
[3]
[4]
[5]
16
算法终止
目录
程序填空
快速排序讲解
left,right用于限定要排序数列的范围,temp即为中心元素
i=left;j=right;int temp=a[left];
do
{
//从右向左找第1个不小于中心元素的位置j
while( a[j] > temp && i<j) j--;
if(i<j)
{
a[ I ] = a[ j ];
i++;
当前元素小于中心元 素结束循环时，应当 在中心元素的左边
快速排序原理(精讲)
进行第一次交换后： 27 38 65 97 76 13 49
( 按照算法的第三步从后面开始找
进行第二次交换后： 27 Βιβλιοθήκη 38 49 97 76 13 65
快速排序就是递归调用此过程——在以49为中点分割这个数据序列，分别对前面一部分和后面一部分进行类似的快速排序，从而完成全部数据序列的快速排序，最后把此数据序列变成一个有序的序列，根据这种思想对于上述数组A的快速排序的全过程如图6所示：
初始状态 {49 38 65 97 76 13 27}
（1） 36 36 18 53 72 30 48 93 15 45
（2） 36 36 18 45 72 30 48 93 15 53
快速排序是对冒泡排序的一种改进。它的基本思想是：通过一躺排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一不部分的所有数据都要小，然后再按次方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。
假设要排序的数组是A[1]……A[N]，首先任意选取一个数据（通常选用第一个数据）作为关键数据，然后将所有比它的数都放到它前面，所有比它大的数都放到它后面，这个过程称为一躺快速排序。一躺快速排序的算法是：
5）、重复第3、4步，直到I=J；
例如：待排序的数组A的值分别是：（初始关键数据X：=49）
A[1] A[2] A[3] A[4] A[5] A[6] A[7]：
49 38 65 97 76 13 27
3）、利用分治思想（即大化小的策略）可进一步对S[1。。K-1]和S[K+1。。N]两组数据再进行快速排序直到分组对象只有一个数据为止。
如具体数据如下，那么第一躺快速排序的过程是：
第2章分治策略3快速排序.ppt.ppt
7
2.5 快速排序问题 快速排序问题
划分过程
Partition 的过程中，首先要选择一个元素，根据其值 划分数组。称该元素为中轴。 选择中轴有许多不同的策略，我们使用最简单的策略， 选择第一个元素：s = a[p]。
8
2.5 快速排序问题 快速排序问题
划分举例
(1) 65 65 (2) 70 45 (3) 75 75 (4) 80 80 (5) 85 85 (6) 60 60 (7) 55 55 (8) 50 50 (9) 45 70 (10) +∞ +∞ i 2 3 p 9 8
18
2.5 快速排序问题 快速排序问题
计数排序、冒泡排序、插入排序、选择排序、归并排 序和快速排序的时间复杂性如下：
算法 杂性 冒泡排序 计数排序
最坏复杂性 n2 n2
平均复 n2 n2
插入排序
选择排序 快速排序 log n 归并排序
n2
n2 n2 n log n
n2
n2 n n log n
2.5 快速排序问题 快速排序问题
例：排列 5，3，1，9，8，2，4，7
0 1
i 5 3 1 9 i 5 3 1 9 i 5 3 1 4 8 i 5 3 1 4 8 i 5 3 1 4 2 j 2 j 2 2 j 8 i 9 7 3 9 7 1 1 2 3 4 8 2 8 2 4 j 4 j 9 7 j 1 i 3 4 7 2
从右到左的扫描从最后一个元素开始，因为我们希 望大于中轴的元素位于子数组的第二部分，扫描会 忽略大于中轴的元素，直到遇到第一个小于等于中 轴的元素才会停止。
10
2.5 快速排序问题 快速排序问题
第九章——4快速排序
《数据结构》 课程
快速排序
主讲教师：赵宁
目录 CONTENTS
1 快速排序基本思想 2 快速排序算法 3 快速排序算法性能分析
1 基本思想
快速排序
选取待排记录中的第一个记录作为基准，通过一趟排 序，将待排记录分为左右两个子序列。左子序列中的记录 小于基准记录，右子序列中的记录大于或等于基准记录。 经过一趟快排，基准记录到位。然后分别对左、右两个子 序列进行排序，直到整个序列有序。
{
int i=left,j=right,temp; /*将i和j分别指向待排序列的第一个和最后一个记录*/
temp=a[i];
/*暂存基准*/
while(i<j) {
while(i<j&& a[j]>=temp) j--;
/*从右侧开始扫描*/
if(i<j) {
/*找到小于基准的记录*/
a[i]=a[j];
④ 重复②和③步，直到i和j指向同一位置，即为基准的最终位置。
1 基本思想
一趟快速排序示例
temp
1
2
3
4
5
6
7
8
9
49 38 65 97 13 27 49* 55 04
i
j
1 基本思想
一趟快速排序示例
1
2
3
4
5
6
7
8
9
49
0449 38 65 97 13 27 49* 55 04
i
j
1 基本思想
i
j
1 基本思想
一趟快速排序示例
1
2
3
4
5
6
7
8
快速排序
主讲教师：赵宁
目录 CONTENTS
1 快速排序基本思想 2 快速排序算法 3 快速排序算法性能分析
1 基本思想
快速排序
选取待排记录中的第一个记录作为基准，通过一趟排 序，将待排记录分为左右两个子序列。左子序列中的记录 小于基准记录，右子序列中的记录大于或等于基准记录。 经过一趟快排，基准记录到位。然后分别对左、右两个子 序列进行排序，直到整个序列有序。
{
int i=left,j=right,temp; /*将i和j分别指向待排序列的第一个和最后一个记录*/
temp=a[i];
/*暂存基准*/
while(i<j) {
while(i<j&& a[j]>=temp) j--;
/*从右侧开始扫描*/
if(i<j) {
/*找到小于基准的记录*/
a[i]=a[j];
④ 重复②和③步，直到i和j指向同一位置，即为基准的最终位置。
1 基本思想
一趟快速排序示例
temp
1
2
3
4
5
6
7
8
9
49 38 65 97 13 27 49* 55 04
i
j
1 基本思想
一趟快速排序示例
1
2
3
4
5
6
7
8
9
49
0449 38 65 97 13 27 49* 55 04
i
j
1 基本思想
i
j
1 基本思想
一趟快速排序示例
1
2
3
4
5
6
7
8
排序方法演示
0 1 2 3 4 5 6 7 8
38
49
65
76
13
27
49
97
38
49
65
76
13
27
49
97
15
3、快速排序
1、 起泡排序 • 原理: 若序列中有 n 个元素，通常进行 n - 1 趟。第 1 趟，针对第 r[1] 至 r[n] 个元 素进行。第 2 趟，针对第 r[1] 至 r[n－1] 个元素进行。…… 第 n-1 趟，针对 第 r[1] 至 r[2] 个元素进行。 每一趟进行的过程： 从第一个元素开始，比较两个相邻的元素。若相邻的元素的相对位置不正确 ，则进行交换；否则继续比较下面两个相邻的元素。 结束条件：在任何一趟进行过程中，未出现交换。 e.g: 将序列 49、38、65、97、76、13、27、49 用 起泡排序的方法进行排序。
0 1 2 3 4 5 6 7 8
49
38
65
97
76
13
27
49
38
49
65
76
97
13
27
49
7
3、快速排序
1、 起泡排序 • 原理: 若序列中有 n 个元素，通常进行 n - 1 趟。第 1 趟，针对第 r[1] 至 r[n] 个元 素进行。第 2 趟，针对第 r[1] 至 r[n－1] 个元素进行。…… 第 n-1 趟，针对 第 r[1] 至 r[2] 个元素进行。 每一趟进行的过程： 从第一个元素开始，比较两个相邻的元素。若相邻的元素的相对位置不正确 ，则进行交换；否则继续比较下面两个相邻的元素。 结束条件：在任何一趟进行过程中，未出现交换。 e.g: 将序列 49、38、65、97、76、13、27、49 用 起泡排序的方法进行排序。
38
49
65
76
13
27
49
97
38
49
65
76
13
27
49
97
15
3、快速排序
1、 起泡排序 • 原理: 若序列中有 n 个元素，通常进行 n - 1 趟。第 1 趟，针对第 r[1] 至 r[n] 个元 素进行。第 2 趟，针对第 r[1] 至 r[n－1] 个元素进行。…… 第 n-1 趟，针对 第 r[1] 至 r[2] 个元素进行。 每一趟进行的过程： 从第一个元素开始，比较两个相邻的元素。若相邻的元素的相对位置不正确 ，则进行交换；否则继续比较下面两个相邻的元素。 结束条件：在任何一趟进行过程中，未出现交换。 e.g: 将序列 49、38、65、97、76、13、27、49 用 起泡排序的方法进行排序。
0 1 2 3 4 5 6 7 8
49
38
65
97
76
13
27
49
38
49
65
76
97
13
27
49
7
3、快速排序
1、 起泡排序 • 原理: 若序列中有 n 个元素，通常进行 n - 1 趟。第 1 趟，针对第 r[1] 至 r[n] 个元 素进行。第 2 趟，针对第 r[1] 至 r[n－1] 个元素进行。…… 第 n-1 趟，针对 第 r[1] 至 r[2] 个元素进行。 每一趟进行的过程： 从第一个元素开始，比较两个相邻的元素。若相邻的元素的相对位置不正确 ，则进行交换；否则继续比较下面两个相邻的元素。 结束条件：在任何一趟进行过程中，未出现交换。 e.g: 将序列 49、38、65、97、76、13、27、49 用 起泡排序的方法进行排序。
排序算法精讲PPT课件
if (L.r[j].key > L.r[j+1].key ) {
for(j = i - 2; L.r[0].key < L.r[j].key]; j--)
L.r[0] = L.r[j]; L.r[j] = L.r[j+1];
L.r[j+1] = L.r[j];
L.r[j+1] = L.r[0]; exchanged =TRUE;
有序序列R[1..i-1]
第i趟 简单选择排序
无序序列 R[i..n] 从中选出关键字最小的记录
有序序列R[1..i]
无序序列 R[i+1..n]
简单选择排序算法
❖ 以顺序表作为存储结构的简单选择排序算法
void SelectSort(SqList &L) {//对顺序表作简单选择排序
ffoorr((ii==11;;ii<<LL..elnenggthth; ;i+i+++) ){{
数据结构定义
#define MAXSIZE 100
typedef int Keytype;
// 定义关键字类型为整型
typedef char InfoType[100];
typedef struct { KeyType key; InfoType otherinfo;
}RedType;
// 关键字项 // 其他数据项 // 记录类型
typedef struct { RedType r[MAXSIZE+1]; int length;
}SqList;
// r[0]闲置或用作哨兵 // 顺序表长度 // 顺序表类型
直接插入排序
直接插入排序(Straight Insertion Sorting)的基本思想 是：n个待排序的元素由一个有序表和一个无序表组成， 开始时有序表中只包含一个元素。排序过程中，每次从 无序表中取出第一个元素，将其插入到有序表中的适当 位置，使有序表的长度不断加长，完成排序过程。
for(j = i - 2; L.r[0].key < L.r[j].key]; j--)
L.r[0] = L.r[j]; L.r[j] = L.r[j+1];
L.r[j+1] = L.r[j];
L.r[j+1] = L.r[0]; exchanged =TRUE;
有序序列R[1..i-1]
第i趟 简单选择排序
无序序列 R[i..n] 从中选出关键字最小的记录
有序序列R[1..i]
无序序列 R[i+1..n]
简单选择排序算法
❖ 以顺序表作为存储结构的简单选择排序算法
void SelectSort(SqList &L) {//对顺序表作简单选择排序
ffoorr((ii==11;;ii<<LL..elnenggthth; ;i+i+++) ){{
数据结构定义
#define MAXSIZE 100
typedef int Keytype;
// 定义关键字类型为整型
typedef char InfoType[100];
typedef struct { KeyType key; InfoType otherinfo;
}RedType;
// 关键字项 // 其他数据项 // 记录类型
typedef struct { RedType r[MAXSIZE+1]; int length;
}SqList;
// r[0]闲置或用作哨兵 // 顺序表长度 // 顺序表类型
直接插入排序
直接插入排序(Straight Insertion Sorting)的基本思想 是：n个待排序的元素由一个有序表和一个无序表组成， 开始时有序表中只包含一个元素。排序过程中，每次从 无序表中取出第一个元素，将其插入到有序表中的适当 位置，使有序表的长度不断加长，完成排序过程。
快速排序 c,c++,ppt
k z
4
y
z
y
4
0
2
1
3
2
1
3
1
0
2
1
3
2
1
3
图 11
图 12
15
执行（3）a[ z ]<k，z=z+1=2，a[2]<k，z=z+1=3，这时 z=y，不会执行（4），同时退出直到型循环，见图13。 然后做 a[ z ]=k，即a[ 3 ]=4，见图14，左边也排好了。
k
4
z y
k
4
z y
1
下面给出参考程序（分两页）
21
// ******************************************* // * 程 序：6_9.cpp * // * 作 者：ghq * // * 编制时间：2010年4月15日 * // * 主要功能：快速排序 * // ******************************************* #include <iostream> //预编译命令 using namespace std; void sort(int array[ ], int zz, int yy) //被调用函数，数组array,zz,yy为形参 { //函数体开始 int z,y,i,k; //定义变量 if ( zz<yy ) //如果 zz < yy ,则做下列 7 件事: { // 7 件事开始 z = zz; y = yy; k = array[ z ]; //第1件事 do{ //第2件事(开始) while(( z<y)&&(array[y]>=k)) y--; //2.1,右边的元素>=k,让 y 往中间移 if( z < y ) //2.2,右边的元素<k,让 { array[ z ] = array[ y ]; //array[ y ]送给 array[ z ]， z = z+1; //同时让 z 往中间移 } while(( z< y) && (array[z] <= k)) z++; //2.3,左边的元素<=k,让 z 往中间移 if ( z < y ) //2.4,左边的元素>k, 让 array[ z ] 22 array[ y ] = array [ z ]; //送给array[ y ]
4
y
z
y
4
0
2
1
3
2
1
3
1
0
2
1
3
2
1
3
图 11
图 12
15
执行（3）a[ z ]<k，z=z+1=2，a[2]<k，z=z+1=3，这时 z=y，不会执行（4），同时退出直到型循环，见图13。 然后做 a[ z ]=k，即a[ 3 ]=4，见图14，左边也排好了。
k
4
z y
k
4
z y
1
下面给出参考程序（分两页）
21
// ******************************************* // * 程 序：6_9.cpp * // * 作 者：ghq * // * 编制时间：2010年4月15日 * // * 主要功能：快速排序 * // ******************************************* #include <iostream> //预编译命令 using namespace std; void sort(int array[ ], int zz, int yy) //被调用函数，数组array,zz,yy为形参 { //函数体开始 int z,y,i,k; //定义变量 if ( zz<yy ) //如果 zz < yy ,则做下列 7 件事: { // 7 件事开始 z = zz; y = yy; k = array[ z ]; //第1件事 do{ //第2件事(开始) while(( z<y)&&(array[y]>=k)) y--; //2.1,右边的元素>=k,让 y 往中间移 if( z < y ) //2.2,右边的元素<k,让 { array[ z ] = array[ y ]; //array[ y ]送给 array[ z ]， z = z+1; //同时让 z 往中间移 } while(( z< y) && (array[z] <= k)) z++; //2.3,左边的元素<=k,让 z 往中间移 if ( z < y ) //2.4,左边的元素>k, 让 array[ z ] 22 array[ y ] = array [ z ]; //送给array[ y ]
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
试讲：快速排序
目录
1
问题导入
2
思想解读
3
案例讲解
4
代码实现
5
性能分析
6
总结作业
1、问题导入：为什么会有快速排序？传统排序的缺点Fra bibliotek传统排序：
冒泡排序 选择排序 插入排序
两两比较
传统排序的缺点
2、核心思想：分治与递归
分治思想
3、案例讲解：６个无序整数
快速排序基本步骤
递归的4个步骤
1、选定Pivot中心轴 2、将大于Pivot的数字放在Pivot的右边 3、将小于Pivot的数字放在Pivot的左边 4、分别对左右子序列重复前三步操作
3）快速排序在（________________________________）情况下效率最低，在 （_______________________________________________）_情况下最易发挥其长处。
4）快速排序在平均情况下的时间复杂度为（__________） ，在最坏 情况下的时间复杂 度为（_ ____）。
案例讲解
38
97
16
26
06
09
97 38
26 16
06
09
案例讲解
97
38
26
16
09 06
L
R
案例讲解
接下来再分别对左子序列和右子序列进行排序
左子序列
右子序列
38
Pivot
09<38(Pivot) 06<38(Pivot)
16<38(Pivot) 26<38(Pivot)
97>38(Pivot)
真诚感谢各位评委老师！
}
代码实现：快速排序函数
void QSort(SqList &L,int left,int right) {
if(left<right) { pivotloc=Partition(L,left,right); Qsort(L,left, pivotloc-1); Qsort(L,pivotloc+1,right);
while(left<right&&L.r[right].key>=pivotkey)--right; L.r[left]=L.r[right];
while(left<right&&L.r[left].key<=pivotkey)++left; L.r[right]=L.r[left];
} L.r[left]=pivotkey; reture left;
时间效率：O(nlog2n) 空间效率：O(log2n)--递归要用到栈空间 不稳定
6、总结作业：课程总结与课后作业
课程总结
问题的导入 解决传统排序两两比 较带来的比较负荷
基本思想 分而治之与递归
案例与代码
主要讲解了一个６位无 序数字序列的案例以及 Ｃ语言代码的实现
性能总结
时间复杂度，空间复杂 度，最好、最坏情形
课后作业
1）在快速排序方法中，进行每次划分时，是从当前待排序区间 的（_____） 向（_____） 依次查找出处于逆序的元素并交换之，最后将 中心元素交换到一个确定位置，从而以该位 置把当前区间划分为前后
2）假定一组记录的关键字为 (46,79,56,38,40,80)，对其进行快速 排序的一次划分的结果 为（_________________）。
可以证明，平均计算时间是O(nlog2n)。 实验结果表明：就平均计算时间而言，快速排序是我 们所讨论的所有内排序方法中最好的一个。 快速排序是递归的，需要有一个栈存放每层递归调用时参 数（新的left和right）。 最大递归调用层次数与递归树的深度一致，因此，要求存储 开销为O(log2n)。
性能总结
97
26 16
09 06
L
R
案例讲解
左子序列
16
26
09 06
L
R
案例讲解
09
左子序列长度为1，
不需要继续排序
需要对右子序列进行排序
06<09（Pivot）
16>09（Pivot）
26>09（Pivot）
16
26
06
L
R
案例讲解
16
16 L
26>16(Pivot)
26 R
案例讲解
97
97
38
} }
5、性能总结：时空分析
性能总结：最好最坏场景分析
最好：划分后，左子序列和右子序列的长度相同
最坏：有序，递归树成为单支树，每次划分只得到一个比上一次少 一个对象的子序列，必须经过n-1趟才能把所有对象定位，而且第i趟 需要经过n-i次关键码才能得到第i个对象的安放位置
性能总结：时间和空间分析
16 09 06
26 16
38 26
06
09
4、代码实现：C语言代码实现
代码实现：一趟划分函数
int Partition(SqList &L, int left, int right) {
L.r[left]=l.r[0]; pivotkey=l.r[0].key;
while(left<right) {
目录
1
问题导入
2
思想解读
3
案例讲解
4
代码实现
5
性能分析
6
总结作业
1、问题导入：为什么会有快速排序？传统排序的缺点Fra bibliotek传统排序：
冒泡排序 选择排序 插入排序
两两比较
传统排序的缺点
2、核心思想：分治与递归
分治思想
3、案例讲解：６个无序整数
快速排序基本步骤
递归的4个步骤
1、选定Pivot中心轴 2、将大于Pivot的数字放在Pivot的右边 3、将小于Pivot的数字放在Pivot的左边 4、分别对左右子序列重复前三步操作
3）快速排序在（________________________________）情况下效率最低，在 （_______________________________________________）_情况下最易发挥其长处。
4）快速排序在平均情况下的时间复杂度为（__________） ，在最坏 情况下的时间复杂 度为（_ ____）。
案例讲解
38
97
16
26
06
09
97 38
26 16
06
09
案例讲解
97
38
26
16
09 06
L
R
案例讲解
接下来再分别对左子序列和右子序列进行排序
左子序列
右子序列
38
Pivot
09<38(Pivot) 06<38(Pivot)
16<38(Pivot) 26<38(Pivot)
97>38(Pivot)
真诚感谢各位评委老师！
}
代码实现：快速排序函数
void QSort(SqList &L,int left,int right) {
if(left<right) { pivotloc=Partition(L,left,right); Qsort(L,left, pivotloc-1); Qsort(L,pivotloc+1,right);
while(left<right&&L.r[right].key>=pivotkey)--right; L.r[left]=L.r[right];
while(left<right&&L.r[left].key<=pivotkey)++left; L.r[right]=L.r[left];
} L.r[left]=pivotkey; reture left;
时间效率：O(nlog2n) 空间效率：O(log2n)--递归要用到栈空间 不稳定
6、总结作业：课程总结与课后作业
课程总结
问题的导入 解决传统排序两两比 较带来的比较负荷
基本思想 分而治之与递归
案例与代码
主要讲解了一个６位无 序数字序列的案例以及 Ｃ语言代码的实现
性能总结
时间复杂度，空间复杂 度，最好、最坏情形
课后作业
1）在快速排序方法中，进行每次划分时，是从当前待排序区间 的（_____） 向（_____） 依次查找出处于逆序的元素并交换之，最后将 中心元素交换到一个确定位置，从而以该位 置把当前区间划分为前后
2）假定一组记录的关键字为 (46,79,56,38,40,80)，对其进行快速 排序的一次划分的结果 为（_________________）。
可以证明，平均计算时间是O(nlog2n)。 实验结果表明：就平均计算时间而言，快速排序是我 们所讨论的所有内排序方法中最好的一个。 快速排序是递归的，需要有一个栈存放每层递归调用时参 数（新的left和right）。 最大递归调用层次数与递归树的深度一致，因此，要求存储 开销为O(log2n)。
性能总结
97
26 16
09 06
L
R
案例讲解
左子序列
16
26
09 06
L
R
案例讲解
09
左子序列长度为1，
不需要继续排序
需要对右子序列进行排序
06<09（Pivot）
16>09（Pivot）
26>09（Pivot）
16
26
06
L
R
案例讲解
16
16 L
26>16(Pivot)
26 R
案例讲解
97
97
38
} }
5、性能总结：时空分析
性能总结：最好最坏场景分析
最好：划分后，左子序列和右子序列的长度相同
最坏：有序，递归树成为单支树，每次划分只得到一个比上一次少 一个对象的子序列，必须经过n-1趟才能把所有对象定位，而且第i趟 需要经过n-i次关键码才能得到第i个对象的安放位置
性能总结：时间和空间分析
16 09 06
26 16
38 26
06
09
4、代码实现：C语言代码实现
代码实现：一趟划分函数
int Partition(SqList &L, int left, int right) {
L.r[left]=l.r[0]; pivotkey=l.r[0].key;
while(left<right) {