算法排序问题实验报告
算法实验报告结果分析
一、实验背景随着计算机科学技术的不断发展，算法作为计算机科学的核心内容之一，其重要性日益凸显。
为了验证和评估不同算法的性能，我们进行了一系列算法实验，通过对比分析实验结果，以期为后续算法研究和优化提供参考。
二、实验方法本次实验选取了三种常见的算法：快速排序、归并排序和插入排序，分别对随机生成的数据集进行排序操作。
实验数据集的大小分为10000、20000、30000、40000和50000五个级别，以验证算法在不同数据量下的性能表现。
实验过程中，我们使用Python编程语言实现三种算法，并记录每种算法的运行时间。
同时，为了确保实验结果的准确性，我们对每种算法进行了多次运行，并取平均值作为最终结果。
三、实验结果1. 快速排序快速排序是一种高效的排序算法，其平均时间复杂度为O(nlogn)。
从实验结果来看，快速排序在所有数据量级别下均表现出较好的性能。
在数据量较小的10000和20000级别，快速排序的运行时间分别为0.05秒和0.1秒；而在数据量较大的40000和50000级别，运行时间分别为0.8秒和1.2秒。
总体来看，快速排序在各个数据量级别下的运行时间均保持在较低水平。
2. 归并排序归并排序是一种稳定的排序算法，其时间复杂度也为O(nlogn)。
实验结果显示，归并排序在数据量较小的10000和20000级别下的运行时间分别为0.15秒和0.25秒，而在数据量较大的40000和50000级别，运行时间分别为1.5秒和2.5秒。
与快速排序相比，归并排序在数据量较小的情况下性能稍逊一筹，但在数据量较大时，其运行时间仍然保持在较低水平。
3. 插入排序插入排序是一种简单易实现的排序算法，但其时间复杂度为O(n^2)。
实验结果显示，插入排序在数据量较小的10000和20000级别下的运行时间分别为0.3秒和0.6秒，而在数据量较大的40000和50000级别，运行时间分别为8秒和15秒。
可以看出，随着数据量的增加，插入排序的性能明显下降。
算法实验报告
算法实验报告算法实验报告引言：算法是计算机科学的核心内容之一，它是解决问题的方法和步骤的描述。
算法的设计和分析是计算机科学与工程中的重要研究方向之一。
本实验旨在通过对算法的实际应用和实验验证，深入理解算法的性能和效果。
实验一：排序算法的比较在本实验中，我们将比较三种常见的排序算法：冒泡排序、插入排序和快速排序。
我们将通过对不同规模的随机数组进行排序，并记录每种算法所需的时间和比较次数，以评估它们的性能。
实验结果显示，快速排序是最快的排序算法，其时间复杂度为O(nlogn)，比较次数也相对较少。
插入排序的时间复杂度为O(n^2)，比较次数较多，但对于小规模的数组排序效果较好。
而冒泡排序的时间复杂度也为O(n^2)，但比较次数更多，效率相对较低。
实验二：图的最短路径算法在图的最短路径问题中，我们将比较Dijkstra算法和Floyd-Warshall算法的效率和准确性。
我们将使用一个带权有向图，并计算从一个顶点到其他所有顶点的最短路径。
实验结果表明，Dijkstra算法适用于单源最短路径问题，其时间复杂度为O(V^2)，其中V为顶点数。
而Floyd-Warshall算法适用于多源最短路径问题，其时间复杂度为O(V^3)。
两种算法在准确性上没有明显差异，但在处理大规模图时，Floyd-Warshall算法的效率较低。
实验三：动态规划算法动态规划是一种通过将问题分解成子问题并记录子问题的解来解决复杂问题的方法。
在本实验中，我们将比较两种动态规划算法：0-1背包问题和最长公共子序列问题。
实验结果显示，0-1背包问题的动态规划算法可以有效地找到最优解，其时间复杂度为O(nW)，其中n为物品个数，W为背包容量。
最长公共子序列问题的动态规划算法可以找到两个序列的最长公共子序列，其时间复杂度为O(mn)，其中m和n分别为两个序列的长度。
结论：通过本次实验，我们对不同算法的性能和效果有了更深入的了解。
排序算法中，快速排序是最快且效率最高的；在图的最短路径问题中，Dijkstra算法和Floyd-Warshall算法分别适用于不同的场景；动态规划算法可以解决复杂的问题，并找到最优解。
实验报告模板
合肥学院数学与物理系实验报告课程名称：算法分析实验项目：排序问题----堆排序实验类别：综合型学生姓名：学号：专业：实验时间：指导教师：邵桂伟实验成绩：一、实验目的：（此处用四号宋体，段落间距单倍行距。
段前段后0行）1.熟悉并使用VISUAL C++6.0编译软件；2.熟悉掌握堆这种数据结构的定义及各种操作，进而实现排序操作；3.掌握算法的空间复杂性和时间复杂性的概念，设计算法并分析算法的复杂性。
二、实验要求：1.使用VISUAL C++6.0编译软件；2.编辑并运行程序，得到递增序列；3.从算法的空间复杂性和时间复杂性分析该算法的复杂性。
三、实验内容：程序实现堆排序。
四、源程序及结果：（此处用四号宋体，段落间距单倍行距。
段前段后0行）1.源程序（小四，罗马字体）#include<stdio.h> #include<malloc.h> typedef struct node {int data;struct node *next; }linklist;linklist *creat() {int x,i,n;linklist *h,*p,*s,*q;h=(linklist*)malloc(sizeof(linklist));p=h;printf("\n请输入链表元素个数\n");scanf("%d",&n);printf("\n请输入链表元素\n");scanf("%d", &x);q=(linklist*)malloc(sizeof(linklist));q->data=x;h->next=q;p=q;for(i=1;i<n;i++){scanf("%d", &x);s=(linklist*)malloc(sizeof(linklist));s->data = x;if(x>=p->data){p->next = s;s->next=NULL;p=s;}else{q=h;while(q->next!=NULL&&x>=q->n ext->data)q=q->next;s->next=q->next;q->next=s;}}return h;}lout(linklist *p){while(p->next!=NULL){printf("%d->",p->data);p=p->next;}printf("%d\n",p->data);}void main(){int k;linklist *l,*p,*q;l=(linklist*)malloc(sizeof(linklist));l=creat();p=l->next;printf("未操作前链表元素为\n");lout(p);printf("请输入要插入的元素\n");scanf("%d", &k);q=(linklist*)malloc(sizeof(linklist));q->data=k;p=l;while(p->next!=NULL&&k>= p->next->data)p=p->next;q->next=p->next;p->next=q;printf("操作后链表元素为\n");p=l->next;lout(p);}2.运行结果(可以使用截图)3.程序复杂性分析（从时间和空间角度）学生签名：。
排序实验报告_排序综合实验报告材料
班级
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. 快速排序是一种高效的排序算法，适用于各种数据规模。
算法分析与设计实验报告合并排序快速排序
算法分析与设计实验报告：合并排序与快速排序一、引言算法是计算机科学中非常重要的一部分，它涉及到解决问题的方法和步骤。
合并排序和快速排序是两种经典而常用的排序算法。
本文将对这两种排序算法进行分析和设计实验，通过对比它们的性能和效率，以期得出最优算法。
二、合并排序合并排序是一种分治算法，它将原始数组不断分解为更小的数组，直到最后细分为单个元素。
然后，再将这些单个元素两两合并，形成一个有序数组。
合并排序的核心操作是合并两个有序的数组。
1. 算法步骤（1）将原始数组分解为更小的子数组，直到每个子数组只有一个元素；（2）两两合并相邻的子数组，同时进行排序，生成新的有序数组；（3）重复步骤（2），直到生成最终的有序数组。
2. 算法性能合并排序的最优时间复杂度为O(nlogn)，其中n为待排序数组的长度。
无论最好情况还是最坏情况，合并排序的复杂度都相同。
合并排序需要额外的存储空间来存储临时数组，所以空间复杂度为O(n)。
三、快速排序快速排序也是一种分治算法，它将原始数组根据一个主元（pivot）分成两个子数组，一个子数组的元素都小于主元，另一个子数组的元素都大于主元。
然后，递归地对这两个子数组进行排序，最后得到有序数组。
快速排序的核心操作是划分。
1. 算法步骤（1）选择一个主元（pivot），可以是随机选择或者固定选择第一个元素；（2）将原始数组根据主元划分为两个子数组，一个子数组的元素都小于主元，另一个子数组的元素都大于主元；（3）递归地对这两个子数组进行快速排序；（4）重复步骤（2）和（3），直到每个子数组只有一个元素，即得到最终的有序数组。
2. 算法性能快速排序的平均时间复杂度为O(nlogn)，其中n为待排序数组的长度。
最坏情况下，当每次选择的主元都是最小或最大元素时，时间复杂度为O(n^2)。
快速排序是原地排序，不需要额外的存储空间，所以空间复杂度为O(1)。
四、实验设计为了验证合并排序和快速排序的性能和效率，我们设计以下实验：1. 实验目的：比较合并排序和快速排序的时间复杂度和空间复杂度。
算法与分析实验报告
算法与分析实验报告一、引言算法是现代计算机科学中的核心概念，通过合理设计的算法可以解决复杂的问题，并提高计算机程序的执行效率。
本次实验旨在通过实际操作和数据统计，对比分析不同算法的执行效率，探究不同算法对于解决特定问题的适用性和优劣之处。
二、实验内容本次实验涉及两个经典的算法问题：排序和搜索。
具体实验内容如下：1. 排序算法- 冒泡排序- 插入排序- 快速排序2. 搜索算法- 顺序搜索- 二分搜索为了对比不同算法的执行效率，我们需要设计合适的测试用例并记录程序执行时间进行比较。
实验中，我们将使用随机生成的整数数组作为排序和搜索的测试数据，并统计执行时间。
三、实验步骤1. 算法实现与优化- 实现冒泡排序、插入排序和快速排序算法，并对算法进行优化，提高执行效率。
- 实现顺序搜索和二分搜索算法。
2. 数据生成- 设计随机整数数组生成函数，生成不同大小的测试数据。
3. 实验设计- 设计实验方案，包括测试数据的规模、重复次数等。
4. 实验执行与数据收集- 使用不同算法对随机整数数组进行排序和搜索操作，记录执行时间。
- 多次重复同样的操作，取平均值以减小误差。
5. 数据分析与结果展示- 将实验收集到的数据进行分析，并展示在数据表格或图表中。
四、实验结果根据实验数据的收集与分析，我们得到以下结果：1. 排序算法的比较- 冒泡排序：平均执行时间较长，不适用于大规模数据排序。
- 插入排序：执行效率一般，在中等规模数据排序中表现良好。
- 快速排序：执行效率最高，适用于大规模数据排序。
2. 搜索算法的比较- 顺序搜索：执行时间与数据规模成线性关系，适用于小规模数据搜索。
- 二分搜索：执行时间与数据规模呈对数关系，适用于大规模有序数据搜索。
实验结果表明，不同算法适用于不同规模和类型的问题。
正确选择和使用算法可以显著提高程序的执行效率和性能。
五、实验总结通过本次实验，我们深入了解了不同算法的原理和特点，并通过实际操作和数据分析对算法进行了比较和评估。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
《排序问题求解》实验报告一、算法得基本思想1、直接插入排序算法思想直接插入排序得基本思想就是将一个记录插入到已排好序得序列中,从而得到一个新得,记录数增 1 得有序序列。
直接插入排序算法得伪代码称为InsertｉonＳorｔ，它得参数就是一个数组A[1、、n］,包含了n个待排序得数。
用伪代码表示直接插入排序算法如下:IｎsｅrtｉonＳｏｒt (Ａ)for i←2 tｏnｄo ｋeｙ←Ａ[i］／/key 表示待插入数//Ｉnsｅrt A［i] ｉnto ｔhｅsｏrteｄｓequence A［1、、i-１］j←i-1wｈｉｌe j＞0 ａnｄＡ[j]＞keydo A[j＋１］←A［j］j←j-1Ａ[j+1］←keｙ2、快速排序算法思想快速排序算法得基本思想就是，通过一趟排序将待排序序列分割成独立得两部分，其中一部分记录得关键字均比另一部分记录得关键字小,则可对这两部分记录继续进行排序,以达到整个序列有序。
假设待排序序列为数组A[１、、n]，首先选取第一个数Ａ[0],作为枢轴(ｐｉvｏt)，然后按照下述原则重新排列其余数:将所有比Ａ[0]大得数都排在它得位置之前,将所有比A[０]小得数都排在它得位置之后,由此以A[0]最后所在得位置i 作为分界线,将数组A[1、、n]分成两个子数组Ａ［1、、i－1］与Ａ[ｉ+1、、n］。
这个过程称作一趟快速排序。
通过递归调用快速排序,对子数组A[1、、ｉ-1]与A[i＋1、、n]排序。
一趟快速排序算法得伪代码称为Paｒtｉtion，它得参数就是一个数组A[１、、n］与两个指针ｌoｗ、high,设枢轴为ｐｉvotｋeｙ，则首先从higｈ所指位置起向前搜索,找到第一个小于ｐivｏtｋey得数,并将其移到低端,然后从low 所指位置起向后搜索,找到第一个大于pivotkey 得数,并将其移到高端，重复这两步直至low=ｈigh。
最后,将枢轴移到正确得位置上。
用伪代码表示一趟快速排序算法如下:Partiｔｉｏn ( Ａ，low，higｈ)A[０］←A[low]／／用数组得第一个记录做枢轴记录priｖotkey←Ａ[low]//枢轴记录关键字wｈile lｏw<ｈigh //从表得两端交替地向中间扫描whｉle low<high ＆＆A［high]>＝pｒivotｋey do ｈｉｇh←higｈ-1A［loｗ]←Ａ[high] //将比枢轴记录小得记录移到低端ｗｈile low<ｈigh &＆A[ｌow］＜＝pivｏｔkｅｙ)dｏlow←lｏw+１A[hｉｇｈ]←A[ｌoｗ] ／/将比枢轴记录大得记录移到高端A［ｌow]←Ａ［０] //枢轴记录到位retｕｒn low ／/返回枢轴位置二、算法得理论分析1、直接插入排序算法理论分析从空间来瞧，直接插入排序只需要一个数得辅助空间;从时间来瞧,直接插入排序得基本操作为:比较两个关键字得大小与移动记录。
先分析一趟直接插入排序得情况。
伪代码InsertiｏnＳｏrt中while循环得次数取决于待插入得数与前ｉ－1 个数之间得关系。
若A[ｉ]＜A[０],则在while 循环中，待插入数需与有序数组A[１、、i-1]中i-１个数进行比较,并将A［i-1]中i－１个数后移。
则在整个排序过程(进行n-1 趟插入排序）中，当待排序数组中数按非递减有序排列时,则需进行数间比较次数达最小值n-1,数不需要移动;反之，当待排序数组中数按非递增有序排列时,总得比较次数达最大值（n＋2)(n－1）/2,数移动得次数也达到最大值(n+４）(n-1)/2。
若待排序数组就是随机得,即待排序数组中得数可能出现得各种排序得概率相同，则我们可取上述最小值与最大值得平均值,作为直接插入排序时所需进行数间得比较次数与数得移动次数,约为n^2／4。
因此直接插入排序算法,在最佳情况下得时间复杂度就是O(n),在最坏情况下得时间复杂度为O(n^2)。
２、快速排序算法理论分析下面我们来分析快速排序得平均时间性能。
假设T(n)为对n 个记录A[1、、ｎ]进行快速排序所需时间,则由算法ＱuｉcｋSoｒt 可见：其中,Tpａss(ｎ)为对n 个记录进行一趟快速排序Ｐartiｔion(A,1,n)所需得时间,从一趟快速排序算法可见,其与记录数n成正比,可以用cｎ表示(c 为某个常数）;T(k-1）与Ｔ（n-k)分别为对A［1、、ｋ-1]与A[k＋1、、ｎ]中记录进行快速排序QuickSorｔ（A,１,ｋ-1)与QuiｃｋSort(A,k+1,n)所需时间。
假设待排序列中记录就是随机排列得，则在一趟排序之后，k 取 1 至n 之间任何一值得概率相同，快速排序所需时间得平均值则为Taｖg(n)=ｋnInn,其中n 为待排序序列中记录得个数,ｋ为某个常数。
通常,快速排序被认为就是,在所有同数量级(O（ｎlogｎ))得排序方法中,其平均性能最好。
但就是,若初始记录序列按关键字有序或基本有序时,快速排序将蜕化为起泡排序,其时间复杂度为O（n^2)。
三、试验分析1、试验环境WＩN 32系统,VＣ6、02、程序得执行1)由函数datagenetare（)生成２0００0 个在区间[1，100０00]上得随机整数,并将随机整数保存到数组nuｍ[]，接着调用函数ＷriteＦｉle（)将这些数输出到外部文件dａｔa、ｔxt 中。
2)调用函数ReadＦiｌe()从ｄata、txｔ中读取数据,并将其保存到数组nuｍ1[]中。
接着对数组nuｍ1 进行直接插入排序,并计算与记录其运行时间。
最后,调用函数ＷrｉｔｅＦilｅ(）将直接插入排序得结果写入rｅsｕltsIS、txt，并记录运行时间为TiｍeＩＳ。
3)调用函数ReａdFilｅ()从ｄata、ｔｘt 中读取数据，并将其保存到数组num2［]中。
接着对数组num２进行快速排序,并计算与记录其运行时间。
最后,调用函数WｒitｅFile()将快速排序得结果写入reｓultsQS、txt,并记录运行时间为TimeＱS。
3、试验数据当N=２０000时：当N=300０0时：当N＝４0０00时：当N＝５0000时:当Ｎ=６0０0０时:当N=７0000时:当N＝8０000时:2 0插入排序０、３２５０、７19 1、397 2、19９3、0５4、57１５、46快速排序 0、０03 0、００5 0、008 0、０1 0、01２0、011 0、０13四、试验心得通过本次试验首先对在C+＋下得文件操作有了一定得深入认识，对于快速排序与插入排序得时间有了相当清晰且一目了然得认识,并且从原理上明白了快速排序得快得原因,对各种排序算法得优劣性有了全局得认识!五、实验代码#iｎｃlude <ｉｏsｔream>#include＜ｃtimｅ＞#ｉｎｃlｕｄe ＜cｓtdlib>#incluｄe<ｆstream>#incｌude <strinｇ>uｓing naｍｅspacｅsｔd;coｎｓｔint NumS = 80000;vｏｉｄｄaｔaｇenetaｒe(ｉnt ｎuｍ[］,int ｎ); //产生随机数，保存到数组nｕmvoid Write num［],ｃｈａr name[]，int n);／/输出数组ｎum到data、tｘｔ文件void Read num[］,cｈar name[]）;/／读取名为namｅ文件中得数据,保存到数组numvoid QuickＳorｔ(iｎt arr［], inｔn)；//将数组arｒ[]中数据快速排序voiｄInｓeｒtionSoｒt(iｎt aｒr［],iｎｔn);//将数组arr［]中数据直接插入排序int ｍaiｎ（){ﻩiｎｔ＊num=(int *)ｍａlloc(sizｅoｆ(inｔ)＊NｕmS);int*nuｍ1＝（iｎt*)ｍalloc(sizeoｆ(int)*NumS);ﻩiｎt ＊nuｍ2=(ｉｎｔ*)mａlｌoc(siｚeof(inｔ)*NumS);ﻩclock_t stａrt_tｉme1,enｄ_tiｍｅ1,ｓtart_tｉｍｅ2,ｅnd_timｅ2;ﻩdouble timeQS=０,ｔｉmeIS＝0；ﻩcoｕt＜<"Cｒeａte "<<NｕmS＜<＂ranｄomｎuｍbｅｒs fｒom 1 to 10０000＂＜<en ｄｌ；ﻩdａtａgｅnetａre(num,NumS）; ／/产生随机数,保存到数组numＷrite,"daｔa、ｔxｔ"，NuｍS)；//输出数组到daｔａ、txt文件ﻩcout、ｐrecisiｏn(６）; //设置浮点数得显示精度cｏut、ｓｅtf(iｏs_bａsｅ::showpoｉnt); //输出末尾得/／直接插入排序得分析Reaｄ,"ｄａtａ、tｘt"）;／/读取ｄaｔａ、txt中得数据,保存到数组num１cout<<"\ｎInseｒtｉonSｏrt Sｔaｒt、、、、\ｎ＂;ｓｔａrt＿tiｍe１=ｃlocｋ(）; ／/开始计时InsｅrtionＳort(num1,NumS); //直接插入排序数组num1中得数据enｄ_time１＝ｃlock（); ／/结束计时tｉｍeIＳ=(dｏｕblｅ)(enｄ＿ｔime1－start_tｉmｅ1)/ＣＬOCＫＳ_ＰＥＲ_SEＣ;ｃouｔ<<＂The Tiｍｅ-sｕptionｉn InｓeｒtiｏnSorｔis "<<ｔiｍeＩＳ<<" seconds!\n\n"; //输出运行时间ﻩﻩWriｔｅ，＂rｅsｕltｓIS、ｔｘt"，ＮumＳ）; //排序后得数据输出到resultQS、txt ﻩ//输出运行时间tｉｍeＩS到ｒｅｓuｌtsIS、tｘｔofｓtｒeam oｃout;ﻩoｃout、opｅｎ（＂reｓultsIS、txt＂,iｏs::aｐp）;ﻩif（ocoｕｔ、good()) //打开ｒesulｔsＩS、txt｛ﻩﻩｏcout＜<"\nThe Ｔime-suptioｎｉn InsｅrtionSortｉｓ"<<timeＩS<<" seconｄs＼ｎ"；ﻩocouｔ、ｃlｏｓe（)；ﻩ}else{ﻩﻩcｏut<<"＼nＣan not open ｒesultsIS、txｔ!＼ｎ";ﻩexiｔ(1);//异常退出ﻩ}//快速排序得分析Ｒead,"data、ｔxt")；//读取dａta、tｘt中得数据,保存到数组nuｍ2[］ﻩｃoｕｔ＜＜"QuiｃkSｏrｔStart、、、、、\n"；ﻩstaｒt_tiｍe2=clock（); //开始计时ﻩＱuｉckＳort（nｕｍ2，NumＳ);/／快速排序数组num中得数据enｄ_time2=clock()；／/结束计时ｔiｍｅQS=(double)(end_time２-ｓtart_timｅ２)/CLOCKS_PＥR_SEC;ﻩｃout<<＂The Ｔiｍe-suption ｉn QuickSｏrtｉｓ"<<timeQS<<" secｏｎds:\n"; //输出运行时间Wriｔｅ,"resuｌtsＱＳ、txt＂，NumS); //排序后得数据输出到resultQＳ、tｘtﻩ／／输出运行时间tｉmeQS到ｒesuｌｔsＱS、txｔﻩocout、open("resultsQＳ、tｘt",ios::ａpp);iｆ(ocout、ｇｏｏd()) //打开resultsIＳ、txtﻩ{ﻩｏcoｕt＜＜"\nThe Tiｍe－sｕｐtiｏn in QuｉｃkSoｒt ｉs"<＜ｔｉmeQS<<"seco ｎds\n";oｃout、closｅ(）;ﻩ}else{coｕt<＜"\ｎCaｎnot open ｒesultsQＳ、ｔxt!\n＂;exｉt(1）; ／/异常退出ﻩ｝rｅｔｕrｎ0;}voｉd datａgｅｎetare(inｔ*num,iｎt ｎ）{ﻩｉnt i;srand（(ｕｎｓigｎed)tｉme（0)）; ／／ｓrａnｄ(）种子发生器函数,还有ｒand()随机数生成器函数ｆor(ｉ=0；i<n;i+＋) //产生个到之间得随机数ﻩｎuｍ[i］＝ranｄ()%9999+1;priｎtf（"\ｎ＂);}//将数组中得数据输出到文件void Ｗritｅ＊num,char name［］,inｔn){ﻩoｆstream oｃoｕt;oｃout、ｏｐen（nａme,ios::trｕnc);ｉnt i=０;if（ｏcouｔ、fａｉl(）)exit(１）；//打开文件失败,退出foｒ(;i<n；ｉ＋+){ﻩocｏut<<num［i]<<" ";ﻩif（（i+１)％40==０｜｜ｉ＝=ｎ-１) ／/每输出40个数,换一行ﻩﻩoｃｏut<＜"＼n";｝ocout、ｃlose()；}//将文件中得数据输入到数组voｉｄRｅad *nuｍ,chaｒｎaｍｅ［]){ﻩｓtring ｓtrLｉne；iｎｔi=0;chａr ａchＬinｅ［300];ﻩｃｏnst chaｒ* pｃhToｋ;ﻩiｆsｔreamｉｃiｎ;iｃin、opeｎ（naｍe,ｉos::in）;/／打开名为naｍe得文件whilｅ（iｃiｎ、gｏod())ﻩ{ﻩﻩint i = 0；whｉle（ｇｅｔline(icin,strLiｎe))ﻩ{ﻩﻩstｒLｉne、copy(achLｉne,strＬｉnｅ、ｓize(),０);ﻩﻩachLiｎe［strLinｅ、siｚe()]='\０';／/每行中得元素以空格为标识断开转换为iｎｔ类型后存入数组ﻩﻩpchTok ＝ｓtrｔoｋ(acｈLｉnｅ, " ");ﻩﻩｗhile((pchTok != NULL))ﻩ{ﻩﻩnum[i］= aｔoi(ｐchＴok);ﻩﻩﻩﻩi++;ﻩﻩﻩｐｃhTok =strtok（ＮULＬ,"");}｝}ｉcin、close();}//快速排序得实现,从左向右递增排序void QｕｉckSｏrｔ（int ＊ａrr,ｉnt ｎ）{ﻩiｎt L ＝0；int R ＝ｎ-1；ﻩint t = arr[Ｌ］; /／区间得第一个数作为基准ﻩif(ｎ<=1) ／／数组中存在个或个数据时,函数返回ﻩreｔurn;ﻩ//将数据分成两个区间wｈilｅ(Ｌ＜R){ ／/区间内至少存在一个元素得情况whilｅ(L<Ｒ&&t＜=aｒr[R]) R－-;//从右向左搜索,直到第一个小于ｔ得数aｒr[R] ﻩarr［L] = arr[R];ﻩｗhiｌｅ(L＜Ｒ&&arr［L]<=t) L++;／／从左向右搜索，找到第一个大于ｔ得数aｒr[L] ﻩarr［R] ＝arｒ[L]；ﻩ}ﻩａrr［L] = t;QuickＳorｔ(arｒ, L); ／/对左区间递归排序QuickＳoｒt(aｒr+L+1,n-Ｌ－1);//对右区间递归排序}//直接插入排序得实现,从左向右递增排序voiｄＩｎsertionＳoｒt(int *aｒr,intｎ）{ﻩｉnt i=０,ｔemｐ=０,ｊ=0;ﻩif(n<=１)ﻩrｅturn;ﻩfor(i=1;ｉ<n;+＋ｉ){ﻩﻩｔeｍｐ＝arｒ[i]; //temｐ记录要插入得数据arr[i]ｊ=i; //要插入得数据得位置ﻩﻩfor(;j>0&&arr[j－1]>temp；-－ｊ) ／/将ａ[ｉ］插入到已排序得arｒ［0]~arｒ[i-1］中ﻩ{arｒ[j]=arｒ[j-1］; /／比temｐ大得数据依次后移ﻩ｝ﻩﻩａrr[j]=teｍp; //找到第一个不大于于ｔｅｍp得数据，在j处插入aｒr[i]ﻩ｝}。