实验3 线性表的链式存储

合集下载

线性表的链式存储,实验报告

线性表的链式存储,实验报告线性表的链式存储结构实验报告实验报告课程名称：数据结构与算法分析实验名称：链表的实现与应用实验日期：2015.01.30 班级：数媒1401 姓名：范业嘉学号1030514108一、实验目的掌握线性表的链式存储结构设计与基本操作的实现。

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

⑸设计一个一元多项式计算器，要求能够：①输入并建立多项式；②输出多项式；③执行两个多项式相加；④执行两个多项式相减；⑤（选做）执行两个多项式相乘。

三、数据结构设计1.按所用指针的类型、个数、方法等的不同，又可分为：线性链表（单链表）静态链表循环链表双向链表双向循环链表2.用一组任意的存储单元存储线性表中数据元素，用指针来表示数据元素间的逻辑关系。

四、算法设计1.定义一个链表void creatlist(Linklist &L,int n){int i;Linklist p,s;L=(Linklist)malloc(sizeof(Lnode));p=L;L-next=NULL;for(i=0;in;i++){s=(Linklist)malloc(sizeof(Lnode));scanf(%d,&s-data);s-next=NULL;p-next=s;p=s;}}2.（1）两个链表的合并void Mergelist(Linklist &La,Linklist &Lb,Linklist &Lc) {Linklist pa,pb,pc;pa=La-next;pb=Lb-next;Lc=pc=La;while(pa&&pb){if(pa-data=pb-data){pc-next=pa;pc=pa;pa=pa-next;}else {pc-next=pb;pc=pb;pb=pb-next;}}pc-next=pa?pa:pb;free(Lb);}（2）两个链表的并集Linklist unionlist(Linklist &La,Linklist &Lb){Linklist p1,p2,head,q,s;int flag;head=q=(Linklist)malloc(sizeof(Lnode)); p1=La-next;while(p1){flag=0;p2=Lb-next;while(p2){if(p1-data==p2-data){flag=1;break;}p2=p2-next;}if(flag==0){s=(Linklist)malloc(sizeof(Lnode));s-data=p1-data;q-next=s;q=s;}p1=p1-next;}q-next=Lb-next;return head;}3.（1）一元多项式的加法List addpoly(List pa,List pb) //一元多项式的加法{ int n;List pc,s,p;pa=pa-next;pb=pb-next;pc=(List)malloc(sizeof(struct Linklist));pc-next=NULL;p=pc;while(pa!=NULL&&pb!=NULL){if(pa-expnpb-expn){s=(List)malloc(sizeof(struct Linklist)); s-expn=pa-expn; s-coef=pa-coef;s-next=NULL;p-next=s;p=s;pa=pa-next;}else if(pa-expnpb-expn){s=(List)malloc(sizeof(struct Linklist)); s-expn=pb-expn; s-coef=pb-coef;s-next=NULL;p-next=s;p=s;pb=pb-next;}else{n=pa-coef+pb-coef;if(n!=0){s=(List)malloc(sizeof(struct Linklist)); s-expn=pa-expn; s-coef=n;s-next=NULL;p-next=s;p=s;}pb=pb-next;pa=pa-next;}}while(pa!=NULL){s=(List)malloc(sizeof(struct Linklist)); s-expn=pa-expn;s-coef=pa-coef;s-next=NULL;p-next=s;p=s;pa=pa-next;}while(pb!=NULL){s=(List)malloc(sizeof(struct Linklist)); s-expn=pb-expn;s-coef=pb-coef;s-next=NULL;p=s;pb=pb-next;}return pc;}（2）一元多项式的减法List subpoly(List pa,List pb)//一元多项式的减法{ int n;List pc,s,p;pa=pa-next;pb=pb-next;pc=(List)malloc(sizeof(struct Linklist));pc-next=NULL;p=pc;while(pa!=NULL&&pb!=NULL){if(pa-expnpb-expn){s=(List)malloc(sizeof(struct Linklist));s-expn=pa-expn;s-coef=pa-coef;s-next=NULL;p=s;pa=pa-next;}else if(pa-expnpb-expn){s=(List)malloc(sizeof(struct L(转载于: 写论文网:线性表的链式存储,实验报告)inklist));s-expn=pb-expn;s-coef=-pb-coef;s-next=NULL;p-next=s;p=s;pb=pb-next;}else{n=pa-coef-pb-coef;if(n!=0){s=(List)malloc(sizeof(struct Linklist));s-expn=pa-expn;s-coef=n;s-next=NULL;p=s;}pb=pb-next;pa=pa-next;}}while(pa!=NULL){s=(List)malloc(sizeof(struct Linklist)); s-expn=pa-expn; s-coef=pa-coef;s-next=NULL;p-next=s;p=s;pa=pa-next;}篇二：《线性表的链式存储》实验报告《线性表的链式存储》实验报告1.需解决的的问题利用线性表的链式存储结构，设计一组输入数据。

实验三单链表的基本操作

实验三单链表的基本操作一、实验目的1、掌握线性表的链式存贮结构及基本操作，深入了解链表的基本特性，以便在实际问题背景下灵活运用它们。

2、巩固该存贮结构的构造方法，深入理解和灵活掌握链表的插入、删除等操作。

二、实验要求1、定义一链表类型，并定义带有头结点的单链表。

2、将教材中链表的建立、初始化、插入、删除等函数实现。

3、链表能够存储10名学生的基本信息（包括姓名、学号和成绩）。

4、由主函数按照用户要求对各个链表操作访问。

5、每操作之前要有明确的说明，操作后要输出操作结果。

6、分析顺序表链表的插入、删除、查找的时间和空间复杂度。

三、实验内容1、在自己的U盘的“姓名+学号”文件夹中创建“实验3”文件夹，本次实验的所有程序和数据都要求存储到本文件夹中。

2、完成链表操作的如下函数：单链表的建立、插入、删除#include<stdio.h>#include<stdlib.h>static int N=5;typedef struct _sy{ char name[12];int no;struct _sy *next;}stud;stud *Create(int m) //创建链表{ int i;stud *h,*p,*q;h=(stud*)malloc(sizeof(stud));if(h!=NULL){ p=h;for(i=0;i<m;i++){ q=(stud*)malloc(sizeof(stud));if(q!=NULL){ printf("依次输入第%d个人的姓名和学号：\n",i+1);scanf("%s%d",q->name,&q->no);q->next=NULL;p->next=q;p=q;}}}printf("\n");return(h);}stud *Delete(stud *sy,int post) //删除一个学生的数据{ int i;stud *cur,*pre;cur=sy;if(0==post){ return(sy);}else{ if(1==post){ cur=cur->next;sy->next=cur->next;free(cur);}else{ for(i=2;i<post+1;i++){ cur=cur->next;pre=cur;}cur=cur->next;pre->next=cur->next;free(cur);}return(sy); }}stud *Insert(stud *sy,int post) //插入一个新的学生的数据 { int i;stud *cur,*pre,*node;if(sy!=NULL){ cur=sy;node=(stud*)malloc(sizeof(stud));if(node!=NULL){ printf("请输入新人的姓名和学号：\n");scanf("%s%d",node->name,&node->no);if(1==post){ node->next=sy->next;sy->next=node;}else{ for(i=2;i<post+2;i++){ pre=cur;cur=cur->next;}node->next=pre->next;pre->next=node;}}}printf("\n");return(sy);}void Print(stud *sy) //输出学生信息{ int post=1;stud *cur;cur=sy->next;printf("当前的学生信息如下所示：\n");while(cur!=NULL){ printf("第%d个人的姓名是：%s，学号为：%d\n",post,cur->name,cur->no); cur=cur->next;post++;}N=--post;}int main(){ int mm,post,i;stud *head;head=Create(N);Print(head);for(i=0;i<1;i++){ printf("请输入要删除的学号的位置：\n");scanf("%d",&mm);Delete(head,mm);Print(head);printf("请输入要插入学号的位置：\n");scanf("%d",&post);Insert(head,post);Print(head);}return 0;}。

第3章线性表的链式存储

L
(a) 空循环链表
L
a1
a2
...
an
(b) 非空循环链表
3.1.3 双向链表
在单链表结点中只有一个指向其后继结点的next 指针域，而找其前驱则只能从该链表的头指针开始，顺着各结点的next指针域进行查找，也就是说找后继的时间复杂度是O(1)，找前驱的时间复杂度是O(n)。如果也希望找前驱像后继那样快，则只能付出空间的代价：每个结点再加一个指向前驱的指针域prior，结点的结构修改为下图，这样链表中有两个方向不同的链，用这种结点组成的链表称为双向链表。
1．带头结点的单链表 2．不带头结点的单链表
3.3.3 单链表插入操作的实现
单链表的插入操作是指在表的第i个位置结点处插入一个值为data的新结点。插入操作需要从单链表的第一个结点开始遍历，直到找到第i个位置的结点。插入操作分为在结点之前插入的前插操作和在结点之后插入的后插操作。
1．前插操作 2．后插操作
2．整数型单链表算法
3．不带头结点的单链表算法
3.2.2 尾插法单链表的创建实现
用头插法实现单链表的创建，比较简单，但读入的数据元素的顺序与生成的链表中元素的顺序是相反的。若希望两者次序一致，则用尾插法创建单链表。为了快速找到新结点插入到链表的尾部位置，所以需加入一个尾指针r用来始终指向链表中的尾结点。初始状态：头指针L和尾指针r均为空，把各数据元素按顺序依次读入，申请结点，将新结点插入到r所指结点的后面，然后r指向新结点，直到读入结束标志为止。
3.2.2 尾插法单链表的创建实现
L
插入P前的尾指针插入P后的尾指针
r
3
4
P1
x^
2
3.3 单链表运算的实现

数据结构线性表实验报告

数据结构线性表实验报告数据结构线性表实验报告1.简介本实验报告旨在介绍数据结构中线性表的实现和应用。

线性表是一种重要的数据结构，它的特点是数据元素之间存在一对一的前后关系，且具有唯一的起点和终点。

本实验通过实现线性表的基本操作，加深对线性表的理解，并通过实例应用展示线性表在实际问题中的应用。

2.实验环境本次实验采用的是编程语言C，并搭配使用一些常用的开发工具和库。

具体环境如下：________●操作系统：________Windows 10●编程语言：________C●开发工具：________Visual Studio Code●辅助库：________Stdio.h、stdlib.h、conio.h3.实验内容3.1 线性表的定义和基本操作3.1.1 线性表的定义线性表是由n（n ≥ 0）个数据元素组成的有限序列，数据元素之间存在一对一的前后关系。

3.1.2 线性表的基本操作●初始化线性表：________创建一个空的线性表。

●插入元素：________在指定位置插入一个新的元素。

●删除元素：________删除指定位置的元素。

●查找元素：________根据值或位置查找指定元素。

●修改元素：________根据位置修改指定元素的值。

●清空线性表：________将线性表中的所有元素清空。

3.2 线性表的顺序存储结构3.2.1 顺序存储结构的定义顺序存储结构是指使用一段连续的存储空间，依次存储线性表中的元素。

3.2.2 顺序存储结构的实现●初始化顺序表：________创建一个空的顺序表，并指定最大容量。

续元素依次后移。

●删除元素：________删除指定位置的元素，并将后续元素依次前移。

●查找元素：________根据值或位置查找指定元素，并返回其位置或值。

●修改元素：________根据位置修改指定元素的值。

●清空顺序表：________将顺序表中的所有元素清空。

●扩容：________当顺序表容量不足时，自动进行扩容。

实验三+线性表的链式存储.doc

实验三线性表的链式存储【实验目的】1.掌握基本线性链式存储的类型定义及C语言实现；2.掌握基本线性表在链式存储结构中的各种基本操作。

【实验要求】1.学会定义一个链式存储结构体LNode；2.学会链式存储结构的初始化、清空、求线性表的长度、遍历、改值、插入（头插、尾插、固定位置插入）、删除（删头、删尾、固定位置删除）；3.学会用main函数调用定义的各个函数；【实验环境】VC++运行的环境【实验步骤及代码】一、创建VC工程环境二、编写、调试程序//一、包含库文件和类型定义#include <stdio.h>#include <stdlib.h>typedef char ElemType;//二、定义结构typedef struct LNode{ElemType data;struct LNode *next;}LNode,*LinkList;//三、基本操作函数的定义//(1)创建一个带头结点的链表LinkList CreateList_L(int n){//逆序输入如n个元素的值，建立一个带表头结点的单链表LinkList L=(LinkList)malloc(sizeof(LNode));L->next=NULL;char ch;for(int i=n;i>0;--i){scanf("%c",&ch);p->data=ch;p->next=L->next;L->next=p;}return L;}//(2)链表的遍历函数void travel_L(LinkList s){LinkList p=s->next;while(p){printf("%c",p->data);p=p->next;}printf("\n");}//(3)返回链表L的第i个元素的值ElemType GetElem_L(LinkList L,int i){ LNode *p=L->next;int j=1;while (p&&j<i) {p=p->next;++j;}if (!p||j>i) {printf("i越界！");exit(1);}elsereturn p->data;}//(4)链表的i个位置插入一个值为e的节点void 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) exit(1);else{s->data=e;s->next=p->next;p->next=s;}return;}//(5)链表中删除第i个元素void ListDelete_L(LinkList L,int i){LNode *p=L;int j=0;while (p->next&&j<i-1) {p=p->next;++j;}if(!(p->next)||j>i-1) exit(1);LNode *q=p->next;p->next=q->next;free(q);return;}//(6)删除链表的第一个节点void ListDeleteFist_L(LinkList L){ListDelete_L(L,1);}//(7)求一个链表的长度int ListLength_L(LinkList L){LNode *p=L;int j=0;while (p->next) {p=p->next;++j;}return j;}//(8)在一个链表的尾部查入一个值为e的节点void ListInsertLast_L(LinkList L,ElemType e){ ListInsert_L(L,ListLength_L(L)+1,e);}//(9)删除链表的尾节点void ListDeleteLast_L(LinkList L){ListDelete_L(L,ListLength_L(L));}//(10)把链表的第i个值改为evoid Listchange(LinkList L,int i,ElemType e){LNode *p=L;int j=0;while (p->next&&j<i) {p=p->next;++j;}if(!(p->next)||j>i) exit(1);p->data=e;return;}//(11)链表中找值为e的节点的位置int ListFind(LinkList L,ElemType e){LNode *p=L;int j=0;while (p->next&&(p->data!=e)) {p=p->next;++j;}if(!(p->next)||j>ListLength_L(L)) exit(1);elsereturn j;}//(12)清空一个链表void ListClear_L(LinkList L){while (L->next) {ListDeleteLast_L(L);}}//四、主调函数void main(){LinkList L=CreateList_L(6);travel_L(L);printf("链表的第2个元素是：");printf("%c\n",GetElem_L(L,2));printf("链表的第2个位置插入值为w后的链表：");ListInsert_L(L,2,'w');travel_L(L);printf("删除链表的第2个位置上的节点后的链表：");ListDelete_L(L,2);travel_L(L);printf("删除链表的头节点后的链表：");ListDeleteFist_L(L);travel_L(L);printf("\n");printf("当前链表的长度为：");printf("%d",ListLength_L(L));printf("\n");printf("链表的尾部插入z后：");ListInsertLast_L(L,'z');travel_L(L);printf("\n");printf("删除链表的尾节点后：");ListDeleteLast_L(L);travel_L(L);printf("\n");printf("把第二个节点的值改为Y后：");Listchange(L,2,'Y');travel_L(L);printf("\n");printf("找链表中值为Y的位置：");printf("%d",ListFind(L,'Y'));printf("\n");printf("清空链表：");ListClear_L(L);travel_L(L);printf("\n");}【实验结果】输入abcdef六个元素时的运行结果：。

实验三链式存储

实验三链式存储一、实验目的和要求掌握线性表链式存储结构的描述，学会针对链式存储线性表的基本操作。

二、实验内容和原理C语言结构化程序设计思想，结构体及指针的应用。

三、主要仪器设备装有Visual C++/Turbo C++等C程序编译软件的计算机。

四、实验中程序的源码1. 设计一个算法，利用单链表原来的结点空间将一个单链表就地逆转。

程序代码如下：#include “linklist.h”V oid verge(linklist head ){ Linklist p,q;P->next=null;Head->next=null;While(p){q=p;P=p->next;q->next=head->next;Head->next=q;}}Int main(){Linklist head;Head=creatlinklist();Print(head);Verge()head;Print(head);}1.建立两个指针struct* p，q，p=head,q=p->next,即最开始p指向链表的第1项，q指向第2项2.if q->next !=NULL,p=p->next,q=q->next 3.endif q->next ==NULL,即q指向最后一项，p 指向倒数第二项新建一个指针，保存原表尾的地址struct*t=q4.q->next=p,q=p //倒数第一项指向倒数第二项，将q指向倒数第二项5.p=head //p重新重表头开始遍历6.if p->next !=q,p=p->next //如果p 指向的不是q指向的前一项，则p继续向后遍历7.endif p->next ==q //q指向p的前一项8. q->next =p,q=p //重复第4步9.p=head //重复第5步。

N. until q=p=head 至此，原链表已经完全逆转，然后让头指针指向原链表的表尾，即指向新链表的表头head=t，这样就搞定了这里写出程序源代码2. 设计一个算法，将一个结点值为自然数的单链表拆分成两个单链表，原表中保留值为偶数的结点，而值为奇数的结点按它们在原表中的相对次序组成一个新的单链表。

数据结构--实验报告线性表的基本操作

数据结构--实验报告线性表的基本操作数据结构实验报告[引言]在本次实验中,我们将学习线性表的基本操作,包括插入、删除、查找等。

通过实践操作,加深对线性表的理解和掌握。

[实验目的]1．学习线性表的基本概念和操作。

2.熟悉线性表的插入、删除和查找等基本操作。

3.掌握线性表的实现方式及其相应的算法。

［实验内容]１.线性表的定义与表示1．1 线性表的定义1.2 线性表的顺序存储结构１.3 线性表的链式存储结构2.线性表的基本操作２．１初始化线性表2.２判断线性表是否为空2.3 插入操作２.3.1 在指定位置插入元素2.3.2 在表尾插入元素2．4 删除操作2．4.1 删除指定位置的元素2．４．2 删除指定值的元素2．5 查找操作2.5.1 按位置查找元素2．5.2 按值查找元素２．6 修改操作2．６．１修改指定位置的元素 2.6.2 修改指定值的元素2.7 清空线性表2．8 销毁线性表[实验步骤]1.初始化线性表1.1 创建一个空的线性表对象１.2 初始化线性表的容量和长度2.插入操作2.１在指定位置插入元素2.1.1 检查插入位置的合法性2.1.2 将插入位置后的元素依次后移2.1．３在指定位置插入新元素2.2 在表尾插入元素２.2．1 将表尾指针后移2.2.2 在表尾插入新元素３.删除操作3.1 删除指定位置的元素３.1.1 检查删除位置的合法性3.１．2 将删除位置后的元素依次前移3.1.3 修改线性表的长度3.2 删除指定值的元素3.2.1 查找指定值的元素位置3.２.２调用删除指定位置的元素操作4.查找操作４.1 按位置查找元素4．1．1 检查查找位置的合法性4.1.2 返回指定位置的元素4.2 按值查找元素4.2．1 从头到尾依次查找元素4.2．2 返回第一个匹配到的元素5.修改操作5.１修改指定位置的元素５.１.1 检查修改位置的合法性5.1.２修改指定位置的元素值5.２修改指定值的元素5.2．1 查找指定值的元素位置5．２．２调用修改指定位置的元素操作6.清空线性表6．1 设置线性表长度为07.销毁线性表７.1 释放线性表的内存空间[实验结果]使用线性表进行各种基本操作的测试,并记录操作的结果和运行时间。

线性表的链式存储结构

1
线性表的链式存储结构
线性表的链式存储结构是指用一组任意的存储单元（可以连续，也可以不连续）存储线性表中的数据元素。为了反映数据元素之间的逻辑关系，对于每个数据元素不仅要表示它的具体内容，还要附加一个表示它的直接后继元素存储位置的信息。假设有一个线性表（a,b,c,d），可用下图2所示的形式存储：
27
p
s
图 2-9
28
完整的算法：
int DuListInsert(DuLinkList *L,int i,EntryType e)
if (L.head->next==NULL) return TRUE; else return FALSE; }
12
6. 通过e返回链表L中第i个数据元素的内容 void GetElem(LinkList L,int i,EntryType *e) {
LNode *p; int j; //j为计数器，记载所经过的结点数目 if (i<1||i>ListLength(L)) exit ERROR; //检测i值的合理性 for (p=L.head,j=0; j!=i;p=p->next,j++); //找到第i个结点 *e=p->data; //将第i个结点的内容赋给e指针所指向的存储单元中 }
10
4. 求链表L的长度
int ListLength(LinkList L)
{
LNode *p;
int len;
for(p=L.head, len=0;p->next==NULL; p=p->next,len++);
return(len);
循环条件表达式重复执行的语句

数据结构线性表实验报告

数据结构线性表实验报告数据结构线性表实验报告实验目的：本次实验主要是为了学习和掌握线性表的基本操作和实现方式。

通过实验，我们可以加深对线性表的理解，并能够熟悉线性表的基本操作。

实验设备与环境：本次实验所需的设备包括计算机和编程环境。

我们选择使用C语言来实现线性表的操作，并在Visual Studio Code编程软件中进行编写和调试。

实验内容：1.线性表的定义和基本操作1.1 线性表的定义：线性表是一种有序的数据结构，其中的元素按照一定的顺序存储，可以插入、删除和访问元素。

1.2 线性表的基本操作：1.2.1 初始化线性表：创建一个空的线性表。

1.2.2 判断线性表是否为空：判断线性表是否不含有任何元素。

1.2.3 获取线性表的长度：返回线性表中元素的个数。

1.2.4 在线性表的指定位置插入元素：在线性表的第i个位置插入元素x，原第i个及其之后的元素依次后移。

1.2.5 删除线性表中指定位置的元素：删除线性表中第i个位置的元素，原第i+1个及其之后的元素依次前移。

1.2.6 获取线性表中指定位置的元素：返回线性表中第i个位置的元素的值。

1.2.7 清空线性表：将线性表中的元素全部删除，使其变为空表。

2.线性表的顺序存储结构实现2.1 线性表的顺序存储结构：使用数组来实现线性表的存储方式。

2.2 线性表的顺序存储结构的基本操作：2.2.1 初始化线性表：创建一个指定长度的数组，并将数组中的每个元素初始化为空值。

2.2.2 判断线性表是否为空：判断线性表的长度是否为0。

2.2.3 获取线性表的长度：返回线性表数组的长度。

2.2.4 在线性表的指定位置插入元素：将要插入的元素放入指定位置，并将原位置及其之后的元素依次后移。

2.2.5 删除线性表中指定位置的元素：将指定位置的元素删除，并将原位置之后的元素依次前移。

2.2.6 获取线性表中指定位置的元素：返回指定位置的元素的值。

2.2.7 清空线性表：将线性表数组中的每个元素赋空值。

线性表的链式存储结构

石家庄经济学院实验报告学院: 信息工程学院专业: 计算机信息工程学院计算机实验中心制一实验内容1.进一步熟悉C 语言的上机环境，掌握C 语言的基本结构。

2.会定义线性表的链式存储结构。

3.熟悉对单链表的一些基本操作(建表、插入、删除等)和具体的函数定义。

二实验目的掌握链式存储结构的特点，了解、掌握并实现单链表的常用的基本算法。

三需求设计线性表抽象数据类型的描述及实现ADT List{数据对象： {|,,,,,0}i i D a a ElemSet i 12n n =∈=≥数据关系： {,|,,,,}i 1i i 1i R a a a a D i 2n --=<>∈=基本操作：构造一个空的线性表L InitList();销毁线性表L DestroyList();将L 重置为空表 ClearList();判断L 是否为空 ListEmpty();求表长 ListLength();查找元素 LocateElem();求前驱 PriorElem();求后继 NextElem();插入元素ListInsert();删除元素ListDelete();元素调用visit()函数ListTraverse(L,visit())}ADT List;程序具体实现要求：1.创建一个线性表2.能输出所有数据元素3.能求线性表长度4.能插入删除元素5.能查找元素6.能求元素的前驱和后继7.用户操作界面如下：*********************************** 1. 构造线性表* 2. 插入元素* 3. 删除元素* 4. 查找元素* 5. 显示表长* 6. 求后继* 7. 求前驱* 8. 输出所有元素* 0. 结束程序运行*********************************** 请输入您的选择(0,1,...,8):四详细设计步骤4：上机编程与调试主程序如下：#include "stdafx.h"#include "stdio.h"#include "LinkList0515.h"#include "user.h"#include "Fun.h"int main(int argc, char* argv[]){CLinkList0515 L;LinkList l;int flag,flag1=0,loc,e,next_e,pre_e;printf("\n**************************************"); printf("\n* 1. 构造单链表");printf("\n* 2. 插入元素");printf("\n* 3. 删除元素");printf("\n* 4. 查找元素");printf("\n* 5. 显示表长");printf("\n* 6. 求后继");printf("\n* 7. 求前驱");printf("\n* 8. 输出所有元素");printf("\n* 0. 结束程序运行");printf("\n**************************************");while(1){printf("\n请输入您的选择(0,1,...,8): ");scanf("%d",&flag);switch(flag){case 0:++flag1;break;case 1:if(OK==L.InitList_L(l))printf("\n成功完成单链表初始化操作!\n");elseprintf("\n操作失败，内存溢出!\n");break;case 2:printf("\n 请输入插入元素的位序,值（空格隔开）: ");scanf("%d %d",&loc,&e);if(ERROR==L.ListInsert_L(l,loc,e))printf("\n操作失败，可能是插入位序不合理!\n");elseprintf("\n成功完成操作!\n");L.ListTraverse_L(l,DisplayData);break;case 3:printf("\n 请输入被删除元素的位序: ");scanf("%d",&loc);if(ERROR==L.ListDelete_L(l,loc,e))printf("\n操作失败,可能是位序不合理!\n");else{ printf("\n元素 %d 成功被删除!\n",e);L.ListTraverse_L(l,DisplayData);}break;case 4:printf("\n 请输入待查找的元素的值: ");scanf("%d",&e);loc=L.LocateElem_L(l,e,compare);if(!loc)printf("\n表中不存在元素 %d !\n",e);elseprintf("\n找到了，元素 %d 在表中的位置是: %d \n",e,loc);break;case 5:printf("\n表长为: %d \n",L.ListLength_L(l));break;case 6:printf("\n 请输入元素的值: ");scanf("%d",&e);if(ERROR==L.NextElem_L(l,e,next_e))printf("\n表中元素 %d 没有后继!\n",e);elseprintf("\n表中元素%d 的后继是: %d\n",e,next_e);break;case 7:printf("\n 请输入元素的值: ");scanf("%d",&e);if(ERROR==L.PriorElem_L(l,e,pre_e))printf("\n表中元素 %d 没有前驱!\n",e);elseprintf("\n表中元素%d 的前驱是: %d \n",e,pre_e);break;case 8:L.ListTraverse_L(l,DisplayData);break;default:break;} //switchif(flag1==1) break;}//whileprintf("\n结束!\n\n\n");return 0;}运行结果如下：图3.1五实验总结1. 基本掌握线性表链式存储结构的特点；2. 基本掌握单链表的常用的基本操作算法；3. 通过线性表的抽象数据类型的学习，进一步掌握抽象数据类型的定义方法；4. 对于同一个线性表，用顺序结构和链式存储结构实现，算法也不同；从而可知，逻辑结构依赖于物理结构；。

线性表的链式存储结构实验报告

贵州大学实验报告学院：计算机科学与信息学院专业：信息安全班级：chaintable *Buildtable(int x[],int y) {chaintable *p,*head;p=new chaintable;head=p;p->data=x[0];for(int i=1;i<y;i++){p->next=new chaintable;p=p->next;p->data=x[i];}p->next=NULL;return head;}bool Deltable(chaintable *&head,int x) {if(x<1)return false;chaintable *relief,*p=head;for(int i=0;i<x-2;i++){if(p->next==NULL)return false;p=p->next;}if(x==1){relief=head;head=head->next;delete relief;if(head!=NULL)return true;elsereturn false;}else{if(p->next!= NULL){relief=p->next;p->next=p->next->next;delete relief;return true;}elsereturn false;}}bool Inserttable(chaintable *&head,int x,int y) {if(y<0)return false;chaintable *p=head,*t=new chaintable;t->data=x;t->next=NULL;if(y==0){t->next=head;head=t;return true;}else{for(int i=0;i<y-1;i++){if(p->next==NULL)return false;p=p->next;}t->next=p->next;p->next=t;return true;}}void Disptable(chaintable *p){while(p!=NULL){cout<<p->data<<' ';p=p->next;}cout<<endl;}bool Searchtable(chaintable *p,int &y,int x) {if(x>=1){for(int i=0;i<x-1;i++){if(p->next==NULL)return false;p=p->next;}y=p->data;return true;}elsereturn false;}int Location(chaintable *p,int x){int i=1;while(p!=NULL){if(p->data==x)return i;i++;p=p->next;}return 0;}void main(){int x,*temp,result;chaintable *head;cin>>x;temp=new int[x];for(int i=0;i<x;i++)cin>>temp[i];head=Buildtable(temp,x);if(Deltable(head,2)){cout<<"删除操作结果：";Disptable(head);}elsecout<<"操作失败！"<<endl;if(Inserttable(head,23,5)){cout<<"将23插入到第五个数字后面的操作结果：";Disptable(head);}elsecout<<"操作失败！"<<endl;if(Searchtable(head,result,4)){cout<<"链表的第四个数是：";cout<<"Search result:"<<result<<endl;}elsecout<<"操作失败！"<<endl;cout<<"Please input your integer:";cin>>x;cout<<"Location:"<<Location(head,x)<<endl;}实验结果：实验总结结果说明:1、第一行的8表示链表初始有8个数2、第二行的8个数是链表初始化的8个数3、第三行的结果是从链表删除了第二个数后的结果4、第五行的结果是搜索链表第四个数5、第六行是输入一个数要搜索的数（图中为25），第七行得出了搜索的结果。

线性表的实验报告

线性表的实验报告线性表的实验报告概述：线性表是一种常见的数据结构，它是由一组具有相同数据类型的元素组成的序列。

本次实验旨在通过实际操作线性表，掌握线性表的基本操作以及了解其应用场景。

实验目的：1. 理解线性表的概念和基本操作；2. 掌握线性表的顺序存储结构和链式存储结构；3. 熟悉线性表的常见应用场景。

实验材料：1. 计算机；2. 编程软件（如C、C++、Java等）；3. 实验教材或参考资料。

实验步骤：一、线性表的顺序存储结构实验1. 创建一个空的线性表；2. 向线性表中插入若干元素；3. 删除线性表中的某个元素；4. 根据索引查找线性表中的元素；5. 遍历线性表，输出所有元素。

二、线性表的链式存储结构实验1. 创建一个空的链表；2. 向链表中插入若干节点；3. 删除链表中的某个节点；4. 根据节点值查找链表中的节点；5. 遍历链表，输出所有节点。

实验结果：1. 顺序存储结构实验结果：- 成功创建空的线性表；- 成功插入若干元素；- 成功删除某个元素；- 成功根据索引查找元素；- 成功遍历线性表，输出所有元素。

2. 链式存储结构实验结果：- 成功创建空的链表；- 成功插入若干节点；- 成功删除某个节点；- 成功根据节点值查找节点；- 成功遍历链表，输出所有节点。

实验分析：1. 顺序存储结构适用于元素个数固定或变化不大的情况，插入和删除操作需要移动大量元素，效率较低；2. 链式存储结构适用于元素个数不固定的情况，插入和删除操作只需修改指针，效率较高；3. 线性表的应用场景包括但不限于：图书馆图书管理系统中的图书列表、学生信息管理系统中的学生列表等。

实验总结：通过本次实验，我深入了解了线性表的概念、基本操作以及两种常见存储结构。

顺序存储结构适用于元素个数固定的情况，而链式存储结构适用于元素个数不固定的情况。

线性表在实际应用中有着广泛的应用场景，如图书馆管理系统、学生信息管理系统等。

在以后的学习和工作中，我将灵活运用线性表，为解决实际问题提供便利。

线性表的链式存储结构实验报告

线性表的链式存储结构实验报告实验一：线性表的链式存储结构【问题描述】某项比赛中，评委们给某参赛者的评分信息存储在一个带头结点的单向链表中，编写程序：（1）显示在评分中给出最高分和最低分的评委的有关信息（姓名、年龄、所给分数等）。

（2）在链表中删除一个最高分和一个最低分的结点。

（3）计算该参赛者去掉一个最高分和一个最低分后的平均成绩。

【基本要求】（1）建立一个评委打分的单向链表；（2）显示删除相关结点后的链表信息。

（3）显示要求的结果。

【实验步骤;】（1）运行PC中的Microsoft Visual C++ 6.0程序，（2）点击“文件”→“新建”→对话窗口中“文件”→“c++ Source File”→在“文件名”中输入“X1.cpp”→在“位置”中选择储存路径为“桌面”→“确定”，（3）输入程序代码，程序代码如下:head=create(PWRS);printf("所有评委打分信息如下:\n");print(head);//显示当前评委打分calc(head);//计算成绩printf("该选手去掉 1 最高分和 1 最低分后的有效评委成绩:\n");print(head);//显示去掉极限分后的评委打分}void input(NODE *s) #include#include#include#include#include#define NULL 0#define PWRS 5 //定义评委人数struct pw //定义评委信息{ char name[6];float score;int age;};typedef struct pw PW;struct node //定义链表结点{struct pw data;struct node * next;};typedef struct node NODE;//自定义函数的声明NODE *create(int m); //创建单链表int calc(NODE *h); //计算、数据处理void print(NODE *h); //输出所有评委打分数据void input(NODE *s);//输入评委打分数据void output(NODE *s);//输出评委打分数据void main(){NODE *head;float ave=0;float sum=0;{printf("请输入评委的姓名: ");scanf("%S",&s->/doc/433085523.html,); printf("年龄: ");scanf("%d",&s->data.age);printf("打分: ");scanf("%f",&s->data.score);printf("\n");}void output(NODE *s){printf("评委姓名: %8s ,年龄: %d,打分: %2.2f\n",s->/doc/433085523.html,,s->data. age,s->data.score);}NODE *create(int m){NODE *head,*p,*q;int i;p=(NODE*)malloc(sizeof(NODE));head=p;q=p;p->next=NULL;for(i=1;i<=m;i++){p=(NODE*)malloc(sizeof(NODE));input(p);p->next=NULL;q->next=p;q=p;}return (head);}void print(NODE *h){ for(int i=1;((i<=PWRS)&&(h->next!=NULL));i++){h=h->next;output(h); }printf("\n");}int calc(NODE *h){NODE *q,*p,*pmin,*pmax;float sum=0;float ave=0;p=h->next; //指向首元结点pmin=pmax=p; //设置初始值sum+=p->data.score;p=p->next;for(;p!=NULL;p=p->next){if(p->data.score>pmax->data.score) pmax=p;if(p->data.scoredata.score) pmin=p;sum+=p->data.score;}cout<<"给出最高分的评委姓名："</doc/433085523.html,<<"年龄："<data.age<<"分值："<data.score<<endl;< bdsfid="172" p=""></endl;<>cout<<"给出最低分的评委姓名："</doc/433085523.html,<<"年龄："<data.age<<"分值："<data.score<<endl;< bdsfid="177" p=""></endl;<>printf("\n");sum-=pmin->data.score;sum-=pmax->data.score;for (q=h,p=h->next;p!=NULL;q=p,p=p->next){if(p==pmin){q->next=p->next; p=q;}//删除最低分结点if(p==pmax) {q->next=p->next; p=q;}//删除最高分结点}ave=sum/(PWRS-2);cout<<"该选手的最后得分是："<<ave<<endl;< bdsfid="188" p=""></ave<<endl;<>return 1;}实验结束。

线性表的链式存储,多项式的加减乘除四则运算报告

多项式实验报告2011-4-9实验题目：一元多项式的表示及四则运算实验目的：1.了解线性表的链式存储结构，熟悉掌握链表2.了解作为链表的多项式存储方式3.熟悉掌握多项式加减乘除四则运算的算法实验内容:一、抽象数学模型：ADT Polynomial{数据对象：D={ai|ai∈TermSet,i=1,2,···，m, m>=0TermSet中的每个元素包含一个表示系数的实数和表示指数的整数} 数据关系：R1={<ai-1,ai>|ai-1,ai∈D,且ai-1中的指数值<ai中的指数值，i=2,···，n}基本操作：Insert(p,h);初始条件：多项式p与h已存在操作结果：合并指数相同的项CreatePolyn(& head, m)操作结果：建立一个头指针为head、项数为m的一元多项式DestroyPolyn(& p)初始条件：一元多项式P已存在操作结果：销毁多项式pPrintPolyn( P)初始条件：一元多项式P已存在操作结果：打印输出一元多项式PAddPolyn(&pa,& pb)初始条件：一元多项式Pa和Pb已存在操作结果：求解并建立多项式Pa=Pa+Pb, 返回其头指针SubtractPolyn(& pa，& pb)初始条件：一元多项式Pa和Pb已存在操作结果：求解并建立多项式Pa=Pa-Pb，返回其头指针MultiplyPolyn(& pa,& pb)初始条件：一元多项式Pa和Pb已存在操作结果：求解并建立多项式Pa=Pa*Pb，返回其头指针DevicePolyn(& pa,& pb)初始条件：一元多项式Pa和Pb已存在操作结果：求解并建立多项式Pa=Pa/Pb，返回其头指针}ADT Polynomial二、算法描述：为了实现上述程序功能，根据一元多项式的特点，可以构造链式存储的线性表存放一元多项式各式的信息。

线性表的链式存储

线性表的链式存储
链式存储是一种重要的线性表存储结构。

它将存储节点链接在一起，它的实现方式是利用链表中的每个结点的指针指向下一个节点。

它可以节约空间，内存占用更少，能够提高存取效率。

首先，讨论一下链式存储的优势：和其它存储技术相比，链式存储可以更有效地实现存储结构。

它可以将链表中的节点按照顺序优先级进行存储，这样可以使得存储空间的利用率更高，要么就可以摆脱固定的存储空间结构，而可以根据实际情况来调整存放的数据顺序，从而达到了更高的存储效率。

其次，也要讨论一下链式存储的实现方式：链式存储的实现方式是通过把结点按照一定顺序进行链接。

每个节点都有一个指针指向下一个节点，这样就可以实现链表中的元素按照顺序进行存放，从而可以节约内存空间，使得数据分配更有灵活性。

同时，还要讨论一下链式存储的缺点：由于链表存储结构的特殊性，对于寻址来说具有一定的弊端。

由于链表中的每一个节点都是依赖于前一个节点的，所以如果要访问链表的某一节点，就必须从前一个节点一直遍历到该节点，这就需要额外的存取时间，从而影响了系统的性能。

总的来说，链式存储的实现方式对线性表的存储具有重要的意义，它可以在更小的存储空间内提供更低的存储量，使得数据分配更有灵活性，使得系统的空间利用率更高。

然而，它也会因为寻址的弊端而降低存储和检索数据的效率，所以在使用的时候要根据实际情况来权衡它的优势和劣势的。

参考文献
1.船井,贺一.(2018).《数据结构与算法》.西南财经大学出版社
2.王晓阳.《数据结构与算法设计》.清华大学出版社。

线性表的链式存储结构实验报告

线性表的链式存储结构实验报告文件编码（008-TTIG-UTITD-GKBTT-PUUTI-WYTUI-8256）实验报告课程名称：数据结构与算法分析实验名称：链表的实现与应用实验日期：班级：数媒1401 姓名：范业嘉学号 08一、实验目的掌握线性表的链式存储结构设计与基本操作的实现。

四、算法设计1.定义一个链表void creatlist(Linklist &L,int n){int i;Linklist p,s;L=(Linklist)malloc(sizeof(Lnode));p=L;L->next=NULL;for(i=0;i<n;i++){s=(Linklist)malloc(sizeof(Lnode));scanf("%d",&s->data);s->next=NULL;p->next=s; p=s;}}2.（1）两个链表的合并void Mergelist(Linklist &La,Linklist &Lb,Linklist &Lc) {Linklist pa,pb,pc;pa=La->next;pb=Lb->next;Lc=pc=La;while(pa&&pb){if(pa->data<=pb->data){pc->next=pa;pc=pa;pa=pa->next;}else {pc->next=pb;pc=pb;pb=pb->next;} }pc->next=papa:pb;free(Lb);}（2）两个链表的并集Linklist unionlist(Linklist &La,Linklist &Lb){Linklist p1,p2,head,q,s;int flag;head=q=(Linklist)malloc(sizeof(Lnode));p1=La->next;while(p1){flag=0;p2=Lb->next;while(p2){if(p1->data==p2->data){flag=1;break;}p2=p2->next;}if(flag==0){s=(Linklist)malloc(sizeof(Lnode));s->data=p1->data;q->next=s;q=s;}p1=p1->next;}q->next=Lb->next;return head;}3.（1）一元多项式的加法List addpoly(List pa,List pb)3.六、心得体会（包括对于本次实验的小结，实验过程中碰到的问题等）1.首先书上给的链表输入是倒序的，写的时候想都没想就抄上去了，结果运行时发现问题，可是上网百度依然没有把问题解决，导致最后输出链表倒序的，并且链表的合并并集依旧是倒序的。

链式存储的实验报告

实验名称：线性表的链式存储结构实验日期：2022年X月X日班级：XX班姓名：XXX学号：XXXXXXX指导教师：XXX一、实验目的1. 理解线性表的链式存储结构及其特点。

2. 掌握链表的基本操作，如创建、插入、删除、查找和遍历等。

3. 通过实际编程实现链表，加深对链式存储结构概念的理解。

二、实验内容与要求1. 定义线性表的链式存储表示，包括节点结构和链表结构。

2. 实现链表的基本操作，如创建链表、插入节点、删除节点、查找节点和遍历链表等。

3. 编写测试代码，验证链表操作的正确性。

三、实验步骤1. 定义链表节点结构体，包含数据和指向下一个节点的指针。

2. 创建链表结构体，包含指向头节点的指针和节点数量。

3. 实现链表创建操作，初始化链表。

4. 实现链表插入操作，包括在链表头部、尾部和指定位置插入节点。

5. 实现链表删除操作，包括删除链表头部、尾部和指定位置的节点。

6. 实现链表查找操作，根据节点数据查找节点在链表中的位置。

7. 实现链表遍历操作，打印链表中的所有节点数据。

8. 编写测试代码，验证链表操作的正确性。

四、实验代码```c#include <stdio.h>#include <stdlib.h>// 定义链表节点结构体typedef struct Node {int data;struct Node next;} Node;// 创建链表Node createList() {Node head = (Node)malloc(sizeof(Node));if (head == NULL) {printf("Memory allocation failed!\n"); return NULL;}head->next = NULL;return head;}// 在链表头部插入节点void insertAtHead(Node head, int data) {Node newNode = (Node)malloc(sizeof(Node)); if (newNode == NULL) {printf("Memory allocation failed!\n"); return;}newNode->data = data;newNode->next = head->next;head->next = newNode;}// 在链表尾部插入节点void insertAtTail(Node head, int data) {Node newNode = (Node)malloc(sizeof(Node)); if (newNode == NULL) {printf("Memory allocation failed!\n"); return;}newNode->data = data;newNode->next = NULL;Node current = head;while (current->next != NULL) {current = current->next;}current->next = newNode;}// 删除链表头部节点void deleteAtHead(Node head) {if (head->next == NULL) {printf("List is empty!\n");return;}Node temp = head->next;head->next = temp->next;free(temp);}// 删除链表尾部节点void deleteAtTail(Node head) {if (head->next == NULL) {printf("List is empty!\n");return;}Node current = head;while (current->next->next != NULL) { current = current->next;}Node temp = current->next;current->next = NULL;free(temp);}// 删除指定位置的节点void deleteAtPosition(Node head, int position) {if (head->next == NULL || position < 0) {printf("Invalid position!\n");return;}Node current = head;int index = 0;while (current->next != NULL && index < position - 1) { current = current->next;index++;}if (current->next == NULL) {printf("Invalid position!\n");return;}Node temp = current->next;current->next = temp->next;free(temp);}// 查找节点Node findNode(Node head, int data) {Node current = head->next;while (current != NULL) {if (current->data == data) { return current;}current = current->next;}return NULL;}// 遍历链表void traverseList(Node head) {Node current = head->next;while (current != NULL) {printf("%d ", current->data); current = current->next;}printf("\n");}// 释放链表内存void freeList(Node head) {Node current = head;while (current != NULL) {Node temp = current;current = current->next;free(temp);}}int main() {Node head = createList();insertAtHead(head, 3);insertAtHead(head, 2);insertAtHead(head, 1);insertAtTail(head, 4);insertAtTail(head, 5);printf("Original list: ");traverseList(head);deleteAtHead(head);deleteAtTail(head);printf("List after deleting head and tail: ");traverseList(head);deleteAtPosition(head, 1);printf("List after deleting node at position 1: ");traverseList(head);Node node = findNode(head, 3);if (node != NULL) {printf("Node with data 3 found at position: %d\n", (head->next == node ? 1 : (head->next != NULL ? 2 : 3)));} else {printf("Node with data 3 not found.\n");}freeList(head);return 0;}```五、实验结果与分析1. 通过实验，成功实现了线性表的链式存储结构，包括创建、插入、删除、查找和遍历等基本操作。

1101080125链式线性表实验报告

printf("第%d个元素为%d\n",i,p->data);/*找到测输出它*/
return p;}
else return NULL;
}
void printlist(LinkList L) /*遍历整个线性表*/
{L=L->next;
while((L->next)!=NULL)
{printf("%d ",L->data);
有了第一次实程的实实所以实次的实程不吃了因实有了思想了在上次的基实上加以修改就好了
实验3：线性表的链式存储结构基本操作的实现
实验
目的
给出实验的目的：设计一个带头结点的有序单链表类型LList并实现以下功能
1.初始化线性链表
2.创建线性表
3.插入数据
4查找指定元素
5.遍历
0.退出
实验
内容
给出实验的内容：把每个功能分块分别编制实现以下功能的子程序
k=k+1;
}
if(!pre)
{
printf("插入位置不合理");
return 0;
}s=(Node *) malloc(sizeof(Node));
s->data=e;
s->next=pre->next;
pre->next=s;
return 1;
}
Node *get(LinkList L) /*在带头节点的单链表L中查找第i个结点*/
1.初始化线性链表
2.创建线性表
3.插入数据
4查找指定元素
5.遍历
0.退出
然后再主程序中调用。
实验
步骤

实验3 线性表的链式存储

线性表的链式存储,实验报告

实验三 单链表的基本操作

第3章线性表的链式存储

数据结构线性表实验报告

实验三+线性表的链式存储.doc

实验三 链式存储

数据结构--实验报告 线性表的基本操作

线性表的链式存储结构

数据结构线性表实验报告

线性表的链式存储结构

线性表的链式存储结构实验报告

线性表的实验报告

线性表的链式存储结构实验报告

线性表的链式存储,多项式的加减乘除四则运算报告

线性表的链式存储

线性表的链式存储结构实验报告

链式存储的实验报告

1101080125链式线性表实验报告

实验三单链表的基本操作

实验三链式存储

数据结构--实验报告线性表的基本操作