链表实现集合实验报告

合集下载

链表的实验报告

链表的实验报告
{
front->next=alist.front->next;
cout<<"复制构造函数"<<endl;
}
//touchafa
template<class T>
linklist<T>::linklist(T a[],int n)
{
front=new Node<T>;
front->next=NULL;
找到要插入的结点的前一个结点新结点的指针域指向p然后p前面的结点指向这个新的结点这样这个新的结点就插入到了链表里面3代码的时间复杂度
数据结构实验报告
1.
2.
2.1
2.2
2.3
算法一:
template<class T>
linklist<T>::linklist(T a[],int n)
{
front=new Node<T>;
T x=q->data;
delete q;
return x;
}
[1]算法功能:删除链表中的某个元素
[2]思想:删除就是先找到要删除的元素的前面的元素,然后前面的这个结点直接指向这个结点的下一个结点,然后再把这个指针删除。
[3]时间复杂度:O(n)
[4]代码逻辑:
1.从第一个结点开始,查找第i-1个元素,设为P指向该结点,如果查找失败则抛出异常
front->next=NULL;
for(int i=n-1;i>=0;i--)
{
Node<T>*s=new Node<T>;
s->data=a[i];

基于单链表实现集合的并交差运算实验报告

基于单链表实现集合的并交差运算实验报告

基于单链表实现集合的并交差运算实验报告一 实验题目: 基于单链表实现集合的并交差运算二 实验要求:2.2:编写一个程序,实现顺序表的各种基本运算(1)初始化单链表h ;(2)依次采用尾插法插入a,b,c,d,e 元素;(3)输出单链表h(4)输出单链表h 的长度(5)判断单链表h 是否为空(6)输出单链表h 的第三个元素(7)输出元素在a 的位置(8)在第4个元素位置上插入f 元素(9)输出单链表h(10)删除L 的第3个元素(11)输出单链表(12)释放单链表2.2:编写一个程序,采用单链表表示集合(集合中不存在重复的元素),并将其按照递增的方式排序,构成有序单链表,并求这样的两个集合的并,交和差。

三 实验内容:3.1 线性表的抽象数据类型:ADT List{数据对象;D=}0,,...,2,1,ElemS et |{≥=∈n n i a a i i数据关系:R1=},...,2,,|,{11n i D a a a a i i i i =∈><--基本操作:InitList(&L)操作结果;构造一个空的线性表LDestroyList(&L)初始条件:线性表L已存在操作结果:销毁线性表LClearList(&L)初始条件:线性表L已存在操作结果:将L置为空表ListEmpty(L)初始条件:线性表已存在操作结果:若L为空表,则返回TRUE,否则返回FALSEListLength(L)初始条件:线性表已存在操作结果:返回L中数据元素的个数GetElem(L,i)初始条件:线性表已存在,1<=i<=ListLength(L)操作结果:用e返回L中第i个数据元素的值LocateElem(L,i,e)初始条件:线性表已存在,用循环遍历整个线性表,如果e与线性表中的元素相同;操作结果:用此时的i+1返回该元素在线性表的位序ListInsert(&L,i,e)初始条件:线性表存在,1<=i<=ListLength(L)+1;操作结果:在L中第i个位置之前插入新的数据元素,e,L的长度加1。

实验二链表的实现和应用[最新]

实验二链表的实现和应用[最新]

实验二链表的实现和应用一、实验目的掌握线性表的链式存储结构设计与基本操作的实现二、实验内容与要求⑴定义线性表的链式存储表示;⑵基于所设计的存储结构实现线性表的基本操作;⑶编写一个主程序对所实现的线性表进行测试;⑷线性表的应用:①设线性表L1和L2分别代表集合A和B,试设计算法求A和B的并集C,并用线性表L3代表集合C;②设线性表L1和L2中的数据元素为整数,且均已按值非递减有序排列,试设计算法对L1和L2进行合并,用线性表L3保存合并结果,要求L3中的数据元素也按值非递减有序排列。

三、数据结构设计在主函数中实现函数的调用,从而实现线性表的插入、删除、创建、显示等。

四、测试结果通过输入不同的数字(1~6)实现不同的操作,在两个线性表结合时,线性表二在源程序中已给出的,通过操作可以得到非单调递减的有序数列五、心得体会在写程序的过程中要注意分析,参照其他标准程序,多上机运行一点点的改正错误,这样才会有所提高。

MAIN.C 方丽平信计1203班1130112321 最后修改时间2014/3/31#include<stdio.h>#include<stdlib.h>#define maxsize 1024typedef int datatype;typedef struct node{datatype data;struct node * next;}linkList;int main(){linkList * CREATE();int INSERT(linkList *head, int value, int position);int DELETE(linkList *head, int position);int DISPLAY(linkList *head);linkList * COMBINE(linkList *head1, linkList *head2); linkList * head1;linkList * head2;linkList * head3;linkList * head;linkList * p1,* p2,* s1,* s2,* r1,* r2;int position, value, i;head1 = malloc(sizeof(linkList));r1 = head1;head2 = malloc(sizeof(linkList));r2 = head2;for(i = 0; i< 20; i++){s1 = malloc(sizeof(linkList));s1 ->data = i;r1 ->next = s1;r1 = s1;s2 = malloc(sizeof(linkList));s2 ->data = i + 2;r2 ->next = s2;r2 = s2;}r2 -> next = NULL;r1 -> next = NULL;while(1){printf("the program \n");printf("can realize to create,insert,delete,display,etc\n"); printf("1:create the ranked list\n");printf("2:insert a data\n");printf("3:delete a data\n");printf("4:display all the data\n");printf("5:Combine two link lists of operation\n"); printf("6:return,end of the program\n");printf("selection of operation\n");scanf("%d",&i);while ( i < 1 || i > 6 ){printf("please input again\n");scanf("%d",&i);}switch(i){case 1:head = CREATE();break;case 2:/*INSERT(p);*/printf("Please input insert place\n");scanf("%d",&position);printf("Please input insert value\n");scanf("%d",&value);INSERT(head, value, position);break;case 3:printf("Please input delete position\n");scanf("%d",&value);DELETE(head, position);break;case 4:DISPLAY(head);break;case 5:printf("The list 1:\n");DISPLAY(head1);printf("The list 2:\n");DISPLAY(head2);printf("The combine list:\n");head3 = COMBINE(head1, head2);DISPLAY(head3);break;case 6:exit(0);break;}}}linkList * CREATE(){int value;linkList * head,* s,* r;head = malloc(sizeof(linkList));r = head;printf("input the data of the number,input 55 over!");scanf("%d",&value);do{s = malloc(sizeof(linkList));s ->data = value;r ->next = s;r = s;printf("input the data of the number");scanf("%d",&value);}while(value != 55);r -> next = NULL;return head;}int INSERT(linkList *head,int value, int position){int j = 1;linkList *p,*s,*n;s = malloc(sizeof(linkList));s ->data = value;p = head;printf("Note:if the position is greater than the length of the table will be put in the final");while(j < position){if( (p -> next) != NULL ){p = p -> next;}j ++;}n = p -> next;s -> next =n;p -> next = s;return 0;}int DELETE(linkList *head, int position){int j;linkList *p;linkList *s;p = head;printf("Note:if the position is greater than the length of the table will be delete nothing!");for(j = 1;j < position; j ++){if( (p -> next) != NULL ){p = p -> next;}else{return 0;}}s = p -> next;if((s -> next) != NULL){(*p).next = (*s).next;}s = NULL;return 0;}int DISPLAY(linkList *head){linkList *p;int i;i = 0;p = head -> next;while(p != NULL){printf("%5d",(*p).data);p = p -> next;i ++;if(i % 5 == 0)printf("\n");}return 0;}linkList * COMBINE(linkList *head1, linkList *head2) {linkList *head,*r;linkList *p1, *p2,*s;head = malloc(sizeof(linkList));r = head;p1 = malloc(sizeof(linkList));p2 = malloc(sizeof(linkList));p1 = head1 -> next;p2 = head2 -> next;do{s = malloc(sizeof(linkList));if( (p1 != NULL) && (p2 != NULL) ){if(p1 -> data < p2 -> data ){s -> data = p1 -> data;p1 = p1 ->next;}else{s -> data = p2 -> data;p2 = p2 ->next;}}else if( (p1 != NULL) && (p2 == NULL) ){s -> data = p1 -> data;p1 = p1 ->next;}else if( (p2 != NULL) && (p1 == NULL) ){s -> data = p2 -> data;p2 = p2 ->next;}r ->next = s;r = s;}while( (p1 != NULL) || (p2 != NULL) );return head;}。

链表顺序表实验报告数据结构与算法分析

链表顺序表实验报告数据结构与算法分析

链表顺序表实验报告--数据结构与算法分析————————————————————————————————作者:————————————————————————————————日期:数据结构与算法分析课程设计报告课题名称: 使用一个链表和顺序表构建城市数据库提交文档组号: 2编程学生姓名及学号:测试学生姓名及学号:报告学生姓名及学号:指导教师姓名:指导教师评阅成绩:指导教师评阅意见:..提交报告时间: 2013年11 月日实验一:Implement acity databaseusingunordered lists andlink lists1.实验的目的和要求:<1>采用C++的ASCII码文件和模块函数实现;<2>熟练掌握数组列表和链表列表的实现;<3>熟练掌握计算机系统的基本操作方法,了解如何编译、运行一个C++程序;<4>上机调试程序,掌握查错、排错使程序能正确运行。

2.实验的环境:1、硬件环境:索尼笔记本电脑,Intel(R)Core(TM) i7-3632M,8GB内存可;2、软件环境:Windows8下的Microsoft Visual Studio 20082.算法描述:数据结构与算法分析的背景:数据结构是计算机程序设计的重要理论技术基础,它不仅是计算机学科的核心课称,而且已成为其他理工专业的热门选修课。

数据结构是一门专业选技术基础科。

一方面,它要求我们学会分析研究计算机加工的数据结构的特性,以便为应用涉及的数据选择适当的逻辑结构、存储结构及其相应的算法,并初步掌握算法的时间分析和空间分析的技术;另一方面,数据结构的学习过程也是复杂程序设计的训练过程,要求我们编写的程序结构清楚和正确易读,复合软件工程的规范,并培养我们的数据抽象能力。

本次课程设计就是对数据结构中的顺序表和链表的操作的应用。

顺序表:1.顺序表的定义ﻫ(1)顺序存储方法即把线性表的结点按逻辑次序依次存放在一组地址连续的存储单元里的方法。

链表基本操作实验报告

链表基本操作实验报告

实验2 链表基本操作实验一、实验目的1. 定义单链表的结点类型。

2. 熟悉对单链表的一些基本操作和具体的函数定义。

3. 通过单链表的定义掌握线性表的链式存储结构的特点。

二、实验内容与要求该程序的功能是实现单链表的定义和主要操作。

如:单链表建立、输出、插入、删除、查找等操作。

该程序包括单链表结构类型以及对单链表操作的具体的函数定义和主函数。

程序中的单链表(带头结点)结点为结构类型,结点值为整型。

要求:同学们可参考指导书实验2程序、教材算法及其他资料编程实现单链表相关操作。

必须包括单链表创建、输出、插入、删除操作,其他操作根据个人情况增减。

三、 算法分析与设计。

头结点......2.单链表插入s->data=x; s->next=p->next; p->next=s;3.单链表的删除:p->next=p->next->next;四、运行结果1.单链表初始化2.创建单链表3.求链表长度4.检查链表是否为空5.遍历链表6.从链表中查找元素7.从链表中查找与给定元素值相同的元素在顺序表中的位置8.向链表中插入元素插入元素之后的链表9.从链表中删除元素删除位置为6的元素(是3)10.清空单链表五、实验体会经过这次单链表基本操作实验,自己的编程能力有了进一步的提高,认识到自己以前在思考一个问题上思路不够开阔,不能灵活的表达出自己的想法,虽然在打完源代码之后出现了一些错误,但是经过认真查找、修改,最终将错误一一修正,主要是在写算法分析的时候出现了障碍,经过从网上查找资料,自己也对程序做了仔细的分析,对单链表创建、插入、删除算法画了详细的N-S流程图。

六、C语言版原代码# include<stdio.h># include<stdlib.h>/* 定义ElemType 为int类型*/typedef int ElemType;# define TRUE 1# define FALSE 0# define NULL 0# define flag -1/*单链表的结点类型*/typedef struct LNode{ElemType data;struct LNode *next;}LNode,*LinkedList;/*初始化单链表*/LinkedList LinkedListInit(){LinkedList L;L=(LinkedList)malloc(sizeof(LNode));L->next=NULL;return L;}/*清空单链表*/void LinkedListClear(LinkedList L){L->next=NULL;printf("链表已经清空\n");}/*检查单链表是否为空*/int LinkedListEmpty(LinkedList L){if(L->next==NULL) return TRUE;else return FALSE;}/*遍历单链表*/void LinkedListTraverse(LinkedList L) {LinkedList p;p=L->next;if(p==NULL) printf("单链表为空表\n");else{printf("链表中的元素为:\n");while(p!=NULL){printf("%d ",p->data); p=p->next;}}printf("\n");}int LinkedListLength (LinkedList L){LinkedList p;int j;p=L->next;j=0;while(p!=NULL){j++;p=p->next;}return j;}LinkedList LinkedListGet(LinkedList L,int i) {LinkedList p;int j;p=L->next;j=1;while(p!=NULL&&j<i){p=p->next;j++;}if(j==i) return p;else return NULL;}int LinkedListLocate(LinkedList L,ElemType x) {LinkedList p;int j;p=L->next;j=1;while(p!=NULL&&p->data!=x){p=p->next;j++;}if(p) return j;else return 0;}void LinkedListInsert(LinkedList L,int i,ElemType x) {LinkedList p,s;int j;j=1;p=L;while(p&&j<i){p=p->next;j++;}if(p==NULL||j>i)printf("插入位置不正确\n");else{s=(LNode *)malloc(sizeof(LNode));s->data=x;s->next=p->next;p->next=s;printf("%d 已插入到链表中\n",x);}}void LinkedListDel(LinkedList L,int i) {LinkedList p,q;int j;j=1;p=L;while(p->next&&j<i){p=p->next;j++;}if(p->next==NULL)printf("删除位置不正确\n");else{q=p->next;p->next=q->next;free(q);printf("第%d 个元素已从链表中删除\n",i);}}LinkedList LinkedListCreat(){LinkedList L=LinkedListInit(),p,r;ElemType x;r=L;printf("请依次输入链表中的元素,输入-1结束\n"); scanf("%d",&x);while(x!=flag){p=(LinkedList)malloc(sizeof(LNode));p->data=x;r->next=p;r=p;scanf("%d",&x);}r->next=NULL;return L;}int scan(){int d;printf("请选择要进行的操作\n");printf("-------------------------------------------------------\n"); printf("1.初始化 2.清空 3.求链表长度 4.检查链表是否为空\n"); printf("-------------------------------------------------------\n"); printf("5.遍历链表 6.从链表中查找元素\n");printf("-------------------------------------------------------\n"); printf("7.从链表中查找与给定元素值相同的元素在顺序表中的位置\n"); printf("-------------------------------------------------------\n"); printf("8.向链表中插入元素 9.从链表中删除元素 10创建线性表\n"); printf("-------------------------------------------------------\n"); printf("其他键退出。

实验报告1

实验报告1

实验一创建链表和链表操作一、实验目的掌握线性表的基本操作:插入、删除、查找、以及线性表合并等操作在顺序存储结构和链式存储结构上的实现。

二、实验内容:1. 创建单链表2.在链表上进行插入、删除操作;3.设计一个程序,用两个单链表分别表示两个集合,并求出这两个集合的并集。

四、测试数据:∙(3,9,5,6,11,8);在5之前插入4,7,并删除11∙求集合{1,12,8,6,4,9}和{2,5,12,7,4}的并集五、概要设计:本操作应完成如下功能:(1)创建链表说明:分配一定的空间,根据给定的链表长度输入值,创建链表。

(2)合并链表说明:将两个链表合并为一个链表只需修改链表头、尾指针即可实现。

(3)在链表中插入值说明:将给定的值插入到指定位置上,只需修改插入位置的前后结点的指针即可。

(4)在链表中删除值说明:将指定位置的值删除,只需修改删除位置的前后结点的指针即可。

六、详细设计:源代码:#include<stdio.h>#include<conio.h>#include<stdlib.h>#include<iostream.h>#define OK 1#define ERROR 0#define OVERFLOW 0//线性链表的存储结构,一个结点typedef struct LNode{int data; // 数据域struct LNode *next; // 指针域}LNode,*LinkList; //结点结构类型和指向结点的指针类型int TraverseList_L(LinkList L) //遍历单链表{LinkList p;p=L->next;while(p){printf("-->%d",p->data);p=p->next;}return OK;}//尾插法创建的带头结点的单链表。

void CreateList_L(LinkList &L,int &n){L=(LinkList)malloc(sizeof (LNode));//建立一个空链表L。

链表实验报告总结

链表实验报告总结

篇一:链表实验报告数据结构实验报告姓名;方钢学号:20105567 专业:电子商务班级: 10-1班指导教师:实验时间:实验地点:新区实验楼4楼(实验题目)单链表实验1.实验内容和要求1.1实验要求①本次实验中的链表结构均为带头结点的单链表;②链表结构定义,算法实现放入库文件“linklist.h”;运算和变量命名直观易懂,并有相应的注释1.2实验内容&lt;1&gt;求链表中第i个结点的指针(函数),若不存在,则返回null。

&lt;2&gt;在第i 个结点前插入值为x的结点。

&lt;3&gt;删除链表中第i个元素结点。

&lt;4&gt;在一个递增有序的链表l中插入一个值为x的元素,并保持其递增有序特性。

&lt;5&gt;将单链表l中的奇数项和偶数项结点分解开(元素值为奇数、偶数),申请2个头结点,把分开的奇数项和偶数项分别链接到这2个头结点上,然后再将这两个新链表同时输出在屏幕上,并保留原链表的显示结果,以便对照求解结果。

&lt;6&gt;求两个递增有序链表l1和l2中的公共元素,并以同样方式连接成链表l3。

2.实验目的2.1 理解线性表的链式存储结构。

2.2熟练掌握单链表结构及有关算法的设计。

2.3根据具体问题的需要,设计出合理的表示数据的链表结构,并设计相关算法。

3.数据结构设计&lt;1&gt;求链表中第i个结点的指针(函数),若不存在,则返回null。

实验代码node *l,*p;int i; createnode(*&amp;l); //尾插法创建一个链表,cout&lt;&lt;链表包含:&lt;&lt;endl;p=l-&gt;next; while(p){cout&lt;&lt;p-&gt;data&lt;&lt;,;p=p-&gt;next; }cout&lt;&lt;endl;cout&lt;&lt;请输入待求元素序号:;cin&gt;&gt;i; locatenode (l, i, &amp;p );if(p!=null)cout&lt;&lt;序号&lt;&lt;i&lt;&lt;的元素值为:&lt;&lt;p-&gt;data&lt;&lt;endl;elsecout&lt;&lt;null&lt;&lt;endl;destroylist(l); //销毁链表,释放heap内存_crtdumpmemoryleaks(); //debug 模式下检测是否内存泄漏测试截图&lt;2&gt;在第i个结点前插入值为x的结点。

链表实验报告1

链表实验报告1

1、熟练掌握线性表的基本操作在两种存储结构上的实现。

2、会用线性链表解决简单的实际问题。

该程序的功能是实现单链表的定义和操作。

该程序包括单链表结构类型以及对单链表操作的具体的函数定义和主函数。

其中,程序中的单链表(带头结点)结点为结构类型,结点值为整型。

单链表操作的选择以菜单形式浮现,如下所示:please input the operation:1.初始化2.清空3.求链表长度4.检查链表是否为空5.检查链表是否为满 6.遍历链表(设为输出元素) 7.从链表中查找元素 8.从链表中查找与给定元素值相同的元素在表中的位置9.向链表中插入元素 10. 从链表中删除元素其他键退出。

设编号为 1,2,3,……, n 的 n(n>0)个人按顺时针方向围坐一圈,每一个人持有一个正整数密码。

开始时任选一个正整数做为报数上限 m,从第一个人开始顺时针方向自 1 起顺序报数,报到 m 时住手报数,报 m 的人出列,将他的密码作为新的m 值,从他的下一个人开始重新从 1 报数。

如此下去,直到所有人全部出列为止。

令n 最大值取 30。

要求设计一个程序摹拟此过程,求出出列编号序列。

struct node //结点结构{int number; /* 人的序号*/int cipher; /* 密码*/struct node *next; /* 指向下一个节点的指针*/};/* 定义 DataType 为 int 类型 */typedef int DataType;/* 单链表的结点类型 */typedef struct LNode{ DataType data;struct LNode *next;}LNode,*LinkedList;LinkedList LinkedListInit(){ //函数功能:对链表进行初始化参数:链表(linklist L) 成功初始化返回 1, 否则返回 0 }void LinkedListClear(LinkedList &L){//函数功能:把链表清空参数:链表(linklist L) 成功清空链表返回 1 }int LinkedListEmpty(LinkedList L){ //函数功能:判断链表是否为空参数:链表(linklist L) 链表为空时返回 0, 不为空返回 1 }void LinkedListTraverse(LinkedList L){ //函数功能:遍历链表,输出每一个节点的 elem 值参数:链表(linklist L) 通过循环逐个输出节点的 elem 值 }int LinkedListLength(LinkedList L){ //函数功能:返回链表的长度参数:链表(linklistL) 函数返回链表的长度 }LinkedList LinkedListGet(LinkedList L,int i){ //函数功能: 从链表中查找有无给定元素参数;链表(linklist L),给定元素 (int i) 如果链表中有给定元素(i)则返回 1,否则返回 0 }LinkedList LinkedListLocate(LinkedList L, DataType x){//函数功能: 从链表中查找给定元素的位置参数;链表(linklist L),给定元素(int i) 如果链表中有给定元素 i 则返回元素的位置, 没有则返回 0 }void LinkedListInsert(LinkedList &L,int i,DataType x)}void LinkedListDel(LinkedList &L,DataType x)i 个结点 }(二)、zhujiemian();cin>>a;do{switch(a){case 1:if(init(L)==1)cout<<"成功初始化! "<<endl;elsecout<<"初始化失败! "<<endl;break;case 2:if(makeempty(L)==1)cout<<"链表已清空! "<<endl;elsecout<<"链表清空失败! "<<endl;break;case 3:b=getlength(L);cout<<"链表的长度为: "<<b<<endl;break;case 4:if(isempty(L)==1)cout<<"链表不为空! "<<endl;elsecout<<"链表为空! "<<endl;break;case 5:if(isfull(L)==1)cout<<"链表不满! "<<endl;elsecout<<"链表已满! "<<endl;break;case 6:show(L);break;case 7:cout<<"输入您要查找的元素: ";cin>>b;if(find(L,b)==1)cout<<"链表中有该元素"<<b<<endl;elsecout<<"链表中没有您要查找的元素"<<b<<endl;break;case 8:cout<<"您要查找的元素为: "<<endl;cin>>b;if(location(L,b)==0)cout<<"没有您要查找的元素"<<b<<endl;elsecout<<"您查找的元素 "<<b<<"在第"<<location(L,b)<<"个位置。

数据结构顺序表链表试验报告

数据结构顺序表链表试验报告

数据结构顺序表链表试验报告数据结构试验报告一、引言数据结构是计算机科学中非常重要的一个概念,它用于组织和存储数据,以便能够高效地进行检索和操作。

顺序表和链表是两种常见的数据结构,它们在实际应用中都有各自的优势和局限性。

本报告将对顺序表和链表进行试验比较,以评估它们在不同场景下的性能和适合性。

二、实验目的本次试验的目的是比较顺序表和链表在插入、删除和查找操作上的性能差异,并分析其时间复杂度和空间复杂度。

通过实验结果,可以对不同场景下选择合适的数据结构提供参考。

三、实验内容1. 顺序表实验a. 创建一个包含100个元素的顺序表;b. 在表尾插入一个元素;c. 在表头插入一个元素;d. 在表的中间位置插入一个元素;e. 删除表尾的一个元素;f. 删除表头的一个元素;g. 删除表的中间位置的一个元素;h. 查找一个元素;i. 遍历整个顺序表。

2. 链表实验a. 创建一个包含100个节点的链表;b. 在链表尾部插入一个节点;c. 在链表头部插入一个节点;d. 在链表的中间位置插入一个节点;e. 删除链表尾部的一个节点;f. 删除链表头部的一个节点;g. 删除链表的中间位置的一个节点;h. 查找一个节点;i. 遍历整个链表。

四、实验结果与分析1. 顺序表实验结果a. 在表尾插入一个元素的平均时间为0.1ms;b. 在表头插入一个元素的平均时间为0.2ms;c. 在表的中间位置插入一个元素的平均时间为0.5ms;d. 删除表尾的一个元素的平均时间为0.1ms;e. 删除表头的一个元素的平均时间为0.2ms;f. 删除表的中间位置的一个元素的平均时间为0.5ms;g. 查找一个元素的平均时间为1ms;h. 遍历整个顺序表的平均时间为10ms。

2. 链表实验结果a. 在链表尾部插入一个节点的平均时间为0.2ms;b. 在链表头部插入一个节点的平均时间为0.1ms;c. 在链表的中间位置插入一个节点的平均时间为0.5ms;d. 删除链表尾部的一个节点的平均时间为0.2ms;e. 删除链表头部的一个节点的平均时间为0.1ms;f. 删除链表的中间位置的一个节点的平均时间为0.5ms;g. 查找一个节点的平均时间为2ms;h. 遍历整个链表的平均时间为5ms。

数据结构实验二链表的实现和应用

数据结构实验二链表的实现和应用
⑵基于所设计的存储结构实现线性表的基本操作;
⑶编写一个主程序对所实现的线性表进行测试;
⑷线性表的应用:①设线性表L1和L2分别代表集合A和B,试设计算法求A和B的并集C,并用线性表L3代表集合C;②设线性表L1和L2中的数据元素为整数,且均已按值非递减有序排列,试设计算法对L1和L2进行合并,用线性表L3保存合并结果,要求L3中的数据元素也按值非递减有序排列。(选做)
switch(compare(qa,qb))
{
case 1:
{
qc->coef=qa->coef;
qc->expn=qa->expn;
qa=qa->next;break;
}
case 0:
{
qc->coef=qa->coef+qb->coef;
qc->expn=qa->expn;
qa=qa->next;
DestroyPolyn(pc);
pd=SubtractPolyn(pa,pb);
printf("多项式a-b:");PrintPolyn(pd);
DestroyPolyn(pd);
pf=MultiplyPolyn(pa,pb);
printf("多项式a*b:");PrintPolyn(pf);
DestroyPolyn(pf);
Polyn qa=pa->next;
Polyn qb=pb->next;
hf=(Polyn)malloc(sizeof(struct Polynomial)); //建立头结点
hf->next=NULL;
for(;qa;qa=qa->next)

链表合并实验报告

链表合并实验报告

《数据结构》实验报告◎实验题目: 实现两个有序循环链表的合并◎实验目的:掌握链表的建立、遍历以及数据的插入,加深对链表的理解。

◎实验内容:设A与B分别为两个带有头结点的有序循环链表(所谓有序是指链接点按数据域值大小链接,本题不妨设按数据域值从小到大排列),list1和list2分别为指向两个链表的头指针。

请写出将这两个链表合并为一个带头结点的有序循环链表的算法。

一、需求分析1、输入:该实验需要建立循环链表,以及读入数据,输出数据,并实现合并。

该链表输入为整数形式,输入值的范围为整个整数域。

2、输出:而输出的形式为整数。

3、程序功能:该程序实现了循环链表的建立,读入和输出数据,主要功能为实现了两个有序循环链表的合并。

4、程序执行命令:(1)创建链表(2)输入数据(3)合并链表(4)输出合并后链表(5)结束5、测试数据:假设第一个链表的输入数据个数为5,其分别为1、3、5、7、9,第二个链表的输入数据个数为3个,其分别为7、9、10,则合并后应输出结果:1 3 5 7 7 9 9 10。

二概要设计为了实现上述操作,应以单向循环链表为存储结构。

本程序的主程序的流程为:本程序的调用函数有创建链表函数create,输出函数displist,以及合并函数add三个模块,其中这三个函数都在主函数中被调用,三个调用函数为平行关系。

三详细设计1.元素类型,结点类型和指针类型:typedef int elemtype;typedef struct lnode{elemtype data;struct lnode *next;}linklist;linklist *s,*r;linklist *list1,*list2,*list3; 2.每个模块的分析:(1)主程序模块:main(){linklist *l1,*l2,*l3;int i,x,n;printf("请输入要建立的链表节点个数:\n");scanf("%d",&n);create(l1,n);displist(l1);getch();printf("请输入要建立的链表节点个数:\n");scanf("%d",&n);create(l2,n);displist(l2);getch();add(l1,l2,l3);printf("合并后链表:\n");displist(l3);getch();return 0;}(2)链表创建并输入数据create(linklist *&l,int n){linklist *s,*r;int i;l=(linklist *)malloc(sizeof(linklist));l->next=NULL;r=l;for(i=0;i<n;i++){s=(linklist *)malloc(sizeof(linklist));printf("\n请输入新节点数据:\n");scanf("%d",&s->data) ;r->next=s;r=s;}r->next=l->next;}(3)数据输出displist(linklist *l){linklist *p=l->next;do{printf("%5d",p->data);p=p->next;}while(p!=l->next);printf("\n");}(4)链表合并add(linklist *l1,linklist *l2,linklist *&l3){linklist *list1,*list2,*list3;l3=(linklist *)malloc(sizeof(linklist));l3->next=NULL;list3=l3;list1=l1->next;list2=l2->next;do{if(list1->data<=list2->data){list3->next=list1;list1=list1->next;list3=list3->next;}else{list3->next=list2;list2=list2->next;list3=list3->next;}} while(list3->next!=l1->next&&list3->next!=l2->next);if(list3->next==l2->next)while(list3->next!=l1->next){list3->next=list1;list3=list1;list1=list1->next;}elsewhile(list3->next!=l2->next){list3->next=list2;list3=list2;list2=list2->next;}list3->next=l3->next;}(5)函数调用关系图main()create()displist()add()diaplist()3.完整的程序:(见源文件).四使用说明、测试分析及结果1.程序使用说明:(1)本程序的运行环境为VC6.0。

实验2 链表的实现-本次实验需要填写报告

实验2 链表的实现-本次实验需要填写报告
4. 实验重点和难点
(1) 重点:单链表的数据元素添加和删除算法设计。 (2) 难点:双链表的数据元素添加和删除算法设计。
5. 实验结果与分析
(必须写这部分) 应用文字、表格、图形等将数据表示出来
6. 实验总结与体会
必须写这部分
7. 部分代码指导
1. 利用 C 语言结构体类型定义单链表如下:
typedef struct node{ ElemType data; struct node *next;
p=p->next; ++j; } if(!p || j>i) return False; //第 i 个元素不存在 e.sn=p->data.sn; strcpy(,p->); e.score=p->data.score; //查找成功,用 e 取 得第 i 个元素值 return True; }
3. 实验内容
1. 链式线性表的建立、插入、删除及查找。 2. 具体要求:
(1)建立含 n 个学生记录结点的链表; (2)可以在链表的任意合法位置 i 插入一个学生结点; (3)可以删除链表在任意合法位置 i 上的一个学生结点; (4)可以查找第 i 个结点的学生情况; (6)可以查找结点值为 e 的学生记录在链表中的第一个位置 i; (7)可以输出该链表中每个学生的情况; 3. 测试: 建立如下含 3 个学生记录的链表 L={(101,zhangsan,98.5),(102,lisi,90.0),(103,wangwu,89.7)} 进行测试 (1) 在第 1、第 2 位置插入两个学生记录; (2) 删除第 3 个位置的学生记录,并返回所删除学生的情况; (3) 删除值为(103,wangyuan,89.7)和(103,wangwu,89.7)的学生; (4) 查找第 1,2,3 位置的学生; (5) 查找值为(101,zhangsan,98.5),(102,lisi,90.0)的学生结点位置; (6) 遍历链表表,输入所有学生的情况。

实验链表实验报告

实验链表实验报告

实验链表实验报告一、实验目的本次实验的主要目的是深入理解链表这种数据结构的概念、特点和操作方法,并通过实际编程实现来提高对链表的应用能力。

二、实验环境本次实验使用的编程语言为C++,开发工具为Visual Studio 2019。

三、实验原理链表是一种常见的数据结构,它由一系列节点组成,每个节点包含数据和指向下一个节点的指针。

与数组不同,链表的内存分配是动态的,并且可以方便地进行插入和删除操作,而不需要移动大量的元素。

链表分为单向链表、双向链表和循环链表等多种类型。

在本次实验中,我们主要实现单向链表。

单向链表的节点结构通常包含数据域和指针域。

数据域用于存储节点的数据,指针域用于指向下一个节点。

通过遍历链表的指针,可以访问链表中的每个节点。

四、实验内容1、链表节点的定义```cppstruct ListNode {int data;ListNode next;ListNode(int x) : data(x), next(NULL) {}};```2、链表的创建```cppListNode createList(){ListNode head = NULL;ListNode tail = NULL;int num;cout <<"请输入链表中的数字(输入-1 结束):";cin >> num;while (num!=-1) {ListNode newNode = new ListNode(num);if (head == NULL) {head = newNode;tail = newNode;} else {tail>next = newNode;tail = newNode;}cin >> num;}return head;}```3、链表的遍历```cppvoid traverseList(ListNode head) {ListNode curr = head;while (curr!= NULL) {cout << curr>data <<"";curr = curr>next;}cout << endl;}```4、链表的插入```cppvoid insertNode(ListNode& head, int position, int value) {ListNode newNode = new ListNode(value);if (position == 0) {newNode>next = head;head = newNode;return;}ListNode curr = head;int count = 0;while (curr!= NULL && count < position 1) {curr = curr>next;count++;}if (curr == NULL) {cout <<"插入位置超出链表长度" << endl; return;}newNode>next = curr>next;curr>next = newNode;}```5、链表的删除```cppvoid deleteNode(ListNode& head, int position) {if (head == NULL) {cout <<"链表为空,无法删除" << endl; return;}if (position == 0) {ListNode temp = head;head = head>next;delete temp;return;}ListNode curr = head;ListNode prev = NULL;int count = 0;while (curr!= NULL && count < position) {prev = curr;curr = curr>next;count++;}if (curr == NULL) {cout <<"删除位置超出链表长度" << endl; return;}prev>next = curr>next;delete curr;}```五、实验结果通过对上述链表操作函数的调用,我们成功地创建、遍历、插入和删除了链表中的节点。

链表的合并 实验报告

链表的合并 实验报告

链表的合并实验报告一、实验目的本次实验的主要目的是深入理解链表的数据结构,并通过编程实现链表的合并操作,以提高对数据结构和算法的理解与应用能力。

二、实验环境本次实验使用的编程语言为 Python,开发环境为 PyCharm。

三、实验原理链表是一种常见的数据结构,它由一系列节点组成,每个节点包含数据和指向下一个节点的指针。

在合并两个链表时,需要比较两个链表节点的值,将较小的值依次添加到新的合并链表中。

当其中一个链表遍历完后,将另一个链表剩余的节点直接添加到合并链表的末尾。

四、实验步骤1、定义链表节点类```pythonclass ListNode:def __init__(self, val=0, next=None):selfval = val```2、合并链表函数```pythondef mergeTwoLists(l1, l2):dummy = ListNode(0) curr = dummywhile l1 and l2:if l1val < l2val:currnext = l1l1 = l1nextelse:currnext = l2l2 = l2nextcurr = currnextif l1:currnext = l1if l2:return dummynext```3、测试函数```pythondef test_mergeTwoLists():构建测试链表 l1l1 = ListNode(1)l1next = ListNode(2)l1nextnext = ListNode(4)构建测试链表 l2l2 = ListNode(1)l2next = ListNode(3)l2nextnext = ListNode(4)merged_list = mergeTwoLists(l1, l2)打印合并后的链表while merged_list:print(merged_listval, end="")merged_list = merged_listnext```五、实验结果与分析运行测试函数,得到合并后的链表输出为:1 1 2 3 4 4 。

链表实现集合实验报告详解

链表实现集合实验报告详解

链表实现实验报告班级:计算机2班学号:201511407141 姓名:杨舟1.需求分析 (2)1.1输入的形式和输入值的范围 (2)1.2输出的形式 (2)1.3程序的功能 (2)1.4数据测试 (2)2.概要设计 (3)2.1主程序流程 (3)2.2数据定义类型 (5)2.3函数调用 (5)3.详细设计 (6)3.1函数设计 (6)3.1.1 函数申明 (6)3.1.2程序运行过程中的常量 (6)3.1.3 结构体 (6)3.1.4 int LinkLocate_L (Linklist *L, int x) (7)3.1.5 int ListInsert_L( Linklist *L, int i, ElemType e ) (7)3.1.6 status INlist( Linklist *L, int i, ElemType *e ) (8)3.1.7 void CreateList_L(Linklist *L, int n) (9)3.1.8 void HHHGG( Linklist *L ) (10)3.1.9 void BJ( Linklist *La, Linklist *Lb ) (10)3.1.10 void JJ( Linklist *La, Linklist *Lb ) (11)3.1.11 void CJ( Linklist *La, Linklist *Lb ) (12)3.1.12 void PKJ( Linklist *La ) (13)4 调试分析 (14)4.1 调试过程中遇到的问题及分析 (14)4.2 问题的解决办法 (14)4.3 总结回顾 (14)4.4 算法的时空分析 (15)5测试结果 (16)5.1集合的输入 (16)5.2集合的插入 (16)5.3集合的删除 (16)5.4集合的查找 (17)5.5集合的合集 (17)5.6集合的交集 (18)5.7集合的差集 (18)5.8集合的判空 (19)6源代码.......................................................................................................... 错误!未定义书签。

数据结构实验报告链表

数据结构实验报告链表

数据结构实验报告链表
《数据结构实验报告:链表》
在计算机科学领域,数据结构是一门重要的课程,它对于计算机程序的设计和性能有着至关重要的作用。

其中,链表是一种常见的数据结构,它在实际应用中有着广泛的用途。

在本次实验中,我们将深入研究链表这一数据结构,并通过实验来验证其性能和应用。

首先,我们需要了解链表的基本概念。

链表是由一系列节点组成的数据结构,每个节点包含数据和指向下一个节点的指针。

相比于数组,链表具有动态的内存分配和插入/删除操作的优势,但在访问元素时性能稍逊色。

因此,链表适用于需要频繁插入/删除操作的场景。

在本次实验中,我们将实现一个简单的链表数据结构,并进行一系列的操作。

首先,我们将实现链表的创建、插入、删除和遍历等基本操作,并通过实验验证其正确性和性能。

其次,我们将对比链表和数组在不同场景下的性能差异,以便更好地理解链表的适用场景和特点。

通过本次实验,我们将深入了解链表这一数据结构的原理和应用,掌握其基本操作和性能特点,为今后的程序设计和优化提供重要的参考。

同时,我们也将通过实验数据和分析来验证链表的优势和不足,为选择合适的数据结构提供依据。

希望本次实验能够为大家对数据结构和算法有更深入的理解和掌握提供帮助。

通过本次实验,我们对链表这一数据结构有了更深入的了解,并通过实验验证了其性能和应用。

链表作为一种常见的数据结构,在实际应用中有着广泛的用途,掌握其原理和操作对于程序设计和性能优化至关重要。

希望本次实验能够
为大家对数据结构和算法有更深入的理解和掌握提供帮助。

链表-实验报告

链表-实验报告

实验2 链表实验概述:一、实验目的本次实习的主要目的是为了使学生熟练掌握链表的基本操作以及在链式存储结构上的实现,包括创建、插入、删除、查找、以及合并等操作。

二、实验要求掌握链表存储方式,熟悉链式存储结构。

三、实验步骤用链表结构实现对多项式初始化、创建、插入、删除等运算。

步骤:输入第一个多项式:7x+2x3输入第二个多项式:8x+9x5输出第一个多项式输出第二个多项式输出两个多项式相加的结果:15x+2x3+9x5实验结果如图:四、实验环境(使用的软件和设备)(1)实习器材:多媒体计算机。

(2)实习地点:校内多媒体机房。

(3)实习软件: Win-TC实验内容:【实验过程】(实验步骤、记录、数据、分析)实验过程(提示)输入第一个多项式:7x+2x3输入第二个多项式:8x+9x5输出第一个多项式输出第二个多项式输出两个多项式相加的结果:15x+2x3+9x5【结果实验记录】(图形或图像)1.说明掌握情况#include<stdio.h>#include<stdlib.h>typedef struct{int sat1,sat2,sat3,sat4;}ElemType;typedef struct LNode{ElemType data;struct LNode *next;}LNode,*LinkList;LinkList InitList(){ LinkList L;L=(LinkList)malloc(sizeof(LNode)); L->next=NULL;return(L);}void InsLNode(LinkList L,ElemType x){ LinkList s,p;s=(LinkList)malloc(sizeof(LNode));s->data=x;p=L;while(p->next)p=p->next;s->next=NULL;p->next=s;}void AddPolyn(LinkList La,LinkList Lb){int sum;int a,b;LinkList pa,pb;pa=La->next;pb=Lb->next;a=pa->data.sat1;b=pb->data.sat1;sum=a+b;printf(" %dx%d exp",sum,pa->data.sat2);printf("+");printf(" %dx%d exp+",pa->data.sat3,pa->data.sat4); printf(" %dx%d exp\n",pb->data.sat3,pb->data.sat4);}void Print(LinkList L){ LinkList p;p=L->next;printf(" %dx%d exp",p->data.sat1,p->data.sat2); printf("+");printf(" %dx%d exp",p->data.sat3,p->data.sat4);}main() {LinkList La,Lb;ElemType c,b;int a,i;La=InitList();Lb= InitList();printf("Please input polynomial La:\n");scanf("%d %d",&c.sat1,&c.sat2);scanf("%d %d",&c.sat3,&c.sat4);InsLNode(La,c);printf("Please input polynomial Lb:\n");scanf("%d %d",&b.sat1,&b.sat2);scanf("%d %d",&b.sat3,&b.sat4);InsLNode(Lb,b);printf("polynomial La:");printf("\n");Print(La);printf("\n");printf("polynomial Lb:");printf("\n");Print(Lb);printf("\n");printf("La+Lb:");printf("\n");AddPolyn(La,Lb);printf("\n");getch();}2.裁图说明实验结果【心得体会、问题和建议】成绩:指导教师签名批阅日期:。

用单链表实现集合的操作

用单链表实现集合的操作
1、若 p->data>q->data,说明还未找到,需在表 B 中继续查找; 2、若 p->data<q->data,说明表 B 中无此值,处理表 A 中下一结点; 3、若 p->data=q->data,,说明找到了公共元素。 (3)求集合 A 和 B 的并集,集合 A∪B 中包含所有或属于集合 A 或属于集合 B 的元素。因此,对单链表 B 中的每一个元素 x,在单链表 A 中进行查找,若存在 和 x 不同的元素,则将该结点出入到单链表 A 中。 (4)求集合 A 和 B 的差集。根基集合的运算规则,集合 A-B 中包含所有属于集 合 A 而不属于集合 B 的元素。因此,对单链表 B 中的每个元素 x 在单链表 A 中进 行查找,若存在和 x 相同的结点,则将该结点从链表 A 中删除。 在主函数中,首先建立两个有序单链表表示集合 A 和 B,然后依次调用相应函数 实现集合的判等、交、并和差等运算,并输出运算结果。
p = first; while(p) {
//工作指针 p 初始化 //释放单链表的每一个结点的存储空间
q = p;
//暂存被释放结点
p = p->next; //工作指针 p 指向被释放结点的下一个结点,使单链表不断开
delete q;
}
}
template<class T> //判断是否相等 int LinkList<T>::Ifdeng(Node<T> *A,Node<T> *B) {
//建立有 n 个元素的单链表
~LinkList(); int Ifdeng(Node<T> *A, Node<T> *B); void Interest(Node<T> *A, Node<T> *B); void Sum(Node<T> *A, Node<T> *B); void Subtraction(Node<T> *A, Node<T> *B);

实验二 链表求集合的并集

实验二 链表求集合的并集

实验二单链表求集合的并集一.实验目的1.熟悉数据结构的设计过程,并实现的数据结构链表的设计。

2.用设计的链表实现求集合的并集。

3.设计单链表、单向循环链表、双向链表和双向循环链表。

二、实验内容1.设计带头结点的单链表:设计头文件LinkList.h,其内容如下:typedef struct node{elemtype data;node *next;}Lnode,*LinkList;void InitList(LinkList &L){L=new Lnode;L->next=NULL;}Lnode *Locate(LinkList L,elemtype e){}void Insert(LinkList L,int i,elemtype e){}void Delete(LinkList L,int i){}void create(LinkList &L,elemtype *a,int n){InitList(L);for(int i=n-1;i>=0;i--){Lnode *p;p=new Lnode;p->data=a[i];p->next=L->next;L->next=p;}}void display(LinkList L){Lnode *p;p=L->next;while(p){cout<<p->data<<" ";p=p->next;}cout<<endl;}2.利用单链表求集合的并集:设计测试文件test.cpp,其内容如下:#include "iostream.h"#include "stdio.h"typedef int elemtype;#include "LinkList.h"void main(){LinkList L;}3.思考:1.带头结点的单向循环链表如何实现。

实现集合实验报告

实现集合实验报告

实验名称:实现集合一、实验目的1. 掌握集合的基本概念和运算方法。

2. 熟悉Python中集合的数据结构及其操作。

3. 提高编程能力和数据结构应用能力。

二、实验环境1. 操作系统:Windows 102. 编程语言:Python3.73. 开发工具:PyCharm三、实验内容1. 创建集合2. 集合的运算3. 集合的遍历四、实验步骤1. 创建集合在Python中,集合是一种无序、不重复的数据结构,使用大括号{}或set()函数可以创建集合。

(1)使用大括号创建集合```python# 创建一个集合,包含整数1、2、3set1 = {1, 2, 3}print(set1)```(2)使用set()函数创建集合```python# 创建一个集合,包含字符串"apple"、"banana"、"orange" set2 = set(["apple", "banana", "orange"])print(set2)```2. 集合的运算集合支持多种运算,如并集、交集、差集、对称差集等。

(1)并集并集是指包含两个集合中所有元素的集合。

```python# 创建两个集合set3 = {1, 2, 3}set4 = {3, 4, 5}# 计算并集union_set = set3 | set4print(union_set)```(2)交集交集是指同时包含在两个集合中的元素组成的集合。

```python# 计算交集intersection_set = set3 & set4print(intersection_set)```(3)差集差集是指包含在第一个集合中,但不包含在第二个集合中的元素组成的集合。

```python# 计算差集difference_set = set3 - set4print(difference_set)```(4)对称差集对称差集是指只包含在两个集合中,且不包含在两个集合交集中的元素组成的集合。

  1. 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
3.1.2
#define ElemType int
#define status int
3.1.3
//结构体
typedef struct Node
{
ElemType data;
struct Node *next;
}Node;
typedef struct Node* Linklist;
3.1.4 int LinkLocate_L (Linklist *L, int x)
//赋值
p = *L;
//循环找到满足条件的插入位置
while( p && j < i - 1 ){
p = p->next;
++j;
}
//如果不满足条件返回0
if( !p || j > i - 1 ){
return 0;
}
//将删除的位置以后的元素往前移一位
q = p->next;
p->next = q->next;
2.3
/*************************************
功能:查找集合中的元素
参数:需要查找的元素、指针头地址
返回值:无
*************************************/
int LinkLocate_L (Linklist *L, int x)
/*****************************************
功能:向集合中插入元素
参数:头地址、插入位置、插入元素
参数:1或0
*****************************************/
int ListInsert_L( Linklist *L, int i, ElemType e )
/********************************************
*e = q->data;
free(q);
return 1;
}
3.1.7 void CreateList_L(Linklist *L, int n)
/*****************************************
功能:创建链表集合
参数:集合长度
返回值:无
*****************************************/
功能:删除元素
参数:头地址、插入位置
返回值:1或0
********************************************/
status INlist( Linklist *L, int i, ElemType *e ){
Linklist p;//指针
Linklist q;//指针
int j = 0;//中间变量
for ( i=n; i > 0; --i ) {
p=(Linklist)malloc(sizeof(Node));
scanf("%d",&p->data);
p->next = (*L)->next;
(*L)->next=p;
}
//输出集合元素
printf( "\n" );
printf( "集合的元素:" );
q=first;
while (q && q->data !=x)
q=q->next;
if (!q) {
q=(Linklist)malloc(sizeof(Node));//申请节点内存将Lb中的元素放到La中
q->data = x;
q->next = (*La)->next;
for ( i=n; i > 0; --i ){
printf( "%d", p->data );
p = p->next;
}
}
3.1.8 void HHHGG( Linklist *L )
/**********************************
功能:输出集合的元素
参数:头结点地址
返回值:无
//申请内存
Linklist *La = (Linklist*)malloc(sizeof(Linklist));
Linklist *Lb = (Linklist*)malloc(sizeof(Linklist));
ElemType *e = (ElemType*)malloc(sizeof(ElemType));
/*************************************
功能:查找集合中的元素
参数:需要查找的元素、指针头地址
返回值:无
*************************************/
int LinkLocate_L (Linklist *L, int x)
{
int i; //中间变量
printf ("元素位置:i=%d\n",i);
}
}
3.1.5 int ListInsert_L( Linklist *L, int i, ElemType e )
/*****************************************
功能:向集合中插入元素
参数:头地址、插入位置、插入元素
功能:创建链表集合
参数:集合长度
返回值:无
*****************************************/
void CreateList_L(Linklist *L, int n)
/**********************************
功能:输出集合的元素
参数:头结点地址
ListInsert_L( Lb,1,7 );
printf( "插入后的结果:" );
HHHGG(Lb);
//交集
JJ( La, Lb );
//差集
CJ( La, Lb );
//判空集
PKJ( La );
//并集
BJ( La, Lb );
}
2.2
#define ElemType int
#define status int
//输入集合的元素
CreateList_L( Lb, n1 );
//查找
printf( "\n" );
printf( "查找结果:" );
LinkLocate_L( Lb, 3 );
//删除并输出
INlist( Lb,1,*e );
printf( "删除后的结果:" );
HHHGG(Lb);
//插入并输出
void JJ( Linklist *La, Linklist *Lb )
/****************************************
功能:集合的差集
参数:两个集合的头地址
返回值:无
****************************************/
void CJ( Linklist *La, Linklist *Lb )
返回值:无*******来自**************************/
void HHHGG( Linklist *L )
/******************************************
功能:集合的并集
参数:两个集合的头地址
返回值:无
******************************************/
线性表实现实验报告
班级:计算机2班学号:姓名:
1.
1.1
输入形式:整数
输入范围:整数集合长度不能超过1000
1.2
用空格分开的一列数
1.3
据课上给出的线性表ADT定义,实现集合的(初始化、插入、删除、查找、交集、并集、差集、判空集)
1.4
线性表长度:6
元素:4 5 6 7 9 10
2.
2.1
void main(){
//删除并输出
INlist( La,1,*e );
printf( "删除后的结果:" );
HHHGG(La);
//插入并输出
ListInsert_L( La,1,8 );
printf( "插入后的结果:" );
HHHGG(La);
//集合的长度赋值
printf( "\n请输入集合的长度:" );
scanf( "%d", &n1 );
//循环找到满足条件的插入位置
while( p && j < i - 1 ){
p = p->next;
++j;
}
//如果不满足条件返回0
if( !p || j > i - 1 ){
return 0;
}
//申请插入位置的内存
s = ( (Linklist) malloc( sizeof(Node) ) );
**********************************/
void HHHGG( Linklist *L ){
Linklist p;//指针
//赋值
p = *L;
p = p->next;
//循环输出
相关文档
最新文档