排序算法实验报告材料
数据排列实验报告
一、实验目的1. 了解数据排列的基本概念和方法。
2. 掌握常用数据排列算法的原理和实现。
3. 通过实验验证不同排列算法的性能和适用场景。
二、实验原理数据排列是指将一组无序的数据按照一定的顺序进行排序的过程。
常见的排列算法有冒泡排序、选择排序、插入排序、快速排序、归并排序等。
本实验主要研究以下几种排序算法：1. 冒泡排序：通过比较相邻元素，将较大的元素交换到后面，直到整个序列有序。
2. 选择排序：在未排序序列中找到最小（大）元素，存放到排序序列的起始位置，然后，再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。
3. 插入排序：将一个记录插入到已经排好序的有序表中，从而得到一个新的、记录数增加1的有序表。
4. 快速排序：通过一趟排序将待排序的记录分割成独立的两部分，其中一部分记录的关键字均比另一部分的关键字小，再分别对这两部分记录继续进行排序。
5. 归并排序：将两个或两个以上的有序表合并成一个新的有序表。
三、实验内容1. 编写数据生成函数，生成一定数量的随机数作为待排序数据。
2. 分别实现冒泡排序、选择排序、插入排序、快速排序和归并排序算法。
3. 对每种排序算法进行性能测试，包括排序时间、空间复杂度等。
4. 分析不同排序算法的适用场景和优缺点。
四、实验步骤1. 导入必要的库文件，如random、time等。
2. 编写数据生成函数，生成一定数量的随机数。
3. 编写冒泡排序算法，实现数据排序功能。
4. 编写选择排序算法，实现数据排序功能。
5. 编写插入排序算法，实现数据排序功能。
6. 编写快速排序算法，实现数据排序功能。
7. 编写归并排序算法，实现数据排序功能。
8. 对每种排序算法进行性能测试，记录排序时间和空间复杂度。
9. 分析不同排序算法的适用场景和优缺点。
五、实验结果与分析1. 数据生成函数：生成10000个随机数，范围在0到9999之间。
2. 冒泡排序：- 排序时间：约0.02秒- 空间复杂度：O(1)- 适用场景：数据量较小，几乎可以忽略排序时间。
排序算法实验报告材料
实验课程：算法分析与设计实验名称：几种排序算法的平均性能比较（验证型实验）实验目标：（1）几种排序算法在平均情况下哪一个更快。
（2）加深对时间复杂度概念的理解。
实验任务：（1）实现几种排序算法（selectionsort, insertionsort,bottomupsort,quicksort, 堆排序）。
对于快速分类，SPLIT中的划分元素采用三者A(low)，A(high)，A((low+high)/2)中其值居中者。
（2）随机产生20组数据（比如n=5000i，1≤i≤20）。
数据均属于范围（0，105）内的整数。
对于同一组数据，运行以上几种排序算法，并记录各自的运行时间（以毫秒为单位）。
（3）根据实验数据及其结果来比较这几种分类算法的平均时间和比较次数，并得出结论。
实验设备及环境：PC；C/C++等编程语言。
实验主要步骤：(1)明确实验目标和具体任务；(2)理解实验所涉及的几个分类算法；(3)编写程序实现上述分类算法；(4)设计实验数据并运行程序、记录运行的结果；(5)根据实验数据及其结果得出结论；(6)实验后的心得体会。
一:问题分析（包括问题描述、建模、算法的基本思想及程序实现的技巧等）：1:随机生成n个0到100000的随机数用来排序的算法如下.for(int n=1000;n<20000;n+=1000){int a[]=new int[n];for(int i=0;i<n;i++){a[i]=(int) (Math.random()*100000);}2.计算时间的类Date通过它的对象d1的getTime()得到当前时间,再得到排序完成时的时间,相减得到排序所花的时间.Date d1=new Date();T=d2.getTime()-d1.getTime()3:排序算法:其它count均表示排序中比较的次数.插入排序主要算法如下int count=0;int c[]=new int[b.length];c[0]=b[0];int j;for(int i=1;i<c.length;i++){for(j=i-1;j>=0&&b[i]<c[j];j--){ count++;c[j+1]=c[j];}count++;c[j+1]=b[i];}选择排序主要算法:int count=0;for(int i=0;i<b.length;i++){ int k=i;for(int j=i+1;j<b.length;j++){count++;if (b[j]<b[k]) k=j;}if(k!=i){int l;l=b[i];b[i]=b[k];b[k]=l;}}合并排序:static int merge(int a[],int st,int ce,int fi){int count=0;//a表示数组,st表示要排序的数据的起点,ce表示第一部分的终点也是第二部分的起点,fi表示第二部份的终点int i=st;int j=ce;int cp=0; //由于数组c从0开始,而a是从st开始,并不一定是0.故要通过cp来表示c的第cp个值.int c[]=new int[fi-st];for(;i<ce;i++){for(;j<fi;j++){if(a[i]>a[j]) {count++;c[cp]=a[j];cp++;}else break;}c[cp]=a[i];cp++;}//若j的值还小于fi则继续把j到fi的值复制给c.此处也与书上的不同,主要由自己的理解来实现for(;j<fi;j++){c[cp]=a[j];cp++;}//把得到的值复制到a数组上for(int k=0;k<c.length;k++){a[st]=c[k];st++;}return count;}快速排序:用的方法与书上略有不同,主要通过spilt直接进行递归. static int spilt(int a[],int low,int high){int count=0;int i=low;int x=a[low];for(int j=low+1;j<=high;j++){if(a[j]<=x){count++;i=i+1;if(i!=j){int temp=a[i];a[i]=a[j];a[j]=temp;}}}int temp= a[low];a[low]=a[i];a[i]=temp;int w=i;if(low<high){if(w-1>low)count=count+spilt(a,low,w-1); //此处的if语句可以减少很多不必要的排序,例如只剩下一个数字时就不必再用spilt来排序了.if(w+1<high)count=count+spilt(a,w+1,high);}return count;}二:实验数据及其结果（可用图表形式给出）：排序个插入排序选择排序合并排序快速排序堆排序数比较次数时间比较次数时间比较次数时间比较次数时间比较次数时间1000 246415 3毫秒499500 2毫秒4292 1毫秒6042 0毫秒5336 1毫秒2000 987905 4毫秒1999000 5毫秒13895 0毫秒12502 1毫秒17251 1毫秒3000 2221253 7毫秒4498500 9毫秒28911 1毫秒18072 1毫秒35738 1毫秒4000 3974807 12毫秒7998000 16毫秒50087 1毫秒27763 0毫秒61389 1毫秒5000 6330740 17毫秒12497500 24毫秒76719 2毫秒31673 0毫秒94119 0毫秒6000 9000822 26毫秒17997000 33毫秒109515 1毫秒38876 1毫秒134365 1毫秒7000 12361649 34毫秒24496500 44毫秒148792 1毫秒52786 1毫秒182049 1毫秒8000 16195701 46毫秒31996000 59毫秒195261 2毫秒54716 0毫秒237456 1毫秒9000 20312730 58毫秒40495500 75毫秒247395 2毫秒78117 1毫秒300444 1毫秒10000 24720510 70毫秒49995000 91毫秒305728 1毫秒80273 1毫秒370843 1毫秒11000 29937848 84毫秒60494500 113毫秒370517 4毫秒89960 1毫秒448841 1毫秒12000 36256786 104毫秒71994000 133毫秒442232 2毫秒107707 1毫秒535030 2毫秒13000 42587471 120毫秒84493500 155毫秒520492 2毫秒102860 1毫秒629174 1毫秒14000 49063373 139毫秒97993000 177毫秒605806 2毫秒125364 1毫秒731191 1毫秒15000 56280216 161毫秒112492500 201毫秒698546 3毫秒134152 2毫秒841492 3毫秒16000 64205137 185毫秒127992000 228毫秒799410 2毫秒135362 1毫秒960400 1毫秒17000 72750562 206毫秒144491500 258毫秒906838 3毫秒144717 1毫秒1087013 2毫秒18000 80846587 231毫秒161991000 288毫秒1020136 3毫秒164631 2毫秒1221699 2毫秒19000 90537142 264毫秒180490500 321毫秒1139757 5毫秒168298 2毫秒1364230 2毫秒三:实验结果分析及结论：实验结果表明,选择排序用时普遍比其它算法大,自顶向上合并排序时间普遍较少,尤其是当数据量变得很大的时候,选择排序的速度变得远远不及自顶向上合并排序算法,大出好几百倍.另外,插入排序在当数据量变大时花费的时间也变得很长.快速排序和堆排序处于不确定的情况,不稳定性比较明显.但是是一种比较快的算法.四:实验自我评价及心得体会：通过本实验,我发现以前经常使用的冒泡排序,选择排序等排序方法在遇到大量的数据的时候显示出来的严重的不足,而自底向上合并排序却显示出了其优越性,尽管合并排序的算法比较难,但它在时间上节省让人发现一切都是值得的.另外,我发现书上的伪代码只能供参考,并不能直接按着它的完全翻译成C++或java代码,而且用到数组的时候,伪代码的1表示第一个数据,而数组中的第一个数据是a[0].所以直接翻译会出现排序的错误.五:主要参考文献：<<算法设计技巧与分析>>。
排序实验报告_排序综合实验报告材料
班级
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]看
算法课设实验报告(3篇)
第1篇一、实验背景与目的随着计算机技术的飞速发展，算法在计算机科学中扮演着至关重要的角色。
为了加深对算法设计与分析的理解，提高实际应用能力，本实验课程设计旨在通过实际操作，让学生掌握算法设计与分析的基本方法，学会运用所学知识解决实际问题。
二、实验内容与步骤本次实验共分为三个部分，分别为排序算法、贪心算法和动态规划算法的设计与实现。
1. 排序算法（1）实验目的：熟悉常见的排序算法，理解其原理，比较其优缺点，并实现至少三种排序算法。
（2）实验内容：- 实现冒泡排序、快速排序和归并排序三种算法。
- 对每种算法进行时间复杂度和空间复杂度的分析。
- 编写测试程序，对算法进行性能测试，比较不同算法的优劣。
（3）实验步骤：- 分析冒泡排序、快速排序和归并排序的原理。
- 编写三种排序算法的代码。
- 分析代码的时间复杂度和空间复杂度。
- 编写测试程序，生成随机测试数据，测试三种算法的性能。
- 比较三种算法的运行时间和内存占用。
2. 贪心算法（1）实验目的：理解贪心算法的基本思想，掌握贪心算法的解题步骤，并实现一个贪心算法问题。
（2）实验内容：- 实现一个贪心算法问题，如活动选择问题。
- 分析贪心算法的正确性，并证明其最优性。
（3）实验步骤：- 分析活动选择问题的贪心策略。
- 编写贪心算法的代码。
- 分析贪心算法的正确性，并证明其最优性。
- 编写测试程序，验证贪心算法的正确性。
3. 动态规划算法（1）实验目的：理解动态规划算法的基本思想，掌握动态规划算法的解题步骤，并实现一个动态规划算法问题。
（2）实验内容：- 实现一个动态规划算法问题，如背包问题。
- 分析动态规划算法的正确性，并证明其最优性。
（3）实验步骤：- 分析背包问题的动态规划策略。
- 编写动态规划算法的代码。
- 分析动态规划算法的正确性，并证明其最优性。
- 编写测试程序，验证动态规划算法的正确性。
三、实验结果与分析1. 排序算法实验结果：- 冒泡排序：时间复杂度O(n^2)，空间复杂度O(1)。
数据结构实验报告-排序
数据结构实验报告-排序一、实验目的本实验旨在探究不同的排序算法在处理大数据量时的效率和性能表现，并对比它们的优缺点。
二、实验内容本次实验共选择了三种常见的排序算法：冒泡排序、快速排序和归并排序。
三个算法将在同一组随机生成的数据集上进行排序，并记录其性能指标，包括排序时间和所占用的内存空间。
三、实验步骤1. 数据的生成在实验开始前，首先生成一组随机数据作为排序的输入。
定义一个具有大数据量的数组，并随机生成一组在指定范围内的整数，用于后续排序算法的比较。
2. 冒泡排序冒泡排序是一种简单直观的排序算法。
其基本思想是从待排序的数据序列中逐个比较相邻元素的大小，并依次交换，从而将最大（或最小）的元素冒泡到序列的末尾。
重复该过程直到所有数据排序完成。
3. 快速排序快速排序是一种分治策略的排序算法，效率较高。
它将待排序的序列划分成两个子序列，其中一个子序列的所有元素都小于等于另一个子序列的所有元素。
然后对两个子序列分别递归地进行快速排序。
4. 归并排序归并排序是一种稳定的排序算法，使用分治策略将序列拆分成较小的子序列，然后递归地对子序列进行排序，最后再将子序列合并成有序的输出序列。
归并排序相对于其他算法的优势在于其稳定性和对大数据量的高效处理。
四、实验结果经过多次实验，我们得到了以下结果：1. 冒泡排序在数据量较小时，冒泡排序表现良好，但随着数据规模的增大，其性能明显下降。
排序时间随数据量的增长呈平方级别增加。
2. 快速排序相比冒泡排序，快速排序在大数据量下的表现更佳。
它的排序时间线性增长，且具有较低的内存占用。
3. 归并排序归并排序在各种数据规模下都有较好的表现。
它的排序时间与数据量呈对数级别增长，且对内存的使用相对较高。
五、实验分析根据实验结果，我们可以得出以下结论：1. 冒泡排序适用于数据较小的排序任务，但面对大数据量时表现较差，不推荐用于处理大规模数据。
2. 快速排序是一种高效的排序算法，适用于各种数据规模。
算法冒泡排序实验报告(3篇)
第1篇一、实验目的本次实验旨在通过实现冒泡排序算法，加深对排序算法原理的理解，掌握冒泡排序的基本操作，并分析其性能特点。
二、实验内容1. 冒泡排序原理冒泡排序是一种简单的排序算法，它重复地遍历要排序的数列，一次比较两个元素，如果它们的顺序错误就把它们交换过来。
遍历数列的工作是重复地进行，直到没有再需要交换，也就是说该数列已经排序完成。
2. 实验步骤（1）设计一个冒泡排序函数，输入为待排序的数组，输出为排序后的数组。
（2）编写一个主函数，用于测试冒泡排序函数的正确性和性能。
（3）通过不同的数据规模和初始顺序，分析冒泡排序的性能特点。
3. 实验环境（1）编程语言：C语言（2）开发环境：Visual Studio Code（3）测试数据：随机生成的数组、有序数组、逆序数组三、实验过程1. 冒泡排序函数设计```cvoid bubbleSort(int arr[], int n) {int i, j, temp;for (i = 0; i < n - 1; i++) {for (j = 0; j < n - i - 1; j++) {if (arr[j] > arr[j + 1]) {temp = arr[j];arr[j] = arr[j + 1];arr[j + 1] = temp;}}}}```2. 主函数设计```cinclude <stdio.h>include <stdlib.h>include <time.h>int main() {int n;printf("请输入数组长度：");scanf("%d", &n);int arr = (int )malloc(n sizeof(int)); if (arr == NULL) {printf("内存分配失败\n");return 1;}// 生成随机数组srand((unsigned)time(NULL));for (int i = 0; i < n; i++) {arr[i] = rand() % 100;}// 冒泡排序bubbleSort(arr, n);// 打印排序结果printf("排序结果：\n");for (int i = 0; i < n; i++) {printf("%d ", arr[i]);}printf("\n");// 释放内存free(arr);return 0;}```3. 性能分析（1）对于随机生成的数组，冒泡排序的平均性能较好，时间复杂度为O(n^2)。
排序基本算法实验报告
一、实验目的1. 掌握排序算法的基本原理和实现方法。
2. 熟悉常用排序算法的时间复杂度和空间复杂度。
3. 能够根据实际问题选择合适的排序算法。
4. 提高编程能力和问题解决能力。
二、实验内容1. 实现并比较以下排序算法：冒泡排序、插入排序、选择排序、快速排序、归并排序、堆排序。
2. 对不同数据规模和不同数据分布的序列进行排序，分析排序算法的性能。
3. 使用C++编程语言实现排序算法。
三、实验步骤1. 冒泡排序：将相邻元素进行比较，如果顺序错误则交换，直到序列有序。
2. 插入排序：将未排序的元素插入到已排序的序列中，直到序列有序。
3. 选择排序：每次从剩余未排序的元素中选取最小（或最大）的元素，放到已排序序列的末尾。
4. 快速排序：选择一个枢纽元素，将序列分为两部分，一部分比枢纽小，另一部分比枢纽大，递归地对两部分进行排序。
5. 归并排序：将序列分为两半，分别对两半进行排序，然后将两半合并为一个有序序列。
6. 堆排序：将序列构建成一个最大堆，然后依次取出堆顶元素，最后序列有序。
四、实验结果与分析1. 冒泡排序、插入排序和选择排序的时间复杂度均为O(n^2)，空间复杂度为O(1)。
这些算法适用于小规模数据或基本有序的数据。
2. 快速排序的时间复杂度平均为O(nlogn)，最坏情况下为O(n^2)，空间复杂度为O(logn)。
快速排序适用于大规模数据。
3. 归并排序的时间复杂度和空间复杂度均为O(nlogn)，适用于大规模数据。
4. 堆排序的时间复杂度和空间复杂度均为O(nlogn)，适用于大规模数据。
五、实验结论1. 根据不同数据规模和不同数据分布，选择合适的排序算法。
2. 冒泡排序、插入排序和选择排序适用于小规模数据或基本有序的数据。
3. 快速排序、归并排序和堆排序适用于大规模数据。
4. 通过实验，加深了对排序算法的理解，提高了编程能力和问题解决能力。
六、实验总结本次实验通过对排序算法的学习和实现，掌握了常用排序算法的基本原理和实现方法，分析了各种排序算法的性能，提高了编程能力和问题解决能力。
排序的实验报告
排序的实验报告排序的实验报告引言：排序是计算机科学中非常重要的一个概念，它涉及到对一组数据按照一定规则进行重新排列的操作。
在计算机算法中，排序算法的效率直接影响到程序的运行速度和资源利用率。
为了深入了解各种排序算法的原理和性能，我们进行了一系列的排序实验。
实验一：冒泡排序冒泡排序是最简单的排序算法之一。
它的原理是通过相邻元素的比较和交换来实现排序。
我们编写了一个冒泡排序的算法，并使用Python语言进行实现。
实验中，我们分别对10、100、1000个随机生成的整数进行排序，并记录了排序所需的时间。
实验结果显示，随着数据规模的增加，冒泡排序的时间复杂度呈现出明显的增长趋势。
当数据规模为10时，排序所需的时间约为0.001秒；而当数据规模增加到1000时，排序所需的时间则增加到了1.5秒左右。
这说明冒泡排序的效率较低，对大规模数据的排序并不适用。
实验二：快速排序快速排序是一种常用的排序算法，它的核心思想是通过分治的策略将数据分成较小的子集，然后递归地对子集进行排序。
我们同样使用Python语言实现了快速排序算法，并对相同规模的数据进行了排序实验。
实验结果显示，快速排序的时间复杂度相对较低。
当数据规模为10时，排序所需的时间约为0.0005秒；而当数据规模增加到1000时，排序所需的时间仅为0.02秒左右。
这说明快速排序适用于大规模数据的排序，其效率较高。
实验三：归并排序归并排序是一种稳定的排序算法，它的原理是将待排序的数据分成若干个子序列，然后将子序列两两合并，直到最终得到有序的结果。
我们同样使用Python 语言实现了归并排序算法，并进行了相同规模数据的排序实验。
实验结果显示，归并排序的时间复杂度相对较低。
当数据规模为10时，排序所需的时间约为0.0008秒；而当数据规模增加到1000时，排序所需的时间仅为0.03秒左右。
这说明归并排序同样适用于大规模数据的排序，其效率较高。
讨论与结论：通过以上实验，我们可以得出以下结论：1. 冒泡排序虽然简单易懂，但对于大规模数据的排序效率较低，不适用于实际应用。
排序查找实验报告
一、实验目的1. 理解排序算法的基本原理和特点。
2. 掌握几种常用的排序算法，如冒泡排序、选择排序、插入排序等。
3. 学习查找算法的基本原理和特点。
4. 掌握几种常用的查找算法，如顺序查找、二分查找等。
5. 通过实验，提高对排序和查找算法的运用能力。
二、实验环境1. 操作系统：Windows 102. 编程语言：Python3.83. 开发工具：PyCharm三、实验内容1. 实现冒泡排序、选择排序、插入排序等排序算法。
2. 实现顺序查找、二分查找等查找算法。
3. 对一组数据进行排序和查找操作，并记录实验数据。
四、实验步骤1. 设计排序算法（1）冒泡排序冒泡排序的基本思想是：通过相邻元素的比较和交换，将较大的元素逐步移动到数组的末尾，从而实现排序。
（2）选择排序选择排序的基本思想是：每次从待排序的数组中找到最小（或最大）的元素，将其放到序列的起始位置，直到全部排序完成。
（3）插入排序插入排序的基本思想是：将一个记录插入到已经排好序的有序表中，从而得到一个新的、记录数增加1的有序表。
2. 设计查找算法（1）顺序查找顺序查找的基本思想是：从数组的第一个元素开始，依次将元素与要查找的值进行比较，直到找到目标元素或遍历完整个数组。
（2）二分查找二分查找的基本思想是：将数组分成两部分，每次比较查找值与中间元素的值，根据比较结果确定查找值的所在区间，直到找到目标元素或区间为空。
3. 编写实验代码```pythondef bubble_sort(arr):n = len(arr)for i in range(n):for j in range(0, n-i-1):if arr[j] > arr[j+1]:arr[j], arr[j+1] = arr[j+1], arr[j]def selection_sort(arr):n = len(arr)for i in range(n):min_idx = ifor j in range(i+1, n):if arr[min_idx] > arr[j]:min_idx = jarr[i], arr[min_idx] = arr[min_idx], arr[i] def insertion_sort(arr):for i in range(1, len(arr)):key = arr[i]j = i-1while j >= 0 and key < arr[j]:arr[j+1] = arr[j]j -= 1arr[j+1] = keydef sequential_search(arr, target):for i in range(len(arr)):if arr[i] == target:return ireturn -1def binary_search(arr, target):low = 0high = len(arr) - 1while low <= high:mid = (low + high) // 2if arr[mid] == target:return midelif arr[mid] < target:low = mid + 1else:high = mid - 1return -1# 测试数据arr = [64, 34, 25, 12, 22, 11, 90]# 排序bubble_sort(arr)print("冒泡排序结果：", arr)selection_sort(arr.copy())print("选择排序结果：", arr)insertion_sort(arr.copy())print("插入排序结果：", arr)# 查找target = 22print("顺序查找结果：", sequential_search(arr, target)) target = 90print("二分查找结果：", binary_search(arr, target))```4. 实验结果与分析通过实验，我们得到了以下结果：（1）冒泡排序结果：[11, 12, 22, 25, 34, 64, 90]（2）选择排序结果：[11, 12, 22, 25, 34, 64, 90]（3）插入排序结果：[11, 12, 22, 25, 34, 64, 90]（4）顺序查找结果：2（5）二分查找结果：6从实验结果可以看出，冒泡排序、选择排序和插入排序都能够对数据进行正确的排序。
排序算法实训报告
一、实验目的通过本次实训，掌握常用的排序算法，包括直接插入排序、冒泡排序、选择排序、希尔排序等，并了解其基本原理、实现方法以及优缺点。
通过实际编程，加深对排序算法的理解，提高编程能力。
二、实验环境1. 开发工具：Visual Studio 20222. 编程语言：C++3. 操作系统：Windows 10三、实验内容本次实训主要涉及以下排序算法：1. 直接插入排序2. 冒泡排序3. 选择排序4. 希尔排序四、实验过程1. 直接插入排序（1）原理：将无序序列中的元素逐个插入到已有序序列的合适位置，直到整个序列有序。
（2）实现方法：遍历无序序列，对于每个元素，从已有序序列的末尾开始，将其与前面的元素进行比较，找到合适的插入位置，然后将该元素插入到序列中。
（3）代码实现：```cppvoid insertionSort(int arr[], int n) {int i, j, key;for (i = 1; i < n; i++) {key = arr[i];j = i - 1;while (j >= 0 && arr[j] > key) {arr[j + 1] = arr[j];j = j - 1;}arr[j + 1] = key;}}```2. 冒泡排序（1）原理：通过相邻元素的比较和交换，将序列中的元素按从小到大（或从大到小）的顺序排列。
（2）实现方法：遍历序列，比较相邻元素，如果顺序错误，则交换它们的位置。
重复此过程，直到整个序列有序。
（3）代码实现：```cppvoid bubbleSort(int arr[], int n) {int i, j, temp;for (i = 0; i < n - 1; i++) {for (j = 0; j < n - i - 1; j++) {if (arr[j] > arr[j + 1]) {temp = arr[j];arr[j] = arr[j + 1];arr[j + 1] = temp;}}}}```3. 选择排序（1）原理：每次从无序序列中选出最小（或最大）的元素，放到已有序序列的末尾。
关于算法的实验报告(3篇)
第1篇一、实验目的1. 理解快速排序算法的基本原理和实现方法。
2. 掌握快速排序算法的时间复杂度和空间复杂度分析。
3. 通过实验验证快速排序算法的效率。
4. 提高编程能力和算法设计能力。
二、实验环境1. 操作系统：Windows 102. 编程语言：C++3. 开发工具：Visual Studio 2019三、实验原理快速排序算法是一种分而治之的排序算法，其基本思想是：选取一个基准元素，将待排序序列分为两个子序列，其中一个子序列的所有元素均小于基准元素，另一个子序列的所有元素均大于基准元素，然后递归地对这两个子序列进行快速排序。
快速排序算法的时间复杂度主要取决于基准元素的选取和划分过程。
在平均情况下，快速排序的时间复杂度为O(nlogn)，但在最坏情况下，时间复杂度会退化到O(n^2)。
四、实验内容1. 快速排序算法的代码实现2. 快速排序算法的时间复杂度分析3. 快速排序算法的效率验证五、实验步骤1. 设计快速排序算法的C++代码实现，包括以下功能：- 选取基准元素- 划分序列- 递归排序2. 编写主函数，用于生成随机数组和测试快速排序算法。
3. 分析快速排序算法的时间复杂度。
4. 对不同规模的数据集进行测试，验证快速排序算法的效率。
六、实验结果与分析1. 快速排序算法的代码实现```cppinclude <iostream>include <vector>include <cstdlib>include <ctime>using namespace std;// 生成随机数组void generateRandomArray(vector<int>& arr, int n) {srand((unsigned)time(0));for (int i = 0; i < n; ++i) {arr.push_back(rand() % 1000);}}// 快速排序void quickSort(vector<int>& arr, int left, int right) { if (left >= right) {return;}int i = left;int j = right;int pivot = arr[(left + right) / 2]; // 选取中间元素作为基准 while (i <= j) {while (arr[i] < pivot) {i++;}while (arr[j] > pivot) {j--;}if (i <= j) {swap(arr[i], arr[j]);i++;j--;}}quickSort(arr, left, j);quickSort(arr, i, right);}int main() {int n = 10000; // 测试数据规模vector<int> arr;generateRandomArray(arr, n);clock_t start = clock();quickSort(arr, 0, n - 1);clock_t end = clock();cout << "排序用时：" << double(end - start) / CLOCKS_PER_SEC << "秒" << endl;return 0;}```2. 快速排序算法的时间复杂度分析根据实验结果，快速排序算法在平均情况下的时间复杂度为O(nlogn)，在最坏情况下的时间复杂度为O(n^2)。
排序算法实验报告
数据结构实验报告八种排序算法实验报告一、实验内容编写关于八种排序算法的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、直接插入排序算法思想直接插入排序的基本思想是将一个记录插入到已排好序的序列中，从而得到一个新的，记录数增1 的有序序列。
直接插入排序算法的伪代码称为InsertionSort，它的参数是一个数组A[1..n]，包含了n个待排序的数。
用伪代码表示直接插入排序算法如下：InsertionSort (A)for i←2 to ndo key←A[i] //key 表示待插入数//Insert A[i] into the sorted sequence A[1..i-1]j←i-1while j>0 and A[j]>keydo A[j+1]←A[j]j←j-1A[j+1]←key2、快速排序算法思想快速排序算法的基本思想是，通过一趟排序将待排序序列分割成独立的两部分，其中一部分记录的关键字均比另一部分记录的关键字小，则可对这两部分记录继续进行排序，以达到整个序列有序。
假设待排序序列为数组A[1..n]，首先选取第一个数A[0]，作为枢轴（pivot），然后按照下述原则重新排列其余数：将所有比A[0]大的数都排在它的位置之前，将所有比A[0]小的数都排在它的位置之后，由此以A[0]最后所在的位置i 作为分界线，将数组A[1..n]分成两个子数组A[1..i-1]和A[i+1..n]。
这个过程称作一趟快速排序。
通过递归调用快速排序，对子数组A[1..i-1]和A[i+1..n]排序。
一趟快速排序算法的伪代码称为Partition,它的参数是一个数组A[1..n]和两个指针low、high,设枢轴为pivotkey，则首先从high 所指位置起向前搜索，找到第一个小于pivotkey 的数，并将其移到低端，然后从low 所指位置起向后搜索，找到第一个大于pivotkey 的数，并将其移到高端，重复这两步直至low=high。
最后，将枢轴移到正确的位置上。
查找排序算法实验报告(3篇)
第1篇一、实验目的1. 熟悉常见的查找和排序算法。
2. 分析不同查找和排序算法的时间复杂度和空间复杂度。
3. 比较不同算法在处理大数据量时的性能差异。
二、实验环境1. 操作系统：Windows 102. 编程语言：Python3.73. 开发工具：PyCharm三、实验内容1. 实现以下查找和排序算法：（1）查找算法：顺序查找、二分查找（2）排序算法：冒泡排序、选择排序、插入排序、快速排序、归并排序2. 分析算法的时间复杂度和空间复杂度。
3. 对不同算法进行性能测试，比较其处理大数据量时的性能差异。
四、实验步骤1. 实现查找和排序算法。
2. 分析算法的时间复杂度和空间复杂度。
3. 创建测试数据，包括小数据量和大数据量。
4. 对每种算法进行测试，记录运行时间。
5. 分析测试结果，比较不同算法的性能。
五、实验结果与分析1. 算法实现（1）顺序查找def sequential_search(arr, target): for i in range(len(arr)):if arr[i] == target:return ireturn -1（2）二分查找def binary_search(arr, target):low, high = 0, len(arr) - 1while low <= high:mid = (low + high) // 2if arr[mid] == target:return midelif arr[mid] < target:low = mid + 1else:high = mid - 1return -1（3）冒泡排序def bubble_sort(arr):n = len(arr)for i in range(n):for j in range(0, n-i-1):if arr[j] > arr[j+1]:arr[j], arr[j+1] = arr[j+1], arr[j]（4）选择排序def selection_sort(arr):n = len(arr)for i in range(n):min_idx = ifor j in range(i+1, n):if arr[min_idx] > arr[j]:min_idx = jarr[i], arr[min_idx] = arr[min_idx], arr[i]（5）插入排序def insertion_sort(arr):for i in range(1, len(arr)):key = arr[i]j = i-1while j >=0 and key < arr[j]:arr[j+1] = arr[j]j -= 1arr[j+1] = key（6）快速排序def quick_sort(arr):if len(arr) <= 1:pivot = arr[len(arr) // 2]left = [x for x in arr if x < pivot]middle = [x for x in arr if x == pivot]right = [x for x in arr if x > pivot]return quick_sort(left) + middle + quick_sort(right)（7）归并排序def merge_sort(arr):if len(arr) <= 1:return arrmid = len(arr) // 2left = merge_sort(arr[:mid])right = merge_sort(arr[mid:])return merge(left, right)def merge(left, right):result = []i = j = 0while i < len(left) and j < len(right):if left[i] < right[j]:result.append(left[i])i += 1else:result.append(right[j])result.extend(left[i:])result.extend(right[j:])return result2. 算法时间复杂度和空间复杂度分析（1）顺序查找：时间复杂度为O(n)，空间复杂度为O(1)。
实验四 排序 实验报告材料
数据结构实验报告实验名称：实验四排序学生：班级：班序号：学号：日期：2012年12月21日1、实验要求题目2使用链表实现下面各种排序算法，并进行比较。
排序算法：1、插入排序2、冒泡排序3、快速排序4、简单选择排序5、其他要求：1、测试数据分成三类：正序、逆序、随机数据。
2、对于这三类数据，比较上述排序算法中关键字的比较次数和移动次数（其中关键字交换计为3次移动）。
3、对于这三类数据，比较上述排序算法中不同算法的执行时间，精确到微秒（选作）。
4、对2和3的结果进行分析，验证上述各种算法的时间复杂度。
编写测试main()函数测试线性表的正确性。
2、程序分析2.1存储结构说明：本程序排序序列的存储由链表来完成。
其存储结构如下图所示。
(1)单链表存储结构：（2）结点结构struct Node {int data;Node * next; };示意图：2.2关键算法分析一：关键算法(一)直接插入排序void LinkSort::InsertSort()直接插入排序是插入排序中最简单的排序方法，其基本思想是：依次将待排序序列中的每一个记录插入到一个已排好的序列中，直到全部记录都排好序。
（1）算法自然语言1.将整个待排序的记录序列划分成有序区和无序区，初始时有序区为待排序记录序列中的第一个记录，无序区包括所有剩余待排序的记录；2.将无须去的第一个记录插入到有序区的合适位置中，从而使无序区减少一个记录，有序区增加一个记录；3.重复执行2，直到无序区中没有记录为止。
（2）源代码void LinkSort::InsertSort() //从第二个元素开始，寻找前面那个比它大的{Node * P = front->next; //要插入的节点的前while(P->next){Node * S = front; //用来比较的节点的前驱while(1){CompareCount++;if( P->next->data < S->next->data ) // P的后继比S的后继小则插入{insert(P, S);break;}S = S->next;if(S==P) //若一趟比较结束，且不需要插入{P = P->next;break; }}}}(3)时间和空间复杂度最好情况下，待排序序列为正序，时间复杂度为O（n）。
排序_上机实验报告
一、实验目的1. 理解不同排序算法的原理和特点。
2. 掌握排序算法的编程实现。
3. 比较不同排序算法的效率，分析其适用场景。
二、实验环境1. 操作系统：Windows 102. 编程语言：Python3.83. 开发环境：PyCharm三、实验内容本次实验主要实现了以下排序算法：1. 冒泡排序2. 选择排序3. 插入排序4. 快速排序5. 归并排序四、实验步骤1. 冒泡排序冒泡排序是一种简单的排序算法，其基本思想是通过比较相邻元素的值，如果它们的顺序错误就把它们交换过来。
重复这个过程，直到没有需要交换的元素为止。
```pythondef bubble_sort(arr):n = len(arr)for i in range(n):for j in range(0, n-i-1):if arr[j] > arr[j+1]:arr[j], arr[j+1] = arr[j+1], arr[j]```2. 选择排序选择排序的基本思想是：首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置，然后，再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。
以此类推，直到所有元素均排序完毕。
```pythondef selection_sort(arr):n = len(arr)for i in range(n):min_idx = ifor j in range(i+1, n):if arr[min_idx] > arr[j]:min_idx = jarr[i], arr[min_idx] = arr[min_idx], arr[i]```3. 插入排序插入排序的基本思想是将一个记录插入到已经排好序的有序表中，从而得到一个新的、记录数增加1的有序表。
```pythondef insertion_sort(arr):for i in range(1, len(arr)):key = arr[i]j = i-1while j >=0 and key < arr[j]:arr[j+1] = arr[j]j -= 1arr[j+1] = key```4. 快速排序快速排序是一种分而治之的排序算法。
排序实验报告
排序实验报告一、实验目的本次排序实验的主要目的是探究和比较不同排序算法在处理不同规模数据时的性能表现，包括时间复杂度和空间复杂度，并深入理解排序算法的工作原理和特点。
二、实验环境本次实验使用的编程语言为Python，运行环境为Jupyter Notebook。
实验中所用到的主要库包括｀time` 用于计算算法的运行时间，｀random` 用于生成随机测试数据。
三、实验原理（一）冒泡排序冒泡排序（Bubble Sort）是一种简单的排序算法。
它重复地走访要排序的数列，一次比较两个数据元素，如果顺序不对则进行交换，并一直重复这样的走访操作，直到没有要交换的数据元素为止。
（二）插入排序插入排序（Insertion Sort）是一种简单直观的排序算法。
它的工作原理是通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入，直到未排序数据为空。
（三）选择排序选择排序（Selection Sort）首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置，然后，再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。
以此类推，直到所有元素均排序完毕。
（四）快速排序快速排序（Quick Sort）是对冒泡排序的一种改进。
它采用分治的思想，通过一趟排序将待排记录分隔成独立的两部分，其中一部分记录的关键字均比另一部分关键字小，然后分别对这两部分记录继续进行排序，以达到整个序列有序。
四、实验步骤（一）生成测试数据为了全面测试排序算法的性能，我们生成了不同规模的随机整数数组作为测试数据。
分别生成了包含 100、500、1000、5000 和 10000 个元素的数组。
（二）实现排序算法使用 Python 实现了上述四种排序算法，确保每个算法的功能正确。
（三）测试算法性能对于每种规模的测试数据，分别使用四种排序算法进行排序，并记录每种算法的运行时间。
五、实验结果与分析（一）时间复杂度分析1、冒泡排序：在最坏情况下，时间复杂度为＄O(n^2)＄，当数据规模较小时，其性能尚可，但随着数据规模的增大，运行时间显著增加。
算法排序上机实验报告
一、实验目的1. 理解并掌握常见的排序算法原理。
2. 通过上机实验，加深对排序算法的理解和运用。
3. 比较不同排序算法的效率，分析其适用场景。
二、实验环境1. 操作系统：Windows 102. 编程语言：Python3.83. 开发环境：PyCharm三、实验内容本次实验主要涉及以下排序算法：1. 冒泡排序2. 选择排序3. 插入排序4. 快速排序5. 归并排序四、实验步骤1. 冒泡排序```pythondef bubble_sort(arr):n = len(arr)for i in range(n):for j in range(0, n-i-1):if arr[j] > arr[j+1]:arr[j], arr[j+1] = arr[j+1], arr[j] return arr```2. 选择排序```pythondef selection_sort(arr):n = len(arr)for i in range(n):min_idx = ifor j in range(i+1, n):if arr[min_idx] > arr[j]:min_idx = jarr[i], arr[min_idx] = arr[min_idx], arr[i] return arr```3. 插入排序```pythondef insertion_sort(arr):for i in range(1, len(arr)):key = arr[i]j = i-1while j >= 0 and key < arr[j]:arr[j+1] = arr[j]j -= 1arr[j+1] = keyreturn arr```4. 快速排序```pythondef partition(arr, low, high):pivot = arr[high]i = low - 1for j in range(low, high):if arr[j] < pivot:i += 1arr[i], arr[j] = arr[j], arr[i] arr[i+1], arr[high] = arr[high], arr[i+1] return i+1def quick_sort(arr, low, high):if low < high:pi = partition(arr, low, high)quick_sort(arr, low, pi-1)quick_sort(arr, pi+1, high)return arr```5. 归并排序```pythondef merge_sort(arr):if len(arr) > 1:mid = len(arr) // 2L = arr[:mid]R = arr[mid:]merge_sort(L)merge_sort(R)i = j = k = 0while i < len(L) and j < len(R): if L[i] < R[j]:arr[k] = L[i]i += 1else:arr[k] = R[j]j += 1k += 1while i < len(L):arr[k] = L[i]i += 1k += 1while j < len(R):arr[k] = R[j]j += 1k += 1return arr```五、实验结果与分析1. 数据准备```pythonimport randomarr = [random.randint(0, 100) for _ in range(10)]print("原始数组：", arr)```2. 排序算法测试```pythonprint("冒泡排序：", bubble_sort(arr.copy()))print("选择排序：", selection_sort(arr.copy()))print("插入排序：", insertion_sort(arr.copy()))print("快速排序：", quick_sort(arr.copy(), 0, len(arr)-1))print("归并排序：", merge_sort(arr.copy()))```3. 效率比较通过对不同排序算法进行多次测试，我们可以得出以下结论：- 冒泡排序和选择排序的平均时间复杂度为O(n^2)，适用于小规模数据排序。
数字排序实验报告
一、实验目的1. 理解数字排序的基本原理和常用算法。
2. 掌握冒泡排序、选择排序、插入排序等常见排序算法的实现方法。
3. 分析不同排序算法的效率，了解它们在不同数据规模下的表现。
4. 通过实验加深对排序算法的理解，提高编程能力。
二、实验环境1. 操作系统：Windows 102. 编程语言：Python3.83. 开发工具：PyCharm三、实验内容本实验主要研究了以下几种排序算法：1. 冒泡排序2. 选择排序3. 插入排序4. 快速排序5. 归并排序四、实验步骤1. 冒泡排序：- 定义一个函数，实现冒泡排序算法。
- 输入一组待排序的数字，调用该函数进行排序。
- 输出排序后的结果。
2. 选择排序：- 定义一个函数，实现选择排序算法。
- 输入一组待排序的数字，调用该函数进行排序。
- 输出排序后的结果。
3. 插入排序：- 定义一个函数，实现插入排序算法。
- 输入一组待排序的数字，调用该函数进行排序。
- 输出排序后的结果。
4. 快速排序：- 定义一个函数，实现快速排序算法。
- 输入一组待排序的数字，调用该函数进行排序。
- 输出排序后的结果。
5. 归并排序：- 定义一个函数，实现归并排序算法。
- 输入一组待排序的数字，调用该函数进行排序。
- 输出排序后的结果。
五、实验结果与分析1. 冒泡排序：- 实验结果：对于较小的数据集，冒泡排序效率较高；但对于较大的数据集，效率较低。
- 分析：冒泡排序的时间复杂度为O(n^2)，当数据规模较大时，效率较低。
2. 选择排序：- 实验结果：对于较小的数据集，选择排序效率较高；但对于较大的数据集，效率较低。
- 分析：选择排序的时间复杂度为O(n^2)，当数据规模较大时，效率较低。
3. 插入排序：- 实验结果：对于较小的数据集，插入排序效率较高；但对于较大的数据集，效率较低。
- 分析：插入排序的时间复杂度为O(n^2)，当数据规模较大时，效率较低。
4. 快速排序：- 实验结果：快速排序在各种数据规模下都表现出较高的效率。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
实验课程：算法分析与设计
实验名称：几种排序算法的平均性能比较（验证型实验）
实验目标：
（1）几种排序算法在平均情况下哪一个更快。
（2）加深对时间复杂度概念的理解。
实验任务：
（1）实现几种排序算法（selectionsort, insertionsort,bottomupsort,quicksort, 堆排序）。
对于快速分类，SPLIT中的划分元素采用三者A(low)，A(high)，A((low+high)/2)中其值居中者。
（2）随机产生20组数据（比如n=5000i，1≤i≤20）。
数据均属于范围（0，105）内的整数。
对于同一组数据，运行以上几种排序算法，并记录各自的运行时间（以毫秒为单位）。
（3）根据实验数据及其结果来比较这几种分类算法的平均时间和比较次数，并得出结论。
实验设备及环境：
PC；C/C++等编程语言。
实验主要步骤：
(1)明确实验目标和具体任务；
(2)理解实验所涉及的几个分类算法；
(3)编写程序实现上述分类算法；
(4)设计实验数据并运行程序、记录运行的结果；
(5)根据实验数据及其结果得出结论；
(6)实验后的心得体会。
一:问题分析（包括问题描述、建模、算法的基本思想及程序实现的技巧等）：1:随机生成n个0到100000的随机数用来排序的算法如下.
for(int n=1000;n<20000;n+=1000)
{
int a[]=new int[n];
for(int i=0;i<n;i++){
a[i]=(int) (Math.random()*100000);
}
2.计算时间的类Date通过它的对象d1的getTime()得到当前时间,再得到排序完成时的时间,相减得到排序所花的时间.
Date d1=new Date();
T=d2.getTime()-d1.getTime()
3:排序算法:其它count均表示排序中比较的次数.
插入排序主要算法如下
int count=0;
int c[]=new int[b.length];
c[0]=b[0];int j;
for(int i=1;i<c.length;i++)
{
for(j=i-1;j>=0&&b[i]<c[j];j--)
{ count++;
c[j+1]=c[j];
}
count++;
c[j+1]=b[i];
}
选择排序主要算法:
int count=0;
for(int i=0;i<b.length;i++)
{ int k=i;
for(int j=i+1;j<b.length;j++)
{count++;if (b[j]<b[k]) k=j;}
if(k!=i)
{int l;l=b[i];b[i]=b[k];b[k]=l;}
}
合并排序:
static int merge(int a[],int st,int ce,int fi)
{int count=0;
//a表示数组,st表示要排序的数据的起点,ce表示第一部分的终点也是第二部分的起点,fi表示第二部份的终点
int i=st;
int j=ce;
int cp=0; //由于数组c从0开始,而a是从st开始,并不一定是0.故要通过cp来表示c的第cp个值.
int c[]=new int[fi-st];
for(;i<ce;i++){
for(;j<fi;j++){
if(a[i]>a[j]) {
count++;
c[cp]=a[j];
cp++;
}
else break;
}
c[cp]=a[i];
cp++;
}
//若j的值还小于fi则继续把j到fi的值复制给c.此处也与书上的不同,主要由自己的理解来实现
for(;j<fi;j++)
{
c[cp]=a[j];
cp++;
}
//把得到的值复制到a数组上
for(int k=0;k<c.length;k++)
{
a[st]=c[k];
st++;
}
return count;
}
快速排序:用的方法与书上略有不同,主要通过spilt直接进行递归. static int spilt(int a[],int low,int high){
int count=0;
int i=low;
int x=a[low];
for(int j=low+1;j<=high;j++){
if(a[j]<=x){
count++;
i=i+1;
if(i!=j){
int temp=a[i];
a[i]=a[j];
a[j]=temp;
}
}
}
int temp= a[low];
a[low]=a[i];
a[i]=temp;
int w=i;
if(low<high){
if(w-1>low)count=count+spilt(a,low,w-1); //此处的if语句可以减少很多不必要的排序,例如只剩下一个数字时就不必再用spilt来排序了.
if(w+1<high)count=count+spilt(a,w+1,high);
}
return count;
}
二:实验数据及其结果（可用图表形式给出）：
排序个
插入排序选择排序合并排序快速排序堆排序
数
比较次数时间比较次数时间比较次数时间比较次数时间比较次数时间1000 246415 3毫秒499500 2毫秒4292 1毫秒6042 0毫秒5336 1毫秒2000 987905 4毫秒1999000 5毫秒13895 0毫秒12502 1毫秒17251 1毫秒3000 2221253 7毫秒4498500 9毫秒28911 1毫秒18072 1毫秒35738 1毫秒4000 3974807 12毫秒7998000 16毫秒50087 1毫秒27763 0毫秒61389 1毫秒5000 6330740 17毫秒12497500 24毫秒76719 2毫秒31673 0毫秒94119 0毫秒6000 9000822 26毫秒17997000 33毫秒109515 1毫秒38876 1毫秒134365 1毫秒7000 12361649 34毫秒24496500 44毫秒148792 1毫秒52786 1毫秒182049 1毫秒8000 16195701 46毫秒31996000 59毫秒195261 2毫秒54716 0毫秒237456 1毫秒9000 20312730 58毫秒40495500 75毫秒247395 2毫秒78117 1毫秒300444 1毫秒10000 24720510 70毫秒49995000 91毫秒305728 1毫秒80273 1毫秒370843 1毫秒11000 29937848 84毫秒60494500 113毫秒370517 4毫秒89960 1毫秒448841 1毫秒12000 36256786 104毫秒71994000 133毫秒442232 2毫秒107707 1毫秒535030 2毫秒13000 42587471 120毫秒84493500 155毫秒520492 2毫秒102860 1毫秒629174 1毫秒14000 49063373 139毫秒97993000 177毫秒605806 2毫秒125364 1毫秒731191 1毫秒15000 56280216 161毫秒112492500 201毫秒698546 3毫秒134152 2毫秒841492 3毫秒16000 64205137 185毫秒127992000 228毫秒799410 2毫秒135362 1毫秒960400 1毫秒17000 72750562 206毫秒144491500 258毫秒906838 3毫秒144717 1毫秒1087013 2毫秒18000 80846587 231毫秒161991000 288毫秒1020136 3毫秒164631 2毫秒1221699 2毫秒19000 90537142 264毫秒180490500 321毫秒1139757 5毫秒168298 2毫秒1364230 2毫秒
三:实验结果分析及结论：
实验结果表明,选择排序用时普遍比其它算法大,自顶向上合并排序时间普遍较少,尤其是当数据量变得很大的时候,选择排序的速度变得远远不及自顶向上合并排序算法,大出好几百倍.另外,插入排序在当数据量变大时花费的时间也变得很长.快速排序和堆排序处于不确定的情况,不稳定性比较明显.但是是一种比较快的算法.
四:实验自我评价及心得体会：
通过本实验,我发现以前经常使用的冒泡排序,选择排序等排序方法在遇到大量的数据的时候显示出来的严重的不足,而自底向上合并排序却显示出了其优越性,尽管合并排序的算法比较难,但它在时间上节省让人发现一切都是值得的.
另外,我发现书上的伪代码只能供参考,并不能直接按着它的完全翻译成C++或java代码,而且用到数组的时候,伪代码的1表示第一个数据,而数组中的第一个数据是a[0].所以直接翻译会出现排序的错误.
五:主要参考文献：
<<算法设计技巧与分析>>。