排序算法的比较课程设计实验报告
《数据结构》课程设计报告题目: 排序算法的比较目录一、课程设计名称 (Ⅲ)二、使用工具软件 (Ⅲ)三、目的意义 (Ⅲ)四、基本要求 (Ⅲ)五、实验歩骤 (Ⅲ)六、运行结果 (Ⅺ)七、得意之处 (XIV)八、创意的技术实现 (XV)九、目前存在的问题 (XV)十、设计实验过程中的自我感受 (XV)十一、主要参考资料 (XV)一、课程设计名称：排序算法的比较二、使用工具软件：Microsoft Visual C++6.0三、目的意义：1.掌握各种排序算法（直接出入排序、冒泡排序、快速排序、简单选择排序）的思路核心，比较他们之间的优劣2.全面提高学生的程序设计、开发能力四、基本要求：1．任意性：系统首先生成1000个随机整数，然后分别用不同的排序方法对其进行升序排序，给出每种方法的比较次数或所用时间2．友好性：界面要友好，输入有提示，尽量展示人性化 3．可读性：源程序代码清晰、有层次4．健壮性：用户输入非法数据时，系统要及时给出警告信息五、实验歩骤：#include"iostream.h"#include"stdio.h"#include"stdlib.h"#include"time.h"long count = 0;#define MAXSIZE 100000typedef long keyType;typedef struct{keyType key;}RcdType;typedef struct{RcdType r[MAXSIZE+1];int length;}SqList;SqList L;void Swap(RcdType &r1,RcdType &r2){RcdType t=r1;r1=r2;r2=t;}void print(SqList L){for(long i =1;i<=L.length;i++)cout<<L.r[i].key<<"\t";cout<<endl;}/*************************直接插入排序*************************/long InsertionSort ( SqList &L ) {// 对顺序表 L 作直接插入排序count =0;for (long i=2; i<=L.length; ++i ) //n-1趟 if (L.r[i].key < L.r[i-1].key) {L.r[0] = L.r[i]; // 设置哨兵for (long j=i-1; L.r[0].key < L.r[j].key; -- j ){count++;L.r[j+1] = L.r[j]; } // 记录向后顺移L.r[j+1] = L.r[0]; // 插入到正确位置 }return count;}/*************************冒泡排序*************************/long BubbleSort(SqList &L){int flag = 1;count = 0;for (long i=1;i<L.length;i++){//n-1趟排序 count++;flag = 0;for (long j=1;j<=L.length-i;j++)//每一趟里n-i 次比较if (L.r[j+1].key < L.r[j].key) Swap(L.r[j], L.r[j+1]);//交换L.r[i]与L.r[j]}return count;}/*************************快速排序*************************/long Partition (SqList &L, long low, long high) {L.r[0] =L.r[low];count++;keyType pivotkey = L.r[0].key; // 枢轴while (low < high) {//循环结束时low==high+1while(low<high && L.r[high].key>=pivotkey)--high; //从右向左搜索关键字比枢轴小的记录并控制越界if(low<high) {L.r[low++] = L.r[high]; count++;} //比枢轴记录小的移到左部while (low<high && L.r[low].key<=pivotkey)++low; //从左向右搜索关键字比枢轴大的记录并控制越界if(low<high) {L.r[high--] = L.r[low];count++;} //比枢轴记录大的移到右部}L.r[low] = L.r[0];count++;return low; //low==high+1}void QSort(SqList &L, long low, long high) {// 对记录序列L.r[low..high]进行快速排序if (low < high) { // 记录个数大于1long pivotloc = Partition(L,low,high);// 对 L.r[low..high] 进行一次划分QSort(L, low, pivotloc-1); //对左部进行快速排序QSort(L, pivotloc+1, high); //对右部进行快速排序}}long QuickSort(SqList &L){count =0;QSort(L,1,L.length);return count;}/*************************简单选择排序*************************/long SelectMinKey(SqList &L,int i){ long j=i;for( long k=i+1;k<=L.length ; k++)if ( L.r[k].key <L.r[j].key) j=k; return j;}long SelectSort (SqList &L) {count = 0;for (long i=1; i<L.length; ++i) {// 选择第 i 小的记录，并交换到位count++;long j = SelectMinKey(L, i);//在L.r[i..L.Length]中选择关键字最小的记录if (i!=j) Swap(L.r[i],L.r[j]);// 与第 i 个记录交换}return count;}/*************************操作选择函数*************************/void operate(){time_t start,end;double dif;long degree;SqList L1;char ch;cout<<"请选择排序算法："; cin>>ch;switch(ch){case 'a':{for(long i = 1;i<=L.length;i++) L1.r[i] = L.r[i]; L1.length = L.length;time(&start);degree = InsertionSort(L1);time(&end);dif = difftime(end,start);cout<<"直接插入排序所用时间：" << dif << "秒\n";cout<<"直接插入排序移动次序：" << degree << endl;print(L1);cout<<endl;break;}case 'b':{for(long i = 1;i<=L.length;i++) L1.r[i] = L.r[i]; L1.length = L.length;time(&start);degree = BubbleSort(L1);time(&end);dif = difftime(end,start);cout<<"冒泡排序所用时间：" << dif << "秒\n";cout<<"冒泡排序移动次序：" << degree << endl;print(L1);cout<<endl;break;}case 'c':{for(long i = 1;i<=L.length;i++) L1.r[i] = L.r[i]; L1.length = L.length;time(&start);degree = QuickSort(L1);time(&end);dif = difftime(end,start);cout<<"快速排序所用时间：" << dif << "秒\n";cout<<"快速排序移动次序：" << degree << endl;print(L1);cout<<endl;break;}case 'd':{for(long i = 1;i<=L.length;i++) L1.r[i] = L.r[i]; L1.length = L.length;time(&start);degree = SelectSort(L1);time(&end);dif = difftime(end,start);cout<<"简单选择排序所用时间：" << dif << "秒\n";cout<<"简单选择排序移动次序：" << degree << endl;print(L1);cout<<endl;break;}case 'q': exit(0); //退出default:{cout<<"您的输入错误，请输入正确的操作！"<<endl;break;}}}/*************************主函数*************************/void main(){cout<<"\n 欢迎进入排序算法 "<<endl;cout<<"\n 设计者：樊盼盼 "<<endl;cout<<"\n 班级：计科1411 "<<endl;cout<<"\n 指导老师：王宏杰 "<<endl;cout<<"\n 设计时间：2016年6月 \n "<<endl;cout<<"===================================== ==========================================="<<endl ;cout<<" a --- 直接插入排序 "<<endl;cout<<" b --- 冒泡排序 "<<endl;cout<<" c --- 快速排序 "<<endl;cout<<" d --- 简单选择排序 "<<endl;cout<<" q --- 退出程序 \n"<<endl;cout<<"===================================== ==========================================="<<endl ;cout<<"\n请输入要产生的随机数的个数：";long n;cin>>n;srand((unsigned long)time(NULL));for(long i = 1;i<=n;i++) L.r[i].key = rand()%n;L.length = n;print(L);for(int j=0;j<=7;j++) operate();}六、运行结果：点击执行出现的第一个界面输入要产生的随机数的个数，得到如下请选择直接插入排序算法，得到的结果如下选择冒泡排序算法选择快速排序算法选择简单选择排序算法选择去退出程序七、得意之处：输入相应的序号可以跳转到不同的程序去调用不同的排序方法去执行，计算出不同的运行次数。
排序算法比较实验报告
信息学部算法分析上机报告学号0901******** 姓名陈龙指导老师秦明时间2011.11.1~11.23一．上机实验题目实验1比较归并排序和快速排序的区别。
实验2利用贪心算法对背包问题进行求解。
二．算法设计思路归并排序：申请空间，使其大小为两个已经排序序列之和，该空间用来存放合并后的序列，设定两个指针，最初位置分别为两个已经排序序列的起始位置，比较两个指针所指向的元素，选择相对小的元素放入到合并空间，并移动指针到下一位置，重复步骤直到某一指针达到序列尾，将另一序列剩下的所有元素直接复制到合并序列尾。
快速排序：设置两个变量I、J，排序开始的时候：I=0，J=N-1；以第一个数组元素作为关键数据，赋值给key，即key=A[0]；从J开始向前搜索，即由后开始向前搜索（J=J-1），找到第一个小于key的值A[J]，并与key交换；从I开始向后搜索，即由前开始向后搜索（I=I+1），找到第一个大于key的A[I]，与key交换；重复第3、4、5步，直到I=J；(3,4步是在程序中没找到时候j=j-1，i=i+1，直至找到为止。
找到并交换的时候i，j指针位置不变。
另外当i=j这过程一定正好是i+或j-完成的最后另循环结束。
)背包问题：用子问题定义状态：即f[i][v]表示前i件物品恰放入一个容量为v的背包可以获得的最大价值。
则其状态转移方程便是：f[i][v]=max{f[i-1][v],f[i-1][v-c[i]]+w[i]} 。
可以压缩空间，f[v]=max{f[v],f[v-c[i]]+w[i]}三. 源程序归并排序#include<stdio.h>#include<stdlib.h># define N 50int b[N],a[N];int n,i;void Merge (int low, int mid,int high) //合并{int i; int l=low,h=mid+1,k=l;while ((l<=mid) && (h<=high)) //部分合并{if (a[l]<=a[h]) b[k++]=a[l++];else b[k++]=a[h++];}if(l>mid)while (h<=high) b[k++]=a[h++]; //转储剩余部分 elsewhile(l<=mid) b[k++]=a[l++];for (i=0;i<=high;i++) //将b数组转储到a a[i]=b[i];}int Merge2 (int l,int h) //分类{for (i=0;i<n;i++)printf("%d ",a[i]);printf("\n");int m;if (l<h){m=(l+h)/2;Merge2(l, m);Merge2(m+1, h);Merge ( l,m,h);}return a[i];}void main(){printf("请输入您要排序的数组大小（不超过50）：");while (scanf("%d",&n)!=EOF){for (i=0;i<n;i++)scanf("%d",&a[i]);Merge2(0,n-1);for (i=0;i<n-1;i++)printf("%d ",a[i]);printf("%d\n",a[n-1]);}}快速排序#include "stdio.h"#include "stdlib.h"# define N 50int a[N];int i,n;void Quick(int list[ ], int left, int right) //lfet为数组最左端, right为数组最右端{int s;int i, j;int temp;for (i=0;i<n;i++)printf("%d ",a[i]);printf("\n");if(left < right) //如果没有查询完所有数组，则继续递归{s = list[left];i = left-1;j = right + 1;while(i+1!=j){if(list[i+1]<=s)i++;else if(list[j-1]>s)j--;else{temp=list[i+1];list[++i]=list[j-1];list[--j]=temp;}}list[left] = list[i];list[i] = s;Quick(list, left, i - 1); //对左边递归Quick(list, i + 1, right); //对右边递归}}void main(){printf("请输入您要排序的数组大小（不超过50）：");while (scanf("%d",&n)!=EOF){for (i=0;i<n;i++)scanf("%d",&a[i]);Quick(a,0,n-1);for (i=0;i<n-1;i++)printf("%d ",a[i]);printf("%d\n",a[n-1]);}}背包问题#include <stdio.h>#include <stdlib.h>#define N 3struct Thing{int num ;int price;int weight;float aver;};void swap(int *i,int *j){int temp;temp = *i;*i = *j;*j = temp;}int main(){int M;int i,j,k=0,NUM = 1;struct Thing *p = (struct Thing *)malloc(N*sizeof(struct Thing));printf("请输入背包能承受的重量：");scanf("%d",&M);printf("\n");for(i=0;i<N;++i){// printf("请输入物品序列号(请从1开始顺序加1):");// scanf("%d",&p[i].num);p[i].num = NUM++;printf("请输入%d号物品的价值:",p[i].num);scanf("%d",&p[i].price);printf("请输入%d号物品的重量:",p[i].num);scanf("%d",&p[i].weight);p[i].aver = ((float)p[i].price / (float)p[i].weight);}for(i = 0;i<N-1;i++){for(j = i+1;j<N;j++){if(p[i].aver<p[j].aver){swap(&p[i].num,&p[j].num);swap(&p[i].price,&p[j].price);swap(&p[i].weight,&p[j].weight);}}}printf("\n");printf("按照物品单位重量的价值从大到小排序为：\n");for(i = 0;i<N;i++){printf("事件序列号：%d ",p[i].num);printf("物品价值%d ",p[i].price);printf("物品重量%d ",p[i].weight);printf("\n");}printf("\n");printf("\n");while(1){if(M > p[k].weight){printf("先装入%d号码的物品%d的重量,\n",p[k].num,p[k].weight);M = M - p[k].weight;k++;}elsebreak;}printf("再装入%d号的物品%d的重量\n",p[k].num,M);printf("\n");printf("\n");free(p);return 0;}三．实验结果归并排序快速排序背包问题五．实验心得通过实验可以知道，若数据比较无序，快排快，若数据中部分有序，归并快。
排序比较的实验报告
一、实验目的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)快速排序是一种高效的排序算法，其基本思想是通过一趟排序将待排序记录分割成独立的两部分，其中一部分记录的关键字均比另一部分的关键字小，再分别对这两部分记录继续进行排序，以达到整个序列有序。
C语言课程设计报告排序比较
信息与控制学院课程设计题目排序算法的比较学生姓名学号学院专业指导教师二Ｏ一四年12月26 日一、实验目的1.1、题目与要求编写排序算法至少 5 种对排序算法进行比较，（包括时间和比较次数）输出结果1.2、本程序涉及的知识点变量的定义、输入和输出函数、产生随机数函数、if语句、goto语句、冒泡排序，直接插入排序，选择排序，希尔排序等。
二、功能设计冒泡排序：将相邻的两个数比较，将较小的数调到前头；有n个数就要进行n-1趟比较，第一次比较中要进行n-1次两两比较，在第j趟比较中，要进行n-j次两两比较。
插入排序：在得到要排序的数组以后，讲数组分为两个部分，数组的第一个元素为一个部分，剩下的元素为一部分，然后从数组的第二个元素开始，和该元素以前的所有元素比较，如果之前的元素没有比该元素大的，那么该元素的位置不变，如果有元素的值比该元素大，那么记录相爱他所在的位置；例如I，该元素的位置为k，则将从i到k位置上的所有元素往后移动一位，然后将k位置上的值移动到i位置上。
这样就找到了K所在的位置。
每一个元素都这样进行，最终就会得到排好顺序的数组。
选择排序：首先以一个元素为基准，从一个方向开始扫描，比如从左到右扫描，以A[0]为基准，接下来从A[0]….A[9]中找出最小的元素，将其与A[0]交换。
然后将其基准位置右移一位，重复上面的动作，比如，以A[1]为基准，找出A[1]~A[9]中最小的，将其与A[1]交换。
一直进行到将基准位置移到数组最后一个元素时排序结束。
计时：使用start_t=clock();计下开始时间使用end_t=clock();记下结束时间针对不同的排序在不同的位置插入计时语句，完成计时功能三、功能实现3.1、随机数函数1）函数原形：rand()2) 功能： rand()函数通过编程生成小于30000的随机数列3）模块代码：for(i=1;i<n+1;i++){b: L.elem[i].key=rand();printf("%10d",L.elem[i].key);if(L.elem[i].key>30000)goto b;++L.length;}}3.2、冒泡排序函数1）函数原形：qipao(SqList &L)2)功能：通过相邻比较，移位达到从小到大的数据排列。
排序算法实验报告
排序算法实验报告（内部排序算法比较）主要实验内容:对各种内部排序算法进行比较要求：（1）任意输入5组各50个数据；（2）对冒泡排序、直接插入排序、简单选择排序、快速排序、堆排序的关键字比较和交换次数进行统计。
源程序代码://主函数文件”sort.cpp”#include<iostream>#include<cstdlib>using namespace std;#include"Sort.h"#define NUMLEN 50 //要排序数组的元素个数/***********************main函数部分*******************************************/void main(){Rec* createData(int i,int &n); //创建5 组数据元素void DataHandle(Sort &data,Rec *r,int n); //处理每种排序的调用过程void ShowData(int i,Rec *r,int n); //显示创建好的未排序过的数组元素int n; //记录待排序数组元素的个数Rec *r; //用以储存待排序的数组元素Sort data; //创建排序对象,通过对象调用排序函数,完成对数据元素的排序for(int i=0;i<5;i++){r=createData(i,n);ShowData(i,r,n);DataHandle(data,r,n);}}/******************************************************************************/Rec* createData(int i,int &n){n=NUMLEN; int j;Rec *r=new Rec[n+1];r[0].key=0;switch(i+1){case 1://创建升序排序的1 - 50 的数组for(j=1;j<=n;j++)r[j].key=j;break;case 2://创建降序排序的50 - 1 的数组for(j=1;j<=n;j++)r[j].key=n+1-j;break;case 3://创建前半部分是升序排序的1 - 25 的数组,后半部分降序排序的50 - 26 的数组for(j=1;j<=n/2;j++)r[j].key=j;if(n%2==0)for(j=1;j<=n/2;j++)r[j+n/2].key=n+1-j;else for(j=1;j<=n/2+1;j++)r[j+n/2].key=n+1-j;break;case 4://创建一个全部元素都都为1 的数组for(j=1;j<=n;j++)r[j].key=3;break;case 5://程序随机的创建一个大小为n 的范围为1 - 1000 之间的随机数组srand(333);for(j=1;j<=n;j++)r[j].key=rand()%1000+1;break;default:return NULL;}return r;}/***********************ShowData函数部分***************************************//*功能:显示创建好的未排序的数组元素*/void ShowData(int i,Rec *r,int n){cout<<endl<<"********************************************************************************";cout<<"The "<<i+1<<" primary array is :"<<endl;for(int j=1;j<=n;j++)cout<<r[j].key<<" ";cout<<endl<<"********************************************************************************"<<endl; }void DataHandle(Sort &data,Rec *r,int n){cout<<endl<<"Bubble sort"<<endl;data.CreateData(r,n);data.BubbleSort();data.display();cout<<"Exchange times: "<<data.GCExTimes()<<endl;cout<<"Compare times: "<<data.GCCoTimes()<<endl;data.Delete();cout<<endl<<"Insert sort"<<endl;data.CreateData(r,n);data.InsertSort();data.display();cout<<"Exchange times: "<<data.GCExTimes()<<endl;cout<<"Compare times: "<<data.GCCoTimes()<<endl;data.Delete();cout<<endl<<"Select sort"<<endl;data.CreateData(r,n);data.SelectSort();data.display();cout<<"Exchange times: "<<data.GCExTimes()<<endl;cout<<"Compare times: "<<data.GCCoTimes()<<endl;data.Delete();cout<<endl<<"Quick sort"<<endl;data.CreateData(r,n);data.QuickSort();data.display();cout<<"Exchange times: "<<data.GCExTimes()<<endl;cout<<"Compare times: "<<data.GCCoTimes()<<endl;data.Delete();cout<<endl<<"Heap sort"<<endl;data.CreateData(r,n);data.HeapSort();data.display();cout<<"Exchange times: "<<data.GCExTimes()<<endl;cout<<"Compare times: "<<data.GCCoTimes()<<endl;data.Delete();cout<<endl;}/******************************************************************************///Sort排序类的文件”Sort.h”#ifndef SORT#define SORT/******************************************************************************/ /*数据类型的定义*/typedef int Key;typedef struct{Key key;}Rec;/******************************************************************************//***************Sort排序类*****************************************************/ /*功能:1 类中的成员函数完成对数据的排序2 数据的录入3 记录交换和比较次数4 显示数据*//*排序函数分别有:冒泡排序,直接插入排序,选择排序,快速排序,堆排序*/class Sort{private:Rec *r; //储存数据所用数组int n; //记录数据数量int ExchangeTimes; //交换次数int CompareTimes; //比较次数void qksort0(int s,int t); //快速排序递归用函数void qkpass(int s,int t,int &k); //快速排序递归函数void sift(int k,int m); //堆排序所用递归函数public:Sort();Sort(Rec r[],int n);void CreateData(Rec r[],int n);void BubbleSort(); //冒泡排序void InsertSort(); //直接插入排序void SelectSort(); //简单选择排序void QuickSort(); //快速排序void HeapSort(); //堆排序int GCExTimes(); //获取交换次数并对交换次数清零int GCCoTimes(); //获取比较次数并对交换次数清零void display(); //显示数据void Delete(); //删除剩余的储存空间};/******************************************************************************/Sort::Sort(){ r=NULL;n=0;ExchangeTimes=0;CompareTimes=0;}Sort::Sort(Rec r[],int n){ this->r=new Rec[n+1];this->n=n;for(int i=0;i<=n;i++)this->r[i]=r[i];ExchangeTimes=0;CompareTimes=0;}/******************************************************************************/ /************CreateData函数****************************************************/ /*功能:调用类中的函数完成对数据的初始化*/void Sort::CreateData(Rec r[],int n){this->r=new Rec[n+1];this->n=n;for(int i=0;i<=n;i++)this->r[i]=r[i];ExchangeTimes=0;CompareTimes=0;}/******************************************************************************//*************BubbleSort冒泡排序***********************************************/ /*功能:用冒泡法对数据进行排序（排序稳定）*/void Sort::BubbleSort(){bool flag;Rec t;for(int i=1;i<=n-1;i++){flag=true;for(int j=1;j<=n-i;j++){CompareTimes++;if(r[j+1].key<r[j].key){flag=false;t=r[j];r[j]=r[j+1];r[j+1]=t;ExchangeTimes++;}}if(flag)break;}}/********************InsertSort直接插入排序************************************/ /*功能:用直接插入排序的方法对数据进行排序（排序稳定）*/void Sort::InsertSort(){for(int i=2;i<=n;i++){r[0]=r[i];CompareTimes++;for(int j=i-1;r[j].key>r[0].key;j--){r[j+1]=r[j];CompareTimes++;}r[j+1]=r[0];}}/******************************************************************************//***********************SelectSort选择排序*************************************/ /*功能:用选择排序的方法对数据进行排序（排序不稳定）*/void Sort::SelectSort(){int k;for(int i=1;i<=n-1;i++){r[0]=r[i]; k=i;for(int j=i+1;j<=n;j++){CompareTimes++;if(r[j].key<r[k].key)k=j;}if(i!=k){r[i]=r[k];r[k]=r[0];ExchangeTimes++;}}}/******************************************************************************//****************QuickSort快速排序*********************************************/ /*功能:用快速排序的方法完成对数据的排序(递归函数) （排序不稳定）*//*在记录快速排序的比较次数的时候,着实费了些工夫,不过最后还是弄出来了*/void Sort::QuickSort(){qksort0(1,n);int k;if(s<t){this->qkpass(s,t,k);this->qksort0(s,k-1);this->qksort0(k+1,t);}}void Sort::qkpass(int s,int t,int &k)//快速排序中的递归函数{int i=s;int j=t;r[0]=r[s];while(i<j){while(i<j&&r[j].key>=r[0].key)//快速排序比价次数的记录应该在这{CompareTimes++;j--;}if(i!=j)CompareTimes++;/*在循环外还有一个满足(i!=j)条件后比较次数的自加,这是因为这个循环的条件不止有关键字比较的条件来跳出循环,还有一另一个条件(i<j)来条出循环,而因为这个条件跳出循环的时,是不需要进行关键字比较的,所以这要多一个if的条件判断*/ r[i]=r[j];while(i<j&&r[i].key<=r[0].key){CompareTimes++;i++;}r[j]=r[i];if(i!=j)CompareTimes++;}if(i!=s){ r[i]=r[0]; ExchangeTimes++; }k=i;}/******************************************************************************//***************HeapSort堆排序*************************************************//*功能:用堆排序方法完成对数据的排序（排序不稳定）*/void Sort::HeapSort(){int i,m;Rec t;m=n/2;for(i=m;i>=1;i--)sift(i,n);for(i=n;i>=2;i--){t=r[1];r[1]=r[i];r[i]=t;ExchangeTimes++;sift(1,i-1);}}i=k;j=2*i;r[0]=r[k];finished=false;while(j<=m&&!finished){ CompareTimes++;if(j<m&&(r[j].key<r[j+1].key))j++;CompareTimes++;if(r[0].key>=r[j].key)finished=true;else{ r[i]=r[j]; i=j; j=2*i; }}if(i!=k){ r[i]=r[0]; ExchangeTimes++; }}/******************************************************************************//*****************display函数**************************************************/ /*功能:显示排序好的数组*/void Sort::display(){for(int i=1;i<=n;i++)cout<<r[i].key<<" ";cout<<endl;}/******************************************************************************/ /***********GCExTimes函数******************************************************/ /*功能:获取交换次数并对交换次数清零*/int Sort::GCExTimes(){ int t=ExchangeTimes; ExchangeTimes=0;return t;}/******************************************************************************/ /***********GCCoTimes函数******************************************************/ /*功能:获取比较次数并对交换次数清零*/int Sort::GCCoTimes(){ int t=CompareTimes; CompareTimes=0;return t;}/******************************************************************************//**********Delete函数**********************************************************/ /*功能:删除不需要用的储存空间,减少空间的占有量*/void Sort::Delete(){ delete[] r;n=0;}/******************************************************************************/******************************************************************************** The 1 primary array is :1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 3031 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50********************************************************************************Bubble sort1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 3031 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50Exchange times: 0Compare times: 49Insert sort1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 3031 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50Exchange times: 0Compare times: 49Select sort1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 3031 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50Exchange times: 0Compare times: 1225Quick sort1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 3031 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50Exchange times: 0Compare times: 1225Heap sort1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 3031 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50Exchange times: 122Compare times: 444******************************************************************************** The 2 primary array is :50 49 48 47 46 45 44 43 42 41 40 39 38 37 36 35 34 33 32 31 30 29 28 27 26 25 2423 22 21 20 19 18 17 16 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1********************************************************************************Bubble sort1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 3031 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50Exchange times: 1225Compare times: 122531 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50Exchange times: 0Compare times: 1274Select sort1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 3031 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50Exchange times: 25Compare times: 1225Quick sort1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 3031 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50Exchange times: 25Compare times: 1250Heap sort1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 3031 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50Exchange times: 96Compare times: 386******************************************************************************** The 3 primary array is :1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 50 49 48 47 4645 44 43 42 41 40 39 38 37 36 35 34 33 32 31 30 29 28 27 26********************************************************************************Bubble sort1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 3031 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50Exchange times: 300Compare times: 925Insert sort1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 3031 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50Exchange times: 0Compare times: 349Select sort1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 3031 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50Exchange times: 12Compare times: 122531 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50Exchange times: 12Compare times: 1237Heap sort1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 3031 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50Exchange times: 122Compare times: 430******************************************************************************** The 4 primary array is :3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 33 3 3 3 3 3 3 3 3 3********************************************************************************Bubble sort3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 33 3 3 3 3 3 3 3 3 3Exchange times: 0Compare times: 49Insert sort3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 33 3 3 3 3 3 3 3 3 3Exchange times: 0Compare times: 49Select sort3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 33 3 3 3 3 3 3 3 3 3Exchange times: 0Compare times: 1225Quick sort3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 33 3 3 3 3 3 3 3 3 3Exchange times: 0Compare times: 1225Heap sort3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 3 33 3 3 3 3 3 3 3 3 3Exchange times: 49Compare times: 146******************************************************************************** The 5 primary array is :127 227 232 129 969 679 4 776 787 922 137 1 589 184 960 338 441 501 803 844 252700 90 472 585 882 972 388 815 762 721 774 587 601 784 193 49 709 941 982 511 370 886 164 314 597 709 915 870 21********************************************************************************Bubble sort1 4 21 49 90 127 129 137 164 184 193 227 232 252 314 338 370 388 441 472 501 511585 587 589 597 601 679 700 709 709 721 762 774 776 784 787 803 815 844 870 882886 915 922 941 960 969 972 982Exchange times: 530Compare times: 1224Insert sort1 4 21 49 90 127 129 137 164 184 193 227 232 252 314 338 370 388 441 472 501 511585 587 589 597 601 679 700 709 709 721 762 774 776 784 787 803 815 844 870 882886 915 922 941 960 969 972 982Exchange times: 0Compare times: 579Select sort1 4 21 49 90 127 129 137 164 184 193 227 232 252 314 338 370 388 441 472 501 511585 587 589 597 601 679 700 709 709 721 762 774 776 784 787 803 815 844 870 882886 915 922 941 960 969 972 982Exchange times: 46Compare times: 1225Quick sort1 4 21 49 90 127 129 137 164 184 193 227 232 252 314 338 370 388 441 472 501 511585 587 589 597 601 679 700 709 709 721 762 774 776 784 787 803 815 844 870 882886 915 922 941 960 969 972 982Exchange times: 25Compare times: 339Heap sort1 4 21 49 90 127 129 137 164 184 193 227 232 252 314 338 370 388 441 472 501 511585 587 589 597 601 679 700 709 709 721 762 774 776 784 787 803 815 844 870 882886 915 922 941 960 969 972 982Exchange times: 118Compare times: 430实验数据分析:本实验一共用了5组数, 每组50个元素的数据测试了这五种排序, 并记录了交换和比较次数, 从这些比较次数中看出每种排序的效率和快慢。
算法课设实验报告(3篇)
第1篇一、实验背景与目的随着计算机技术的飞速发展，算法在计算机科学中扮演着至关重要的角色。
为了加深对算法设计与分析的理解，提高实际应用能力，本实验课程设计旨在通过实际操作，让学生掌握算法设计与分析的基本方法，学会运用所学知识解决实际问题。
二、实验内容与步骤本次实验共分为三个部分，分别为排序算法、贪心算法和动态规划算法的设计与实现。
1. 排序算法（1）实验目的：熟悉常见的排序算法，理解其原理，比较其优缺点，并实现至少三种排序算法。
（2）实验内容：- 实现冒泡排序、快速排序和归并排序三种算法。
- 对每种算法进行时间复杂度和空间复杂度的分析。
- 编写测试程序，对算法进行性能测试，比较不同算法的优劣。
（3）实验步骤：- 分析冒泡排序、快速排序和归并排序的原理。
- 编写三种排序算法的代码。
- 分析代码的时间复杂度和空间复杂度。
- 编写测试程序，生成随机测试数据，测试三种算法的性能。
- 比较三种算法的运行时间和内存占用。
2. 贪心算法（1）实验目的：理解贪心算法的基本思想，掌握贪心算法的解题步骤，并实现一个贪心算法问题。
（2）实验内容：- 实现一个贪心算法问题，如活动选择问题。
- 分析贪心算法的正确性，并证明其最优性。
（3）实验步骤：- 分析活动选择问题的贪心策略。
- 编写贪心算法的代码。
- 分析贪心算法的正确性，并证明其最优性。
- 编写测试程序，验证贪心算法的正确性。
3. 动态规划算法（1）实验目的：理解动态规划算法的基本思想，掌握动态规划算法的解题步骤，并实现一个动态规划算法问题。
（2）实验内容：- 实现一个动态规划算法问题，如背包问题。
- 分析动态规划算法的正确性，并证明其最优性。
（3）实验步骤：- 分析背包问题的动态规划策略。
- 编写动态规划算法的代码。
- 分析动态规划算法的正确性，并证明其最优性。
- 编写测试程序，验证动态规划算法的正确性。
三、实验结果与分析1. 排序算法实验结果：- 冒泡排序：时间复杂度O(n^2)，空间复杂度O(1)。
排序算法比较系统实验报告
排序算法比较系统一．项目计划书1.项目的选题意义随着计算机科学技术的快速发展，排序成为了计算机程序设计中的一种重要操作。
它在计算机图形、计算机辅助设计、机器人、模式识别及统计学等领域具有广泛应用。
在实际应用当中比如数据统计等方面都会用到。
而且对一组数据进行排序也方便了后面对数据查找的操作。
要知道在一个有序数组中查找和在一个随机无序数组中的查找的时间复杂度和系统消耗是有天壤之别的。
它的的功能是将一个数据元素（或记录）的任意序列，重新排列成一个关键字有序的序列。
由于排序法很多，但就其全面性能而言，很难提出一种被认为是最好的方法，每一种方法都有各自的优缺点，适合在不同的的环境下使用。
一般情况下，采用不同的排序算法效率会不一样。
因此，在不同的环境下选择相对效率最高的排序算法，能够有效加快工程实施的进度。
为了方便大家了解不同排序算法的时间效率，特建立一种排序算法比较系统，实现比较不同排序算法效率的目的。
2.项目的主要内容和目标排序算法比较系统主要实现的下列十种功能:一．简单选择排序；二．折半插入排序；三．直接插入排序；四．冒泡排序；五．希尔排序；六．快速排序；七．归并排序；八．堆排序；九．清屏；十．退出系统；3．项目的技术基础、特点及实施的条件该项目可用C语言实现，适于在单机环境下运行。
小组成员均已学习过C语言程序设计、数据结构、算法等课程，具有一定的开发能力。
4.项目人员分工所有人都参与了项目的选题、设计、实现及测试工作，项目负责人归纳整理小组成员讨论成果，并确定最终方案。
在实践阶段，按照功能模块具体分工如下：项目组负责人：李齐，构建模型、设计算法、设计界面、实现功能二、四、五、六、七、十项目组成员：刘运皇，初始化数据、实现功能一、三、八、九二．设计方案1.算法思想的选择与设计此项目来源于实际问题。
通常，在排序的过程中需进行下列两种基本操作：（1）比较两个关键字的大小；（2）将记录从一个位置移动至另一个位置。
排序算法设计实验报告总结
排序算法设计实验报告总结1. 引言排序算法是计算机科学中最基础的算法之一，它的作用是将一组数据按照特定的顺序进行排列。
在现实生活中，我们经常需要对一些数据进行排序，比如学生成绩的排名、图书按照标题首字母进行排序等等。
因此，了解不同的排序算法的性能特点以及如何选择合适的排序算法对于解决实际问题非常重要。
本次实验旨在设计和实现几种经典的排序算法，并对其进行比较和总结。
2. 实验方法本次实验设计了四种排序算法，分别为冒泡排序、插入排序、选择排序和快速排序。
实验采用Python语言进行实现，并通过编写测试函数对算法进行验证。
测试函数会生成一定数量的随机数，并对这些随机数进行排序，统计算法的执行时间和比较次数，最后将结果进行记录和分析。
3. 测试结果及分析3.1 冒泡排序冒泡排序是一种简单且常用的排序算法，其基本思想是从待排序的数据中依次比较相邻的两个元素，如果它们的顺序不符合要求，则交换它们的位置。
经过多轮的比较和交换，最小值会逐渐冒泡到前面。
测试结果显示，冒泡排序在排序1000个随机数时，平均执行时间为0.981秒，比较次数为499500次。
从执行时间和比较次数来看，冒泡排序的性能较差，对于大规模数据的排序不适用。
3.2 插入排序插入排序是一种简单但有效的排序算法，其基本思想是将一个待排序的元素插入到已排序的子数组中的正确位置。
通过不断将元素插入到正确的位置，最终得到排序好的数组。
测试结果显示，插入排序在排序1000个随机数时，平均执行时间为0.892秒，比较次数为249500次。
插入排序的性能较好，因为其内层循环的比较次数与待排序数组的有序程度相关，对于近乎有序的数组排序效果更好。
3.3 选择排序选择排序是一种简单但低效的排序算法，其基本思想是在待排序的数组中选择最小的元素，将其放到已排序数组的末尾。
通过多次选择和交换操作，最终得到排序好的数组。
测试结果显示，选择排序在排序1000个随机数时，平均执行时间为4.512秒，比较次数为499500次。
内部排序算法比较课程设计报告(7种基本排序)
合肥学院计算机科学与技术系课程设计报告2017 ～2018 学年第一学期课程数据结构与算法课程设计名称内部排序算法比较学生姓名操彦学号1504012027专业班级计算机科学与技术系15级2 班指导教师2017 年9 月1、问题分析和任务定义各种内部排序算法的时间复杂度分析结果只给出了算法执行时间的阶，或大概执行时间，存在一定的却缺陷。
我们将通过随机的数据比较各算法的关键字比较次数和关键字移动次数，以取得直观感受。
所设计的程序应能够将产生的随机数据同时用不同的内部排序算法排序，并列出关键字比较次数与移动次数，方便比较。
待排序表的表长不少于100，为方便起见，我们令表长等于100，用5组随机的数据排序的结果作比较。
2、数据结构的选择和概要设计一．可能排序表的抽象数据类型定义：ADT OrderableList｛数据对象：D=｛|∈IntegerSet，i=1，2，……，n，n≥0｝数据关系：R1=｛<,|,∈D,i=2,……n｝基本操作：InitList（n）操作结果：构造一个长度为n，元素值依次为1，2，……，n的有序表。
RandomizeList(d,isInverseOrder)操作结果：首先根据isInverseOrder为True或False，将表置为逆序或正序，然后将表进行d（0≤d≤8）级随机打乱。
d为0时表不打乱，d越大，打乱程度越高。
RecallList（）操作结果：恢复最后一次用RandomizeList随机大乱的可排序表。
ListLength（）操作结果：返回可排序的长度。
ListEmpty（）操作结果：若可排序表为空表，则返回True，否则返回False。
BubbleSort（&c，&s）操作结果：进行冒泡排序，返回关键字比较次数c和移动次数s。
InsertSort（&c，&s）操作结果：进行插入排序，返回关键字比较次数c和移动次数s。
SelectSort（&c，&s）操作结果：进行选择排序，返回关键字比较次数c和移动次数s。
课程设计报告---排序算法的实现与比较
《数据结构》课程设计实验报告题目：排序算法的实现与比较目录一．设计内容和要求----------------------------------2 二．算法思想-------------------------------------------2 三．程序结构-------------------------------------------3 四．使用说明-------------------------------------------4 五．测试结果-------------------------------------------5 六．收获与体会----------------------------------------6一．设计内容和要求设计内容：排序算法的实现与比较要求：编程实现希尔、快速、堆排序、归并排序算法，并利用程序统计每种算法的执行时间。
要求随机产生10000、50000、100000、200000个待排数据存入磁盘文件，从磁盘文件读入待排数据进行排序，并将排序结果写入另一个文件中。
二．算法思想在本课题中，对常见的4 中排序算法希尔、快速、堆排序、归并排序进行实现，并根据待排数据个数的不同来对各种排序算法的执行时间进行比较，从而比较出在不同的情况下各排序算法的性能。
1.希尔排序希尔排序是对直接插入排序的一种改进，它的基本思想是：先将整个待排序记录序列分割成若干个子序列，在子序列内分别进行直接插入排序，待整个序列基本有序时，再对全体记录进行一次直接插入排序。
2.快速排序快速排序是对气泡排序的一种改进，其基本思想是：首先选一个轴值（即比较的基准），将待排序记录分割成独立的两部分，左侧记录的关键码均小于或等于轴值，右侧记录的关键码均大于或等于轴值，然后分别对这两部分重复上述过程，直到整个序列有序。
3.堆排序堆排序是简单选择排序的一种改进，其基本思想是：首先将待排序的记录序列构造成一个堆，此时，选出了堆中所有记录的最大值即堆顶记录，然后将它从堆中移走（通常将堆顶记录和堆中最后一个记录交换），并将剩余的记录再调整成堆，这样又找出了次大的记录，依此类推，直到堆中只有一个记录。
数据结构课程设计实验报告-内部排序算法比较
内部排序算法比较【实验简介】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个记录进行比较，找到第一个比起大的记录，利用循环让记录后移，把其放到第一个比起大的记录前面。