10.1几种基本排序算法的实现
数据结构-内排序
Shell排序的性能分析
Shell排序的时间复杂度在O(nlog2n)和O(n2)间, Knuth的 统计结论是,平均比较次数和记录平均移动次数在n1.25与 1.6n1.25之间
Shell排序是一种不稳定的排序方法
最后谈一下delta的取法。 Shell最初的方案是delta=n/2, delta=delta/2,直到delta=1。Knuth的方案是delta=delta/3 +1。其它方案有:都取奇数为好;或delta互质为好等等。 而使用象1, 2, 4, 8, …或1, 3, 6, 9, …这样的增量序列就不太 合适,因为这样会使几个元素多次被分到一组中,从而造 成重复排序,产生大量无用的比较操作
另外,在无序子表中向前移动的过程中,如果没 有交换元素,则说明无序子表已有序,无须再做 排序
24
冒泡排序算法实现
1 void bubble_sort(RecType R[ ], int n) { 2 //待排序元素用一个数组R表示,数组有n个记录
3 int i, j; 4 bool swap=TRUE; //判断无序子表是否已有序的变量
内排序和外排序 按照排序过程中使用内、外存的不 同将排序方法分为内排序和外排序。若待排序记录全 部在内存中,称为内排序;若待排序记录的数量很大, 以致内存一次不能容纳全部记录,在排序过程中需要 进行内、外存交换,称为外排序。本章仅讨论内排序
内排序可分为五大类:插入排序、交换排序、选择排 序、归并排序和基数排序
直接插入排序(straight insert sort) 折半插入排序(binary insert sort) Shell排序(Shell sort)
10
10.2.1 直接插入排序举例
十大经典排序算法总结
⼗⼤经典排序算法总结最近⼏天在研究算法,将⼏种排序算法整理了⼀下,便于对这些排序算法进⾏⽐较,若有错误的地⽅,还请⼤家指正0、排序算法说明0.1 排序术语稳定:如果a=b,且a原本排在b前⾯,排序之后a仍排在b的前⾯不稳定:如果a=b,且a原本排在b前⾯,排序之后排在b的后⾯时间复杂度:⼀个算法执⾏所耗费的时间空间复杂度:⼀个算法执⾏完所需内存的⼤⼩内排序:所有排序操作都在内存中完成外排序:由于数据太⼤,因此把数据放在磁盘中,⽽排序通过磁盘和内存的数据传输才能进⾏0.2算法时间复杂度、空间复杂度⽐较0.3名词解释n:数据规模k:桶的个数In-place:占⽤常数内存,不占⽤额外内存Out-place:占⽤额外内存0.4算法分类1.冒泡排序冒泡排序是⼀种简单的排序算法。
它重复地⾛访过要排序的数列,⼀次⽐较两个元素,如果它们的顺序错误就把它们交换过来。
⾛访数列的⼯作是重复地进⾏直到没有再需要交换,也就是说该数列已经排序完成。
这个算法的名字由来是因为越⼩的元素会经由交换慢慢“浮”到数列的顶端1.1算法描述⽐较相邻的元素,如果前⼀个⽐后⼀个打,就交换对每⼀对相邻元素做同样的⼯作,从开始第⼀对到结尾最后⼀对,这样在最后的元素应该会是最⼤的数针对所有的元素重复以上的步骤,除了最后⼀个重复步骤1-3,知道排序完成1.2动图演⽰1.3代码实现public static int[] bubbleSort(int[] array) {if (array.length == 0)return array;for (int i = 0; i < array.length; i++)for (int j = 0; j < array.length - 1 - i; j++)if (array[j + 1] < array[j]) {int temp = array[j + 1];array[j + 1] = array[j];array[j] = temp;}return array;}1.4算法分析最佳情况:T(n) = O(n) 最差情况:T(n) = O(n2) 平均情况:T(n) = O(n2)2.选择排序表现简单直观的最稳定的排序算法之⼀,因为⽆论什么数据都是O(n2)的时间复杂度,⾸先在未排序序列中找到最⼩(⼤)元素,与数组中第⼀个元素交换位置,作为排序序列的起始位置,然后再从剩余未排序元素中继续寻找最⼩(⼤)的元素,与数组中的下⼀个元素交换位置,也就是放在已排序序列的末尾2.1算法描述1.初始状态:⽆序区为R[1..n],有序区为空2.第i躺排序开始时,当前有序区和⽆序区R[1..i-1]、R[i..n]3.n-1趟结束,数组有序化2.2动图演⽰2.3代码实现public static int[] selectionSort(int[] array) {if (array.length == 0)return array;for (int i = 0; i < array.length; i++) {int minIndex = i;for (int j = i; j < array.length; j++) {if (array[j] < array[minIndex]) //找到最⼩的数minIndex = j; //将最⼩数的索引保存}int temp = array[minIndex];array[minIndex] = array[i];array[i] = temp;}return array;}2.4算法分析最佳情况:T(n) = O(n2) 最差情况:T(n) = O(n2) 平均情况:T(n) = O(n2)3、插⼊排序是⼀种简单直观的排序算法,通过构建有序序列,对于未排序序列,在已排序序列中从后向前扫描,找到相应位置并插⼊,需要反复把已排序元素逐步向后挪位,为最新元素腾出插⼊空间3.1算法描述1.从第⼀个元素开始,该元素可以认为已经被排序2.取出下⼀个元素(h),在已排序的元素序列中从后往前扫描3.如果当前元素⼤于h,将当前元素移到下⼀位置4.重复步骤3,直到找到已排序的元素⼩于等于h的位置5.将h插⼊到该位置6.重复步骤2-53.2动图演⽰3.3代码实现public static int[] insertionSort(int[] array) {if (array.length == 0)return array;int current;for (int i = 0; i < array.length - 1; i++) {current = array[i + 1];int preIndex = i;while (preIndex >= 0 && current < array[preIndex]) {array[preIndex + 1] = array[preIndex];preIndex--;}array[preIndex + 1] = current;}return array;}3.4算法分析最佳情况:T(n) = O(n) 最坏情况:T(n) = O(n2) 平均情况:T(n) = O(n2)4、希尔排序是简单插⼊排序经过改进之后的⼀个更⾼效的版本,也称为缩⼩增量排序,同时该算法是冲破O(n2)的第⼀批算法之⼀。
排序
2
5
[2
[2
3
3
8] 5
5
9
1 6
1 6
8] 9
i=5
i=6
9
1
[2
[1 [1
3
2 2
5
3
8
5
9] 1 6
8 6 9] 6 8 9]
i=7 6
3 5
方法1:边比较边移动
void straightsort1(SqList &L){
//设立监视哨:r[i]r[0],在查找的过程中同时后移记录
for(i=2;i≤L.length;i++){ L.r[0]=L.r[i]; j=i-1; while(L.r[0].key<L.r[j].key){ L.r[j+1]=L.r[j]; j-- ;} L.r[j+1]= L.r[0]; } }//straightsort
{ L.r[0]=L.r[i]; j=i-step;
while(j≥1 && L.r[0].key<L.r[j].key)
{ L.r[j+step]=L.r[j]; //元素右移
j=j-step }; }
//考虑前一个位置
L.r[ j+step]=L.r[0]; //r[i]放在合适的位置 } //shellpass ---r[0]不是哨兵
10.1.1 直接插入排序
在数组{r[1],r[2],… ,r[n] } 中从第二个元素 起,将其依次插入到前面已排好序的序列中。 设立监视哨:r[i]r[0]
r[0] r[1] r[2]… r[j] r[j+1] … r[i-1] r[i] …
数据结构 排序
2019/9/7
30
10.4.1 简单选择排序
待排记录序列的状态为:
有序序列R[1..i-1] 无序序列 R[i..n]
有序序列中所有记录的关键字均小于无序序列中记 录的关键字,第i趟简单选择排序是从无序序列 R[i..n]的n-i+1记录中选出关键字最小的记录加入 有序序列
2019/9/7
5
排序的类型定义
#define MAXSIZE 20 // 待排序记录的个数
typedef int KeyType;
typedef struct
{ KeyType key;
InfoType otherinfo; ∥记录其它数据域
} RecType;
typedef struct {
RecType r[MAXSIZE+1];
分别进行快速排序:[17] 28 [33] 结束 结束
[51 62] 87 [96] 51 [62] 结束
结束
快速排序后的序列: 17 28 33 51 51 62 87 96
2019/9/7
26
自测题 4 快速排序示例
对下列一组关键字 (46,58,15,45,90,18,10,62) 试写出快速排序的每一趟的排序结果
final↑ ↑first
i=8
[51 51 62 87 96 17 28 33]
final↑ ↑first
2019/9/7
14
希尔(shell )排序
基本思想:从“减小n”和“基本有序”两 方面改进。
将待排序的记录划分成几组,从而减少参 与直接插入排序的数据量,当经过几次分 组排序后,记录的排列已经基本有序,这 个时候再对所有的记录实施直接插入排序。
简单排序算法
简单排序算法排序算法是计算机科学中最基本、最常用的算法之一。
通过对原始数据集合进行排序,可以更方便地进行搜索、统计、查找等操作。
常用的排序算法有冒泡排序、选择排序、插入排序等。
本文将介绍这些简单排序算法的具体实现及其优缺点。
一、冒泡排序(Bubble Sort)冒泡排序是一种基础的交换排序算法。
它通过不断地交换相邻的元素,从而将数据集合逐渐排序。
具体实现步骤如下:1.比较相邻的元素。
如果第一个比第二个大,就交换它们两个;2.对每一对相邻元素做同样的工作,从第一对到最后一对,这样一轮排序后,就可以确保最后一个元素是最大的元素;3.针对所有元素重复以上的步骤,除了最后一个;4.重复步骤1~3,直到排序完成。
冒泡排序的优点是实现简单、容易理解。
缺点是排序效率较低,尤其是对于较大的数据集合,时间复杂度为O(n²)。
二、选择排序(Selection Sort)选择排序是一种基础的选择排序算法。
它通过在数据集合中选择最小的元素,并将其放置到最前面的位置,然后再从剩余元素中选出最小的元素,放置到已排序部分的末尾。
具体实现步骤如下:1.在未排序序列中找到最小元素,存放到排序序列的起始位置;2.再从剩余未排序元素中继续寻找最小元素,放到排序序列末尾;3.重复步骤1~2,直到排序完成。
选择排序的优点是实现简单、固定时间复杂度O(n²)。
缺点是排序效率仍然较低,尤其是对于大数据集合,因为每次只能交换一个元素,所以相对于冒泡排序,它的移动次数固定。
三、插入排序(Insertion Sort)插入排序是一种基础的插入排序算法。
它将未排序的元素一个一个插入到已排序部分的正确位置。
具体实现步骤如下:1.从第一个元素开始,该元素可以认为已经被排序;2.取出下一个元素,在已经排序的元素序列中从后往前扫描;3.如果该元素(已排序)大于新元素,将该元素移到下一位置;4.重复步骤3,直到找到已排序的元素小于或等于新元素的位置;5.将新元素插入到该位置后;6.重复步骤2~5,直到排序完成。
第十章 内部排序
(38) (65) (97) (76) (13) (27) (49)
直接插入排序算法
Void InsertSort(SqList &L) { //对顺序表L作直接插入排序 for (i=2; i<=L.length; ++i) if LT(L.r[i].key, L.r[i-1].key) { L.r[0]=L.r[i]; //复制为哨兵 for (j=i-1; LT(L.r[0].key, L.r[j].key); --j) L.r[j+1]=L.r[j]; //记录后移 L.r[j+1]=L.r[0]; //插入到正确位置 } }//InsertSort
改写上述算法:将枢轴暂存在r[0]的位置上,直至一趟排 序结束后再将枢轴记录移至正确位置上, 算法10.6(b): Int Partition(SqList &L, int low, int high) { L.r[0]=L.r[low]; Pivotkey=L.r[low].key; while (low<high) { while(low<high && L.r[high].key>=pivotkey) --high;
10。3交换排序
起泡排序思想: 依次对未排序部分相邻的两个元素进行比较,若逆序则 交换位置,每一趟可以使一个最大(最小)元素从这个序列 中冒出来,经过n-1趟,就可以排好序 例:
起泡排序示例
初始关键字 第一趟排序后 第二趟排序后 第三趟排序后 第四趟排序后 第五趟排序后 12 12 12 12 12 4 23 23 18 14 4 18 18 14 4 14 14 14 4 18 4 4 23 90 90
快速排序
noi练习题
NOI练习题一、基础算法1.1 递归算法1. 请编写一个C++函数,实现求斐波那契数列的第n项。
2. 编写一个C++函数,实现计算阶乘n!。
1.2 循环算法3. 编写一个C++程序,实现输出1到100之间所有偶数。
4. 编写一个C++程序,计算1到100之间所有奇数的和。
1.3 排序算法5. 编写一个C++程序,使用冒泡排序算法对数组进行从小到大排序。
6. 编写一个C++程序,使用快速排序算法对数组进行从小到大排序。
二、数据结构2.1 线性表7. 编写一个C++程序,实现单链表的创建、插入、删除和查找操作。
8. 编写一个C++程序,实现顺序表的创建、插入、删除和查找操作。
2.2 栈和队列9. 编写一个C++程序,实现栈的基本操作:入栈、出栈、查看栈顶元素。
10. 编写一个C++程序,实现队列的基本操作:入队、出队、查看队首元素。
2.3 树和图11. 编写一个C++程序,实现二叉树的创建、遍历(前序、中序、后序)。
12. 编写一个C++程序,实现图的邻接矩阵表示和邻接表表示。
三、数学问题3.1 素数问题13. 编写一个C++程序,判断一个整数是否为素数。
14. 编写一个C++程序,输出1到100之间的所有素数。
3.2 最大公约数和最小公倍数15. 编写一个C++程序,计算两个整数的最大公约数。
16. 编写一个C++程序,计算两个整数的最小公倍数。
四、搜索算法4.1 暴力搜索17. 编写一个C++程序,实现全排列算法。
18. 编写一个C++程序,实现组合算法。
4.2 深度优先搜索19. 编写一个C++程序,使用深度优先搜索解决迷宫问题。
20. 编写一个C++程序,使用深度优先搜索求解N皇后问题。
五、动态规划5.1 斐波那契数列21. 编写一个C++程序,使用动态规划求解斐波那契数列的第n项。
5.2 最长公共子序列22. 编写一个C++程序,使用动态规划求解两个字符串的最长公共子序列。
5.3 最小路径和23. 编写一个C++程序,使用动态规划求解二维数组中的最小路径和。
【十大经典排序算法(动图演示)】 必学十大经典排序算法
【十大经典排序算法(动图演示)】必学十大经典排序算法0.1 算法分类十种常见排序算法可以分为两大类:比较类排序:通过比较来决定元素间的相对次序,由于其时间复杂度不能突破O(nlogn),因此也称为非线性时间比较类排序。
非比较类排序:不通过比较来决定元素间的相对次序,它可以突破基于比较排序的时间下界,以线性时间运行,因此也称为线性时间非比较类排序。
0.2 算法复杂度0.3 相关概念稳定:如果a原本在b前面,而a=b,排序之后a仍然在b的前面。
不稳定:如果a原本在b的前面,而a=b,排序之后a 可能会出现在b 的后面。
时间复杂度:对排序数据的总的操作次数。
反映当n变化时,操作次数呈现什么规律。
空间复杂度:是指算法在计算机内执行时所需存储空间的度量,它也是数据规模n的函数。
1、冒泡排序(Bubble Sort)冒泡排序是一种简单的排序算法。
它重复地走访过要排序的数列,一次比较两个元素,如果它们的顺序错误就把它们交换过来。
走访数列的工作是重复地进行直到没有再需要交换,也就是说该数列已经排序完成。
这个算法的名字由来是因为越小的元素会经由交换慢慢“浮”到数列的顶端。
1.1 算法描述比较相邻的元素。
如果第一个比第二个大,就交换它们两个;对每一对相邻元素作同样的工作,从开始第一对到结尾的最后一对,这样在最后的元素应该会是最大的数;针对所有的元素重复以上的步骤,除了最后一个;重复步骤1~3,直到排序完成。
1.2 动图演示1.3 代码实现1.unction bubbleSort(arr) {2. varlen = arr.length;3. for(vari = 0; i arr[j+1]) {// 相邻元素两两对比6. vartemp = arr[j+1];// 元素交换7. arr[j+1] = arr[j];8. arr[j] = temp;9. }10. }11. }12. returnarr;13.}2、选择排序(Selection Sort)选择排序(Selection-sort)是一种简单直观的排序算法。
FORTRAN95第十章 排序、查找算法
给定值与处于顺序表“中间位置”上的元素的关键字进行比较键字则在表的后半部分继续进行二 分查找。否则在表的前半部分继续进行二分查找, 如此进行下去直 至找到满足条件的元素,或当前查找区为空。
10.1.4 直接插入排序 直接插入排序的方法是将待排记录分成两部分,初始第
一部分只含1个记录,在排序进程中把第二部分的全部记 录逐步插入到第一部分,并使该部分每次插入记录后是有 序的。直接插入排序算法步骤:
(1)将n个待排的记录数据存一维数组A中,默认A(1)为第 一部分的记录,2=>I;
(2)若I<=n, 则第二部分的一个记录A(I)与第一部分记 录进行比较, 找出在第一部分插入这个记录的位置,然后 将该位置上原来的记录及其后面所有的记录顺序后移一 个位置,在空出的位置上插入这个记录;若I>n (表示把 第二部分的记录全部插入到第一部分) ,则结束排序;
10.1.2 冒泡排序 冒泡排序是通过相邻两个排序记录的关键字的比
较,按一定次序互换逐步实现有序排序。 冒泡排序的实现过程是:第一次冒泡排序,首先将第
一个记录的关键字和第二个记录的关键字进行比较, 若不满足顺序的要求,则将两个记录进行交换,然
后比较第二个记录和第三个记录的关键字并做同样
处理,依次类推,直至对第n-1个记录和第n个记录 进行比较并处理完, 使得关键字值最大的记录被交换 到了最后一个记录的位置上。第二次冒泡排序只需
integer::low,high,key,ix,mid integer,dimension(low:high):: a do while(low<=high)
10种常用典型算法
10种常用典型算法1. 冒泡排序(Bubble Sort):通过比较相邻元素的大小,将较大的元素交换到后面,较小的元素交换到前面,从而实现排序。
时间复杂度为O(n^2)。
2. 插入排序(Insertion Sort):将待排序的元素插入到有序子数组中的合适位置,逐步构建有序数组。
时间复杂度为O(n^2)。
3. 选择排序(Selection Sort):找到未排序部分最小的元素,并将其放到已排序部分的末尾,不断重复这个过程,直到排序完成。
时间复杂度为O(n^2)。
4. 归并排序(Merge Sort):将数组不断二分,然后将二分后的小数组进行排序合并,最终得到一个排序好的数组。
时间复杂度为O(nlogn)。
5. 快速排序(Quick Sort):从数组中选择一个基准元素,将比基准元素小的元素放到基准元素的左边,比基准元素大的元素放到基准元素的右边,然后递归地对左右两个部分进行排序。
时间复杂度为O(nlogn)。
6. 堆排序(Heap Sort):将待排序的数组构建成一个最大堆(或最小堆),然后依次从堆顶取出最大(或最小)元素,再进行调整,直到堆为空。
时间复杂度为O(nlogn)。
7. 计数排序(Counting Sort):统计数组中每个元素出现的次数,然后根据元素的出现次数将其放到相应的位置上,最终得到一个有序的数组。
时间复杂度为O(n+k),其中k为数组中的最大值。
8. 基数排序(Radix Sort):按照元素的位数将数组进行排序,从低位到高位依次排序。
时间复杂度为O(d*(n+k)),其中d为数组中元素的位数,k为基数。
9. 希尔排序(Shell Sort):将待排序的数组按照一定的间隔(增量)分成多个子数组,对每个子数组进行插入排序,然后不断减小增量,最终进行一次完整的插入排序。
时间复杂度为O(nlogn)。
10. 鸽巢排序(Pigeonhole Sort):适用于元素范围较小且元素重复较多的数组,通过统计元素的出现次数,将元素按照其出现的次数放入鸽巢中,然后按次数从小到大依次取出元素,得到一个有序的数组。
数据结构chapter_10
typedef struct { //定义每个记录 数据元素) 定义每个记录( //定义每个记录(数据元素)的结构 KeyType key ; //关键字 //关键字 InfoType otherinfo; //其它数据项 //其它数据项 }RedType; //记录类型 //记录类型 typedef struct { //定义顺序表 定义顺序表L //定义顺序表L的结构 RecordType r [ MAXSIZE +1 ]; //存储顺序表的向量 //存储顺序表的向量 //r[0] r[0]一般作哨兵或缓冲区 //r[0]一般作哨兵或缓冲区 int length ; //顺序表的长度 //顺序表的长度 }SqList; //顺序表类型 //顺序表类型
void BInsertSort (SqList &L) {
// 对顺序表 作折半插入排序 对顺序表L作折半插入排序 for ( i=2; i<=L.length; ++i ) { L.r[0] = L.r[i]; // 将L.r[i]暂存到 暂存到L.r[0] 暂存到 low = 1; high = i-1; while (low<=high) { // 在r[low..high]中折半查找有序插入的位置 中折半查找有序插入的位置 m = (low+high)/2; // 折半 if (L.r[0].key < L.r[m].key) high = m-1; // 插入点在低半区 else low = m+1; // 插入点在高半区 } // while for ( j=i-1; j>=low; --j ) L.r[j+1] = L.r[j]; // 记录后移 // 插入 L.r[high+1] = L.r[0]; } } // BInsertSort
数结与算法_9排序1(复习版2012修改)
第一趟后: 第二趟后: 第三趟后: 第四趟后: 第五趟后:
R
0
15 58 46 45 90 08 32
1 2 3 4 5 6 7
R
0
15 46 58 45 90 08 32
1 2 3 4 5 6 7
R
0
15 46 58 45 90 08 32
1 2 3 4 5 6 7
R
0
15 45 46 58 90 08 32
§10.2
插入排序
10.2.1 直接插入排序 10.2.2 折半插入排序 10.2.3 二路插入排序 10.2.4 表插入排序 10.2.5 希尔排序
插入排序
•
希尔排序
插入排序
•
希尔排序
考察直接插入排序,当 ①n较小时 ②序列基本有序时 直接插入排序的效果比较好。 希尔排序正是基于这两点对直接插入排序 做改进的。 希尔排序又称为缩小增量排序
插入排序
•
直接插入排序
R[0]有两个作用: (1)保留R[i]的副本 (2)监视哨,监视j是否越界
插入排序
•
直接插入排序
直接插入排序算法:
void InsertSort( SqList &L){ //对顺序表L作直接插入排序 for(i=2; i<=L.length; i++) if(L.R[i].key<L.R[i-1].key){ L.R[0].key=L.R[i].key; L.R[i]=L.R[i-1];
在排序的过程中,整个排序区间被分为两个子区间: 有序区R[1..i-1]和无序区R[i..n]; 共进行n-1趟排序,每趟排序都是把无序区的第一 条记录Ri插到有序区的合适位置上。
第十章 内部排序1
0 1 2 3 4 5 6 i=1 7 (49 38 65 97 76 13 27 ) i=2 38 (38 49) 65 97 76 13 27 i=3 65 (38 49 65) 97 76 13 27 i=4 97 (38 49 65 97) 76 13 27 i=5 76 (38 49 65 76 97) 13 27 i=6 13 (13 38 49 65 76 97) 27
k’1≤k’2≤···≤k’n 或 k’1≥k’2≥···≥k’n
• 稳定与不稳定:若记录序列中的任意两个记录 Rx , Ry 的排序码 Kx= Ky ;如果在排序之前和排 序之后,它们的相对位置保持不变,则这种排序 方法是稳定的,否则是不稳定的 • 排序中的两种基本操作:
– 两个排序码的比较(通常是必须的)
n
0
1 2 3 4 97 76 65 49
5 6 7 38 27 13
若待排序记录是随机的,取平均值
排序码比较次数:
n2 4
n2 记录移动次数: 4
时间复杂度:T(n)=O(n² ) 空间复杂度:S(n)=O(1)
10.1.2 折半插入排序
• 对直接插入排序,在插入记录Ri时,改用折半查找 方法确定插入的位置 • 算法思想:在插入Ri时,前面的记录R1, R2 ,·· Ri -1 ·, 已经排好序,因此可用折半查找找到Ri的插入位置
算法描述 #define M 100 //最大记录个数 typedef struct { int key; //排序码域 ···· //其他域 · ·; }RcdType; //记录类型 typedef RcdType Rcdlist[M+1];
//用顺序表存放,记录0下标不用 假设Rcdlist R;排序前待排序的记录已顺序存放在 R中,记录个数为n i:排序趟数,j:移动次数,直接插入排序算法如下:
10排序1
1,排序所需的时间开销 排序所需的时间开销 主要是指执行排序时对关键字 比较次数和记录的移动次数. 和记录的移动次数 的比较次数和记录的移动次数. 2,排序所需的附加空间的开销 排序所需的附加空间的开销 附加空间
10.2 插入排序
插入排序总的基本思想: 插入排序总的基本思想:
每次将一个待排序的记录, 每次将一个待排序的记录, 按其关键字大小插入到一个已经排 好序(不减次序或不增次序) 好序(不减次序或不增次序)的文 件中适当的位置, 件中适当的位置,直到全部记录插 入完毕为止. 入完毕为止.
K i= K j, i > j
稳定排序: 稳定排序: 不稳定排序: 不稳定排序:
排序后
R i 领先R 领先R R j 领先R 领先R
j i
排序后具有相同关键字的记 录之间的相对次序 相对次序保持不变 录之间的相对次序保持不变
5,排序的分类
内部排序: 1. 内部排序:
排序中,文件只在内存中进行的排序. 排序中,文件只在内存中进行的排序. 2,外部排序: 外部排序: 排序中,文件不单要使用内存, 排序中,文件不单要使用内存, 而且使用外存的排序. 而且使用外存的排序.
10.2.1
直接插入排序
例如: 例如:已知一个无序文件记录的关键字序列 49,38,65,97,76,13,27, 为:49,38,65,97,76,13,27,49
以直接插入排序方法进行不减次序排序的过程为: 以直接插入排序方法进行不减次序排序的过程为: 不减次序排序的过程为 49,38,65,97,76,13,27,49 , , , , , , ,
27 27 27 27 27 97 97 76
49 49 49 49 49 49 49 97
[课件]数据结构 第九章 查找
例 初始: 49 38 65 97 76 13 27 48 55 4 取d1=5 49 一趟分组: 38 65 97 76 13 27 48 55 4
一趟排序:13 27 48 55 4 取d2=3 13 二趟分组: 27 48 55 4
49 38 65 97 76 49 38 65 97 76
二趟排序:13 4 48 38 27 49 55 65 97 76 取d3=1 13 三趟分组: 4 48 55 27 49 38 65 97 76
第十章 排序
排序定义——将一个数据元素(或记录)的任意 序列,重新排列成一个按关键字有序的序列叫~ 排序分类
按待排序记录所在位置
内部排序:待排序记录存放在内存 外部排序:排序过程中需对外存进行访问的排序
按排序依据原则
插入排序:直接插入排序,折半插入排序,希尔排序 交换排序:冒泡排序,快速排序 选择排序:简单选择排序,堆排序 归并排序:2-路归并排序 基数排序
4 一趟排序:13 27 48 38 27 49 55 65 97 76 55 4 38 j j j ji ij ij ij i i i
二趟排序: 13 4 48 38 27 49 55 65 97 76 Ch8_3.c
希尔排序特点
子序列的构成不是简单的"逐段分割",而是将相隔某个增 量的记录组成一个子序列 希尔排序可提高排序速度,因为 分组后n值减小,n更小,而T(n)=O(n),所以T(n)从总体 上看是减小了 关键字较小的记录跳跃式前移,在进行最后一趟增量为1 的插入排序时,序列已基本有序 增量序列取法 无除1以外的公因子 最后一个增量值必须为1
2 ( n + 4 )( n 1 ) ( i + 1) = 2
数据结构 排序
(3)时间复杂度
比较次数与待排记录的初始顺序无关,只依赖 记录个数; 插入每个记录需要O(log2i)次比较 最多移动i+1次,最少2次(临时记录) 最佳情况下总时间代价为O(nlog2n) ,最差和 平均情况下仍为O(n2)。
30
9.2.3希尔排序(又称缩小增量排序)
1.基本思想
把待排序的数据元素分成若干个小组, 对同一小组内的数据元素用直接插入法排 序;小组的个数逐次缩小;当完成了所有 数据元素都在一个组内的排序后排序过程
11
存储方式
3. 地址连续的一组存储单元,另设一个 指示各个记录存储位臵的地址向量,在 排序过程中不移动记录本身,而移动地 址向量中的地址,在排序之后再按照地 址向量中的值调整记录的存储位臵-- 地址排序
12
#define MAXSIZE 20 // 待排顺序表最大长度 待排记录的数据类型定义如下 : typedef int KeyType; // 关键字类型为整数类型 typedef struct { KeyType key; // 关键字项 InfoType otherinfo; // 其它数据项 } RedType; // 记录类型 typedef struct { RedType r[MAXSIZE+1]; // r[0]闲臵 int length; // 顺序表长度 } SqList; // 顺序表类型
low high low high m m m high
L.r[high+1] = L.r[0]; // 插入
27
2. 算法实现 void BiInsertionSort ( SqList &L ) {
for ( i=2; i<=L.length; ++i ) { L.r[0] = L.r[i]; // 将 L.r[i] 暂存到 L.r[0]
DS10_排序01_概述和插入排序
排序
先迚排序方法,其时间复杂度为O(nlogn)
基数排序,其时间复杂度为O(d·n)
内排序的分类
按排序过程中依据的原则分
揑入类(直揑排序、二分排序、希尔排序) 交换类(冒泡排序、快速排序) 排序
选择类(直选排序、树型排序、堆排序)
归并类(二路归并排序、多路归并排序) 分配类(多关键字排序、基数排序)
3)折半插入排序性能分析
折半揑入排序减少了关键字的比较次数,但记彔的移动次数丌变,其 时间复杂度不直接揑入排序相同。
折半揑入排序是“稳定的”
3. 2-路插入排序
1)基本思想 2-路揑入排序是在折半揑入排序的基础上改迚的,目的是减少排序过 程中移动记彔的次数,但为此需要n个记彔的辅助空间。
2)具体做法
2)折半插入排序算法
void BinsertSort(SqList &L){ int i,low,high,mid; for(i=2; i<= L.length; ++i) { L.r[0]=L.r[i]; low=1; high=i-1; While(low<=high) { mid=(low+high)/2; if (L.r[0].key< L.r[mid].key) high=mid-1; else low=mid+1; } for( j=i-1; j>=low; j ) L.r[j+1]=L.r[j]; L.r[low]=L.r[0]; } }
另设一个和 L.r 同类型的数组d,首先将 L.r[1] 赋值给 d[1] ,并将 d[1] 看成是在排好序的序列中处于中间位置的记彔,然后从 L.r 中第 2 个记彔起依次揑入到d[1] 之前或之后的有序序列中。先将待揑入记彔的 关键字和 d[1] 的关键字迚行比较。 若 L.r[i]<d[1].key,则将 L.r[i] 揑入到 d[1] 之前的有序表中。反之, 揑入到 d[1] 之后的有序表中。
第9单元 排序
主讲:彭伟国 平顶山学院 计算机学院
主要内容
10.1 排序的基本概念 10.2 插入排序(直接插入、折半插入) 10.3 交换排序(冒泡排序、快速排 序10.)4 选择排序(直接选择排序、堆排 序10.)5 归并排序 10.6 基数排序 10.7 各种排序方法的比较和选择
10.1 排序的基本概念
j=j-1; } R[j+1]=tmp; }
25/20
希尔排序的时间复杂度约为O(n1.3)。
为什么希尔排序比直接插入排序好? 例如:有10个元素要排序。
希尔排序
直接插入排序
大约时间=102=100
注意:
d=5:分为5组,时间约为5×22=20
+
d=2:分为2组,时间约为2×52=50
+
d=1:分为1组,几乎有序,时间约为10
第1趟 (dk=5)
//插入点在右半区
}
for (j=i-1;j>=high+1;j--)
//元素后移
R[j+1]=R[j];
R[high+1]=tmp;
//插入
}
}
折半插入排序的元素移动次数与直接插入排序相同,不 同的仅是变分散移动为集合移动。在R[0..i-1]中查找插入R[i] 的位置,折半查找的平均关键字比较次数为log2(i+1)-1,平均 移动元素的次数为i/2+2,所以平均时间复杂度为:
基本思路
① d=n/2 ② 将排序序列分为d个组,在各组内进行直接插入排序 ③ 递减d=d/2,重复② ,直到d=1
算法最后一趟对所有数据进行了直接插入排序, 所以结果一定是正确的。
22/20
一趟希尔排序过程
数据结构第十章 排序
10.2 插入排序 插入排序
直接插入排序 折半插入排序 2-路插入排序 表插入排序 希尔排序
10.2.1 直接插入排序
基本操作:将一个记录插入到已排好序的有序表中, 从而得到一个新的、记录数增1的有序表。
例:有一组待排序的记录的关键字初始序列如下:
(49,38,65,97,76,13,27,49`)
(4)归并排序 (5)基数排序
按内排过程中所需的工作量分类:
(1)简单的排序方法,其时间复杂度为O(n×n)
(2)先进的排序方法,其时间复杂度为O(nlogn);
(3)基数排序,其时间复杂度为O(d(n+rd))
排序算法的两种基本操作:
(1)比较两个关键字的大小; (2)将记录从一个位置移至另一个位置;
算法实现的关键设计:
将d看成是一个循环数组,并设两个指针first和final分别指示排序过 程中得到的有序序列中的第一个记录和最后一个记录在d中的位置.
例:有一组待排序的记录的关键字初始排列如下:
(49,38,65,97,76,13,27,49`) 16
[初始关键字] 49 38 65 97 76 13 27 49`
18
10.2.3 希尔排序 从直接插入排序
待排序序列基本有序可提高效率 回顾 待排序序列的记录数n很小时可提高效率
希尔排序的基本思想:
先将整个待排记录序列分割成为若干子序列分别进行
直接插入排序,待整个序列中的记录“基本有序”时,再对 全
体记例录:有进一行组一待次排直序接的插记入录排的序关. 键字初始排列如下: (49,38,65,97,76,13,27,49`)
} 12
直接插入排序的性能分析: 10. 3
(1)空间:只需一个记录的辅助空间r[0].
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
数据结构实验
报告
实验题目:几种基本排序算法的实现
姓名:张耀
班级:计嵌151
学号: 17
一、实验目的
实现直接插入排序,冒泡排序,简单选择排序,快速排序,希尔排序,堆排序等6种常用内部排序算法,比较各算法的比较次数和移动次数。
二、数据结构设计
(1)设计待排序记录的存储结构。
(2)设计待排序数据的存储结构。
(3)输入:待排序数据的数据个数和数据可由键盘输入,也可由程
序生成伪随机数,以菜单方式选择上述排序方法中的一个,并指明输出第几趟排序的结果。
(4)输出:各趟排序结果或指定趟的排序结果,以及对应的关键字
比较次数和移动次数。
三、算法设计与N-S图
算法设计:
编写一个主函数main(),在主函数中设计一个简单的菜单,分别调用6种内部排序算法。
为了对各种排序算法的性能进行比较,算法中的主要工作是在已知算法的适当位置插入对关键字的比较次数和移动次数的计数操作。
为此,可设立一个实现排序算法中的关键字比较的函数;设立一个实现排序算法中的关键字移动的函数;设立一个实现排序算法中的关键字交换的函数,从而解决比较次数和移动次数的统计问题。
数据的输入也可以通过菜单选择输入方式:键盘输入或由伪随机数程
序生成数据,以便随时更换排序数据,并按照不同要求对排序数据进行排序,输出排序的结果以及对应的关键字比较次数和移动次数。
对于测试数据,算法中可以考虑几组数据的典型性,如正序,逆序和不同程度等,以取得直观的感受,从而对不同算法进行比较。
四、程序清单
#include<iostream>
using namespace std;
void showMenu()
{
cout << " * 菜单 * " << endl;
cout << " 1.直接插入排序 " << endl;
cout << " 2.冒泡排序 " << endl;
cout << " 3.简单选择排序 " << endl;
cout << " 4.快速排序 " << endl;
cout << " 5.希尔排序 " << endl;
cout << " 6.堆排序 " << endl;
cout << " 7.退出程序 " << endl;
}
struct SqList{
int * key;
int length;
};
void CreateSqList(SqList &sl).]调整为大顶堆
HeapAdjust(L, i, , compare_Time, move_Time);
for (i = ; i>1; --i)
{
value = [1];
[1] = [i];
[i] = value;
HeapAdjust(L, 1, i - 1, compare_Time, move_Time);.i-1]重新调整为大顶堆
k++;
cout << "第" << k << "趟排序结果:"; OutPut(L);
}
cout << "比较次数为:" << compare_Time << endl;
cout << "移动次数为:" << move_Time << endl;
}
int main()
{
int choice;
SqList sq,sp;
CreateSqList(sq);
Copy(sq, sp);
showMenu();
cout << "Please enter your choice: ";
cin >> choice;
while (choice != 0)
{
switch (choice)
{
case 1:
InsertSort(sq); cout << "最终结果:";
OutPut(sq); break;
case 2:
BubbleSort(sq); cout << "最终结果:";
OutPut(sq); break;
case 3:
SelectSort(sq); cout << "最终结果:";
OutPut(sq); break;
case 4:
QuitSort(sq); cout << "最终结果:";
OutPut(sq); break;
case 5:
int *p, n;
cout << "请输入增量个数:" << endl;
cin >> n;
p = new int[n];
cout << "请输入各个增量的值:" << endl;
for (int i = 0; i < n; i++)
{
cin >> p[i];
}
ShellSort(sq, p, n); cout << "最终结果:";
OutPut(sq); break;
case 6:
HeapSort(sq); cout << "最终结果:";
OutPut(sq); break;
case 7:
cout << "程序运行结束,退出程序。
" << endl;
return 0; break;
}
Copy(sp, sq);
showMenu();
cout << "Please enter your choice: ";
cin >> choice;
}
return 0;
}
五、运行与测试
六、实验分析及体会
通过这次试验主要让我们深入了解了各种排序的不同特点和排序原理,各种排序在时间复杂度和空间复杂度上均各有差异,对于不同的排序案例,我们可以根据他们各自的特点挑选最佳的排序方案。
今后在实际操作中会注意各个排序的特点正确的运用。
2017,加油!。