数据结构实验四题目一排序实验报告

合集下载

数据结构实验报告(C语言)(强力推荐)

数据结构实验报告(C语言)(强力推荐)

数据结构实验实验内容和目的:掌握几种基本的数据结构:集合、线性结构、树形结构等在求解实际问题中的应用,以及培养书写规范文档的技巧。

学习基本的查找和排序技术。

让我们在实际上机中具有编制相当规模的程序的能力。

养成一种良好的程序设计风格。

实验教材:数据结构题集(C语言版)清华大学出版社2007年实验项目:实验一、栈和循环队列㈠、实验内容:①栈掌握栈的特点(先进后出FILO)及基本操作,如入栈、出栈等,栈的顺序存储结构和链式存储结构,以便在实际问题背景下灵活应用。

本程序采用的是链栈结构,具有初始化一个栈、PUSH、POP、显示所有栈里的元素四个功能。

②循环队列掌握队列的特点(先进先出FIFO)及基本操作,如入队、出队等,学会循环队列的实现,以便在实际问题背景下灵活运用。

本程序具有初始化一个队列、入队、出队、显示队列的所有元素、队列长度五个功能。

㈡、实验代码①栈程序代码:#include <stdio.h>#include <malloc.h>#define Stack_Size 6#define ERROR 0#define OK 1typedef int SElemType;typedef struct SNode{SElemType data;struct SNode *next;}SNode,*LinkStack;int CreatTwo(LinkStack &head,int n){int i;SNode *p;head=(LinkStack)malloc(sizeof(SNode));head->next=NULL;printf("请输入数据(数字):\n");for(i=n;i>0;--i){p=(SNode *)malloc(sizeof(SNode));scanf("%d",&p->data);p->next=head->next;head->next=p;}return 1;}int menu_select(){int sn;for(;;){scanf("%d",&sn);if(sn<1||sn>6)printf("\n\t输入错误,请重新输入\n");elsebreak;}return sn;}int Push(LinkStack &top,SElemType e){SNode *q;q=(LinkStack)malloc(sizeof(SNode));if(!q){printf("溢出!\n");return(ERROR);}q->data=e;q->next=top->next;top->next=q;return(OK);}int Pop(LinkStack &top,SElemType &e){SNode *q;if(!top->next){printf("error!\n");return(ERROR);}e=top->next->data;q=top->next;top->next=q->next;free(q);return(OK);}void main(){ int e;LinkStack top;printf("1.初始化一个栈;\n2.PUSH;\n3.POP;\n4.显示所有栈里的元素;\n5.结束;\n");while(1){switch(menu_select()){case 1:if(CreatTwo(top,Stack_Size))printf("Success!\n");break; case 2:printf("Push:\n");scanf("%d",&e);if(Push(top,e))printf("Success!\n");break;case 3:if(Pop(top,e))printf("Success!\n");printf("%d\n",e);break;case 4:LinkStack p;printf("所有栈里的元素:\n");p=top;while(p->next){p=p->next;printf("%7d",p->data);}printf("\n");break;case 5:return;}}}运行结果:②循环队列程序代码:#include<stdlib.h>#include<stdio.h>#define OVERFLOW -1#define OK 1#define ERROR 0#define MAXSIZE 100typedef struct{int *elem;//队列存储空间int front;int rear;}SqQueue;//判断选择是否正确int menu_select(){int sn;for(;;){scanf("%d",&sn);if(sn<1||sn>6)printf("\n\t输入错误,请重新输入\n");elsebreak;}return sn;}//参数(传出)SqQueue &Q,循环队列(空)int InitQueue(SqQueue &Q){Q.elem=(int *)malloc(MAXSIZE*sizeof(int));if(!Q.elem)exit(OVERFLOW);Q.front=Q.rear=-1;for(int i=0;i<MAXSIZE;i++)Q.elem[i]=-1;return OK;}//返回Q的元素个数int QueueLength(SqQueue Q){return (Q.rear-Q.front+MAXSIZE)%MAXSIZE;}//显示队列的元素void Display(SqQueue Q){for(int i=0;i<=QueueLength(Q);i++)if(Q.elem[i]!=-1)printf("%d ",Q.elem[i]);printf("\n");}//入队int EnQueue(SqQueue &Q,int e){Q.rear=(Q.rear+1)%MAXSIZE;if(Q.rear==Q.front)return ERROR;Q.elem[Q.rear]=e;return OK;}//出队int DeQueue(SqQueue &Q,int &e){if(Q.front==Q.rear)return ERROR;e=Q.elem[Q.front+1];Q.elem[Q.front+1]=-1;Q.front=(Q.front+1)%MAXSIZE;return OK;}void main(){SqQueue Q;InitQueue(Q);int elem,e;printf("请输入队列元素(以0结束):\n");scanf("%d",&elem);while(elem!=0){EnQueue(Q,elem);scanf("%d",&elem);}printf("队列为:\n");Display(Q);printf("1.初始化一个队列;\n2.入队;\n3.出队;\n4.显示队列的所有元素;\n5.队列长度:\n6.结束;\n");while(1){switch(menu_select()){case 1:printf("请输入队列元素(以0结束):\n");scanf("%d",&elem);while(elem!=0){EnQueue(Q,elem);scanf("%d",&elem);}printf("队列为:\n");Display(Q);fflush(stdin);break;case 2:scanf("%d",&elem);EnQueue(Q,elem);printf("队列为:\n");Display(Q);fflush(stdin);break;case 3:DeQueue(Q,elem);printf("队列为:\n");Display(Q);break;case 4:printf("\n队列的所有元素:\n");Display(Q);break;case 5:printf("%d\n",QueueLength(Q));break;case 6:return;}}}运行结果:实验二、数组㈠、实验内容:数组一般不做插入或删除操作,也就是说,一旦建立了数组,则结构中的数据元素个数和元素之间的关系就不再发生变动。

数据结构排序实验报告

数据结构排序实验报告

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

数据结构实验报告-排序

数据结构实验报告-排序

本章共8道实验题目。

一、直接插入排序1. 定义顺序表的存储结构2. 初始化顺序表为空表3. 输入10个元素创建含有10个元素的顺序表4. 输出顺序表5. 对顺序表进行直接插入排序(InsertSort)6. 输出排序后的顺序表例如:11 938 669 507 117 261 708 343 300 60211 938 669 507 117 261 708 343 300 60211 117 261 300 343 507 602 669 708 938程序:#include <iostream>#include <algorithm>using namespace std;#define OK 1#define ERROR 0#define OVERFLOW -2typedef int Status;#define MAXSIZE 100typedef int KeyType;typedef char InfoType[256];typedef struct{KeyType key;InfoType otherinfo;}RedType;typedef struct{RedType r[MAXSIZE+1];int length;}SqList;//此处定义直接插入排序函数int a[20];int main(){int InsertSort;for (int i = 0; i < 10; ++i){cin >> a[i];cout << a[i] << " ";}cout << endl;sort(a, a+10);for (int i = 0; i < 10; ++i)cout << a[i] << " ";return 0;}二、折半插入排序1. 定义顺序表的存储结构2. 初始化顺序表为空表3. 输入10个元素创建含有10个元素的顺序表4. 输出顺序表5. 对顺序表进行折半插入排序(BInsertSort)6. 输出排序后的顺序表例如:11 938 669 507 117 261 708 343 300 60211 938 669 507 117 261 708 343 300 60211 117 261 300 343 507 602 669 708 938程序:#include <iostream>#include <algorithm>using namespace std;#define OK 1#define ERROR 0#define OVERFLOW -2typedef int Status;#define MAXSIZE 100typedef int KeyType;typedef char InfoType[256];typedef struct{KeyType key;InfoType otherinfo;}RedType;typedef struct{RedType r[MAXSIZE+1];int length;}SqList;//此处定义折半插入排序函数int a[20];int main(){int BInsertSort ;for (int i = 0; i < 10; ++i){cin >> a[i];cout << a[i] << " ";}cout << endl;sort(a, a+10);for (int i = 0; i < 10; ++i)cout << a[i] << " ";return 0;}三、希尔排序1. 定义顺序表的存储结构2. 初始化顺序表为空表3. 输入10个元素创建含有10个元素的顺序表4. 输出顺序表5. 对顺序表进行希尔排序(ShellSort)6. 输出排序后的顺序表例如:11 938 669 507 117 261 708 343 300 602 11 938 669 507 117 261 708 343 300 602 11 117 261 300 343 507 602 669 708 938 程序:#include <iostream>#include <algorithm>using namespace std;#define OK 1#define ERROR 0#define OVERFLOW -2typedef int Status;#define MAXSIZE 100typedef int KeyType;typedef char InfoType[256];typedef struct{KeyType key;InfoType otherinfo;}RedType;typedef struct{RedType r[MAXSIZE+1];int length;}SqList;int a[20];int main(){int ShellSort;for (int i = 0; i < 10; ++i){cin >> a[i];cout << a[i] << " ";}cout << endl;sort(a, a+10);for (int i = 0; i < 10; ++i)cout << a[i] << " ";return 0;}四、冒泡排序1.定义顺序表的存储结构2.初始化顺序表为空表3.输入10个元素创建含有10个元素的顺序表4.输出顺序表5.对顺序表进行冒泡排序(BubbleSort)6.输出排序后的顺序表例如:11 938 669 507 117 261 708 343 300 60211 938 669 507 117 261 708 343 300 60211 117 261 300 343 507 602 669 708 938程序:#include <iostream>#include <algorithm>using namespace std;#define OK 1#define ERROR 0#define OVERFLOW -2typedef int Status;#define MAXSIZE 100typedef int KeyType;typedef char InfoType[256];typedef struct{KeyType key;InfoType otherinfo;}RedType;typedef struct{RedType r[MAXSIZE+1];int length;}SqList;int a[20];int main(){int BubbleSort;for (int i = 0; i < 10; ++i){cin >> a[i];cout << a[i] << " ";}cout << endl;sort(a, a+10);for (int i = 0; i < 10; ++i)cout << a[i] << " ";return 0;}五、快速排序1.定义顺序表的存储结构2.初始化顺序表为空表3.输入10个元素创建含有10个元素的顺序表4.输出顺序表5.对顺序表进行快速排序(QuickSort)6.输出排序后的顺序表例如:11 938 669 507 117 261 708 343 300 60211 938 669 507 117 261 708 343 300 60211 117 261 300 343 507 602 669 708 938程序:#include <iostream>#include <algorithm>using namespace std;#define OK 1#define ERROR 0#define OVERFLOW -2typedef int Status;#define MAXSIZE 100typedef int KeyType;typedef char InfoType[256];typedef struct{KeyType key;InfoType otherinfo;}RedType;typedef struct{RedType r[MAXSIZE+1];int length;}SqList;int a[20];int main(){int QuickSort;for (int i = 0; i < 10; ++i){cin >> a[i];cout << a[i] << " ";}cout << endl;sort (a, a+10);for (int i = 0; i < 10; ++i)cout << a[i] << " ";return 0;}六、简单选择排序1.定义顺序表的存储结构2.初始化顺序表为空表3.输入10个元素创建含有10个元素的顺序表4.输出顺序表5.对顺序表进行简单选择排序(SelectSort)6.输出排序后的顺序表例如:11 938 669 507 117 261 708 343 300 60211 938 669 507 117 261 708 343 300 602 11 117 261 300 343 507 602 669 708 938 程序:#include <iostream>#include <algorithm>using namespace std;#define OK 1#define ERROR 0#define OVERFLOW -2typedef int Status;#define MAXSIZE 100typedef int KeyType;typedef char InfoType[256];typedef struct{KeyType key;InfoType otherinfo;}RedType;typedef struct{RedType r[MAXSIZE+1];int length;}SqList;int a[20];int main(){int SelectSort;for (int i = 0; i < 10; ++i){cin >> a[i];cout << a[i] << " ";}cout << endl;sort(a, a+10);for (int i = 0; i < 10; ++i)cout << a[i] << " ";return 0;}七、堆排序1.定义顺序表的存储结构2.初始化顺序表为空表3.输入10个元素创建含有10个元素的顺序表4.输出顺序表5.对顺序表进行堆排序(HeapSort)6.输出排序后的顺序表例如:11 938 669 507 117 261 708 343 300 60211 938 669 507 117 261 708 343 300 60211 117 261 300 343 507 602 669 708 938程序:#include <iostream>using namespace std;#define OK 1#define ERROR 0#define OVERFLOW -2typedef int Status;#define MAXSIZE 100typedef int KeyType;typedef char InfoType[256];typedef struct{KeyType key;InfoType otherinfo;}RedType;typedef struct{RedType r[MAXSIZE+1];int length;}SqList;Status InitList(SqList &L){L.length=0;return 0;}Status CreateList(SqList &L,int n){if(!L.r||n<1||n>MAXSIZE) return ERROR;//cout<<"\n请输入"<<n<<"个元素(用空格隔开):";for(int i=1;i<=n;i++)cin>>L.r[i].key;L.length=n;return OK;}void ListTraverse(SqList L){//cout<<"L=(";for(int i=1;i<=L.length;i++)cout<<L.r[i].key<<' ';//if(L.length) cout<<'\b';//cout<<")";cout<<endl;}void HeapSort(SqList &L){int value = 0;for(int i = 0;i<L.length;i++)for(int j = 0;j<L.length-i;j++){if(L.r[j].key>L.r[j+1].key){value = L.r[j].key;L.r[j].key= L.r[j+1].key;L.r[j+1].key = value;}}int main(){SqList L;InitList(L);CreateList(L,10);ListTraverse(L);HeapSort(L);ListTraverse(L);return 0;}八、归并排序1.定义顺序表的存储结构2.初始化顺序表为空表3.输入10个元素创建含有10个元素的顺序表4.输出顺序表5.对顺序表进行二路归并排序(MergeSort)6.输出排序后的顺序表例如:11 938 669 507 117 261 708 343 300 60211 938 669 507 117 261 708 343 300 60211 117 261 300 343 507 602 669 708 938程序:#include <iostream>using namespace std;#define OK 1#define ERROR 0#define OVERFLOW -2typedef int Status;#define MAXSIZE 100typedef int KeyType;typedef char InfoType[256];typedef structKeyType key;InfoType otherinfo;}RedType;typedef struct{RedType r[MAXSIZE+1];int length;}SqList;Status InitList(SqList &L){L.length=0;return 0;}Status CreateList(SqList &L,int n){if(!L.r||n<1||n>MAXSIZE) return ERROR;//cout<<"\n请输入"<<n<<"个元素(用空格隔开):";for(int i=1;i<=n;i++)cin>>L.r[i].key;L.length=n;return OK;}void ListTraverse(SqList L){//cout<<"L=(";for(int i=1;i<=L.length;i++)cout<<L.r[i].key<<' ';//if(L.length) cout<<'\b';//cout<<")";cout<<endl;}void MSort(){}void Merge(){}void MergeSort(SqList &L){int value = 0;for(int i = 0;i<L.length;i++)for(int j = 0;j<L.length-i;j++){if(L.r[j].key>L.r[j+1].key){value = L.r[j].key;L.r[j].key= L.r[j+1].key;L.r[j+1].key = value;}}}int main(){SqList L;InitList(L);CreateList(L,10);ListTraverse(L);MergeSort(L);ListTraverse(L);return 0;}。

数据结构实验四题目一排序实验报告

数据结构实验四题目一排序实验报告

数据结构实验报告实验名称:实验四——排序学生:XX班级:班序号:学号:日期:1.实验要求实验目的:通过选择实验容中的两个题目之一,学习、实现、对比、各种排序的算法,掌握各种排序算法的优劣,以及各种算法使用的情况。

题目1:使用简单数组实现下面各种排序算法,并进行比较。

排序算法如下:1、插入排序;2、希尔排序;3、冒泡排序;4、快速排序;5、简单选择排序;6、堆排序;7、归并排序;8、基数排序(选作);9、其他。

具体要求如下:1、测试数据分成三类:正序、逆序、随机数据。

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

3、对于这三类数据,比较上述排序算法中不同算法的执行时间,精确到微妙。

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

5、编写main()函数测试各种排序算法的正确性。

2. 程序分析2.1 存储结构存储结构:数组2.2 关键算法分析一、关键算法:1、插入排序a、取排序的第二个数据与前一个比较b、若比前一个小,则赋值给哨兵c、从后向前比较,将其插入在比其小的元素后d、循环排序2、希尔排序a、将数组分成两份b、将第一份数组的元素与哨兵比较c、若其大与哨兵,其值赋给哨兵d、哨兵与第二份数组元素比较,将较大的值赋给第二份数组e、循环进行数组拆分3、对数据进行编码a、取数组元素与下一个元素比较b、若比下一个元素大,则与其交换c、后移,重复d、改变总元素值,并重复上述代码4、快速排序a、选取标准值b、比较高低指针指向元素,若指针保持前后顺序,且后指针元素大于标准值,后指针前移,重新比较c、否则后面元素赋给前面元素d、若后指针元素小于标准值,前指针后移,重新比较e、否则前面元素赋给后面元素5、简单选择排序a、从数组中选择出最小元素b、若不为当前元素,则交换c、后移将当前元素设为下一个元素6、堆排序a、生成小顶堆b、将堆的根节点移至数组的最后c、去掉已做过根节点的元素继续生成小顶堆d、数组倒置7、归并排序a、将数组每次以1/2拆分,直到为最小单位b、小相邻单位数组比较重排合成新的单位c、循环直至完成排序二、代码详细分析:1、插入排序关键代码:①取排序的第二个数据与前一个比较:if(r[i]<r[i-1])②若比前一个小,则赋值给哨兵:r[0]=r[i];③从后向前比较,将其插入在比其小的元素后:for(j=i-1;r[0]<r[j];j--){r[j+1]=r[j];a++;} r[j+1]=r[0];④循环排序2、希尔排序关键代码:①将数组分成两份:d=n/2②将第一份数组的元素与哨兵比较:for(int i=d+1;i<=n;i++)③若其大与哨兵,其值赋给哨兵:if(r[0]<r[i-d]){ r[0]=r[i];}④哨兵与第二份数组元素比较,将较大的值赋给第二份数组:for(j=i-d;j>0&&r[0]<r[j];j=j-d) {r[j+d]=r[j]; }⑤循环进行数组拆分:for(int;d>=1;d=d/2)3、冒泡排序关键代码:①取数组元素与下一个元素比较: for(int i=1;i<bound;i++)if(r[i]>r[i+1])②若比下一个元素大,则与其交换: r[0]=r[i]; r[i]=r[i+1]; r[i+1]=r[0];③后移,重复:for(int i=1;i<bound;i++)④改变总元素值,并重复上述代码:int bound=pos;4、快速排序关键代码:①选取标准值:r[0]=r[i]②比较高低指针指向元素,若指针保持前后顺序,且后指针元素大于标准值,后指针前移,重新比较:while(i<j&&r[j]>=flag) {j--;}③否则后面元素赋给前面元素:r[i]=r[j];④若后指针元素小于标准值,前指针后移,重新比较:while(i<j&&r[i]<=flag){i++;}⑤否则前面元素赋给后面元素:r[j]=r[i];5、简单选择排序关键代码:①从数组中选择出最小元素: for(int j=i+1;j<=n;j++)②{if(r[j]<r[index]) index=j; }③若不为当前元素,则交换:if(index!=i) {r[0]=r[i]; r[i]=r[index];r[index]=r[0];}④后移将当前元素设为下一个元素:for(int i=1;i<n;i++)6、堆排序关键代码:①生成小顶堆:while(j<=m) {if(j<m&&r[j]>r[j+1]) {j++;}②if(r[i]<r[j]) {break; }③else{ int x; x=r[i]; r[i]=r[j]; r[j]=x; i=j; j=2*i; }}④将堆的根节点移至数组的最后: x=r[1]; r[1]=r[n-i+1]; r[n-i+1]=x;⑤去掉已做过根节点的元素继续生成小顶堆:sift(r,1,n-i,x,y);⑥数组倒置输出: for(int i=n;i>0;i--)cout<<r[i]<<" ";7、归并排序关键代码:①将数组每次以1/2拆分,直到为最小单位: mid=(low+high)/2;②小相邻单位数组比较重排合成新的单位:while(i<=m&&j<=high)if(L.r[i]<=L.r[j]) t[k++]=L.r[i++];else t[k++]=L.r[j++];while(i<=m) t[k++]=L.r[i++];while(j<=high) t[k++]=L.r[j++];for(i=low,k=0;i<=high;i++,k++) L.r[i]=t[k];三、计算关键算法的时间、空间复杂度插入排序O(n2)希尔排序O(n2)冒泡排序O(n2)快速排序O(nlog2n)简单选择排序O(n2)堆排序O(nlog2n)归并排序O(nlog2n)3. 程序运行结果1、测试主函数流程:流程图如图所示流程图示意图程序运行结果图如下:2、测试条件:按题目要求分别输入同组数据的正序、逆序、随机序列进行测试。

数据结构实验报告-排序

数据结构实验报告-排序

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

数据结构排序实验报告

数据结构排序实验报告

数据结构排序实验报告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为止。

数据结构实验4 排序

数据结构实验4 排序

实验4快速排序一、实验目的和要求1 在掌握各种排序方法的排序过程的基础上,完成快速排序算法程序设计。

2 能够对排序算法进行基本的复杂度分析。

二、实验内容排序就是把一组元素按照某个域的值的递增或递减的次序重新排列的过程。

快速排序在待排序记录序列中任取一个记录作为枢轴,以它作为比较的“基准”,将待排序划分为左右两个子序列,使行左边子序列中记录的关键字均小于等于枢轴,右边子序列中各记录的关键字都大于等于枢轴。

对所划分的两组分别重复上述过程,直到各个序列的记录个数为1时为止。

快速排序函数原型QuickSort(SeqList sq)。

设计一个算法,在顺序表存储结构上实现快速排序。

排序数据为学生的考试成绩单。

成绩单由学生的学号、姓名和成绩组成,设计一个程序对给定的n个学生的成绩单按照名次列打印出每个学生的名次、学号、姓名和成绩。

三、实验步骤1.输入待排序的记录2. 对自定义记录类型重载比较运算符3.排序1)并选择第一个记录作为pivotkey记录2)从high指向的记录开始,向前找到第一个关键字的值小于Pivotkey的记录,将其放到low指向的位置,low+13).从low指向的记录开始,向后找到第一个关键字的值大于Pivotkey的记录,将其放到high指向的位置,high-14)重复2),3),直到low=high,将枢轴记录放在low(high)指向的位置5)重复2),3),4),直到整个记录有序为止6) 输出排序记录,完成比较。

4. 附加要求:不采用运算法重载的方式,而是定义compare函数指针,通过传给quicksort 函数指针,完成排序。

四、实验提示算法实现:#include "iostream.h"#define MaxSize 100typedef int DataType;class CRecord{public:int No;string name;int grade;}Typdef CRecord DataType;class SeqList{public:CRecord * data;int length;}//创建顺序表V oid SLCreat(SeqList & sq);{ CRecord x;length = 0;cout <<"请输入数据元素数”;cin>>sq.length;sq.data= new CRecord[sq.length];cout <<"请输入数据元素值: no, , name grade ";for(int i = 0; i < n; i++){cin >> sq.data[i].no>>sq .data[i].name>>sq. data[i]grade;}}//排序V oid Sort( SeqList & sq ){ SLCreat(sq);QuickSort(sq,0,sq.length);}//快速排序void QuickSort(SeqList & sq, int low, int high){ int pos;if(low < high){ pos = partition(sq,low, high);QuickSort(sq,low, pos-1);QuickSort(sq, pos+1, high);}}int partition(SeqList & list, int i, int j){ DataType pivotkey;pivotkey = list[i];while(i < j){ while(i < j&&list[j] >= pivotkey) --j;if(i < j) list[i++] = list[j];while(i < j&&list[i] <= pivotkey) ++i;if(i < j) list[j--] = list[i];}list[i] = pivotkeylreturn i;}//将顺序表显示在屏幕上void SLPrint(SeqList & sq){cout <<"快速排序结果: "’for(int i = 0; i <list.length; i++)cout<<i<<sq.data[i].no<<sq .data[i].name<<sq. data[i].grade<<endl;cout << endl;}void main( ){ SeqList myList;SLCreat(SeqList &mylist);Sort(mylist );SLPrint( );}。

数据结构 实验报告 排序

数据结构 实验报告 排序

实验报告实验目的:1.掌握各种排序方法的排序过程;2.了解一些排序算法的实现。

实验内容:学生的考试成绩表由学生的学号、姓名和成绩组成,设计一个程序对给定的n个学生信息实现:1.按分数高低排序,打印出每个学生在考试中的排名,分数相同的为同一名次,同一名次的学生按学号从小到大排列。

2.按照名次列出每个学生的名次、学号、姓名、成绩。

实验原理:排序分为插入排序、交换排序、选择排序、归并排序等。

插入排序又分为直接插入排序、其他插入排序和希尔排序;交换排序分为冒泡排序和快速排序;选择排序又分为简单选择排序和堆排序。

不同的排序方法各有利弊,根据具体的情况选择合适的排序方法。

设计思想:本程序采用简单选择排序的方法。

程序中定义一个stu结构和student类。

类中定义creat 创建函数,selectgrade成绩排序函数,samegrade、selectnum成绩相同的按学号排序函数,print输出函数。

按照选择排序的思想,先对成绩按照从高到低进行排序;然后寻找成绩相同的部分,对该局部元素的学号从小到大进行排序。

然后调用输出函数,输出名次、学号、姓名、成绩。

实现部分:源代码:#include<iostream.h>struct stu{int num;char name[100];int grade;};class student{ struct stu s[100];int length;int start,end;public:student(){length=0;}void creat();void selectgrade();void samegrade();void selectnum();void print();};//创建顺序表void student::creat(){cout<<"请依次输入学生的学号、姓名、成绩。

输入#结束:"<<endl; int num;cin>>num;while(num){s[length].num=num;cin>>s[length].name;cin>>s[length].grade;cin>>num;length++;}}//对成绩进行选择排序void student::selectgrade(){stu temp;int i,j,k;for(i=0;i<length;i++){k=i;for(j=i+1;j<length;j++){if(s[j].grade>s[k].grade)k=j;}if(k!=i){temp=s[i];s[i]=s[k];s[k]=temp;}}}//对成绩相同的学号进行选择排序void student::samegrade(){int i,j;for(i=0;i<length;i++){if(s[i].grade==s[i+1].grade){for(j=length-1;;j--){if(s[j].grade==s[i].grade)break;}start=i;end=j;i=j;}selectnum();}}//对学号进行选择排序void student::selectnum(){stu temp;int i,j,k;for(i=start;i<=end;i++){k=i;for(j=i+1;j<=end;j++){if(s[j].num<s[k].num)k=j;}if(k!=i){temp=s[i];s[i]=s[k];s[k]=temp;}}}void student::print(){int i,j=0,k=0;cout<<"成绩从高到低依次为(成绩相同按学号从小到大排列)"<<endl;cout<<"名次学号姓名成绩"<<endl;for(i=0;i<length;i++){ if(i==0)cout<<k+1<<" "<<s[i].num<<" "<<s[i].name<<""<<s[i].grade<<endl;else{if(s[i].grade==s[i-1].grade){j++;k=i-j;}else {j=0;k=i-j;}cout<<k+1<<" "<<s[i].num<<" "<<s[i].name<<" "<<s[i].grade<<endl;} }}int main(){student ss;ss.creat();ss.selectgrade();ss.samegrade();ss.print();}测试用例1.实验小节:通过本程序的练习,对各种排序方法的排序过程有了更深的了解,对各种排序算法的实现特别是选择排序有了更深的认识。

数据结构实验报告排序

数据结构实验报告排序

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

数据结构内排序实验报告

数据结构内排序实验报告

数据结构内排序实验报告数据结构内排序实验报告一、实验目的本实验旨在熟悉数据结构内排序算法的实现过程,比较各种内排序算法的效率和性能,并掌握它们的优缺点。

二、实验内容⒈实验环境搭建在实验开始前,需要搭建适当的实验环境,包括编程语言、集成开发环境(IDE)等。

⒉内排序算法实现选择合适的内排序算法,如冒泡排序、插入排序、选择排序、快速排序等,对给定的待排序数据进行实现。

⒊程序测试编写测试程序,随机生成一定量的数据,对每个内排序算法进行测试,并记录运行时间和比较次数。

⒋数据比较与分析将各个内排序算法的运行时间和比较次数进行比较,分析它们的优劣势。

⒌实验结论结合实验结果,给出对内排序算法的选择建议,并对实验过程中的问题进行总结。

三、实验步骤与介绍⒈实验环境搭建在本次实验中,我们选择使用C++编程语言,并搭建Visual Studio作为集成开发环境。

该环境提供了丰富的调试和测试工具,适合本次实验的需求。

⒉内排序算法实现我们选择了三种常见的内排序算法进行实现,包括冒泡排序、插入排序和快速排序。

a) 冒泡排序冒泡排序是一种交换排序算法,通过不断比较相邻元素并交换位置来实现排序。

具体实现步骤如下:- 从待排序数组的第一个元素开始,不断比较相邻两元素的大小。

- 如果前一个元素大于后一个元素,则交换它们的位置。

- 继续比较下一对元素,直到最后一个元素。

- 重复以上步骤,直到排序完成。

b) 插入排序插入排序是一种直接插入排序算法,通过不断将待排序元素插入已排序部分的合适位置来实现排序。

具体实现步骤如下:- 从待排序数组的第二个元素开始,依次将元素与前面已排好序的元素进行比较。

- 如果前一个元素大于待排序元素,则将前一个元素后移一位。

- 继续比较前一个元素,直到找到合适的位置插入待排序元素。

- 重复以上步骤,直到排序完成。

c) 快速排序快速排序是一种分治排序算法,通过不断地将数组分成两部分并对子数组递归进行排序来实现整体排序。

北邮数据结构实验报告排序

北邮数据结构实验报告排序

数据结构实验报告实验名称:实验四——排序学生姓名:班级:班内序号:学号:日期:2014年12月19日1.实验要求实验目的通过实现下述实验内容,学习、实现、对比各种排序算法,掌握各种排序算法的优劣,以及各种算法使用的情况。

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

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

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

2. 程序分析首先,题目要求测试不同的数据,所以可以手动输入待排序元素。

其次,由于对一组数据要求用不同的排序算法来处理,所以需要一个复制函数把排序前的无序数组寄存出去,为下一次排序做准备。

再次,由于每次排序后都需要把排序后的结果打印出来,代码是一样的,根据相同的代码可以封装成一个函数的思想,所以还需增加一个打印函数。

2.1 存储结构本程序采用简单数组来储存输入的待排序数组2.2 关键算法分析核心算法思想:1. 利用教材讲述的基本算法思想,实现七种排序算法,统计其运行相关数据。

2. 将七种排序函数入口地址作为函数指针数组,实现快速调用和统计。

使得程序代码可读性增、结构更加优化。

关键算法思想描述和实现:关键算法1:实现七种算法的基本排序功能。

1、插入排序:依次将待排序的序列中的每一个记录插入到先前排序好的序列中,直到全部记录排序完毕。

插入排序的思想是:每次从无序区取一元素将其添加到有序区中。

2、希尔排序:先将整个序列分割成若干个子列,分别在各个子列中运用直接插入排序,待整个序列基本有序时,再对全体记录进行一次直接插入排序。

数据结构顺序表实验报告

数据结构顺序表实验报告

数据结构顺序表实验报告数据结构顺序表实验报告1.实验目的:本实验旨在通过实现顺序表的基本操作,加深对数据结构顺序表的理解,并掌握相关算法的实现方法。

2.实验环境:●操作系统:Windows 10●编程语言:C/C++●开发工具:Visual Studio Code3.实验内容:3.1 初始化顺序表●定义顺序表结构体●实现创建顺序表的函数●实现销毁顺序表的函数3.2 插入元素●实现在指定位置插入元素的函数●实现在表尾插入元素的函数3.3 删除元素●实现删除指定位置元素的函数●实现删除指定值元素的函数3.4 查找元素●实现按值查找元素的函数●实现按位置查找元素的函数3.5 修改元素●实现修改指定位置元素的函数3.6 打印顺序表●实现打印顺序表中所有元素的函数4.实验步骤:4.1 初始化顺序表●定义顺序表结构体,并分配内存空间●初始化顺序表中的数据和长度4.2 插入元素●调用插入元素函数,在指定位置或表尾插入元素4.3 删除元素●调用删除元素函数,删除指定位置或指定值的元素4.4 查找元素●调用查找元素函数,按值或位置查找元素4.5 修改元素●调用修改元素函数,修改指定位置的元素4.6 打印顺序表●调用打印顺序表函数,输出顺序表中的所有元素5.实验结果:经过测试,顺序表的基本操作均能正确执行。

插入元素、删除元素、查找元素、修改元素和打印顺序表等功能都能正常运行。

6.实验总结:本实验通过实现顺序表的基本操作,巩固了对数据结构顺序表的理论知识,并加深了对算法的理解和应用能力。

顺序表是一种简单、易于实现的数据结构,适用于元素数量变化较少的情况下。

7.附件:无8.法律名词及注释:●顺序表:一种基本的线性数据结构,数据元素按照其逻辑位置依次存储在一片连续的存储空间中。

●初始化:为数据结构分配内存空间并进行初始化,使其具备基本的数据存储能力。

●插入元素:将一个新元素插入到已有元素的合适位置,使得数据结构保持有序或符合特定要求。

数据结构实验报告顺序表

数据结构实验报告顺序表

数据结构实验报告顺序表数据结构实验报告:顺序表摘要:顺序表是一种基本的数据结构,它通过一组连续的存储单元来存储线性表中的数据元素。

在本次实验中,我们将通过实验来探索顺序表的基本操作和特性,包括插入、删除、查找等操作,以及顺序表的优缺点和应用场景。

一、实验目的1. 理解顺序表的概念和特点;2. 掌握顺序表的基本操作;3. 了解顺序表的优缺点及应用场景。

二、实验内容1. 实现顺序表的初始化操作;2. 实现顺序表的插入操作;3. 实现顺序表的删除操作;4. 实现顺序表的查找操作;5. 对比顺序表和链表的优缺点;6. 分析顺序表的应用场景。

三、实验步骤与结果1. 顺序表的初始化操作在实验中,我们首先定义了顺序表的结构体,并实现了初始化操作,即分配一定大小的存储空间,并将表的长度设为0,表示表中暂时没有元素。

2. 顺序表的插入操作接下来,我们实现了顺序表的插入操作。

通过将插入位置后的元素依次向后移动一位,然后将新元素插入到指定位置,来实现插入操作。

我们测试了在表中插入新元素的情况,并验证了插入操作的正确性。

3. 顺序表的删除操作然后,我们实现了顺序表的删除操作。

通过将删除位置后的元素依次向前移动一位,来实现删除操作。

我们测试了在表中删除元素的情况,并验证了删除操作的正确性。

4. 顺序表的查找操作最后,我们实现了顺序表的查找操作。

通过遍历表中的元素,来查找指定元素的位置。

我们测试了在表中查找元素的情况,并验证了查找操作的正确性。

四、实验总结通过本次实验,我们对顺序表的基本操作有了更深入的了解。

顺序表的插入、删除、查找等操作都是基于数组的操作,因此在插入和删除元素时,需要移动大量的元素,效率较低。

但是顺序表的优点是可以随机访问,查找效率较高。

在实际应用中,顺序表适合于元素数量不变或变化不大的情况,且需要频繁查找元素的场景。

综上所述,顺序表是一种基本的数据结构,我们通过本次实验对其有了更深入的了解,掌握了顺序表的基本操作,并了解了其优缺点及应用场景。

数据结构排序实验报告

数据结构排序实验报告

引言概述:数据结构排序实验是计算机科学与技术专业中一项重要的实践课程。

通过实验,可以深入理解和掌握不同排序算法的原理、特点和性能表现。

本文将针对数据结构排序实验进行详细的阐述和总结,包括实验目的、实验内容、实验结果分析和总结。

一、实验目的1. 加深对数据结构排序算法的理解:通过实验,掌握不同排序算法的工作原理和实现方式。

2. 分析和比较不同排序算法的性能:对比不同排序算法在不同数据规模下的时间复杂度和空间复杂度,理解它们的优劣势。

3. 提高编程和算法设计能力:通过实验的编写,提升对排序算法的实现能力和代码质量。

二、实验内容1. 选择排序算法:选择排序是一种简单直观的排序算法,将序列分为有序和无序两部分,每次从无序部分选择最小(最大)元素,放到有序部分的末尾(开头)。

- 算法原理及步骤- 实现过程中的注意事项- 时间复杂度和空间复杂度的分析2. 插入排序算法:插入排序逐步构建有序序列,对于未排序的元素,在已排序序列中从后向前扫描,找到对应位置插入。

- 算法原理及步骤- 实现过程中的注意事项- 时间复杂度和空间复杂度的分析3. 快速排序算法:快速排序利用分治的思想,将序列分为左右两部分,选取基准元素,将小于基准的放在左边,大于基准的放在右边,递归地对左右部分进行排序。

- 算法原理及步骤- 实现过程中的注意事项- 时间复杂度和空间复杂度的分析4. 归并排序算法:归并排序是一种稳定的排序算法,通过将序列分为若干子序列,分别进行排序,然后再将排好序的子序列合并成整体有序序列。

- 算法原理及步骤- 实现过程中的注意事项- 时间复杂度和空间复杂度的分析5. 堆排序算法:堆是一种特殊的树状数据结构,堆排序利用堆的性质进行排序,通过构建大顶堆或小顶堆,并逐个将堆顶元素移出形成有序序列。

- 算法原理及步骤- 实现过程中的注意事项- 时间复杂度和空间复杂度的分析三、实验结果分析1. 比较不同排序算法的执行时间:根据实验数据和分析,对比不同排序算法在不同数据规模下的执行时间,并针对其时间复杂度进行验证和分析。

实验四 排序 实验报告材料

实验四 排序 实验报告材料

数据结构实验报告实验名称:实验四排序学生:班级:班序号:学号:日期:2012年12月21日1、实验要求题目2使用链表实现下面各种排序算法,并进行比较。

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

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

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

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

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

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

其存储结构如下图所示。

(1)单链表存储结构:(2)结点结构struct Node {int data;Node * next; };示意图:2.2关键算法分析一:关键算法(一)直接插入排序void LinkSort::InsertSort()直接插入排序是插入排序中最简单的排序方法,其基本思想是:依次将待排序序列中的每一个记录插入到一个已排好的序列中,直到全部记录都排好序。

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

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

数据结构课程设计排序实验报告

数据结构课程设计排序实验报告

《数据结构》课程设计报告专业班级姓名学号指导教师起止时间课程设计:排序综合一、任务描述利用随机函数产生n个随机整数(20000以上),对这些数进行多种方法进行排序。

(1)至少采用三种方法实现上述问题求解(提示,可采用的方法有插入排序、希尔排序、起泡排序、快速排序、选择排序、堆排序、归并排序)。

并把排序后的结果保存在不同的文件中。

(2)统计每一种排序方法的性能(以上机运行程序所花费的时间为准进行对比),找出其中两种较快的方法。

要求:根据以上任务说明,设计程序完成功能。

二、问题分析1、功能分析分析设计课题的要求,要求编程实现以下功能:(1)随机生成N个整数,存放到线性表中;(2)起泡排序并计算所需时间;(3)简单选择排序并计算时间;(4)希尔排序并计算时间;(5)直接插入排序并计算所需时间;(6)时间效率比较。

2、数据对象分析存储数据的线性表应为顺序存储。

三、数据结构设计使用顺序表实现,有关定义如下:typedef int Status;typedef int KeyType ; //设排序码为整型量typedef int InfoType;typedef struct { //定义被排序记录结构类型KeyType key ; //排序码I nfoType otherinfo; //其它数据项} RedType ;typedef struct {RedType * r; //存储带排序记录的顺序表//r[0]作哨兵或缓冲区int length ; //顺序表的长度} SqList ; //定义顺序表类型四、功能设计(一)主控菜单设计为实现通各种排序的功能,首先设计一个含有多个菜单项的主控菜单程序,然后再为这些菜单项配上相应的功能。

程序运行后,给出5个菜单项的内容和输入提示,如下:1.起泡排序2.简单选择排序3.希尔排序4. 直接插入排序0. 退出系统(二)程序模块结构由课题要求可将程序划分为以下几个模块(即实现程序功能所需的函数):●主控菜单项选择函数menu()●创建排序表函数InitList_Sq()●起泡排序函数Bubble_sort()●简单选择排序函数SelectSort()●希尔排序函数ShellSort();●对顺序表L进行直接插入排序函数Insertsort()(三)函数调用关系程序的主要结构(函数调用关系)如下图所示。

数据结构排序实验报告

数据结构排序实验报告

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

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

数据结构实验报告实验名称:实验四——排序学生姓名:XX班级:班内序号:学号:日期:1.实验要求实验目的:通过选择实验内容中的两个题目之一,学习、实现、对比、各种排序的算法,掌握各种排序算法的优劣,以及各种算法使用的情况。

题目1:使用简单数组实现下面各种排序算法,并进行比较。

排序算法如下:1、插入排序;2、希尔排序;3、冒泡排序;4、快速排序;5、简单选择排序;6、堆排序;7、归并排序;8、基数排序(选作);9、其他。

具体要求如下:1、测试数据分成三类:正序、逆序、随机数据。

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

3、对于这三类数据,比较上述排序算法中不同算法的执行时间,精确到微妙。

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

5、编写main()函数测试各种排序算法的正确性。

2. 程序分析2.1 存储结构存储结构:数组2.2 关键算法分析一、关键算法:1、插入排序a、取排序的第二个数据与前一个比较b、若比前一个小,则赋值给哨兵c、从后向前比较,将其插入在比其小的元素后d、循环排序2、希尔排序a、将数组分成两份b、将第一份数组的元素与哨兵比较c、若其大与哨兵,其值赋给哨兵d、哨兵与第二份数组元素比较,将较大的值赋给第二份数组e、循环进行数组拆分3、对数据进行编码a、取数组元素与下一个元素比较b、若比下一个元素大,则与其交换c、后移,重复d、改变总元素值,并重复上述代码4、快速排序a、选取标准值b、比较高低指针指向元素,若指针保持前后顺序,且后指针元素大于标准值,后指针前移,重新比较c、否则后面元素赋给前面元素d、若后指针元素小于标准值,前指针后移,重新比较e、否则前面元素赋给后面元素5、简单选择排序a、从数组中选择出最小元素b、若不为当前元素,则交换c、后移将当前元素设为下一个元素6、堆排序a、生成小顶堆b、将堆的根节点移至数组的最后c、去掉已做过根节点的元素继续生成小顶堆d、数组倒置7、归并排序a、将数组每次以1/2拆分,直到为最小单位b、小相邻单位数组比较重排合成新的单位c、循环直至完成排序二、代码详细分析:1、插入排序关键代码:①取排序的第二个数据与前一个比较:if(r[i]<r[i-1])②若比前一个小,则赋值给哨兵:r[0]=r[i];③从后向前比较,将其插入在比其小的元素后:for(j=i-1;r[0]<r[j];j--){r[j+1]=r[j];a++;} r[j+1]=r[0];④循环排序2、希尔排序关键代码:①将数组分成两份:d=n/2②将第一份数组的元素与哨兵比较:for(int i=d+1;i<=n;i++)③若其大与哨兵,其值赋给哨兵:if(r[0]<r[i-d]){ r[0]=r[i];}④哨兵与第二份数组元素比较,将较大的值赋给第二份数组:for(j=i-d;j>0&&r[0]<r[j];j=j-d) {r[j+d]=r[j]; }⑤循环进行数组拆分:for(int;d>=1;d=d/2)3、冒泡排序关键代码:①取数组元素与下一个元素比较:for(int i=1;i<bound;i++)if(r[i]>r[i+1])②若比下一个元素大,则与其交换:r[0]=r[i]; r[i]=r[i+1]; r[i+1]=r[0];③后移,重复:for(int i=1;i<bound;i++)④改变总元素值,并重复上述代码:int bound=pos;4、快速排序关键代码:①选取标准值:r[0]=r[i]②比较高低指针指向元素,若指针保持前后顺序,且后指针元素大于标准值,后指针前移,重新比较:while(i<j&&r[j]>=flag) {j--;}③否则后面元素赋给前面元素:r[i]=r[j];④若后指针元素小于标准值,前指针后移,重新比较:while(i<j&&r[i]<=flag) {i++;}⑤否则前面元素赋给后面元素:r[j]=r[i];5、简单选择排序关键代码:①从数组中选择出最小元素:for(int j=i+1;j<=n;j++)②{if(r[j]<r[index]) index=j; }③若不为当前元素,则交换:if(index!=i) {r[0]=r[i]; r[i]=r[index]; r[index]=r[0];}④后移将当前元素设为下一个元素:for(int i=1;i<n;i++)6、堆排序关键代码:①生成小顶堆:while(j<=m) {if(j<m&&r[j]>r[j+1]) {j++;}②if(r[i]<r[j]) {break; }③else{ int x; x=r[i]; r[i]=r[j]; r[j]=x; i=j; j=2*i; }}④将堆的根节点移至数组的最后:x=r[1]; r[1]=r[n-i+1]; r[n-i+1]=x;⑤去掉已做过根节点的元素继续生成小顶堆:sift(r,1,n-i,x,y);⑥数组倒置输出: for(int i=n;i>0;i--)cout<<r[i]<<" ";7、归并排序关键代码:①将数组每次以1/2拆分,直到为最小单位:mid=(low+high)/2;②小相邻单位数组比较重排合成新的单位:while(i<=m&&j<=high)if(L.r[i]<=L.r[j]) t[k++]=L.r[i++];else t[k++]=L.r[j++];while(i<=m) t[k++]=L.r[i++];while(j<=high) t[k++]=L.r[j++];for(i=low,k=0;i<=high;i++,k++) L.r[i]=t[k];三、计算关键算法的时间、空间复杂度插入排序O(n2)希尔排序O(n2)冒泡排序O(n2)快速排序O(nlog2n)简单选择排序O(n2)堆排序O(nlog2n)归并排序O(nlog2n)3. 程序运行结果1、测试主函数流程:流程图如图所示流程图示意图程序运行结果图如下:2、测试条件:按题目要求分别输入同组数据的正序、逆序、随机序列进行测试。

3、测试结论:不同的排序方法移动次数比较次数和所用时间都是有所区别的。

4. 总结调试时出现的问题及解决的方法:在调试时,开始在归并排序的时候,虽然代码编译成功,但调试出现了错误,通过逐步调试发现是由于发生了地址冲突。

因此将原本的直接调用数组改成了结构体数组,通过引用来实现归并排序,最终获得了成功心得体会:学习、实现、对比、各种排序的算法,掌握各种排序算法的优劣,以及各种算法使用的情况下一步的改进:改进计数器,寻找其他排序方式。

附:源代码#include<iostream>using namespace std;int Cnum = 0;int Mnum = 0;class LED{private :int compare;int move;public:void InsertSort(int r[] , int n) ;//直接插入排序void ShellInsert(int r[],int n) ;//希尔排序void BubbleSort(int r[],int n);//冒泡排序void Qsort(int r[],int i,int j);//快速排序void SelectSort(int r[],int n);//选择排序void HeapSort (int r[],int n);void MergePass(int r[],int r1[],int n ,int h);int Partion(int r[] ,int first ,int end );void Sift(int r[],int k , int m);void Merge(int r[],int r1[],int s,int m,int t);};void LED::InsertSort(int r[] , int n) //插入排序{compare = 0;move = 0;for(int i=2;i<=n;i++){if(r[i]<r[i-1]){r[0]=r[i];move ++;r[i]=r[i-1];move ++;int j;for(j=i-2;r[0]<r[j];j--){compare++;r[j+1]=r[j];move ++;}++compare;r[j+1]=r[0];move ++;}++compare;}for(int i=1;i<=n;i++)cout<<r[i]<<" ";cout<<"比较次数为"<<compare <<" ; 移动次数为"<<move<<" ;"; }void LED::ShellInsert(int r[],int n) //希尔排序{compare = 0;move = 0;for(int d=n/2;d>=1;d=d/2){for(int i=d+1;i<=n;i++){if(r[i]<r[i-d]){move++;r[0]=r[i];int j;for(j=i-d;j>0&&r[0]<r[j];j=j-d){r[j+d]=r[j];move++;}compare++;r[j+d]=r[0];move++;}compare++;}}for(int i=1;i<=n;i++)cout<<r[i]<<" ";cout<<"比较次数为"<<compare <<" ; 移动次数为"<<move<<" ;"; }void LED::BubbleSort(int r[],int n) //冒泡排序改进{compare = 0;move = 0;int pos = n ;while(pos != 0){int bound = pos;pos = 0;for(int i =1;i <bound ; i++){compare ++;if(r[i]>r[i+1]){r[0] = r[i];r[i] = r[i+1];r[i+1] = r[0]; //交换pos = i;move=move+3;}}}for(int i=1;i<=n;i++)cout<<r[i]<<" ";cout<<"比较次数为"<<compare <<" ; 移动次数为"<<move<<" ;";}int LED::Partion(int r[] ,int first ,int end ){int i = first ; //分区的左界int j = end; //分区的右界int pivot = r[i]; //保存第一个元素,作为基准元素while(i < j){while((i<j)&&(r[j]>=pivot)) //右侧扫描,寻找<pivot的元素前移{j -- ;Cnum++;}r[i] = r[j] ;while((i<j)&&(r[i]<=pivot )) //左侧扫描,寻找>pivot的元素后移{i ++;Cnum++;}r[j] = r[i];}r[i] = pivot ; //将轴值移动到i=j的位置return i; //返回分区的分界值i}void LED::Qsort(int r[],int i,int j){if(i < j){ Mnum ++;int pivotloc = Partion(r,i,j);Qsort (r,i,pivotloc -1); //左分区快速排序Qsort (r,pivotloc +1,j); // 右分区快速排序}else{}}void LED::SelectSort(int r[],int n) //简单选择排序{compare = 0;move = 0;for(int i =1 ; i <n ; i++) //n-1趟排序{int index = i; //查找最小记录的位置indexfor(int j = i + 1;j<=n;j++){compare++;if(r[j]<r[index])index = j;}if(index != i) //若第一就是最小元素,则不用交换{r[0] = r[i];r[i] = r[index];r[index] = r[0]; //利用r[0],作为临时空间交换记录move+=3;}}for(int i=1;i<=n;i++)cout<<r[i]<<" ";cout<<"比较次数为"<<compare <<" ; 移动次数为"<<move<<" ;"; }/*void LED::Sift(int r[],int k , int m){int i = k, j = 2*i;while(j<=m){if(j<m&&r[j]<r[j+1])j++;if(r[i]>=r[j])break;else{r[0] = r[i];r[i] = r[j];r[j] = r[0];i = j ;j = 2* i;}}}void LED::HeapSort (int r[],int n){for(int i = n/2; i >= 1 ; i--) //建堆Sift(r,i,n);for(int i = n;i>1;i--) //堆排序{r[0] = r[1]; r[1] = r[i];r[i]= r[0]; //输出堆顶元素Sift(r,1,i-1); //重建堆}}void LED::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++];elser1[k++] = r[j++];}while(i<=m)r1[k++] = r[i++];while(j<=t)r1[k++] = r[j++];}void LED::MergePass(int r[],int r1[],int n ,int h){int i = 1;while(i<=n-2*h+1){Merge (r ,r1,i,i+h-1,i+2*h-1);i+= 2*h;}if(i<n-h+1)Merge (r,r1,i,i+h-1,n);elsefor(;i<=n;i++)r1[i] = r[i];}*/void main(){int r1[10000],r2[10000],r3[10000];int R[10000];char y ;int j=0;cout<<"请输入元素个数:"<<endl;cin>>j;cout<<"请输入将要排序的元素(正序):"<<endl;for(int i=1;i<=j;i++){cin>>r1[i];}cout<<"请输入将要排序的元素(逆序):"<<endl;for(int i=1;i<=j;i++){cin>>r2[i];}cout<<"请输入将要排序的元素(乱序):"<<endl;for(int i=1;i<=j;i++){cin>>r3[i];}cout<<endl;LED l;for(int i= 1;i<=j;i++){R[i]=r1[i];}cout<<"直接插入排序正序输出结果:";l.InsertSort(R,j); cout<<endl;for(int i= 1;i<=j;i++){R[i]=r2[i];}cout<<"直接插入排序逆序输出结果:";l.InsertSort(R,j); cout<<endl;for(int i= 1;i<=j;i++){R[i]=r3[i];}cout<<"直接插入排序乱序输出结果:";l.InsertSort(R,j); cout<<endl;for(int i= 1;i<=j;i++){R[i]=r1[i];}cout<<"希尔排序正序输出结果:";l.ShellInsert(R,j); cout<<endl;for(int i= 1;i<=j;i++){R[i]=r2[i];}cout<<"希尔排序逆序输出结果:";l.ShellInsert(R,j); cout<<endl;for(int i= 1;i<=j;i++){R[i]=r3[i];}cout<<"希尔排序乱序输出结果:";l.ShellInsert(R,j); cout<<endl;for(int i= 1;i<=j;i++){R[i]=r1[i];}cout<<"冒泡排序正序输出结果:";l.BubbleSort(R,j); cout<<endl;for(int i= 1;i<=j;i++){R[i]=r2[i];}cout<<"冒泡排序逆序输出结果:";l.BubbleSort(R,j);cout<<endl;for(int i= 1;i<=j;i++){R[i]=r3[i];}cout<<"冒泡排序乱序输出结果:";l.BubbleSort(R,j);cout<<endl;for(int i= 1;i<=j;i++){R[i]=r1[i];}cout<<"快速排序正序输出结果:";l.Qsort(R,1,j);for(int k=1;k<=j;k++)cout<<R[k]<<" ";cout<<"比较次数为"<<Cnum <<" ; 移动次数为"<<Mnum<<" ";Cnum = 0;Mnum = 0;cout<<endl;for(int i= 1;i<=j;i++){R[i]=r2[i];}cout<<"快速排序逆序输出结果:";l.Qsort(R,1,j);for(int k=1;k<=j;k++)cout<<R[k]<<" ";cout<<"比较次数为"<<Cnum <<" ; 移动次数为"<<Mnum<<" ";Cnum = 0;Mnum = 0;cout<<endl;for(int i= 1;i<=j;i++){R[i]=r3[i];}cout<<"快速排序乱序输出结果:";l.Qsort(R,1,j);for(int k=1;k<=j;k++)cout<<R[k]<<" ";cout<<"比较次数为"<<Cnum <<" ; 移动次数为"<<Mnum<<" "; cout<<endl;for(int i= 1;i<=j;i++){R[i]=r1[i];}cout<<"简单选择排序正序输出结果:";l.SelectSort(R,j);cout<<endl;for(int i= 1;i<=j;i++){R[i]=r2[i];}cout<<"简单选择排序逆序输出结果:";l.SelectSort(R,j); cout<<endl;for(int i= 1;i<=j;i++){R[i]=r3[i];}cout<<"简单选择排序乱序输出结果:";l.SelectSort(R,j); cout<<endl;}。

相关文档
最新文档