c++数据结构实验链表排序
C语言链表实现冒泡法排序
C语⾔链表实现冒泡法排序功能是:从键盘输⼊字符以空格隔开当输⼊q或者Q时按回车表⽰输⼊结束先放出main函数int main(){MyNode *myNode = (MyNode *)malloc(sizeof(MyNode));if (NULL == myNode) {return 0;}getNum(myNode);sortList(myNode);printStr(myNode);freeStr(myNode);return 0;}然后就结构体#include <stdio.h>#include <stdlib.h>#include <string.h>typedef struct mynode{long value;struct mynode *next;}MyNode;最后是⼏个⽅法void getNum(MyNode *myNode){char s[20];printf("please input num and end with q/Q\n");scanf("%s", s);while ((strcmp(s, "q") != 0) && (strcmp(s , "Q") != 0)) {MyNode *temp = (MyNode *)malloc(sizeof(MyNode));if (NULL == temp) {return;}temp->value = strtol(s , 0, 0);temp->next = NULL;myNode->next = temp;myNode = myNode->next;scanf("%s", s);}}void printStr(MyNode *node){if (node == NULL) {return;}MyNode *temp = node;while (temp->next != NULL) {printf("%ld ", temp->next->value);temp = temp->next;}}void sortList(MyNode *node){if (NULL == node) {return;}MyNode *startP = node->next;MyNode *nextP = node->next;while (startP->next != NULL) {nextP = startP->next;while (nextP->next != NULL) {if (startP->next->value > nextP->next->value) { long temp = startP->next->value;startP->next->value = nextP->next->value; nextP->next->value = temp;}nextP = nextP->next;}startP = startP->next;}}void freeStr(MyNode *node){if (NULL == node) {return;}MyNode *old = NULL;while (node != NULL) {printf("d\n");old = node;node = node->next;free(old);}}。
数据结构排序实验报告
数据结构排序实验报告数据结构排序实验报告引言:数据结构是计算机科学中的重要概念之一,它涉及到数据的组织、存储和操作方式。
排序是数据结构中的基本操作之一,它可以将一组无序的数据按照特定的规则进行排列,从而方便后续的查找和处理。
本实验旨在通过对不同排序算法的实验比较,探讨它们的性能差异和适用场景。
一、实验目的本实验的主要目的是通过实际操作,深入理解不同排序算法的原理和实现方式,并通过对比它们的性能差异,选取合适的排序算法用于不同场景中。
二、实验环境和工具实验环境:Windows 10 操作系统开发工具:Visual Studio 2019编程语言:C++三、实验过程1. 实验准备在开始实验之前,我们需要先准备一组待排序的数据。
为了保证实验的公正性,我们选择了一组包含10000个随机整数的数据集。
这些数据将被用于对比各种排序算法的性能。
2. 实验步骤我们选择了常见的五种排序算法进行实验比较,分别是冒泡排序、选择排序、插入排序、快速排序和归并排序。
- 冒泡排序:该算法通过不断比较相邻元素的大小,将较大的元素逐渐“冒泡”到数组的末尾。
实现时,我们使用了双重循环来遍历整个数组,并通过交换元素的方式进行排序。
- 选择排序:该算法通过不断选择数组中的最小元素,并将其放置在已排序部分的末尾。
实现时,我们使用了双重循环来遍历整个数组,并通过交换元素的方式进行排序。
- 插入排序:该算法将数组分为已排序和未排序两部分,然后逐个将未排序部分的元素插入到已排序部分的合适位置。
实现时,我们使用了循环和条件判断来找到插入位置,并通过移动元素的方式进行排序。
- 快速排序:该算法通过选取一个基准元素,将数组分为两个子数组,并对子数组进行递归排序。
实现时,我们使用了递归和分治的思想,将数组不断划分为更小的子数组进行排序。
- 归并排序:该算法通过将数组递归地划分为更小的子数组,并将子数组进行合并排序。
实现时,我们使用了递归和分治的思想,将数组不断划分为更小的子数组进行排序,然后再将子数组合并起来。
数据结构实验报告-排序
数据结构实验报告-排序一、实验目的本实验旨在探究不同的排序算法在处理大数据量时的效率和性能表现,并对比它们的优缺点。
二、实验内容本次实验共选择了三种常见的排序算法:冒泡排序、快速排序和归并排序。
三个算法将在同一组随机生成的数据集上进行排序,并记录其性能指标,包括排序时间和所占用的内存空间。
三、实验步骤1. 数据的生成在实验开始前,首先生成一组随机数据作为排序的输入。
定义一个具有大数据量的数组,并随机生成一组在指定范围内的整数,用于后续排序算法的比较。
2. 冒泡排序冒泡排序是一种简单直观的排序算法。
其基本思想是从待排序的数据序列中逐个比较相邻元素的大小,并依次交换,从而将最大(或最小)的元素冒泡到序列的末尾。
重复该过程直到所有数据排序完成。
3. 快速排序快速排序是一种分治策略的排序算法,效率较高。
它将待排序的序列划分成两个子序列,其中一个子序列的所有元素都小于等于另一个子序列的所有元素。
然后对两个子序列分别递归地进行快速排序。
4. 归并排序归并排序是一种稳定的排序算法,使用分治策略将序列拆分成较小的子序列,然后递归地对子序列进行排序,最后再将子序列合并成有序的输出序列。
归并排序相对于其他算法的优势在于其稳定性和对大数据量的高效处理。
四、实验结果经过多次实验,我们得到了以下结果:1. 冒泡排序在数据量较小时,冒泡排序表现良好,但随着数据规模的增大,其性能明显下降。
排序时间随数据量的增长呈平方级别增加。
2. 快速排序相比冒泡排序,快速排序在大数据量下的表现更佳。
它的排序时间线性增长,且具有较低的内存占用。
3. 归并排序归并排序在各种数据规模下都有较好的表现。
它的排序时间与数据量呈对数级别增长,且对内存的使用相对较高。
五、实验分析根据实验结果,我们可以得出以下结论:1. 冒泡排序适用于数据较小的排序任务,但面对大数据量时表现较差,不推荐用于处理大规模数据。
2. 快速排序是一种高效的排序算法,适用于各种数据规模。
C语言数据结构线性表的基本操作实验报告
实验一线性表的基本操作一、实验目的与基本要求1.掌握数据结构中的一些基本概念。
数据、数据项、数据元素、数据类型和数据结构,以及它们之间的关系。
2.了解数据的逻辑结构和数据的存储结构之间的区别与联系;数据的运算与数据的逻辑结构的关系。
3.掌握顺序表和链表的基本操作:插入、删除、查找以及表的合并等运算。
4.掌握运用C语言上机调试线性表的基本方法。
二、实验条件1.硬件:一台微机2.软件:操作系统和C语言系统三、实验方法确定存储结构后,上机调试实现线性表的基本运算。
四、实验内容1.建立顺序表,基本操作包括:初始化,建立一个顺序存储的链表,输出顺序表,判断是否为空,取表中第i个元素,定位函数(返回第一个与x相等的元素位置),插入,删除。
2.建立单链表,基本操作包括:初始化,建立一个链式存储的链表,输出顺序表,判断是否为空,取表中第i个元素,定位函数(返回第一个与x相等的元素位置),插入,删除。
3.假设有两个按数据元素值非递减有序排列的线性表A和B,均以顺序表作为存储结构。
编写算法将A表和B表归并成一个按元素值非递增有序(允许值相同)排列的线性表C。
(可以利用将B中元素插入A中,或新建C表)4.假设有两个按数据元素值非递减有序排列的线性表A和B,均以单链表作为存储结构。
编写算法将A表和B表归并成一个按元素值递减有序(即非递增有序,允许值相同)排列的线性表C。
五、附源程序及算法程序流程图1.源程序(1)源程序(实验要求1和3)#include<stdio.h>#include<malloc.h>#include<stdlib.h>#define LIST_INIT_SIZE 100#define LISTINCREMENT 10typedef struct arr{int * elem;int length;int listsize;}Sqlist;void menu(); //菜单void InitList(Sqlist *p); // 创建线性表void ShowList(Sqlist *p); // 输出顺序线性表void ListDelete(Sqlist *p,int i,int &e); // 在顺序线性表中删除第i个元素,并用e返回其值void ListInsert(Sqlist *p); // 在顺序线性表中第i个元素前插入新元素evoid ListEmpty(Sqlist *p); // 判断L是否为空表void GetList(Sqlist *p,int i,int &e); // 用e返回L中第i个数据元素的值void ListInsert(Sqlist *p,int i,int e);bool compare(int a,int b);void LocateElem(Sqlist *L,int e); // 在顺序线性表L中查找第1个值与e满足compare()d元素的位序void MergeList_L(Sqlist *La,Sqlist *Lb); // 归并void main(){Sqlist La;Sqlist Lb;int n,m,x;menu();scanf("%d",&n);while(n){switch(n){case 0: ; break;case 1:InitList(&La);break;case 2:ListEmpty(&La);break;case 3:printf("请输入插入的位序:\n");scanf("%d",&m);printf("请出入要插入的数:\n");scanf("%d",&x);ListInsert(&La,m,x);break;case 4:printf("请输入删除元素的位序:\n");scanf("%d",&m);ListDelete(&La,m,x);printf("删除的元素为:%d\n",x);break;case 5:printf("请输入要找的与线性表中相等的数:\n");scanf("%d",&m);LocateElem(&La,m);break;case 6:printf("请输入查找的位序:\n");scanf("%d",&m);GetList(&La,m,x);printf("La中第%d个元素的值为%d\n",m,x);break;case 7:ShowList(&La);break;case 8:InitList(&Lb);break;case 9:MergeList_L(&La,&Lb);printf("归并成功!");break;}menu();scanf("%d",&n);}}/*菜单*/void menu(){printf("********************\n\n");printf(" 0.退出\n\n");printf(" 1.创建线性表La\n\n");printf(" 2.判断La是否为空表\n\n");printf(" 3.插入元素(La)\n\n");printf(" 4.删除元素(La)\n\n");printf(" 5.定位元素(La)\n\n");printf(" 6.取元素(La)\n\n");printf(" 7.输出线性表\n\n");printf(" 8.创建线性表Lb\n\n");printf(" 9.归并为一个线性表La\n\n");printf("********************\n\n");}/*创建顺序线性表L*/void InitList(Sqlist *L){int n;int i=0;L->elem=(int *)malloc(LIST_INIT_SIZE*sizeof(int));if(NULL==L->elem)printf("储存分配失败!\n");else{L->length=0;L->listsize=LIST_INIT_SIZE;printf("输入顺序表a:\n");scanf("%d",&n);while(n){L->elem[i]=n;i++;L->length++;L->listsize=L->listsize-4;scanf("%d",&n);}}}/*输出顺序线性表*/void ShowList(Sqlist *p){int i;if(0==p->length)printf("数组为空!\n");elsefor(i=0;i<p->length;i++)printf("%d ",p->elem[i]);printf("\n");}/*判断L是否为空表*/void ListEmpty(Sqlist *p)if(0==p->length)printf("L是空表!\n");elseprintf("L不是空表!\n");}/*在顺序线性表中第i个元素前插入新元素e */void ListInsert(Sqlist *p,int i,int e){int *newbase;int *q1;int *q2;while(i<1||i>p->length+1){printf("您输入的i超出范围!\n请重新输入要插入的位置\n:");scanf("%d",&i);}if(p->length>=p->listsize){newbase=(int *)realloc(p->elem,(p->listsize+LISTINCREMENT)*sizeof(int));if(!newbase)exit(0);else{p->elem=newbase;p->listsize+=LISTINCREMENT;}}q1=&(p->elem[i-1]);for(q2=&(p->elem[p->length-1]);q2>=q1;--q2)*(q2+1)=*q2;*q1=e;++p->length;}/*/在顺序线性表中删除第i个元素,并用e返回其值*/void ListDelete(Sqlist *p,int i,int &e){int *q1,*q2;while(i<1||i>p->length){printf("您输入的i超出范围!请重新输入:");scanf("%d",&i);}q1=&(p->elem[i-1]);e=*q1;q2=p->elem+p->length-1;for(++q1;q1<=q2;++q1)*(q1-1)=*q1;--p->length;}/*对比a与b相等*/bool compare(int a,int b){if(a==b)return 1;elsereturn 0;}/*在顺序线性表L中查找第1个值与e满足compare()d元素的位序*/ void LocateElem(Sqlist *L,int e){int i=1;int *p;p=L->elem;while(i<=L->length && !compare(*p++,e))++i;if(i<=L->length)printf("第1个与e相等的元素的位序为%d\n",i);elseprintf("没有该元素!\n");}/*用e返回L中第i个数据元素的值*/void GetList(Sqlist *p,int i,int &e){Sqlist *p1;p1=p;e=p1->elem[i-1];}/* 已知顺序线性表La和Lb是元素按值非递减排列*//* 把La和Lb归并到La上,La的元素也是按值非递减*/void MergeList_L(Sqlist *La,Sqlist *Lb){int i=0,j=0,k,t;int *newbase;Sqlist *pa,*pb;pa=La;pb=Lb;while(i<pa->length && j<pb->length){if(pa->elem[i] >= pb->elem[j]){if(pa->listsize==0){newbase=(int*)realloc(pa->elem,(pa->listsize+LISTINCREMENT)*sizeof(int));if(!newbase)exit(0);}for(k=pa->length-1; k>=i; k--)pa->elem[k+1]=pa->elem[k];pa->length++;pa->elem[i]=pb->elem[j];i++;j++;}elsei++;}while(j<pb->length){if( pa->listsize < pb->length-j ){newbase=(int*)realloc(pa->elem,(pa->listsize+LISTINCREMENT)*sizeof(int));if(!newbase)exit(0);}for(j;j<pb->length;j++,i++){pa->elem[i]=pb->elem[j];pa->length++;}}for(i=0;i<pa->length/2;i++){t=pa->elem[i];pa->elem[i]=pa->elem[pa->length-i-1];pa->elem[pa->length-i-1]=t;}}(2)源程序(实验要求2和4)#include<stdio.h>#include<malloc.h>#include<stdlib.h>typedef struct LNode{int data;struct LNode *next;}LNode, *LinkList;void menu();LinkList InitList();void ShowList(LinkList L);void ListDelete(LinkList L,int i,int &e);void ListEmpty(LinkList L);void GetList(LinkList L,int i,int &e);void ListInsert(LinkList L,int i,int e);bool compare(int a,int b);void LocateElem(LinkList L,int e);LinkList MergeList_L(LinkList La,LinkList Lb);int total=0;void main(){LinkList La;LinkList Lb;La=(LinkList)malloc(sizeof(struct LNode));La->next=NULL;Lb=(LinkList)malloc(sizeof(struct LNode));Lb->next=NULL;int n;int m;int x;menu();scanf("%d",&n);while(n){switch(n){case 0: ; break;case 1:La->next=InitList();break;case 2:ListEmpty(La);break;case 3:printf("请输入要插入到第几个节点前:\n");scanf("%d",&m);printf("请输入插入的数据:\n");scanf("%d",&x);ListInsert(La,m,x);break;case 4:printf("请输入删除元素的位序:\n");scanf("%d",&m);ListDelete(La,m,x);printf("删除的元素为:%d\n",x);break;case 5:printf("请输入要找的与线性表中相等的数:\n");scanf("%d",&m);LocateElem(La,m);break;case 6:printf("请输入查找的位序:\n");scanf("%d",&m);GetList(La,m,x);printf("La中第%d个元素的值为%d\n",m,x);break;case 7:ShowList(La);break;case 8:Lb->next=InitList();break;case 9:La=MergeList_L(La,Lb);printf("归并成功\n");break;}menu();scanf("%d",&n);}}void menu(){printf("********************\n\n");printf(" 0.退出\n\n");printf(" 1.创建线性表La\n\n");printf(" 2.判断是否为空表\n\n");printf(" 3.插入元素\n\n");printf(" 4.删除元素\n\n");printf(" 5.定位元素\n\n");printf(" 6.取元素\n\n");printf(" 7.输出线性表\n\n");printf(" 8.创建线性表Lb\n\n");printf(" 9.归并两线性表\n\n");printf("********************\n\n");}// 创建链式线性表LLinkList InitList(){int count=0;LinkList pHead=NULL;LinkList pEnd,pNew;pEnd=pNew=(LinkList)malloc(sizeof(struct LNode));printf("请输入数据:\n");scanf("%d",&pNew->data);while(pNew->data){count++;if(count==1){pNew->next=pHead;pEnd=pNew;pHead=pNew;}else{pNew->next=NULL;pEnd->next=pNew;pEnd=pNew;}pNew=(LinkList)malloc(sizeof(struct LNode));printf("请输入数据:\n");scanf("%d",&pNew->data);}free(pNew);total=total+count;return pHead;}// 判断L是否为空表void ListEmpty(LinkList L){if(NULL==L->next)printf("此表为空表!\n");elseprintf("此表不为空表!\n");}// 在链式线性表中第i个元素前插入新元素e void ListInsert(LinkList L,int i,int e){LinkList p;LinkList s;p=L;int j=0;while(p&&j<i-1){p=p->next;++j;}if(!p||j>i-1)printf("不存在您要找的节点!\n");else{s=(LinkList)malloc(sizeof(int));s->data=e;s->next=p->next;p->next=s;printf("插入节点成功!\n");}}// 输出链式线性表void ShowList(LinkList L){LinkList p;p=L->next;if(p==NULL)printf("此表为空表!\n");elsewhile(p){printf("%d ",p->data);p=p->next;}printf("\n");}// 在链式线性表中删除第i个元素,并用e返回其值void ListDelete(LinkList L,int i,int &e){LinkList p;LinkList q;p=L;int j=0;while(p->next && j<i-1){p=p->next;++j;}if(!(p->next)||j>i-1)printf("没有找到要删除的位置!");else{q=p->next;p->next=q->next;e=q->data;free(q);}}// 用e返回L中第i个数据元素的值void GetList(LinkList L,int i,int &e){LinkList p;p=L->next;int j=0;while(p->next && j<i-1){p=p->next;++j;}if(!(p)||j>i-1)printf("没有找到要查找的位置!");elsee=p->data;}// 对比a与b相等bool compare(int a,int b){if(a==b)return 1;elsereturn 0;}// 在链式线性表L中查找第1个值与e满足compare()d元素的位序void LocateElem(LinkList L,int e){int i=0;LinkList p;p=L;while(p->next && !compare(p->data,e)){p=p->next;i++;}if(NULL==p->next){if(0==compare(p->data,e))printf("没有该元素!\n");elseprintf("第1个与e相等的元素的位序为%d\n",i);}elseif(compare(p->data,e))printf("没有该元素!\n");}LinkList MergeList_L(LinkList La,LinkList Lb){int i,j,k;LinkList pa_1,pb_1,pa_2,pb_2,pc,pd;pa_1=La->next;pc=pa_2=La;pb_1=pb_2=Lb->next;if(pa_1->data > pb_1->data){pc=pa_2=Lb;pa_1=Lb->next;pb_1=pb_2=La->next;}while(pa_1 && pb_1){if(pa_1->data >= pb_1->data){pa_2->next=pb_1;pb_2=pb_1->next;pb_1->next=pa_1;pb_1=pb_2;pa_2=pa_2->next;}else{pa_1=pa_1->next;pa_2=pa_2->next;}}if(pb_1)pa_2->next=pb_1;pd=(LinkList)malloc(sizeof(struct LNode));pd->next=NULL;pa_2=pd;k=total;for(i=0;i<total;i++){pa_1=pc->next;for(j=1;j<k;j++)pa_1=pa_1->next;pb_1=(LinkList)malloc(sizeof(struct LNode));pa_2->next=pb_1;pa_2=pa_2->next;pa_2->data=pa_1->data;k--;}pa_2->next=NULL;return pd;}2.流程图(实验要求1和3)图1 主函数流程图图2创建线性表La流程图图3判断La是否为空表流程图图4 插入元素(La)流程图图5删除元素(La)流程图图6定位元素(La)流程图图7取元素(La)流程图图8输出线性表流程图图9输出线性表流程图流程图(实验要求2和4)图10主函数流程图图11创建线性表La流程图图12判断是否为空表流程图图13插入元素流程图图14删除元素流程图图15定位元素流程图图图16取元素流程图图17创建Lb流程图图18归并两表流程图六、运行结果1. (实验要求1和3)点击运行,首先出现的是菜单界面,选择菜单选项进行操作,如图所示。
数据结构 实验报告
数据结构实验报告一、实验目的数据结构是计算机科学中非常重要的一门课程,通过本次实验,旨在加深对常见数据结构(如链表、栈、队列、树、图等)的理解和应用,提高编程能力和解决实际问题的能力。
二、实验环境本次实验使用的编程语言为C++,开发工具为Visual Studio 2019。
操作系统为 Windows 10。
三、实验内容1、链表的实现与操作创建一个单向链表,并实现插入、删除和遍历节点的功能。
对链表进行排序,如冒泡排序或插入排序。
2、栈和队列的应用用栈实现表达式求值,能够处理加、减、乘、除和括号。
利用队列实现银行排队系统的模拟,包括顾客的到达、服务和离开。
3、二叉树的遍历与操作构建一棵二叉树,并实现前序、中序和后序遍历。
进行二叉树的插入、删除节点操作。
4、图的表示与遍历用邻接矩阵和邻接表两种方式表示图。
实现图的深度优先遍历和广度优先遍历。
四、实验步骤及结果1、链表的实现与操作首先,定义了链表节点的结构体:```cppstruct ListNode {int data;ListNode next;ListNode(int x) : data(x), next(NULL) {}};```插入节点的函数:```cppvoid insertNode(ListNode& head, int val) {ListNode newNode = new ListNode(val);head = newNode;} else {ListNode curr = head;while (curr>next!= NULL) {curr = curr>next;}curr>next = newNode;}}```删除节点的函数:```cppvoid deleteNode(ListNode& head, int val) {if (head == NULL) {return;}ListNode temp = head;head = head>next;delete temp;return;}ListNode curr = head;while (curr>next!= NULL && curr>next>data!= val) {curr = curr>next;}if (curr>next!= NULL) {ListNode temp = curr>next;curr>next = curr>next>next;delete temp;}}```遍历链表的函数:```cppvoid traverseList(ListNode head) {ListNode curr = head;while (curr!= NULL) {std::cout << curr>data <<"";curr = curr>next;}std::cout << std::endl;}```对链表进行冒泡排序的函数:```cppvoid bubbleSortList(ListNode& head) {if (head == NULL || head>next == NULL) {return;}bool swapped;ListNode ptr1;ListNode lptr = NULL;do {swapped = false;ptr1 = head;while (ptr1->next!= lptr) {if (ptr1->data > ptr1->next>data) {int temp = ptr1->data;ptr1->data = ptr1->next>data;ptr1->next>data = temp;swapped = true;}ptr1 = ptr1->next;}lptr = ptr1;} while (swapped);}```测试结果:创建了一个包含 5、3、8、1、4 的链表,经过排序后,输出为 1 3 4 5 8 。
链表排序(冒泡、选择、插入、快排、归并、希尔、堆排序)
链表排序(冒泡、选择、插⼊、快排、归并、希尔、堆排序)这篇⽂章分析⼀下链表的各种排序⽅法。
以下排序算法的正确性都可以在LeetCode的这⼀题检测。
本⽂⽤到的链表结构如下(排序算法都是传⼊链表头指针作为参数,返回排序后的头指针)struct ListNode {int val;ListNode *next;ListNode(int x) : val(x), next(NULL) {}};插⼊排序(算法中是直接交换节点,时间复杂度O(n^2),空间复杂度O(1))class Solution {public:ListNode *insertionSortList(ListNode *head) {// IMPORTANT: Please reset any member data you declared, as// the same Solution instance will be reused for each test case.if(head == NULL || head->next == NULL)return head;ListNode *p = head->next, *pstart = new ListNode(0), *pend = head;pstart->next = head; //为了操作⽅便,添加⼀个头结点while(p != NULL){ListNode *tmp = pstart->next, *pre = pstart;while(tmp != p && p->val >= tmp->val) //找到插⼊位置{tmp = tmp->next; pre = pre->next;}if(tmp == p)pend = p;else{pend->next = p->next;p->next = tmp;pre->next = p;}p = pend->next;}head = pstart->next;delete pstart;return head;}};选择排序(算法中只是交换节点的val值,时间复杂度O(n^2),空间复杂度O(1))class Solution {public:ListNode *selectSortList(ListNode *head) {// IMPORTANT: Please reset any member data you declared, as// the same Solution instance will be reused for each test case.//选择排序if(head == NULL || head->next == NULL)return head;ListNode *pstart = new ListNode(0);pstart->next = head; //为了操作⽅便,添加⼀个头结点ListNode*sortedTail = pstart;//指向已排好序的部分的尾部while(sortedTail->next != NULL){ListNode*minNode = sortedTail->next, *p = sortedTail->next->next;//寻找未排序部分的最⼩节点while(p != NULL){if(p->val < minNode->val)minNode = p;p = p->next;}swap(minNode->val, sortedTail->next->val);sortedTail = sortedTail->next;}head = pstart->next;delete pstart;return head;}};快速排序1(算法只交换节点的val值,平均时间复杂度O(nlogn),不考虑递归栈空间的话空间复杂度是O(1))这⾥的partition我们参考(选取第⼀个元素作为枢纽元的版本,因为链表选择最后⼀元素需要遍历⼀遍),具体可以参考这⾥我们还需要注意的⼀点是数组的partition两个参数分别代表数组的起始位置,两边都是闭区间,这样在排序的主函数中:void quicksort(vector<int>&arr, int low, int high){if(low < high){int middle = mypartition(arr, low, high);quicksort(arr, low, middle-1);quicksort(arr, middle+1, high);}}对左边⼦数组排序时,⼦数组右边界是middle-1,如果链表也按这种两边都是闭区间的话,找到分割后枢纽元middle,找到middle-1还得再次遍历数组,因此链表的partition采⽤前闭后开的区间(这样排序主函数也需要前闭后开区间),这样就可以避免上述问题class Solution {public:ListNode *quickSortList(ListNode *head) {// IMPORTANT: Please reset any member data you declared, as// the same Solution instance will be reused for each test case.//链表快速排序if(head == NULL || head->next == NULL)return head;qsortList(head, NULL);return head;}void qsortList(ListNode*head, ListNode*tail){//链表范围是[low, high)if(head != tail && head->next != tail){ListNode* mid = partitionList(head, tail);qsortList(head, mid);qsortList(mid->next, tail);}}ListNode* partitionList(ListNode*low, ListNode*high){//链表范围是[low, high)int key = low->val;ListNode* loc = low;for(ListNode*i = low->next; i != high; i = i->next)if(i->val < key){loc = loc->next;swap(i->val, loc->val);}swap(loc->val, low->val);return loc;}};快速排序2(算法交换链表节点,平均时间复杂度O(nlogn),不考虑递归栈空间的话空间复杂度是O(1))这⾥的partition,我们选取第⼀个节点作为枢纽元,然后把⼩于枢纽的节点放到⼀个链中,把不⼩于枢纽的及节点放到另⼀个链中,最后把两条链以及枢纽连接成⼀条链。
数据结构(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].num<=RandArray[i]; L->Length<=i;}BOOL LT(int i, int j,int* CmpNum){(*CmpNum)++; 若i<j) 则返回TRUE; 否则返回FALSE;}void Display(LinkList* L){FILE* f; //定义一个文件指针f int i;若打开文件的指令不为空则//通过文件指针f打开文件为条件判断{ //是否应该打开文件输出“can't open file”;exit(0); }for (i=0; i小于L->Length; i++)fprintf(f,"%d\n",L->Record[i].num);通过文件指针f关闭文件;三、调试分析1.调试过程中遇到的问题及经验体会:在本次程序的编写和调试过程中,我曾多次修改代码,并根据调试显示的界面一次次调整代码。
数据结构实验(使用版)
实验一顺序表的应用一.实验目的1、掌握线性表的顺序存储结构的基本操作的实现。
2、设计并实现顺序表的应用程序,提高编程能力。
二.实验内容编写程序实现:1、在原来的顺序表中将顺序表实现逆置。
2、要求顺序表的内容由用户输入,并分别显示出逆置前和逆置后的顺序表。
三.实验设备及实验环境实验设备:微机一台实验环境:C语言运行环境实验二单链表的应用三.实验目的1、掌握线性表的链式存储结构的基本操作的实现。
2、设计并实现单链表的应用程序,提高编程能力。
四.实验内容编写程序实现:1、在原有的单链表中,将单链表实现逆置。
(即不增加新的结点)2、程序要求单链表的内容由用户输入,并分别显示出逆置前和逆置后的单链表。
三.实验设备及实验环境实验设备:微机一台实验环境:C语言运行环境实验三栈和队列的应用一.实验目的1、掌握栈和队列的基本操作的实现。
2、利用栈和队列的特点解决实际问题,提高编程能力。
二.实验内容(1是必做题目,2和3可选其一)编写两个程序分别实现:1、进制之间的转换:如将10进制转换为2进制,10进制数n和要转换的进制d通过键盘输入。
2、利用栈解决火车调度问题,将本来杂乱无章的车厢排成软席(S)在前,硬席(H)在后。
车厢序列通过键盘输入,如HSHSHSSSH,输出SSSSSHHHH。
3、利用队列模拟医院排队系统。
三.实验设备及实验环境实验设备:微机一台实验环境:C语言运行环境实验四二叉树的操作(一)一、实验目的1、熟悉二叉树的概念和存储结构。
2、掌握二叉树的基本操作和实现方法。
二.实验内容1、利用栈并且采用非递归先序算法建立二叉树。
2、要求通过键盘输入二叉树的先序遍历顺序从而建立一棵二叉树。
三.实验设备及实验环境实验设备:微机一台实验环境:C语言运行环境实验五二叉树的基本操作(二)一、实验目的1.熟悉二叉树的遍历方法。
2.掌握非递归中序遍历、先序遍历和后序遍历算法的实现。
二.实验内容(中序非递归遍历必做、先序和后序可选其一)1、在前一实验的基础上,利用栈实现一棵二叉树的非递归遍历。
链表实现排序算法
链表实现排序算法本页仅作为文档页封面,使用时可以删除This document is for reference only-rar21year.March数据结构实验报告实验名称:实验三排序学生姓名:班级:班内序号: 15 学号:日期:1.实验要求题目2使用链表实现下面各种排序算法,并进行比较。
排序算法:1、插入排序2、冒泡排序3、快速排序4、简单选择排序5、其他要求:1、测试数据分成三类:正序、逆序、随机数据2、对于这三类数据,比较上述排序算法中关键字的比较次数和移动次数(其中关键字交换计为3次移动)。
3、对于这三类数据,比较上述排序算法中不同算法的执行时间,精确到微秒(选作)4、对2和3的结果进行分析,验证上述各种算法的时间复杂度编写测试main()函数测试线性表的正确性2. 程序分析存储结构我使用了线性表的链式存储结构,通过建立双向循环链表进行顺序存取。
每个节点分为data、next、previor。
data域称为数据域,数据通过node 结构存储待排序的信息;next为指针域,用来储存直接后继的地址;prior为指针域,用来储存直接前继的地址;struct Node{int data;struct Node*next;struct Node*previor;};程序流程 (或程序结构、或类关系图等表明程序构成的内容,一般为流程图等)class LinkList {private:是Node* partion(Node*first,Node*end);入排序 2.冒泡排序\n""3.快速排序 4.简单选择排序\n""5.退出\n";cin >> choice;int count = 0;Node*x, *y, *z;while (choice != 5){switch (choice){case 1:if (count != 0){x = >next;y = >next;z = >next;for (int i = 0; i < 7; i++){x->data = jay1[i];y->data = jay2[i];z->data = jay3[i];x = x->next;y = y->next;z = z->next;}= = 0;= = 0;= = 0;}cout << "插入排序:\n";();();();();();();count = 1;break;case 2:if (count != 0){x = >next;y = >next;z = >next;for (int i = 0; i < 7; i++){x->data = jay1[i];y->data = jay2[i];z->data = jay3[i];x = x->next;y = y->next;z = z->next;}= = 0;= = 0;= = 0;}();();();cout << "冒泡排序:\n";();();();count = 1;break;case 3:if (count != 0){x = >next;y = >next;z = >next;for (int i = 0; i < 7; i++){x->data = jay1[i];y->data = jay2[i];z->data = jay3[i];x = x->next;y = y->next;z = z->next;}= = 0;= = 0;= = 0;}x = ;y = ;z = ;(x->next, x->previor);(y->next, y->previor);(z->next, z->previor);cout << "快速排序:\n";();();();count = 1;break;case 4:if (count != 0){x = >next;y = >next;z = >next;for (int i = 0; i < 7; i++){x->data = jay1[i];y->data = jay2[i];z->data = jay3[i];x = x->next;y = y->next;z = z->next;}= = 0;= = 0;= = 0;}();();();cout << "简单选择排序:\n"; ();();();count = 1;break;default:cout << "这不是一个选项。
数据结构实验报告(C语言)顺序表__排序
int i,j,n,x,change; n=L->length; change=1; for(i=1;i<=n-1 && change;++i){
change=0; for(j=1;j<=n-i-1;++j)
if(L->r[j] > L->r[j+1]){ x=L->r[j]; L->r[j]=L->r[j+1]; L->r[j+1]=x; change=1;
void QuickSort(SqeList *L,int low,int high){ int mid; if(low<high){ mid=Partition(L,low,high); QuickSort(L,low,mid-1); QuickSort(L,mid+1,high); }
}
//直接选择排序
printf("\n7-直接选择排序结果为:\n"); SelectSort(&l); PrintList(&l); printf("\n"); printf("\n8-二路归并结果为:\n"); MergeSort(&l);
PrintList(&l); printf("\n"); } else printf("请输入大于 0 的值: "); return 0; }
} else{
MR->r[k]=R->r[j]; ++j; } ++k; } while(i<=mid) MR->r[k++]=R->r[i++]; while(j<=high) MR->r[k++]=R->r[j++]; }
冒泡排序链表c语言
冒泡排序链表c语言冒泡排序是一种简单而常用的排序算法,它可以用于对链表进行排序。
在本文中,我们将介绍如何使用C语言实现冒泡排序链表,并解释算法的原理和步骤。
让我们来了解一下冒泡排序的基本原理。
冒泡排序通过多次遍历待排序的元素,比较相邻的两个元素的大小,并根据需要交换它们的位置。
通过这样的比较和交换,最大(或最小)的元素会逐渐“冒泡”到列表的末尾(或开头),从而实现排序。
在链表中实现冒泡排序的思路与数组类似,但需要注意的是,我们无法像数组那样通过下标直接访问链表中的元素。
因此,在链表中进行元素比较和交换时,我们需要修改节点之间的连接关系。
下面是使用C语言实现冒泡排序链表的步骤:1. 遍历链表,确定链表的长度。
这一步是为了确定需要进行多少次排序遍历。
2. 写一个循环,循环次数为链表的长度减1。
每次循环都进行一次完整的遍历和排序。
3. 在每次遍历中,从链表的头部开始,比较相邻节点的值。
如果前一个节点的值大于后一个节点的值,则交换它们的位置。
4. 重复步骤3,直到遍历到链表的倒数第二个节点。
这样可以确保在每次遍历后,链表的最后一个节点都是当前遍历范围内的最大(或最小)值。
5. 重复步骤2和步骤3,直到完成所有的排序遍历。
此时,链表中的元素已经按照从小到大(或从大到小)的顺序排列好了。
以下是冒泡排序链表的C语言代码实现:```c#include <stdio.h>// 定义链表节点的结构体typedef struct Node {int data;struct Node* next;} Node;// 冒泡排序链表的函数void bubbleSortList(Node* head) {if (head == NULL || head->next == NULL) {return;}int len = 0;Node* cur = head;while (cur != NULL) {len++;cur = cur->next;}for (int i = 0; i < len - 1; i++) {cur = head;for (int j = 0; j < len - i - 1; j++) {if (cur->data > cur->next->data) { int temp = cur->data;cur->data = cur->next->data; cur->next->data = temp;}cur = cur->next;}}}// 打印链表的函数void printList(Node* head) {Node* cur = head;while (cur != NULL) {printf("%d ", cur->data);cur = cur->next;}printf("\n");}int main() {// 创建链表Node* head = (Node*)malloc(sizeof(Node)); Node* node1 = (Node*)malloc(sizeof(Node)); Node* node2 = (Node*)malloc(sizeof(Node)); Node* node3 = (Node*)malloc(sizeof(Node)); head->data = 3;node1->data = 2;node2->data = 4;node3->data = 1;head->next = node1;node1->next = node2;node2->next = node3;node3->next = NULL;// 打印排序前的链表printf("排序前的链表:");printList(head);// 对链表进行冒泡排序bubbleSortList(head);// 打印排序后的链表printf("排序后的链表:");printList(head);return 0;}```在上面的代码中,我们首先定义了一个链表节点的结构体,其中包含一个整型数据成员和一个指向下一个节点的指针成员。
C语言链表的排序
C语言链表的排序/某==========================功能:选择排序(由小到大)返回:指向链表表头的指针==========================某//某选择排序的基本思想就是反复从还未排好序的那些节点中,选出键值(就是用它排序的字段,我们取学号num为键值)最小的节点,依次重新组合成一个链表。
head存储的是第一个节点的地址,head->ne某t存储的是第二个节点的地址;任意一个节点p的地址,只能通过它前一个节点的ne某t来求得。
单向链表的选择排序图示:---->[1]---->[3]---->[2]...---->[n]---->[NULL](原链表)head1->ne某t3->ne某t2->ne某tn->ne某t---->[NULL](空链表)firttail---->[1]---->[2]---->[3]...---->[n]---->[NULL](排序后链表)firt1->ne某t2->ne某t3->ne某ttail->ne某t图10:有N个节点的链表选择排序1、先在原链表中找最小的,找到一个后就把它放到另一个空的链表中;2、空链表中安放第一个进来的节点,产生一个有序链表,并且让它在原链表中分离出来(此时要注意原链表中出来的是第一个节点还是中间其它节点);3、继续在原链表中找下一个最小的,找到后把它放入有序链表的尾指针的ne某t,然后它变成其尾指针;某/tructtudent某SelectSort(tructtudent某head){tructtudent某firt;/某排列后有序链的表头指针某/tructtudent 某tail;/某排列后有序链的表尾指针某/tructtudent某p_min;/某保留键值更小的节点的前驱节点的指针某/tructtudent某min;/某存储最小节点某/tructtudent某p;/某当前比较的节点某/firt=NULL;while(head!=NULL)/某在链表中找键值最小的节点。
数据结构c++顺序表、单链表的基本操作,查找、排序代码
} return 0; }
实验三 查找
实验名称: 实验3 查找 实验目的:掌握顺序表和有序表的查找方法及算法实现;掌握二叉排序 树和哈希表的构造和查找方法。通过上机操作,理解如何科学地组织信 息存储,并选择高效的查找算法。 实验内容:(2选1)内容1: 基本查找算法;内容2: 哈希表设计。 实验要求:1)在C++系统中编程实现;2)选择合适的数据结构实现查 找算法;3)写出算法设计的基本原理或画出流程图;4)算法实现代码 简洁明了;关键语句要有注释;5)给出调试和测试结果;6)完成实验 报告。 实验步骤: (1)算法设计 a.构造哈希函数的方法很多,常用的有(1)直接定址法(2)数字分析法;(3) 平方取中法;(4)折叠法;( 5)除留余数法;(6)随机数法;本实验采用的是除 留余数法:取关键字被某个不大于哈希表表长m的数p除后所得余数为哈 希地址 (2)算法实现 hash hashlist[n]; void listname(){ char *f; int s0,r,i; NameList[0].py="baojie"; NameList[1].py="chengቤተ መጻሕፍቲ ባይዱoyang"; ……………………………… NameList[29].py="wurenke"; for(i=0;i<q;i++){s0=0;f=NameList[i].py; for(r=0;*(f+r)!='\0';r++) s0+=*(f+r);NameList[i].k=s0; }} void creathash(){int i;
v[k-1]=v[k]; nn=nn-1; return ; } int main() {sq_LList<double>s1(100); cout<<"第一次输出顺序表对象s1:"<<endl; s1.prt_sq_LList(); s1.ins_sq_LList(0,1.5); s1.ins_sq_LList(1,2.5); s1.ins_sq_LList(4,3.5); cout<<"第二次输出顺序表对象s1:"<<endl; s1.prt_sq_LList(); s1.del_sq_LList(0); s1.del_sq_LList(2); cout<<"第三次输出顺序表对象s1:"<<endl; s1.prt_sq_LList(); return 0; } 运行及结果:
数据结构实验报告-实验一顺序表、单链表基本操作的实现
数据结构实验报告-实验⼀顺序表、单链表基本操作的实现实验⼀顺序表、单链表基本操作的实现l 实验⽬的1、顺序表(1)掌握线性表的基本运算。
(2)掌握顺序存储的概念,学会对顺序存储数据结构进⾏操作。
(3)加深对顺序存储数据结构的理解,逐步培养解决实际问题的编程能⼒。
l 实验内容1、顺序表1、编写线性表基本操作函数:(1)InitList(LIST *L,int ms)初始化线性表;(2)InsertList(LIST *L,int item,int rc)向线性表的指定位置插⼊元素;(3)DeleteList1(LIST *L,int item)删除指定元素值的线性表记录;(4)DeleteList2(LIST *L,int rc)删除指定位置的线性表记录;(5)FindList(LIST *L,int item)查找线性表的元素;(6)OutputList(LIST *L)输出线性表元素;2、调⽤上述函数实现下列操作:(1)初始化线性表;(2)调⽤插⼊函数建⽴⼀个线性表;(3)在线性表中寻找指定的元素;(4)在线性表中删除指定值的元素;(5)在线性表中删除指定位置的元素;(6)遍历并输出线性表;l 实验结果1、顺序表(1)流程图(2)程序运⾏主要结果截图(3)程序源代码#include<stdio.h>#include<stdlib.h>#include<malloc.h>struct LinearList/*定义线性表结构*/{int *list; /*存线性表元素*/int size; /*存线性表长度*/int Maxsize; /*存list数组元素的个数*/};typedef struct LinearList LIST;void InitList(LIST *L,int ms)/*初始化线性表*/{if((L->list=(int*)malloc(ms*sizeof(int)))==NULL){printf("内存申请错误");exit(1);}L->size=0;L->Maxsize=ms;}int InsertList(LIST *L,int item,int rc)/*item记录值;rc插⼊位置*/ {int i;if(L->size==L->Maxsize)/*线性表已满*/return -1;if(rc<0)rc=0;if(rc>L->size)rc=L->size;for(i=L->size-1;i>=rc;i--)/*将线性表元素后移*/L->list[i+=1]=L->list[i];L->list[rc]=item;L->size++;return0;}void OutputList(LIST *L)/*输出线性表元素*/{int i;printf("%d",L->list[i]);printf("\n");}int FindList(LIST *L,int item)/*查找线性元素,返回值>=0为元素的位置,返回-1为没找到*/ {int i;for(i=0;i<L->size;i++)if(item==L->list[i])return i;return -1;}int DeleteList1(LIST *L,int item)/*删除指定元素值得线性表记录,返回值为>=0为删除成功*/ {int i,n;for(i=0;i<L->size;i++)if(item==L->list[i])break;if(i<L->size){for(n=i;n<L->size-1;n++)L->list[n]=L->list[n+1];L->size--;return i;}return -1;}int DeleteList2(LIST *L,int rc)/*删除指定位置的线性表记录*/{int i,n;if(rc<0||rc>=L->size)return -1;for(n=rc;n<L->size-1;n++)L->list[n]=L->list[n+1];L->size--;return0;}int main(){LIST LL;int i,r;printf("list addr=%p\tsize=%d\tMaxsize=%d\n",LL.list,LL.size,LL.Maxsize);printf("list addr=%p\tsize=%d\tMaxsize=%d\n",LL.list,LL.list,LL.Maxsize);while(1){printf("请输⼊元素值,输⼊0结束插⼊操作:");fflush(stdin);/*清空标准输⼊缓冲区*/scanf("%d",&i);if(i==0)break;printf("请输⼊插⼊位置:");scanf("%d",&r);InsertList(&LL,i,r-1);printf("线性表为:");OutputList(&LL);}while(1){printf("请输⼊查找元素值,输⼊0结束查找操作:");fflush(stdin);/*清空标准输⼊缓冲区*/scanf("%d ",&i);if(i==0)break;r=FindList(&LL,i);if(r<0)printf("没有找到\n");elseprintf("有符合条件的元素,位置为:%d\n",r+1);}while(1){printf("请输⼊删除元素值,输⼊0结束查找操作:");fflush(stdin);/*清楚标准缓存区*/scanf("%d",&i);if(i==0)break;r=DeleteList1(&LL,i);if(i<0)printf("没有找到\n");else{printf("有符合条件的元素,位置为:%d\n线性表为:",r+1);OutputList(&LL);}while(1){printf("请输⼊删除元素位置,输⼊0结束查找操作:");fflush(stdin);/*清楚标准输⼊缓冲区*/scanf("%d",&r);if(r==0)break;i=DeleteList2(&LL,r-1);if(i<0)printf("位置越界\n");else{printf("线性表为:");OutputList(&LL);}}}链表基本操作l 实验⽬的2、链表(1)掌握链表的概念,学会对链表进⾏操作。
数据结构课程设计 实验报告 心得体会 链表 C语言
数据结构课程设计设计题目: 两个链表的交叉合并专业班级:08软件工程3班姓名:xxxxxx学号: 080107031123设计时间:2010/9/25指导教师:杨薇薇一、设计题目实现两个链表的合并设计目的1.掌握线性链表的建立。
2.掌握线性链表的基本操作。
设计内容和要求1. 建立两个链表A和B,链表元素个数分别为m和n个。
2. 假设元素分别为(x1,x2,…xm),和(y1,y2, …yn)。
把它们合并成一个线形表C,使得:当m>=n时,C=x1,y1,x2,y2,...xn,yn, (x)当n>m时,C=y1,x1,y2,x2,…ym,xm,…,yn输出线性表C。
3. 用直接插入排序法对C进行升序排序,生成链表D,并输出链表D。
4. 能删除指定单链表中指定位子和指定值的元素。
二、运行环境(软、硬件环境)软件环境: VC++6.0编程软件,运行平台:Win32硬件:普通个人pc机、算法设计的思想三、算法的流程图四、算法设计分析这个两个链表的交叉合并算法主要运用到的是链表的基本操作,定义节点,将链表的创建、计算链表的长度、链表A,B的交叉组合、链表内容升序排列、删除链表指定位置元素、删除指定的元素等算法写成了独立函数,通过主函数调用。
这样就大大精简了主函数的操作。
但主函数中很大篇幅用到了if、else语句,用以指定链表指定结点和指定元素的删除操作,这样就使得本来很精简变得繁琐,降低了程序的质量。
所以其有优点和缺点,但需要不断的改进,不断优化该程序。
五、源代码程序源代码:#include<stdio.h>#include<stdlib.h>typedef struct node //节点定义{int data;struct node *next;} node,*linklist;linklist creat(linklist head) //该函数用来创建链表{node *r,*s;int a;r = (linklist)malloc(sizeof(node));head = r;scanf("%d",&a);while(a != 0){s =(node*)malloc(sizeof(node));s->data=a;r->next=s;r=s;printf("please input a data:");scanf("%d",&a);}r->next=NULL;return head;}linklist length(linklist l) // 返回L中数据元素个数{int i=0;linklist p=l->next; // p指向第一个结点while(p){i++;p=p->next;}return i;}linklist mergel(linklist A,linklist B) //用于实现链表A,B的交叉组合 {int m,n;node *p,*q,*s,*t;linklist C;p=A->next;q=B->next;m=length(A);n=length(B);C=A;if(m<n){p=B->next;q=A->next;C=B;}while(p&&q){s=p->next;p->next=q;if(s){t=q->next;q->next=s;}p=s;q=t;}return C;}linklist sort(linklist L) //链表内容升序排列{linklist p,q,min;int temp;p=L;while( p=p->next ){q=min=p;while(q=q->next){if( q->data<min->data )min = q;}if( min!=p ){temp = p->data;p->data = min->data;min->data=temp;}}return L;}linklist Delete(linklist l,int index) //删除链表指定位置元素{ linklist p,t;int cx=1; //用于计数p=l;if(index<length(l)){while(p&&(cx<index)){t=p;p=p->next;cx++;}t->next=p->next;}elseprintf("input indext error");return l;}linklist Delete_element(linklist l,int data) //删除指定的元素{ linklist p;p=l;if(p->next){while(p->next->data!=data){p=p->next;}p->next=p->next->next;}elseprintf("don't faind the element");return l;}linklist display(linklist l) //打印{ linklist p;printf("new linklist :\n");p = l->next;while(p){printf("%d\n",p->data);p= p->next;}return l;}main(){linklist p,q,A,B,C,D;int indexs;int datas;char name;int cmd;printf("Creat linklist A:\n"); //创建A链表,并打印printf("please input a data:");A = creat(A);printf("Creat linklist B:\n"); //创建B链表,并打印printf("please input a data:");B = creat(B);C = mergel(A,B); //生成C链表,并打印 printf("linklist C\n");p = C->next;while(p){printf("%d\n",p->data);p=p->next;}D=C; //对C进行排序生成D sort(D);printf("linklist D:\n");q = D->next;while(q){printf("%d\n",q->data);q = q->next;}printf("\nplease input 0 or 1 \n");//用1和0判断是按位置删除还是直接删除元素scanf("%d",&cmd);if(cmd==0) //位置删除{printf("please input linklist name\n ");fflush(stdin);scanf("%c",&name);printf("\nplease input index \n");scanf("%d",&indexs);fflush(stdin);if(name=='A'){Delete(A,indexs);display(A);}else if(name=='B'){Delete(B,indexs);display(B);}else if(name=='C'){Delete(C,indexs);display(C);}else if(name=='D'){Delete(D,indexs);display(D);}elseprintf("nameError");}else if(cmd==1) //元素删除{fflush(stdin); //清除缓冲printf("please input linklist name\n ");//fflush(stdin);scanf("%c",&name);printf("\nplease input datas \n");scanf("%d",&datas);if(name=='A'){Delete_element(A,datas);display(A);}else if(name=='B'){Delete_element(B,datas);display(B);}else if(name=='C'){Delete_element(C,datas);display(C);}else if(name=='D'){Delete_element(D,datas);display(D);}elseprintf("name2error");}elseprintf("cmdError");printf("\nOver\n"); getchar();return 0;}六、运行结果分析截图:结果分析:大体来说,该程序都实现了课程设计的算法要求及功能,但还是有很多问题,由于时间问题该算法做得比较粗糙,还不能很好的处理问题,例如,如果想在一次操作完成后还像再次操作,但此时已经结束算法了,需要重新运行程序再次输入操作才能达到要求,这样很繁琐。
数据结构实验报告顺序表
数据结构实验报告顺序表数据结构实验报告:顺序表摘要:顺序表是一种基本的数据结构,它通过一组连续的存储单元来存储线性表中的数据元素。
在本次实验中,我们将通过实验来探索顺序表的基本操作和特性,包括插入、删除、查找等操作,以及顺序表的优缺点和应用场景。
一、实验目的1. 理解顺序表的概念和特点;2. 掌握顺序表的基本操作;3. 了解顺序表的优缺点及应用场景。
二、实验内容1. 实现顺序表的初始化操作;2. 实现顺序表的插入操作;3. 实现顺序表的删除操作;4. 实现顺序表的查找操作;5. 对比顺序表和链表的优缺点;6. 分析顺序表的应用场景。
三、实验步骤与结果1. 顺序表的初始化操作在实验中,我们首先定义了顺序表的结构体,并实现了初始化操作,即分配一定大小的存储空间,并将表的长度设为0,表示表中暂时没有元素。
2. 顺序表的插入操作接下来,我们实现了顺序表的插入操作。
通过将插入位置后的元素依次向后移动一位,然后将新元素插入到指定位置,来实现插入操作。
我们测试了在表中插入新元素的情况,并验证了插入操作的正确性。
3. 顺序表的删除操作然后,我们实现了顺序表的删除操作。
通过将删除位置后的元素依次向前移动一位,来实现删除操作。
我们测试了在表中删除元素的情况,并验证了删除操作的正确性。
4. 顺序表的查找操作最后,我们实现了顺序表的查找操作。
通过遍历表中的元素,来查找指定元素的位置。
我们测试了在表中查找元素的情况,并验证了查找操作的正确性。
四、实验总结通过本次实验,我们对顺序表的基本操作有了更深入的了解。
顺序表的插入、删除、查找等操作都是基于数组的操作,因此在插入和删除元素时,需要移动大量的元素,效率较低。
但是顺序表的优点是可以随机访问,查找效率较高。
在实际应用中,顺序表适合于元素数量不变或变化不大的情况,且需要频繁查找元素的场景。
综上所述,顺序表是一种基本的数据结构,我们通过本次实验对其有了更深入的了解,掌握了顺序表的基本操作,并了解了其优缺点及应用场景。
数据结构实验报告1线性表的顺序存储结构
数据结构实验报告1线性表的顺序存储结构一、实验目的本次实验的主要目的是深入理解线性表的顺序存储结构,并通过编程实现其基本操作,包括创建线性表、插入元素、删除元素、查找元素以及输出线性表等。
通过实际操作,掌握顺序存储结构的特点和优势,同时也了解其在不同情况下的性能表现。
二、实验环境本次实验使用的编程语言为C++,编译环境为Visual Studio 2019。
三、实验原理1、线性表的定义线性表是由 n(n≥0)个数据元素组成的有限序列。
在顺序存储结构中,线性表的元素存储在一块连续的存储空间中,通过数组来实现。
2、顺序存储结构的特点存储密度高,无需额外的指针来表示元素之间的关系。
可以随机访问表中的任意元素,时间复杂度为 O(1)。
插入和删除操作需要移动大量元素,平均时间复杂度为 O(n)。
四、实验内容及步骤1、定义线性表的数据结构```cppdefine MAX_SIZE 100 //定义线性表的最大长度typedef struct {int dataMAX_SIZE; //存储线性表元素的数组int length; //线性表的当前长度} SeqList;```2、初始化线性表```cppvoid InitList(SeqList L) {L>length = 0; //初始时线性表长度为 0}```3、判断线性表是否为空```cppbool ListEmpty(SeqList L) {return (Llength == 0);}```4、求线性表的长度```cppint ListLength(SeqList L) {return Llength;}```5、按位查找操作```cppint GetElem(SeqList L, int i) {if (i < 1 || i > Llength) {printf("查找位置不合法!\n");return -1;}return Ldatai 1;}```6、按值查找操作```cppint LocateElem(SeqList L, int e) {for (int i = 0; i < Llength; i++){if (Ldatai == e) {return i + 1;}}return 0; //未找到返回 0}```7、插入操作```cppbool ListInsert(SeqList L, int i, int e) {if (L>length == MAX_SIZE) {//表已满printf("表已满,无法插入!\n");return false;}if (i < 1 || i > L>length + 1) {//插入位置不合法printf("插入位置不合法!\n");return false;}for (int j = L>length; j >= i; j) {//移动元素L>dataj = L>dataj 1;}L>datai 1 = e; //插入元素L>length++;//表长加 1return true;}```8、删除操作```cppbool ListDelete(SeqList L, int i) {if (L>length == 0) {//表为空printf("表为空,无法删除!\n");return false;}if (i < 1 || i > L>length) {//删除位置不合法printf("删除位置不合法!\n");return false;}for (int j = i; j < L>length; j++){//移动元素L>dataj 1 = L>dataj;}L>length; //表长减 1return true;}```9、输出线性表```cppvoid PrintList(SeqList L) {for (int i = 0; i < Llength; i++){printf("%d ", Ldatai);}printf("\n");}```10、测试用例```cppint main(){SeqList L;InitList(&L);ListInsert(&L, 1, 10);ListInsert(&L, 2, 20);ListInsert(&L, 3, 30);ListInsert(&L, 4, 40);ListInsert(&L, 5, 50);printf("线性表的长度为:%d\n", ListLength(L));printf("查找第 3 个元素:%d\n", GetElem(L, 3));int loc = LocateElem(L, 30);if (loc) {printf("元素 30 的位置为:%d\n", loc);} else {printf("未找到元素 30\n");}ListDelete(&L, 3);printf("删除第 3 个元素后的线性表:");PrintList(L);return 0;}```五、实验结果及分析1、实验结果成功创建并初始化了线性表。
数据结构课程设计排序实验报告
《数据结构》课程设计报告专业班级姓名学号指导教师起止时间课程设计:排序综合一、任务描述利用随机函数产生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 个元素)的随机整数列表作为测试数据。
数据结构实验任务书(8个)
目录实验1 线性表顺序存储的应用 (2)实验2 线性表链式存储的应用 (5)实验3 栈及其应用 (6)实验4 队列及其应用 (7)实验5 树及其应用 (8)实验6 图的遍历和连通性应用 (9)实验7 图的最短路径应用 (11)实验8 查找和排序应用 (12)实验1 线性表顺序存储的应用实验目的1.熟悉C语言的上机环境,掌握C语言的基本结构。
2.会定义线性表的顺序存储结构。
3.熟悉对顺序表的一些基本操作和具体的函数定义。
4.掌握在线性表的顺序存储结构上的一些其它操作。
实验要求1.独立完成;2.程序调试正确,有执行结果。
实验内容1、基础题:编写应用程序(填空),实现可以在顺序表中插入任意给定数据类型(定义为抽象数据类型)数据的功能。
要求在主函数中定义顺序表并对该顺序表插入若干个整数类型的数据(正整数),对它们求和并输出。
请使用动态内存分配的方式申请数组空间,并把主函数设计为一个文件SeqList.cpp,其余函数设计为另一个文件SeqList.h。
请填空完成以下给出的源代码并调试通过。
(1)文件SeqList.h:typedef struct List{ElemType *elem;int length;int listsize;}SeqList;void InitList(SeqList &L){ //初始化线性表…………}void ClearList(SeqList &L){ //清除线性表………………}int LengthList(SeqList L){ //求线性表长度………..}bool InsertList(SeqList &L, ElemType item, int pos){ //按给定条件pos向线性表插入一个元素…….}ElemType GetList(SeqList L, int pos){ //在线性表L中求序号为pos的元素,该元素作为函数值返回…………..}(2)文件SeqList.cpp:#include <stdio.h>#include <stdlib.h>typedef ElemType;#define MAXSize 10#include "SeqList.h"void main(void){SeqList myList;int i=1, x, sum=0, n;InitList ( );scanf(“%d”, &x);while ( x!= -1 ){if ( InsertList (myList, , i )==0) {printf("错误!\n");return ;}i++;scanf(“%d”, &x);}n = LengthList (myList);for (i=1; i<=n; i++){x=GetList(myList, i);sum = + x;}printf("%d\n ", sum);ClearList(myList);}2、提高部分:编写函数bool DeleteElem(SeqList &L, int min, int max)实现从顺序表中删除其值在给定值min和max之间(min < max)的所有元素,要求把该函数添加到文件SeqList.h中,并在主函数文件SeqList.cpp中添加相应语句进行测试。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
1.实验要求i.实验目的:通过编程,学习、实现、对比各种排序算法,掌握各种排序算法的优劣,以及各种算法使用的情况。
理解算法的主要思想及流程。
ii.实验内容:使用链表实现下面各种排序算法,并进行比较。
排序算法:1、插入排序2、冒泡排序(改进型冒泡排序)3、快速排序4、简单选择排序5、堆排序(小根堆)要求:1、测试数据分成三类:正序、逆序、随机数据2、对于这三类数据,比较上述排序算法中关键字的比较次数和移动次数(其中关键字交换计为3次移动)。
3、对于这三类数据,比较上述排序算法中不同算法的执行时间,精确到微秒(选作)4、对2和3的结果进行分析,验证上述各种算法的时间复杂度编写测试main()函数测试线性表的正确性iii.代码要求:1、必须要有异常处理,比如删除空链表时需要抛出异常;2、保持良好的编程的风格:代码段与段之间要有空行和缩近标识符名称应该与其代表的意义一致函数名之前应该添加注释说明该函数的功能关键代码应说明其功能3、递归程序注意调用的过程,防止栈溢出2. 程序分析通过排序算法将单链表中的数据进行由小至大(正向排序)2.1 存储结构单链表存储数据: struct node {int data;node *next;};单链表定义如下:class LinkList {private :node * front; public :LinkList(int a[], int n);//构造~LinkList();void insert(node *p, node *s);//插入void turn(node *p, node *s);//交换数据void print();//输出void InsertSort();//插入排序void BubbleSort();//pos 冒泡void QSort();//快速排序void SelectSort();//简单选择排序node * Get(int i);//查找位置为i 的结点void sift(int k, int m); //一趟堆排序void LinkList ::QSZ(node * b, node *e); //快速排序的递归主体void heapsort(int n); //堆排序算法};2.2 关键算法分析:1.直接插入排序:首先将待排序数据建立一个带头结点的单链表。
将单链表划分为有序区和无序区,有序区只包含一个元素节点,依次取无序区中的每一个结点,在有序区中查找待插入结点的插入位置,然后把该结点从单链表中删除,再插入到相应位置。
分析上述排序过程,需设一个工作指针p->next 在无序区中指向待插入的结点,在找到插入位置后,将结点p->next 插在结点s 和p 之间。
void LinkList ::InsertSort()//将第一个元素定为初始有序区元素,由第二个元素开始依次比较{LARGE_INTEGER t1, t2, feq;QueryPerformanceFrequency(&feq); //每秒跳动次数QueryPerformanceCounter(&t1); //测前跳动次数node * p = front->next;//要插入的节点的前驱……{node * s = front;//充分利用带头结点的单链表while (1){comparef++;if (p->next->data <s->next->data)// [P后继]比[S后继]小则插入{insert(p, s); break;}s = s->next;if (s == p)//若一趟比较结束,且不需要插入{p = p->next; break;}}}QueryPerformanceCounter(&t2); //测后跳动次数double d = ((double)t2.QuadPart - (double)t1.QuadPart) / ((double)feq.QuadPart);//时间差秒cout << "操作时间为:" << d << endl;}2.快速排序:主要通过轴值将数据从两端向中间进行比较,交换以实现排序。
通过递归的调用来实现整个链表数据的排序。
代码中选用了第一个元素作为轴值。
一趟排序的代码:void LinkList::QSZ(node * b, node *e){if (b->next == e || b == e)//排序完成return;node * qianqu = b;//轴点前驱node * p = qianqu->next;while (p != e && p != e->next){comparef++;if (qianqu->next->data > p->next->data)//元素值小于轴点值,则将该元素插在轴点之前{if (p->next == e)//若该元素为e,则将其前驱设为ee = p;insert(p, qianqu);qianqu = qianqu->next;}else p = p->next;}QSZ(b, qianqu);//继续处理轴点左侧链表QSZ(qianqu->next, e);//继续处理轴点右侧链表整个快速排序的实现:void LinkList::QSort(){LARGE_INTEGER t1, t2, feq;QueryPerformanceFrequency(&feq); //每秒跳动次数QueryPerformanceCounter(&t1); //测前跳动次数node * e = front;while (e->next){e = e->next;}QSZ(front, e);QueryPerformanceCounter(&t2); //测后跳动次数double d = ((double)t2.QuadPart - (double)t1.QuadPart) / ((double)feq.QuadPart);//时间差秒cout << "操作时间为:" << d << endl;}3.改进版的冒泡排序:通过设置pos来记录无序边界的位置以减少比较次数。
将数据从前向后两两比较,遇到顺序不对是直接交换两数据的值。
每交换一次movef+3;void LinkList::BubbleSort(){LARGE_INTEGER t1, t2, feq;QueryPerformanceFrequency(&feq); //每秒跳动次数QueryPerformanceCounter(&t1); //测前跳动次数node * p = front->next;while (p->next) // 排序查找无序边界{comparef++;if (p->data > p->next->data)turn(p, p->next);p = p->next;}node * pos = p; p = front->next;while (pos != front->next){node * bound = pos;pos = front->next;while (p->next != bound){comparef++;if (p->data > p->next->data){turn(p, p->next); pos = p->next;}p = front->next;}QueryPerformanceCounter(&t2); //测后跳动次数double d = ((double)t2.QuadPart - (double)t1.QuadPart) / ((double)feq.QuadPart);//时间差秒cout << "操作时间为:" << d << endl;}4.选择排序:每趟排序再待排序的序列中选择关键码最小的元素,顺序添加至已排好的有序序列最后,知道全部记录排序完毕。
void LinkList::SelectSort(){LARGE_INTEGER t1, t2, feq;QueryPerformanceFrequency(&feq); //每秒跳动次数QueryPerformanceCounter(&t1); //测前跳动次数node * s = front;while (s->next->next){node * p = s;node * index = p;while (p->next){comparef++;if (p->next->data < index->next->data)index = p;p = p->next;}insert(index, s);s = s->next;}QueryPerformanceCounter(&t2); //测后跳动次数double d = ((double)t2.QuadPart - (double)t1.QuadPart) / ((double)feq.QuadPart);//时间差秒cout << "操作时间为:" << d << endl;}5.堆排序:利用前一趟比较的结果来减少比较次数,提高整体的效率。
其中通过链表储存了一棵树。
选择使用小根堆进行排序。
void LinkList::sift(int k, int m){int i = k, j = 2 * i;while (j <= m)if (j<m && (Get(j)->data>Get(j + 1)->data)) j++;if (Get(i)->data < Get(j)->data) break;else{turn(Get(i), Get(j));i = j;j = 2 * i;}}}void LinkList::heapsort(int n){LARGE_INTEGER t1, t2, feq;QueryPerformanceFrequency(&feq); //每秒跳动次数QueryPerformanceCounter(&t1); //测前跳动次数for (int i = n / 2; i >= 1; i--)sift(i, n);for (int i = 1; i < n; i++){turn(Get(1), Get(n - i + 1));sift(1, n - i);}QueryPerformanceCounter(&t2); //测后跳动次数double d = ((double)t2.QuadPart - (double)t1.QuadPart) / ((double)feq.QuadPart);//时间差秒cout << "操作时间为:" << d << endl;}其中堆排序中需要知道孩子节点和父亲节点处的值,故设置了函数获取i出的指针。