(最新)数据结构实验(排序算法效率比较平台)(精品文档)

合集下载

排序的实验报告范文

排序的实验报告范文数据结构实验报告实验名称：实验四排序学生姓名：班级：班内序号：学号：日期：2022年12月21日实验要求题目2使用链表实现下面各种排序算法，并进行比较。

排序算法：1、插入排序2、冒泡排序3、快速排序4、简单选择排序5、其他要求：1、测试数据分成三类：正序、逆序、随机数据。

2、对于这三类数据，比较上述排序算法中关键字的比较次数和移动次数（其中关键字交换计为3次移动）。

3、对于这三类数据，比较上述排序算法中不同算法的执行时间，精确到微秒（选作）。

4、对2和3的结果进行分析，验证上述各种算法的时间复杂度。

编写测试main()函数测试线性表的正确性。

2、程序分析2.1存储结构说明：本程序排序序列的存储由链表来完成。

其存储结构如下图所示。

(1)单链表存储结构：结点地址：1000HA[2]结点地址：1000H1080H……头指针地址：1020HA[0]头指针地址：1020H10C0H……地址：1080HA[3]地址：1080HNULL……地址：10C0HA[1]地址：10C0H1000H……（2）结点结构tructNode{intdata;Node某ne某t;};示意图：intdataNode某ne某tintdataNode某ne某t2.2关键算法分析一：关键算法(一)直接插入排序voidLinkSort::InertSort()直接插入排序是插入排序中最简单的排序方法，其基本思想是：依次将待排序序列中的每一个记录插入到一个已排好的序列中，直到全部记录都排好序。

（1）算法自然语言1.将整个待排序的记录序列划分成有序区和无序区，初始时有序区为待排序记录序列中的第一个记录，无序区包括所有剩余待排序的记录；2.将无须去的第一个记录插入到有序区的合适位置中，从而使无序区减少一个记录，有序区增加一个记录；3.重复执行2，直到无序区中没有记录为止。

（2）源代码voidLinkSort::InertSort()//从第二个元素开始，寻找前面那个比它大的{Node某P=front->ne某t;//要插入的节点的前驱while(P->ne某t){Node某S=front;//用来比较的节点的前驱while(1){if(P->ne某t->data<S->ne某t->data)//P的后继比S的后继小则插入{inert(P,S);break;}S=S->ne某t;if(S==P)//若一趟比较结束，且不需要插入{P=P->ne某t;break;}}}}(3)时间和空间复杂度最好情况下，待排序序列为正序，时间复杂度为O（n）。

排序比较的实验报告

一、实验目的1. 了解常见的排序算法及其基本原理。

2. 比较不同排序算法的时间复杂度和空间复杂度。

3. 分析不同排序算法在实际应用中的适用场景。

二、实验环境1. 操作系统：Windows 102. 编程语言：Python3.83. 数据集：随机生成的10000个整数三、实验内容本次实验主要比较以下排序算法：1. 冒泡排序（Bubble Sort）2. 选择排序（Selection Sort）3. 插入排序（Insertion Sort）4. 快速排序（Quick Sort）5. 归并排序（Merge Sort）四、实验步骤1. 定义排序算法函数。

2. 生成随机整数数据集。

3. 对每个排序算法进行多次测试，记录其时间消耗。

4. 比较不同排序算法的时间复杂度和空间复杂度。

5. 分析不同排序算法在实际应用中的适用场景。

五、实验结果与分析1. 冒泡排序空间复杂度：O(1)冒泡排序是一种简单的排序算法，其基本思想是通过两两比较相邻元素的大小，将较大的元素交换到后面，直到排序完成。

实验结果显示，冒泡排序的时间消耗较高，不适合处理大数据集。

2. 选择排序时间复杂度：O(n^2)空间复杂度：O(1)选择排序的基本思想是每次从待排序的序列中找到最小（或最大）元素，将其放到序列的起始位置，然后继续对剩余未排序的序列进行同样的操作。

实验结果显示，选择排序的时间消耗与冒泡排序相近，同样不适合处理大数据集。

3. 插入排序时间复杂度：O(n^2)空间复杂度：O(1)插入排序的基本思想是将一个记录插入到已经排好序的有序表中，从而得到一个新的、记录数增加1的有序表。

实验结果显示，插入排序的时间消耗与冒泡排序和选择排序相近，同样不适合处理大数据集。

4. 快速排序时间复杂度：O(nlogn)空间复杂度：O(logn)快速排序是一种高效的排序算法，其基本思想是通过一趟排序将待排序记录分割成独立的两部分，其中一部分记录的关键字均比另一部分的关键字小，再分别对这两部分记录继续进行排序，以达到整个序列有序。

数据结构排序实验报告

数据结构排序实验报告数据结构排序实验报告引言：数据结构是计算机科学中的重要概念之一，它涉及到数据的组织、存储和操作方式。

排序是数据结构中的基本操作之一，它可以将一组无序的数据按照特定的规则进行排列，从而方便后续的查找和处理。

本实验旨在通过对不同排序算法的实验比较，探讨它们的性能差异和适用场景。

一、实验目的本实验的主要目的是通过实际操作，深入理解不同排序算法的原理和实现方式，并通过对比它们的性能差异，选取合适的排序算法用于不同场景中。

二、实验环境和工具实验环境：Windows 10 操作系统开发工具：Visual Studio 2019编程语言：C++三、实验过程1. 实验准备在开始实验之前，我们需要先准备一组待排序的数据。

为了保证实验的公正性，我们选择了一组包含10000个随机整数的数据集。

这些数据将被用于对比各种排序算法的性能。

2. 实验步骤我们选择了常见的五种排序算法进行实验比较，分别是冒泡排序、选择排序、插入排序、快速排序和归并排序。

- 冒泡排序：该算法通过不断比较相邻元素的大小，将较大的元素逐渐“冒泡”到数组的末尾。

实现时，我们使用了双重循环来遍历整个数组，并通过交换元素的方式进行排序。

- 选择排序：该算法通过不断选择数组中的最小元素，并将其放置在已排序部分的末尾。

实现时，我们使用了双重循环来遍历整个数组，并通过交换元素的方式进行排序。

- 插入排序：该算法将数组分为已排序和未排序两部分，然后逐个将未排序部分的元素插入到已排序部分的合适位置。

实现时，我们使用了循环和条件判断来找到插入位置，并通过移动元素的方式进行排序。

- 快速排序：该算法通过选取一个基准元素，将数组分为两个子数组，并对子数组进行递归排序。

实现时，我们使用了递归和分治的思想，将数组不断划分为更小的子数组进行排序。

- 归并排序：该算法通过将数组递归地划分为更小的子数组，并将子数组进行合并排序。

实现时，我们使用了递归和分治的思想，将数组不断划分为更小的子数组进行排序，然后再将子数组合并起来。

数据结构实验报告——排序

1．实验要求【实验目的】学习、实现、对比各种排序算法，掌握各种排序算法的优劣，以及各种算法使用的情况。

【实验内容】使用简单数组实现下面各种排序算法，并进行比较。

排序算法：1、插入排序2、希尔排序3、冒泡排序4、快速排序5、简单选择排序6、堆排序（选作）7、归并排序（选作）8、基数排序（选作）9、其他要求：1、测试数据分成三类：正序、逆序、随机数据2、对于这三类数据，比较上述排序算法中关键字的比较次数和移动次数（其中关键字交换计为3次移动）。

3、对于这三类数据，比较上述排序算法中不同算法的执行时间，精确到微秒（选作）4、对2和3的结果进行分析，验证上述各种算法的时间复杂度编写测试main()函数测试线性表的正确性。

2. 程序分析2.1 存储结构存储结构：数组2.2 关键算法分析//插入排序void InsertSort(int r[], int n) {int count1=0,count2=0;插入到合适位置for (int i=2; i<n; i++){r[0]=r[i]; //设置哨兵for (int j=i-1; r[0]<r[j]; j--) //寻找插入位置r[j+1]=r[j]; //记录后移r[j+1]=r[0];count1++;count2++;}for(int k=1;k<n;k++)cout<<r[k]<<" ";cout<<endl;cout<<"比较次数为"<<count1<<" 移动次数为"<<count2<<endl; }//希尔排序void ShellSort(int r[], int n){int i;int d;int j;int count1=0,count2=0;for (d=n/2; d>=1; d=d/2) //以增量为d进行直接插入排序{for (i=d+1; i<n; i++){r[0]=r[i]; //暂存被插入记录for (j=i-d; j>0 && r[0]<r[j]; j=j-d)r[j+d]=r[j]; //记录后移d个位置r[j+d]=r[0];count1++;count2=count2+d;}count1++;}for(i=1;i<n;i++)cout<<r[i]<<" ";cout<<endl;cout<<"比较次数为"<<count1<<" 移动次数为"<<count2<<endl; }//起泡排序void BubbleSort(int r[], int n) {插入到合适位置int temp;int exchange;int bound;int count1=0,count2=0;exchange=n-1; //第一趟起泡排序的范围是r[1]到r[n]while (exchange) //仅当上一趟排序有记录交换才进行本趟排序{bound=exchange;exchange=0;for(int j=0;j<bound;j++) //一趟起泡排序{count1++; //接下来有一次比较if(r[j]>r[j+1]){temp=r[j]; //交换r[j]和r[j+1]r[j]=r[j+1];r[j+1]=temp;exchange=j; //记录每一次发生记录交换的位置count2=count2+3; //移动了3次}}}for(int i=1;i<n;i++)cout<<r[i]<<" ";cout<<endl;cout<<"比较次数为"<<count1<<" 移动次数为"<<count2<<endl;}//快速排序一次划分int Partition(int r[], int first, int end,int &count1,int &count2){int i=first; //初始化int j=end;while (i<j){while (i<j && r[i]<= r[j]){j--; //右侧扫描count1++;}count1++;if (i<j){temp=r[i]; //将较小记录交换到前面r[i]=r[j];r[j]=temp;i++;count2=count2+3;}while (i<j && r[i]<= r[j]){i++; //左侧扫描count1++;}count1++;if (i<j){temp=r[j];r[j]=r[i];r[i]=temp; //将较大记录交换到后面j--;count2=count2+3;}}return i; //i为轴值记录的最终位置}//快速排序void QuickSort(int r[], int first, int end,int &count1,int &count2){if (first<end){ //递归结束int pivot=Partition(r, first, end,count1,count2); //一次划分QuickSort(r, first, pivot-1,count1,count2);//递归地对左侧子序列进行快速排序QuickSort(r, pivot+1, end,count1,count2); //递归地对右侧子序列进行快速排序}}//简单选择排序Array void SelectSort(int r[ ], int n){int i;int j;int index;int temp;int count1=0,count2=0;for (i=0; i<n-1; i++) //对n个记录进行n-1趟简单选择排序{index=i;for(j=i+1;j<n;j++) //在无序区中选取最小记录{count1++; //比较次数加一if(r[j]<r[index]) //如果该元素比现在第i个位置的元素小index=j;}count1++; //在判断不满足循环条件j<n时，比较了一次if(index!=i){temp=r[i]; //将无序区的最小记录与第i个位置上的记录交换r[i]=r[index];r[index]=temp;count2=count2+3; //移动次数加3 }}for(i=1;i<n;i++)cout<<r[i]<<" ";cout<<endl;cout<<"比较次数为"<<count1<<" 移动次数为"<<count2<<endl;}//筛选法调整堆void Sift(int r[],int k,int m,int &count1,int &count2) //s，t分别为比较和移动次数{int i;int j;int temp;i=k;j=2*i+1; //置i为要筛的结点，j为i的左孩子while(j<=m) //筛选还没有进行到叶子{if(j<m && r[j]<r[j+1]) j++; //比较i的左右孩子，j为较大者count1=count1+2; //该语句之前和之后分别有一次比较if(r[i]>r[j])break; //根结点已经大于左右孩子中的较大者else{temp=r[i];r[i]=r[j];r[j]=temp; //将根结点与结点j交换i=j;j=2*i+1; //下一个被筛结点位于原来结点j的位置count2=count2+3; //移动次数加3 }}}//堆排序void HeapSort(int r[],int n){int count1=0,count2=0; //计数器，计比较和移动次数int i;int temp;for(i=n/2;i>=0;i--) //初始建堆，从最后一个非终端结点至根结点Sift(r,i,n,count1,count2) ;for(i=n-1; i>0; i--) //重复执行移走堆顶及重建堆的操作{temp=r[i]; //将堆顶元素与最后一个元素交换r[i]=r[0];r[0]=temp; //完成一趟排序，输出记录的次序状态Sift(r,0,i-1,count1,count2); //重建堆}for(i=1;i<n;i++)cout<<r[i]<<" ";cout<<endl;cout<<"比较次数为"<<count1<<" 移动次数为"<<count2<<endl;}//一次归并void Merge(int r[], int r1[], int s, int m, int t){int i=s;int j=m+1;int k=s;while (i<=m && j<=t){if (r[i]<=r[j])r1[k++]=r[i++]; //取r[i]和r[j]中较小者放入r1[k]elser1[k++]=r[j++];}if (i<=m)while (i<=m) //若第一个子序列没处理完，则进行收尾处理r1[k++]=r[i++];elsewhile (j<=t) //若第二个子序列没处理完，则进行收尾处理r1[k++]=r[j++];}//一趟归并void MergePass(int r[ ], int r1[ ], int n, int h){int i=0;int k;while (i<=n-2*h) //待归并记录至少有两个长度为h的子序列{Merge(r, r1, i, i+h-1, i+2*h-1);i+=2*h;}if (i<n-h)Merge(r, r1, i, i+h-1, n); //待归并序列中有一个长度小于h else for (k=i; k<=n; k++) //待归并序列中只剩一个子序列r1[k]=r[k];}//归并排序void MergeSort(int r[ ], int r1[ ], int n ){int h=1;int i;while (h<n){MergePass(r, r1, n-1, h); //归并h=2*h;MergePass(r1, r, n-1, h);h=2*h;}for(i=1;i<n;i++)cout<<r[i]<<" ";cout<<endl;}void Newarray(int a[],int b[],int c[]) {cout<<"新随机数组：";c[0]=0;a[0]=0;b[0]=0;for(int s=1;s<11;s++){a[s]=s;b[s]=20-s;c[s]=rand()%50+1;cout<<c[s]<<" ";}cout<<endl;}2.3 其他3. 程序运行结果void main(){srand(time(NULL));const int num=11; //赋值int a[num];int b[num];int c[num];int c1[num];c[0]=0;a[0]=0;b[0]=0;Newarray(a,b,c);cout<<"顺序数组：";for(int j=1;j<num;j++)cout<<a[j]<<" ";cout<<endl;cout<<"逆序数组：";for(j=1;j<num;j++)cout<<b[j]<<" ";cout<<endl;cout<<endl;cout<<"插入排序结果为："<<"\n";InsertSort(a,num);InsertSort(b,num);InsertSort(c,num);cout<<endl;Newarray(a,b,c);cout<<"希尔排序结果为："<<"\n";ShellSort(a, num);ShellSort(b, num);ShellSort(c, num);cout<<endl;Newarray(a,b,c);cout<<"起泡排序结果为："<<"\n";BubbleSort(a, num);BubbleSort(b, num);BubbleSort(c, num);cout<<endl;int count1=0,count2=0;Newarray(a,b,c);cout<<"快速排序结果为："<<"\n";QuickSort(a,0,num-1,count1,count2);for(int i=1;i<num;i++)cout<<a[i]<<" ";cout<<endl;cout<<"比较次数为"<<count1<<" 移动次数为"<<count2<<endl; count1=0,count2=0;QuickSort(b,0,num-1,count1,count2);for(i=1;i<num;i++)cout<<b[i]<<" ";cout<<endl;cout<<"比较次数为"<<count1<<" 移动次数为"<<count2<<endl; count1=0,count2=0;QuickSort(c,0,num-1,count1,count2);for(i=1;i<num;i++)cout<<c[i]<<" ";cout<<endl;cout<<"比较次数为"<<count1<<" 移动次数为"<<count2<<endl;cout<<endl;cout<<endl;Newarray(a,b,c);cout << "简单选择排序结果为：" << "\n";SelectSort(a,num);SelectSort(b,num);SelectSort(c,num);cout<<endl;Newarray(a,b,c);cout << "堆排序结果为：" << "\n";HeapSort(a, num);HeapSort(b, num);HeapSort(c, num);cout<<endl;Newarray(a,b,c);cout << "归并排序结果为：" << "\n";MergeSort(a, c1,num );MergeSort(b, c1,num );MergeSort(c, c1,num );}。

(完整)数据结构(C语言版)实验报告 (内部排序算法比较)

(完整)数据结构(C语言版)实验报告 (内部排序算法比较)编辑整理：尊敬的读者朋友们：这里是精品文档编辑中心，本文档内容是由我和我的同事精心编辑整理后发布的，发布之前我们对文中内容进行仔细校对，但是难免会有疏漏的地方，但是任然希望（(完整)数据结构(C语言版)实验报告 (内部排序算法比较)）的内容能够给您的工作和学习带来便利。

同时也真诚的希望收到您的建议和反馈，这将是我们进步的源泉，前进的动力。

本文可编辑可修改，如果觉得对您有帮助请收藏以便随时查阅，最后祝您生活愉快业绩进步，以下为(完整)数据结构(C语言版)实验报告 (内部排序算法比较)的全部内容。

《数据结构与算法》实验报告一、需求分析问题描述：在教科书中，各种内部排序算法的时间复杂度分析结果只给出了算法执行时间的阶，或大概执行时间。

试通过随机数据比较各算法的关键字比较次数和关键字移动次数,以取得直观感受.基本要求：(l)对以下6种常用的内部排序算法进行比较：起泡排序、直接插入排序、简单选择排序、快速排序、希尔排序、堆排序。

（2)待排序表的表长不小于100000；其中的数据要用伪随机数程序产生;至少要用5组不同的输入数据作比较;比较的指标为有关键字参加的比较次数和关键字的移动次数（关键字交换计为3次移动）。

（3)最后要对结果作简单分析，包括对各组数据得出结果波动大小的解释。

数据测试：二．概要设计1.程序所需的抽象数据类型的定义：typedef int BOOL; //说明BOOL是int的别名typedef struct StudentData ｛ int num; //存放关键字}Data； typedef struct LinkList { int Length; //数组长度Data Record[MAXSIZE］; //用数组存放所有的随机数} LinkList int RandArray［MAXSIZE]; //定义长度为MAXSIZE的随机数组void RandomNum（) //随机生成函数void InitLinkList(LinkList* L） //初始化链表BOOL LT(int i, int j,int* CmpNum） //比较i和j 的大小void Display（LinkList* L） //显示输出函数void ShellSort（LinkList* L， int dlta[]， int t,int＊ CmpNum, int* ChgNum) //希尔排序void QuickSort (LinkList＊L，int* CmpNum, int＊ChgNum) //快速排序void HeapSort （LinkList* L, int* CmpNum, int＊ChgNum) //堆排序void BubbleSort(LinkList＊L，int* CmpNum, int＊ChgNum) //冒泡排序void SelSort（LinkList* L, int* CmpNum，int＊ChgNum）//选择排序void Compare(LinkList* L,int＊CmpNum，int* ChgNum) //比较所有排序2 .各程序模块之间的层次（调用）关系：二、详细设计typedef int BOOL; //定义标识符关键字BOOL别名为int typedef struct StudentData //记录数据类型{int num； //定义关键字类型｝Data； //排序的记录数据类型定义typedef struct LinkList //记录线性表{int Length； //定义表长Data Record[MAXSIZE］; //表长记录最大值｝LinkList; //排序的记录线性表类型定义int RandArray[MAXSIZE］； //定义随机数组类型及最大值/＊＊*＊*＊＊**＊*＊****＊＊随机生成函数**＊＊*＊＊＊*＊＊＊＊＊＊*＊＊＊*/void RandomNum(){int i; srand（（int)time（NULL）)； //用伪随机数程序产生伪随机数for(i=0； i小于MAXSIZE； i++） RandArray[i］〈=(int）rand(）；返回；}/＊**＊＊＊*＊*＊*＊＊**＊*初始化链表＊＊**＊＊*＊＊＊*＊*＊***＊＊＊＊＊/void InitLinkList（LinkList＊ L） //初始化链表{int i；memset（L,0，sizeof(LinkList））；RandomNum();for(i=0； i小于〈MAXSIZE； i++)L—〉Record［i]。

数据结构实验报告-排序

数据结构实验报告-排序一、实验目的本实验旨在探究不同的排序算法在处理大数据量时的效率和性能表现，并对比它们的优缺点。

二、实验内容本次实验共选择了三种常见的排序算法：冒泡排序、快速排序和归并排序。

三个算法将在同一组随机生成的数据集上进行排序，并记录其性能指标，包括排序时间和所占用的内存空间。

三、实验步骤1. 数据的生成在实验开始前，首先生成一组随机数据作为排序的输入。

定义一个具有大数据量的数组，并随机生成一组在指定范围内的整数，用于后续排序算法的比较。

2. 冒泡排序冒泡排序是一种简单直观的排序算法。

其基本思想是从待排序的数据序列中逐个比较相邻元素的大小，并依次交换，从而将最大（或最小）的元素冒泡到序列的末尾。

重复该过程直到所有数据排序完成。

3. 快速排序快速排序是一种分治策略的排序算法，效率较高。

它将待排序的序列划分成两个子序列，其中一个子序列的所有元素都小于等于另一个子序列的所有元素。

然后对两个子序列分别递归地进行快速排序。

4. 归并排序归并排序是一种稳定的排序算法，使用分治策略将序列拆分成较小的子序列，然后递归地对子序列进行排序，最后再将子序列合并成有序的输出序列。

归并排序相对于其他算法的优势在于其稳定性和对大数据量的高效处理。

四、实验结果经过多次实验，我们得到了以下结果：1. 冒泡排序在数据量较小时，冒泡排序表现良好，但随着数据规模的增大，其性能明显下降。

排序时间随数据量的增长呈平方级别增加。

2. 快速排序相比冒泡排序，快速排序在大数据量下的表现更佳。

它的排序时间线性增长，且具有较低的内存占用。

3. 归并排序归并排序在各种数据规模下都有较好的表现。

它的排序时间与数据量呈对数级别增长，且对内存的使用相对较高。

五、实验分析根据实验结果，我们可以得出以下结论：1. 冒泡排序适用于数据较小的排序任务，但面对大数据量时表现较差，不推荐用于处理大规模数据。

2. 快速排序是一种高效的排序算法，适用于各种数据规模。

数据结构实验--各种排序算法的比较

实验题目：各种查找及排序算法比较实验内容：内部排序算法——插入排序（直接插入排序、折半插入排序）、交换排序（冒泡、快速排序）、选择排序（直接选择排序、堆排序）和归并排序（2-路归并排序）的具体实现。

目的与要求：掌握各种内部排序算法的特点，并对一整型数组排序，比较不同算法的速度。

实验算法：1）、数据结构描述：主函数中的a数组保存需要排序数组，将数组作为自变量输入到各种排序算法的函数中，各个函数返回值为排序之后的数组，在主函数中以一个循环体输出。

2）、函数和算法描述：主函数main先用循环体保存数组a，然后输出菜单，通过switch语句调用排序函数，将数组排序后输出。

InsertSort为直接插入排序对应的函数，并附有插入元素到数组的功能，函数主体是从数组第二个元素开始与其前的元素一一比较大小，并且插入到合适位置使得该元素的大小位于相邻元素之间。

BinsertSort为折半插入排序对应的函数，函数主体是在如上所述进行插入时，先比较待插入元素与其前的有序列的中心元素的大小关系，以此循环来判断插入位置。

BubbleSort为冒泡排序对应的函数，为二重循环结构，外循环每循环一次，决定出待排序部分的最大值并置于待排部分的末端，内循环对相邻两个元素大小作比较，进行调换。

Partition QuickSort为快速排序对应的函数，建有两个指针，从待排部分两端进行扫描，一次循环之后，将极大值和极小值各置于一端。

SelectMinKey SSSort为选择排序对应的函数，每循环一次，直接选出待排序部分中最小的元素并置于已排序部分之后，直至待排部分长度为0。

Merge MSort MergeSort为归并排序对应的函数，先将数组元素每两个一组并在组内排序，再将每两组和为一组进行排序，依次循环，直至分组长度与数组长度相同。

HeapAdjust HeapSort为堆排序对应的函数，通过循环，将数组调整为大顶堆形式，输出一次即可得到有序序列。

数据结构排序实验报告

数据结构排序实验报告1. 引言数据结构是计算机科学中的重要概念，它涉及组织和管理数据的方式。

排序算法是数据结构中的重要部分，它可以将一组无序的数据按照一定的规则进行重新排列，以便更容易进行搜索和查找。

在本实验中，我们将对不同的排序算法进行研究和实验，并对其性能进行评估。

2. 实验目的本实验旨在通过比较不同排序算法的性能，深入了解各算法的特点，从而选择最适合特定场景的排序算法。

3. 实验方法本实验使用C++编程语言实现了以下排序算法：冒泡排序、选择排序、插入排序、快速排序和归并排序。

为了评估这些算法的性能，我们设计了一组实验来测试它们在不同数据规模下的排序时间。

4. 实验过程4.1 数据生成首先，我们生成了一组随机的整数数据作为排序的输入。

数据规模从小到大递增，以便观察不同算法在不同规模下的性能差异。

4.2 排序算法实现接下来，我们根据实验要求，使用C++编程语言实现了冒泡排序、选择排序、插入排序、快速排序和归并排序。

每个算法被实现为一个独立的函数，并按照实验顺序被调用。

4.3 性能评估我们使用计时器函数来测量每个排序算法的执行时间。

在测试过程中，我们多次运行每个算法，取平均值以减小误差。

5. 实验结果我们将在不同数据规模下运行每个排序算法，并记录它们的执行时间。

下表展示了我们的实验结果：数据规模（n）冒泡排序选择排序插入排序快速排序归并排序1000 2ms 3ms 1ms 1ms 1ms5000 20ms 15ms 10ms 3ms 5ms10000 85ms 60ms 30ms 5ms 10ms50000 2150ms 1500ms 700ms 10ms 15ms从上表我们可以观察到，随着数据规模的增加，冒泡排序和选择排序的执行时间呈指数级增长，而插入排序、快速排序和归并排序的执行时间则相对较稳定。

此外，当数据规模较大时，快速排序和归并排序的性能远优于其他排序算法。

6. 实验结论根据实验结果，我们可以得出以下结论：- 冒泡排序和选择排序是简单但效率较低的排序算法，仅适用于较小规模的数据排序。

数据结构排序实验报告

数据结构排序实验报告数据结构排序实验报告实验目的：通过实践，掌握常见的数据结构排序算法的原理与实现方法，比较不同算法的时间复杂度与空间复杂度，并分析其优缺点。

实验环境：编程语言：Python运行平台：Windows 10实验内容：1. 插入排序 (Insertion Sort)2. 冒泡排序 (Bubble Sort)3. 快速排序 (Quick Sort)4. 选择排序 (Selection Sort)5. 归并排序 (Merge Sort)6. 堆排序 (Heap Sort)实验步骤：1. 实现各种排序算法的函数，并验证其正确性。

2. 构建不同规模的随机数数组作为输入数据。

3. 使用time库测量每种算法在不同规模数据下的运行时间。

4. 绘制时间复杂度与输入规模的关系图。

5. 对比分析各种算法的时间复杂度和空间复杂度。

实验结果：1. 插入排序的时间复杂度为O(n^2)，空间复杂度为O(1)。

2. 冒泡排序的时间复杂度为O(n^2)，空间复杂度为O(1)。

3. 快速排序的时间复杂度为O(nlogn)，空间复杂度为O(logn)。

4. 选择排序的时间复杂度为O(n^2)，空间复杂度为O(1)。

5. 归并排序的时间复杂度为O(nlogn)，空间复杂度为O(n)。

6. 堆排序的时间复杂度为O(nlogn)，空间复杂度为O(1)。

实验结论：1. 在小规模数据排序时，插入排序和冒泡排序由于其简单性和稳定性可以采用。

2. 在大规模数据排序时，快速排序、归并排序和堆排序由于其较低的时间复杂度可以采用。

3. 选择排序由于其时间复杂度较高，不适合用于大规模数据排序。

4. 归并排序由于其需要额外的空间存储中间结果，空间复杂度较高。

5. 快速排序由于其递归调用栈的使用，时间复杂度虽然较低，但空间复杂度较高。

综上所述，选择排序、插入排序和冒泡排序适用于小规模数据排序，而归并排序、快速排序和堆排序适用于大规模数据排序。

《数据结构》实验报告——排序

《数据结构》实验报告排序实验题目：输入十个数，从插入排序，快速排序，选择排序三类算法中各选一种编程实现。

实验所使用的数据结构内容及编程思路：1.插入排序：直接插入排序的基本操作是，将一个记录到已排好序的有序表中，从而得到一个新的，记录增一得有序表。

一般情况下，第i趟直接插入排序的操作为：在含有i-1个记录的有序子序列r［1..i-1］中插入一个记录r［i］后，变成含有i个记录的有序子序列r［1..i］；并且，和顺序查找类似，为了在查找插入位置的过程中避免数组下标出界，在r［0］处设置哨兵。

在自i-1起往前搜索的过程中，可以同时后移记录。

整个排序过程为进行n-1趟插入，即：先将序列中的第一个记录看成是一个有序的子序列，然后从第2个记录起逐个进行插入，直至整个序列变成按关键字非递减有序序列为止。

2.快速排序：基本思想是，通过一趟排序将待排记录分割成独立的两部分，其中一部分记录的关键字均比另一部分记录的关键字小，则可分别对这两部分记录继续进行排序，以达到整个序列有序。

假设待排序的序列为{L.r[s]，L.r[s+1],…L.r[t]},首先任意选取一个记录(通常可选第一个记录L.r[s])作为枢轴（或支点）（pivot），然后按下述原则重新排列其余记录：将所有关键字较它小的记录都安置在它的位置之前，将所有关键字较大的记录都安置在它的位置之后。

由此可以该“枢轴”记录最后所罗的位置i作为界线，将序列{L.r[s]，…，L.r[t]}分割成两个子序列{L.r[i+1],L.[i+2],…,L.r[t]}。

这个过程称为一趟快速排序，或一次划分。

一趟快速排序的具体做法是：附设两个指针low和high，他们的初值分别为low和high，设枢轴记录的关键字为pivotkey，则首先从high所指位置起向前搜索找到第一个关键字小于pivotkey的记录和枢轴记录互相交换，然后从low所指位置起向后搜索，找到第一个关键字大于pivotkey的记录和枢轴记录互相交换，重复这两不直至low=high为止。

数据结构试验报告——各种内排序算法的实现及性能比较

实验报告（2010 / 2011 学年第 2 学期）课程名称数据结构——使用C++语言描述实验名称各种内排序算法的实现及性能比较实验时间2011年5月27日指导单位计算机科学与技术系指导教师学生姓名班级学号学院(系)专业一．实验目的和要求内容：验证教材的各种内排序算法。

分析各种排序算法的时间复杂度。

要求：使用随机数产生器产生大数据集合，运行上述各种排序算法，使用系统时钟测量各算法所需的实际时间，并进行比较。

二．实验环境（实验设备）Visual C++三．实验原理及内容单选择排序"<<endl;接插入排序"<<endl;泡排序"<<endl;速排序"<<endl;路合并排序"<<endl;排序"<<endl;出"<<endl;cout<<"PS：测试用的数组元素为"<<SIZE<<"时间为重复运行"<<TIMES<<"次的时间（包括了产生数据与析构的时间）"<<endl;this->switcha();}template <class T>void Menu<T>::childmenu(){cout<<"--------------------------------------------------------"<<endl;cout<<"1.最好情况"<<endl;cout<<"2.最坏情况"<<endl;cout<<"3.平均情况"<<endl;cout<<"4.返回主菜单"<<endl;cin>>b;if(b==4)this->printmenu();}template<class T>void Menu<T>::childmenu2(){cout<<"--------------------------------------------------------"<<endl;cout<<"1.原始算法"<<endl;cout<<"2.改进算法"<<endl;cout<<"3.返回主菜单"<<endl;cin>>c;if(c==3)this->printmenu();}template <class T>void Menu<T>::switcha(){<<endl;return 0;}/*ok--------------------------------------------------------内排序测试系统--------------------------------------------------------1.简单选择排序2.直接插入排序3.冒泡排序4.快速排序5.两路合并排序6.堆排序7.退出PS：测试用的数组元素为400时间为重复运行1000次的时间（包括了产生数据与析构的时间）ok1简单选择排序直接用随机数据测试ok用时：请按任意键继续. . .--------------------------------------------------------内排序测试系统--------------------------------------------------------1.简单选择排序2.直接插入排序3.冒泡排序4.快速排序5.两路合并排序6.堆排序7.退出PS：测试用的数组元素为400时间为重复运行1000次的时间（包括了产生数据与析构的时间）ok2直接插入排序--------------------------------------------------------1.最好情况2.最坏情况3.平均情况4.返回主菜单1ok用时：0请按任意键继续. . .直接插入排序--------------------------------------------------------1.最好情况2.最坏情况3.平均情况4.返回主菜单2ok用时：请按任意键继续. . .直接插入排序--------------------------------------------------------1.最好情况2.最坏情况3.平均情况4.返回主菜单3ok用时：请按任意键继续. . .直接插入排序--------------------------------------------------------1.最好情况2.最坏情况3.平均情况4.返回主菜单4--------------------------------------------------------内排序测试系统--------------------------------------------------------1.简单选择排序2.直接插入排序3.冒泡排序4.快速排序5.两路合并排序6.堆排序7.退出PS：测试用的数组元素为400时间为重复运行1000次的时间（包括了产生数据与析构的时间）ok3冒泡排序--------------------------------------------------------1.最好情况2.最坏情况3.平均情况4.返回主菜单1ok用时：请按任意键继续. . .冒泡排序--------------------------------------------------------1.最好情况2.最坏情况3.平均情况4.返回主菜单2ok用时：请按任意键继续. . .冒泡排序--------------------------------------------------------1.最好情况2.最坏情况3.平均情况4.返回主菜单3ok用时：请按任意键继续. . .冒泡排序--------------------------------------------------------1.最好情况2.最坏情况3.平均情况4.返回主菜单4--------------------------------------------------------内排序测试系统--------------------------------------------------------1.简单选择排序2.直接插入排序3.冒泡排序4.快速排序5.两路合并排序6.堆排序7.退出PS：测试用的数组元素为400时间为重复运行1000次的时间（包括了产生数据与析构的时间）ok4--------------------------------------------------------1.原始算法2.改进算法3.返回主菜单1原始快速排序直接用随机数据测试ok用时：请按任意键继续. . .--------------------------------------------------------1.原始算法2.改进算法3.返回主菜单2改进的快速排序直接用随机数据测试ok用时：请按任意键继续. . .--------------------------------------------------------1.原始算法2.改进算法3.返回主菜单3--------------------------------------------------------内排序测试系统--------------------------------------------------------1.简单选择排序2.直接插入排序3.冒泡排序4.快速排序5.两路合并排序6.堆排序7.退出PS：测试用的数组元素为400时间为重复运行1000次的时间（包括了产生数据与析构的时间）ok5合并排序直接用随机数据测试ok用时：请按任意键继续. . .--------------------------------------------------------内排序测试系统--------------------------------------------------------1.简单选择排序2.直接插入排序3.冒泡排序4.快速排序5.两路合并排序6.堆排序7.退出PS：测试用的数组元素为400时间为重复运行1000次的时间（包括了产生数据与析构的时间）ok6堆排序直接用随机数据测试ok用时：请按任意键继续. . .--------------------------------------------------------内排序测试系统--------------------------------------------------------1.简单选择排序2.直接插入排序3.冒泡排序4.快速排序5.两路合并排序6.堆排序7.退出PS：测试用的数组元素为400时间为重复运行1000次的时间（包括了产生数据与析构的时间）ok7Press any key to continue*/四．实验小结（包括问题解和解决方法、心得体会、意见与建议等）通过本次实验对教材上的各种内排序算法进行了逐一验证。

数据结构实验报告排序

数据结构实验报告排序数据结构实验报告：排序引言：排序是计算机科学中常见的算法问题之一，它的目标是将一组无序的数据按照特定的规则进行排列，以便于后续的查找、统计和分析。

在本次实验中，我们将学习和实现几种常见的排序算法，并对它们的性能进行比较和分析。

一、冒泡排序冒泡排序是最简单的排序算法之一，它通过不断交换相邻的元素，将较大（或较小）的元素逐渐“冒泡”到数组的一端。

具体实现时，我们可以使用两层循环来比较和交换元素，直到整个数组有序。

二、插入排序插入排序的思想是将数组分为两个部分：已排序部分和未排序部分。

每次从未排序部分中取出一个元素，插入到已排序部分的适当位置，以保持已排序部分的有序性。

插入排序的实现可以使用一层循环和适当的元素交换。

三、选择排序选择排序每次从未排序部分中选择最小（或最大）的元素，与未排序部分的第一个元素进行交换。

通过不断选择最小（或最大）的元素，将其放置到已排序部分的末尾，从而逐渐形成有序序列。

四、快速排序快速排序是一种分治的排序算法，它通过选择一个基准元素，将数组划分为两个子数组，其中一个子数组的所有元素都小于等于基准元素，另一个子数组的所有元素都大于基准元素。

然后对两个子数组分别递归地进行快速排序，最终将整个数组排序。

五、归并排序归并排序也是一种分治的排序算法，它将数组划分为多个子数组，对每个子数组进行排序，然后再将排好序的子数组合并成一个有序的数组。

归并排序的实现可以使用递归或迭代的方式。

六、性能比较与分析在本次实验中，我们对以上几种排序算法进行了实现，并通过对不同规模的随机数组进行排序，比较了它们的性能。

我们使用了计算排序时间的方式，并记录了每种算法在不同规模下的运行时间。

通过对比实验结果，我们可以得出以下结论：1. 冒泡排序和插入排序在处理小规模数据时表现较好，但在处理大规模数据时性能较差，因为它们的时间复杂度为O(n^2)。

2. 选择排序的时间复杂度也为O(n^2)，与冒泡排序和插入排序相似，但相对而言，选择排序的性能稍好一些。

数据结构实验快速排序

数据结构实验快速排序快速排序（Quicksort）是一种常用的排序算法，其基本思想是通过一趟排序将待排序序列分割成独立的两部分，其中一部分的所有元素小于等于基准值，而另一部分的所有元素大于等于基准值，然后再对这两部分分别进行快速排序，以达到整个序列有序的目的。

本文将详细介绍快速排序的实现步骤，包括选择基准值、划分操作和递归排序等。

一、选择基准值在快速排序中，我们需要选择一个基准值。

基准值的选择可以影响快速排序的效率，一般选择待排序序列的第一个元素作为基准值。

二、划分操作划分操作是快速排序的核心步骤之一。

在划分操作中，我们需要将待排序序列划分成两部分，一部分的元素小于等于基准值，另一部分的元素大于等于基准值。

具体的划分操作步骤如下：1.设置左右两个指针，分别指向待排序序列的第一个和最后一个元素。

2.左指针向右移动，直到遇到大于等于基准值的元素。

3.右指针向左移动，直到遇到小于等于基准值的元素。

4.如果左指针小于等于右指针，则交换左右指针所指向的元素，并将左指针右移、右指针左移。

5.重复步骤2~4，直到左指针大于右指针。

三、递归排序在划分操作之后，我们得到了两个独立的子序列。

接下来，我们需要将这两个子序列分别进行递归排序，以达到整个序列有序的目的。

具体的递归排序步骤如下：1.如果待排序序列的长度大于1，则进行以下操作：a.以基准值将序列划分成两部分。

b.对左子序列进行递归排序。

c.对右子序列进行递归排序。

2.合并左右子序列和基准值，得到有序序列。

法律名词及注释：1.版权：指对作品享有的全部权利的法律保护，包括复制权、发行权、出租权、表演权、展览权、改编权等。

2.专利：指为了鼓励技术创新而给予的一种专有权，以防止他人在一定时期内未经许可制造、使用或销售该技术。

3.商标：指用来区分企业的产品或服务与其他企业产品或服务的标识，如商标名称、商标图案等。

附件：本文档涉及的附件包括代码示例、示意图等。

数据结构实验报告：内部排序算法比较

# include "stdlib.h"
# define OVERFLOW -2
typedef struct
{ int * elem;
int length;
}SqList;
SqList create(int n)//建立一个顺序表
{ SqList L;
L.elem = (int *)malloc( n*sizeof(int));
T=QuickSort(T);
printf("排序后数据如下：\n");
for(int k=2;k<=n;k++)
printf("%6d",T.elem[k]);
printf("\n");
do
{ printf("如果想继续验证请输入Y或y,否则输入N或n：\n\n");
scanf("%s",&yes_no);
实验报告
课程名称：数据结构实验名称：内部排序算法比较任课教师：
专业:计网类班级:2007级1班学号：
姓名：___________完成日期：2008年12月30日
一、实验目的：
掌握主要排序算法的基本思想，包括插入排序、冒泡排序、快速排序、直接选择排序、堆排序、归并排序及基数排序；掌握以上排序算法的实现方法；对各种算法的效率进行比较。
printf("%6d",L.elem[k]);
printf("\n");
}
} // InsertSort
void main()
{ SqList T;
int n=0,k,flag=0;
char yes_no;

各排序算法实验报告(3篇)

第1篇一、实验目的本次实验旨在通过编程实现几种常见的排序算法，并对其进行性能分析，以加深对排序算法原理的理解，掌握不同排序算法的适用场景，提高算法设计能力。

二、实验内容本次实验选择了以下几种排序算法：冒泡排序、插入排序、快速排序、归并排序、希尔排序、选择排序和堆排序。

以下是对每种算法的简要介绍和实现：1. 冒泡排序（Bubble Sort）冒泡排序是一种简单的排序算法，它重复地遍历要排序的数列，一次比较两个元素，如果它们的顺序错误就把它们交换过来。

遍历数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。

```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. 插入排序（Insertion Sort）插入排序是一种简单直观的排序算法。

它的工作原理是通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入。

```cvoid insertionSort(int arr[], int n) {int i, key, j;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;}}```3. 快速排序（Quick Sort）快速排序是一种分而治之的排序算法。

它将原始数组分成两个子数组，一个包含比基准值小的元素，另一个包含比基准值大的元素，然后递归地对这两个子数组进行快速排序。

(完整word版)数据结构课程设计-排序算法比较【完整版】(word文档良心出品)

XXXXXX大学《数据结构》课程设计报告目录排序算法比较一、需求分析二、程序的主要功能三、程序运行平台四、数据结构五、算法及时间复杂度六、测试用例七、程序源代码二感想体会与总结排序算法比较一、需求分析利用随机函数产生N个随机整数（N = 500, 1000, 1500, 2000,2500, …,30000）, 利用直接插入排序、折半插入排序, 起泡排序、快速排序、选择排序、堆排序, 基数排序七种排序方法（可添加其它排序方法）进行排序（结果为由小到大的顺序）, 并统计每一种排序所耗费的时间（统计为图表坐标形式）。

二、程序的主要功能1.用户输入任意个数, 产生相应的随机数2.用户可以自己选择排序方式（直接插入排序、折半插入排序、起泡排序、快速排序、选择排序、堆排序、基数排序）的一种3.程序给出原始数据、排序后从小到大的数据, 并给出排序所用的时间。

三、程序运行平台Visual C++ 6.0版本四、数据结构本程序的数据结构为线形表, 线性顺序表、线性链表。

1.结构体:typedef struct{int *r; //r指向线形表的第一个结点。

r[0]闲置, 不同的算法有不同的用处, 如用作哨兵等。

int length; //顺序表的总长度}Sqlist;2.空线性表Status InitSqlist(Sqlist &L){L.r=(int *)malloc(MAXSIZE*sizeof(int)); //分配存储空间if(!L.r){printf("存储分配失败！");exit(0);} //存储分配失败L.length=0;//初始长度为0return OK;}五、算法及时间复杂度（一）各个排序是算法思想:（1）直接插入排序: 将一个记录插入到已排好的有序表中, 从而得到一个新的, 记录数增加1的有序表。

（2）折半插入排序: 插入排序的基本插入是在一个有序表中进行查找和插入, 这个查找可利用折半查找来实现, 即为折半插入排序。

(效率管理)数据结构实验(排序算法效率比较平台)

《数据结构》课程实验实验报告题目：内部排序算法效率比较平台的设计与实现专业：计算机科学与技术班级：姓名：学号：完成日期：一、试验内容各种内部排序算法的时间复杂度分析结果只给出了算法执行时间的阶，或大概执行时间。

设计和实现内部排序算法效率比较平台，通过随机的数据比较各算法的关键字比较次数和关键字移动次数，以取得直观的感受。

二、试验目的掌握多种排序方法的基本思想，如直接插入、冒泡、简单选择、快速、堆、希尔排序等排序方法，并能够用高级语言实现。

三、源程序代码#include<iostream.h>#include<string.h>#include<stdlib.h>#define le 100struct point{char key[11];};//冒泡法void maopao(point c[]){point a,b[le];int i,j,jh=0,bj=0,q;for(i=0;i<le;i++){b[i]=c[i];};for(i=0;i<le;i++){for(j=le-1;j>i;j--){bj=bj+1;q=strcmp(b[i].key,b[j].key);if(q==1){a=b[i];b[i]=b[j];b[j]=a;jh=jh+3;};};};cout<<"冒泡法:"<<endl<<"完成的序列如下:"<<endl;for(i=0;i<le;i++){cout<<b[i].key<<" ";};cout<<endl<<"共进行比较"<<bj<<"次,进行交换"<<jh<<"次"<<endl<<"***************************"<<endl;};//直接插入排序void zhijiecharu(point c[]){point b[le+1];int i,j,jh=0,bj=0,q;for(i=0;i<le;i++){b[i+1]=c[i];};for(i=2;i<=le+1;i++){q=strcmp(b[i].key,b[i-1].key);bj=bj+1;if(q==-1){b[0]=b[i];b[i]=b[i-1];jh=jh+2;q=strcmp(b[0].key,b[i-2].key);bj=bj+1;for(j=i-2;q==-1;j--){b[j+1]=b[j];jh=jh+1;q=strcmp(b[0].key,b[j-1].key);bj=bj+1;};b[j+1]=b[0];jh=jh+1;};};cout<<"直接插入排序:"<<endl<<"完成的序列如下:"<<endl;for(i=1;i<le+1;i++){cout<<b[i].key<<" ";};cout<<endl<<"共进行比较"<<bj<<"次,进行交换"<<jh<<"次"<<endl<<"***************************"<<endl;};//void shellinsert(point c[],int dk,int d[]){int j,i,q;point a;for(i=dk+1;i<le+1;i++){q=strcmp(c[i].key,c[i-dk].key);d[0]=d[0]+1;if(q==-1){a=c[i];q=strcmp(a.key,c[i-dk].key);d[0]=d[0]+1;d[1]=d[1]+1;for(j=i-dk;j>0&&q==-1;j=j-dk){c[j+dk]=c[j];d[1]=d[1]+1;q=strcmp(a.key,c[j-dk].key);};c[j+dk]=a;d[1]=d[1]+1;};};};void shellsort(point c[],int dlta[],int t){int k,d[2],i;d[0]=0;d[1]=0;point b[le+1];for(k=0;k<le;k++){b[k+1]=c[k];};for(k=0;k<t;k++)shellinsert(b,dlta[k],d);cout<<"希尔排序:"<<endl<<"完成的序列如下:"<<endl;for(i=1;i<le+1;i++){cout<<b[i].key<<" ";};cout<<endl<<"共进行比较"<<d[0]<<"次,进行交换"<<d[1]<<"次"<<endl<<"***************************"<<endl;};//希尔排序void xier(point c[]){int dlta[20],t,i;t=le/2;for(i=0;i<20;i++){dlta[i]=t+1;if(t==0)break;t=t/2;};t=i+1;shellsort(c,dlta,t);};//简单选择排序void jiandanxuanze(point c[]){point a,b[le];int i,j,jh=0,bj=0,q,w;for(i=0;i<le;i++){b[i]=c[i];};for(i=0;i<le-1;i++){q=i;for(j=i+1;j<le;j++){bj=bj+1;w=strcmp(b[q].key,b[j].key);if(w==1)q=j;};if(q==i)continue;else {a=b[i];b[i]=b[q];b[q]=a;jh=jh+3;};};cout<<"简单选择排序排序:"<<endl<<"完成的序列如下:"<<endl;for(i=0;i<le;i++){cout<<b[i].key<<" ";};cout<<endl<<"共进行比较"<<bj<<"次,进行交换"<<jh<<"次"<<endl<<"***************************"<<endl;};int partition(point c[],int low,int high,int d[]){point a,b;int jh=0,bj=0,q;a=c[low];while(low<high){q=strcmp(c[high].key,a.key);d[0]=d[0]+1;while(low<high&&q!=-1){high--;q=strcmp(c[high].key,a.key);d[0]=d[0]+1;};b=c[low];c[low]=c[high];c[high]=b;d[1]=d[1]+3;q=strcmp(c[low].key,a.key);d[0]=d[0]+1;while(low<high&&q!=1){low++;q=strcmp(c[low].key,a.key);d[0]=d[0]+1;};b=c[low];c[low]=c[high];c[high]=b;d[1]=d[1]+3;};return(low);};void qsort(point c[],int low,int high,int d[]){int pivotloc;if(low<high){pivotloc=partition(c,low,high,d);qsort(c,low,pivotloc-1,d);qsort(c,pivotloc+1,high,d);};};//快速排序void kuaisu(point c[]){point b[le];int i,d[2];d[0]=0;d[1]=0;for(i=0;i<le;i++){b[i]=c[i];};qsort(b,0,le-1,d);cout<<"快速排序:"<<endl<<"完成的序列如下:"<<endl;for(i=0;i<le;i++){cout<<b[i].key<<" ";};cout<<endl<<"共进行比较"<<d[1]<<"次,进行交换"<<d[0]<<"次"<<endl<<"***************************"<<endl;};void diu(point b[],int we,int *jh,int *bj){point a;int i,q;for(i=we/2-1;i>=0;i--){q=strcmp(b[i].key,b[2*i].key);*bj=*bj+1;if(q==-1){a=b[i];b[i]=b[2*i];b[2*i]=a;*jh=*jh+3;};if(2*i+1<we){q=strcmp(b[i].key,b[2*i+1].key);*bj=*bj+1;if(q==-1){a=b[i];b[i]=b[2*i+1];b[2*i+1]=a;*jh=*jh+3;};};};a=b[we-1];b[we-1]=b[0];b[0]=a;*jh=*jh+3;};//堆排序void diup(point c[]){point b[le];int i,jh=0,bj=0,*j,*bl;j=&jh;bl=&bj;for(i=0;i<le;i++){b[i]=c[i];};for(i=le;i>1;i--){diu(b,i,j,bl);};cout<<"堆排序:"<<endl<<"完成的序列如下:"<<endl;for(i=0;i<le;i++){cout<<b[i].key<<" ";};cout<<endl<<"共进行比较"<<bj<<"次,进行交换"<<jh<<"次"<<endl<<"***************************"<<endl;};void main(){int i,j,n=10,ans,an;char b[]="abcdefghijklmnopqrstuvwxyz";point a[le];for(i=0;i<le;i++){n=10;an=rand()*(n-1)/RAND_MAX+1;n=26;for(j=0;j<an;j++){ans=rand()*(n-0)/RAND_MAX+0;a[i].key[j]=b[ans];};a[i].key[j]='\0';};for(i=0;i<le;i++){cout<<a[i].key<<endl;};zhijiecharu(a);maopao(a);xier(a);jiandanxuanze(a);kuaisu(a);diup(a);};四、流程图五、调试过程要很好的理解各种算法就可以这样才可以编出程序来，要注意比较次数和交换次数的计数问题。

数据结构课程设计实验报告(各种排序的实现与效率分析)

数据结构课程设计实验报告1、需求分析(1)对起泡排序、直接排序、简单选择排序、快速排序、希尔排序、堆排序算法进行比较；(2)待排序表的表长不小于100，表中数据随机产生，至少用5组不同数据作比较，比较指标有：关键字参加比较次数和关键字的移动次数（关键字进行一次交换操作记为3次移动）；(3)输出比较结果。

2、主要函数及数据类型typedef int KeyType; //定义关键字类型为整数类型typedef int InfoType; //定义关键字类型为整数类型typedef int Status; /* Status是函数的类型,其值是函数结果状态代码，如OK等*/typedef int Boolean; /* Boolean是布尔类型,其值是TRUE或FALSE */typedef struct{KeyType key; //关键字项InfoType otherinfo; //其它数据项}RedType; //记录类型typedef struct {RedType r[MAXSIZE+1]; //r[0]闲置或用作哨兵单元int length; //顺序表长度}SqList; //顺序表类型3、源代码/*头文件和宏定义部分*/#include"string.h"#include"ctype.h"#include"time.h"#include"malloc.h" /* malloc()等*/#include"limits.h" /* INT_MAX等*/#include"stdio.h" /* EOF(=^Z或F6),NULL */#include"stdlib.h" /* atoi() */#include"io.h" /* eof() */#include"math.h" /* floor(),ceil(),abs() */#include"process.h" /* exit() *//* 函数结果状态代码*/#define TRUE 1#define FALSE 0#define OK 1#define ERROR 0#define INFEASIBLE -1#define MAXSIZE 100 //示例数据类型的最大长度typedef int KeyType; //定义关键字类型为整数类型typedef int InfoType; //定义关键字类型为整数类型typedef int Status; /* Status是函数的类型,其值是函数结果状态代码，如OK等*/ typedef int Boolean; /* Boolean是布尔类型,其值是TRUE或FALSE */typedef struct{KeyType key; //关键字项InfoType otherinfo; //其它数据项}RedType; //记录类型typedef struct {RedType r[MAXSIZE+1]; //r[0]闲置或用作哨兵单元int length; //顺序表长度}SqList; //顺序表类型void InitData(SqList *L,int dataCopy[]){int i;L->length=MAXSIZE;srand((unsigned)time(NULL));for(i=0;i<=MAXSIZE;i++){L->r[i].otherinfo=0;dataCopy[i]=L->r[i].key=rand();}}void PrintData(SqList L){int i;for(i=1;i<=L.length;i++){printf("%d\t",L.r[i].key);}}void ResumeData(SqList *L,int dataCopy[]){int i;for(i=0;i<=MAXSIZE;i++){L->r[i].key=dataCopy[i];}}void PrintStatistic(int *compareCounts,int *moveCounts){printf("\n\t\t各种排序方法比较结果:\n\n");printf("\t\t起泡排序: 比较次数%d,移动次数%d\n",compareCounts[0],moveCounts[0]);printf("\t\t直接插入排序:比较次数%d,移动次数%d\n",compareCounts[1],moveCounts[1]);printf("\t\t简单选择排序:比较次数%d,移动次数%d\n",compareCounts[2],moveCounts[2]);printf("\t\t快速排序: 比较次数%d,移动次数%d\n",compareCounts[3],moveCounts[3]);printf("\t\t希尔排序: 比较次数%d,移动次数%d\n",compareCounts[4],moveCounts[4]);printf("\t\t堆排序: 比较次数%d,移动次数%d\n",compareCounts[5],moveCounts[5]);}/*******************************直接插入排序*******************************/void InsertSort(SqList *L,int *compareCounts,int *moveCounts ) //直接插入排序{int i,j; //for(i=2;i<=L->length;i++) //从顺序表的第二个元素开始进行比较{if(L->r[i].key<L->r[i-1].key) //将每个元素与它的前一个元素关键字进行比较{L->r[0]=L->r[i]; //如果关键字比前一个元素关键字小，就将元素复制作为哨兵L->r[i]=L->r[i-1];(*moveCounts)+=2; //关键字移动了2次j=i-2; //从要比较的关键字的前第二个记录开始进行比较,然后后移while(L->r[0].key<L->r[j].key){L->r[j+1]=L->r[j]; //记录后移(*moveCounts)++; //每作一次后移,移动次数加1j--;(*compareCounts)++; //每作一次比较，比较次数加1}L->r[j+1]=L->r[0]; //插入到正确位置}(*compareCounts)++;}}/*******************************希尔排序*******************************/void ShellInsert(SqList *L,int increment,int *compareCounts,int *moveCounts){ //对顺序表作一趟希尔插入排序int j,n;for(j=1+increment;j<=L->length;j++){if(L->r[j].key<L->r[j-increment].key) //将L->[i]插入到有序增量子表{L->r[0]=L->r[j]; //暂存在L->r[0]L->r[j]=L->r[j-increment];(*moveCounts)+=2;for(n=j-2*increment;n>0&&L->r[0].key<L->r[n].key;n-=increment){L->r[n+increment]=L->r[n]; //记录后移，查找插入位置(*moveCounts)++;(*compareCounts)++;}L->r[n+increment]=L->r[0]; //插入(*moveCounts)++;}(*compareCounts)++;}}void ShellSort(SqList *L,int IncreList[],int times,int *compareCounts,int *moveCounts) //希尔排序{ //按增量序列Increlist［0.....times-1］对顺序表Ｌ作希尔排序int k; //for(k=0;k<times;k++){ShellInsert(L,IncreList[k],compareCounts,moveCounts); //一趟增量为IncreList[k]的插入排序}}/*******************************起泡排序*******************************/void BubbleSort(SqList *L,int *compareCounts,int *moveCounts) //起泡排序{int i,j;for(i=1;i<=L->length;i++){for(j=L->length;j>i;j--){ //从后往前两两进行比较，将元素关键字小的交换到前面if(L->r[j].key<L->r[j-1].key){L->r[0]=L->r[j];L->r[j]=L->r[j-1];L->r[j-1]=L->r[0];(*moveCounts)+=3;}(*compareCounts)++;}}}/*******************************快速排序*******************************/int Partition(SqList *L,int low,int high,int *compareCounts,int *moveCounts) //快速排序中的分{int pivotkey;L->r[0]=L->r[low];(*moveCounts)++;pivotkey=L->r[low].key;while(low<high){while(low<high&&L->r[high].key>=pivotkey){high--;(*compareCounts)++;}L->r[low]=L->r[high];(*moveCounts)++;while(low<high&&L->r[low].key<=pivotkey){low++;(*compareCounts)++;}L->r[high]=L->r[low];(*moveCounts)++;(*compareCounts)++;}L->r[low]=L->r[0];(*moveCounts)++;return low;}void QSort(SqList *L,int low,int high,int *compareCounts,int *moveCounts){int pivotloc;if(low<high){pivotloc=Partition(L,low,high,compareCounts,moveCounts);QSort(L,low,pivotloc-1,compareCounts,moveCounts);QSort(L,pivotloc+1,high,compareCounts,moveCounts);}}void QuickSort(SqList *L,int *compareCounts,int *moveCounts){QSort(L,1,L->length,compareCounts,moveCounts);}/*******************************简单选择排序*******************************/void SelectSort(SqList *L,int *compareCounts,int *moveCounts){int i,j,minPoint;for(i=1;i<=L->length;i++){L->r[0]=L->r[i];(*moveCounts)++;minPoint=i;for(j=i+1;j<=L->length;j++){if(L->r[j].key<L->r[0].key){L->r[0]=L->r[j];(*moveCounts)++;minPoint=j;}(*compareCounts)++;}L->r[minPoint]=L->r[i];L->r[i]=L->r[0];(*moveCounts)++;}}/*******************************堆排序*******************************/void HeapAdjust(SqList *L,int s,int m,int *compareCounts,int *moveCounts){RedType cmpKey; //待比较的值int j;cmpKey=L->r[s];(*moveCounts)++;for(j=s*2;j<=m;j*=2){(*compareCounts)+=2;if(j<m&&L->r[j].key<L->r[j+1].key) j++;if(!(cmpKey.key<L->r[j].key)) break;L->r[s]=L->r[j];(*moveCounts)++;s=j;}L->r[s]=cmpKey;(*moveCounts)++;}void HeapSort(SqList *L,int *compareCounts,int *moveCounts){int i;RedType temp;for(i=L->length/2;i>0;i--) HeapAdjust(L,i,L->length,compareCounts,moveCounts);for(i=L->length;i>1;i--){temp=L->r[1];L->r[1]=L->r[i];L->r[i]=temp;(*moveCounts)+=3;HeapAdjust(L,1,i-1,compareCounts,moveCounts);}}void SortCompare(){SqList L; //用顺序表存放待排序的元素int dataCopy[MAXSIZE+1],i;int compareCounts[7],moveCounts[7];int increList[6];for(i=0;i<5;i++){increList[i]=(int)pow(2,7-i)-1;}increList[5]=1;for(i=0;i<7;i++){compareCounts[i]=0;moveCounts[i]=0;}InitData(&L,dataCopy); //初始化数据，随机产生100个正整数的数列printf("\t\t\t初始化数据后产生的数列:\n");PrintData(L); //显示出未排序的数列printf("\n\n\t\t\t经过起泡排序后产生的数列:\n");BubbleSort(&L,&compareCounts[0],&moveCounts[0]); //对数列使用起泡排序PrintData(L); //显示出排序好的数列ResumeData(&L,dataCopy);printf("\n\n\t\t\t经过直接插入排序后产生的数列:\n");InsertSort(&L,&compareCounts[1],&moveCounts[1]); //对数列使用插入排序PrintData(L); //显示出排序好的数列ResumeData(&L,dataCopy);printf("\n\n\t\t\t经过简单选择排序后产生的数列:\n");SelectSort(&L,&compareCounts[2],&moveCounts[2]); //对数列使用简单选择排序PrintData(L); //显示出排序好的数列ResumeData(&L,dataCopy);printf("\n\n\t\t\t经过快速排序后产生的数列:\n");QuickSort(&L,&compareCounts[3],&moveCounts[3]); //对数列使用快速排序PrintData(L); //显示出排序好的数列ResumeData(&L,dataCopy);printf("\n\n\t\t\t经过希尔排序后产生的数列:\n");ShellSort(&L,increList,6,&compareCounts[4],&moveCounts[4]); //对数列使用希尔排序PrintData(L); //显示出排序好的数列ResumeData(&L,dataCopy);printf("\n\n\t\t\t经过堆排序后产生的数列:\n");HeapSort(&L,&compareCounts[5],&moveCounts[5]); //对数列使用堆排序PrintData(L); //显示出排序好的数列PrintStatistic(compareCounts,moveCounts);}main(){int i,temp;for(i=0;i<5;i++){SortCompare();printf("\n\t\t请按任意键进行下一组数据的排序对比\n\n");temp=getchar();}}4、调试分析成功运行，如图所示：。

数据结构排序实验报告

数据结构排序实验报告一、实验目的本次数据结构排序实验的主要目的是深入理解和掌握常见的排序算法，包括冒泡排序、插入排序、选择排序、快速排序和归并排序，并通过实际编程和实验分析，比较它们在不同规模数据下的性能表现，从而为实际应用中选择合适的排序算法提供依据。

二、实验环境本次实验使用的编程语言为 Python 3x，开发环境为 PyCharm。

实验中使用的操作系统为 Windows 10。

三、实验原理1、冒泡排序（Bubble Sort）冒泡排序是一种简单的排序算法。

它重复地走访要排序的数列，一次比较两个数据元素，如果顺序不对则进行交换，并一直重复这样的走访操作，直到没有要交换的数据元素为止。

2、插入排序（Insertion Sort）插入排序是一种简单直观的排序算法。

它的工作原理是通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入，直到整个数组有序。

3、选择排序（Selection Sort）首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置，然后，再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。

以此类推，直到所有元素均排序完毕。

4、快速排序（Quick Sort）通过一趟排序将待排记录分隔成独立的两部分，其中一部分记录的关键字均比另一部分关键字小，则可分别对这两部分记录继续进行排序，以达到整个序列有序。

5、归并排序（Merge Sort）归并排序是建立在归并操作上的一种有效、稳定的排序算法，该算法是采用分治法(Divide and Conquer）的一个非常典型的应用。

将已有序的子序列合并，得到完全有序的序列；即先使每个子序列有序，再使子序列段间有序。

四、实验步骤1、算法实现使用 Python 语言分别实现上述五种排序算法。

为每个算法编写独立的函数，函数输入为待排序的列表，输出为排序后的列表。

2、生成测试数据生成不同规模（例如 100、500、1000、5000、10000 个元素）的随机整数列表作为测试数据。

1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。

设计和实现内部排序算法效率比较平台，通过随机的数据比较各算法的关键字比较次数和关键字移动次数，以取得直观的感受。

二、试验目的掌握多种排序方法的基本思想，如直接插入、冒泡、简单选择、快速、堆、希尔排序等排序方法，并能够用高级语言实现。