实验3 线性表的链式存储结构的表示与实现
线性表的链式存储,实验报告
![线性表的链式存储,实验报告](https://img.taocdn.com/s3/m/2acd3c1bf02d2af90242a8956bec0975f465a418.png)
线性表的链式存储,实验报告线性表的链式存储结构实验报告实验报告课程名称:数据结构与算法分析实验名称:链表的实现与应用实验日期: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.需解决的的问题利用线性表的链式存储结构,设计一组输入数据。
线性表的链式表示和实现解析
![线性表的链式表示和实现解析](https://img.taocdn.com/s3/m/608e2ded4693daef5ef73d46.png)
头结点 复习:
a1
a2
p 结点
… ...
an ^
p 指针和 p 结点的区别: L是带头结点的链表的头指针,即L指向头结点,p为指针变 量,写出语句 p指向头结点: p指向第一个结点: p指向p结点的下一个结点: p=L p=L->next p=p->next
头指针
L
空指针
头结点
a1
a2
… ...
P=L; while (P!= NULL ) p=p->next; p=NULL
改进的 ClearList(L) :
p
L
///
…
^
void ClearList(LinkList L) { while (L->next) { p=L->next;
int LListlen(LinkList L ) { n=0; p=L ; while ( p->next ) { p=p->next; L->next=p->next; n++; } free(p) ; 算法时间复杂度: return n; } } } // ClearList O(ListLength(L))
Typedef struct LNode {ElemType data; // 数据域 struct Lnode *next; // 指针域 } LNode, *LinkList;
// LNode 为结构变量类型名, LinkList 为结构指针类型名 LinkList p;// p 为指针变量, 分配给 p 一个指针变量; p = (LinkList) malloc (sizeof (LNode)); p 或 p = (LNode*) malloc (sizeof (LNode));
线性表的链式表示和实现(插入删除建空合并)
![线性表的链式表示和实现(插入删除建空合并)](https://img.taocdn.com/s3/m/13fc017526d3240c844769eae009581b6bd9bdcb.png)
线性表的链式表⽰和实现(插⼊删除建空合并)题解:后续的功能会不定期更新emmm框架:代码:#include <iostream>#include <cstdio>using namespace std;typedef struct LNode{int data;struct LNode *next;}LNode,*LinkList;int GetElem_L(LinkList L, int i, int &e){LNode *p = L->next;int j = 1;while (p&&j < i){p = p->next;++j;}if (!p || j>i)return0;e = p->data;return1;}int ListInsert_L(LinkList &L, int i, int e){LNode *p = L->next;int j = 1;while (p && j < i-1){p = p->next;++j;}if (!p || j>i-1)return0;LNode *node =(LNode*)malloc(sizeof(LNode));node->data = e;LNode* q = p->next;p->next = node;node->next = q;return1;}int ListDelete_L(LinkList &L, int i, int &e){LNode *p = L->next;int j = 1;while (p->next&&j < i - 1)//注意此处为p->next,因为若是p,则出来的p可能为空 {p = p->next;++j;}if (!p->next || j>i - 1)return0;LNode*q= p->next;e = q->data;p->next = p->next->next;free(q);return1;}void CreateList_L(LinkList &L, int n){printf("Enter the value of the node:");// L = (LinkList)malloc(n*sizeof(LNode)); 如果像这样创建的话,//那就是⽣成连续存储空间的线性表,应该单独对每⼀个节点分配内存空间L = (LinkList)malloc(sizeof(LNode));L->next = nullptr;//先⽣成⼀个表头的单链表for (int i = n;i > 0;--i){LNode *p = (LinkList)malloc(sizeof(LNode));cin>>p->data;p->next = L->next;//插⼊⽅式为向表头的后⼀个插⼊,不然插在表尾太⿇烦 L->next = p;}}void MergeList_L(LinkList &L,LinkList &Lb,LinkList &Lc)//合并{LNode *p=L->next;LNode *pb=Lb->next;LNode *pc=Lc=L;while(p&&pb){if(p->data<=pb->data){pc->next=p;pc=p;p=p->next;}else{pc->next=pb;pc=pb;pb=pb->next;}}pc->next=p?p:pb;free(Lb);}/*int Length_L(LinkList &L)//计算长度{int j=0;LNode *p=L->next;while(p){p=p->next;j++;}return j;}*/ //没⽤到emmmmvoid ShowList(LinkList &L){LNode *p = L->next;while (p){cout<<p->data<<"";p = p->next;}}int main(){LinkList L;cout<<"Enter the length of the linked list:";int num;cin>>num;CreateList_L(L, num);//建表ShowList(L);//展⽰int e1,temp;cout<<"\nTo increase the number of positions:";int place;cin>>place;cout<<"\nEnter the number to insert:";cin>>e1;ListInsert_L(L, place, e1);ShowList(L);cout<<"\nThe number of digits to be deleted:";int place1;cin>>place1;ListDelete_L(L, place1, temp);ShowList(L);printf("\nThe deleted node value is :%d\n", temp);LinkList Lb,Lc;cout<<"\nEnter the length of the linked list:";int num1;cin>>num1;CreateList_L(Lb, num1);//建表cout<<"\nThe two linked lists are:";MergeList_L(L,Lb,Lc);ShowList(L);cout<<endl;return0;}今天也是元⽓满满的⼀天!good luck!。
线性表的链式表示和实现—链表
![线性表的链式表示和实现—链表](https://img.taocdn.com/s3/m/48e58a2afe4733687f21aa65.png)
/*调用myList的析构函数*/
MyList的存储结构
(带头结点的空表)
head size 0
next NULL data
▪ 单链表求表长函数
int LinList<T>::Size(void) const {
return size; }
思考1:int LinList<T>::IsEmpty( ) const 如何实 现?——判断单链表空否
2.3.1 单链表的存储结构
◆ 结点结构:链表每个结点中只有一个指针 域指向直接后继结点。 data next 数据域 指针域
数据域:元素本身信息
指针域:指示直接后继的存储位置
结点类的定义 LinList.h文件实现单链表类
template <class T> class LinList; //前视定义,否则友元无法定义
//j从0开始计数
while(p != NULL && j < i) //寻找第i个结点
{ p = p->next; j++; }
return p;
//返回第i个结点的指针
} 思考2:ListNode<T> * LinList<T>::Find(T x) 如何实现?——
查找第一个值为x的元素在单链表的结点
单链表类的定义
template <class T>
class LinList
{
private:
ListNode<T> *head;
//头指针
int size;
//当前数据元素个数
ListNode<T> *Index(int i); //定位函数
实验三+线性表的链式存储.doc
![实验三+线性表的链式存储.doc](https://img.taocdn.com/s3/m/864cee0d58fb770bf78a552e.png)
实验三线性表的链式存储【实验目的】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六个元素时的运行结果:。
实验三 链式存储
![实验三 链式存储](https://img.taocdn.com/s3/m/47ee3c0fbed5b9f3f80f1c06.png)
实验三链式存储一、实验目的和要求掌握线性表链式存储结构的描述,学会针对链式存储线性表的基本操作。
二、实验内容和原理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. 设计一个算法,将一个结点值为自然数的单链表拆分成两个单链表,原表中保留值为偶数的结点,而值为奇数的结点按它们在原表中的相对次序组成一个新的单链表。
数据结构C语言版 线性表的单链表存储结构表示和实现
![数据结构C语言版 线性表的单链表存储结构表示和实现](https://img.taocdn.com/s3/m/57275d3982c4bb4cf7ec4afe04a1b0717fd5b3c5.png)
#include 〈stdio.h>#include <malloc。
h>#include 〈stdlib.h>/*数据结构C语言版线性表的单链表存储结构表示和实现P28—31编译环境:Dev-C++ 4。
9。
9。
2日期:2011年2月10日*/typedef int ElemType;// 线性表的单链表存储结构typedef struct LNode{ElemType data; //数据域struct LNode *next;//指针域}LNode, *LinkList;// typedef struct LNode *LinkList;// 另一种定义LinkList的方法// 构造一个空的线性表Lint InitList(LinkList *L){/*产生头结点L,并使L指向此头结点,头节点的数据域为空,不放数据的。
void *malloc(size_t)这里对返回值进行强制类型转换了,返回值是指向空类型的指针类型.*/(*L)= (LinkList)malloc(sizeof(struct LNode) );if( !(*L))exit(0);// 存储分配失败(*L)-〉next = NULL;// 指针域为空return 1;}// 销毁线性表L,将包括头结点在内的所有元素释放其存储空间。
int DestroyList(LinkList *L){LinkList q;// 由于单链表的每一个元素是单独分配的,所以要一个一个的进行释放while(*L ){q = (*L)—〉next;free(*L );//释放*L = q;}return 1;}/*将L重置为空表,即将链表中除头结点外的所有元素释放其存储空间,但是将头结点指针域置空,这和销毁有区别哦。
不改变L,所以不需要用指针。
*/int ClearList( LinkList L ){LinkList p,q;p = L—〉next;// p指向第一个结点while( p ) // 没到表尾则继续循环{q = p—>next;free( p );//释放空间p = q;}L—>next = NULL; // 头结点指针域为空,链表成了一个空表return 1;}// 若L为空表(根据头结点L—〉next来判断,为空则是空表),则返回1,// 否则返回0.int ListEmpty(LinkList L){if(L—>next ) // 非空return 0;elsereturn 1;}// 返回L中数据元素个数。
数据结构线性表实验报告
![数据结构线性表实验报告](https://img.taocdn.com/s3/m/c18020b485868762caaedd3383c4bb4cf6ecb767.png)
数据结构线性表实验报告数据结构线性表实验报告实验目的:本次实验主要是为了学习和掌握线性表的基本操作和实现方式。
通过实验,我们可以加深对线性表的理解,并能够熟悉线性表的基本操作。
实验设备与环境:本次实验所需的设备包括计算机和编程环境。
我们选择使用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 清空线性表:将线性表数组中的每个元素赋空值。
线性表的链式存储结构和实现
![线性表的链式存储结构和实现](https://img.taocdn.com/s3/m/2f06ce57680203d8cf2f24ba.png)
经济学院实验报告学院: ______专业:计算机班级: ________________学号: ____________姓名:_________________信息工程学院计算机实验中心制实验题目:线性表的链式存储结构和实现实验室:机房4 设备编号: 09 完成日期:2012. ()4. ()9一、实验容1.会定义线性表的链式存储结构。
2.熟悉对单链表的一些基本操作(建表、插入、删除等)和具体的函数定义。
二、实验目的学握链式存储结构的特点,掌握并实现单链表的常用的基本算法。
三、实验的容及完成情况1.需求分析(1)线性表的抽象数据类型ADT的描述及实现。
本实验实现使用Visual c卄6.0实现线性表链式存储结构的表示及操作。
具体实现要求:(2)完成对线性表链式存储结构的表示和实现。
(3)实现对单链表的创建。
(4)实现对单链表的插入和删除操作。
2.概要设计抽象数据类型线性表的定义:ADT LIST{抽象对象:D= {ai | ai<-Elemset, i = l,2, •••,n,n>=0}数据关系:Rl= {<ai-l,ai<-DJ=2.-,n}基本操作:InitList(&L)操作结果:构造一个空的线性表L。
DestoryList(&L)初始条件:线性表L已存在。
操作结果:销毁线性表LCLearList(&L)初始条件:线性表L已存在。
操作结果:将L重置为空表。
ListEmpty(L)初始条件:线性表L已存在。
操作结果:若L为空表,则返回TRUE,否则返回FALSE。
ListLength(L)初始条件:线性表L已存在。
操作结果:返回L中数据元素个数。
GetElem(L,I,&e)初始条件:线性表L已存在,l<=i<=ListLength(L)o操作结果:用e返回L中第i个数据元素的值。
LocateElem(L,e,compare())初始条件:线性表L已存在,compare()是数据元素判定的函数。
线性表的链式存储结构实验报告
![线性表的链式存储结构实验报告](https://img.taocdn.com/s3/m/04a0209a87c24028915fc3c3.png)
贵州大学实验报告学院:计算机科学与信息学院专业:信息安全班级: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),第七行得出了搜索的结果。
线性表的链式存储结构实验报告
![线性表的链式存储结构实验报告](https://img.taocdn.com/s3/m/73e729f8db38376baf1ffc4ffe4733687e21fced.png)
线性表的链式存储结构实验报告实验一:线性表的链式存储结构【问题描述】某项比赛中,评委们给某参赛者的评分信息存储在一个带头结点的单向链表中,编写程序:(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;}实验结束。
线性表的链式存储结构实验报告
![线性表的链式存储结构实验报告](https://img.taocdn.com/s3/m/c0d4a70d1a37f111f0855b68.png)
线性表的链式存储结构实验报告文件编码(008-TTIG-UTITD-GKBTT-PUUTI-WYTUI-8256)实验报告课程名称:数据结构与算法分析实验名称:链表的实现与应用实验日期:班级:数媒1401 姓名:范业嘉学号 08一、实验目的掌握线性表的链式存储结构设计与基本操作的实现。
二、实验内容与要求⑴定义线性表的链式存储表示;⑵基于所设计的存储结构实现线性表的基本操作;⑶编写一个主程序对所实现的线性表进行测试;⑷线性表的应用:①设线性表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;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.首先书上给的链表输入是倒序的,写的时候想都没想就抄上去了,结果运行时发现问题,可是上网百度依然没有把问题解决,导致最后输出链表倒序的,并且链表的合并并集依旧是倒序的。
链式存储的实验报告
![链式存储的实验报告](https://img.taocdn.com/s3/m/63482b3c0a1c59eef8c75fbfc77da26925c59694.png)
实验名称:线性表的链式存储结构实验日期: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链式线性表实验报告
![1101080125链式线性表实验报告](https://img.taocdn.com/s3/m/c4c31721af45b307e87197a9.png)
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.退出
然后再主程序中调用。
实验
步骤
线性表的链式表示和实现
![线性表的链式表示和实现](https://img.taocdn.com/s3/m/fb5a3f0bfc4ffe473368ab43.png)
// 删除以 L 为头指针(带头结点)的单链表中第 i 个结点
if (!(p->next) || j > i-1) return ERROR; // 删除位置不合理 q = p->next; p->next = q->next; //删除并释放结点 e = q->data; free(q); return OK; } // ListDelete_L
s (c) 插入第一个结点
执行的语句组为:s -> nex t=L-> nex t;L-> nex t=s ;
void CreateList_L(LinkList &L, int n) {
// 头插法建立带头结点的单链表 L = (LinkList) malloc (sizeof (LNode)); L->next = NULL; // 先建立一个带头结点的单链表
例1:两个链表的归并(教材P31例) 请将该例子和ch2-1的ppt的第18页进行比较! 算法要求:
已知:线性表 A和B,分别由单链表 La和Lb 存储,其中 数据元素按值非递减有序排列(即已经有序); 要求:将A和B归并为一个新的线性表C , C的数据元素仍 按值非递减排列。设线性表C由单链表 Lc 存储。
链表是一个动态的结构,它不需要预先分配空间,因 此生成链表的过程是一个结点“逐个插入” 的过程。 例如:头插法输入 n 个数据元素的值,建立带头结 点的单链表。 操作步骤: 一、建立一个“空表”; 二、输入数据元素an, 建立结点并插入; 三、输入数据元素an-1, 建立结点并插入表头; 四、依次类推,直至输入a1为止。
讨论1: 如何表示空表?
无头结点时,当头指针的值为空时表示空表; 有头结点时,当头结点的指针域为空时表示空表。 头指针 头指针 头结点 头结点不计入 ^ ^ 链表长度! 有头结点 无头结点
数据结构实验报告三线性表的链式存储
![数据结构实验报告三线性表的链式存储](https://img.taocdn.com/s3/m/4cb29d215bcfa1c7aa00b52acfc789eb162d9e0a.png)
实验报告三线性表的链式存储班级: 2010XXX 姓名: HoogLe 学号: 2010XXXX 专业: XXXX*****************(1)实验目的:(2)掌握单链表的基本操作的实现方法。
(3)掌握循环单链表的基本操作实现。
(4)掌握两有序链表的归并操作算法。
实验内容: (请采用模板类及模板函数实现)1.线性表链式存储结构及基本操作算法实现[实现提示] (同时可参见教材p64-p73页的ADT描述及算法实现及ppt)函数、类名称等可自定义, 部分变量请加上学号后3位。
也可自行对类中所定义的操作进行扩展。
所加载的库函数或常量定义:#include <iostream>using namespace std;(1)单链表存储结构类的定义:template<class T>class LinkList{public:LinkList(); //初始化带头结点空单链表构造函数实现LinkList(T a[],int n);//利用数组初始化带头结点的单链表构造函数实现~LinkList();int length(); //求单链表表长算法T get(int i); //获得单链表中第i个结点的值算法int locate(T temp);void insert(int i,T temp); //在带头结点单链表的第i个位置前插入元素e算法T Delete(int i); //在带头结点单链表中删除第i个元素算法void print(); //遍历单链表元素算法bool isEmpty(); //判单链表表空算法void deleleAll(); //删除链表中所有结点算法(这里不是析构函数, 但功能相同)private:Node<T> *head;};(2)初始化带头结点空单链表构造函数实现输入:无前置条件: 无动作: 初始化一个带头结点的空链表输出:无后置条件: 头指针指向头结点。
线性表的链式表示和实现讲解
![线性表的链式表示和实现讲解](https://img.taocdn.com/s3/m/49908867b9f3f90f77c61b47.png)
访问第i个数据元素的操作函数可写为:
Status GetElem_L(LinkList L, int i, ElemType e) {p=L->next; j=1; //带头结点的链表
Q1:第一行的LNode 与最后一行的LNode是不是一回 事?
A1:不是。前者LNode是结构名,后者LNode是对整个 struct类型的一种“缩写”,是一种“新定义名”,它只 是对现有类型名的补充,而不是取代。
10
Q2: 那为何两处要同名(LNode和LNode)?太不严谨 了吧?
A2:同名是为了表述起来方便。因为描述的对象相同, 方便阅读和理解。 Q3:结构体中间的那个struct LNode是何意?
(1) 链式存储结构特点: 其结点在存储器中的位置是随意的,即逻辑上 相邻的数据元素在物理上不一定相邻。
如何实现? 通过指针来实现!
让每个存储结点都包含两部分:数据域和指针域
样式: 数据 指针 或 指针 数据 指针
数据域:存储 元素数值数据
指针域:存储直接后继或 者直接前驱的存储位置
设计思想:牺牲空间效率换取时间效率 3
13
(2) 单链表的插入(重点)
在链表中第i个位置前插入一个元素x 的示意图如下:
p
p
ai-1
ai
ai-1
ai
p->next
插入X
第2章 线性表
2.1 线性表的逻辑结构 2.2 线性表的顺序表示和实现 2.3 线性表的链式表示和实现 2.4 一元多项式的表示和相加
1
2.3 线性表的链式表示和实现
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
if(head==NULL)//表空
{
printf("表空\n");
return 0 ;
}
else if(x==head->data)//第一个结点为删除的结点
{
q=head;
head=head->next;
y=q->data;
i=1;
goto LOOP;
}
else
return;
}
void main()
{
printf("09计本 093821001 徐成昌\n\n");
int a;
LOOP:
printf(" *****************\n");
struct list *creat_n()//创建有n个元素的链表
{
struct list *q,*p,*head=NULL;
printf("\n输入你所要创建的结点数: ");
scanf("%d",&length);
head=p=(list*)malloc(sizeof(list)); //创建一个新结点并用头指针指向它
printf(" ** 1 创建链表 **\n");
printf(" ** 2 链表输出 **\n");
printf(" ** 3 插入结点 **\n");
printf(" ** 4 删除结点 **\n");
printf(" ** 5 查找结点 **\n");
printf("删除成功\n\n");
length=length-1;
output();
return (y);
}
else
{
printf("表中没有指定的结点\n");
output();
return 0;
}
scanf("%d",&x);
k=(list*)malloc(sizeof(list));//创建新结点
printf("请输入新结点的值: ");
scanf("%d",&k->data);
k->next=NULL;
if(head==NULL)//若链表为空,则直接入链表
{
#include <stdio.h>
#include <stdlib.h>
#include<conio.h>
struct list //结点类型
{ int data;
struct list *next;
};
struct list *head;//声明结点指针
int static length;//声明表长变量
}
else
{
q=head;
p=head->next;
while((p != NULL) && (p->data != x))//找出值为X的结点的位置
{
q = p;
p = p->next;
}
if (p == NULL)
printf("输入该结点的值: ");
scanf("%d", &p->data);
q->next=p;
}
printf("输入完毕\n\n");
p->next=NULL;
return head;
break;
case 3 :
insert();
break;
case 4 :
delet();
break;
case 5 :
find();
break;
}
goto LOOP;
}
printf("输入该结点的值: ");
scanf("%d", &p->data);
p->next=NULL;
for(int i=length-1;i>=1;i--)
{
q=p;
p=(list*)malloc(sizeof(list)); //创建新结点
length=length+1;
}
}
output();
}
int delet()//删除结点函数
{
struct list *q,*p;
int x,y;
printf("请输入你所要删除的结点值: ");
scanf("%d",&x);
p=p->next;
}
printf("当前的表长是: %d\n\n",length);//输出当前表长
return head;
}
void insert()//插入结点函数
{
struct list *பைடு நூலகம்,*p,*q;
int x;
printf("请输入你要在哪个结点值之前插入新结点: ");
}
return 0;
}
void find()
{
struct list *p;
int k,x,i=1;
char y,n;
LOOP:
p=head;
printf("请输入你要查找的结点值: ");
scanf("%d",&x);
while(p->data!=x)
printf(" *****************\n");
printf("\n请选择: ");
scanf("%d",&a);
switch(a)
{
case 1 :
head=creat_n();
break;
case 2 :
output();
{
p=p->next;
i++;
}
printf("你所查找的结点是表中第 %d 个结点!\n\n",i);
printf("是否要继续查找,请输入y/n\n\n");
k=getch();
if(k=='y')
{
free(q);
printf("删除成功\n\n");
length=length-1;
output();
return(y);
}
else
{
q=head;
p=head->next;
while((p != NULL) && (p->data != x))//找出值为X的结点
{
q=p;
p=p->next;
}
if(p==NULL)
{
printf("没有删除对象\n");
}
if(x==p->data)//删除值为X的结点
{
q->next=p->next;
y=p->data;
free(p);
head=k;
length=length+1;
printf("插入成功\n\n");
}
else if(head->data==x)//在第一个结点前插入新结点
{
k->next=head;
head=k;
printf("插入成功\n\n");
length=length+1;
{
q->next=k;//在链表末插入新结点
printf("插入成功\n");
length=length+1;
}
else if(p->data == x)//在要求的X结点前插入新结点
{
k->next=p;
q->next=k;
printf("插入成功\n\n");
}
struct list * output()//输出表长与结点值函数
{
struct list *p;
p=head;
printf("\n当前链表中存有的元素:\n");
while(p!=NULL)
{
printf("%d\n",p->data);