数据结构课程设计报告---链表操作

合集下载

数据结构课程设计—链表应用

数据结构课程设计—链表应用

一、链表应用1、流程图2、源程序#include<stdio.h>#include<stdlib.h>//预处理器指令,引用头文件int n;struct Lnode//创建结构体Lnode,包含数据域data和指针域next{int data;struct Lnode *next;}Lnode;void menu()//菜单程序{printf("\n链表应用\n1 创建高次多项式A,B\n2 加法运算A+B=C\n3 减法运算A-B=C\n4 输出C\n5 退出\n");}struct Lnode *creat(char c)//创建链表{int i,d;struct Lnode *head,*p;head = (struct Lnode *)malloc(sizeof(struct Lnode));//用malloc函数动态分配空间head->next = 0;//赋初值printf("\n由0次到%d次输入%c的每项系数(若无该项则系数为0):",n,c); //记头结点head的下一结点位置为0,用结点在链表中的位置代表幂数,将系数存入对应数据域for(i = 0;i <= n;i++){scanf("%d",&d);p = (struct Lnode *)malloc(sizeof(struct Lnode)); //用malloc函数动态分配空间p->data = d;p->next = head->next;head->next = p;}return(head);}struct Lnode *plus(struct Lnode *head1,struct Lnode *head2)//加法运算{int i;struct Lnode *p,*q,*s,*head3;head3 = (struct Lnode *)malloc(sizeof(struct Lnode)); //用malloc函数动态分配空间head3->next = 0;//初始化p = head1;q = head2;//将链表A,B中位置相同(即幂数相同)的结点的数据域值(即系数)相加,所得和链成链表Cfor(i = 0;i <= n;i++){s = (struct Lnode *)malloc(sizeof(struct Lnode)); //用malloc函数动态分配空间s->data = p->next->data + q->next->data;s->next = head3->next;head3->next = s;p = p->next;q = q->next;}return(head3);}struct Lnode *minus(struct Lnode *head1,struct Lnode *head2)//减法运算(与加法运算原理相同){int i;struct Lnode *p,*q,*s,*head3;head3 = (struct Lnode *)malloc(sizeof(struct Lnode));head3->next = 0;p = head1;q = head2;for(i = 0;i <= n;i++){s = (struct Lnode *)malloc(sizeof(struct Lnode));s->data = p->next->data - q->next->data;s->next = head3->next;head3->next = s;p = p->next;q = q->next;}return(head3);}struct Lnode *display(struct Lnode *head)//输出链表C{int i,d;struct Lnode *p;p = head->next;//将位置为0的结点赋给pprintf("\n输出C\n幂数\t系数");//用for循环依次输出各结点位置(即幂数)和数据域值(即系数)for(i = 0;i <= n;i++){printf("\n%d",i);d = p->data;printf("\t%d",d);p = p->next;}return(head);}void main(){int choice;struct Lnode *A,*B,*C;menu();printf("\n输入选项:");scanf("%d",&choice);//用while循环实现菜单的循环选择while(choice! = 5){//用switch函数实现功能选择switch(choice){case 1: printf("\n输入A,B的最高次项的幂数:");scanf("%d",&n);A = creat('A');B = creat('B');break;case 2: C = plus(A,B);break;case 3: C = minus(A,B);break;case 4: C = display(C);break;}menu();printf("\n输入选项:");scanf("%d",&choice);}}3、运行结果1、流程图2、源程序#include <stdio.h>#include <stdlib.h>//预处理器指令,引用头文件int s1=0,s2=0;//定义全局变量typedef struct//创建结构体,包含字符域c,权值域w,双亲域p,左孩子域l 和右孩子域r;声明HT来代替结构体struct{int c;int w;int p,l,r;}HT;typedef char * *HuffmanCode;HT *HTree;HuffmanCode HCode;void Select(HT *HTree,int b)// 选择双亲域值为0且权值最小的两个结点s1,s2 {int i,j,t;//找第一个p为0的结点for(i=1;i<=b;i++)if(!HTree[i].p)//若一结点双亲域值为0,则用s1记录其位置{s1 = i;break;}//找第二个p为0的结点for(j=i+1;j<=b;j++)if(!HTree[j].p) //若s1之后一结点双亲域值为0,则用s2记录其位置{s2 = j;break;}//找第一个w最小的结点for(i=1;i<=b;i++)if((HTree[s1].w>HTree[i].w)&&(!HTree[i].p)&&(s2!=i))//用s1与其他非s2的双亲域为0的结点比较权值s1=i;//找第二个w最小的结点for(j=1;j <= b;j++)if((HTree[s2].w>HTree[j].w)&&(!HTree[j].p)&&(s1!=j))//用s2与其他非s1的双亲域为0的结点比较权值s2=j;//令s1小于s2if(s1>s2){t=s1;//t为中间变量,做变量交换s1=s2;s2=t;}}void Strcpy(char *p1,char *p2,int i,int j)//字符串连接{int k;for(k=0;i<=j;k++,i++)*(p1+k)=*(p2+i);}void Print(HT *HTree,HuffmanCode HCode,int n)//打印赫夫曼编码{int i;for(i=1;i<=n;i++){printf("%c--",HTree[i].c);printf("%d--",HTree[i].w);printf("%s",HCode[i]);printf("\n");}}void main(){int n,m,i,C,W,start,t,P,l,WPL;int wpl[100];HT *h;printf("\n输入叶子节点个数:");scanf("%d",&n);m=2*n-1;//含n个叶子结点的赫夫曼树共有2n-1个结点HTree=(HT *)malloc((m+1)*sizeof(HT));//0号单元未用,用malloc函数动态分配连续空间h=HTree+1;//越过0号单元printf("\n输入%d个字符的ASCⅡ码和权值:",n);//叶子结点初始化for(i=1;i<=n;i++,h++){scanf("%d",&C);scanf("%d",&W);h->c=C;h->w=W;h->p=0;h->l=0;h->r=0;}//中间结点初始化for(i=n+1;i<=m;i++,h++){h->c=' ';h->w=0;h->p=0;h->l=0;h->r=0;}//输出初始状态图printf("\n输出初始状态图\n字符\t权值\t双亲\t左孩子\t右孩子");h=HTree+1; //越过0号单元for(i=1;i<=m;i++,h++){printf("\n%c\t%d\t%d\t%d\t%d",h->c,h->w,h->p,h->l,h->r);}//建赫夫曼树for(i=n+1;i<=m;i++){Select(HTree,i-1);//选择双亲域值为0且权值最小的两个结点s1,s2HTree[s1].p=i;//将两个结点的和结点存入中间结点HTree[s2].p=i;HTree[i].l=s1;HTree[i].r=s2;HTree[i].w=HTree[s1].w+HTree[s2].w;}//输出终结状态图printf("\n输出终结状态图\n字符\t权值\t双亲\t左孩子\t右孩子");h=HTree+1; //越过0号单元for(i=1;i<=m;i++,h++){printf("\n%c\t%d\t%d\t%d\t%d",h->c,h->w,h->p,h->l,h->r);}//从叶子到根逆向求赫夫曼树编码char *code;HCode=(HuffmanCode)malloc((n+1)*sizeof(char));//0号单元未用,用malloc 函数动态分配连续n个字符编码的头指针向量code=(char *)malloc(n*sizeof(char));// 用malloc函数分配求编码的公用工作空间code[n-1]='\0';//编码结束符//逐个字符求赫夫曼编码for(i=1;i<=n;i++){start=n-1;//编码结束符位置//从叶子到根逆向求编码for(t=i,P=HTree[i].p;P!=0;t=P,P=HTree[P].p){if (HTree[P].l==t)code[--start]='0';//左孩子表示0elsecode[--start]='1'; //右孩子表示1}HCode[i]=(char *)malloc((n-start)*sizeof(char));// 用malloc函数为第i 个字符编码分配空间Strcpy(HCode[i],code,start,n-1); //字符串连接}printf("\n赫夫曼编码为:\n");Print(HTree,HCode,n); //打印赫夫曼编码//赫夫曼树的带权路径长度for(i=1;i<=n;i++){for(l=0,P=HTree[i].p;P!=0;P=HTree[P].p)//若该结点有双亲,则边数l+1 l+=1;wpl[i]=HTree[i].w*l;//第i个结点的带权路径长度}for(i=1,WPL=0;i<=n;i++)//树的带权路径长度为所有叶子结点的带权路径长度之和WPL+=wpl[i];printf("\n带权路径长度:%d\n",WPL);}3、运行结果三、收获及体会四、软件环境及参考文献1、软件环境2、文献《数据结构(c语言版)》清华大学出版社。

链表操作课程设计

链表操作课程设计

链表操作课程设计一、教学目标本课程的目标是让学生掌握链表的基本操作,包括链表的创建、插入、删除和遍历。

具体来说,学生需要了解链表的概念和原理,能够使用编程语言实现链表的基本操作。

此外,学生还需要通过实践,培养解决问题的能力和团队合作精神。

二、教学内容本课程的教学内容主要包括链表的基本概念和操作。

首先,学生需要了解链表的定义和结构,理解链表的工作原理。

然后,学生将学习如何创建链表,包括单向链表和双向链表。

接下来,学生将学习如何向链表中插入和删除元素,以及如何遍历链表。

最后,学生将通过实践项目,综合运用所学知识解决实际问题。

三、教学方法为了激发学生的学习兴趣和主动性,我们将采用多种教学方法。

首先,通过讲授法,我们向学生传授链表的基本概念和原理。

然后,通过讨论法,我们鼓励学生积极参与讨论,提出问题和解决问题。

此外,我们还将使用案例分析法,通过分析实际案例,帮助学生理解链表的应用场景。

最后,我们将实验课,让学生亲自动手实践,巩固所学知识。

四、教学资源为了支持教学内容和教学方法的实施,我们将选择和准备适当的教学资源。

教材将是主要的教学资源,我们将选用一本权威的教材,确保学生能够获得系统的知识。

此外,我们还将提供参考书籍,供学生进一步深入学习。

为了增强学生的学习体验,我们将使用多媒体资料,如教学视频和演示文稿。

最后,我们将准备实验设备,让学生能够进行实际操作。

五、教学评估本课程的评估方式将包括平时表现、作业和考试。

平时表现将根据学生在课堂上的参与度、提问和回答问题的表现来评估。

作业将包括编程练习和理论题目,以检验学生对链表操作的理解和应用能力。

考试将包括选择题、填空题和编程题,全面考察学生的知识掌握和实际操作能力。

评估方式将客观、公正,全面反映学生的学习成果。

六、教学安排本课程的教学进度将分为10个课时,每个课时45分钟。

教学时间安排将在工作日的下午进行,以便学生能够在白天专注于学习。

教学地点将选择在学校的计算机实验室,以便学生能够进行实验和实际操作。

课程设计链表操作

课程设计链表操作

课程设计链表操作一、教学目标本节课的学习目标包括以下三个方面:1.知识目标:学生需要掌握链表的基本概念,了解链表的组成部分,理解链表节点之间的动态连接原理,以及掌握链表的基本操作方法,如创建、插入、删除和遍历链表。

2.技能目标:学生能够运用所学的链表知识,独立编写程序实现链表的基本操作,包括创建链表、插入节点、删除节点和遍历链表。

3.情感态度价值观目标:通过学习链表操作,培养学生对计算机编程的兴趣和热情,提高学生分析问题和解决问题的能力,培养学生的团队合作意识和创新精神。

二、教学内容本节课的教学内容主要包括以下几个部分:1.链表的基本概念:介绍链表的定义、特点和应用场景,让学生了解链表作为一种数据结构的重要性。

2.链表的组成部分:讲解链表节点的构成,包括数据域和指针域,以及链表的的头节点和尾节点的概念。

3.链表的创建:引导学生学习如何创建链表,包括初始化头节点和逐个插入节点的方法。

4.链表的插入操作:教授如何在链表中插入节点,包括在头节点插入、在尾节点插入和在指定位置插入节点的方法。

5.链表的删除操作:讲解如何删除链表中的节点,包括删除指定节点、删除头节点和删除尾节点的操作方法。

6.链表的遍历:介绍如何遍历链表,让学生掌握遍历链表的方法和技巧。

三、教学方法为了提高教学效果,本节课将采用以下几种教学方法:1.讲授法:教师通过讲解链表的基本概念、原理和操作方法,让学生掌握链表的相关知识。

2.案例分析法:教师通过分析典型链表操作案例,引导学生学会运用链表知识解决问题。

3.实验法:学生通过动手编写程序,实现链表的基本操作,提高实际编程能力。

4.小组讨论法:学生分组进行讨论,分享学习心得和编程经验,培养团队合作意识。

四、教学资源为了支持本节课的教学,教师需要准备以下教学资源:1.教材:为学生提供教材,以便学生能够跟随教学进度学习链表知识。

2.参考书:为学生提供参考书,以便学生能够拓展学习,深入了解链表及相关知识。

数据结构链表课程设计

数据结构链表课程设计

数据结构链表课程设计一、课程目标知识目标:1. 理解链表的基本概念,掌握链表的存储结构及其特点。

2. 学会使用链表实现数据的插入、删除和查找等基本操作。

3. 了解链表在实际应用场景中的优势,如解决动态数据存储问题。

技能目标:1. 能够编写链表的初始化、插入、删除和查找等操作的代码。

2. 能够运用所学知识解决实际问题,如设计一个简单的链表应用系统。

3. 能够分析链表操作的时间复杂度和空间复杂度。

情感态度价值观目标:1. 培养学生独立思考、解决问题的能力,增强自信心。

2. 培养学生团队协作精神,学会在讨论和交流中共同进步。

3. 激发学生对数据结构学习的兴趣,提高自主学习能力。

分析课程性质、学生特点和教学要求,我们将课程目标分解为以下具体学习成果:1. 掌握链表的基本概念,能够用文字和图形描述链表结构。

2. 熟练编写链表相关操作代码,能够实现简单的链表应用。

3. 了解链表的优势和局限性,能够结合实际场景选择合适的数据结构。

4. 培养良好的编程习惯,注重代码的规范性和可读性。

5. 通过小组合作,培养学生的沟通协作能力和团队精神。

6. 提高学生对数据结构在计算机科学中重要性的认识,激发学习兴趣。

二、教学内容根据课程目标,本章节教学内容主要包括以下几部分:1. 链表基本概念:介绍链表的定义、分类(单向链表、双向链表、循环链表等),以及链表在数据结构中的重要性。

2. 链表的存储结构:讲解链表节点的定义,以及链表的内存存储方式。

3. 链表基本操作:- 初始化:介绍如何创建一个空链表。

- 插入:讲解链表节点插入的原理和实现方法,包括头插法和尾插法。

- 删除:阐述链表节点删除的原理,以及如何实现删除指定节点。

- 查找:介绍如何在链表中查找指定元素,并实现相关功能。

4. 链表应用案例分析:分析实际应用场景,如多项式表示、约瑟夫问题等。

5. 链表性能分析:讨论链表操作的时间复杂度和空间复杂度。

教学内容安排和进度如下:1. 第1课时:链表基本概念、存储结构。

链表的基本操作 数据结构实验报告

链表的基本操作 数据结构实验报告

大学数据结构实验报告课程名称数据结构实验第(四)次实验实验名称链表的基本操作学生姓名于歌专业班级学号实验成绩指导老师(签名)日期2018年10月01日一、实验目的1. 学会定义单链表的结点类型,实现对单链表的一些基本操作和具体的函数定义,了解并掌握单链表的类定义以及成员函数的定义与调用。

2. 掌握单链表基本操作及两个有序表归并、单链表逆置等操作的实现。

二、实验要求1.预习C语言中结构体的定义与基本操作方法。

2.对单链表的每个基本操作用单独的函数实现。

3.编写完整程序完成下面的实验内容并上机运行。

4.整理并上交实验报告。

三、实验内容:1.编写程序完成单链表的下列基本操作:(1)初始化单链表La(2)在La中插入一个新结点(3)删除La中的某一个结点(4)在La中查找某结点并返回其位置(5)打印输出La中的结点元素值(6)清空链表(7)销毁链表2 .构造两个带有表头结点的有序单链表La、Lb,编写程序实现将La、Lb合并成一个有序单链表Lc。

四、思考与提高:1.如果上面实验内容2中合并的表内不允许有重复的数据该如何操作?2.如何将一个带头结点的单链表La分解成两个同样结构的单链表Lb,Lc,使得Lb中只含La表中奇数结点,Lc中含有La表的偶数结点?五、实验设计1.编写程序完成单链表的下列基本操作:(1)初始化单链表LaLinkList InitList(){int i,value,n;LinkList H=(LinkList)malloc(sizeof(LNode));LinkList P=H;P->next=NULL;do{printf("请输入链表的长度:");scanf("%d",&n);if(n<=0)printf("输入有误请重新输入!\n");}while(n<=0);printf("请输入各个元素:\n");for(i=0; i<n; i++){scanf("%d",&value);LinkList NEW = (LinkList)malloc(sizeof(LNode)); NEW->data=value;P->next=NEW;NEW->next=NULL;P=NEW;}printf("链表建立成功!\n");return H->next;}(2)在La中插入一个新结点LinkList InsertList(LinkList L,int i,ElemType value) {LinkList h,q,t=NewLNode(t,value);int x=0;h=q=L;if(i==1)t->next=h, h=t;else{while(x++<i-2)q=q->next;t->next=q->next;q->next=t;}printf("插入成功!\n");return h;}(3)删除La中的某一个结点LinkList DeleteList(LinkList L,int i){LinkList h,q,de;int x=0;h=q=L;int t;if(i==1)h=h->next;else{while(x++<i-2)q=q->next;de=q->next;if(de->next==NULL)q->next=NULL;elseq->next=de->next;}printf("删除成功!\n");return h;}(4)在La中查找某结点并返回其位置Status LocateList(LinkList L,ElemType value){LinkList q=L;int i=0,t;while(q!=NULL){i++;if(q->data==value){printf("该结点在链表中的位置为第%d个\n",i); return OK;}q=q->next;}printf("该链表中没有该结点!\n");return ERROR;}(5)打印输出La中的结点元素值Status Print(LinkList L){LinkList q=L;printf("该链表的每个元素为:\n");while(q!=NULL){printf("%8d",q->data);q=q->next;}printf("\n");return OK;}(6)清空链表LinkList EmptyList(LinkList L){free(L->data);L->next=NULL;printf("清空成功!\n");return L;}(7)销毁链表LinkList FreeList(LinkList L){printf("释放成功!\n");free(L);}(8)主函数int main(){LinkList L=InitList();int n,i,j;Pr();scanf("%d",&n);while(n>0&&n<7){switch(n){case 1:printf("请输入要插入的结点的值和插入的位置:"); scanf("%d %d",&i,&j);InsertList(L,j,i);break;case 2:printf("请输入要删除的结点的位置:");scanf("%d",&i);DeleteList(L,i);break;case 3:printf("请输入要查找的结点的值:");scanf("%d",&i);LocateList(L,i);break;case 4:Print(L);break;case 5:EmptyList(L);break;case 6:FreeList(L);break;}Pr();scanf("%d",&n);}if(n==7)printf("退出成功!");return 0;}2.构造两个带有表头结点的有序单链表La、Lb,编写程序实现将La、Lb合并成一个有序单链表LcLinkList ConnectList(LinkList La,LinkList Lb){LinkList Lc,a,b,c;a=La;b=Lb;if(La->data<Lb->data)Lc=La,a=a->next;elseLc=Lb,b=b->next;c=Lc;while(a!=NULL||b!=NULL){if(a==NULL)c->next=b,break;if(b==NULL)c->next=a;break;if(a->data<b->data)c->next=a,a=a->next,c=c->next;elsec->next=b,b=b->next,c=c->next;return Lc;}3.如果上面实验内容2中合并的表内不允许有重复的数据该如何操作LinkList ConnectList(LinkList La,LinkList Lb){int i=1;LinkList Lc,a,b,c,q,p;a=La;b=Lb;if(La->data<Lb->data)Lc=La;a=a->next;elseLc=Lb;b=b->next;c=Lc;while(a!=NULL||b!=NULL){if(a==NULL)c->next=b,break;if(b==NULL)c->next=a,break;if(a->data<b->data)c->next=a,a=a->next,c=c->next;elsec->next=b,b=b->next,c=c->next;}c=Lc;q=c->next;while(q!=NULL){if(c->data==q->data){c->next=q->next;}c=c->next;q=c->next;}return Lc;}4.如何将一个带头结点的单链表La分解成两个同样结构的单链表Lb,Lc,使得Lb中只含La表中奇数结点,Lc中含有La表的偶数结点?Status PartList(LinkList Lc){int n1=0,n2=0;LinkList La,Lb,L;LinkList a,b;L=Lc;while(L!=NULL){if(L->data%2==0){if(n1==0){a=La=L;L=L->next;}else{a->next=L;L=L->next;}}else{if(n2==0){b=Lb=L;L=L->next;}else{b->next=L;L=L->next;}}}a->next=NULL;b->next=NULL;return OK;}六、实验测试1.编写程序完成单链表的下列基本操作:七、总结附录1:源代码#include<stdio.h>#include<stdlib.h>#define OK 1#define ERROR 0#define OVERFLOW -2typedef int ElemType;typedef int Status;typedef struct LNode{ElemType data;struct LNode *next;} LNode,*LinkList;LinkList NewLNode(LNode *P,ElemType data){P = (LNode *)malloc(sizeof(LNode));P->data = data;P->next = NULL;return P;}LinkList InitList(){int i,value,n;LinkList H=(LinkList)malloc(sizeof(LNode));LinkList P=H;P->next=NULL;do{printf("请输入链表的长度:");scanf("%d",&n);if(n<=0)printf("输入有误请重新输入!\n");}while(n<=0);printf("请输入各个元素:\n");for(i=0; i<n; i++){scanf("%d",&value);LinkList NEW = (LinkList)malloc(sizeof(LNode)); NEW->data=value;P->next=NEW;NEW->next=NULL;P=NEW;}printf("链表建立成功!\n");return H->next;}LinkList InsertList(LinkList L,int i,ElemType value) {LinkList h,q,t=NewLNode(t,value);int x=0;h=q=L;if(i==1){t->next=h;h=t;}else{while(x++<i-2)q=q->next;t->next=q->next;q->next=t;}printf("插入成功!\n");return h;}LinkList DeleteList(LinkList L,int i){LinkList h,q,de;int x=0;h=q=L;int t;if(i==1)h=h->next;else{while(x++<i-2)q=q->next;de=q->next;if(de->next==NULL)q->next=NULL;elseq->next=de->next;}printf("删除成功!\n");return h;}Status LocateList(LinkList L,ElemType value){LinkList q=L;int i=0,t;while(q!=NULL){i++;if(q->data==value){printf("该结点在链表中的位置为第%d个\n",i); return OK;}q=q->next;}printf("该链表中没有该结点!\n");return ERROR;}Status Print(LinkList L){LinkList q=L;printf("该链表的每个元素为:\n");while(q!=NULL){printf("%8d",q->data);q=q->next;}printf("\n");return OK;}LinkList EmptyList(LinkList L){free(L->data);L->next=NULL;printf("清空成功!\n");return L;}LinkList FreeList(LinkList L){printf("释放成功!\n");free(L);}void Pr(){printf("\n1.插入新结点\n");printf("2.删除链表中的结点\n");printf("3.查找结点\n");printf("4.输出链表\n");printf("5.清空链表\n");printf("6.销毁链表\n");printf("7.退出\n");printf("请输入要使用的功能:");}int main(){LinkList L=InitList();int n,i,j;Pr();scanf("%d",&n);while(n>0&&n<7){switch(n){case 1:printf("请输入要插入的结点的值和插入的位置:"); scanf("%d %d",&i,&j);InsertList(L,j,i);break;case 2:printf("请输入要删除的结点的位置:");scanf("%d",&i);DeleteList(L,i);break;case 3:printf("请输入要查找的结点的值:");scanf("%d",&i);LocateList(L,i);break;case 4:Print(L);break;case 5:EmptyList(L);break;case 6:FreeList(L);break;}Pr();scanf("%d",&n);}if(n==7)printf("退出成功!"); return 0;}。

数据结构 实验报告

数据结构 实验报告

数据结构实验报告一、实验目的数据结构是计算机科学中非常重要的一门课程,通过本次实验,旨在加深对常见数据结构(如链表、栈、队列、树、图等)的理解和应用,提高编程能力和解决实际问题的能力。

二、实验环境本次实验使用的编程语言为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 。

数据结构课程设计实验单链表的插入与删除实验报告

数据结构课程设计实验单链表的插入与删除实验报告

数据结构课程设计实验单链表的插入与删除实验报告**学院本科实验报告(**-**学年第一学期)课程名称:数据结构实验任课教员:系:专业:年月日**学院《数据结构》课程实验报告实验项目名称:单链表的插入与删除系()::专业:指导教员:姓名:学号:成绩:同组姓名:实验地点:1.实验项目名称:单链表的查找、插入与删除2.实验目的和要求:设计算法,实现线性结构上的单链表的产生以及元素的查找、插入与删除。

通过该算法的设计和C语言程序实现,熟悉针对单链表作为存储结构的线性表上的查找、插入、删除等基本操作的实现方法。

3.实验原理:单链表采用链式存储结构,具有指针域和数据域。

4.实验内容:1)从键盘输入20个整数,产生不带表头的单链表,并输入结点值。

2)从键盘输入1个整数,在单链表中查找该结点的位置。

若找到,则显示“找到了”;否则,则显示“找不到”。

3)从键盘输入2个整数,一个表示欲插入的位置i,另一个表示欲插入的数值x,将x插入在对应位置上,输出单链表所有结点值,观察输出结果。

4)从键盘输入1个整数,表示欲删除结点的位置,输出单链表所有结点值,观察输出结果。

5.实验环境:Windows2000 visual studio c++6.操作方法与实验步骤:(1)实验原代码(c语言版):#includetypedef int ElemType;#include /* For _MAX_PATH definition */#include/* 单链表结构的定义*/typedef struct LNode {ElemType data;struct LNode *next;};typedef struct LNode *LinkList;LinkList CreatList_L(struct LNode **L,int n){ /*建立带表头结点的单链表L,n为单链表的大小*/ int i;struct LNode *p,*q;p=(struct LNode *)malloc(sizeof (struct LNode));(*L)=p;printf("请输入第1个数.");scanf("%d",&(p->data));for(i=n-1;i>0;--i){ q=(LinkList)malloc(sizeof(struct LNode));/*生成新结点*/ printf("请输入第%d个数.",n-i+1);scanf("%d",&(q->data));p->next=q;p=q;}p->next=NULL;return (*L);}void print(int c){ printf("\t%d",c);}/*打印函数*/void FindList(struct LNode *La,ElemType f) { struct LNode *cur;int i=1,u=1;cur=La;while(cur !=NULL){++i;if(cur->data==f){printf("在链表中找到了你输入的数字。

链表基本操作的课程设计

链表基本操作的课程设计

链表基本操作的课程设计一、课程目标知识目标:1. 学生能理解链表的基本概念,掌握链表的节点结构。

2. 学生能掌握链表的常见操作,包括创建、插入、删除和遍历。

3. 学生能了解链表与数组等其他数据结构的特点及适用场景。

技能目标:1. 学生能运用编程语言实现链表的创建、插入、删除和遍历等基本操作。

2. 学生能分析链表操作的算法复杂度,并进行简单优化。

3. 学生能通过链表解决实际问题,如实现队列、栈等数据结构。

情感态度价值观目标:1. 学生培养对数据结构的好奇心和求知欲,提高解决问题的兴趣。

2. 学生培养合作意识,学会在团队中分享和交流链表相关知识。

3. 学生培养严谨的学术态度,注重代码规范和程序优化。

课程性质:本课程为计算机科学或信息技术学科的高中课程,主要针对有一定编程基础的学生。

学生特点:学生已掌握基本编程概念,具备一定的逻辑思维能力,但对复杂数据结构了解有限。

教学要求:通过本课程,使学生能够掌握链表的基本操作,培养解决实际问题的能力,同时提高编程水平和团队协作能力。

教学过程中,注重理论与实践相结合,关注学生的个体差异,鼓励学生主动探索和思考。

二、教学内容1. 链表基本概念:链表的节点结构,链表的分类(单向链表、双向链表、循环链表)。

2. 链表操作:- 创建链表:动态申请内存,初始化节点。

- 插入操作:头插法、尾插法、指定位置插入。

- 删除操作:删除节点,释放内存。

- 遍历链表:遍历节点,访问数据。

3. 链表应用案例:实现队列、栈等数据结构。

4. 算法复杂度分析:分析链表操作的时间复杂度和空间复杂度。

5. 优化方法:链表操作的优化技巧,如缓存池、哨兵节点等。

教材关联:教学内容与教材中关于链表的相关章节紧密关联,涵盖链表的定义、操作及应用。

教学安排与进度:1. 课时:共4课时。

2. 第一课时:链表基本概念,节点结构及分类。

3. 第二课时:链表的创建与插入操作。

4. 第三课时:链表的删除与遍历操作,算法复杂度分析。

c课程设计链表实验报告

c课程设计链表实验报告

c课程设计链表实验报告一、教学目标本节课的教学目标是让学生掌握链表的基本概念和操作,包括链表的定义、节点的结构、链表的创建、插入、删除和遍历等操作。

通过本节课的学习,学生应该能够理解链表的工作原理,熟练使用链表进行数据存储和操作,并能够编写相应的程序实现链表功能。

具体来说,知识目标包括:1.了解链表的定义和特点;2.掌握链表的基本操作及其时间复杂度;3.理解链表在数据存储和处理中的应用场景。

技能目标包括:1.能够使用编程语言实现链表的创建、插入、删除和遍历等基本操作;2.能够分析链表程序的正确性和性能;3.能够运用链表解决实际问题,如实现一个简单的链表排序算法。

情感态度价值观目标包括:1.培养学生的逻辑思维能力和问题解决能力;2.激发学生对计算机科学和编程的兴趣;3.培养学生的团队合作意识和代码规范意识。

二、教学内容本节课的教学内容主要包括链表的基本概念和操作。

具体安排如下:1.链表的定义和特点:介绍链表的概念、节点结构以及链表的两种类型(单向链表和双向链表);2.链表的创建:讲解如何创建一个链表,包括初始化节点和链接节点的方法;3.链表的插入操作:介绍如何在链表中插入一个新节点,包括头插法和中插法的实现;4.链表的删除操作:讲解如何删除链表中的一个节点,包括头删法和中删法的实现;5.链表的遍历操作:介绍如何遍历链表,实现链表中各个节点的访问和打印;6.链表的应用场景:举例说明链表在实际编程中的应用,如链表排序算法。

三、教学方法为了达到本节课的教学目标,将采用以下教学方法:1.讲授法:讲解链表的基本概念和原理,引导学生理解链表的工作方式;2.案例分析法:通过分析典型链表程序,让学生掌握链表的操作方法和技巧;3.实验法:让学生动手编写链表程序,培养学生的实际编程能力和问题解决能力;4.讨论法:学生进行小组讨论,分享学习心得和编程经验,提高学生的团队合作意识。

四、教学资源为了支持本节课的教学内容和教学方法的实施,将准备以下教学资源:1.教材:《数据结构与算法》;2.参考书:《链表:原理与实现》;3.多媒体资料:PPT课件、链表操作视频教程;4.实验设备:计算机、编程环境。

链表的基本操作实验报告

链表的基本操作实验报告

链表的基本操作实验报告链表的基本操作实验报告引言:链表是一种常见的数据结构,它由一系列节点组成,每个节点包含数据和指向下一个节点的指针。

链表相较于数组拥有更灵活的操作,能够动态地增删节点。

本实验旨在通过实际操作链表,加深对链表基本操作的理解和掌握。

实验目的:1. 理解链表的基本概念和结构;2. 学会链表的插入、删除和遍历操作;3. 掌握链表的相关算法。

实验过程:1. 创建链表首先,我们需要创建一个链表。

链表可以是单链表、双链表或循环链表,本次实验我们选择创建一个单链表。

创建链表的过程如下:(1)定义一个链表的节点结构,包含数据和指向下一个节点的指针;(2)创建头节点,并将头节点的指针指向NULL,表示链表为空。

2. 插入节点链表的插入操作可以在链表的任意位置插入节点。

我们可以选择在链表的头部、尾部或指定位置插入节点。

下面以在链表头部插入节点为例,介绍插入节点的过程:(1)创建一个新节点,设置新节点的数据;(2)将新节点的指针指向原头节点;(3)将头节点的指针指向新节点,完成插入操作。

3. 删除节点链表的删除操作可以删除链表中的任意节点。

同样,我们可以选择删除链表的头部、尾部或指定位置的节点。

以下是删除链表头部节点的步骤:(1)将头节点的指针指向下一个节点,跳过原头节点;(2)释放原头节点的内存空间。

4. 遍历链表链表的遍历操作用于访问链表中的每个节点。

通过遍历链表,我们可以获取链表中的所有数据或执行特定的操作。

链表的遍历操作如下:(1)从链表的头节点开始,依次访问每个节点;(2)对每个节点执行相应的操作,如打印节点的数据。

实验结果:通过以上实验过程,我们成功地创建了一个链表,并实现了链表的插入、删除和遍历操作。

链表的基本操作能够灵活地处理数据,适用于各种场景。

链表的插入和删除操作可以在O(1)时间内完成,相较于数组的插入和删除操作具有更高的效率。

实验总结:链表作为一种常见的数据结构,具有灵活性和高效性的特点。

链表课程设计数据结构

链表课程设计数据结构

链表课程设计数据结构一、教学目标本节课的教学目标是让学生掌握链表的基本概念、原理和操作方法,包括链表的定义、结构、创建、插入、删除等基本操作,以及循环链表和双向链表的概念和应用。

同时,通过实践操作,培养学生的逻辑思维能力和编程能力,提高学生对数据结构的理解和应用能力。

在教学过程中,注重培养学生的团队合作意识和问题解决能力,使学生在学习过程中能够积极主动地参与讨论和实践,形成良好的学习习惯和态度。

二、教学内容本节课的教学内容主要包括链表的基本概念和操作方法。

首先,介绍链表的定义和结构,让学生了解链表是由一系列节点组成的数据结构,每个节点包含数据部分和指向下一个节点的指针。

然后,讲解链表的创建、插入、删除等基本操作,并通过示例代码让学生动手实践,加深对链表操作的理解。

接下来,介绍循环链表和双向链表的概念和应用,让学生了解循环链表是一种特殊的链表结构,每个节点都指向下一个节点,形成一个环状结构;双向链表则是一种每个节点都包含指向前一个节点和指向下一个节点的指针的链表结构。

最后,通过案例分析和讨论,让学生掌握链表在实际应用中的优势和局限性。

三、教学方法为了达到本节课的教学目标,将采用多种教学方法相结合的方式进行教学。

首先,采用讲授法,向学生讲解链表的基本概念和原理,让学生了解链表的定义、结构及其操作方法。

其次,采用讨论法,学生进行小组讨论,让学生分享对链表的理解和应用经验,互相学习和交流。

接下来,采用案例分析法,展示实际应用场景中的链表实例,让学生分析链表在解决问题时的优势和局限性。

最后,采用实验法,让学生动手编写代码实践链表的操作,培养学生的编程能力和解决问题的能力。

四、教学资源为了支持本节课的教学内容和教学方法的实施,将准备以下教学资源。

首先,教材《数据结构与算法》,提供链表的基本概念、原理和操作方法的理论支持。

其次,参考书籍,包括《链表编程实战》等,为学生提供更多的实践案例和经验分享。

再次,多媒体资料,包括PPT课件、教学视频等,为学生提供直观的学习材料,帮助学生更好地理解和掌握链表知识。

数据结构实验报告之链表顺序表的操作

数据结构实验报告之链表顺序表的操作

数据结构实验报告之链表顺序表的操作1、编写程序实现顺序表的各种基本运算:初始化、插⼊、删除、取表元素、求表长、输出表、销毁、判断是否为空表、查找元素。

在此基础上设计⼀个主程序完成如下功能:(1)初始化顺序表L;(2)依次在表尾插⼊a,b,c,d,e五个元素;(3)输出顺序表L;(4)输出顺序表L的长度;(5)判断顺序表L是否为空;(6)输出顺序表L的第4个元素;(7)输出元素c的位置;(8)在第3个位置上插⼊元素f,之后输出顺序表L;(9)删除L的第2个元素,之后输出顺序表L;(10)销毁顺序表L。

2、编写程序实现单链表的各种基本运算:初始化、插⼊、删除、取表元素、求表长、输出表、销毁、判断是否为空表、查找元素。

在此基础上设计⼀个主程序完成如下功能:(1)初始化单链表L;(2)依次在表尾插⼊a,b,c,d,e五个元素;(3)输出单链表L;(4)输出单链表L的长度;(5)判断单链表L是否为空;(6)输出单链表L的第4个元素;(7)输出元素c的位置;(8)在第3个位置上插⼊元素f,之后输出单链表L;(9)删除L的第2个元素,之后输出单链表L;(10)销毁单链表L。

1顺序表2 #include<stdio.h>3 #include<malloc.h>4 #include<stdlib.h>56#define TRUE 17#define FALSE 08#define OK 19#define ERROR 010#define INFEASIBLE -111#define OVERFLOW -212 typedef int Status;13 typedef char ElemType;1415#define LIST_INIT_SIZE 100 //线性表存储空间的初始分配量16#define LISTINCREMENT 10 //线性表存储空间的分配增量17 typedef struct {18 ElemType *elem; //存储空间基地址19int length; //当前长度20int listsize; //当前分配的存储容量21 } SqList;2223 Status InitList_Sq(SqList &L) { //算法2.324 L.elem = (ElemType *)malloc(LIST_INIT_SIZE * sizeof(ElemType));25if (!L.elem) exit(OVERFLOW); //存储分配失败26 L.length = 0; //空表长度为027 L.listsize = LIST_INIT_SIZE; //初始存储容量28return OK;29 }//InitList_Sq3031 Status ListInsert_Sq(SqList &L, int i, ElemType e) { //算法2.432 ElemType *newbase, *p, *q;33if (i<1 || i>L.length + 1) return ERROR; //i值不合法34if (L.length >= L.listsize)35 { //当前存储空间已满,增加分配36 newbase = (ElemType*)realloc(L.elem, (L.listsize + LISTINCREMENT) * sizeof(ElemType));37if (!newbase) exit(OVERFLOW); //存储分配失败38 L.elem = newbase; //新基址39 L.listsize += LISTINCREMENT; //增加存储容量40 }41 q = &(L.elem[i - 1]); //q为插⼊位置42for (p = &(L.elem[L.length - 1]); p >= q; --p) *(p + 1) = *p; //元素右移43 *q = e; //插⼊e44 ++L.length; //表长增145return OK;46 }4748void DispSqList(SqList L)49 {50int i;51for (i = 0; i < L.length; i++)52 printf("%c ", L.elem[i]);53 }5455 Status ListDelete(SqList &L, int i, ElemType &e)56 {57 ElemType *p,*q;58if ((i < 1) || (i > L.length)) return ERROR;59 p = &(L.elem[i - 1]);60 e = *p;61 q = L.elem + L.length - 1;62for (++p; p <= q; ++p)63 *(p - 1) = *p;64 --L.length;65return OK;66 } //ListDelete_Sq6768 Status GetElem(SqList L, int i, ElemType &e)69 {70if (L.length == 0 || i<1 || i>L.length)71return ERROR;72 e = L.elem[i - 1];73return OK;74 }7576int ListLength(SqList L)77 {78return(L.length);79 }8081 Status DestroyList(SqList &L)82 {83 free(L.elem);84 L.length = 0;85return OK;86 }8788 Status ListEmpty(SqList L)89 {90return(L.length == 0);91 }9293int LocateElem(SqList L, ElemType e)94 {95int i = 0;96while (i < L.length && L.elem[i] != e) i++;97if (i >= L.length) return0;98else return i + 1;99 }100101void main()102 {103 SqList h;104 ElemType e;105 InitList_Sq(h);106 ListInsert_Sq(h, h.length + 1, 'a');107 ListInsert_Sq(h, h.length + 1, 'b');108 ListInsert_Sq(h, h.length + 1, 'c');109 ListInsert_Sq(h, h.length + 1, 'd');110 ListInsert_Sq(h, h.length + 1, 'e');111 DispSqList(h);112 printf("%d\n\n",ListLength(h));113 ListEmpty(h);114if (ListEmpty(h))116 printf("Empty\n\n");117 }118else119 {120 printf("Not empty\n\n");121 }122 GetElem(h, 4, e);123 printf("%c\n", e);124 printf("%d\n",LocateElem(h, 'c'));125 ListInsert_Sq(h,3,' f');126 DispSqList(h);127 ListDelete(h, 2, e);128 DispSqList(h);129 DestroyList(h);130 }131132133134135136单链表137138139140 #include<stdio.h>141 #include<malloc.h>142 #include<stdlib.h>143144#define TRUE 1145#define FALSE 0146#define OK 1147#define ERROR 0148#define INFEASIBLE -1149#define OVERFLOW -2150 typedef int Status;151152 typedef char ElemType;153154155 typedef struct LNode {156 ElemType data;157int length;158struct LNode *next;159 }LNode, *LinkList;160161162 Status InitList_L(LinkList &L) {163 L = (LinkList)malloc(sizeof(LNode));164 L->next = NULL;165return OK;166 }167168 Status ListInsert_L(LinkList L, int i, ElemType e) { 169 LinkList p = L,s;170int j = 0;171while (p && j < i - 1)172 {173 p = p->next;174 ++j;175 }176if (!p || j > i - 1)177 {178return ERROR;179 }180else181 {182 s = (LinkList)malloc(sizeof(LNode));183 s->data = e;184 s->next = p->next;185 p->next = s;186return OK;187 }188 }189190void DispList_L(LinkList L)191 {192 LinkList p = L->next;193while (p != NULL)194 {195 printf("%c\n", p->data);196 p = p->next;197 }198200201void DestoryList(LinkList &L)202 {203 LinkList p = L, q = p->next;204while (q != NULL)205 {206 free(p);207 p = q;208 q = p->next;209 }210 free(p);211 }212213 Status ListLength_L(LinkList L) {214 LinkList p = L; int n = 0;215while (p->next != NULL)216 {217 n++;218 p = p->next;219 }220return (n);221 }222223 Status ListDelete(LinkList L, int i, ElemType &e){ 224int j;225 LinkList p, q;226 p = L;227 j = 1;228while (p->next && j < i)229 {230 p = p->next;231 ++j;232 }233if (!(p->next) || j > i)234 {235return ERROR;236 }237 q = p->next;238 p->next = q->next;239 e = q->data;240 free(q);241return OK;242 }243244 Status ListEmpty_L(LinkList L)245 {246return(L->length == 0);247 }248249 Status GetElem(LinkList L, int i, ElemType &e) 250 {251int j;252 LinkList p;253 p = L->next;254 j = 1;255while (p&&j<i)256 {257 p = p->next;258 ++j;259 }260if (!p || j > i)261 {262return ERROR;263 }264 e = p->data;265return OK;266 }267268 Status LocateElem(LinkList L, int e)269 {270 LinkList p = L;271int n=0;272//p->length = 0;273while (p != NULL)274 {275if(p->data != e)276 {277 p = p->next;278 n++;279 }280else281 {282break;283 }284 }285if(p != NULL)286 {287return n;288 }289else290 {291return ERROR;292 }293 }294295void main()296 {297 LinkList h;298 ElemType e;299 InitList_L(h);300 ListInsert_L(h, 1, 'a');301 ListInsert_L(h, 2, 'b');302 ListInsert_L(h, 3, 'c');303 ListInsert_L(h, 4, 'd');304 ListInsert_L(h, 5, 'e');305 DispList_L(h);306 printf("%d\n", ListLength_L(h)); 307if (ListEmpty_L(h))308 {309 printf("Empty\n\n");310 }311else312 {313 printf("Not empty\n\n");314 }315 GetElem(h, 4, e);316 printf("%c\n", e);317 printf("%d\n", LocateElem(h, 'c')); 318 ListInsert_L(h, 3, 'f');319 DispList_L(h);320 ListDelete(h, 2, e);321 DispList_L(h);322 DestoryList(h);323 }。

数据结构实验报告-链表

数据结构实验报告-链表

数据结构实验报告-链表院系:计算机学院实验课程:数据结构实验实验项⽬:实验⼆利⽤链表实现学⽣健康系统指导⽼师:开课时间:专业:计算机类班级:学⽣:学号:实验⼆利⽤链表实现学⽣健康系统1.综设实验题⽬利⽤链表实现学⽣健康系统2.中⽂摘要本实验是利⽤链表这⼀经典的数据结构来实现⼀个学⽣健康系统,从⽽学⽣的健康信息和相应的个⼈信息可以很⽅便地通过这个系统进⾏增、删、查、改等操作。

3.关键词课程名称数据结构实验实验项⽬利⽤链表实现学⽣健康系统实验时间年⽉⽇实验指导⽼师实验评分链表健康系统C++4.前⾔实验⽬的:想要通过链表这⼀数据结构来实现学⽣健康情况管理的⼏个操作功能。

实验意义:⽅便相关⼈员对学⽣健康信息的管理和操作。

实验内容:主要是新建学⽣健康系统、插⼊学⽣的数据、删除学⽣的数据、从⽂件读取学⽣健康数据、将学⽣的健康等信息写⼊到⽂件、查询指定学⽣的相关信息、在屏幕上输出学⽣相关信息等功能。

健康表中学⽣的信息有学号、姓名、出⽣⽇期、性别、⾝体状况等。

5.实验设计由于该实验主要涉及到链表这⼀存储结构,因此整个实验的关键点便在于对链表这个数据结构的建⽴和操作上。

常见的链表的操作有:建⽴链表、往链表中插⼊数据、从链表中删除数据、查找链表中的元素、修改链表中的元素、销毁链表。

由此,经过对问题的仔细分析之后,发现我们所要实现的健康系统的增、删、查、改等功能与链表这⼀数据结构的关系是:增加学⽣数据相当于往链表中的插⼊数据的操作;删除学⽣数据相当于从链表中的删除数据的操作;查找学⽣数据相当于链表中的查找元素的操作;修改学⽣数据相当于链表中的修改元素的操作;因此,我们可以直接⽤链表来存储所有学⽣的信息,每⼀个学⽣的信息集就是链表中的⼀个节点,这样,就使得我们的健康系统的问题归约到了链表的实现问题上了。

在这个链表的设计上,每⼀个节点包含有相应学⽣的所有信息和⼀个指向下⼀个节点的指针,学⽣的信息包括:学号、姓名、出⽣⽇期、性别和健康信息,分别采⽤C++中的string, string, int, bool 和string类型来表⽰。

链表的基本操作实验报告

链表的基本操作实验报告

《数据结构》实验报告学号1445203105 姓名王胜博班级软件5班成绩实验名称实验三链表的基本操作是否原创是一、实验要求编程实现链表下教材第二章定义的线性表的基本操作,最好用菜单形式对应各个操作,使其编程一个完整的小软件。

二、实验目的通过该实验,深入理解链表的逻辑结构、物理结构等概念,掌握链表基本操作的编程实现,熟练掌握C语言中指针的操作。

和实验2对比,掌握线性结构两种不同存储方式的区别。

三、设计思想用函数执行各个功能,随机插入元素四、主要源代码#include<stdio.h>#include<stdlib.h>#include<time.h>typedef int ElemType;typedef struct Node{ElemType data;struct Node *next;}Node, *LinkList;void InitList(LinkList *L){*L=(LinkList)malloc(sizeof(Node));if(!(*L))printf("存储分配失败\n");(*L)->next=NULL;}void DestroyList(LinkList L){LinkList p;while(L){p=L->next;free(L);L=p;}}int ListLength(LinkList L){LinkList p;int i=0;p=L->next;while(p){i++;p=p->next;}return i;}int GetElem(LinkList L,int i,ElemType &e){ LinkList p;p=L->next;int j=1;while(p&&j<i){p=p->next;++j;}e=p->data;return e;}int GetElemLo(LinkList L,int i,ElemType &e){ LinkList p;p=L->next;int j=1;while(p->data!=i&&j<=ListLength(L)){p=p->next;++j;}e=j;return e;}void FindPre(LinkList L,int x){LinkList p;p=L;if(p->next->data==x){printf("第一个元素没有前驱\n");}else{while(p->next){if(p->next->data==x){printf("%d的前驱结点是:%d\n",x,p->data);break;}else{p=p->next;}}}}void FindNext(LinkList L,int x){LinkList p;p=L->next;while(p){if(p->data==x){printf("%d的后继结点是:%d\n",x,p->next->data);break;}else{p=p->next;}if(p->next==NULL){printf("最后一个元素没有后继\n");break;}}}void LinkInset_L(LinkList &L,int i,ElemType e){ LinkList p;p=L;int j=0;while(p&&j<i-1){p=p->next;++j;}if(!p||j>i-1)printf("i小于1或者i大于表长加1\n");LinkList s;s=(LinkList)malloc(sizeof (Node));s->data=e;s->next=p->next;p->next=s;}void ListDelete_L(LinkList &L,int i,ElemType &e){ LinkList p,q;p=L;int j=0;while(p->next && j<i-1){p=p->next;++j;}if(!p->next ||j>i-1)printf("删除位置不合理\n");q=p->next;p->next=q->next;e=q->data;free(q);printf("已删除的元素是:%d\n",e);}void visit(ElemType e){printf("%d,",e);}void ListTraverse(LinkList L){LinkList p=L->next;while(p){visit(p->data);p=p->next;}printf("\n");}void CreatListTail(LinkList *L,int n){LinkList p,r;int i;srand(time(0));*L=(LinkList)malloc(sizeof(Node));r=*L;for(i=0;i<n;i++){p=(Node *)malloc(sizeof(Node));p->data=rand()%100+1;r->next=p;r=p;}r->next=NULL;}int main(){LinkList L;int opp;printf("可执行的操作有:\n");printf("1.初始化或重置链表\n");printf("2.随机插入元素\n");printf("3.显示链表中数据元素个数\n");printf("4.输出所输入的链表元素\n");printf("5.所指位序的元素值\n");printf("6.链表已存在元素的位序\n");printf("7.请输入元素,求直接前驱\n");printf("8.请输入元素,求直接后继\n");printf("9.在第i个位置插入元素\n");printf("10.删除第i个元素\n");printf("11.销毁链表\n");printf("12.退出\n");printf("\n");printf("请输入你的选择:\n");do{scanf("%d",&opp);switch(opp){case 1:{InitList(&L);printf("链表已初始化\n");printf("下一步操作:");break;}case 2:{int n;printf("输入插入元素个数:");scanf("%d",&n);CreatListTail(&L,n);printf("下一步操作:");break;}case 3:{printf("链表中元素的个数是:%d\n",ListLength(L));printf("下一步操作:");break;}case 4:{ListTraverse(L);printf("下一步操作:");break;}case 5:{int m,e;printf("输入要取元素的位置:");scanf("%d",&m);if(m>ListLength(L)){printf("输入有误\n");}else{GetElem(L,m,e);printf("该元素是:%d\n",e);}printf("下一步操作:");break;}case 6:{int i,e;printf("输入要取的元素:");scanf("%d",&i);GetElemLo(L,i,e);printf("该元素的位置是:%d\n",e);printf("下一步操作:");break;}case 7:{int x;printf("要求哪个元素的前驱?");scanf("%d",&x);FindPre(L,x);printf("下一步操作:");break;}case 8:{int x;printf("要求哪个元素的后继?");scanf("%d",&x);FindNext(L,x);printf("下一步操作:");break;}case 9:{int i,e;printf("在哪个位置插入元素?");scanf("%d",&i);if(i>ListLength(L))printf("输入有误\n");else{printf("插入的新元素是:");scanf("%d",&e);LinkInset_L(L,i,e);printf("新链表:");ListTraverse(L);}printf("下一步操作:");break;}case 10:{int i,e;printf("要删除哪个位置的元素?");scanf("%d",&i);if(i>ListLength(L))printf("输入有误\n");else{ListDelete_L(L,i,e);printf("新链表:");ListTraverse(L);}printf("下一步操作:");break;}case 11:{DestroyList(L);printf("链表已销毁!\n");printf("下一步操作:");break;}case 12:{printf("谢谢使用\n");break;}default:{printf("输入错误,请重新输入\n");break;}}}while(opp!=12);return 0;}五、调试与测试数据六、实验总结。

数据结构课程设计-单链表的插入、删除、查找等

数据结构课程设计-单链表的插入、删除、查找等

单链表的插入、删除、合并等基本操作一、实验目的1、理解数据结构中单链表的定义和建立。

2、掌握单链表中结点结构的C语言描述。

3、熟练掌握单链表的插入、删除和修改等算法的设计与C语言实现。

4、将理论与实际相结合,切实提高自己的逻辑能力和动手能力。

二、设计内容1、输入单链表长度,创建一个单链表。

2、对建立好的单链表进行插入操作。

3、对建立好的单链表进行删除操作。

4、对建立好的单链表进行合并操作。

三、概要设计抽象数据类型线性表的定义如下:ADTA List{数据对象:D={ai I ai∈ElemSet , i=1 ,2 , … , n n>=0 }数据关系:R1={<ai-1 , ai> I ai-1 , ai∈D , i=2 , … , n }基本操作:Creates( &L )操作结果:构建一个空的线性表L。

Insertsl( &L , k ,i)初始条件:线性表L已存在。

操作结果:在带有头结点单链表的第k个元素之前插入元素i。

Deletesl( &L , i, j )初始条件:线性表L已存在。

操作结果:删除指定位置j元素i。

Hebing( &L )初始条件:线性表L已存在。

操作结果:清除新链表中相同的元素。

}ADT List四、算法流程图五、算法源代码#include <stdio.h> #include <malloc.h>typedef struct node {int data;struct node *next; }node;node *head;int k;node * creates(){node *p,*s,*h;int j=1,x, n;p=h=(node*)malloc(sizeof(node));h->next=NULL;printf("请输入链表长度:");scanf("%d",&n);printf("请输入 %d 个数字创建链表:",n);while(j<=n){scanf("%d",&x);s=(node*)malloc(sizeof(node));s->data=x;p->next=s;p=s;j++;}p->next=NULL;return h;}void insertsl(node *head, int k, int i){/*在带有头结点单链表的第k个元素之前插入元素i*/ int j;node *p, *t;p=head;j=0;while ( p&&j<k-1 ) /*若p不指向空,并且没有找到合适位置则继续循环*/ {p = p->next;j++;}if (!p||j>k-1) /*k小于1或大于表长*/printf("插入位置不对。

数据结构课程设计报告--链表

数据结构课程设计报告--链表

班级:姓名: 学号: 设计时间:《高级语言程序设计》课程设计报告一、应用程序的名称:链表二、应用程序的主题与设计目的:实现一个链表的建立、输出,并且完成节点的插入、删除操作。

三、应用程序简介: 1、基本结构A 、功能模块图B 、各模块流程图 (1)链表的建立:开辟一个新节点,使p1、P2指向它读入一个学生数据给p1所指的结点p 指向的节点并且p(3) 链表结点的删除(4)链表节点的插入2、基本内容:(源代码及注释) #include<stdio.h>#include<malloc.h>#define LEN sizeof(struct student) int n;struct student{int num;int score;struct student *next;};struct student *creat(void) /*定义函数,此函数带回一个指向链表头的指针*/{struct student *head;struct student *p1,*p2;n=0;p1=p2=(struct student *)malloc(LEN); /*开辟一个新单元*/ scanf("%d,%d",&p1->num,&p1->score);head=NULL;while(p1->num!=0){ n=n+1;if(n==1)head=p1;else p2->next=p1; /*把p1所指的结点连接在p2所指的结点后面*/p2=p1;p1=(struct student*)malloc(LEN);scanf("%d,%d",&p1->num,&p1->score);}p2->next=NULL;return(head); /*函数返回head的值,即链表中第一个节点的起始地址*/}void print(struct student*head){struct student*p;printf("\nNow,these %d records are:\n",n);p=head;if(head!=NULL)do{ printf("%d %d\n",p->num,p->score);p=p->next;}while(p!=NULL);}struct student*del(struct student*head,int num){struct student*p1,*p2;if(head==NULL){printf("\nlist null! \n");return head;}p1=head;while(num!=p1->num && p1->next!=NULL) /*p1指向的不是所要找的节点,且后有节点*/{ p2=p1;p1=p1->next;} /*p1后移一个节点*/if(num==p1->num) /*找到了*/{ if(p1==head)head=p1->next; /*若p1指向的首节点,把第二个节点地址赋予head*/else p2->next=p1->next; /*否则将下一个节点地址赋给前一节点地址*/printf("delete:%d\n",num);n=n-1;}else printf("%d not beed found!\n",num); /*找不到该节点*/ return(head);}struct student*insert(struct student*head,struct student*stud) {struct student*p0,*p1,*p2;p1=head; /*使p1指向第一个节点*/p0=stud; /*p0指向要插入的节点*/if(head==NULL) /*原来的链表是空表*/{head=p0;p0->next=NULL;} /*使p0指向的节点作为头结点*/else{while((p0->num>p1->num) && (p1->next!=NULL)){ p2=p1; /*使p2指向刚才p1指向的节点*/p1=p1->next; /*p1后移一个节点*/}if(p0->num<=p1->num){if(head==p1)head=p0; /*插到原来第一个节点之前*/else p2->next=p0; /*插到p2指向的节点之后*/ p0->next=p1;}else{ p1->next=p0;p0->next=NULL;} /*插到最后的节点之后*/}n=n+1; /*节点数加1*/return(head);}void main() /*作主调函数*/{ struct student *head,stu;long del_num;printf("input records:\n");head=creat(); /*建立链表,返回头指针*/print(head); /*输出全部节点*/printf("\ninput the deleted number:");scanf("%1d",&del_num); /*输入要删除的学号*/head=del(head,del_num); /*删除后链表的头地址*/print(head); /*输出全部节点*/printf("\ninput thr inserted record:"); /*输入要插入的节点*/ scanf("%d,%d",&stu.num,&stu.score);head=insert(head,&stu); /*插入一个节点,返回头结点地址*/ print(head); /*输出全部节点*/}四、主要运行界面的介绍:(在vc环境下)1、连接运行后,输入数据(以两组为例),组之间以逗号间隔,最后以数字0结束。

数据结构课程设计-链表操作

数据结构课程设计-链表操作
(3)定义一个遍历查找的算法,通过此算法可以查找到链表中的每一个节点是否存在。
(4)定义查找链表的每一个前驱和后继,通过定义这个算法,可以很容易的实现对链表的前驱和后继的查找工作。
(5)定义插入节点的算法,通过定义这个算法,并结合这查找前驱和后继的算法便可以在连链表的任意位置进行插入一个新节点。
(6)定义删除节点的操作,这个算法用于对链表中某个多余节点的删除工作。
根据对数据结构的了解,我们觉得我们对单链表的认识要深一点。因此我们选择了单链表的实验,作为线性表的一种存储结构,它的特点是可以从分利用存储单元来存储数据,并且可以方便的实现对数据进行插入、删除、输出等操作。在我们进行课程设计时,虽然在大体上算法是正确的,但时常会出现一些小问题,使我们不得不花一些时间来查找、修改错误。
case 7:printf("请输入要查找的元素:");
scanf("%d",&x);
Locate(H,x);break;
}
printf("\n请选择以下操作数,选择-1为结束");
printf("\n1:creatlinklist(H)");
printf("\n2:leng(H)");
printf("\n3:GetElem(H,i)");
if(p->next==NULL)
printf("链表为空!");
while(p->next!=NULL){
k++;
p=p->next;
printf("%3d",p->data);
}
}nt x)//查找元素
  1. 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。

《数据结构》课程设计报告题目: _________链表操作__________ 专业班级: _______ ________ 姓名: _________________ 学号: ______ ______ 设计时间: _______ _______ 指导教师: _________ _________一、设计题目链表操作一、设计目的1.掌握线性链表的建立。

2.掌握线性链表的基本操作。

二、设计内容和要求利用链表的插入运算建立线性链表,然后实现链表的查找、删除、计数、输出、排序、逆置等运算,插入、删除、查找、计数、输出、排序、逆置要单独写成函数,并能在屏幕上输出操作前后的结果。

二、运行环境(软、硬件环境)硬件环境:软件环境:Microsoft Visual C++ 6.0三、算法设计思想插入:先创建一个结点用来存储要插入的元素,然后,通过单链表的指针功能,修改指针的指向来将新创建的结点插入该单链表中。

删除:通过循环找到要删除的位置,然后也是通过修改指针来将该位置的元素删除。

查找:声明三个变量和一个数组,其中两变量分别表示查找元素的个数和在链表中出现的位置,一数组储存该元素在链表之中的位置,另外一变量作数组下标的递增之用。

通过循环和if语句的条件比较来确定元素的位置和在链表之中的出现次数,保存于数组中,最后可将该元素在链表中的位置通过数组输出。

计数:用一结构体数组储存链表中各元素和其出现的次数然后通过双重循环来确定各元素的个数。

排序:可将简单的选择排序将循环条件变作指针表示得到。

逆置:用循环找到单链表的倒数第二个结点和最后一个结点,再声明一个新的结点将其指向最后一个结点,然后令链表的倒数第二个结点空(由此作为循环的截止条件),在用外层循环一步步将链表结点倒序接到以新增结点为头结点的链表上。

四、流程图五、算法设计与分析插入:先创建一个结点用来存储要插入的元素,然后,通过单链表的指针功能,修改指针的指向来将新创建的结点插入该单链表中。

该算法简单易行。

删除:通过循环找到要删除的位置,然后也是通过修改指针来将该位置的元素删除。

查找:声明三个变量和一个数组,其中两变量分别表示查找元素的个数和在链表中出现的位置,一数组储存该元素在链表之中的位置,另外一变量作数组下标的递增之用。

通过循环和if语句的条件比较来确定元素的位置和在链表之中的出现次数,保存于数组中,最后可将该元素在链表中的位置通过数组输出。

计数:用一结构体数组储存链表中各元素和其出现的次数然后通过双重循环来确定各元素的个数。

此算法不足之处是会删除重复的结点,导致计数前后链表变化。

排序:可将简单的选择排序将循环条件变作指针表示得到。

逆置:用循环找到单链表的倒数第二个结点和最后一个结点,再声明一个新的结点将其指向最后一个结点,然后令链表的倒数第二个结点空(由此作为循环的截止条件),在用外层循环一步步将链表结点倒序接到以新增结点为头结点的链表上。

六、源代码#include <stdio.h>#include <malloc.h>#include <stdlib.h>typedef struct node{int data;struct node *next;}node,*linklist;//创建链表void creatlist(linklist &l){linklist p,r;l=(linklist)malloc(sizeof(node));l->next=NULL;r=l;printf("输入链表以0结束\n");for(;;){p=(linklist)malloc(sizeof(node));scanf("%d",&p->data);r->next=p;if (p->data!=0)r=p;else{free(p);break;}}r->next=NULL;}//将e插到第i位void insertlist(linklist &l,int i,int e){int j;linklist s,f;s=(linklist)malloc(sizeof(node));f=(linklist)malloc(sizeof(node));f->data=e;s=l;for (j=1;j<i;j++){s=s->next;}f->next=s->next;s->next=f;}//查找元素evoid Searchelem(linklist l,int e){int counti=0,counte=0,s=0;int a[100];while (l->next){counti++;if (l->next->data==e){counte++;a[s++]=counti;}l=l->next;}if(counte==0){printf("该链表中无此数!\n");}else{printf("该链表中此元素出现了%d次,在第",counte);for(int i = 0 ;i<s;i++){printf("%d ",a[i]);}printf("次出现!\n");}}//删除第i位void deletelist(linklist &l,int i){int j;linklist p,q;p=(linklist)malloc(sizeof(node));q=(linklist)malloc(sizeof(node));p=l;for(j=1;j<i;j++){p=p->next;}q=p->next;p->next=q->next;free(q);}//计数void listcount(linklist l){struct a{int x;int y;}a[100];int m=0;linklist p,q;p=(linklist)malloc(sizeof(node));q=(linklist)malloc(sizeof(node));while (l->next){a[m].x = l->next->data;a[m].y = 1;p=l->next;while (p->next){if (l->next->data==p->next->data){p->next=p->next->next;a[m].y++;}else{p=p->next;}}m++;l=l->next;}printf("此链表中:\n");for (int i=0;i<m;i++){printf(" %d出现%d次\n",a[i].x,a[i].y);}}//排序void listsort(linklist &l){linklist p,q;int m;p=l;while(p->next){q=p->next;while(q->next){if(p->next->data>q->next->data){m=p->next->data;p->next->data=q->next->data;q->next->data=m;}elseq=q->next;}p=p->next;}}//逆置void inverse(linklist &l){linklist p,q,r;p=(linklist)malloc(sizeof(node));q=(linklist)malloc(sizeof(node));r=(linklist)malloc(sizeof(node));p=l;q->next=NULL;r=q;while (p->next){while(p->next->next){p=p->next;}q->next=p->next;q=q->next;p->next=NULL;p=l;}l=r;}//输出void printlist(linklist l){while(l->next){printf("%d ",l->next->data);l=l->next;}printf("\n");}void main(){int e,n;linklist l;l=(linklist)malloc(sizeof(node));l->next=NULL;creatlist(l);system("cls");int x;do{printf("初始化:");printlist(l);printf ("~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n"); printf ("|* 1.插入*|\n"); printf ("|* 2.删除*|\n"); printf ("|* 3.查找*|\n"); printf ("|* 4.计数*|\n"); printf ("|* 5.排序*|\n"); printf ("|* 6.逆置*|\n"); printf ("|* 7.退出*|\n"); printf ("~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n"); printf ("输入选择:");scanf("%d",&x);switch (x){case 1:printf("前:");printlist(l);printf("依次输入插入元素和插入位置:");scanf("%d %d",&e,&n);insertlist(l,n,e);printf("后:");printlist(l);break;case 2:printf("前:");printlist(l);printf("请输入要删除元素的位置:");scanf("%d",&n);deletelist(l,n);printf("后:");printlist(l);break;case 3:printf("前:");printlist(l);printf("请输入要查找的数:");scanf("%d",&e);Searchelem(l,e);printf("后:");printlist(l);break;case 4:listcount(l);break;case 5:printf("前:");printlist(l);listsort(l);printf("后:");printlist(l);break;case 6:printf("前:");printlist(l);inverse(l);printf("后:");printlist(l);break;case 7:exit(0);}getchar();if (getchar()){system("cls");}}while(x>0&&x<7); }七、运行结果分析输入:插入:逆置:排序:计数:删除:查找:八、收获及体会对于数据结构里单链表部分的内容还是非常熟悉的,在学数据结构这门课的时候,由于一开始没听懂,老师讲到后面我还在看前面,而且老参不透,以至于前面的单链表的部分花了大量时间,但这也是有好处的,钻研的时间多了到后来就非常的熟了,在对而后的课程中理解的速度就加快了不少。

相关文档
最新文档