河北工业大学-数据结构实验报告-内部排序算法效率比较平台的设计与实现
- 格式:doc
- 大小:584.05 KB
- 文档页数:13
实验报告3实验名称:数据结构与软件设计实习题目:内部排序算法比较专业:生物信息学班级:01 姓名:学号:实验日期:2010.07.24一、实验目的:比较冒泡排序、直接插入排序、简单选择排序、快速排序、希尔排序;二、实验要求:待排序长度不小于100,数据可有随机函数产生,用五组不同输入数据做比较,比较的指标为关键字参加比较的次数和关键字移动的次数;对结果做简单的分析,包括各组数据得出结果的解释;设计程序用顺序存储。
三、实验内容对各种内部排序算法的时间复杂度有一个比较直观的感受,包括关键字比较次数和关键字移动次数。
将排序算法进行合编在一起,可考虑用顺序执行各种排序算法来执行,最后输出所有结果。
四、实验编程结果或过程:1. 数据定义typedef struct { KeyType key; }RedType; typedef struct { RedType r[MAXSIZE+1]; int length;}SqList;2. 函数如下,代码详见文件“排序比较.cpp”int Create_Sq(SqList &L)void Bubble_sort(SqList &L)//冒泡排序void InsertSort(SqList &L)//插入排序void SelectSort(SqList &L) //简单选择排序int Partition(SqList &L,int low,int high) void QSort(SqList &L,int low,int high)//递归形式的快速排序算法void QuickSort(SqList &L)void ShellInsert(SqList &L,int dk)//希尔排序void ShellSort(SqList &L,int dlta[ ])3. 运行测试结果,运行结果无误,如下图语速个数为20元素个数为100错误调试无。
数据结构排序实验报告数据结构排序实验报告引言:数据结构是计算机科学中的重要概念之一,它涉及到数据的组织、存储和操作方式。
排序是数据结构中的基本操作之一,它可以将一组无序的数据按照特定的规则进行排列,从而方便后续的查找和处理。
本实验旨在通过对不同排序算法的实验比较,探讨它们的性能差异和适用场景。
一、实验目的本实验的主要目的是通过实际操作,深入理解不同排序算法的原理和实现方式,并通过对比它们的性能差异,选取合适的排序算法用于不同场景中。
二、实验环境和工具实验环境: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 );}。
实验五内排序1.实验目的(1)掌握在数组上进行各种排序的方法和算法(2)加深对排序的理解,逐步培养解决实际问题的编程能力2.实验内容(1)完成直接插入排序算法(2)完成起泡(冒泡)排序算法3.实验重点熟悉和掌握数组上各种排序方法和算法4. 实验难点掌握数组上各种排序方法和算法5.实验指导参考程序代码如下:(1)/*****************************************//* 直接插入排序算法 *//*****************************************/InsertSort.hvoid InsertSort (DataType a[], int n)//用直接插入法对a[0]--a[n-1]排序{int i, j;DataType temp;for(i=0; i<n-1; i++){temp = a[i+1];j = i;while(j > -1 && temp.key < a[j].key){a[j+1] = a[j];j--;}a[j+1] = temp;}}InsertSort.cpp#include <iostream>using namespace std;typedef int KeyType;struct DataType{KeyType key;};#include "InsertSort.h"void main(void){DataType test[6]={64,5,7,89,6,24};int n = 6;InsertSort(test,n);for(int i=0; i<n; i++)cout << test[i].key << " "; system("pause");}/*****************************************/ /* 冒泡排序算法 */ /*****************************************/ datatype.htypedef int keytype;struct datatype{keytype key;};BubbleSort.cpp#include <iostream>using namespace std;#include"datatype.h"void BubbleSort(datatype a[], int n)//用冒泡排序法对a[0]--a[n-1]排序{int i, j, flag=1;datatype temp;for(i = 1; i < n && flag == 1; i++){flag = 0;for(j = 0; j < n-i; j++){if(a[j].key > a[j+1].key){flag = 1;temp = a[j];a[j] = a[j+1];a[j+1] = temp;}}}}void main(void){datatype test[6]={64,5,7,89,6,24};int n = 6;BubbleSort(test,n);for(int i=0; i<n; i++)cout << test[i].key << " "; system("pause");}。
(完整)数据结构(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]。
数据结构课程设计—内部排序算法比较在计算机科学领域中,数据的排序是一项非常基础且重要的操作。
内部排序算法作为其中的关键部分,对于提高程序的运行效率和数据处理能力起着至关重要的作用。
本次课程设计将对几种常见的内部排序算法进行比较和分析,包括冒泡排序、插入排序、选择排序、快速排序和归并排序。
冒泡排序是一种简单直观的排序算法。
它通过重复地走访要排序的数列,一次比较两个数据元素,如果顺序不对则进行交换,并一直重复这样的走访操作,直到没有要交换的数据元素为止。
这种算法的优点是易于理解和实现,但其效率较低,在处理大规模数据时性能不佳。
因为它在最坏情况下的时间复杂度为 O(n²),平均时间复杂度也为O(n²)。
插入排序的工作原理是通过构建有序序列,对于未排序数据,在已排序序列中从后向前扫描,找到相应位置并插入,直到整个序列有序。
插入排序在数据量较小时表现较好,其平均时间复杂度和最坏情况时间复杂度也都是 O(n²),但在某些情况下,它的性能可能会优于冒泡排序。
选择排序则是每一次从待排序的数据元素中选出最小(或最大)的一个元素,存放在序列的起始位置,然后,再从剩余未排序元素中继续寻找最小(或最大)元素,然后放到已排序序列的末尾。
以此类推,直到全部待排序的数据元素排完。
选择排序的时间复杂度同样为O(n²),但它在某些情况下的交换操作次数可能会少于冒泡排序和插入排序。
快速排序是一种分治的排序算法。
它首先选择一个基准元素,将数列分成两部分,一部分的元素都比基准小,另一部分的元素都比基准大,然后对这两部分分别进行快速排序。
快速排序在平均情况下的时间复杂度为 O(nlogn),最坏情况下的时间复杂度为 O(n²)。
然而,在实际应用中,快速排序通常表现出色,是一种非常高效的排序算法。
归并排序也是一种分治算法,它将待排序序列分成若干个子序列,每个子序列有序,然后将子序列合并成一个有序序列。
数据结构实验报告本文是范文,仅供参考写作,禁止抄袭本文内容上传提交,违者取消写作资格,成绩不合格!实验名称:排序算法比较提交文档学生姓名:提交文档学生学号:同组成员名单:指导教师姓名:排序算法比较一、实验目的和要求1、设计目的1.掌握各种排序的基本思想。
2.掌握各种排序方法的算法实现。
3.掌握各种排序方法的优劣分析及花费的时间的计算。
4.掌握各种排序方法所适应的不同场合。
2、设计内容和要求利用随机函数产生30000个随机整数,利用插入排序、起泡排序、选择排序、快速排序、堆排序、归并排序等排序方法进行排序,并统计每一种排序上机所花费的时间二、运行环境(软、硬件环境)软件环境:Vc6.0编程软件运行平台: Win32硬件:普通个人pc机三、算法设计的思想1、冒泡排序:bubbleSort()基本思想: 设待排序的文件为r[1..n]第1趟(遍):从r[1]开始,依次比较两个相邻记录的关键字r[i].key和r[i+1].key,若r[i].key>r[i+1].key,则交换记录r[i]和r[i+1]的位置;否则,不交换。
(i=1,2,...n-1)第1趟之后,n个关键字中最大的记录移到了r[n]的位置上。
第2趟:从r[1]开始,依次比较两个相邻记录的关键字r[i].key和r[i+1].key,若r[i].key>r[i+1].key,则交换记录r[i]和r[i+1]的位置;否则,不交换。
(i=1,2,...n-2)第2趟之后,前n-1个关键字中最大的记录移到了r[n-1]的位置上,作完n-1趟,或者不需再交换记录时为止。
2、选择排序:selSort()每一趟从待排序的数据元素中选出最小(或最大)的一个元素,顺序放在已排好序的数列的最后,直到全部待排序的数据元素排完。
选择排序不像冒泡排序算法那样先并不急于调换位置,第一轮(k=1)先从array[k]开始逐个检查,看哪个数最小就记下该数所在的位置于minlIndex中,等一轮扫描完毕,如果找到比array[k-1]更小的元素,则把array[minlIndex]和a[k-1]对调,这时array[k]到最后一个元素中最小的元素就换到了array[k-1]的位置。
内部排序实验报告内部排序实验报告一、引言内部排序是计算机科学中的重要概念,它指的是对一个数据集合进行排序的过程。
在计算机科学中,排序算法是一种基本的算法,它对于提高数据处理效率和优化算法性能有着重要的作用。
本实验旨在通过实际操作和对比分析,探究不同内部排序算法的性能差异。
二、实验目的1. 了解内部排序的基本概念和常用算法;2. 掌握不同内部排序算法的实现方法;3. 比较不同内部排序算法的时间复杂度和空间复杂度;4. 分析实验结果,总结不同算法的优缺点。
三、实验过程1. 实验环境搭建在进行实验之前,我们需要搭建适当的实验环境。
选择一种编程语言,并准备好相应的开发环境。
2. 实验数据准备为了进行排序算法的测试,我们需要准备一组测试数据。
可以选择不同规模的数据集,包括有序、无序和部分有序等情况。
3. 实验算法实现选择几种常用的内部排序算法,如冒泡排序、插入排序、选择排序、快速排序和归并排序等。
分别实现这些算法,并确保其正确性。
4. 实验性能测试使用不同规模的测试数据对算法进行性能测试。
记录每个算法的运行时间和所占用的内存空间。
5. 实验结果分析根据实验数据和测试结果,对比分析不同算法的性能差异。
针对时间复杂度和空间复杂度,给出相应的分析和解释。
四、实验结果与分析经过实验测试,我们得到了不同内部排序算法的运行时间和内存占用情况。
下面对实验结果进行分析和解释。
1. 时间复杂度分析通过实验数据,我们可以观察到不同算法的运行时间随着数据规模的增加而增加。
快速排序和归并排序在大规模数据集上表现出色,时间复杂度为O(nlogn)。
而冒泡排序和选择排序的时间复杂度为O(n^2),在大规模数据集上性能较差。
2. 空间复杂度分析在内部排序中,空间复杂度是指算法执行过程中所需的额外内存空间。
插入排序和冒泡排序是原地排序算法,它们的空间复杂度为O(1)。
而归并排序和快速排序需要额外的空间来存储中间结果,空间复杂度为O(n)。
实验报告3实验名称:数据结构与软件设计实习题目:内部排序算法比较专业:生物信息学班级:01 姓名:学号:实验日期:2010.07.24一、实验目的:比较冒泡排序、直接插入排序、简单选择排序、快速排序、希尔排序;二、实验要求:待排序长度不小于100,数据可有随机函数产生,用五组不同输入数据做比较,比较的指标为关键字参加比较的次数和关键字移动的次数;对结果做简单的分析,包括各组数据得出结果的解释;设计程序用顺序存储。
三、实验内容对各种内部排序算法的时间复杂度有一个比较直观的感受,包括关键字比较次数和关键字移动次数。
将排序算法进行合编在一起,可考虑用顺序执行各种排序算法来执行,最后输出所有结果。
四、实验编程结果或过程:1. 数据定义typedef struct { KeyType key; }RedType; typedef struct { RedType r[MAXSIZE+1]; int length;}SqList;2. 函数如下,代码详见文件“排序比较.cpp”int Create_Sq(SqList &L)void Bubble_sort(SqList &L)//冒泡排序void InsertSort(SqList &L)//插入排序void SelectSort(SqList &L) //简单选择排序int Partition(SqList &L,int low,int high) void QSort(SqList &L,int low,int high)//递归形式的快速排序算法void QuickSort(SqList &L)void ShellInsert(SqList &L,int dk)//希尔排序void ShellSort(SqList &L,int dlta[ ])3. 运行测试结果,运行结果无误,如下图语速个数为20元素个数为100错误调试无。
《数据结构》课程实验实验报告题目:内部排序算法效率比较平台的设计与实现专业:计算机科学与技术班级:姓名:学号:完成日期:一、试验内容各种内部排序算法的时间复杂度分析结果只给出了算法执行时间的阶,或大概执行时间。
设计和实现内部排序算法效率比较平台,通过随机的数据比较各算法的关键字比较次数和关键字移动次数,以取得直观的感受。
二、试验目的掌握多种排序方法的基本思想,如直接插入、冒泡、简单选择、快速、堆、希尔排序等排序方法,并能够用高级语言实现。
三、源程序代码#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);};四、流程图五、调试过程要很好的理解各种算法就可以这样才可以编出程序来,要注意比较次数和交换次数的计数问题。
数据结构内排序实验报告数据结构内排序实验报告一、实验目的本实验旨在熟悉数据结构内排序算法的实现过程,比较各种内排序算法的效率和性能,并掌握它们的优缺点。
二、实验内容⒈实验环境搭建在实验开始前,需要搭建适当的实验环境,包括编程语言、集成开发环境(IDE)等。
⒉内排序算法实现选择合适的内排序算法,如冒泡排序、插入排序、选择排序、快速排序等,对给定的待排序数据进行实现。
⒊程序测试编写测试程序,随机生成一定量的数据,对每个内排序算法进行测试,并记录运行时间和比较次数。
⒋数据比较与分析将各个内排序算法的运行时间和比较次数进行比较,分析它们的优劣势。
⒌实验结论结合实验结果,给出对内排序算法的选择建议,并对实验过程中的问题进行总结。
三、实验步骤与介绍⒈实验环境搭建在本次实验中,我们选择使用C++编程语言,并搭建Visual Studio作为集成开发环境。
该环境提供了丰富的调试和测试工具,适合本次实验的需求。
⒉内排序算法实现我们选择了三种常见的内排序算法进行实现,包括冒泡排序、插入排序和快速排序。
a) 冒泡排序冒泡排序是一种交换排序算法,通过不断比较相邻元素并交换位置来实现排序。
具体实现步骤如下:- 从待排序数组的第一个元素开始,不断比较相邻两元素的大小。
- 如果前一个元素大于后一个元素,则交换它们的位置。
- 继续比较下一对元素,直到最后一个元素。
- 重复以上步骤,直到排序完成。
b) 插入排序插入排序是一种直接插入排序算法,通过不断将待排序元素插入已排序部分的合适位置来实现排序。
具体实现步骤如下:- 从待排序数组的第二个元素开始,依次将元素与前面已排好序的元素进行比较。
- 如果前一个元素大于待排序元素,则将前一个元素后移一位。
- 继续比较前一个元素,直到找到合适的位置插入待排序元素。
- 重复以上步骤,直到排序完成。
c) 快速排序快速排序是一种分治排序算法,通过不断地将数组分成两部分并对子数组递归进行排序来实现整体排序。
内部排序算法比较【实验简介】1、在教科书各种内部排序算法的时间复杂度分析结果只给出了算法执行的时间的阶,或大概的执行时间,如:直接插入排序即时间复杂度为O(n*n)2、通过五组随机数据、一组正序数据与一组逆序数据比较6种常用的内部算法(起泡排序、直接插入排序、简单选择排序、快速查找排序、希尔排序、堆排序)的关键字比较次数和关键字移动次数,以取得直观感受;3、用五组不同的长度不小于100的数据进行测试,并对测试结果作出简单的分析,对得出结果拨动大小的进行解释;【设计模块】【对应模块算法说明】(1) 此算法程序中需要用到顺序表数据类型,数据元素的类型定义如下:typedef struct{KeyType key; //关键字项}RedType;typedef struct{RedType r[MAXSIZE+1]; //0号单元闲置或用作哨兵单元int length; //顺序表长度int info; //记录关键字移动次数int cmp; //关键字的比较次数}Sqlist;(2) 本实验用到六种排序算法,一个主函数和菜单函数,其中排序算法分别为起泡排序、直接插入排序、简单选择排序、快速查找排序、希尔排序、堆排序;相应时间复杂度分析如下:起泡排序:若待排序列为“正序”,则需进行一趟排序在排序过程中关键字需进行n-1次比较,无须移动纪录;若是“逆序”,则进行n-1趟排序,需n(n-1)/2次比较,并坐等数量级的移动,因此总的事件复杂度为O(n2);直接插入排序待排序纪录是随机的,关键字间的移动次数和比较次数的平均值约为n*n/4,即时间复杂度为O(n2);简单的选择排序虽然在排序过程中所需要的移动次数较少,最小时为0,最大时为3(n-1);但是关键字的比较次数总是相同的,均为n(n-1)/2,因此,时间复杂度亦为O(n2);快速排序其平均时间是kn*㏑n,其中n为待排序列中纪录的个数,k为某个常数,其时间复杂度为O(n*㏑n);希尔排序当增序序列为dlta[k]=2t-k+1-1时,时间复杂度为O(n3/2),其中t为排序趟数,1≤k≤t≤㏒2(n+1);堆排序此排序对于含n个元素的序列排序时,总共进行的关键字比较次数不超过4n,且在最坏的情况下,其时间复杂度为O(n*㏑n);算法分析如下:①冒泡排序该算法的的思路是首先将第1个记录的关键字负值给L.r[0],然后用L.r[0]与第(i+1)个记录的关键字比较,若为逆序,则交换第i与第i+1两记录的位置,然后让i加1,重复以上操作,直至i=n-1为止;依次进行第二趟、第三趟……作同样的操作,直至所有的记录按正序排列(一般需要n-1趟比较,第i趟从L.r[1]到L.r[n-i+1]依次比较,1≦ i ≦n-i,比较结果是让其中最大的记录放在L.r[n-i+1]的位置)void BubbleSort(Sqlist *L) //冒泡排序{for(i=0;i<L->length;i++){L->r[0]=L->r[1];for(j=1;j<N-i;j++)if(L->r[0].key>=L->r[j+1].key)L->r[j] L->r[j+1]; //交换两记录的位置elseL->r[0]=L->r[j+1]; //保证L->r[0]始终为较大的记录L->r[j+1]=L->r[0]; //把最大的记录放到祠堂排序的最高位置}printf(L->r[MAXSIZE]);//输出排序后数组和相关数据}②直接插入排序本算法的思路是,把L->r[0]设置为哨兵,排序时把第i个记录复制给哨兵,并于其前的i-1个记录进行比较,找到第一个比起大的记录,利用循环让记录后移,把其放到第一个比起大的记录前面。
《数据结构》课程实验实验报告题目:内部排序算法效率比较平台的设计与实现专业:计算机科学与技术班级:姓名:学号:完成日期:一、试验内容各种内部排序算法的时间复杂度分析结果只给出了算法执行时间的阶,或大概执行时间。
设计和实现内部排序算法效率比较平台,通过随机的数据比较各算法的关键字比较次数和关键字移动次数,以取得直观的感受。
二、试验目的掌握多种排序方法的基本思想,如直接插入、冒泡、简单选择、快速、堆、希尔排序等排序方法,并能够用高级语言实现。
三、源程序代码#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);};四、流程图五、调试过程要很好的理解各种算法就可以这样才可以编出程序来,要注意比较次数和交换次数的计数问题。
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);} //存储分配失败第3 页共20 页L.length=0;//初始长度为0return OK;}五、算法及时间复杂度(一)各个排序是算法思想:(1)直接插入排序:将一个记录插入到已排好的有序表中,从而得到一个新的,记录数增加1的有序表。
(2)折半插入排序:插入排序的基本插入是在一个有序表中进行查找和插入,这个查找可利用折半查找来实现,即为折半插入排序。
引言概述:数据结构排序实验是计算机科学与技术专业中一项重要的实践课程。
通过实验,可以深入理解和掌握不同排序算法的原理、特点和性能表现。
本文将针对数据结构排序实验进行详细的阐述和总结,包括实验目的、实验内容、实验结果分析和总结。
一、实验目的1. 加深对数据结构排序算法的理解:通过实验,掌握不同排序算法的工作原理和实现方式。
2. 分析和比较不同排序算法的性能:对比不同排序算法在不同数据规模下的时间复杂度和空间复杂度,理解它们的优劣势。
3. 提高编程和算法设计能力:通过实验的编写,提升对排序算法的实现能力和代码质量。
二、实验内容1. 选择排序算法:选择排序是一种简单直观的排序算法,将序列分为有序和无序两部分,每次从无序部分选择最小(最大)元素,放到有序部分的末尾(开头)。
- 算法原理及步骤- 实现过程中的注意事项- 时间复杂度和空间复杂度的分析2. 插入排序算法:插入排序逐步构建有序序列,对于未排序的元素,在已排序序列中从后向前扫描,找到对应位置插入。
- 算法原理及步骤- 实现过程中的注意事项- 时间复杂度和空间复杂度的分析3. 快速排序算法:快速排序利用分治的思想,将序列分为左右两部分,选取基准元素,将小于基准的放在左边,大于基准的放在右边,递归地对左右部分进行排序。
- 算法原理及步骤- 实现过程中的注意事项- 时间复杂度和空间复杂度的分析4. 归并排序算法:归并排序是一种稳定的排序算法,通过将序列分为若干子序列,分别进行排序,然后再将排好序的子序列合并成整体有序序列。
- 算法原理及步骤- 实现过程中的注意事项- 时间复杂度和空间复杂度的分析5. 堆排序算法:堆是一种特殊的树状数据结构,堆排序利用堆的性质进行排序,通过构建大顶堆或小顶堆,并逐个将堆顶元素移出形成有序序列。
- 算法原理及步骤- 实现过程中的注意事项- 时间复杂度和空间复杂度的分析三、实验结果分析1. 比较不同排序算法的执行时间:根据实验数据和分析,对比不同排序算法在不同数据规模下的执行时间,并针对其时间复杂度进行验证和分析。
数据结构课程设计实验报告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]对顺序表L作希尔排序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、调试分析成功运行,如图所示:。
内部排序算法的实现与⽐较-数据结构课程设计内部排序算法的实现与⽐较1)问题描述在教科书中,各种内部排序算法的时间复杂度分析结果只给出了算法执⾏时间的阶,或⼤概执⾏时间。
试通过随机数据⽐较各算法的关键字⽐较次数和关键字移动次数,以取得直观感受。
2)基本要求(1) 对常⽤的内部排序算法进⾏⽐较:直接插⼊排序、简单选择排序、冒泡排序、快速排序、希尔排序、归并排序。
(2) 利⽤随机函数产⽣N(N=30000)个随机整数,作为输⼊数据作⽐较;⽐较的指标为关键字参加的⽐较次数和关键字的移动次数(关键字交换计为3次移动)。
(3) 对结果作出简要分析。
3)测试数据随机函数产⽣。
4)提⽰主要⼯作是设法在已知算法中适当位置插⼊对关键字的⽐较次数和移动次数的计数操作。
注意采⽤分块调试的⽅法。
5)输⼊输出:输⼊数据:参加排序的整数个数N(N=30000,注:不得减少N);输出数据:各种排序⽅法的关键字⽐较次数和移动次数(从⼩到⼤排列)。
本来冒泡排序交换次数想⽤树状数组BIT发现数据太多时 ⽤BIT加的数据会超限 所以还是直接⽤了冒泡排序上代码--纯C语⾔:/** zhagoodwell 查昊昊QQ微信:2423824433* 直接插⼊: charu函数* 选择: xuanzepai函数* 冒泡: maopao函数* 快排: Qsort 递归函数* 希尔:shell 函数* 归并:GB 函数*/# include <stdio.h># include <stdlib.h># include <time.h># define N 30000# define SR 1001int A[N],B[N],C[N],D[N],E[N],F[N],G[N];int a,aa,b,bb,d,dd,e,ee,f,ff,num; //单个字母的为记录的⽐较次数-移动的次数,双字母为关键字的移动次数long long c,cc;void charu(int A[],int n);//对n个元素直接插⼊排序void xuanzepai(int A[],int n);//对n个元素选择升序void maopao(int A[],int n); // 冒泡排序void Quicksort(int A[],int L,int R);//对[L,R]个元素快速升序void shell(int A[],int n);//对n个元素 shell 升序void GBPX(int S[],int L,int R,int T[]);// 归并排序int GB(int S[],int L,int M,int R,int T[]);//数组归并操作int gainint(int *p,int min,int max);//防输错⽽建的函数 *p的范围[min,max]int change(int *a,int *b);//交换函数交换a b的值void charu(int A[],int n)//返回循环⽐较次数int i,j,temp;for (i=1,a++;i<n;i++,a++)if (A[i]<A[i-1]){temp=A[i];for(a++,aa++,j=i-1;j>=0&& A[j]>temp;j--,a++,aa++) A[j+1]=A[j];A[j+1]=temp;}}void xuanzepai(int A[],int n)//以A[0]为⽐较依据升序{int i,j,k;for(i=0,b++;i<n-1;i++,b++){k=i;for(j=i+1,b++;j<n;j++,b++)if(A[j]<A[k]){ k=j;b++;}if(k!=i){bb+=change(&A[i],&A[k]);}}}void maopao(int A[],int n){int i,j;for (i = n -1 ; i>=0 ;i--){for (j = 0; j<i; j++){if(A[j]>A[j+1])cc+=change(&A[j],&A[j+1]);}}}void Quicksort(int A[],int L,int R)//快速排序升序{int i=L,j=R,T=A[L]; //T为基准数if(L>R) return;while(i!=j) //当数组左右两边没相遇{while(A[j]>=T&&i<j){j--;d++;} //从右向左找while(A[i]<=T&&i<j){i++;d++;} //从左向右找if(i<j)dd+=change(&A[i],&A[j]); //交换两数}if(L!=i)dd+=change(&A[L],&A[i]); //基准数归位Quicksort(A,L,i-1); //递归左Quicksort(A,i+1,R); //递归右}void shell(int A[],int n)//希尔排序增量为2{int i,j,k;for(k=n>>1,e++;k>0;k=k>>1,e++){for(i=k,e++;i<n;i++,e++){for(j=i-k,e++;j>=0;j-=k,e++)if(A[j]>A[j+k])ee+=change(&A[j],&A[j+k]);}}int GB(int S[],int L,int M,int R,int T[])//数组归并操作{int i=M,j=R,k=0,count=0;while(i>=L&&j>M){f++;if(S[i]>S[j]){T[k++]=S[i--];//从临时数组的最后⼀个位置开始排序}else T[k++]=S[j--];count++;}while(i>=L){f++;T[k++]=S[i--];} //若前半段数组还有元素未放⼊临时数组T中while(j>M){f++;T[k++]=S[j--];}for(i=0,f+=k;i<k;i++) S[R-i]=T[i];//写回原数组return count;}void GBPX(int S[],int L,int R,int T[]){int M;if(L<R){M=(L+R)>>1;GBPX(S,L,M,T);//找左半段的逆序对数⽬GBPX(S,M+1,R,T);//找右半段的逆序对数⽬ff+=GB(S,L,M,R,T);//找完左右半段逆序对以后两段数组有序,找两段之间的逆序对。
实验五内部排序算法效率比较平台的设计与实现1.试验内容1、问题描述各种内部排序算法的时间复杂度分析结果只给出了算法执行时间的阶,或大概执行时间。
设计和实现内部排序算法效率比较平台,通过随机的数据比较各算法的关键字比较次数和关键字移动次数,以取得直观的感受。
2、基本要求(1)对以下6种常用的内部排序算法进行比较:起泡排序、直接插入排序、简单选择排序、快速排序、希尔排序、堆排序。
(2)待排序的表长不小于100;其中的数据要用伪随机数产生程序产生;至少要用5组不同的输入数据作比较;比较的指标为有关键字参加的比较次数和关键字的移动次数(关键字交换计为3次移动)。
(3)最后要对结果作出简单分析,包括对各组数据得出结果波动大小的解释。
3、测试数据由随机数产生器生成。
4、实现提示主要工作是设法在已知算法中的适当位置插入对关键字的比较次数和移动次数的计数操作。
程序还可以考虑几组数据的典型性,如,正序、逆序和不同程度的乱序。
注意采用分块调试的方法。
2.试验目的掌握多种排序方法的基本思想,如直接插入、冒泡、简单选择、快速、堆、希尔排序等排序方法,并能够用高级语言实现。
3.流程图4.源程序代码#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);}参考自百度文库5.实验结果运行结果如下:直接插入排序:完成的序列如下:***************************冒泡法:完成的序列如下:***************************希尔排序:完成的序列如下:*************************** 简单选择排序排序:完成的序列如下:*************************** 快速排序:完成的序列如下:*************************** 堆排序:完成的序列如下:。