实验二_单链表的实现及测试

合集下载

实验二 单链表实现

实验二 单链表实现

实验报告
课程名称数据结构课程设计
实验项目单链表的实现
实验仪器PC机一台
学院_____信息管理学院_______
专业电子商务
班级/学号___电子商务1401______
学生姓名____________
实验日期___12。

27_______
成绩_______________________指导教师_________________
北京信息科技大学
信息管理学院
(课程上机)实验报告
实验课程名称:数据结构课程设计专业:电子商务班级:商务1401学号:姓名:成绩:
Show_LinkList(Head);
Show_LinkList(HT);
contact(Head,HT); Show_LinkList(Head);
return 0;

5.实验总结:理解线性表的逻辑特点;掌握了单链表的定义及C语言实现.但是还有很多不清
楚的地方运行时有许多错误。

1.实验名称、实验目的、实验内容、实验要求由教师确定,实验前由教师事先填好,然后作为实验报告模版
供学生使用;
2.实验准备由学生在实验或上机之前填写,教师应该在实验前检查;
3.实验过程由学生记录实验的过程,包括操作过程、遇到哪些问题以及如何解决等;
4.实验总结由学生在实验后填写,总结本次实验的收获、未解决的问题以及体会和建议等;
5.源程序、代码、具体语句等,若表格空间不足时可作为附录另外附页。

单链表的实验报告

单链表的实验报告

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

在本次实验中,我们将学习如何使用单链表来实现一些基本的操作,并通过实验验证其功能和效率。

一、实验目的本次实验的主要目的是掌握单链表的基本概念和操作方法,包括插入、删除、查找等操作,并通过实际操作来验证其正确性和效率。

二、实验过程1. 单链表的定义和初始化首先,我们需要定义一个单链表的结构,并初始化一个空链表。

链表的结构可以使用C语言中的结构体来表示,其中包含一个数据域和一个指向下一个节点的指针。

2. 插入操作在已有链表中插入一个新的节点,可以分为两种情况:在链表头部插入和在链表中间插入。

我们可以通过修改指针的指向来实现插入操作。

3. 删除操作删除链表中的一个节点,同样可以分为两种情况:删除头节点和删除中间节点。

删除操作需要注意指针的重新连接,以防止链表断裂。

4. 查找操作在链表中查找指定的元素,可以通过遍历链表的方式来实现。

从链表头开始,依次比较节点的数据域,直到找到目标元素或者遍历到链表尾部。

5. 其他操作在实际应用中,还可以对链表进行排序、逆序、合并等操作,这些操作都可以通过适当的算法来实现。

三、实验结果通过实际操作,我们验证了单链表的各种操作方法的正确性和效率。

在插入、删除和查找操作中,链表的时间复杂度为O(n),其中n为链表的长度。

而在其他操作中,时间复杂度则根据具体算法的实现方式而定。

四、实验总结通过本次实验,我们深入了解了单链表的结构和操作方法,并通过实际操作来验证了其功能和效率。

单链表作为一种常用的数据结构,在实际应用中具有广泛的用途,例如链表可以用来实现栈、队列等其他数据结构,也可以用于解决一些实际问题,如链表的反转、环的检测等。

总之,掌握单链表的基本概念和操作方法对于学习和理解数据结构具有重要意义。

通过实验的方式,我们不仅能够加深对单链表的理解,还能够提高编程能力和解决实际问题的能力。

实验报告2(单链表)

实验报告2(单链表)
设计分析:
1、定义结点指针类型:结点包括两个域,即数据域(用来存储结点的值)和指针域(用来存储数据元素的直接后继的地址)。
2、链表的创建(1)头插入法:从一个空表开始,每次读入数据,生成新结点,将读入数据存放到新结点的数据域中,然后将新结点插入到当前链表的表头结点之后,直到读入结束标志为止;(2)尾插入法:将新结点依次插到当前单链表的表尾上;
printf("|[2]尾部插入|\n");
printf("|[3]输出链表|\n");
printf("|[4]序号查找|\n");
printf("|[5]按值查找|\n");
printf("|[6]插入结点|\n");
printf("|[7]删除结点|\n");
printf("|[8]链表长度|\n");
{
Node *r,*s;
int c=0,flag;
r=L;
printf("请顺序输入一串数字,以负数结束:");
while(flag)
{
scanf("%d",&c);
if(c>-1)
{
}
void output(LinkList L)//链表输出
{
Node *p;
p=L->next;
printf("Head->");
{
Node *p;
p=L;
int j=0;
if(p->next ==NULL)
printf("NULL!");
while(p!=NULL)

实验2 单链表

实验2   单链表

实验二单链表一、实验的目的和要求1.掌握线性结构的四个特点,掌握线性表的抽象数据类型描述。

2.掌握线性表的链式存储结构的特点。

头结点的作用。

3.掌握单链表的C语言的类型描述形式。

掌握这种表示形式的优缺点。

4.重点掌握单链表的基本运算的实现,对插入和删除运算能进行性能分析。

5.掌握几个典型的复杂运算,如:归并、逆置、排序等。

二、实验的内容和步骤1.建立一个单链表的头文件,文件名为Linklist.h,内容是单链表的数据类型描述和基本运算的说明(为了方便可以包括运算的实现)typedef int ElemType ; /*定义数据元素类型为整型*//*单链表的结构类型描述*/typedef struct ListNode{ElemType data ; /*存储数据元素的基地址*/struct ListNode *next ; /*指向本结点在逻辑关系下的直接后继*/} ListNode, *LinkListTp ; /*数据元素结点类型和单链表类型*//*单链表的初始化*/Status InitListLink(LinkListTp *L);/*单链表的创建,创建一个有n个数据的单链表*/Status CreatListLink(LinkListTp *L, int n,void (*Scan)(ElemType *));/*单链表的求长度*/int LengthListLink(LinkListTp L) ;/*单链表的取数据元素*/Status GetElemListLink(LinkListTp L, int i, ElemType *e) ;/*单链表的定位*/int LocateListLink(LinkListTp L, ElemType e, Status (*compare)(ElemType, ElemType)) ;/*单链表的插入*/Status InsertListLink(LinkListTp *L, int i, ElemType e) ;/*单链表的删除*/Status DeleteListLink(LinkListTp *L, int i, ElemType *e) ;/*单链表的判空*/Status EmptyListLink(LinkListTp L) ;/*单链表的清空*/void ClearListLink(LinkListTp *L) ;/*单链表的遍历,其中(*Visit)()是访问函数*/void TraverseListLink(LinkListTp L, void (*Visit)(ElemType)) ; 2.基本运算的实现,/*单链表的初始化*/Status InitListLink(LinkListTp *L){*L = (LinkListTp)malloc(sizeof(ListNode)) ;if (!*L) return OVERFLOW ;(*L)->next = NULL ;return OK ;}/*单链表的创建*/Status CreatListLink(LinkListTp *L, int n,void (*Scan)(ElemType *)) {int i ;LinkNode *p ;*L = (LinkListTp)malloc(sizeof(LinkNode)) ;(*L)->next = NULL ;for(i=n; i>0; i--){p = (LinkListTp)malloc(sizeof(LinkNode)) ;if (!p) return(OVERFLOW);Scan(&p->data) ;p->next = (*L)->next ;(*L)->next = p ;}return OK ;}/*单链表的求长度*/int LengthListLink(LinkListTp L){int i=0 ;LinkNode *p=L->next ;while(p){i++ ;p = p->next ;}return(i) ;}/*单链表的取数据元素*/Status GetElemListLink(LinkListTp L , int i, ElemType *e){int j ;LinkNode *p ;p = L ; j = 0 ;while (p->next && j<i ){p = p->next ;j++ ;}if (!p ||j>i) return ERROR ;*e = p->data ;return OK;}/*单链表的定位*/int LocateListLink(LinkListTp L , ElemType e, Status (*Compare)(ElemType, ElemType)){LinkNode *p=L->next ;int i=1 ;while (p && !Compare(p->data, e)){p = p->next ;i++;}if (p) return i ;else return 0 ;}/*单链表的插入*/Status InsertListLink( LinkListTp L , int i, ElemType e ){LinkNode *p = L, *s;int j=0 ;while (p && j<i-1){p = p->next ;j++;}if (!p||j>i-1) return ERROR ;s = (LinkNode *)malloc(sizeof(LinkNode)) ;if (!s) return(OVERFLOW) ;s->data = e ;s->next = p->next ;p->next = s ;return OK ;}/*单链表的删除*/Status DeleteListLink( LinkListTp L, int i, ElemType *e) {LinkNode *p = L, *q ;int j=0 ;while (p->next && j<i-1){p = p->next ; j++ ;}if(!(p->next)||j>i-1) return ERROR ;q = p->next ;p->next = q->next ;*e = q->data ;free(q) ;return OK ;}/*单链表的判空*/Status EmptyListLink(LinkListTp L){if (L->next==NULL) return TRUE ;else return FALSE ;}/*单链表的清空*/void ClearListLink(LinkListTp L){LinkNode *p=L->next, *q ;while(p) {q = p ;p = p->next ;free(q) ;}}/*单链表的遍历*/void TraverseListLink(LinkListTp L, void (*Visit)(ElemType)){LinkNode *p=L->next ;while(p){(*Visit)(p->data) ;p = p->next ;}printf("\n") ;}以上运算的实现均放在Linklist.h的头文件中。

单链表的实现实验报告

单链表的实现实验报告

单链表的实现实验报告篇一:数据结构单链表实验报告一、设计人员相关信息1. 设计者姓名、学号和班号:12地信李晓婧120122429832. 设计日期:2014.3. 上机环境:VC++6.0二、程序设计相关信息1. 实验题目:编写一个程序,实现单链表的各种基本运算(假设单链表的元素类型为char),并在此基础上设计一个程序,完成如下功能:(1)初始化单链表;(2)采用尾插法依次插入元素a,b,c,d,e;(3)输出单链表(4)输出单链表长度(5)判断单链表是否为空(6)输出单链表第3个元素(7)输出元素a的位置(8)在第4个元素位置上插入元素f(9)输出单链表(10)删除第三个元素(11)输出单链表(12)释放单链表2. 实验项目组成:(1)插入和删除节点操作(2)建立单链表尾插法建表(3)线性表基本运算在单链表中的实现初始化线性表销毁线性表判断线性表是否为空表求线性表的长度3. 实验项目的程序结构(程序中的函数调用关系图):4. 实验项目包含的各个文件中的函数的功能描述:? 尾插法建表CreateListR:将新节点插到当前链表的表尾上,为此必须增加一个尾指针r,使其始终指向当前链表的尾节点。

? 初始化线性表InitList:该运算建立一个空的单链表,即创建一个头节点;? 销毁线性表DestroyList:释放单链表占用的内存空间,即逐一释放全部节点的空间; ? 判断线性表是否为空表ListEmpty:若单链表没有数据节点,则返回真,否则返回假; ? 求线性表的长度ListLength:返回单链表中数据节点的个数;? 输出线性表DispList:逐一扫描单链表的每个数据节点,并显示各节点的data域值;? 求线性表中某个数据元素值GetElem:在单链表中从头开始找到第i个节点,若存在第i个数据节点,则将其data域值赋给变量e;? 按元素值查找LocateElem:在单链表中从头开始找第一个值域与e相等的节点,若存在这样的节点,则返回逻辑序号,否则返回0;? 插入数据元素ListInsert:先在单链表中找到第i1个节点*p,若存在这样的节点,将值为e的节点*s插入到*p节点的后面;? 删除数据元素ListDelete:先在单链表中找到第i1个节点*p,若存在这样的节点,且也存在后继节点*q;删除*q节点,返回TRUE;否则返回FALSE表示参数i错误。

实验二、线性表-单链表的实现

实验二、线性表-单链表的实现

实验二单链表的实现
一、实验目的
1.熟练掌握指针的使用;
2.熟练掌握使用分支语句进行决策;熟练掌握使用循环语句提高效率;
3.熟练掌握函数的使用。

4.熟练掌握链表的使用
二、实验要求
1.在上机前完成源程序;
2.能在机器上正确、调试运行程序;
3.本实验需提交实验报告。

4.实验报告文件命名方法:实验2_信管12xx_学号后两位_姓名.doc
三、实验内容和步骤
1.基于带头结点的单链表实现线性表的以下操作:
a)单链表初始化
b)插入
c)删除
d)查找
e)单链表判空
f)打印顺序表中的所有元素
g)* 删除递增有序单链表中所有值大于mink且小于maxk的元素。

h)* 将x插入到单链表的适当位置上,以保持单链表中元素的有序性。

i)* 将单链表进行就地逆置。

j)* 将两个单链表表合并为一个单链表。

k)* 若两个元素按值递增有序排列的单链表A和B,且同一表中的元素值各不相同。

试构造一个单链表C,其元素为A和B中元素的交集,且表
C中的元素也按值递增有序排列。

l)* 删除第i个开始的k个元素。

2.备份自己程序。

三、实验成绩考核方法
成绩考核方法主要为:
教师抽查部分学生,让他们演示自己写的程序。

教师提出问题,确定学生对程序的把握程度和熟练程度。

实验二 单链表基本操作

实验二  单链表基本操作

实验二单链表基本操作一、实验目的1.掌握握单链表的基本操作:新建、插入、删除、查找等运算。

二、实验要求1.认真阅读和掌握本实验的程序。

2.上机运行本程序。

3.保存和打印出程序的运行结果,并结合程序中的问题进行分析。

三、实验内容单链表基本操作的实现,这个程序中演示了单链表的创建、插入、删除和查找。

程序如下:#include<malloc.h>typedef struct node{int data;struct node *next;} NODE;/******************************************/NODE *Create()//问题1:该函数创建的带头结点的单链表,还是不带头结点的单链表?{NODE *p,*head;int x;head=(NODE *)malloc(sizeof(NODE));head->next=NULL;printf("Input data,-1 to End!\n");scanf("%d",&x);while(x!=-1){p=(NODE *)malloc(sizeof(NODE));p->data=x;p->next=head->next;head->next=p;scanf("%d",&x);}return(head);}/******************************************/void Output(NODE *head){NODE *p;p=head;printf("Begin to dump the LinkList...\n");while(p->next!=NULL){printf("->%d",p->next->data);p=p->next;}printf("\nThe LinkList ended!\n");}/******************************************/int Listlen(NODE *head){int i=0;NODE *p=head;while(p->next!=NULL){i++;p=p->next;}return(i);}/******************************************/int Get(NODE *head,int i)//问题2:将该函数修改成返回第i个元素的指针,若不存在,返回空{int j=0;NODE *p=head;while(p->next&&j<i){j++;p=p->next;}if(!p->next||j>i) return(0);else return(p->data);}/******************************************/void Del(NODE *head,int i){NODE *p=head;int j=0;while(p->next&&j<i-1){j++;p=p->next;}if(!p->next||j>i-1) printf("the position is wrong\n");elsep->next=p->next->next;}/******************************************/void Ins(NODE *head,int i,int e){NODE *p=head,*q;int j=0;while(p->next&&j<i-1){j++;p=p->next;}if(!p->next&&j>i-1) printf("Wrong position\n" );else{q=(NODE *)malloc(sizeof(NODE));q->data=e;q->next=p->next;p->next=q;}}/******************************************/main(){NODE *head;int length;int i,element;head=Create();Output(head);//以下函数调用(求长度、插入、删除、查找)能否改成菜单形式?如何改?length=Listlen(head);printf("the length of the link is %d\n",length);printf("input the order :\n");scanf("%d",&i);element=Get(head,i);printf("the element of the order is %d\n",element);printf("input the del position \n");scanf("%d",&i);Del(head,i);Output(head);printf("Input the insert posion and element:\n");scanf("%d%d",&i,&element);Ins(head,i,element);Output(head);}}。

实验报告二——单链表

实验报告二——单链表
三、源程序及注释:
#include <stdio.h>
#include <stdlib.h>
//单链表的定义:
typedef int DataType;//DataType可以是任何相应的数据类型如int, float或char
typedef struct node//结点类型定义
{DataType data;//结点的数据域
struct node *next;//结点的指针域
}ListNode;
typedef ListNode *LinkList;
int a[10];
void main()
{
int i;
DataType key;
DataType x;
LinkList head;
ListNode *p;
LinkList CreateList(void);//单链表的建立
从键盘输入2个整数一个表示欲插入的位置i另一个表示欲插入的数值x从键盘输入1个整数表示欲删除结点的位巻输出单链表所有结点值观链表中含有原链表中序号为奇数的元链表中含有原链表中序号为偶数的元素且保持原来的相对顺序分别输出单链和单链表b的所有结点值观察输出结果
《数据
实验二—单链表
分校:上海第二工业大学
班级:09安全01
p->next=s;
}
//单链表的删除:
void DeleteList(LinkList head,int i)
{
ListNode *p,*r;
int j;
p=head;j=1;
while(p&&j<i-1)
{
p=p->next;
j++;

实验二 链表操作实现

实验二 链表操作实现

实验二链表操作实现实验日期:2017 年 3 月16 日实验目的及要求1. 熟练掌握线性表的基本操作在链式存储上的实现;2. 以线性表的各种操作(建立、插入、删除、遍历等)的实现为重点;3. 掌握线性表的链式存储结构的定义和基本操作的实现;4. 通过本实验加深对C语言的使用(特别是函数的参数调用、指针类型的应用)。

实验内容已知程序文件linklist.cpp已给出学生身高信息链表的类型定义和基本运算函数定义。

(1)链表类型定义typedef struct {int xh; /*学号*/float sg; /*身高*/int sex; /*性别,0为男生,1为女生*/} datatype;typedef struct node{datatype data; /*数据域*/struct node *next; /*指针域*/} LinkNode, *LinkList;(2)带头结点的单链表的基本运算函数原型LinkList initList();/*置一个空表(带头结点)*/void createList_1(LinkList head);/*创建单链表*/void createList_2(LinkList head);/* 创建单链表*/void sort_xh(LinkList head);/*单链表排序*/void reverse(LinkList head);/*对单链表进行结点倒置*/void Error(char *s);/*自定义错误处理函数*/void pntList(LinkList head);/*打印单链表*/void save(LinkList head,char strname[]);/*保存单链表到文件*/任务一创建程序文件linklist.cpp,其代码如下所示,理解LinkList类型和基本运算函数后回答下列问题。

#include <stdio.h>#include <stdlib.h>/*单链表结点类型*/typedef struct {int xh; /*学号*/float sg; /*身高*/int sex; /*性别,0为男生,1为女生*/} datatype;typedef struct node{datatype data; /*数据域*/struct node *next; /*指针域*/} LinkNode, *LinkList;/*带表头的单链表的基本运算函数*/LinkList initList();/*置一个空表(带头结点)*/void createList_1(LinkList head);/*创建单链表*/void createList_2(LinkList head);/*创建单链表*/void sort_xh(LinkList head);/*单链表排序*/void reverse(LinkList head);/*单链表倒置*/void Error(char *s);/*自定义错误处理函数*/void pntList(LinkList head);/*打印单链表*/void save(LinkList head,char strname[]);/*保存单链表到文件*//*置一个空表*/LinkList initList(){ LinkList p;p=(LinkList)malloc(sizeof(LinkNode));p->next=NULL;return p;}/*创建单链表*/void createList_1(LinkList head){ FILE *fp;int xh;float sg;int sex;LinkList p;if((fp=fopen("records.txt","r"))==NULL){ Error("can not open file !");return ;}while(!feof(fp)){ fscanf(fp,"%d%f%d",&xh,&sg,&sex);p=(LinkList)malloc(sizeof(LinkNode));p->data.xh=xh;p->data.sg=sg;p->data.sex=sex;p->next=head->next;head->next=p;}fclose(fp);}/*创建单链表*/void createList_2(LinkList head){ FILE *fp;int xh;float sg;int sex;LinkList p,rear;if((fp=fopen("records.txt","r"))==NULL){ Error("can not open file !");return ;}rear=head;while(!feof(fp)){ fscanf(fp,"%d%f%d",&xh,&sg,&sex);p=(LinkList)malloc(sizeof(LinkNode));p->data.xh=xh;p->data.sg=sg;p->data.sex=sex;p->next=NULL;rear->next=p;rear=p;}fclose(fp);}/*单链表排序*/void sort_xh(LinkList head){LinkList q,p,u;p=head->next;head->next=NULL;/*利用原表头结点建新的空表*/while(p){ q=p; /*q为被插入的结点*/p=p->next;/*用p记录后继结点*//*遍历新链表查找插入位置*/u=head;while(u->next!=NULL)/*查找插入位置*/{ if(u->next->data.xh>q->data.xh)break;u=u->next;}/*插入在u结点的后面*/q->next=u->next;u->next=q;}}/*单链表倒置*/void reverse(LinkList head){ LinkList p, r;p=head->next;head->next=NULL;while(p){ r=p;p=p->next;/*r指向结点头插到链表*/r->next=head->next;head->next=r;}}/*输出单链表*/void pntList(LinkList head){ LinkList p;p=head->next;while(p!=NULL){printf("%2d: %.2f %d\n",p->data.xh,p->data.sg,p->data .sex);p=p->next;}}/*自定义错误处理函数*/void Error(char *s){ printf("\n %s", s);exit(1); /*返回OS,该函数定义在stdlib.h中*/}/*保存单链表到文件*/void save(LinkList head,char strname[]){ FILE *fp;LinkList p;if((fp=fopen(strname,"w"))==NULL){ printf("can not open file !");return ;}p=head->next;while(p!=NULL){ fprintf(fp,"%2d %5.2f %2d\n",p->data.xh,p->data.sg,p->data.sex);p=p->next;}fclose(fp);}请回答下列问题:(1)由单链表结点类型定义可知,该链表结点类型名为 LinkNode ,结点的指针类型为 LinkList ,向系统申请一个学生结点空间并把起始地址存于上述结点指针变量new 中的语句是: p=(LinkList)malloc(sizeof(LinkNode)); 。

实验二

实验二

实验二、链表基本操作
一、实验目的
1.掌握链表的概念,学会对链表进行操作。

2.加深对链式存储结构的理解,逐步培养解决实际问题的能力。

二、实验内容
(1)编写链表基本操作函数
●创建一个包含n个结点的单链表,要求返回头指针;
CreateList_L(LinkList &L,int n)
●在单链表中数据元素值为a的结点前插入值为b的结
点,要求如果值为a的结点不存在,则插在表尾;
InsertList_L(LinkList &L, char a,char b)
●在单链表中删除数据元素值为c的结点,要求如果存
在,则返回1,否则返回0;
DeleteList_L(LinkList &L,char c)
注意:每完成一个步骤,必须及时输出链表元素,便于观察操作结果。

(2)用主函数调用上述函数,实现相应功能。

三、实验要求
1.C完成算法设计和程序设计并上机调试通过。

2.撰写实验报告,提供实验结果和数据。

3.分析算法,简要给出算法设计小结和心得。

四、程序运行情况
写出输入数据及运行结果五、源程序清单。

实验二:单链表基本运算实现

实验二:单链表基本运算实现
typedef struct node
{
int data; //存放表结点值
struct node *next; //存放表结点的直接后驱元素的地址
} ListNode,*LinkList;
//头插法创建初始链表
LinkList create_h(int size)
{
;//将工作指针p指向后一个结点
;//计数器累加
}
return i;
}
//打印链表中的现有元素
printList(LinkList head)
{
LinkList p;
;//将工作指针p指向第1个结点
{
p=(LinkList)malloc(sizeof(ListNode));//申请新结点的存储空间
scanf("%d",&p->data);//读入新结点的值到data域中
;//将新增结点插到头结点的后面
;//将新增结点插到头结点的后面
printf("————头插法建立链表(1)\n");
printf("————尾插法建立链表(2)\n");
printf("————按位查找元素(3)\n");
printf("————按值查找元素(4)\n");
printf("————插入元素(5)\n");
printf("————删除元素(6)\n");
printList(h);
break;
case 5:
printf("插入元素,请输入要插入元素的值:\n");

数据结构实验报告单链表

数据结构实验报告单链表

数据结构实验报告_单链表数据结构实验报告——单链表一、实验目的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.实验结果:通过运行上述代码,我们可以看到单链表的基本操作得到了实现。

数据结构 实验二:单链表的基本操作

数据结构 实验二:单链表的基本操作

数据结构实验二:单链表的基本操作数据结构实验二:单链表的基本操作实验二:单链表的基本操作一、【实验目的】1、理解和掌握单链表的类型定义方法和结点生成方法。

2、掌握建立单链表和显示单链表元素的算法。

3、掌握单链表的查找、插入和删除算法二、【实验内容】1、建立一个整形数的单链表,手动输入10个数,并从屏幕显示单链表元素列表。

2、从键盘输入一个数,查找在以上创建的单链表中是否存在该数;如果存在,显示它的位置;如果不存在,给出相应提示。

3、删除上述单链表中指定位置的元素。

以下就是程序部分代码,恳请调试并补足并使之恰当运转:1.linlist.htypedefstructnode{datatypedata;structnode*next;}slnode;voidlistinitiate(slnode**head)/*初始化*/{/*如果有内存空间,申请头结点空间并使头指针head指向头结点*/if((*head=(slnode*)malloc(sizeof(slnode)))==null)exit(1);(*head)->next=null;/*置链尾标记null*/}intlistlength(slnode*head){slnode*p=head;/*p指向首元结点*/intsize=0;/*size初始为0*/while(p->next!=null)/*循环计数*/{p=p->next;size++;}returnsize;}intlistinsert(slnode*head,inti,datatypex)/*在带头结点的单链表head的数据元素ai(0≤i≤size)结点前*//*填入一个存放数据元素x的结点*/{slnode*p,*q;intj;p=head;/*p指向首元结点*/j=-1;/*j起始为-1*/while(p->next!=null&&j<i-1)/*最终让指针p指向数据元素ai-1结点*/{p=p->next;j++;}if(j!=i-1){printf(\填入边线参数弄错!\return0;}/*生成新结点由指针q指示*/if((q=(slnode*)malloc(sizeof(slnode)))==null)exit(1);q->data=x;q->next=p->next;/*给指针q->next赋值*/p->next=q;/*给指针p->next重新赋值*/return1;}intlistdelete(slnode*head,inti,datatype*x)/*删除带头结点的单链表head的数据元素ai(0≤i≤size-1)结点*//*删除结点的数据元素域值由x带回。

实验二_单链表的实现及测试

实验二_单链表的实现及测试

if(p!=null) { s=p->next; p->next=s->next; free(s); print(head,i-1); } else printf("not find i\n"); } node *get(node*head,datatype i) {node *p p=head->next; while((p!=null)&&(conter<i)) {p=p->next; counter++; } if((p!=null)&&(conter==i)) return p; else return null; } void print(node*head,datatype i) {int k; for(k=0;k<i;k++) printf("%6d",head*datd[k]); printf("\n"); } void main() { node *v; }
: 学号: 日期:
实验要求:
1. 给出程序设计的基本思想、原理和算法描述。 2. 画出程序流程图;根据数据结构有关知识编出算法程序。 3. 源程序给出注释。 4. 保存和打印出程序的运行结果,并结合程序进行分析。
实验内容:
1. 编写函数实现单链表的基本运算 (1) 单链表的生成 (2) 单链表的插入 (3) 单链表的删除 2. 编写主函数测试单链表的各种基本运算: (1) 生成一个单链表,链表中的元素由计算机输入 (2) 在表中的第5个位置上插入元素”7” (3) 删除表中的第6个元素 (4) 显示(1)—(4)每一步的操作结果 #include<stdio.h> #include<stdlib.h> #include<malloc.h> typedef int datatype; typedef struct node{ datetype data; struct node *next;} node; node *creatlink(); node *inseart(node*head,datdtype i,datatype x);

实验二 单链表操作(C++)

实验二 单链表操作(C++)

实验二单链表操作实验目的1.会定义单链表的结点类型。

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

3.了解和掌握单链表的类定义以及成员函数的定义与调用格式。

实验要求1.认真阅读和掌握本实验内容所给的全部程序。

2.从本实验内容中任选一个程序上机运行。

3.保存和打印出程序运行结果,并结合程序进行分析。

4.按照你对单链表操作的需要,重新改写主文件并运行,打印出主文件清单和运行结果。

当然也可以根据你的需要改写或增删进行单链表操作的函数。

实验内容下面程序用来实现单链表的定义和操作,程序由头文件、实现文件和主文件所组成。

程序中的单链表采用类的定义,操作函数为类中的成员函数,单链表中每个结点的值为整型。

//链表类.htypedef int ElemType;struct sNode{ElemType data;sNode* next;};class ListClassLink{struct sNode *Head;public:ListClassLink(void);ElemType GetElemList(int pos);bool FindList(ElemType& item);bool ModifyList(const ElemType& item);void InsertList(ElemType item);bool DeleteList(ElemType item);bool EmptyList(void);int LenthList(void);void OutputList(void);~ListClassLink(void);};//链表类实现文件.cpp#include<iostream.h>#include<stdlib.h>#include"链表类.h"ListClassLink::ListClassLink(void){sNode* np=new sNode;Head=np;np->next=NULL;}ElemType ListClassLink::GetElemList(int pos){ if(pos<1){cerr<<"pos is out range!"<<endl;exit(1);}int n=0;sNode *p=Head->next;while(p!=NULL){n++;if(n==pos)break;p=p->next;}if(p!=NULL)return p->data;else{cerr<<"pos 值无效!"<<endl;exit(1);}}bool ListClassLink::FindList(ElemType& item){ sNode *p=Head->next;while(p!=NULL){if(p->data==item)break;else p=p->next;}if(p!=NULL){item=p->data;return true;}else return false;}bool ListClassLink::ModifyList(const ElemType& item){ sNode *p=Head->next;while(p!=NULL){if(p->data==item)break;else p=p->next;}if(p!=NULL){p->data=item;return true;}else return false;}void ListClassLink::InsertList(ElemType item){ sNode *newp=new sNode;newp->data=item;sNode *q=Head,*p=q->next;newp->next=p;q->next=newp;}bool ListClassLink::DeleteList(ElemType item){ sNode *p=Head->next,*q=p;while(p!=NULL){if(p->data==item)break;else{q=p;p=p->next;}}if(p==NULL)return false;else q->next=p->next;delete p;return true;}bool ListClassLink::EmptyList(void){return Head->next==NULL;}int ListClassLink::LenthList(void){int n=0;sNode *p=Head->next;while(p!=NULL){n++;p=p->next;}return n;}void ListClassLink::OutputList(void){sNode *p=Head->next;while(p!=NULL){cout<<p->data<<' ';p=p->next;}cout<<endl;}ListClassLink::~ListClassLink(void){sNode *p=Head->next,*q;while(p!=NULL){q=p->next;delete p;p=q;}Head->next=NULL;}//链表类主文件.cpp#include<iostream.h>#include<stdlib.h>#include"链表类实现文件.cpp"void main(){int c1[8]={23,45,62,78,94,40,83,62};int c2[7]={36,78,48,23,78,90,78};ListClassLink a,b;for(int i=0;i<8;i++)a.InsertList(c1[i]);a.OutputList();for(i=0;i<7;i++)b.InsertList(c2[i]);b.OutputList();cout<<a.LenthList()<<' '<<a.EmptyList()<<endl;cout<<b.LenthList()<<' '<<b.EmptyList()<<endl;cout<<a.GetElemList(4)<<' '<<b.GetElemList(4)<<endl;int x=94;if(a.FindList(x)) cout<<"Yes"<<endl;else cout<<"No"<<endl;if(b.ModifyList(90)) cout<<"Yes"<<endl;else cout<<"No"<<endl;}。

实验二 单链表操作

实验二 单链表操作

注意事项:在磁盘上创建一个目录,专门用于存储数据结构实验的程序。

因为机房机器有还原卡,请同学们将文件夹建立在最后一个盘中,以学号为文件夹名。

实验二单链表操作一、实验目的掌握单链表的基本操作:插入、删除、查找等运算。

二、实验要求1.认真阅读和掌握单链表相关操作的算法。

2.将操作函数的算法转成程序并运行(将函数剩余部分补齐)。

三、实验内容程序1:线性单链表基本操作的实现(以带头结点的单链表为例)实现单链表的创建、插入、删除和查找。

参考程序如下:#include<iostream.h>#include<malloc.h>#include<conio.h>#define ERROR 0#define OK 1typedef int ElemType;struct LNODE{ElemType data;struct LNODE *next;};typedef struct LNODE LNode;typedef struct LNODE *LinkList;//初始化单链表int init(LinkList &L){L=(LNode *)malloc(sizeof(LNode));if(!L) return(ERROR);L->next=NULL;return OK;}/*init *///求表长int ListLength(LinkList L){}//获取表中第i个元素的值int GetElem(LinkList L,int i,ElemType &e) {}//确定元素e在该链表中的位序int LocateElem(LinkList La,ElemType e){LinkList p;p=La;int i=0;while(p->next){p=p->next;i++;if(p->data==e)return i;}return 0;}//打印表中元素值void PrintList(LinkList L){LinkList p;p=L;while(p->next){p=p->next;cout<<p->data<<ends;}cout<<endl;}//插入操作int ListInsert(LinkList &L,int i,ElemType e) {}/*ListInsert Before i *///删除操作Int ListDelete(LinkList &L,int i,ElemType &e) {}//建表(头插法或尾插法都可)int CreateList(LinkList &L,int n){}//合并两个有序表void MergeList(LinkList La,LinkList Lb,LinkList &Lc){}void main(){LinkList La,Lb,Lc;ElemType e;cout<<"\n\n-------------------List Demo is running...----------------\n\n";cout<<"First is InsertList function.\n";init(La);int n;cout<<"请输入La表中元素个数:";cin>>n;cout<<endl<<"请输入"<<n<<"个元素值:";CreateList(La,n);PrintList(La);cout<<"La的表长为:"<<ListLength(La)<<endl;//取值cout<<"取第i位元素的值:\n请输入位序:";cin>>n;GetElem(La,n,e);cout<<endl<<"第"<<n<<"位元素的值为:"<<e<<endl;//定位cout<<"定位操作:\n请输入要查找的元素:";cin>>e;cout<<endl<<" 所要查找的元素在表中第"<<LocateElem(La,e)<<"位\n"; //删除cout<<"删除操作:\n输入要删除元素的位序:";cin>>n;ListDelete(La,n,e);cout<<"\n要删除的元素值为:"<<e<<endl;cout<<"删除后表中值有:"PrintList(La);init(Lb);cout<<"请输入Lb表中元素个数:";cin>>n;cout<<endl<<"请输入"<<n<<"个元素值:";CreateList(Lb,n);PrintList(Lb);cout<<"Lb的表长为:"<<ListLength(Lb)<<endl; cout<<"合并两个有序表:\n";MergeList(La,Lb,Lc);PrintList(Lc);getch();}。

实验二 单链表操作

实验二 单链表操作

实验二单链表操作一、实验目的1.掌握握单链表的基本操作:插入、删除、查找等运算。

二、实验要求1.认真阅读和掌握本实验的程序。

2.上机运行本程序。

3.保存和打印出程序的运行结果,并结合程序进行分析。

4.按照你对单链表的操作需要,重新改写主程序并运行,打印出文件清单和运行结果三、实验内容单链表基本操作的实现四、实验步骤1、定义单链表的结构typedef struct Lnode{int *base;int *top;int stacksize;} *LinkList;2、定义单链表的几个常用操作:单链表的创建、插入、删除和查找。

void CreateList_L(LinkList &L,int n){L=(LinkList)malloc(sizeof(LNode));L->next=NULL;LNode *p;printf("请输入%d个元素\n",n);for(int i=n;i>0;--i){p=(LinkList)malloc(sizeof(LNode));scanf("%d",&p->data);p->next=L->next;L->next=p;}}单链表插入,删除和查找int ListInsert_L(LinkList &L,int i,int e){//找到第i-1个元素,让p指向它LNode *p=L;int j=0;while(p&&j<i-1){p=p->next;j++;}//没有找到的情况,i<1或者i>表长if(!p||j>i-1)return -1;//为新结点申请内存LNode *s=(LinkList)malloc(sizeof(LNode));s->data=e;//插入新结点s->next=p->next;p->next=s;return 1;}3、编写主函数测试单链表的操作void main(){LinkList L;int length;printf("输入你要创建单链表的长度\n");scanf("%d",&length);CreateList_L(L,length);Output(L);length=Listlen(L);printf("单链表的长度是:%d\n",length);int i;ElemType element;printf("输入你要查找的元素的位置:\n");scanf("%d",&i);GetElem_L(L,i,element);printf("第%d个元素的值是: ",i);printf(" %d\n",element);printf("输入你要插入的元素的位置:\n");scanf("%d",&i);printf("输入你要插入的元素的值:\n");scanf("%d",&element);ListInsert_L(L,i,element);printf("插入后的线性表是: ");Output(L);printf("输入你要删除的元素的位置:\n");scanf("%d",&i);ListDelete_L(L,i,element);printf("删除后的线性表是: ");Output(L);五、实验总结:附录:完整程序#include<malloc.h>#include <stdio.h>typedef int ElemType; //定义数据元素的类型为int,你也可以在这里把它改成其它数据类型//单链表结点的定义typedef struct LNode{int *base;int *top;int stacksize;} *LinkList;/*创建单链表*****************************************/void CreateList_L(LinkList &L,int n){L=(LinkList)malloc(sizeof(LNode));L->next=NULL;LNode *p;printf("请输入%d个元素\n",n);for(int i=n;i>0;--i){p=(LinkList)malloc(sizeof(LNode));scanf("%d",&p->data);p->next=L->next;L->next=p;}}/*输出单链表*****************************************/void Output(LinkList &L){//……//部分代码printf("开始输出单链表各个元素\n");//……printf("\n单链表结束!\n");}/*单链表的长度*****************************************/int Listlen(LinkList &L){//1、分配内存L.elem=(ElemType *)malloc(LIST_INIT_SIZE*sizeof(ElemType));if(!L.elem)//申请内存失败的情况exit(OVERFLOW);L.length=0; //线性表的长度L.listsize=LIST_INIT_SIZE;//线性表L的容量return OK;}/*得到单链表中第i个元素的值*****************************************/ int GetElem_L(LinkList &L,int i,ElemType &e){}/*删除第i个元素*****************************************/int ListDelete_L(LinkList &L,int i,ElemType &e)/*在第i个位置上插入一个新的元素*****************************************/int ListInsert_L(LinkList &L,int i,ElemType e){//1、判断插入位置i是不是正确if(i<1||i>L.length+1)return ERROR;//2、判断线性表的存储空间是否已满if(L.length>=L.listsize){//满则追加内存ElemType *newbase=(ElemType *)realloc(L.elem,(L.listsize+LISTINCREMENT)*sizeof(ElemType) );//判断申请内存是否成功if(!newbase)//申请失败exit(OVERFLOW);//申请成功L.elem=newbase;L.listsize+=LISTINCREMENT;}//从第n个元素至第i个元素依次向后移动一个位置ElemType * q= &(L.elem[i-1]);//用q保存第i个元素的地址ElemType *p=&(L.elem[L.length-1]);//用p保存第n个元素的地址for( ;p>=q;--p){*(p+1)=*p;}*q=e;//将q插入到第i个位置++L.length;return OK;}/******************************************/void main(){LinkList L;int length;printf("输入你要创建单链表的长度\n");scanf("%d",&length);CreateList_L(L,length);Output(L);length=Listlen(L);printf("单链表的长度是:%d\n",length);int i;ElemType element;printf("输入你要查找的元素的位置:\n");scanf("%d",&i);GetElem_L(L,i,element);printf("第%d个元素的值是: ",i);printf(" %d\n",element);printf("输入你要插入的元素的位置:\n");scanf("%d",&i);printf("输入你要插入的元素的值:\n");scanf("%d",&element);ListInsert_L(L,i,element);printf("插入后的线性表是: ");Output(L);printf("输入你要删除的元素的位置:\n");scanf("%d",&i);ListDelete_L(L,i,element);printf("删除后的线性表是: ");Output(L);}。

《数据结构》实验指导实验二单链表的存储及操作

《数据结构》实验指导实验二单链表的存储及操作

《数据结构》实验指导实验二:单链表的存储及操作一、实验目的1、掌握单链表抽象数据类型的定义。

2、掌握单链表的存储实现。

3、掌握单链表的操作算法实现。

4、了解单链表的应用。

二、实验学时2学时三、实验类型验证性实验四、实验需求1、硬件每位学生配备计算机一台;2、软件Windows XP/ Windows 7 操作系统;开发工具软件:Microsoft Visual Studio 2010。

五、实验理论与预备知识1、数据结构的基本概念2、顺序存储结构的特点3、线性表的特点和基本运算4、线性表顺序存储结构下的操作算法六、实验任务1、单链表抽象数据类型的代码实现2、编写应用程序,用相关数据验证运算算法七、实验内容及步骤1、任务一:有一个单链表对象L,设计一个算法查找最后一个值为x 的结点的逻辑序号。

并分析算法的时间和空间复杂度。

实验步骤: (1)启动Visual Studio 2010,创立窗体应用程序。

(2) 增加单链表类,代码参考如下:public class LinkList(public string data; public LinkList next;}; class LinkListClasspublic LinkList head = new LinkList();〃单链表头结点//-单链表的基本运算算法public void CrcatcListF(string[] split) 〃头插法建立单链表 {LinkList s;int i;=null;〃将头结点的next 字段置为null for (i = 0; i < h; i++)〃循环建立数据结点{s = new LinkList();s.data = split[i];〃创立数据结点ss.next =; 〃将s 结点插入到开始结点之HU,头结点之后public void CrcatcListR(string[] split) 〃尾插法建立单链表{LinkList s, r;int i;r = head;//r 始终指向尾结点,开始时指向头结点for (i = 0; i < h; i++) 〃循环建立数据结点{s = new LinkList();s.data = splitfi];〃创立数据结点s r.next = s;〃将s 结点插入r 结点之后r.next = null;〃将尾结点的next 字段置为null〃定义单链表结点类〃存放数据元素//指向下一个结点的字段string str = LinkList p; P =;//p 指向开始结点if (p == null) str ="空串"; while (p != null)//p 不为null,输出p 结点的data 字段str += p.data + " p =p.next; 〃p 移向下一个结点 return sir;1public int ListLength() 〃求单链表数据结点个数int n = 0;LinkList p; p = head; //p 指向头结点,n 置为0(即头结点的序号为0)while (p.next != null) (n++;p = p.next; }return (n);〃循环结束,p 指向尾结点,其序号n 为结点个数public bool GetElem(int i, ref string e) 〃求单链表中某个数据元素值 {intj = O;LinkList p;p = head; while (j < i && p != null) //p 指向头结点,j 置为0(即头结点的序号为0) 〃找第i 个结点pj++; p = p.next;}if (p == null) return false; 〃不存在第i 个数据结点,返回falseelse//存在第i 个数据结点,返回true c = p.data; return true;public int LocateElcm(string c)int i= 1;LinkList p;p = ;〃p 指向开始结点,i 置为1(即开始结点的序号为1)while (p != null && p.data != e) 〃查找data 值为e 的结点,其序号为i {p = p.next; i++; }if (p == null)//不存在元素值为e 的结点,返回0return (0);public stringDispList()〃将单链表所有结点值构成一个字符串返同//按元素值查找else〃存在元素值为e的结点,返回其逻辑序号ireturn (i);} _public bool Listlnsert(int i, string e) //插入数据元素{ int j = 0;LinkList s, p;if(i< 1)//i<l 时i 错误,返回falsereturn false;p = head;//p指向头结点,j置为0(即头结点的序号为0) while (j < i - 1 && p != null)〃查找第i-1 个结点{j++;p = p.next;}if(p ==null)〃未找到第i-l个结点,返回falsereturn false;else〃找到第i-l个结点p,插入新结点并返回true(s = new LinkList();s.data = e;〃创立新结点s,其data字段置为es.ncxt = p.next;〃将s结点插入到p结点之后p.next = s;return true;}}public bool ListDele(e(inl i, ref string e) 〃删除数据元素{ int j = 0;LinkList q, p;if (i < 1)〃ivl 时i 错误,返回falsereturn false;p = head;//p指向头结点j置为0(即头结点的序号为0) while (j < i - 1 && p != null)//查找第i-l 个结点j++;public int Findlast(LinkListClass L. stringx)LinkList p = L.; inti = O,j = i; while (p != null)i++;if (p.data == x) j = i ;p = p.next; return j;}(3)设计窗体,界面参考如下:p =p.ncxt;if (p == null) return false; else 〃未找到第i-1个结点,返回fa lse〃找到第i-1个结点p q = p.next; if (q == null) return false; c = q.data; p.next= q.next;q = null; return true; 〃q 指向第i 个结点〃假设不存在第i 个结点,返回false〃从单链表中删除q 结点〃释放q 结点〃返回(rue 表示成功删除第i 个结点(4) 编写窗体中按钮等控件的代码,调用单链表类,参考如下:LinkListClass L = new LinkListClassO;private〃单链表Lvoid Forml_Load(object sender, Event Args e)(=”2,3,1,5,6,2,3,8”;}private void buttonl_Click(object sender, Event Args e)(string str = .Trini();if (str ===”操作提示:必须输入元素”;else{string[] split = (new Char[] {'});L.CreateListR(split);ed = false;ed = true;=”操作提示:成功创立单链表”;}}private void button2_Click(object sender, Event Args e)(int i;string elem;elem =;i = L.Findlast(L, elem);if(i == 0)=”操作提示:在单链表中没有找到该元素”;else=i.ToStringO;=”操作提示:在单链表中找到该元素”;(5)选择【调试】—►【开始执行(不调试)】命令或按【CtH+F5】组合键运行程序,并观察运行情况。

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

上海电力学院计算机软件技术实验实验报告实验题目:单链表的实现及测试院系:自动化工程学院专业年级:自动化2013级学生姓名:晁文涛学号20131529实验二单链表的基本算法一.实验目的:通过上机编程掌握1.生成单链表的基本算法;2.在单链表上的插入、删除运算。

二.实验要求:1. 给出程序设计的基本思想、原理和算法描述。

2. 画出程序流程图;根据数据结构有关知识编出算法程序;3. 源程序给出注释;4. 保存和打印出程序的运行结果,并结合程序进行分析。

三.实验内容:1.编写函数实现单链表的基本运算:(1)单链表的生成反向建立链表(头插法)思想:首先生成头结点,形成一个空链表,然后在表中逐一读入新的结点,反复执行下列步骤:使用malloc函数开辟新结点的存储单元;将读入数据存放到新结点的数据域中;将新结点插入到当前链表的表头上,直到读入结束标志为止。

流程图为:NODE *creatlink1() //头插法{NODE *head,*s;int x;head=(NODE*)malloc(sizeof(NODE)); //生成头结点head->next=NULL;scanf("%d",&x); //读入第一个结点值while(x!=0){s=(NODE*)malloc(sizeof(NODE));s->data=x;s->next=head->next;head->next=s; //将新节点插入到表头上scanf("%d",&x);}return head;}正向建立单链表(尾插法)思想:首先生成头结点,依次读入线性表的元素,从前往后依次将元素插入到当前链表的最后一个结点之后。

流程图为:具体算法为:Array NODE *creatlink2() //尾插法{NODE *head,*p,*s;int num;head=(NODE*)malloc(sizeof(NODE));//生成头结点scanf("%d",&num); //读入第一个结点值p=head; //头指针等于尾指针while (num!=0) //输入0作为结束符{s=(NODE*)malloc(sizeof(NODE));//生成新节点s->data=num; //新结点上填入输入值p->next=s; //新结点*s插入到尾结点*p之后p=s; //尾指针指向新的表尾scanf("%d",&num); //读入下一个结点值}p->next=NULL; //将尾结点的指针置空return head; //返回单链表表头指针}(2)单链表的插入思想:首先要搜索单链表以找到指定插入结点的前趋结点p;然后改变链接,即只要是将待插入结点的指针域内容赋予p结点的指针域即可。

流程图为:具体算法为:Array NODE *get(NODE *head,int i) //查找第i个元素的位置{NODE *p;int counter=1;p=head->next;while((p!=NULL)&&(counter<i)){p=p->next;counter++;}if((p!=NULL)&&(counter==i)) //找到,1<=i<=nreturn p;elsereturn NULL; //找不到,i>n或i<=n}void insertafter(NODE *p,int x){NODE *s;s=(NODE*)malloc(sizeof(NODE)); //修改i-1结点的尾指针s->data=x;s->next=p->next;p->next=s;}void insert(NODE *head,int i,int x) //在i个位置插入x{NODE *p;int j=i-1;p=get(head,j); //调用查找函数找到i-1的结点位置if(p==NULL)printf("error");elseinsertafter(p,x); //调用insertafter函数}(2)单链表的删除思想:首先要搜索单链表以找到指定删除结点的前趋结点p;然后改变链接,即只要是将待删除结点的指针域内容赋予p结点的指针域即可。

流程图为:void delete(NODE *head,int i) //删除第i个位置的元素{NODE *p,*s;int j=0;p=head;while((p->next!=NULL)&&(j<i-1)) //查找第i个元素的结点{p=p->next;j++;}if((p->next==NULL)||(j>i-1))printf("i值不合法\n");else{s=p->next; //修改p->next,使指向s->nextp->next=s->next; //删除s结点free(s);}}2.编写主函数测试单链表的各种基本运算:(1)生成一个至少包含有5个元素的单链表,元素值由计算机输入(2)在表中的第5个位置上插入元素”7”(3)删除表中的第6个元素(4)显示(1)—(3)每一步的操作结果源程序为:#include <stdio.h>#include <malloc.h>typedef int datatype;typedef struct node{ datatype data;struct node *next;}NODE;NODE *creatlink1() //头插法{NODE *head,*s;int x;head=(NODE*)malloc(sizeof(NODE)); //生成头结点head->next=NULL;scanf("%d",&x); //读入第一个结点值while(x!=0){s=(NODE*)malloc(sizeof(NODE));s->data=x;s->next=head->next;head->next=s; //将新节点插入到表头上scanf("%d",&x);}return head;}NODE *creatlink2() //尾插法{NODE *head,*p,*s;int num;head=(NODE*)malloc(sizeof(NODE));//生成头结点scanf("%d",&num); //读入第一个结点值p=head; //头指针等于尾指针while (num!=0) //输入0作为结束符{s=(NODE*)malloc(sizeof(NODE));//生成新节点s->data=num; //新结点上填入输入值p->next=s; //新结点*s插入到尾结点*p之后p=s; //尾指针指向新的表尾scanf("%d",&num); //读入下一个结点值}p->next=NULL; //将尾结点的指针置空return head; //返回单链表表头指针}NODE *get(NODE *head,int i) //查找第i个元素的位置{NODE *p;int counter=1;p=head->next;while((p!=NULL)&&(counter<i)){p=p->next;counter++;}if((p!=NULL)&&(counter==i)) //找到,1<=i<=nreturn p;elsereturn NULL; //找不到,i>n或i<=n}void delete(NODE *head,int i) //删除第i个位置的元素{NODE *p,*s;p=head;while((p->next!=NULL)&&(j<i-1)) //查找第i个元素的结点{p=p->next;j++;}if((p->next==NULL)||(j>i-1))printf("i值不合法\n");else{s=p->next; //修改p->next,使指向s->nextp->next=s->next; //删除s结点free(s);}}void insertafter(NODE *p,int x){NODE *s;s=(NODE*)malloc(sizeof(NODE)); //修改i-1结点的尾指针s->data=x;s->next=p->next;p->next=s;}void insert(NODE *head,int i,int x) //在i个位置插入x{NODE *p;int j=i-1;p=get(head,j); //调用查找函数找到i-1的结点位置if(p==NULL)printf("error");elseinsertafter(p,x); //调用insertafter函数}void print(NODE *head) //输出函数{int x;NODE *p;p=head;printf("\n");p=p->next;while(p){x=p->data;printf("%4d",x);}}main(){NODE *head;printf("Please enter the link of elements:\n");//head=creatlink1(); //头插法head=creatlink2(); //尾插法printf("The first step of is :\n");print(head);printf("\n");insert(head,5,7); //调用插入函数printf("The second step of is :\n");print(head);printf("\n");delete(head,6); //调用删除函数printf("The third step of is :\n");print(head);printf("\n");}运算结果为:四、实验心得在这次实验中,我学到很多东西,加强了我的编程能力,加强了我对链表的了解,并且培养了我的独立思考能力。

相关文档
最新文档