实验二 单链表的基本算法

合集下载

单链表的基本操作实验报告

单链表的基本操作实验报告

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

在本次实验中,我们将学习和实践单链表的基本操作,包括创建链表、插入节点、删除节点以及遍历链表等。

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

通过实践操作,加深对单链表的理解,并掌握如何应用单链表解决实际问题。

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

链表可以通过一个头节点来表示,头节点不存储数据,只用于标识链表的起始位置。

我们可以定义一个指针变量head,将其指向头节点。

2. 插入节点在链表中插入节点是常见的操作。

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

插入节点的过程可以分为以下几个步骤:a. 创建一个新节点,并为其赋值;b. 找到要插入位置的前一个节点;c. 将新节点的指针指向前一个节点的下一个节点;d. 将前一个节点的指针指向新节点。

3. 删除节点删除节点是另一个常见的操作。

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

删除节点的过程可以分为以下几个步骤:a. 找到要删除节点的前一个节点;b. 将前一个节点的指针指向要删除节点的下一个节点;c. 释放要删除节点的内存空间。

4. 遍历链表遍历链表是为了查看链表中的元素。

我们可以从头节点开始,依次访问每个节点,并输出节点的值。

三、实验结果在本次实验中,我们成功完成了单链表的基本操作。

通过创建链表、插入节点、删除节点和遍历链表等操作,我们可以方便地对链表进行增删改查操作。

四、实验总结通过本次实验,我们对单链表的基本操作有了更深入的了解。

单链表是一种非常重要的数据结构,广泛应用于各个领域。

掌握了单链表的基本操作,我们可以更好地解决实际问题,并且为以后学习更复杂的数据结构打下坚实的基础。

在实验过程中,我们还发现了一些问题和不足之处。

单链表的基本算法实验报告

单链表的基本算法实验报告

单链表的基本算法实验报告单链表的的基本算法学号:⽇期:⼀、需求分析1.程序的功能(1)程序具备任意选择删除、插⼊、查找数据元素,和求单链表表长等⼏项功能。

(2)当选择删除功能时,从键盘读⼊欲删除的元素位置,按指定位置删除;当选择插⼊功能时,从键盘读⼊新元素值和被插⼊位置,在指定位置插⼊;当选择查找功能时,从键盘读⼊欲查找的元素值,返回其位置序号;当选择求表长功能时,返回该单链表表长的数值。

2.输⼊输出的要求(1)从键盘读⼊⼀组整数,按输⼊顺序形成单链表。

(2)每种操作结束后,都能在屏幕上打印出此时单链表元素的遍历结果。

(3)测试数据从键盘输⼊⼀组若⼲数字使之形成单链表⼆、概要设计1.本程序所⽤的抽象数据类型的定义typedef struct{DataType items[LISTSIZE];int length;}SqList;2.主程序的流程及各程序模块之间的层次关系先定义⼀个顺序表,结构体⾥的⼀位数组为顺序表内容,然后调⽤int InitList(SqList *L)初始化顺序表,然后已键盘输⼊的形式输⼊⼀组⼀维数组,保存到顺序表⾥,次数组以-222作为结束符号,然后调⽤int TraverseList(SqList L)遍历次顺序表,在主函数⾥实⾏do-while在⾥⾯进⾏意选择删除、插⼊、查找数据元素的功能。

删除功能调⽤int ListInsertt(SqList *L),int ListInsertt(SqList *L)⼜调⽤int ListDelete(SqList *L),为嵌套调⽤。

插⼊功能调⽤int ListInsert(SqList *L,int pos,DataType item)此函数。

查找功能调⽤int Find(SqList L);在以上⼦函数中要⽤到int ListEmpty(SqList L)判空函数。

三、详细设计1.采⽤c 语⾔定义相关的数据类型(1)⽤C 语⾔描述的单链表的节点结构 typedef struct Node{DataType data;struct Node *next;}LNode, *PNode,*LinkList; 四、调试分析1.调试中遇到的问题及对问题的解决⽅法在调试过程在运⾏插⼊和查找功能时把位置找错,总是找到正确位置的后⼀个,后来经过仔细阅读课本发现我把书上定义理解错了。

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

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

实验截图(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、 掌握单链表存储结构的类型定义;2、 实现单链表各种基本运算的算法。

二、 实验环境1、 Windows 操作系统;2、 Visual C++ 6.0三、 实验内容实现单链表各种基本运算的算法。

四、 概要设计1、 存储结构的类型定义:typedef struct LNode{ElemType data; struct LNode *next;} LinkList;2、 单链表示意图:3、 项目组成图:4、algo2_2.cpp 的程序文件包含的函数原型及功能:InitList(LinkList *&L) 初始化单链表LDestroyList(LinkList *&L) 释放单链表LListEmpty(LinkList *L)判断单链表L 是否为空表ListLength(LinkList *L)返回单链表L 的元素个数DispList(LinkList *L)输出单链表LGetElem(LinkList *L,int i,ElemType &e)获取单链表L 的第i 个元素LocateElem(LinkList *L,ElemType e)在单链表L 中查找元素eListInsert(LinkList *&L,int i,ElemType e)在单链表L 中的第i 个位置上插入元素e ListDelete(LinkList *&L,int i,ElemType &e)在单链表L 中删除第i 个元素……5、exp2_2.cpp程序文件简介:(1)初始化单链表h: InitList(h);(2)依次采用尾插法插入a,b,c,d,e元素:ListInsert(h,1,'a');ListInsert(h,2,'b');ListInsert(h,3,'c');ListInsert(h,4,'d');ListInsert(h,5,'e');(3)输出单链表h: DispList(h);(4)单链表h长度:ListLength(h)(5)判断单链表h 是否为空:ListEmpty(h)?"空":"非空"(6)查找单链表h的第3个元素:GetElem(h,3,e);(7)查找元素f的位置:LocateElem(h,'f')(8)在第4个元素位置上插入f元素:ListInsert(h,4,'f');(9)输出单链表h:DispList(h);(10)删除h的第3个元素:ListDelete(h,3,e);(11)输出单链表h:DispList(h);(12)释放单链表h:DestroyList(h);6、oj2-2的项目的模块结构:在文件algo2-2中,1.定义单链表结构类型;2.初始化单链表3.定义释放单链表的函数4.定义判断单链表是否为空的函数5.定义返回单链表元素个数的函数6.定义输出单链表的函数7.定义获取第i个元素的函数8.定义查找元素的函数9.定义插入元素的函数10.定义删除元素的函数在文件exp2-2中分别调用algo2-2中所定义的函数 函数调用关系图。

实验报告二——单链表

实验报告二——单链表
三、源程序及注释:
#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 个元素的值和正位序(插在表尾)输入n 个元素的值;∙插入结点可以根据给定位置进行插入(位置插入),也可以根据结点的值插入到已知的链表中(值插入),且保持结点的数据按原来的递增次序排列,形成有序链表。

∙删除结点可以根据给定位置进行删除(位置删除),也可以把链表中查找结点的值为搜索对象的结点全部删除(值删除);∙输出单链表的内容是将链表中各结点的数据依次显示,直到链表尾结点;∙求前驱结点是根据给定结点的值,在单链表中搜索其当前结点的后继结点值为给定的值,将当前结点返回;∙求后继结点是根据给定结点的值,在单链表中搜索其当前结点的值为给定的值,将后继结点返回;∙两个有序链表的合并是分别将两个单链表的结点依次插入到第3 个单链表中,继续保持结点有序;编写主程序,实现对各不同的算法调用。

其它的操作算法描述略。

2.实现要求:对链表的各项操作一定要编写成为C(C++)语言函数,组合成模块化的形式,还要针对每个算法的实现从时间复杂度和空间复杂度上进行评价。

∙“初始化算法”的操作结果:构造一个空的线性表L,产生头结点,并使L 指向此头结点;∙“建立链表算法”初始条件:空链存在;操作结果:选择逆位序或正位序的方法,建立一个单链表,并且返回完成的结果;∙“链表(位置)插入算法”初始条件:已知单链表L 存在;操作结果:在带头结点的单链线性表L 中第i 个位置之前插入元素e;∙“链表(位置)删除算法”初始条件:已知单链表L 存在;操作结果:在带头结点的单链线性表L 中,删除第i 个元素,并由e 返回其值;∙“输出算法”初始条件:链表L 已存在;操作结果:依次输出链表的各个结点的值;∙“求前驱算法”初始条件: 线性表L 已存在;操作结果: 若cur_e 是L 的数据元素,且不是第一个,则用pre_e 返回它的前驱;∙“求后继算法”初始条件: 线性表L 已存在;操作结果: 若cur_e 是L 的数据元素,且不是最后一个,则用next_e 返回它的后继;∙“两个有序链表的合并算法”初始条件: 线性表单链线性表La 和Lb 的元素按值非递减排列;操作结果:归并La 和Lb 得到新的单链表。

单链表的基本操作

单链表的基本操作

实验二:单链表的基本操作编写一个完整的程序,实现单链表的建立、插入、删除、输出等基本操作。

(1)建立一个带头结点的单链表。

(2)计算单链表的长度,然后输出单链表。

(3)查找值为x的直接前驱结点q。

(4)删除值为x的结点。

(5)把单向链表中元素逆置(不允许申请新的结点空间)。

(6)已知单链表中元素递增有序,请写出一个高效的算法,删除表中所有值大于mink且小于maxk的元素(若表中存在这样的元素),同时释放被删结点空间,并分析你的算法的时间复杂度(注意:mink和maxk是给定的两个参变量,他们的值可以和表中的元素相同,也可以不同)。

(7)同(6)的条件,试写一高效的算法,删除表中所有值相同的多余元素(使得操作后的线性表中所有元素的值均不相同),同时释放被删结点空间,并分析你的算法时间复杂度。

(8)利用(1)建立的链表,实现将其分解成两个链表,其中一个全部为奇数,另一个全部为偶数(尽量利用已知的存储空间)。

(9)在主函数中设计一个简单的菜单,分别测试上述算法。

# include <stdio.h># include <stdlib.h>typedef struct node{int data;struct node * next;}Lnode, * LinkList;int m=sizeof(Lnode);//建立新的链表void Bulid_List(LinkList root){int num;LinkList s,p;s=root->next;int n;printf("请输入新建链表的长度n数据:\n"); scanf("%d",&n);printf("请依次建立链表:");for(int i=0;i<n;i++){scanf("%d",&num);s->data=num;p=(LinkList)malloc(m);s->next=p;s=p;s->next=NULL;}printf("链表已建立!\n");}//对链表的输出,包括长度和元素void OutPut_list(LinkList root) {int len=0;LinkList s;s=root->next;if(s->next==NULL)printf("单链表无数据,请先新建单链表。

单链表的基本运算

单链表的基本运算
{ Node *s; char c; int flag=1; while(flag) /* flag 初值为 1,当输入“$”时,置 flag 为 0,
建表结束*/ { c=getchar(); if(c!=’$’) { s=(Node*)malloc(sizeof(Node)); /*建立新结点 s*/ s->data=c; s->next=L->next; /*将 s 结点插入表头*/ L->next=s; } else flag=0;
3. 结果判断 如找到第 i 个结点,则返回结点 p;
如表查完未找到,则返回空。
【算法描述】
Node * Get (LinkList L, int i) / * 在带头结点的单链表 L 中查找第 i 个结点,若找到(1≤i≤n),则返回 该结点的存储位置; 否则返回 NULL * / { int j;
【算法描述】
int ListLength(LinkList L)
/*求带头结点的单链表 L 的长度*/
{ Node *p;
p=L->next;
j=0; /*用来存放单链表的长度*/
while(p!=NULL)
{
p=p->next;
j ++;
}
return j; /*j 为求得的单链表长度*/
} /* ListLength */
H

s r
(a)初始化的空表
C1 ∧
(b)申请新结点并赋值
s 指向新申请的结点空间;
s->data:=C1
H
c1 ∧
r
(c)插入第一个结点
s
① r->next=s;
c1 H

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

实验二:单链表基本运算实现
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.掌握单链表基本操作及两个有序表归并、单链表逆置等操作的实现。

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

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

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

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

三实验内容1.编写程序完成单链表的下列基本操作:(1)初始化单链表La。

(2)在La中第i个元素之前插入一个新结点。

(3)删除La中的第i个元素结点。

(4)在La中查找某结点并返回其位置。

(5)打印输出La中的结点元素值。

2 .构造两个带有表头结点的有序单链表La、Lb,编写程序实现将La、Lb合并成一个有序单链表Lc。

合并思想是:程序需要3个指针:pa、pb、pc,其中pa,pb分别指向La表与Lb表中当前待比较插入的结点,pc 指向Lc表中当前最后一个结点。

依次扫描La和Lb中的元素,比较当前元素的值,将较小者链接到*pc 之后,如此重复直到La或Lb结束为止,再将另一个链表余下的内容链接到pc所指的结点之后。

3.构造一个单链表L,其头结点指针为head,编写程序实现将L逆置。

(即最后一个结点变成第一个结点,原来倒数第二个结点变成第二个结点,如此等等。

)四思考与提高1.如果上面实验内容2中合并的表内不允许有重复的数据该如何操作?2.如何将一个带头结点的单链表La分解成两个同样结构的单链表Lb,Lc,使得Lb中只含La表中奇数结点,Lc中含有La表的偶数结点?1.编写程序完成单链表的下列基本操作:(1)初始化单链表La。

(2)在La中第i个元素之前插入一个新结点。

(3)删除La中的第i个元素结点。

(4)在La中查找某结点并返回其位置。

(5)打印输出La中的结点元素值。

#include<stdio.h>#include<stdlib.h>#include <malloc.h>#define OK 1#define ERROR 0typedef int Status;typedef int ElemType;//定义存储结构typedef struct Lnode{int data; /*每个元素数据信息*/struct Lnode *next; /*存放后继元素的地址*/} LNode,*LinkList;int main(){void Create_L(LinkList &L,int n);void Print_L(LinkList L);Status ListInsert_L(LinkList &L,int i,ElemType e);Status ListDelete_L(LinkList &L,int i,ElemType &e);Status Find_L(LinkList L,int e);LinkList La;//创建单链表Laint n;printf("请输入链表La中的元素个数:\n");scanf("%d",&n);Create_L(La,n);//初始化单链表printf("现在La中的元素为:\n");Print_L(La);printf("-------------------------------------\n\n");printf("现在准备插入元素,请输入插入位置及所插入元素的值\n");int i,e;scanf("%d %d",&i,&e);ListInsert_L(La,i,e);printf("插入后La中的元素为:\n");Print_L(La);printf("-------------------------------------\n\n");printf("现在准备删除元素,请输入删除位置\n");scanf("%d",&i);ListDelete_L(La,i,e);printf("删除后La中的元素为:\n");Print_L(La);printf("-------------------------------------\n\n");printf("请输入所要查找元素的值:\n");scanf("%d",&e);Find_L(La,e);printf("所要查找元素的位置为:%d\n",Find_L(La,e)); }void Create_L(LinkList &L,int n){int j=1;L=(LinkList)malloc(sizeof(Lnode));L->next =NULL;//先建立一个带头结点的单链线性表L for(int i=n;i>0;--i){LinkList p=(LinkList)malloc(sizeof(Lnode));printf("请输入链表La中的第%d个元素:\n",j++);scanf("%d",&p->data);p->next=L->next;L->next =p;}//(逆序实现)/*LinkList q=L;for(int i=1;i<=n;i++){LinkList p=(LinkList)malloc (sizeof(Lnode));q->next=p;p->next=NULL;q=q->next ;printf("请输入链表La中的第%d个元素:\n",i);scanf("%d",&p->data);}//(正序实现)*/}//初始化单链表//输出单链表void Print_L(LinkList L){LinkList p;p=L->next;while(p){printf("%d ",p->data );p=p->next;}printf("\n");}//在单链表L的第i个位置前插入元素eStatus ListInsert_L(LinkList &L,int i,ElemType e) {LinkList p=L;int j=0;while(p&&j<i-1){p=p->next; ++j;}if(!p||j>i-1) return ERROR;LinkList s=(LinkList)malloc(sizeof(LNode));s->data=e; s->next=p->next;p->next=s;return OK;} //ListInsert_L//删除单链表L中第i个位置上的元素Status ListDelete_L(LinkList &L,int i,ElemType &e) {LinkList p=L;int j=0;while( p->next && j<i-1){p=p->next; ++j;}if(!p->next||j>i-1) return ERROR;LinkList q=p->next; p->next=q->next;e=q->data;free(q);return OK;}//LinkDelete_L/*查找元素并返回位置*/Status Find_L(LinkList L,int e){LinkList p=L->next;int j=1;while(p->data!=e&&p->next){p=p->next;j++;}if(p->data==e) return j;else{printf("无当前元素\n");return ERROR;}if(!p){printf("无当前元素\n");return ERROR;}}//定位2 .构造两个带有表头结点的有序单链表La、Lb,编写程序实现将La、Lb合并成一个有序单链表Lc。

单链表的各种基本运算的实现 实验报告

单链表的各种基本运算的实现  实验报告

软件技术基础实验一——单链表的各种基本运算的实现一、实验题目编写一个程序,实现单链表的各种基本运算,并在此基础上设计一个主程序完成如下功能:(1)初始化单链表(2)依次采用尾插法插入a,b,c,d,e元素(3)输出单链表(4)在第四个元素位置上插入f元素(5)删除该单链表的第三个元素二、实验目的1、理解单链表的概念及结构特点;2、掌握单链表的基本操作:查找、插入、删除等运算在链接存储结构上的运算。

三、调试通过并正确执行给定功能要求的实验代码#include "stdafx.h"#include<malloc.h>#include<iostream.h>struct link{char data;link *next;};link *rcreat(link *head,char x) //尾插法建立单链表{link *s,*r;r=head;s=new link;s->data=x;r->next=s;r=s;r->next=NULL;return r;}link *get(link *head,int i) //查找第i个元素,返回其地址{int j;link *p;j=1;p=head->next ;while((j<i-1)&&(p!=NULL)){j++;p=p->next;}return p;}void insert(link *head,int num,char y) //元素y之后插入x {link *p,*s;s=new link;s->data=y;if(head->next==NULL){head->next=s;s->next=NULL;}p=get(head,num);if(p==NULL) cout<<"插入位置非法";else{s->next=p->next;p->next=s;}}void delet(link *head,char x) //将指定元素x删除{link * p, * q;q=head;p=head->next;while((p!=NULL)&&(p->data!=x)){q=p;p=p->next;}if(p==NULL) cout<<"要删除的元素不存在";else{q->next=p->next;delete(p);}}void print(link *head) //输出单链表{link *p;p=head->next;while(p->next!=NULL){cout<<p->data<<"->";p=p->next;}cout<<p->data<<endl;}void main(int argc, char* argv[]){link *head,*p,*q,*r;char x,y;int n,dele,i=1,j=1;head=new link;head->next=NULL;r=head;while(j<=5){cout<<"请输入要插入的元素:";cin>>x;r=rcreat(r,x);j=j+1;}print(head);cout<<"请输入要插入元素的位置:";cin>>n;cout<<"请输入要插入的元素:";cin>>y;insert(head,n,y);cout<<"输出插入后的单链表:"<<endl;print(head);cout<<"请输入要删除元素的位置:";cin>>dele;q=head;p=head->next;while(i<dele){q=p;p=p->next;i=i+1;}q->next=p->next;delete (p);cout<<"删除后的链表如下:"<<endl;print(head);}四、实验结果。

实验二 单链表的逆转

实验二 单链表的逆转

实验二单链表的逆转一、实验要求逆转一个单链表二、数据结构使用了单向链表,链表的节点都使用的是结构体。

三、算法描述1、定义一个结构体struct node{int data;node *next;};定义一个名为node的结构体,为了简便起见,结构体中只包含一个int型数据和指针。

定义四个函数:node *Input() //数据录入函数void Output(node *head) //数据输出函数void Delete(node *h) //节点删除函数node *Reverse(node *head) //链表逆序函数2、建立一条无序链表node *Input():使用三个指针 p1、p2、head,head指向第一个节点,p2为最后一个节点,p1为新节点。

每次操作时使p2->next=p1,p2=p1。

当输入为-1时使p2->next=0。

由此链表建立完成。

返回新建链表的头指针。

3、单链表的逆转总的思想:1)首先,使p1、p、p2依次指向head开始的前三个node,然后使p1赋给p->next,由此实现了p1和p的逆转;2)再将三个指针依次向后移一个node。

p1的下一个是p,p的下一个是p2,p2的下一个是p2->next;3)重复步骤2和3直至p2->next==nil,node* Reverse(node *head){node *p1,*p,*p2;p1=head;p=p1->next;p1->next=0; //使用3个指针,p1、p和p2。

令p1->next=0if(p->next!=0){p2=p->next; //使p1、p、p2依次指向head开始的前三个nodewhile(p2->next!=0){p->next=p1; //p->next,由此实现了p1和p的逆转p1=p;p=p2;p2=p2->next; //将三个指针依次向后移一个node}p->next=p1; //当p2->next==nil,完成单链表的逆转,只需再将最后两个节点p、p2的指针再分别指向p1、p即可p2->next=p;return p2;}else{p->next=p1;return p;}}四、测试数据输入数据产生无序链表,以-1结束1378-1链表上各结点的数据:1 3 7 8逆转后链表上各结点的数据:8 7 3 1输入四个数据,成功实现逆转。

数据结构c++顺序表、单链表的基本操作,查找、排序代码

数据结构c++顺序表、单链表的基本操作,查找、排序代码

} return 0; }
实验三 查找
实验名称: 实验3 查找 实验目的:掌握顺序表和有序表的查找方法及算法实现;掌握二叉排序 树和哈希表的构造和查找方法。通过上机操作,理解如何科学地组织信 息存储,并选择高效的查找算法。 实验内容:(2选1)内容1: 基本查找算法;内容2: 哈希表设计。 实验要求:1)在C++系统中编程实现;2)选择合适的数据结构实现查 找算法;3)写出算法设计的基本原理或画出流程图;4)算法实现代码 简洁明了;关键语句要有注释;5)给出调试和测试结果;6)完成实验 报告。 实验步骤: (1)算法设计 a.构造哈希函数的方法很多,常用的有(1)直接定址法(2)数字分析法;(3) 平方取中法;(4)折叠法;( 5)除留余数法;(6)随机数法;本实验采用的是除 留余数法:取关键字被某个不大于哈希表表长m的数p除后所得余数为哈 希地址 (2)算法实现 hash hashlist[n]; void listname(){ char *f; int s0,r,i; NameList[0].py="baojie"; NameList[1].py="chengቤተ መጻሕፍቲ ባይዱoyang"; ……………………………… NameList[29].py="wurenke"; for(i=0;i<q;i++){s0=0;f=NameList[i].py; for(r=0;*(f+r)!='\0';r++) s0+=*(f+r);NameList[i].k=s0; }} void creathash(){int i;
v[k-1]=v[k]; nn=nn-1; return ; } int main() {sq_LList<double>s1(100); cout<<"第一次输出顺序表对象s1:"<<endl; s1.prt_sq_LList(); s1.ins_sq_LList(0,1.5); s1.ins_sq_LList(1,2.5); s1.ins_sq_LList(4,3.5); cout<<"第二次输出顺序表对象s1:"<<endl; s1.prt_sq_LList(); s1.del_sq_LList(0); s1.del_sq_LList(2); cout<<"第三次输出顺序表对象s1:"<<endl; s1.prt_sq_LList(); return 0; } 运行及结果:

实习2:实现单链表各种基本运算

实习2:实现单链表各种基本运算

实习2:实现单链表各种基本运算1、实验目的充分理解线性表的链接存储方式,掌握单链表的各种基本运算的实现。

2、实验内容编写一个程序,实现单链表的各种基本运算,并在此基础上设计一个主程序,完成如下功能:(1)根据输入指定个数的表元素值,采用头插法建立一个单链表,并输出单链表中各元素的值,同时观察输入内容与输出内容是否一致。

(2)在单链表的第i个元素之前插入一个值为x的新元素,并输出插入后的单链表中各元素的值。

(3)删除单链表中第i个元素,并输出删除后的单链表中各元素的值。

(4)在单链表中查找第i个元素,如果查找成功,则输出该元素的值;否则,输出该元素不存在。

(5)在单链表中查找值为y的元素,如果查找成功,则输出该元素的位序号(0~n-1);否则,输出该元素不存在。

import java.util.Scanner;class Node {private Object data;private Node next;public Node() {this(null, null);}public Node(Object data) {this(data, null);}public Node(Object data, Node next) {this.data = data;this.next = next;}public Object getData() {return data;}public void setData(Object data) {this.data = data;}public Node getNext() {return next;}public void setNext(Node next) {this.next = next;}}class LinkList {Node head=new Node();public LinkList(int n,boolean Order)throws Exception{if(Order)create1(n);}public void create1(int n) throws Exception {Scanner sc = new Scanner(System.in);for (int j=0; j<n; j++)insert(0, sc.nextInt());}public Object get(int i) throws Exception {Node p = head.getNext();int j = 0;while (p != null && j < i) {p = p.getNext();++j;}if (j > i || p == null) {throw new Exception("第" + i + "个元素不存在");}return p.getData();}public int indexOf(Object x){Node p=head.getNext();int j=0;while(p!=null && !p.getData().equals(x)){p=p.getNext();++j;}if(p!=null)return j;elsereturn -1;}public void insert(int i, Object x) throws Exception {Node p = head;int j = -1;while (p != null && j < i - 1) {p = p.getNext();++j;}if (j > i - 1 || p == null)throw new Exception("插入位置不合理");Node s = new Node(x);s.setNext(p.getNext());p.setNext(s);}public void remove(int i) throws Exception {Node p = head;int j = -1;while (p.getNext() != null && j < i - 1) {p = p.getNext();++j;}if (j > i - 1 || p.getNext() == null) {throw new Exception("删除位置不合理");}p.setNext(p.getNext().getNext());}public void display() {Node p = head.getNext();while (p != null) {System.out.print(p.getData() + " ");p = p.getNext();}System.out.println();}}public class LinkL{public static void main(String[] args) throws Exception{Scanner sc=new Scanner(System.in);int n=0;LinkList L=new LinkList(n,true);System.out.println("请输入链表中的结点数:");n=sc.nextInt();System.out.println("请输入"+n+"个数字:");L.create1(n);System.out.println("建立的单链表为:");L.display();System.out.println("请输入待插入的位置i:");int i=sc.nextInt();System.out.println("请输入待插入的数据值x:");int x= sc.nextInt();L.insert(i, x);System.out.println("插入后的链表为:");L.display();System.out.println("请输入待删除元素的位置:");i=sc.nextInt();L.remove(i);System.out.println("删除后的链表为:");L.display();System.out.println("请输入待查找的数据元素的位序号:");i=sc.nextInt();Object o=L.get(i);System.out.println("此单链表中第"+i+"个结点的数据元素值为"+o);System.out.println("请输入待查找的数据元素的值:");x=sc.nextInt();int order=L.indexOf(x);if (order==-1)System.out.println("此顺序表中不包含值为"+x+"的数据元素!");elseSystem.out.println("值为"+x+"元素在顺序表中的第"+order+"个位置上");}}。

实验二 单链表的插入和删除

实验二   单链表的插入和删除

实验二 单链表的插入和删除1.实验目的:了解单链表的基本概念、结构的定义及在单链表上的基本操作(插入、删除、查找以及线性表合并),通过在VC 实现以上操作更好的了解书本上的内容并体会线性表的两种存储结构的区别。

2.实验预备知识:⑴ 复习C 语言中指针的用法,特别是结构体的指针的用法;⑵ 了解单链表的概念,单链表的定义方法;单链表是线性表的链式存储表示,是用一组任意的存储单元依次存储线性表的数据元素。

因此,为了表示每个数据元素a i 与其直接后继元素a i+1之间的逻辑关系,对数据元素ai 来说,,除了存储其本身的信息之外,还需存储一个指示其直接后继的信息(即直接后继的存储位置),而这部分就是用指针来完成的。

⑶ 掌握线性表在链式存储结构上实现基本操作:查找、插入、删除的算法; 在实现这些算法的时候,要注意判断输入数据的合法性,除此之外还要要注意以下内容:在实现查找的时候,首先要判断该顺序表是否为空,其次要判断查找后的结果(查到时输出查到的数据,未查到时给出错误提示)。

在实现插入的时候,由于是链式存储,它可以随机产生和回收存储空间,所以它不要判断线性表是否为满,但仍需判断要插入的位置是否合法,原因同实验一,其次要注意插入的时候语句的顺序不可颠倒,否则出错。

例如:s 所指向结点要插入在p 所指向的结点之后,则:正确形式:s->next=p->nextp->next=s错误形式:p->next=ss->next=p->next(因为此时p->next 已经指向s 了)在实现删除的时候,首先要判断线性表是否为空,为空则不能删除; 其次在删除后要回收空间。

例如:删除如上图所示s 所指向的结点p->next=p->next->nextfree s3.实验内容:⑴ 单链表的插入算法⑵ 单链表的删除算法⑶循环链表的插入和删除算法4.部分实验代码:⑴单链表的结构定义:#include <stdio.h>typedef int elemtype;typedef struct lnode{ elemtype data;struct lnode *next;}*linklist;⑵建立单链表的算法int n; /*n作为整个程序的全局变量*/linklist *creat(void){ linklist *head, *p1, *p2;n=0;p1=p2=(linklist *)malloc(sizeof(linklist));scanf(“%d”,&p1->data);head=null;while(p1->data!=0){ n=n+1;if(n==1) head=p1;else p2->next=p1;p2=p1;p1=(linklist *)malloc(sizeof(linklist));scanf(“%d”,&p1->data);}p2->next=null;return(head);}⑶单链表的插入算法int insert(linklist *head, int i,elemtype e) { linklist *p, *s;int j;p=head; j=0;while(p && j<i-1){ p=p->next;++j;}if(!p||j>i-1){ printf(“无法插入”);return 0;}s=(linklist *)malloc(sizeof(lnode));s->data=e;s->next=p->next;p->next=s;return 1;}⑷单链表的删除算法int deltree(linklist *head,int i,elemtype e){ linklist *p, *q;int j;lp=head; j=0;while(p->next && j<i-1){ p=p->next;++j;}if(!(p->next)||j>i-1){ printf(“无法删除”);return 0;}q=p->next;p->next=q->next;e=q->data;free(q);return 1;}。

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

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

数据结构实验二:单链表的基本操作数据结构实验二:单链表的基本操作实验二:单链表的基本操作一、【实验目的】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带回。

实验二 单链表操作

实验二 单链表操作

实验二单链表操作一、实验目的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);}。

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

实验二单链表的基本算法一.实验目的:
通过上机编程掌握
1.生成单链表的基本算法;
2.在单链表上的插入、删除运算。

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

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

三.实验内容:
1.编写函数实现单链表的基本运算:
(1)单链表的生成
(2)单链表的插入
(3)单链表的删除
2.编写主函数测试单链表的各种基本运算:
(1)生成一个至少包含有5个元素的单链表,元素值由计算机输入
(2)在表中的第5个位置上插入元素”7”
(3)删除表中的第6个元素
(4)显示(1)—(3)每一步的操作结果
实验原理:首先建立头结点,形成一个单链表,通过malloc函数创建新的结点单元,将要读取的数据赋值给新结点。

其次插入链表,从头结点开始依次延指针域查找需要插入的结点,为插入数据元素x生成一个新结点s,将x插入在s和s-1之间。

最后链表结点删除,找到指定结点的前趋结点通过改变连接完成删除。

源程序:
#include<stdio.h>
#include<stdlib.h>
typedef int datatype;
typedef struct node/*结构体更名为NODE*/
{ datatype data;
struct node *next;
}NODE;
NODE *creatlink() /*建立带头结点的单链表*/
{ NODE *head,*s ,*p;
int x;
head=(NODE*)malloc(sizeof(NODE)); /*生成一个NODE型新结点并赋值给head*/
p=head;
scanf("%d",&x);
while(x!=0)
{ s=(NODE*)malloc(sizeof(NODE)); /*生成一个NODE型新结点并赋值给s*/
s->data=x;
s->next=head->next;
head->next=s;
scanf("%d",&x);
}
p->next=NULL;
return head;/*返还给head*/
}
void insert(NODE *head,int i,int x);/*单链表的插入*/
{ NODE *p, *s;
int counter=0;/*计数器*/
p=head;
while((p!=NULL)&&(counter<i))
p=p->next;
counter++;
}
if((p==NULL)||(counter>i))
printf("i值不合法\n");
else
{ s=(NODE*)malloc(sizeof(NODE));/*生成一个NODE型新结点并赋值给s*/ s->data=x;
s->next=p->next;
p->next=s;
}
}
void delete(NODE *head,int i) /*单链表的删除*/
{ NODE *P, *S;
int counter=0;/*计数器*/
p=head;
while((p->next!=NULL)&&(counter<i-1))
{ p=p->next;
counter++;
}
if((p->next==NULL)||(counter>i-1))
printf("i值不合法\n");
else
{ s=(NODE*)malloc(sizeof(NODE));/*生成一个NODE型新结点并赋值给s*/ s=p->next;
p->next=s->next;
free(s);/*删除s*/
}
}
main()
{NODE *head ,*p;
head=(NODE*)malloc(sizeof(NODE));
printf("输入元素值(用0做结束符):\n");
head=creatlink(); /*创建链表函数*/
insert(head,5,7); /*插入函数*/
delete(head,s);/*删除函数*/
printf("在第三个位置插入58并删除第四个元素后的链表是:\n");
p=head->next;
while(p!=NULL)
{ printf("%d",p->data);
p=p->next;
}
printf("\n");
}
四.实验结果
四.实验小结
通过本次实验进一步了解了链表的知识,通过实际操作加强了使用链表的熟练程度。

同时在本次试验中也发现了自己的一些问题,对于顺序表的语句还存在着一些不理解、不清楚的地方,在上机时间通过和同学的沟通解决。

相关文档
最新文档