《数据结构》实验报告 设计循环单链表

合集下载

数据结构实验报告--单链表

数据结构实验报告--单链表

数据结构实验报告--单链表数据结构实验报告--单链表1.引言1.1 研究目的本实验旨在通过实践的方式,深入了解单链表的数据结构以及相关操作,提升对数据结构的理解和应用能力。

1.2 实验内容本实验主要包括以下几个方面的内容:●单链表的基本定义和实现●单链表的插入、删除、遍历操作●单链表的逆置操作●单链表的查找和修改操作2.理论基础2.1 单链表的定义单链表是一种常见的线性数据结构,它由一系列的节点组成,每个节点包含数据和指向下一个节点的指针。

2.2 单链表的基本操作①单链表的插入操作在单链表中,可以通过插入操作在指定位置插入一个新节点,该操作主要包括以下步骤:●创建一个新的节点,并为其赋值●将新节点的next指针指向插入位置的后一个节点●将插入位置的前一个节点的next指针指向新节点②单链表的删除操作在单链表中,可以通过删除操作删除指定位置的节点,该操作主要包括以下步骤:●将删除位置的前一个节点的next指针指向删除位置的后一个节点●释放删除节点的内存③单链表的遍历操作单链表的遍历操作主要是依次访问链表中的每一个节点,并执行相应的操作。

④单链表的逆置操作单链表的逆置操作可以将一个单链表中的节点顺序进行颠倒。

⑤单链表的查找操作在单链表中,可以通过查找操作找到指定值的节点。

⑥单链表的修改操作在单链表中,可以通过修改操作修改指定位置的节点的值。

3.实验过程3.1 实验环境本次实验使用C语言进行编程,需要先安装相应的编程环境,如gcc编译器。

3.2 实验步骤①单链表的创建和初始化首先创建一个空链表,并初始化链表的头指针。

②单链表的插入操作按照需求,在链表的指定位置插入一个新节点。

③单链表的删除操作按照需求,删除链表中的指定位置的节点。

④单链表的遍历操作依次访问链表中的每一个节点,并输出其值。

⑤单链表的逆置操作将单链表中的节点顺序进行逆置。

⑥单链表的查找操作按照需求,在链表中查找指定值的节点。

3.2.7 单链表的修改操作按照需求,修改链表中指定位置的节点的值。

循环单链表的实验报告

循环单链表的实验报告

《数据结构》实验报告1、实验名称:设计循环单链表2、实验日期: 2011-3-43、基本要求:1)循环单链表的操作,包括初始化、求数据元素个数、插入、删除、取数据元素;2)设计一个测试主函数实际运行验证所设计循环单链表的正确性。

4、测试数据:依次输入1,2,3,4,5,6,7,8,9,10,删除5,再依次输出数据元素。

5、算法思想或算法步骤:主函数主要是在带头结点的循环单链表中删除第i个结点,其主要思想是在循环单链表中寻找到第i-1个结点并由指针p指示,然后让指针s指向a[i]结点,并把数据元素a[i]的值赋给x,最后把a[i]结点脱链,并动态释放a[i]结点的存储空间。

6、模块划分:1)头文件LinList.h。

头文件LinList.h中包括:结点结构体定义、初始化操作、求当前数据个数、插入一个结点操作、删除一个结点操作以及取一个数据元素操作;2)实现文件xhdlb.cpp。

包含主函数void main(void),其功能是测试所设计的循环单链表的正确性。

7、数据结构:链表中的结点的结构体定义如下:typedef struct Node{DataType data;struct Node *next;}SLNode;8、源程序:源程序存放在两个文件中,即头文件LinList.h和实现文件xhdlb.cpp。

//头文件LinList.htypedef struct Node{DataType data;struct Node *next;}SLNode;void ListInitiate(SLNode **head) //初始化{*head=(SLNode *)malloc(sizeof(SLNode));//申请头结点,由head指示其地址(*head)->next=*head;}int ListLength(SLNode *head){SLNode *p=head; //p指向头指针int size=0; //size初始值为0while(p->next!=head) //循环计数{p=p->next;size++;}return size;}int ListInsert(SLNode *head,int i,DataType x)//在带头结点的循环单链表head的第i(0<=i<=size)个结点前插//入一个存放数据元素x的结点。

数据结构单链表实验报告

数据结构单链表实验报告

数据结构单链表实验报告实验目的:掌握单链表的基本操作,学会使用单链表实现各种算法。

实验内容:实现单链表的基本操作,包括创建、插入、删除、访问等。

利用单链表完成以下算法:- 单链表逆序- 查找单链表中的中间节点- 删除单链表中的倒数第K个节点- 合并两个有序单链表为一个有序单链表实验步骤:1. 创建单链表在创建单链表时,先定义一个结构体Node来表示链表中的节点,节点包括数据域和指针域,指针域指向下一个节点。

然后,用指针p指向链表的头节点,将头节点的指针域初始化为NULL。

2. 插入节点在单链表中插入节点的操作分为两种情况:- 在链表头插入节点- 在链表中间或尾部插入节点无论是哪种情况,先将新节点的指针域指向要插入的位置的下一个节点,再将要插入的位置的指针域指向新节点即可。

3. 删除节点删除链表节点的操作同样分为两种情况:- 删除头节点- 删除中间或尾部节点要删除头节点,先用一个指针将头节点指向的下一个节点保存起来,再将头节点释放掉。

要删除中间或尾部节点,先用一个指针指向要删除节点的前一个节点,然后将指向要删除节点的前一个节点的指针域指向要删除节点的下一个节点,最后将要删除的节点释放掉。

4. 单链表逆序单链表逆序可以使用三个指针来完成,分别为pre指针、cur指针和next指针。

首先将pre指针和cur指针指向NULL,然后循环遍历链表,将cur指针指向当前节点,将next指针指向当前节点的下一个节点,然后将当前节点的指针域指向pre指针,最后将pre指针和cur指针向前移动一个节点,继续进行循环。

5. 查找单链表中的中间节点查找单链表中的中间节点可以使用双指针法,将两个指针p1和p2都指向链表头,然后p1每次向前移动一个节点,而p2每次向前移动两个节点,当p2指向了链表尾部时,p1指向的节点即为中间节点。

6. 删除单链表中的倒数第K个节点删除单链表中的倒数第K个节点可以使用双指针法,在链表中定义两个指针p1和p2,p1指向链表头,p2指向第K个节点,然后p1和p2同时向前移动,直到p2指向链表尾部,此时p1指向的节点即为要删除的节点。

数据结构实验报告实现单链表各种基本运算的算法

数据结构实验报告实现单链表各种基本运算的算法

实验截图(1)void InitList(LinkNode *&L)//初始化线性表{L=(LinkNode *)malloc(sizeof(LinkNode)); //创建头结点L->next=NULL;//单链表置为空表}void DestroyList(LinkNode *&L)//销毁线性表{LinkNode *pre=L,*p=pre->next;实验截图(2)bool GetElem(LinkNode *L,int i,ElemType &e) //求线性表中第i个元素值{ int j=0;if (i<=0) return false;//i错误返回假LinkNode *p=L;//p指向头结点,j置为0(即头结点的序号为0) while (j<i && p!=NULL)//找第i个结点p{ j++;p=p->next;}if (p==NULL)//存在值为e的结点,返回其逻辑序号ireturn(i);}实验截图(3)bool ListInsert(LinkNode *&L,int i,ElemType e) //插入第i个元素{ int j=0;if (i<=0) return false;//i错误返回假LinkNode *p=L,*s;//p指向头结点,j置为0(即头结点的序号为0) while (j<i-1 && p!=NULL)//查找第i-1个结点p{ j++;p=p->next;}}实验截图(4)编写exp2-2.cpp程序包含有关代码//文件名:exp2-2.cpp#include "linklist.cpp"int main(){LinkNode *h;ElemType e;printf("单链表的基本运算如下:\n");printf(" (1)初始化单链表h\n");InitList(h);printf(" (2)依次采用尾插法插入a,b,c,d,e元素\n");return 1;}实验截图(5)运行得到结果实验截图(6)。

数据结构-单链表实验报告

数据结构-单链表实验报告

单链表实验报告一、实验目的1、帮助读者复习C++语言程序设计中的知识。

2、熟悉线性表的逻辑结构。

3、熟悉线性表的基本运算在两种存储结构上的实现,其中以熟悉链表的操作为侧重点。

二、实验内容[问题描述]实现带头结点的单链表的建立、求长度,取元素、修改元素、插入、删除等单链表的基本操作。

[基本要求](1)依次从键盘读入数据,建立带头结点的单链表;(2)输出单链表中的数据元素(3)求单链表的长度;(4)根据指定条件能够取元素和修改元素;(5)实现在指定位置插入和删除元素的功能。

三、算法设计(1)建立带表头结点的单链表;首先输入结束标志,然后建立循环逐个输入数据,直到输入结束标志。

(2)输出单链表中所有结点的数据域值;首先获得表头结点地址,然后建立循环逐个输出数据,直到地址为空。

(3)输入x,y在第一个数据域值为x的结点之后插入结点y,若无结点x,则在表尾插入结点y;建立两个结构体指针,一个指向当前结点,另一个指向当前结点的上一结点,建立循环扫描链表。

当当前结点指针域不为空且数据域等于x的时候,申请结点并给此结点数据域赋值为y,然后插入当前结点后面,退出函数;当当前结点指针域为空的时候,申请结点并给此结点数据域赋值为y,插入当前结点后面,退出函数。

(4)输入k,删除单链表中所有的结点k,并输出被删除结点的个数。

建立三个结构体指针,一个指向当前结点,另一个指向当前结点的上一结点,最后一个备用;建立整形变量l=0;建立循环扫描链表。

当当前结点指针域为空的时候,如果当前结点数据域等于k,删除此结点,l++,跳出循环,结束操作;如果当前结点数据域不等于k,跳出循环,结束操作。

当当前结点指针域不为空的时候,如果当前结点数据域等于k,删除此结点,l++,继续循环操作;如果当前结点数据域不等于k,指针向后继续扫描。

循环结束后函数返回变量l的值,l便是删除的结点的个数。

四、实验结果1、新建一个链表:2、输出链表的数据:(4)插入数据:在数据为3后面插入一个数据100:(5)删除数据:删除刚刚插入的数据100:五、总结实验之前由于准备不够充分,所以堂上实验时只完成了建立单链表和数据的输出,而后面两个实验要求也是用来很多时间长完成的。

数据结构单链表实验报告

数据结构单链表实验报告

数据结构单链表实验报告范本:数据结构单链表实验报告一、引言本实验旨在掌握数据结构中单链表的基本概念、操作和应用。

通过实际操作,理解单链表的结构与实现,提高数据结构的编程能力和问题解决能力。

二、实验目的1. 理解单链表的概念和特点;2. 掌握单链表的基本操作,包括插入、删除、遍历;3. 学会使用单链表解决实际问题。

三、实验内容1. 单链表的定义和结构设计;2. 单链表的基本操作的实现,包括插入节点、删除节点、遍历;3. 针对具体的问题,设计相应的单链表操作。

四、实验步骤1. 单链表的定义和结构设计:(1)定义单链表的结构体,包含数据域和指针域;(2)实现单链表的初始化函数;(3)实现单链表的销毁函数。

2. 单链表的基本操作的实现:(1)实现单链表的插入节点操作;(2)实现单链表的删除节点操作;(3)实现单链表的遍历操作。

3. 针对具体问题的单链表操作:(1)根据具体需求,设计并实现相应的操作函数;(2)利用单链表解决具体问题。

五、实验结果与分析1. 在实验过程中,成功实现了单链表的定义和结构设计,包括数据域和指针域的正确设置。

2. 实验中实现了插入节点、删除节点和遍历等基本操作。

3. 针对具体问题,通过单链表操作解决了相应的问题。

六、实验总结通过本次实验,加深了对单链表的理解和掌握。

掌握了单链表的基本操作和应用实现,提高了数据结构的编程能力和问题解决能力。

附件:1. 本文所涉及的代码文件;2. 实验过程中所用到的数据文件。

法律名词及注释:1. 数据结构:指的是一组数据的表示方法和相应的操作。

在计算机科学中,数据结构是计算机中存储、组织数据的方式。

2. 单链表:是一种链式存储结构,每个节点包含数据域和指针域。

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

数据结构实验报告实现单链表各种基本运算的算法

数据结构实验报告实现单链表各种基本运算的算法

实验截图(1)void InitList(LinkNode *&L)//初始化线性表{L=(LinkNode *)malloc(sizeof(LinkNode)); //创建头结点L->next=NULL;//单链表置为空表}void DestroyList(LinkNode *&L)//销毁线性表{LinkNode *pre=L,*p=pre->next;实验截图(2)bool GetElem(LinkNode *L,int i,ElemType &e) //求线性表中第i个元素值{ int j=0;if (i<=0) return false;//i错误返回假LinkNode *p=L;//p指向头结点,j置为0(即头结点的序号为0) while (j<i && p!=NULL)//找第i个结点p{ j++;p=p->next;}if (p==NULL)//存在值为e的结点,返回其逻辑序号ireturn(i);}实验截图(3)bool ListInsert(LinkNode *&L,int i,ElemType e) //插入第i个元素{ int j=0;if (i<=0) return false;//i错误返回假LinkNode *p=L,*s;//p指向头结点,j置为0(即头结点的序号为0) while (j<i-1 && p!=NULL)//查找第i-1个结点p{ j++;p=p->next;}}实验截图(4)编写exp2-2.cpp程序包含有关代码//文件名:exp2-2.cpp#include "linklist.cpp"int main(){LinkNode *h;ElemType e;printf("单链表的基本运算如下:\n");printf(" (1)初始化单链表h\n");InitList(h);printf(" (2)依次采用尾插法插入a,b,c,d,e元素\n");return 1;}实验截图(5)运行得到结果实验截图(6)。

数据结构实验报告--单链表

数据结构实验报告--单链表

2016级数据结构实验报告实验名称:实验一线性表——题目1学生姓名:李文超班级: 2015661131班内序号: 15学号: 2015522147日期: 2016年11月13日1.实验要求实验目的:根据线性表的抽象数据类型的定义,选择下面任一种链式结构实现线性表,并完成线性表的基本功能。

线性表存储结构(五选一):1、带头结点的单链表2、不带头结点的单链表3、循环链表4、双链表5、静态链表线性表的基本功能:1、构造:使用头插法、尾插法两种方法2、插入:要求建立的链表按照关键字从小到大有序3、删除4、查找5、获取链表长度6、销毁7、其他:可自行定义编写测试main()函数测试线性表的正确性。

2.程序分析2.1 存储结构单链表的存储:(1)链表用一组任意的存储单元来存放线性表的结点。

这组存储单元既可以是连续的,也可以是不连续的,甚至零散地分布在内存的某些位置。

(2)链表中结点的逻辑次序和物理次序不一定相同。

为了能正确表示结点间的逻辑关系,在存储每个元素值的同时,还要存储该元素的直接后继元素的位置信息,这个信息称为指针或链。

结点结构┌──┬──┐ data域---存放结点值的数据域│data│next│ next域---存放结点的直接后继的地址的指针域└──┴──┘单链表在内存中的存储示意地址内存单元1000H头指针 1020H1080H10C0H2.2 关键算法分析1、关键算法:(1)头插法自然语言描述:a:在堆中建立新结点b:将a[i]写入到新结点的数据域c:修改新结点的指针域d:修改头结点的指针域。

将新结点加入链表中伪代码描述a:Node <T> * s=new Node <T>b:s->data=a[i]c:s->next=front->next;d:front->next=s(2)尾插法自然语言描述:a:在堆中建立新结点:b:将a[i]写入到新结点的数据域:c:将新结点加入到链表中d:修改修改尾指针伪代码描述a:Node <T> * s=new Node <T>b:s->data=a[i]c:r->next=s;d:r=s(3)遍历打印函数自然语言描述:a:判断该链表是否为空链表,如果是,报错b:如果不是空链表,新建立一个temp指针c:将temp指针指向头结点d:打印temp指针的data域e:逐个往后移动temp指针,直到temp指针的指向的指针的next域为空伪代码描述a: If front->next==NULL①Throw ”an empty list ”②Node<T>* temp=front->next;b:while(temp->next)c:cout<<temp->data<<" ";d:temp=temp->next;(4) 获取链表长度函数自然语言描述:a:判断该链表是否为空链表,如果是,输出长度0b:如果不是空链表,新建立一个temp指针,初始化整形数n为0c:将temp指针指向头结点d:判断temp指针指向的结点的next域是否为空,如果不是,n加一,否则return n e: 使temp指针逐个后移,重复d操作,直到temp指针指向的结点的next域为0,返回n伪代码描述a:if ront->next==NULLb:Node<T>* temp=front->next;c:while(temp->next)d:temp=temp->next;(5)析构/删除函数自然语言描述:a:新建立一个指针,指向头结点b:判断要释放的结点是否存在,c:暂时保存要释放的结点d:移动a中建立的指针e:释放要释放的指针伪代码描述a:Node <T> * p=frontb:while(p)c:front=pd:p=p->nexte:delete front(6)按位查找函数a:初始化工作指针p和计数器j,p指向第一个结点,j=1b:循环以下操作,直到p为空或者j等于1①:p指向下一个结点②:j加1c:若p为空,说明第i个元素不存在,抛出异常d:否则,说明p指向的元素就是所查找的元素,返回元素地址伪代码描述a:Node <T> * p=front->next;j=1;b:while(p&&j!=1)①:p=p->next②:j++c:if(!p) throw ”error”d:return p(7)按位查找函数自然语言描述:a:初始化工作指针p和计数器j,p指向第一个结点,j=1b:循环以下操作,找到这个元素或者p指向最后一个结点①:判断p指向的结点是不是要查找的值,如果是,返回j,否则p指向下一个结点,并且j的值加一c:如果找到最后一个结点还没有找到要查找的元素,返回查找失败信息伪代码描述a:Node <T> * p=front->next;j=1;b:while(p)①: if(p->next==x) return jp=p->nextj++c:return “error”(8)插入函数自然语言描述:a:在堆中建立新结点b:将要插入的结点的数据写入到新结点的数据域c:修改新结点的指针域d:修改前一个指针的指针域,使其指向新插入的结点的位置伪代码描述a:Node <T> * s=new Node <T>;b:s-data=p->datac:s->next=p->nextd:p->next=se:p->data=x(9)删除函数a:从第一个结点开始,查找要删除的位数i前一个位置i-1的结点b:设q指向第i个元素c:将q元素从链表中删除d:保存q元素的数据e:释放q元素伪代码描述a:q=p->nextb:p->next=q->nextc:x=q->datad:delete q2、代码详细分析(插入):(1)从第一个结点开始,查找节点,使它的数据比x大,设p指向该结点:while (x>p->data) { p=p->next;}(2)新建一个节点s,把p的数据赋给s: s->data=p->data;(3)把s加到p后面:s->next=p->next; p->next=s;(4)p节点的数据用x替换:p->data=x;示意图如图所示3、关键算法的时间复杂度:O(1)3.程序运行结果1. 流程图:2、结果截图3.测试结论:可以正确的对链表进行插入,删除,取长度,输出操作。

数据结构单链表实验报告

数据结构单链表实验报告

数据结构单链表实验报告一、实验目的本实验的目的是通过设计和实现单链表数据结构,加深对于单链表的理解和掌握,并能够灵活应用单链表解决实际问题。

二、实验内容1·理解单链表的概念和基本操作2·设计并实现单链表数据结构3·实现单链表的创建、插入、删除和查找操作4·应用单链表解决实际问题三、实验步骤1·理解单链表的概念和基本操作单链表是一种常见的线性链表结构,它由多个节点组成,每个节点包含一个数据元素和一个指向下一个节点的指针。

单链表的基本操作包括创建链表、插入节点、删除节点和查找节点等。

2·设计并实现单链表数据结构首先,定义单链表节点的结构,包含数据元素和指向下一个节点的指针。

然后,定义一个链表结构,包含头节点和尾节点的指针。

3·实现单链表的创建、插入、删除和查找操作●创建链表:通过依次插入节点的方式创建一个空的链表。

●插入节点:根据插入位置,将新节点插入到链表中的适当位置。

●删除节点:根据节点的值或位置,删除链表中的对应节点。

●查找节点:根据节点的值或位置,在链表中查找对应节点。

4·应用单链表解决实际问题通过设计和实现单链表数据结构,应用单链表解决实际问题,如实现一个通讯录、一个待办事项列表等。

四、实验结果根据实验步骤,我们成功设计并实现了单链表数据结构,并应用单链表解决了实际问题。

经过测试,单链表的创建、插入、删除和查找操作均正常工作。

五、实验总结通过本次实验,我们深入学习了单链表的概念和基本操作。

通过设计和实现单链表数据结构,并应用单链表解决实际问题,加深了对于单链表的理解和掌握。

六、附件本实验报告涉及的附件包括实验代码和测试数据。

七、法律名词及注释1·数据结构:数据结构是计算机存储、组织数据的方式,是程序设计和算法设计的基础。

2·单链表:单链表是一种常见的线性链表结构,它由多个节点组成,每个节点包含一个数据元素和一个指向下一个节点的指针。

链表(单链表 双向循环)实验报告讲解

链表(单链表 双向循环)实验报告讲解

数据结构实验报告T1223-3-21余帅实验一实验题目:仅仅做链表部分难度从上到下1.双向链表,带表头,线性表常规操作。

2.循环表,带表头,线性表常规操作。

3.单链表,带表头,线性表常规操作。

实验目的:了解和掌握线性表的逻辑结构和链式存储结构,掌握单链表的基本算法及相关的时间性能分析。

实验要求:常规操作至少有:1.数据输入或建立2.遍历3.插入4.删除必须能多次反复运行实验主要步骤:1、分析、理解给出的示例程序。

2、调试程序,并设计输入数据,测试程序的如下功能:1.数据输入或建立2.遍历3.插入4.删除单链表示意图:headhead head 创建删除双向循环链表示意图:创建程序代码://单链表#include<iostream.h>#include<windows.h>const MAX=5;enum returninfo{success,fail,overflow,underflow,range_error}; int defaultdata[MAX]={11,22,33,44,55};class node{public:int data;node *next;};class linklist{private:node *headp;protected:int count;public:linklist();~linklist();bool empty();void clearlist();returninfo create(void);returninfo insert(int position,const int &item);returninfo remove(int position) ;returninfo traverse(void);};linklist::linklist(){headp = new node;headp->next = NULL;count=0;}linklist::~linklist(){clearlist();delete headp;}bool linklist::empty(){if(headp->next==NULL)return true;elsereturn false;}void linklist::clearlist(){node *searchp=headp->next,*followp=headp;while(searchp->next!=NULL){followp=searchp;searchp=searchp->next;delete followp;}headp->next = NULL;count = 0;}returninfo linklist::create(){node *searchp=headp,*newnodep;for(int i=0;i<MAX;i++){newnodep = new node;newnodep->data = defaultdata[i];newnodep->next = NULL;searchp->next = newnodep;searchp = searchp->next;count++;}searchp->next = NULL;traverse();return success;}returninfo linklist::insert(int position,const int &item) //插入一个结点{if(position<=0 || position>=count)return range_error;node *newnodep=new node,*searchp=headp->next,*followp=headp;for(int i=1; i<position && searchp!=NULL;i++){followp=searchp;searchp=searchp->next;}newnodep->data=item; //给数据赋值newnodep->next=followp->next; //注意此处的次序相关性followp->next=newnodep;count++; //计数器加一return success;}returninfo linklist::remove(int position) //删除一个结点{if(empty())return underflow;if(position<=0||position>=count+1)return range_error;node *searchp=headp->next,*followp=headp; //这里两个指针的初始值设计一前一后for(int i=1; i<position && searchp!=NULL;i++){followp=searchp;searchp=searchp->next;}followp->next=searchp->next; //删除结点的实际语句delete searchp; //释放该结点count--; //计数器减一return success;}returninfo linklist::traverse(void){node *searchp;if(empty())return underflow;searchp = headp->next;cout<<"连表中的数据为:"<<endl;while(searchp!=NULL){cout<<searchp->data<<" ";searchp = searchp->next;}cout<<endl;return success;}class interfacebase{public:linklist listface; //定义一个对象Cskillstudyonfacevoid clearscreen(void);void showmenu(void);void processmenu(void);};void interfacebase::clearscreen(void){system("cls");}void interfacebase::showmenu(void){cout<<"================================"<<endl;cout<<" 功能菜单 "<<endl;cout<<" 1.创建链表 "<<endl;cout<<" 2.增加结点 "<<endl;cout<<" 3.删除结点 "<<endl;cout<<" 4.遍历链表 "<<endl;cout<<" 0.结束程序 "<<endl;cout<<"======================================"<<endl;cout<<"请输入您的选择:";}void interfacebase::processmenu(void){int returnvalue,item,position;char menuchoice;cin >>menuchoice;switch(menuchoice) //根据用户的选择进行相应的操作{case '1':returnvalue=listface.create();if(returnvalue==success)cout<<"链表创建已完成"<<endl;break;case '2':cout<<"请输入插入位置:"<<endl;cin>>position;cout<<"请输入插入数据:"<<endl;cin>>item;returnvalue = listface.insert(position,item);if(returnvalue==range_error)cout<<"数据个数超出范围"<<endl;elsecout<<"操作成功!!!"<<endl;break;case '3':cout<<"输入你要删除的位置:"<<endl;cin>>position;returnvalue = listface.remove(position);if(returnvalue==underflow)cout<<"链表已空"<<endl;else if(returnvalue==range_error)cout<<"删除的数据位置超区范围"<<endl;elsecout<<"操作成功!!!"<<endl;break;case '4':listface.traverse();break;case '0':cout<<endl<<endl<<"您已经成功退出本系统,欢迎再次使用!!!"<<endl;system("pause");exit(1);default:cout<<"对不起,您输入的功能编号有错!请重新输入!!!"<<endl;break;}}void main(){interfacebase interfacenow;linklist listnow;system("color f0");interfacenow.clearscreen();while(1){interfacenow.showmenu();interfacenow.processmenu();system("pause");interfacenow.clearscreen();}}/* 功能:用双向循环链表存储数据1.创建链表2.增加结点3.删除结点4.遍历链表制作人:余帅内容:239行*/#include<iostream.h>#include<windows.h>const MAX=5;enum returninfo{success,fail,overflow,underflow,range_error}; int defaultdata[MAX]={11,22,33,44,55};class node{public:int data;node * next; //指向后续节点node * pre; //指向前面的节点};class linklist{private:node *headp;protected:int count;public:linklist();~linklist();bool empty();void clearlist();returninfo create(void);returninfo insert(int position,const int &item);returninfo remove(int position) ;returninfo traverse(void);};linklist::linklist(){headp = new node;headp->next = NULL;headp->pre = NULL;count=0;}linklist::~linklist(){clearlist();delete headp;}bool linklist::empty(){if(headp->next==NULL)return true;elsereturn false;}void linklist::clearlist(){node *searchp=headp->next,*followp=headp;while(searchp->next!=NULL){followp=searchp;searchp=searchp->next;delete followp;}headp->next = NULL;headp->pre = NULL;count = 0;}returninfo linklist::create(){node *searchp=headp,*newnodep;for(int i=0;i<MAX;i++){newnodep = new node;newnodep->data = defaultdata[i];newnodep->next = NULL;searchp->next = newnodep;newnodep->pre = searchp;searchp = searchp->next;count++;}searchp->next = headp;headp->pre = searchp;traverse();return success;}returninfo linklist::insert(int position,const int &item) //插入一个结点{if(position<=0 || position>count+1)return range_error;node *newnodep=new node;node *searchp=headp->next,*followp=headp;for(int i=1; i<position && searchp!=NULL;i++){followp=searchp;searchp=searchp->next;}newnodep->data=item; //给数据赋值newnodep->next = searchp;searchp->pre = newnodep;followp->next = newnodep;newnodep->pre = followp;count++; //计数器加一return success;}returninfo linklist::remove(int position) //删除一个结点{if(empty())return underflow;if(position<=0||position>=count+1)return range_error;node *searchp=headp->next,*followp=headp; //这里两个指针的初始值设计一前一后for(int i=1; i<position && searchp!=NULL;i++){followp=searchp;searchp=searchp->next;}followp->next=searchp->next; //删除结点的实际语句searchp->next->pre = followp;delete searchp; //释放该结点count--; //计数器减一return success;}returninfo linklist::traverse(void){node *searchp1,*searchp2;if(empty())return underflow;searchp1 = headp;searchp2 = headp;cout<<"连表中的数据为:"<<endl;cout<<"从左至右读取:";while (searchp1->next!=headp ) {searchp1 = searchp1 ->next;cout << searchp1->data<<" ";}cout<<endl;cout<<"从右至左读取:";while (searchp2->pre!=headp ) {searchp2 = searchp2 ->pre;cout << searchp2->data<<" ";}cout<<endl;return success;}class interfacebase{public:linklist listface; //定义一个对象Cskillstudyonface void clearscreen(void);void showmenu(void);void processmenu(void);};void interfacebase::clearscreen(void){system("cls");}void interfacebase::showmenu(void){cout<<"================================"<<endl;cout<<" 功能菜单 "<<endl;cout<<" 1.创建链表 "<<endl;cout<<" 2.增加结点 "<<endl;cout<<" 3.删除结点 "<<endl;cout<<" 4.遍历链表 "<<endl;cout<<" 0.结束程序 "<<endl;cout<<"======================================"<<endl;cout<<"请输入您的选择:";}void interfacebase::processmenu(void){int returnvalue,item,position;char menuchoice;cin >>menuchoice;switch(menuchoice) //根据用户的选择进行相应的操作{case '1':returnvalue=listface.create();if(returnvalue==success)cout<<"链表创建已完成"<<endl;break;case '2':cout<<"请输入插入位置:"<<endl;cin>>position;cout<<"请输入插入数据:"<<endl;cin>>item;returnvalue = listface.insert(position,item);if(returnvalue==range_error)cout<<"数据个数超出范围"<<endl;elsecout<<"操作成功!!!"<<endl;break;case '3':cout<<"输入你要删除的位置:"<<endl;cin>>position;returnvalue = listface.remove(position);if(returnvalue==underflow)cout<<"链表已空"<<endl;else if(returnvalue==range_error)cout<<"删除的数据位置超区范围"<<endl;elsecout<<"操作成功!!!"<<endl;break;case '4':listface.traverse();break;case '0':cout<<endl<<endl<<"您已经成功退出本系统,欢迎再次使用!!!"<<endl;system("pause");exit(1);default:cout<<"对不起,您输入的功能编号有错!请重新输入!!!"<<endl;break;}}void main(){interfacebase interfacenow;linklist listnow;system("color f0");interfacenow.clearscreen();while(1){interfacenow.showmenu();interfacenow.processmenu();system("pause");interfacenow.clearscreen();}}运行结果:1.创建链表:2.增加结点3.删除结点心得体会:本次实验使我们对链表的实质了解更加明确了,对链表的一些基本操作也更加熟练了。

数据结构实验报告单链表

数据结构实验报告单链表

数据结构实验报告_单链表数据结构实验报告——单链表一、实验目的1.掌握单链表的基本概念和原理。

2.了解单链表在计算机科学中的应用。

3.掌握单链表的基本操作,如插入、删除、遍历等。

4.通过实验,加深对理论知识的理解,提高编程能力。

二、实验内容1.实验原理:单链表是一种线性数据结构,由一系列节点组成,每个节点包含数据域和指针域。

其中,指针域指向下一个节点,最后一个节点的指针域指向空。

单链表的主要操作包括插入、删除、遍历等。

2.实验步骤:(1)创建一个单链表。

(2)实现插入操作,即在链表的末尾插入一个新节点。

(3)实现删除操作,即删除链表中的一个指定节点。

(4)实现遍历操作,即输出链表中所有节点的数据。

3.实验代码:下面是使用Python语言实现的单链表及其基本操作的示例代码。

class Node:def __init__(self, data):self.data = dataself.next = Noneclass LinkedList:def __init__(self):self.head = Nonedef insert(self, data):new_node = Node(data)if self.head is None:self.head = new_nodeelse:current = self.headwhile current.next is not None:current = current.nextcurrent.next = new_nodedef delete(self, data):if self.head is None:returnif self.head.data == data:self.head = self.head.nextreturncurrent = self.headwhile current.next is not None and current.next.data != data:current = current.nextif current.next is None:returncurrent.next = current.next.nextdef traverse(self):current = self.headwhile current is not None:print(current.data)current = current.next4.实验结果:通过运行上述代码,我们可以看到单链表的基本操作得到了实现。

数据结构单链表实验报告

数据结构单链表实验报告
if(!(pre->next)) /*即while循环是因为p->next=NULL或i<1而跳出的,而是因为没有找到合法的前驱位置,说明删除位置i不合法。*/
{
printf("删除结点的位置i不合理!");
return ERROR;
}
r=pre->next;
pre->next=pre->next->next; /*修改指针,删除结点r*/
返回值说明:返回ERROR插入失败,返回OK插入成功;
(5)按位置查找链表元素:int GetList(LinkList L,int i,int *e);
4.详细设计
void init_linklist(LinkList *l)/*对单链表进行初始化*/{
*l=(LinkList)malloc(sizeof(Node)); /*申请结点空间*/
(*l)->next=NULL; /*置为空表*/
}
void CreateFromHead(LinkList L)
{
Node *s;
charc;
intflag=1;
while(flag) /* flag初值为1,当输入"$"时,置flag为0,建表结束*/
{
c=getchar();
if(c!='$')
*e = r->data;
free(r); /*释放被删除的结点所占的内存空间*/
printf("成功删除结点!");
return OK;
}
intListLength(LinkList L)
/*求带头结点的单链表L的长度*/

数据结构课程设计-- 循环单链表

数据结构课程设计--  循环单链表

数据结构课程设计-- 循环单链表信息科学与技术学院《数据结构》课程设计报告题目名称:循环单链表(附加头结点,引用)专业班级:计算机科学与技术2011级1班学生姓名:**学生学号:**********指导教师:**目录1 课程设计的目的 (1)1.1 课程设计的目的 (1)1.2 课程设计的题目 (1)1.3 题目要求 (1)2 概要设计 (1)2.1 存储结构 (1)2.2 基本操作 (1)3 详细设计 (2)3.1 流程图 (2)3.2 源程序 (7)4 测试 (12)5 课程设计总结 (19)6参考书目: (20)1 课程设计的目的1.1 课程设计的目的更好的掌握数据结构这门课程,会用数据结构的基本思想及算法解决实际问题。

更好的掌握循环链表,能进行各种基本的操作,提高编程能力。

1.2 课程设计的题目循环单链表(附加头结点,引用)1.3 题目要求实现附加头结点循环单链表的基本操作:创建空表、输出、求表长、取元素、查找、替换、插入、删除、清空。

2 概要设计2.1 存储结构存储结构L data next data next data next datnexttypedef struct node{datatype data;/*数据域*/struct node *next;/*指针域*/}LNode,*LinkList;/*结点及结点的地址*/2.2 基本操作创建空表、输出、求表长、取元素、查找、替换、插入、删除、清空。

3 详细设计3.1 流程图各个算法的设计如下:1.主函数:2.主菜单用于进行指示进行各种操作,是与每个函数都相联系的一个函数3.显示链表先让指针指向首元结点,在判断该指针是否为头指针,不是则输入数据,实则退出4.求表长先求表的初始长,在判断链表是否为空,不是则len自加,否则结束先求表长,在判断Index < 1 || Index > len,为否则循环,一直活得该数据6.查找求表长,在判断链表是否为空,是则结束,否则判断要查找的数据是否在链表中,是则成功判断要替换的位置是否在链表范围中,是则循环找到要替换的数据替换,否则结束判断将要插入的位置是否在链表范围内,是则循环将要插入的数据插入,否则结束9.删除判断链表是否为空,否则删除该结点,是则结束10.清空判断聊表是够为空,否则依次释放空间,否则结束3.2 源程序#include <iostream>using namespace std;typedef int ElemType;typedef struct node{ElemType data;struct node *next;}LNode,*LinkList,*pNODE;// 创建一个有头结点的空循环表。

数据结构实验报告-实验一顺序表、单链表基本操作的实现

数据结构实验报告-实验一顺序表、单链表基本操作的实现

数据结构实验报告-实验⼀顺序表、单链表基本操作的实现实验⼀顺序表、单链表基本操作的实现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)掌握链表的概念,学会对链表进⾏操作。

数据结构单链表实验报告

数据结构单链表实验报告

数据结构单链表实验报告数据结构单链表实验报告1. 引言数据结构是计算机科学中的重要基础,它研究数据的组织、存储和管理方式。

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

本实验旨在通过实践操作单链表,加深对数据结构的理解。

2. 实验目的本实验的主要目的是掌握单链表的基本操作,包括创建链表、插入节点、删除节点和遍历链表。

通过实践操作,加深对链表的理解,提高编程能力和解决问题的能力。

3. 实验环境和工具本实验使用C语言进行编程实现,可以选择任何C语言开发环境,如Dev-C++、Code::Blocks等。

在编程过程中,可以使用任何文本编辑器编写代码。

4. 实验步骤4.1 创建链表首先,需要定义一个节点结构体,包含数据和指向下一个节点的指针。

然后,通过动态内存分配来创建链表的第一个节点,并将其地址赋给头指针。

接下来,可以通过输入数据的方式,逐个创建链表的其他节点。

4.2 插入节点在链表中插入节点是一种常见的操作。

可以在链表的任意位置插入一个新节点,只需要修改相应节点的指针即可。

首先,需要找到插入位置的前一个节点,然后将新节点的指针指向原来的下一个节点,再将前一个节点的指针指向新节点。

4.3 删除节点删除链表中的节点也是一种常见的操作。

可以根据节点的值或位置来删除节点。

首先,需要找到要删除的节点的前一个节点,然后将前一个节点的指针指向要删除节点的下一个节点,最后释放要删除节点的内存空间。

4.4 遍历链表遍历链表是一种查看链表中所有节点的操作。

可以通过循环遍历链表中的每个节点,输出节点的值或进行其他操作。

需要注意的是,遍历链表时需要使用一个临时指针来指向当前节点,以便于移动到下一个节点。

5. 实验结果与分析通过实验,我们成功实现了单链表的创建、插入、删除和遍历操作。

在实际应用中,单链表可以用于实现各种数据结构和算法,如栈、队列和图等。

它具有灵活性和高效性的特点,可以方便地进行节点的插入和删除操作。

数据结构单链表实验报告

数据结构单链表实验报告

数据结构单链表实验报告一、实验目的本次实验的主要目的是深入理解和掌握数据结构中单链表的基本概念、操作方法以及其在实际编程中的应用。

通过实际编写代码实现单链表的创建、插入、删除、查找等基本操作,提高对数据结构的理解和编程能力。

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

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

指针域指向链表中的下一个节点,通过这种方式将各个节点连接起来形成链表。

在单链表中,头节点通常用于标识链表的开始,尾节点的指针域指向空,表示链表的结束。

四、实验内容(一)单链表的创建创建单链表的基本思路是逐个节点地进行插入。

首先创建一个头节点,然后根据输入的数据依次创建新节点,并将其插入到链表的末尾。

以下是创建单链表的代码实现:```cppinclude <iostream>using namespace std;//定义链表节点结构体struct ListNode {int data;ListNode next;ListNode(int x) : data(x), next(NULL) {}};//创建单链表ListNode createList(){ListNode head = new ListNode(0);ListNode curr = head;int data;cout <<"请输入链表节点的值(输入-1 结束):";cin >> data;while (data!=-1) {curr>next = newNode;curr = newNode;cin >> data;}return head>next;}```(二)单链表的插入操作单链表的插入操作可以分为在表头插入、在表尾插入和在指定位置插入。

1、在表头插入在表头插入新节点时,只需要将新节点的指针指向原表头节点,然后更新头节点即可。

数据结构单链表实验报告

数据结构单链表实验报告

数据结构单链表实验报告实验目的:本实验的目的是通过实现单链表数据结构,加深对数据结构的理解,并掌握单链表的基本操作和算法。

实验内容:1、单链表的定义单链表由若干个节点组成,每个节点包含数据域和指针域,数据域存储具体数据,指针域指向下一个节点。

单链表的头指针指向链表的第一个节点。

2、单链表的基本操作2.1 初始化链表初始化链表时,将头指针置空,表示链表为空。

2.2 插入节点插入节点可以分为头插法和尾插法。

- 头插法:将新节点插入链表头部,新节点的指针域指向原头节点,头指针指向新节点。

- 尾插法:将新节点插入链表尾部,新节点的指针域置空,原尾节点的指针域指向新节点。

2.3 删除节点删除节点可以分为按位置删除和按值删除两种方式。

- 按位置删除:给定要删除节点的位置,修改前一节点的指针域即可。

- 按值删除:给定要删除节点的值,遍历链表找到对应节点,修改前一节点的指针域即可。

2.4 遍历链表遍历链表即按顺序访问链表的每个节点,并输出节点的数据。

2.5 查找节点查找节点可以分为按位置查找和按值查找两种方式。

- 按位置查找:给定节点的位置,通过遍历链表找到对应节点。

- 按值查找:给定节点的值,通过遍历链表找到第一个匹配的节点。

实验步骤:1、根据实验目的,定义单链表的结构体和基本操作函数。

2、实现初始化链表的函数,将头指针置空。

3、实现头插法或尾插法插入节点的函数。

4、实现按位置删除节点的函数。

5、实现按值删除节点的函数。

6、实现遍历链表的函数,输出节点的数据。

7、实现按位置查找节点的函数。

8、实现按值查找节点的函数。

9、设计实验样例,测试单链表的各种操作。

实验结果与分析:通过测试实验样例,我们可以验证单链表的各种操作是否正确。

如果出现异常情况,可通过调试找出问题所在,并进行修改。

单链表的操作时间复杂度与操作的位置有关,对于查找操作,时间复杂度为O(n);对于插入和删除操作,时间复杂度也为O(n)。

附件:1、单链表的定义和基本操作的源代码文件。

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

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

printf("查找不到该元素!\n");
printf("---------------------------------------------\n"); return 0; } 二: 1. 编写头文件及各个函数。这里函数有 CreateList_L() 创建函数,MergeList_L() 是排序函 2. 数。MergeList_L 函数不改变存储,只改变指针。PrintList_L() 用来打印结果。 写主函数。在主函数里输入元素个数,调用函数创建链表输入各个元素值。在调用函数
五、实验结果与讨论
一:
二:
-5-
六、总结
在查找元素的函数中如果按照下面的写法则会产生如下的结果:
于是必须改成 while(p&&(p->data!=e))
-6-
原因:先判断 p 是因为如果先判断 p->data 有可能此时 p 已指向空,p->data 没有值
七、思考与提高
1.如果上面实验内容 2 中合并的表内不允许有重复的数据该如何操作? 2.如何将一个带头结点的单链表 La 分解成两个同样结构的单链表 Lb,Lc, 使得 Lb 中只含 La 表中奇数结点,Lc 中含有 La 表的偶数结点?
-3-
排序,改变指针。输出。 3. 完整代码如下: #include<stdio.h> #include<stdlib.h> #define TRUE 1 #define FALSE 0 #define ERROR 0 #define OK 1 typedef int Status; typedef int ElemType; typedef struct LNode { ElemType data; struct LNode *next; }LNode,*Linklist; Status CreateList_L(Linklist &L,int n) { Linklist p,q; int i=0; L=(Linklist)malloc(sizeof(LNode)); L->next=NULL; p=L; printf("请输入%d 个元素:\n",n); for(i=0;i<n;i++) { q=(Linklist)malloc(sizeof(LNode)); scanf("%d",&q->data); q->next=p->next; } return OK; } void MergeList_L(Linklist &La, Linklist &Lb, Linklist &Lc) { Linklist pa, pb, pc; pa = La->next; pb = Lb->next; while (pa && pb) { if(pa->data <= pb->data) { pc->next = pa; else { pc->next = pb; Lc = pc = La; p->next=q; p=q;

数据结构实验报告_单链表

数据结构实验报告_单链表

数据结构实验报告_单链表【实验目的】1、顺序表的基本操作及c语言实现【实验要求】1、用c语言建立自己的线性表结构的程序库,实现顺序表的基本操作。

2、对线性表表示的集合,集合数据由用户从键盘输入(数据类型为整型),建立相应的顺序表,且使得数据按从小到大的顺序存放,将两个集合的并的结果存储在一个新的线性表集合中,并输出。

【实验内容】1、根据教材定义的顺序表机构,用c语言实现顺序表结构的创建、插入、删除、查找等操作;2、利用上述顺序表操作实现如下程序:建立两个顺序表表示的集合(集合中无重复的元素),并求这样的两个集合的并。

【实验结果】[实验数据、结果、遇到的问题及解决]一.statusinsertorderlist(sqlist&va,elemtypex){}二.statusdeletek(sqlist&a,inti,intk){//在非递减的顺序表va中插入元素x并使其仍成为顺序表的算法inti;if(v==ze)return(overflow);for(i=v;i>0,x }//注意i的编号从0开始intj;if(i<0||i>-1||k<0||k>-i)returninfeasible;for(j=0;j<=k;j++)[j+i]=[j+i+k];=-k;returnok;三.//将合并逆置后的结果放在c表中,并删除b表statuslistmergeoppose_l(linklist&a,linklist&b,linklist& c){linklistpa,pb,qa,qb;pa=a;pb=b;qa=pa;qb=pb;//保存pa的前驱指针//保存pb的前驱指针pa=pa->next;pb=pb->next;a->next=null;c=a;while(pa&&pb){}whi le(pa){}qa=pa;pa=pa->next;qa->next=a->next;a->next=qa;if(pa ->datadata){}else{}qb=pb;pb=pb->next;qb->next=a->next;//将当前最小结点插入a表表头a->next=qb;qa=pa;pa=pa->next;qa->next=a->next;//将当前最小结点插入a表表头a->next=qa;}}pb=b;free(pb);returnok;qb=pb;pb=pb->next;qb->next=a->n ext;a->next=qb;顺序表就是把线性表的元素存储在数组中,元素之间的关系直接通过相邻元素的位置来表达。

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

《数据结构》实验报告
1、实验名称:设计循环单链表
2、实验日期: 2013-3-26
3、基本要求:
1)循环单链表的操作,包括初始化、求数据元素个数、插入、删除、取数据元素;
2)设计一个测试主函数实际运行验证所设计循环单链表的正确性。

4、测试数据:
依次输入1,2,3,4,5,6,7,8,9,10,删除5,再依次输出数据元素。

5、算法思想或算法步骤:
主函数主要是在带头结点的循环单链表中删除第i个结点,其主要思想是在循环单链表中寻找到第i-1个结点并由指针p指示,然后让指针s指向a[i]结点,并把数据元素a[i]的值赋给x,最后把a[i]结点脱链,并动态释放a[i]结点的存储空间。

6、模块划分:
1)头文件LinList.h。

头文件LinList.h中包括:结点结构体定义、初始化操作、求当前数据个数、插入一个结点操作、删除一个结点操作以及取一个数据元素操作;
2)实现文件dlb.cpp。

包含主函数void main(void),其功能是测试所设计的循环单链表的正确性。

7、数据结构:
链表中的结点的结构体定义如下:
typedef struct Node
{
DataType data;
struct Node *next;
}SLNode;
8、源程序:
源程序存放在两个文件中,即头文件LinList.h和实现文件dlb.cpp。

//头文件LinList.h
typedef struct Node
{
DataType data;
struct Node *next;
}SLNode;
void ListInitiate(SLNode **head) //初始化
{
*head=(SLNode *)malloc(sizeof(SLNode));
//申请头结点,由head指示其地址
(*head)->next=*head;
}
int ListLength(SLNode *head)
{
SLNode *p=head; //p指向头指针
int size=0; //size初始值为0
while(p->next!=head) //循环计数
{
p=p->next;
size++;
}
return size;
}
int ListInsert(SLNode *head,int i,DataType x)
//在带头结点的循环单链表head的第i(0<=i<=size)个结点前插//入一个存放数据元素x的结点。

插入成功返回1;失败则返回0 {
SLNode *p,*q;
int j;
p=head;
j=-1;
while(p->next!=head&&j<i-1)
//最终让指针p指向第i-1个结点
{
p=p->next;
j++;
}
if(j!=i-1)
{
printf("插入位置参数错!");
return 0;
}
q=(SLNode *)malloc(sizeof(SLNode)); //生成新结点
q->data=x; //新结点数据域赋值
q->next=p->next;
p->next=q;
return 1;
}
int ListDelete(SLNode *head,int i,DataType *x)
//删除带头结点循环单链表head的第i(0<=i<=size-1)个结点被删//除结点的数据域值由x带回。

删除成功则返回1;失败则返回0。

{
SLNode *p,*s;
int j;
p=head;
j=-1;
while(p->next!=head&&p->next->next!=NULL&&j<i-1)
//循环结束时指针p指向第i-1个结点
{
p=p->next;
j++;
}
if(j!=i-1)
{
printf("删除位置参数错!");
return 0;
}
s=p->next; //指针s指向a[i]结点
*x=s->data; //把指针s所指结点的数据域值赋予x p->next=p->next->next; //删除
free(s); //释放指针s所指结点的内存空间return 1;
}
int ListGet(SLNode *head,int i,DataType *x)
{
SLNode *p;
int j;
p=head;
j=-1;
while(p->next!=head&&j<i)
{
p=p->next;
j++;
}
if(j!=i)
{
printf("取元素位置参数错!");
return 0;
}
*x=p->data;
return 1;
}
//实现文件dlb.cpp
#include<stdio.h> //包含printf()函数#include<malloc.h> //包含malloc()函数typedef int DataType; //定义DataTyoe为int #include"LinList.h" //包含LinList.h头文件void main(void)
{
SLNode *head; //定义头指针变量
int i,x;
ListInitiate(&head); //初始化
for(i=0;i<10;i++) //插入10个数据元素
ListInsert(head,i,i+1); //删除数据元素5
ListDelete(head,4,&x);
for(i=0;i<ListLength(head);i++) //显示当前数据元素
{
ListGet(head,i,&x); //取元素
printf("%d ",x); //显示
}
}
9、测试情况:
1)程序运行输出为:
1 2 3 4 6 7 8 9 10
2)测试结果分析:
程序运行结果和预测的完全相同,说明所设计的循环单链表是正确的。

相关文档
最新文档