插入排序算法实验报告
实验七 插入和希尔排序实验

实验七插入排序实验一、实验目的1、掌握直接插入排序的算法2、掌握希尔排序的算法3、理解排序算法的两个主要步骤:“比较”和“移动”4、了解插入排序的应用二、实验内容1、直接插入排序算法验证1.1 数据结构的设计用数组作为待排序记录的存储结构:例如:#define Max 20int a[Max] = {05, 56, 13, 88,19, 37, 64,75,80, 21,92}1.2 基本思想:每步将一个待排序的对象,按其关键字大小,插入到前面已经有序的一组对象的适当位置上,直到剩余对象全部插入为止。
输入:待排序的记录:{05, 56, 13, 88,19, 37, 64,75,80, 21,92}(用数组存放)输出:直接插入排序后的序列:05, 13,19,21,37, 56,64, 75, 80, 88,921.3 实验步骤:源程序:1.4 运行结果:2、希尔排序算法验证2.1 数据结构的设计用数组作为待排序记录的存储结构:例如:#define Max 20int a[Max] = 37,56, 88,05,13, 9,21, 64, 75,80,92}2.2 基本思路先将整个待排记录序列分割成若干子序列(按照每一趟的增量d k),分别进行直接插入排序,待整个序列中的记录“基本有序”时,再对全体记录进行一次直接插入排序。
增量d k逐趟缩短(例如依次取d k =5,3,1)输入:待排序的记录序列{37,56, 88,05,13, 9,21, 64, 75,80,92}输出:希尔排序后的序列:05, 13,19,21,37, 56,64, 75, 80, 88,922.3 实验步骤:2.4 运行结果:三、问题讨论1、直接插入排序有哪些特点?有哪些应用?2、希尔排序的时间复杂度是多少?与直接插入排序相比有哪些优点?四、实验总结(1)直接插入排序:# include <stdio.h>#define Max 15main(){int a[Max],i,j,t;int length = Max-1;printf("请输入待排序的%d个记录:",length);for(i=0;i<length;i++)scanf("%d",&a[i]);for(i=1;i<length;i++) /*外循环控制趟数,n个数从第2个数开始到最后共进行n-1次插入*/ {t=a[i]; /*将待插入数暂存于变量t中*/for( j=i-1 ; j>=0 && t>a[j] ; j-- ) /*在有序序列(下标0 ~ i-1)中寻找插入位置*/a[j+1]=a[j]; /*若未找到插入位置,则当前元素后移一个位置*/a[j+1]=t; /*找到插入位置,完成插入*/}printf("直接插入排序后的序列:");for(i=0;i<length;i++)printf("%d ",a[i]);printf("\n");}(2)希尔排序# include <stdio.h>#define Max 16void shell_sort(int a[], int n){int h, j, k, t;for (h=n/2; h>0; h=h/2){for (j=h; j<n; j++){t = a[j];for (k=j-h; (k>=0 && t<a[k]); k-=h){// *(x+k+h) = *(x+k);a[k+h] = a[k];}//*(x+k+h) = t;a[k+h] = t;}}}main(){int a[Max],i;int length = Max-1;printf(" 这是一个希尔排序 \n");printf("请输入%d个待排序的记录序列:\n",length); for(i=0;i<length;i++)scanf("%d",&a[i]);shell_sort(a,length);printf("希尔排序后的序列:");for(i=0;i<length;i++)printf(" %d",a[i]);printf("\n");}(3)折半排序# include <stdio.h>#define Max 7void B_sort(int a[], int n){int low,high, i,j, t;int m;for(i=2;i<=n;++i){t = a[i];//临时存放low =1;high =i-1;while(low<=high){m=(low+high)/2;if(t<a[m])high =m-1;elselow =m+1;}for(j=i-1;j>=high+1;--j){a[j+1] = a[j];}a[high+1] = t;}}main(){int a[Max],i;int length = Max-1;printf(" 这是一个折半排序 \n");printf("请输入%d个待排序的记录序列:\n",length-1); for(i=1;i<length;i++)scanf("%d",&a[i]);B_sort(a,length);printf("折半排序后的序列:");for(i=2;i<=length;i++)printf(" %d",a[i]);printf("\n");}。
数据结构与算法实验报告2:插入排序及归并排序(递增策略)

数据结构与算法实验报告2:插入排序及归并排序(递增策略)1. 实验介绍本实验旨在探索插入排序和归并排序这两种排序算法的实现过程和性能表现。
插入排序是一种简单的排序算法,它通过不断将元素插入已排序的序列中来完成排序。
归并排序是一种分治法排序算法,它将待排序的序列拆分成小的子序列,然后逐步合并这些子序列来完成排序。
2. 插入排序插入排序的思想是将数组分为已排序和未排序两部分,最初已排序部分只包含一个元素,然后逐个将未排序部分的元素插入到已排序部分的适当位置,以此达到排序的目的。
插入排序使用两个循环来实现,外循环遍历未排序部分的元素,内循环将元素插入已排序部分的合适位置。
3. 归并排序归并排序是一种分治法排序算法,它将待排序的序列拆分成小的子序列,然后逐步合并这些子序列来完成排序。
归并排序使用递归的方式将序列拆分成单个元素,然后不断合并这些单个元素来创建有序的序列。
4. 实验结果通过实验测试,插入排序和归并排序的性能如下所示:- 插入排序:- 时间复杂度:平均情况下为 O(n^2),最好情况下为 O(n),最坏情况下为 O(n^2)- 空间复杂度:O(1)- 稳定性:稳定排序- 归并排序:- 时间复杂度:平均情况下为 O(nlogn),最好情况下为O(nlogn),最坏情况下为 O(nlogn)- 空间复杂度:O(n)- 稳定性:稳定排序5. 结论插入排序和归并排序都是常见的排序算法,它们各有优势和适用场景。
插入排序适用于小规模的数据集,且对部分已排序的情况有更好的性能。
归并排序适用于大规模的数据集,其时间复杂度始终稳定,且不受输入数据的影响。
根据实际需求选择合适的算法可以提高代码的效率和性能。
排序实验报告_排序综合实验报告材料

班级
2*10^7
10 电信 1 班
10^8
操作系统
10^5
Microsoft Windows 7 旗舰版 (64 位/Service Pck 1)
正序
xxxxxxxxxxxxx
逆序
编译软件
直接插入
Visul C++ 6.0
(带监视哨〕
emil
C
609803959.
24.874
10^4
100.158
2*10^4
中选出键值最小的记录,与无序区第一个记录 R 交换;新的无序区为 R 到
各种排序试验结果:
R[n],从中再选出键值最小的记录,与无序区第一个记录 R 交换;类似, CPU
第 i 趟排序时 R 到 R[i-1]是有序区,无序区为 R[i]到 R[n],从中选出键
(英特尔)Intel(R) Core(TM) i5 CPU M 480 2.67GHz
〔1〕二路并归排序:开始时,将排序表 R 到 R[n]看成 n 个长度为 1
录,顺序放在已排好序的子序列的后面〔或最前〕,直到全部记录排序完 的有序子表,把这些子表两两并归,便得到 n/2 个有序的子表〔当 n 为奇
毕。
数时,并归后仍是有一个长度为 1 的子表〕;然后,再把这 n/2 个有序的
〔1〕直接选择排序:首先,全部记录组成初始无序区 R 到 R[n],从 子表两两并归,如此反复,直到最终得到一个程度为 n 的有序表为止。
指导老师: 胡圣荣
序与排序要求相反时就交换两者的位置,直到没有反序的记录为止。
日期: 20XX.12.15~20XX.1.5
〔1〕冒泡排序:设想排序表 R 到 R[n]垂直放置,将每个记录 R[i]看
排序的实验报告

排序的实验报告排序的实验报告引言:排序是计算机科学中常见的问题之一。
在实际应用中,我们经常需要对一组数据进行排序,以便更好地理解和分析数据。
本实验旨在比较不同排序算法的效率和性能,以及探讨它们在不同数据集上的表现。
实验设计:为了进行排序算法的比较,我们选择了五种常见的排序算法,分别是冒泡排序、选择排序、插入排序、快速排序和归并排序。
我们使用Python编程语言实现了这些算法,并在同一台计算机上运行它们以确保公平比较。
实验步骤:1. 数据集的准备我们选择了三种不同规模的数据集:小规模(100个元素)、中规模(1000个元素)和大规模(10000个元素)。
这些数据集包含了随机生成的整数。
2. 算法实现我们按照上述算法的描述,使用Python编程语言实现了这些排序算法。
为了确保准确性和效率,我们在实现过程中进行了多次测试和调试。
3. 实验运行我们分别对小规模、中规模和大规模的数据集运行这些排序算法,并记录下每个算法的运行时间。
实验结果:1. 小规模数据集排序结果对于小规模的数据集,所有的排序算法都能够在很短的时间内完成排序。
然而,快速排序和归并排序的运行时间明显短于冒泡排序、选择排序和插入排序。
2. 中规模数据集排序结果随着数据规模的增加,冒泡排序、选择排序和插入排序的运行时间显著增加,而快速排序和归并排序的运行时间仍然较短。
特别是在中规模数据集上,快速排序和归并排序的效率明显高于其他算法。
3. 大规模数据集排序结果在大规模数据集上,冒泡排序、选择排序和插入排序的运行时间急剧增加,而快速排序和归并排序的运行时间仍然保持在可接受的范围内。
这进一步证明了快速排序和归并排序的高效性。
讨论:通过对不同规模数据集的排序实验,我们可以得出以下结论:1. 快速排序和归并排序是最有效的排序算法,它们的运行时间相对较短。
2. 冒泡排序、选择排序和插入排序在小规模数据集上表现良好,但在大规模数据集上效率较低。
3. 对于特定的应用场景,选择合适的排序算法非常重要。
数据结构与算法实验报告_内排序

数据结构与算法实验报告实验名称:二分插入排序及其性能姓名:学号:专业:指导教师:日期:2012-5-22一、实验目的了解二分插入排序与直接插入排序的关系;掌握二分插入排序算法的实现;掌握算法运行时间的测量。
二、实验内容实现二分插入排序算法,并将它和直接插入排序算法进行性能比较,然后用理论分析支持你的结论。
三、实验环境Window XP操作系统;Microsoft VisualC++编程环境;Pentium(R) Dual-Core cpu;2.50GHz,2.00GB内存四、实现1.类间的关系提示:总排序类、插入排序类、直接插入排序类、二分插入排序类间的关系答:父类是:总排序类子类是:插入排序类和二分插入排序类父类是:插入排序类子类是:直接插入排序类2.二分插入排序类排序函数sort的实现结果:3.性能测试程序的主要代码//二分法插入排序,Array[]为待排序数组,n为数组长度template <class Record,class Compare>void BinaryInsertSorter<Record,Compare>::Sort(Record Array[], int n) {Record TempRecord; //用来保存当前待插入纪录的临时变量int left,right,middle; //记录已排好序序列的左、右、中位置for (int i=1;i<n;i++) //插入第i个记录{TempRecord = Array[i]; //将当前待插入记录保存在临时变量中left = 0; right = i-1; //记录已排好序序列的左右位置while(left <= right) //开始查找待插入记录的正确位置{middle = (left+right)/2; //记录中间位置//如果待插入记录比中间记录小,就在左一半中查找,否则,在右一半中查找if (Compare::lt(TempRecord, Array[middle]))right = middle-1;else left = middle+1;}//将前面所有大于当前待插入记录的记录后移for(int j = i-1; j >= left; j --)Array[j+1] = Array[j];Array[left] = TempRecord; //将待插入记录回填到正确位置}}五、实验数据及结论1.实验数据及分析实验过程的描述。
排序算法实验报告

数据结构实验报告八种排序算法实验报告一、实验内容编写关于八种排序算法的C语言程序,要求包含直接插入排序、希尔排序、简单项选择择排序、堆排序、冒泡排序、快速排序、归并排序和基数排序。
二、实验步骤各种内部排序算法的比较:1.八种排序算法的复杂度分析〔时间与空间〕。
2.八种排序算法的C语言编程实现。
3.八种排序算法的比较,包括比较次数、移动次数。
三、稳定性,时间复杂度和空间复杂度分析比较时间复杂度函数的情况:时间复杂度函数O(n)的增长情况所以对n较大的排序记录。
一般的选择都是时间复杂度为O(nlog2n)的排序方法。
时间复杂度来说:(1)平方阶(O(n2))排序各类简单排序:直接插入、直接选择和冒泡排序;(2)线性对数阶(O(nlog2n))排序快速排序、堆排序和归并排序;(3)O(n1+§))排序,§是介于0和1之间的常数。
希尔排序(4)线性阶(O(n))排序基数排序,此外还有桶、箱排序。
说明:当原表有序或基本有序时,直接插入排序和冒泡排序将大大减少比较次数和移动记录的次数,时间复杂度可降至O〔n〕;而快速排序则相反,当原表基本有序时,将蜕化为冒泡排序,时间复杂度提高为O〔n2〕;原表是否有序,对简单项选择择排序、堆排序、归并排序和基数排序的时间复杂度影响不大。
稳定性:排序算法的稳定性:假设待排序的序列中,存在多个具有相同关键字的记录,经过排序,这些记录的相对次序保持不变,则称该算法是稳定的;假设经排序后,记录的相对次序发生了改变,则称该算法是不稳定的。
稳定性的好处:排序算法如果是稳定的,那么从一个键上排序,然后再从另一个键上排序,第一个键排序的结果可以为第二个键排序所用。
基数排序就是这样,先按低位排序,逐次按高位排序,低位相同的元素其顺序再高位也相同时是不会改变的。
另外,如果排序算法稳定,可以防止多余的比较;稳定的排序算法:冒泡排序、插入排序、归并排序和基数排序不是稳定的排序算法:选择排序、快速排序、希尔排序、堆排序四、设计细节排序有内部排序和外部排序,内部排序是数据记录在内存中进行排序,而外部排序是因排序的数据很大,一次不能容纳全部的排序记录,在排序过程中需要访问外存。
排序实验报告

实验五排序实验目的: 掌握几种排序的思想及算法问题分析:(一)直接插入排序1. 排序思想将待排序的记录Ri,插入到已排好序的记录表R1, R2 ,…., Ri-1中,得到一个新的、记录数增加1的有序表。
直到所有的记录都插入完为止。
设待排序的记录顺序存放在数组R[1…n]中,在排序的某一时刻,将记录序列分成两部分:◆R[1…i-1]:已排好序的有序部分;◆R[i…n]:未排好序的无序部分。
显然,在刚开始排序时,R[1]是已经排好序的。
2 . 算法实现void straight_insert_sort(Sqlist R){ int i, j ;for (i=2; i<=n; i++){ R[0]=R[i]; j=i-1; /*设置哨兵*/while( LT(R[0].key, R[j].key) ){ R[j+1]=R[j];j--;} /* 查找插入位置*/R[j+1]=R[0]; /* 插入到相应位置*/}}(二)希尔排序1. 排序思想①先取一个正整数d1(d1<n)作为第一个增量,将全部n个记录分成d1组,把所有相隔d1的记录放在一组中,即对于每个k(k=1, 2, … d1),R[k], R[d1+k], R[2d1+k] , …分在同一组中,在各组内进行直接插入排序。
这样一次分组和排序过程称为一趟希尔排序;②取新的增量d2<d1,重复①的分组和排序操作;直至所取的增量di=1为止,即所有记录放进一个组中排序为止。
2. 算法实现先给出一趟希尔排序的算法,类似直接插入排序。
void shell_pass(Sqlist R, int d)/* 对顺序表L进行一趟希尔排序, 增量为d */{ int j, k ;for (j=d+1; j<=n; j++){ R[0]=R[j] ; /* 设置监视哨兵*/k=j-d ;while (k>0&<(R[0].key, R[k].key) ){ R[k+d]=R[k] ; k=k-d ; }R[k+d]=R[0] ;}}然后在根据增量数组dk进行希尔排序。
北邮数据结构实验报告-排序

北邮数据结构实验报告-排序北邮数据结构实验报告-排序一、实验目的本实验旨在掌握常见的排序算法,包括冒泡排序、插入排序、选择排序、快速排序、归并排序等,并通过实际编程实现对数字序列的排序。
二、实验内容1.冒泡排序冒泡排序是一种简单的排序算法,其基本思想是依次比较相邻的两个元素,并按照从小到大或从大到小的顺序交换。
具体步骤如下:- 从待排序序列的第一个元素开始,依次比较相邻的两个元素;- 如果前面的元素大于后面的元素,则交换这两个元素的位置;- 重复上述步骤,直到整个序列有序。
2.插入排序插入排序是一种简单且直观的排序算法,其基本思想是将待排序序列分为已排序和未排序两部分,每次从未排序部分中选择一个元素插入到已排序部分的合适位置。
具体步骤如下:- 从待排序序列中选择一个元素作为已排序部分的第一个元素;- 依次将未排序部分的元素插入到已排序部分的合适位置,使得已排序部分保持有序;- 重复上述步骤,直到整个序列有序。
3.选择排序选择排序是一种简单且直观的排序算法,其基本思想是每次选择未排序部分中的最小(或最大)元素,并将其放在已排序部分的末尾。
具体步骤如下:- 在未排序部分中选择最小(或最大)的元素;- 将选择的最小(或最大)元素与未排序部分的第一个元素交换位置;- 重复上述步骤,直到整个序列有序。
4.快速排序快速排序是一种高效的排序算法,其基本思想是通过一趟排序将待排序序列分割成两部分,其中一部分的元素都比另一部分的元素小。
具体步骤如下:- 选择一个枢轴元素(一般选择第一个元素);- 将待排序序列中小于枢轴元素的元素放在枢轴元素的左侧,大于枢轴元素的元素放在枢轴元素的右侧;- 对枢轴元素左右两侧的子序列分别进行递归快速排序;- 重复上述步骤,直到整个序列有序。
5.归并排序归并排序是一种高效的排序算法,其基本思想是将待排序序列划分成足够小的子序列,然后对这些子序列进行两两合并,最终形成有序的序列。
具体步骤如下:- 将待排序序列递归地划分成足够小的子序列;- 对每个子序列进行归并排序;- 合并相邻的子序列,直到整个序列有序。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
算法设计与分析基础
实验报告
应用数学学院
二零一六年六月
实验一插入排序算法
一、实验性质设计
二、实验学时14学时
三、实验目的
1、掌握插入排序的方法和原理。
2、掌握java语言实现该算法的一般流程。
四、实验内容
1、数组的输入。
2、输入、输出的异常处理。
3、插入排序的算法流程。
4、运行结果的输出。
五、实验报告
Ⅰ、算法原理
从左到右扫描有序的子数组,直到遇到一个大于(或小于)等于A[n-1]的元素,然后就把A[n-1]插在该元素的前面(或后面)。
插入排序基于递归思想。
Ⅱ、书中源代码
算法InsertionSort(A[0..n-1])
//用插入排序对给定数组A[0..n-1]排序
//输入:n个可排序元素构成的一个数组A[0..n-1]
//输出:非降序排列的数组A[0..n-1]
for i ←1 to n-1 do
v ← A[i]
j ← i-1
while j ≥ 0 and A[j] > v do
A[j+1] ← A[j]
j ← j-1
A[j+1] ← v
Ⅲ、Java算法代码:
import java.util.*;
public class Charu {
public static void main(String[] args) {
int n = 5;
int a[] = new int[n];
int s = a.length;
int i = 0, j = 0, v = 0;
System.out.println("请输入若干个数字:");
Scanner sc = new Scanner(System.in);
try {
while (i < s) {
a[i] = sc.nextInt();
i++;
}
for (i = 1; i <s; i++) {
v = a[i];
j = i - 1;
while (j >= 0 && a[j] > v) {
a[j + 1] = a[j];
j--;
}
a[j + 1] = v;
}
System.out.println("插入排序结果显示:");
for (i = 0; i < s; i++) {
System.out.println(a[i]);
}
} catch (Exception es) {
System.out.println(es);
}
}
}
Ⅳ、运行结果显示:
图(1) 图(2)
Ⅴ、实验结论:
插入排序的基本操作是键值比较A[j]>v 。
键值比较次数显然依
赖于特定的输入,在最坏的情况下,插入排序与选择排序的键值比较次数是完全一致的。
在最好的情况下,在外部循环的每次迭代中,比较次数只执行一次。
插入排序的平均性能比最差性能快两倍,以及遇到基本有序的数组时表现出优异的性能,使得插入排序领先与选择排序和冒泡排序。