算法分析与复杂性理论 实验报告 基本排序
算法实验报告结果分析
一、实验背景随着计算机科学技术的不断发展，算法作为计算机科学的核心内容之一，其重要性日益凸显。
为了验证和评估不同算法的性能，我们进行了一系列算法实验，通过对比分析实验结果，以期为后续算法研究和优化提供参考。
二、实验方法本次实验选取了三种常见的算法：快速排序、归并排序和插入排序，分别对随机生成的数据集进行排序操作。
实验数据集的大小分为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秒。
可以看出，随着数据量的增加，插入排序的性能明显下降。
排序算法设计实验报告
一、实验目的1. 理解排序算法的基本原理和常用算法。
2. 通过编程实现几种常见的排序算法。
3. 分析不同排序算法的性能，比较其优缺点。
4. 培养编程能力和算法思维能力。
二、实验环境1. 操作系统：Windows 102. 编程语言：Python3.73. 开发工具：PyCharm三、实验内容1. 算法选择：冒泡排序、选择排序、插入排序、快速排序、归并排序2. 实现排序算法3. 分析算法性能4. 比较不同排序算法的优缺点四、实验步骤1. 设计排序算法（1）冒泡排序冒泡排序是一种简单的排序算法，其基本思想是通过比较相邻元素的值，将较大的元素向后移动，较小的元素向前移动，直到整个序列有序。
（2）选择排序选择排序的基本思想是遍历整个序列，在未排序的序列中找到最小（大）元素，将其与序列的第一个元素交换，然后继续在剩余未排序的序列中找到最小（大）元素，重复此过程，直到整个序列有序。
（3）插入排序插入排序的基本思想是将未排序的序列中的元素插入到已排序的序列中，直到整个序列有序。
（4）快速排序快速排序是一种高效的排序算法，其基本思想是选取一个基准值，将序列分为两部分，一部分小于基准值，另一部分大于基准值，然后递归地对这两部分进行快速排序。
（5）归并排序归并排序是一种分治策略的排序算法，其基本思想是将序列划分为两个子序列，分别对这两个子序列进行排序，然后将排序好的子序列合并为一个有序序列。
2. 编写排序算法代码```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):n = len(arr)for i in range(1, n):key = arr[i]j = i-1while j >= 0 and key < arr[j]:arr[j+1] = arr[j]j -= 1arr[j+1] = keydef quick_sort(arr):if len(arr) <= 1:return arrpivot = 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) 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])j += 1result.extend(left[i:])result.extend(right[j:])return result```3. 分析算法性能（1）冒泡排序冒泡排序的时间复杂度为O(n^2)，空间复杂度为O(1)。
算法实现与复杂度分析实习报告
算法实现与复杂度分析实习报告一、实习背景在计算机科学与技术领域中，算法的实现和复杂度分析是非常重要的一部分。
算法是计算机问题求解的方法和步骤的描述，是计算机科学的核心内容。
而复杂度分析则是对算法运行效率和资源消耗进行评估的方法。
在这次实习中，我主要学习了算法的实现和复杂度分析，并通过实际编程实践了解了不同算法的运行效率和资源利用。
二、实习过程1. 算法实现在实习的第一阶段，我学习了常见的排序算法和查找算法，并进行了实现。
其中包括冒泡排序、插入排序、选择排序、快速排序、归并排序等排序算法，以及顺序查找、二分查找等查找算法。
通过实现这些算法，我深入理解了它们的原理和思想，并通过编程实践加深了对算法的理解。
在实现算法的过程中，我注意到不同算法之间的差别。
例如，冒泡排序算法的时间复杂度为O(n^2)，而快速排序算法的时间复杂度为O(nlogn)。
这表明快速排序算法在处理大规模数据时比冒泡排序算法更加高效。
同时，我还注意到了一些排序算法的稳定性，即算法在排序过程中是否能够保持相同元素的相对位置不变。
例如，冒泡排序是稳定的，而选择排序是不稳定的。
2. 复杂度分析在实现算法的基础上，我学习了如何对算法的复杂度进行分析。
复杂度分析主要关注算法的时间复杂度和空间复杂度。
时间复杂度表示算法解决问题所需的时间随输入规模的增长而增长的趋势。
通常使用大O记法来表示时间复杂度。
例如，O(n)表示算法的时间复杂度与输入规模成线性关系，O(n^2)表示算法的时间复杂度与输入规模成平方关系。
通过分析算法的循环次数、递归层数等特征，可以得出算法的时间复杂度。
空间复杂度表示算法解决问题所需的额外空间随输入规模的增长而增长的趋势。
同样使用大O记法表示空间复杂度。
例如，O(n)表示算法的空间复杂度与输入规模成线性关系，O(1)表示算法的空间复杂度为常数。
通过分析算法使用的额外数据结构、递归调用的深度等特征，可以得出算法的空间复杂度。
通过对算法的时间复杂度和空间复杂度进行分析，可以评估算法的运行效率和资源消耗。
算法设计与分析实验报告三篇
算法设计与分析实验报告一实验名称统计数字问题评分实验日期2014 年11 月15 日指导教师姓名专业班级学号一.实验要求1、掌握算法的计算复杂性概念。
2、掌握算法渐近复杂性的数学表述。
3、掌握用C++语言描述算法的方法。
4．实现具体的编程与上机实验，验证算法的时间复杂性函数。
二.实验内容统计数字问题1、问题描述一本书的页码从自然数1 开始顺序编码直到自然数n。
书的页码按照通常的习惯编排，每个页码都不含多余的前导数字0。
例如，第6 页用数字6 表示，而不是06 或006 等。
数字计数问题要求对给定书的总页码n，计算出书的全部页码中分别用到多少次数字0，1，2， (9)2、编程任务给定表示书的总页码的10 进制整数n (1≤n≤109) 。
编程计算书的全部页码中分别用到多少次数字0，1，2， (9)三.程序算法将页码数除以10，得到一个整数商和余数，商就代表页码数减余数外有多少个1—9作为个位数，余数代表有1—余数本身这么多个数作为剩余的个位数，此外，商还代表1—商本身这些数出现了10次，余数还代表剩余的没有计算的商的大小的数的个数。
把这些结果统计起来即可。
四.程序代码#include<iostream.h>int s[10]; //记录0~9出现的次数int a[10]; //a[i]记录n位数的规律void sum(int n,int l,int m){ if(m==1){int zero=1;for(int i=0;i<=l;i++) //去除前缀0{ s[0]-=zero;zero*=10;} }if(n<10){for(int i=0;i<=n;i++){ s[i]+=1; }return;}//位数为1位时,出现次数加1//位数大于1时的出现次数for(int t=1;t<=l;t++)//计算规律f(n)=n*10^(n-1){m=1;int i;for(i=1;i<t;i++)m=m*10;a[t]=t*m;}int zero=1;for(int i=0;i<l;i++){ zero*= 10;} //求出输入数为10的n次方int yushu=n%zero; //求出最高位以后的数int zuigao=n/zero; //求出最高位zuigaofor(i=0;i<zuigao;i++){ s[i]+=zero;} //求出0~zuigao-1位的数的出现次数for(i=0;i<10;i++){ s[i]+=zuigao*a[l];} //求出与余数位数相同的0~zuigao-1位中0~9出现的次数//如果余数是0,则程序可结束,不为0则补上所缺的0数,和最高位对应所缺的数if(yushu==0) //补上所缺的0数,并且最高位加1{ s[zuigao]++;s[0]+=l; }else{ i=0;while((zero/=10)>yushu){ i++; }s[0]+=i*(yushu+1);//补回因作模操作丢失的0s[zuigao]+=(yushu+1);//补回最高位丢失的数目sum(yushu,l-i-1,m+1);//处理余位数}}void main(){ int i,m,n,N,l;cout<<"输入数字要查询的数字:";cin>>N;cout<<'\n';n = N;for(i=0;n>=10;i++){ n/=10; } //求出N的位数n-1l=i;sum(N,l,1);for(i=0; i<10;i++){ cout<< "数字"<<i<<"出现了:"<<s[i]<<"次"<<'\n'; }}五.程序调试中的问题调试过程，页码出现报错。
算法实验报告
算法实验报告算法实验报告引言：算法是计算机科学的核心内容之一，它是解决问题的方法和步骤的描述。
算法的设计和分析是计算机科学与工程中的重要研究方向之一。
本实验旨在通过对算法的实际应用和实验验证，深入理解算法的性能和效果。
实验一：排序算法的比较在本实验中，我们将比较三种常见的排序算法：冒泡排序、插入排序和快速排序。
我们将通过对不同规模的随机数组进行排序，并记录每种算法所需的时间和比较次数，以评估它们的性能。
实验结果显示，快速排序是最快的排序算法，其时间复杂度为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算法分别适用于不同的场景；动态规划算法可以解决复杂的问题，并找到最优解。
排序实验报告_排序综合实验报告材料
班级
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]看
信息算法分析实验报告
一、实验目的1. 理解信息算法的基本概念和原理。
2. 掌握信息算法的常见类型及其应用场景。
3. 学习如何分析算法的复杂度，包括时间复杂度和空间复杂度。
4. 通过实际操作，提高运用信息算法解决实际问题的能力。
二、实验内容本次实验主要围绕以下内容展开：1. 排序算法：选择排序、冒泡排序、插入排序、快速排序、归并排序、堆排序等。
2. 查找算法：顺序查找、二分查找、散列表查找等。
3. 动态规划：0-1背包问题、最长公共子序列问题等。
4. 贪心算法：活动选择问题、背包问题等。
三、实验过程1. 选择排序：通过交换元素的位置，将数组排序。
时间复杂度为O(n^2)，空间复杂度为O(1)。
```cvoid selectionSort(int arr[], int n) {for (int i = 0; i < n - 1; i++) {int min_idx = i;for (int j = i + 1; j < n; j++) {if (arr[j] < arr[min_idx]) {min_idx = j;}}swap(&arr[min_idx], &arr[i]);}}```2. 快速排序：选取一个基准元素，将数组分为两部分，使得左边的元素都比基准小，右边的元素都比基准大。
时间复杂度为O(nlogn)，空间复杂度为O(logn)。
```cint partition(int arr[], int low, int high) {int pivot = arr[high];int i = (low - 1);for (int j = low; j <= high - 1; j++) {if (arr[j] < pivot) {i++;swap(&arr[i], &arr[j]);}}swap(&arr[i + 1], &arr[high]);return (i + 1);}void quickSort(int arr[], int low, int high) {if (low < high) {int pi = partition(arr, low, high);quickSort(arr, low, pi - 1);quickSort(arr, pi + 1, high);}}```3. 动态规划解决0-1背包问题：给定一个背包容量和若干物品，每个物品有一个价值和重量，求解背包中物品的最大价值。
算法分析与设计实验报告合并排序快速排序
算法分析与设计实验报告：合并排序与快速排序一、引言算法是计算机科学中非常重要的一部分，它涉及到解决问题的方法和步骤。
合并排序和快速排序是两种经典而常用的排序算法。
本文将对这两种排序算法进行分析和设计实验，通过对比它们的性能和效率，以期得出最优算法。
二、合并排序合并排序是一种分治算法，它将原始数组不断分解为更小的数组，直到最后细分为单个元素。
然后，再将这些单个元素两两合并，形成一个有序数组。
合并排序的核心操作是合并两个有序的数组。
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、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
深圳大学实验报告课程名称：算法设计与分析实验名称：多种排序算法的算法实现及性能比较学院：计算机与软件学院专业：计算机科学与技术报告人：张健哲学号：2013150372 班级： 3 同组人：无指导教师：李炎然实验时间：2015/3/25——2015/4/8实验报告提交时间：2015/4/8教务处制一．实验目的1.掌握选择排序、冒泡排序、合并排序、快速排序、插入排序算法原理2.掌握不同排序算法时间效率的经验分析方法，验证理论分析与经验分析的一致性。
二．实验步骤与结果实验总体思路：利用switch结构来选择实验所要用的排序算法，每一种排序都用相同的计算运行时间的代码，不同的算法就在算法实现部分进行改动（如下代码1至5所示）。
不断的改变数据规模，每一个规模在实验时，用循环进行多次实验并作为样本记录消耗的时间。
最后输出在不同排序算法下，不同的数据规模的20次实验样本和平均用时（如下图1至5所示）。
各排序算法的实现及实验结果：（注1：以下代码全部为伪代码，具体代码实现请参照程序中的代码）（注2：图中显示的时间单位均为毫秒，图中“排序所花时间”一项为平均消耗时间，平均消耗时间结果以20组样本计算平均值后取整得到（并非四舍五入）。
）1、选择排序代码1：for i=0 to n-2min=ifor j= i+1 to n-1if ele[min]>ele[j] min=jswap(ele[i],ele[min]) //交换图1、选择排序在不同数据规模下排序所消耗的时间2、冒泡排序代码2：for i= 0 to n-1for j=0 to n-1-iif a[j]>a[j+1]swap(a[j],a[j+1]) //交换图2、冒泡排序在不同数据规模下排序所消耗的时间3、合并排序代码3：Merge(ele[1...n],left,right)middle=(left+right)/2if right>1eft+1Merge(ele,left,middle)Merge(ele,middle+1,right)l←left r←right i←leftwhile l<=middle&&r<=right //两组分别一一比较，数据小的放入ele if ele[l]<=ele[r]t[i++]←ele[l++]elset[i++]←ele[r++]while l>middle&&r<=r //只剩一组还有剩余的时，将剩下的按顺序放入ele[i++]=s[r++]while l<=middle && r>rightele[i++]=s[l++];图3、合并排序在不同数据规模下排序所消耗的时间4、快速排序代码4：quick(ele[0...n-1],left,right)if l<rl←left r←right x←ele[l];while l<rwhile l<r && x<=ele[r] //找到一个比x小的数之后交换到前面的部分r--if l<rele[l]←ele[r] l++while l<r && x>ele[l] //与上面相反ll++if l<rele[r]←ele[l] r--ele[l]←x;quick(ele,left,l-1) // 递归调用quick(ele,l+1,right)图4、快速排序在不同数据规模下排序所消耗的时间5、插入排序代码5：for i=1→n-1if ele[i]<ele[i-1] temp=ele[i]for j= i-1 to 0 && ele[j]>tempele[j+1]←ele[j]ele[j+1]←temp图5、插入排序在不同数据规模下排序所消耗的时间三．实验分析选择排序：图6、由图1数据整合而成的折线图为了更清晰的看到排序的数据规模与排序所需时间之间的影响，我将实验的数据规模进行了一些调整，得到的平均数据依旧是以20组数据样本取平均数算得（如下表1、图7所示）：（由于图片占空间大且表达不直白，我将所得数据做成表格分析，下同）表1、选择排序在不同数据规模下排序所消耗的时间图7、由表1数据整合而成的折线图图形上：形状基本符合n2（二次增长）数据上：我们发现当数据规模增大两倍时：当数据规模增大两倍时：10000→20000： 158*22=632≈634 10000→30000：158*32=1422≈142420000→40000： 634*22=2536≈2541其他倍数也可得到类似的结果。
结论：我们发现，由于时间复杂度是o（n2）并且该排序的主要操作是比较操作，当数据规模扩大n倍时，相应的在时间的消耗上会扩大n2倍，同时我们发现，理论上乘以n2后的数据普遍会略小于实际数据，这主要原因可能是除了比较操作之外，赋值操作也随着n的增加逐渐增大，并且会在时间上体现出来，此外轻微的误差可能是数据的差异造成或者电脑等其他因素造成。
冒泡排序：图8、由图2数据整合而成的折线图为了更清晰的看到排序的数据规模与排序所需时间之间的影响，我将实验的数据规模进行了一些调整，得到的平均数据依旧是以20组数据样本取平均数算得（如下表2、图9所示）：表2、冒泡排序在不同数据规模下排序所消耗的时间图9、由表2数据整合而成的折线图图形上：形状基本符合n2（二次增长）数据上：我们发现当数据规模增大两倍时：当数据规模增大两倍时：10000→20000：284*22=1136≠1266(误差130） 10000→30000：284*32=2556≠2899(误差343）20000→40000:1266*22=5064≠5313(误差149）其他倍数也可得到类似的结果。
结论：我们发现，虽然时间复杂度是o（n2），但当数据规模扩大n倍时，并没有相应的在时间的消耗上扩大n2倍，而是多于n2，同时我们发现，这个误差会随着数据规模的扩大而扩大，这主要原因是除了比较操作之外，赋值操作也随着n的增加逐渐增大，而且事实证明在数据比较极端的情况下，赋值操作已经不能忽略不计（这里的赋值操作发生在数据交换时所需要的操作），最糟糕的情况是每次比较就要进行三次的赋值操作，与此相比，电脑等其他因素造成轻微的误差可以忽略不计。
合并排序：图10、由图3数据整合而成的折线图为了更清晰的看到排序的数据规模与排序所需时间之间的影响，我将实验的数据规模进行了一些调整，得到的平均数据依旧是以20组数据样本取平均数算得（如下表3、图11所示）：表3、合并排序在不同数据规模下排序所消耗的时间图11、由表3数据整合而成的折线图图形上：形状基本符合n（线性增长）数据上：我们发现当数据规模增大两倍时：当数据规模增大两倍时：10000→20000： 24*2log22=48≈51 10000→30000：24*3log23=72≈76 20000→40000： 51*2log222=102≈105其他倍数也可得到类似的结果。
结论：我们发现，由于时间复杂度是o（nlog2n），当数据规模扩大n倍时，相应的在时间的消耗上会扩大nlog2n倍，同时我们发现，理论上乘以nlog2n后的数据普遍会略小于实际数据，这主要原因快速排序需要递归调用，递归调用需要花费额外的时间，此外轻微的误差可能是数据的差异造成或者电脑等其他因素造成。
快速排序：图12、由图4数据整合而成的折线图为了更清晰的看到排序的数据规模与排序所需时间之间的影响，我将实验的数据规模进行了一些调整，得到的平均数据依旧是以20组数据样本取平均数算得（如下表4、图13所示）：图13、由表4数据整合而成的折线图图形上：形状基本符合n（线性增长）数据上：我们发现当数据规模增大两倍时：当数据规模增大两倍时：10000→20000： 17*2log22=34≈36 10000→30000：17*3log23≈5620000→40000： 26*2log22=54≈56其他倍数也可得到类似的结果。
结论：我们发现，由于时间复杂度是o（nlog2n），当数据规模扩大n倍时，相应的在时间的消耗上会扩大nlog2n倍，同时我们发现，理论上乘以nlog2n后的数据普遍会略小于实际数据，这主要原因快速排序需要递归调用，递归调用需要花费额外的时间，此外轻微的误差可能是数据的差异造成或者电脑等其他因素造成。
插入排序：图14、由图5数据整合而成的折线图为了更清晰的看到排序的数据规模与排序所需时间之间的影响，我将实验的数据规模进行了一些调整，得到的平均数据依旧是以20组数据样本取平均数算得（如下表5、图15所示）：表5、插入排序在不同数据规模下排序所消耗的时间图15、由表5数据整合而成的折线图图形上：形状基本符合n2（二次增长）数据上：我们发现当数据规模增大两倍时：当数据规模增大两倍时：10000→20000： 80*22=320≈319 10000→30000：80*32=720≈72320000→40000： 319*22=1276≈1283其他倍数也可得到类似的结果。
结论：我们发现，由于时间复杂度是o（n2），当数据规模扩大n倍时，相应的在时间的消耗上会扩大n2倍，理论上，如果数据太具有特殊性，那此算法被影响的程度会比较大，他的的比较次数可以从线性次数，到n2次，赋值次数也可能由常数次变成n2总的来说，受数据影响较大，由于我实验基数少，所以无法得出此结论。
将五种排序的实验汇总在一起，如下图16所示图16、由图6、8、10、12、14整合而来从图中以及之前的分析中我们可以得到以下结论时间复杂度同样为o（n2）的选择、冒泡和合并排序，在数据处理上相差的也比较大，其中1、冒泡排序平均耗时最多，其主要原因是：冒泡排序在比较次数上达到了o（n2），但这种排序同时也受交换次数的影响，而且最多时间复杂度也是o（n2）。
如此，同样是o（n2），但冒泡排序的二次项系数会比另外两个大不少，所以最为耗时。
2、选择排序和插入排序相比较，插入排序更快，其原因是：选择排序需要从序列中找到当前最大或最小的值才能进行排序，因此每次都需要与子序列中的全部元素进行比较。
而插入排序无需比较子序列全部元素，只需要找到当前序列第一个比自己大或小的元素，将自身插入到其前一个位置即可。
3、同样是o（nlog2n）但快速排序更快：快速排序出现最差的情况并不是由于输入数据，而是选取到的随机数本身，选到极端的情况非常小，所以对于绝大部分数据而言都是能达o （nlog2n），而合并排序需要赋值的语句还是较多，受输入数据的影响比快排大，所以当数据规模较大时，不受输入数据影响的快速排序更快四．实验心得本次实验虽然花费很大的心思，但确实让我对这几种排序的认识更加深刻，同样的数据，排序的时间可以相差如此之大，这可能会改变我每次都使用冒泡排序的这一习惯，同时，对算法的优良性不同而导致的结果差异之大，感觉到好的算法是多么的重要，当然合理利用算法也是不可忽视的。