实验五__线性表的链式表示和实现
线性表的链式表示和实现解析
头结点 复习：
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));
线性表的链式表示和实现（插入删除建空合并）
线性表的链式表⽰和实现（插⼊删除建空合并）题解：后续的功能会不定期更新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！。
线性表的链式表示和实现—链表
/*调用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); //定位函数
数据结构实验研究报告线性表的顺序表示和实现
纟眇理工数学与计算科学学院实验报告实验项目名称：线性表的顺序表示和实现所属课程名称：数据结构A _________________实验类型：验证性________________________实验日期： _______班级：_________学号：—201044070218 _________姓名：_______ 张松涛_______________成绩：_____________________________、实验概述:【实验目的】(1)、线性表的逻辑结构特征。
①、总存在第一个和最后一个元素。
②、除第一个元素以外，每一个元素总存在唯一一个直接前驱元素。
③、除最后一个元素以外，每一个元素总存在唯一一个直接后驱元素。
⑵、顺序表的特征。
①、逻辑关系上相邻的物理位置上也相邻。
②、是一种随机存储结构，可以用一个简单直观的公式来表示每一个元素的地址。
(3)学会定义线性表的顺序存储类型，实现C程序的基本结构，对线性表的一些基本操作和具体的函数定义。
掌握顺序表的基本操作，实现顺序表的插入、删除、查找以及求并集等运算。
【实验原理】//——线性表的动态分配顺序存储结构--------------#defi ne LIST_INIT_SIZE 5 // 线性表存储空间的初始分配量#defi ne LISTINCREMENT 2 // 线性表存储空间的分配增量Typedef struct{ElemType *elem; // 存储空间基址int len gth; // 当前长度int listsize; // 当前分配的存储容量(以sizeof(ElemType)为单位)}SqList;【实验环境】实验的环境：VC++、实验内容:【实验方案】编写主函数，调用初始化，建立顺序表的算法以及插入和删除算法。
调试运行输入数据得出结果并进行分析【实验过程】（实验步骤、记录、数据、分析）|叶《4* IHOt 1KOHl* fHl lf fl■tfer—«K li ■TT ST f RR«H nIKf KIBtf -1 i nr Sr ittif;apt K]t^pii ippr]utfiM u(r_inn_iiff，"删農存侶阿的杓站寸生量ITETHKfiTHFNT IQFwMpp*理)帼・：l*t l^njth■ill llwiliK；&u_)(•SUflllflCd-EST IHIT (FlfBlJIir) | ；iJ--4fl.rim) e<it(4MEflFLW|;LL .li«t5L7P=l.] £1 IINI I SIZE :[tltllst 耐tirntfiiD- vn«-tft K<I?, ip, "q ：14 IIT Li^t U i a F1 ml yipr r J(1 F J -j f 4 II I'M lflMfl-fc-ii-Vl wbihrn fERM ・SiltlMi L LSI Ht 亂丿诉I*)41K1<1 11 ) rrtuim tRHBR;a 1194KliKt)<*«5«-俺]材加昶*)r »] )aa(L .#1 f L . ].lS(Si?e*L 1ST IMWMFHT ZP»f 4 EleRTyp* })if( tnii^dtwjiektt ・>:|| rll5tSiEe*-Ll$ I J HCfltKHI $k. elwuLL ..lrkg< ■"Wnr卜巩u ;+ "-L. Lr nr|C.h ；(MIE tt|:StitU% L"II#亍林•—聲(骑Ll钊U^ltt L.11 PHI v|itIFKKI) II 舁乳7"*4"和『HU阳EKIDI：pW 叭呵i- 1J>^q・L ■•丄w-L ilff*g|l.k-li―.Ipruft h;milrti}/vi 丸valid VU I H C)IE" uItiK1;I «r((surtff 'Ur .U ,eke«(f )p; L .>PFiintrr'td w»i|T imwr f;网■，刮.b); LisHlrH-rr t_En(L 4l H.rj;f<jp| 1»*;1 (f.叶枇.31«■> printF<"1bri MB, *(1 ;■dm刊rm；, 1 ,»)；.priRtF4>!%4 ;将源程序输入VC6.0Lk卄LrL-Unll||UF**l(*； 1 -灯#2 弁----------------- -- --- —----- “tMipELlni .・< Mri xelUnyi^difebiiijfti^lti'M .uptf l^fYlrrv 版IM煮■UiriEAft丄*科ItfHtiHfr^-：\dKurmts- ±nd ictLinqs'iiKtaLnlstj'jtiM'XI上z mrnr CSBK: "EEt*R" ; ukfccl-H-rd adMllfirr lErrir rkrcti^l>g Ci^nr^iLnhj ・1 err writ),. ■发现有OVERFLOW : undeclared identifier ，错误，是没有定义导致加入宏替换定义OVERFLOW1^™-™-=-=-"=-=^^——-C»nfi|UFitii*3 1 - ■i«32i Ir眄l h•打i»1 .£ibj -・Mr甘忖F ■ji编译之后没有发现语法错误-»"-■■■■■-- ----- l^urKluiiia ii - trtn3£■ -■ ■»»w«Liifting __1 - tie - ■ rnrurts) B• wriaikf(和连接没问题，直接运行【实验结论】（结果）【实验小结】（收获体会）1. 实验要细心，认真。
(数据结构)线性表的链式表示和实现(源代码)
数据结构实验线性表的链式表示和实现（源代码）件inc lude<stdio・h>#tnclude<malloc,h>#include<stdl)b.h>#define TURElttdefine FALSE 0ttdefine OK 1ttdefine ERROR 0ffdefine INEEASLIBE -1#define OVERFLOW -2 typedefint status; typ edefi ntelemty pe; struct nodeelemty pe date; struct node *next;struct node* createlistfnode *headjnt n)printf(“输入的n值不合法\汕); return head;node *p/q;head={struct node*)malloc(sizeof(struct node)); ifllhead) return head; head->next=NULL; head->date=n; q=head;inti=O;for(;i<n;)p=(struct no de*)malloc(sizeof(struct node));printf(“诸输入创建的结点数拯元索的scanf("%d'\&p・>datg);getcharO;p->next=NULL; q->next=p; q=P； i++；systemC^cIs"); return head;struct node* clearlistfnode *head)head=NULL; return head;status destroylist(node *head)head=NULL; free(head); return OK; statuslistempty(node *head)if|head==NULL)return OK;elsereturn ERROR;statusiist!ength(node *head)inti=0; node *p;p=head->next; while ⑴i++； if(p->next==NULL) break;p=p->next；prints该线性表的表长为%d\n\i);return OK;statusgetelem(node *headjnti,elemtype&e)node *p; p=head-> next; int n=1;printfC输入的i傅不合法\屮); return ERROR;while(n<i)p=p・> next;n++;iflp==NULL)printT输入的i值不合法W); return ERROR;e=p->date; return OK;statuslocatelemfnode *head,elemtvpe e)node *p; inti=l; p=head->next; while ⑴if(p->date==e&&p==NULL) break;p=p->next;i++；if)p==NULL)prints该线性表中没有％d这个数据元索\吧6);return ERROR;printfC-%d存在该线性表的第％d位\叭巳i）; return OK; statuspnorelem(node *headjntbelemtype&e)printfC该位上的数据元素为一个元索没有直接前驱元^\nj; return ERROR;struct node *p/q; p=head->next;int j=l;for(;p!=NULL;p=p->next)break;q=p;j++； iflp!=NULL)e*q・>date;printf（“该元索有数据元素并且直接前驱元索已传递给0\""）; returnOK;elseprintfC输入的i值不合法\门”); return ERROR;statusnextelem(node *head,inti,elenritype&e) struct node *p; p=head->next;int j=O;for(;p->next!=NULL; p=p->next)j++；break;iflp->next!=NULL)e=p・> next->date;printf（“该位上有后继元索且K接后继元索的垃已传递给e\n“）;return OK;if(p->next==：NULL&&(j+l)Ki)prints该位上的数据元素为最后一个元素没有直接后继元素Vn； returnERROR;else if(p==NULL&&{j+l)<i)printT输入的i值不合法W); return ERROR;struct node* insert(node *headjnti,elemtype e)printfC输入的i值不合法\门”); return head;struct node *q/p;q=head;int j=l;p=(struct no de*)malloc(sizeof(struct n ode)); p ・>date=e;while(j<i)if(q・>next==NULL) break;q=q->next; j++；p・> next=q->next; q・>next=p;elseprints输入的i值不合法\小;return head;struct node* delete_node{node *head,inti,elemtype&e)printf(”输入的i值不合法W); return head;struct node *p,*q; p 二head;int j=l; while(j<i)if(p・> next->next==NULL) break;p=p・> next;j++；q=p・>n ext;p ・>next=p・> next->next;e=q->date;free(q);ifijd)printfr输入的i值不合法\叶1;return head;status trip(node *head)struct node *p; p=head->next; inti=l;doprintf("第％d 位=~%d\n'\i,p*>datG); p=p・> next;i++；}vzhile(p!=NULL);return OK;main()struct node *head; char a,int n; elemty pe e; while(l)printfCl:构造一个线性後\"2:销毁线性表\n3:将已有线性表置为空表\"4：判断线性衣是否为空\n5:计算已有线性表中数据元素的个数\n”)；printfC'6:取出元索的值\n7:定位元索的位置\n8:插入新的数据元索\n9:删除某一个数据元索\冋显示该线性表中全部的元索W);printfC'b:取出特定位置的貞接前驱元素\皿:取出特定位置上直接后继元素00:退出\n\n\n'*);scanf("%c'\&a);getcharO;systemCcIs”)；switch(a)case O: exit(O);case T:printf("请输入需要创建元索的个数n\n"); scanf(” ％d”,&n);getcharO;head=createlist(head,n); break;case 2:if(destroylist{head)==OK)head=NULL;free(head);prints线性表销毁成功\");break;case 3:clearlist(head);printf(“线性表以置为空表\""); break;case '4':if(listempty(head)==OK) phntfC*线性表为空表\n“)； elsephntfC'线性表不为空表匕“)；break;case S:listlength(head);break;case '6':Printf(“请输入需要取出元素的位数冲“)；scanf(”％cr：&n);getcharO；P rintf("\n");getelem(head,n,e);printf("第％d位数据元索的值为%d\n'\n,e); break;case 7:p hntfC'W输入需要定位元素的值e=");scanfC'%d\&€);getcharO;P rintfCAn-);locatelem(head,e);break;case 8:printf(”请输入需要插入的位置n=");scanf(”％cr：&n);getcharO;printfCAn该位置上的数据元素的值曰)；scanf(-%cl\&e)； getcharO;p hntf("\n");head=insert(head, n^e);break;case 9:Printf(“诸输入需要删除的位置n=-); scanfr%cr&n); getcharO;delGte_node(head,n,G);printf(" C•删除第％(1位上的数据元素％d\n",n,e); break；case N:tnp(head);break;case V:phntfC'i#输入需要取出直接前驱元素的位数n=**)； scanfC'% cT&n);getcharO;if(p norelem(head,n,e)==OK)printf("\n第％€1位的直接前驱元素为%d\n'\n,e); break;case 'c';pmtf(“诸输入需要取出克接后继元素的位数冲“)； scanf("%d'\&n);getcharO；if(nextelem(head,n,e)==OK)printf("\n第％＜1位的直接后继元索为%d\n'\n,e); break；default:printf(”输入不合法 ... 请选择：\n'");printf("\n\n\n'');。
实验五__线性表的链式表示和实现
浙江大学城市学院实验报告课程名称数据结构基础实验项目名称实验五线性表的链式表示和实现学生姓名专业班级学号实验成绩指导老师（签名）日期一.实验目的和要求1、了解线性表的链式存储结构，学会定义线性表的链式存储结构。
2、掌握单链表、循环单链表的一些基本操作实现函数。
二.实验内容1、设线性表采用带表头附加结点的单链表存储结构，请编写线性表抽象数据类型各基本操作的实现函数，并存放在头文件LinkList.h中（注：教材上为不带表头附加结点）。
同时建立一个验证操作实现的主函数文件test5.cpp，编译并调试程序，直到正确运行。
提示：⑴单向链表的存储结构可定义如下：struct LNode { // 定义单链表节点类型ElemType data; // 存放结点中的数据信息LNode *next; // 指示下一个结点地址的指针}⑵线性表基本操作可包括如下一些：①void InitList (LNode *&H) //初始化单链表②void ClearList(LNode *&H) //清除单链表③int LengthList (LNode *H) //求单链表长度④bool EmptyList (LNode *H) //判断单链表是否为空表⑤ElemType GetList (LNode *H, int pos)//取单链表第pos 位置上的元素⑥void TraverseList(LNode *H) //遍历单链表⑦bool InsertList ( LNode *&H, ElemType item, int pos)//向单链表插入一个元素⑧bool DeleteList ( LNode *&H, ElemType &item, int pos)//从单链表中删除一个元素⑶带表头附加结点的单链表初始化操作的实现可参考如下：void InitList(LNode *&H){ //构造一个空的线性链表H，即为链表设置一个头结点，//头结点的data数据域不赋任何值，头结点的指针域next则为空H=(LNode *)malloc(sizeof(LNode)); // 产生头结点Hif (!H) exit(0); // 存储分配失败，退出系统H->next=NULL; // 指针域为空}2、选做部分：编写一个函数void MergeList(LNode *&La, LNode *&Lb, LNode *&Lc)，实现将两个有序单链表La和Lb合并成一个新的有序单链表Lc，同时销毁原有单链表La和Lb。
数据结构线性表的链式表示和实现(C语言)
/*创建一个链表，实现对链表的创建，插入/追加，删除等操作*/# include <stdio.h># include <stdlib.h># include <malloc.h>//创建一个结构体typedef struct Node{int data;struct Node * pNext;}NODE,*PNODE;//函数前置声明PNODE create_list(void); //创建一个链表void traverse_list(PNODE); //遍历整个链表bool is_empty(PNODE); //判断列表是否为空int length_list(PNODE); //返回链表的长度bool insert_list(PNODE, int , int); //在链表中插入元素bool delete_list(PNODE, int, int *);//删除链表中的某个元素，并且返回被删除的元素的值。
void sort_list(PNODE); //对链表进行排序int main(void){//初始化头指针变量PNODE pHead = NULL;int val;//创建一个链表，将头结点的指针返回，保存到头指针变量中pHead = create_list();//判断这个链表是否为空/*if( is_empty(pHead) ){printf("这个链表为空\n");}else{printf("链表不为空\n");}*///查看元素的个数printf("该链表元素的个数为：%d\n",length_list(pHead));//遍历整个链表printf("遍历整个链表：");traverse_list(pHead);//插入元素printf("在第3个元素前插入一个99的值：");insert_list(pHead, 3, 99);traverse_list(pHead);//对链表进行排序printf("对链表进行升序排序：");sort_list(pHead);traverse_list(pHead);//删除链表中的元素printf("删除第三个位置的值：");delete_list(pHead, 3, &val);//遍历这个链表traverse_list(pHead);return 0;}/*常见一个链表@param void@return pHead 头指针*/PNODE create_list(void){int val; //用于保存用户输入的值int i; //for循环自增变量int data;//创建头结点PNODE pHead = (PNODE)malloc(sizeof(NODE));if(NULL == pHead){printf("动态内存创建失败\n");exit(-1);}PNODE pTail = pHead;pTail -> pNext = NULL;printf("需要创建元素的个数len=");scanf("%d",&val);for(i = 0; i < val; ++i){printf("请输入第%d个元素：", i + 1);scanf("%d",&data);//创建这个节点PNODE pNew = (PNODE)malloc(sizeof(NODE));if(NULL == pNew){printf("动态内存创建失败\n");exit(-1);}pNew -> data = data;pNew -> pNext = NULL;pTail -> pNext = pNew;pTail = pNew;}return pHead;}/*遍历一个链表@param PNODE 头指针@return void*/void traverse_list(PNODE pHead){PNODE p;p = pHead;if( is_empty(pHead) ){printf("这个链表为空\n");return;}while(NULL != p->pNext){p = p->pNext;printf("%d ",p->data);}printf("\n");}/*判断链表是否为空@param PNODE pHead 头指针@return bool*/bool is_empty(PNODE pHead){if( NULL == pHead -> pNext){return true;}else{return false;}}/*返回链表的长度@param PNODE pHead 头指针@return int i 指针的长度*/int length_list(PNODE pHead){PNODE p;int i = 0;if( is_empty(pHead) ){printf("链表为空。
实验报告.线性表的顺序表示和实现
return OK;
}
void main()
{Sqlist L; int i; InitList_Sq(L); //构造一个空的线性表L
for (i=0;i<L.listsize;i++)
{scanf("%d",&L.elem[i]);
++L.length;}//输入数据
if(!L.elem) exit(OVERFLOW); //存储分配失败
L.length=0; //空表长度为0
L.listsize=LIST_INIT_SIZE; //初始存储容量
return OK;
}
Status ListInsert_Sq(Sqlist &L,int i, ElemType e){
for(i=0;i<L.listsize;i++)printf("%d ",*(L.elem+i));
//输出表中的数据
printf("\n");
ElemType e;scanf("%d""%d",&i,&e);
ListInsert_Sq(L,i,e);
//在线性表L中第i个元素之前插入元素e
for(i=0;i<L.length;i++)
要不然就会出现很多错误，得不到自己想要的结果。
第二点：要熟练的掌握有关C语言的知识，要充分明白算法与程序的区别，在
编写程序的过程中要保持清醒的头脑，时刻注意那些容易出错的地
方。
第三点：每次进行删除算法之后表长都要减一。否则会造成数据冗余，浪费
数据结构实验第5次课线性表的链式表示及应用
删除
status ListDelete(LinkList L, int i, ElemType &e){ LinkList p; int j; p=L; 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 Initlist(LinkList &L){ LinkList p,q; int i,n; printf("请输入存入线性表中的元素个数："); 请输入存入线性表中的元素个数： 请输入存入线性表中的元素个数 scanf("%d",&n); p=(LinkList)malloc(sizeof(LNode)); L=p; p->next=NULL; for(i=1;i<=n;i++){ q=(LinkList)malloc(sizeof(LNode)); printf("请输入第 %d 个数据 个数据:",i); 请输入第 scanf ("%d", &q->data); q->next=NULL; p->next=q;p=q; } return(ok); }
status ListInsert(LinkList L,int i,ElemType e){ LinkList p,s; int j; p=L; j=0; while(p&&j<i-1){p=p->next; j++;} if(!p||j>i-1) return(error); s=(LinkList)malloc(sizeof(LNode)); s->data=e; s->next=p->next; p->next=s; return ok; }
线性表 链表实验报告-链表线性表
[线性表链表实验报告]链表线性表实验一：线性表运算的实现班级姓名学号一、实验预备知识1复习C++中编写函数的相关内容。
2复习如何用主函数将多个函数连在一起构成一个C++完整程序。
二、实验目的1掌握线性表的顺序和链式存储结构2熟练运用线性表在顺序存储方式下的初始化、创建、输出、插入和删除运算3熟练运用线性表在链式存储方式下的创建、输出、插入和删除运算三、实验要求1编写初始化并创建线性表和输出线性表的算法。
2编写对线性表插入和删除运算算法，要判断位置的合法性和溢出问题。
3编写一个主函数，将上面函数连在一起，构成一个完整的程序。
4将实验源程序调试并运行，写出输入、输出结果，并对结果进行分析。
四、实验步骤◇顺序表实验内容：1．给定的线性表为L=（12，25，7，42，19，38），元素由键盘输入。
2．初始化并建立顺序表。
3．编写顺序表输出算法。
（内存中开辟的单元数为8）4．依次插入3，21，15三个数，分别插入在第4，6和2位置，每插入一次都要输出一次顺序表。
5．删除第5，第3和第12个位置上的元素，每删除一个元素都要输出一次顺序表。
◇单链表实验内容：1．给定的线性表为L=（12，25，7，42，19，38），元素由键盘输入。
2．建立一个带表头结点的单链表（前插入法和尾插入法都可以）。
3．编写单链表输出算法。
4．依次插入3，21，15三个数，分别插入在第4，6和12位置，每插入一次都要输出一次单链表。
5．删除第5，第3和第12个位置上的元素，每删除一个元素都要输出一次单链表。
五、实验程序◇顺序表实验//LinkList.h#defineMAXSIZE8typedefintDataType;typedefstruct{DataTypedata[MAXSIZE];intlast;}Seqlist;voidcreat_seqlist(Seqlists);voiddisplay_seqlist(Seqlists);intinsert_seqlist(Seqlists,inti,DataTypex);intdelet_seqlist(Seqlists,inti);//LinkList.cpp#include#include”Seqlist.h”voidcreat_seqlist(Seqlists){intx,i=0;coutcinx;while(x!=-1){s.data[i]=x;cinx;i++;}st=i-1;}voiddisplay_seqlist(Seqlists){inti;coutfor(i=0;icoutcout}intinsert_seqlist(Seqlists,inti,DataTypex){intj;if(st==MAXSIZE-1){}st+2){cout=i-1;j--)s.data[j+1]=s.data[j];s.data[i-1]=x;st ++;return1;intdelet_seqlist(Seqlists,inti){intj;if(st+1){coutreturn-1;}for(j=i;js.data[j-1]=s.data[j];st--;return1;}//main.cpp#include#include”Seqlist.h”intmain(){intx,d,s;Seqlists_list;creat_seqlist(s_list);coutd;coutx;s=insert_seqlist(s_list,d,x);if(s==1){coutd;s=delet_seqli st(s_list,d);}if(s==1){cout运行结果:请输入数据（以输入-1结束）12257421938-1顺序表为：12257421938插入操作请输入插入的位置:4请输入要插入的数据：3插入后的顺序表为：122573421938请输入插入的位置:6请输入要插入的数据：21插入后的顺序表为：12257342211938请输入插入的位置:2请输入要插入的数据：15表满！删除操作请输入删除元素的位置：5删除后的顺序表为：122573211938请输入删除元素的位置：3删除后的顺序表为：12253211938请输入删除元素的位置：12不存在该元素！Pressanykeytocontinue◇单链表实验//LinkList.htypedefintDataType;typedefstructNode{DataTypedata;structNode*next;}LNode,*LinkList;voidCreat_LinkList(LinkListL);//创建链表voidShow_LinkList(LinkListL);//显示数据LNode*Get_LinkList(LinkListL,inti);//获得第i个结点的地址intInsert_linklist(LinkListL,inti,DataTypex);//插入结点intDelete_LinkList(LinkListL,inti);//删除结点//LinkList.cpp#include#include”LinkList.h”voidCreat_LinkList(LinkListL){LNode*s;L=NULL;s=newLNode;s-next=L;L=s;intx;}//头插法创建带头结点的链表coutx;while(x!=-1){s=newLNode;s-next=L;L-data=x;L=s;cinx;} voidShow_LinkList(LinkListL){LNode*p;p=L-next;while(p!=NULL){coutdatap=p-next;//显示数据}cout}LNode*Get_LinkList(LinkListL,inti){intj=1;LNode*q;q=L-next;while(q!=NULLjq=q-next;j++;}returnq;}//获得第i个结点的地址intInsert_LinkList(LinkListL,inti,DataTypex)//插入结点{ LNode*p,*s;p=Get_LinkList(L,i-1);if(p==NULL){}coutdata=x;s-next=p-next;p-next=s;return1;}intDelete_LinkList(LinkListL,inti){LNode*p,*s;p=Get_LinkList(L,i-1);if(p==NULL){//删除结点coutnext==NULL){coutreturn0;}else{s=p-next;p-next=s-next;deletes;return1;}}//main.cpp#include#include”LinkList.h”intmain(){intx,d,s;LinkListH;Creat_LinkList(H);Show_LinkList(H);}coutd;coutx;s=Insert_LinkList(H,d,x);if(s==1){coutd;s=Delete_Lin kList(H,d);if(s==1){cout运行结果：请输入数据（以输入-1结束）12257421938-1单链表为：38194272512插入操作请输入插入的位置:4请输入要插入的数据：3插入后的单链表为：381942372512请输入插入的位置:6请输入要插入的数据：21插入后的单链表为： 38194237212512请输入插入的位置:12请输入要插入的数据：15插入位置错误!删除操作请输入删除元素的位置：5删除后的单链表为：3819423212512请输入删除元素的位置：3删除后的单链表为：38193212512 请输入删除元素的位置：12插入位置的前驱结点不存在!。
数据结构算法代码实现——线性表的链式表示与实现（单链表）（三）
数据结构算法代码实现——线性表的链式表⽰与实现（单链表）（三）线性表的链式表⽰使⽤⼀组任意的存储单元存储线性表的数据元素（这些存储单元可以是连续也可以是不连续的）。
常见的链式表：单链表、静态链表、循环链表、双向链表。
链表的存储⽅式和特点我们修改⼀下上⼀篇⽂章的例⼦：假如现在是新⽣⼊校，按照新⽣的先来后到编号1-6，先到的同学可以随意选择床铺，但是需要记住下⼀位同学的床铺号（1舍友记住2舍友床铺号，2舍友记住3舍友床铺号，依次类推）。
此时⽆形的就把同学构成了⼀条链表。
链表的存储⽅式也于此类似，下⾯讨论⼀下链表的特点：(1)数据元素的逻辑顺序和物理顺序不⼀定相同。
(2)在查找数据元素时，必须从头指针开始依次查找，表尾的指针域指向NULL。
(3)在特定的数据元素之后插⼊或删除元素，不需要移动数据元素，因此时间复杂度为 O(1)。
(4) 存储空间不连续，数据元素之间使⽤指针相连，每个数据元素只能访问周围的⼀个元素。
(5)长度不固定，可以任意增删。
在来看下链表中的结点：结点是数据元素信息和指⽰存储位置信息这两部分的组成，这两部分信息也称作数据元素的存储映像。
结点包括了两个域：存储数据元素data是数据域，⽤来存储位置信息next是指针域。
注意：为了增强程序可读性，通常在链表第⼀个结点之前我们会加⼀个头结点，头结点的数据域可以不存储任何信息，也可以存储线性表的长度等附加信息。
另外，有头结点的好处是便于在第⼀个结点做插⼊和删除时不需要做特殊的处理。
下⾯来看单链表单链表的存储结构//----线性表的单链表存储结构（课本28页）---typedef struct LNode{ElemType data;struct LNode *next;}LNode,*LinkList;单链表的基本操作（C语⾔）基本操作包括了教材19页的12个操作，其中的操作也实现了教材中的2.8，2.9，2.10算法。
C语⾔代码：1. 头⽂件请参考顺序表⽂章2. 在给出基本操作代码：//----单链表的存储结构（课本28页）---typedef struct LNode{ElemType data;struct LNode *next;}LNode,*LinkList;//-----线性表的链式之单链表的基本操作(12个) *///1,Status InitList(LinkList *L){ /* 操作结果：构造⼀个空的线性表L(默认带头结点) */*L =(LinkList)malloc(sizeof(LNode)); //产⽣头结点，并初始化给头指针。
数据结构线性表实验报告五篇
数据结构线性表实验报告五篇第一篇：数据结构线性表实验报告实验报告课程名：数据结构实验名：线性表及其操作姓名：班级：学号：撰写时间：2014.09.24一实验目的与要求1.掌握线性表的实现2.掌握线性表的基本操作的实现二实验内容• 分别完成线性表的顺序表示及链式表示• 在两种表示上, 分别实现一些线性表的操作, 至少应该包括–在第i个位置插入一个元素–删除第i个元素–返回线性表长–返回第i个元素的值三实验结果与分析#include #include //---------线性表链式表示-----------struct V//声明一个结构体类型struct V { int value;struct V * next;//定义结构体变量};void PrintLink(struct V*p)//定义一个结构体指针{ while(p!=NULL)//只要指针指向的变量不为NULL；就会一直循环链表指向下一个结构体{printf(“%d, ”,(*p).value);p=(*p).next;//指针指向下一个结构体} printf(“n”);} void Link(){struct V*head;head=(struct V*)malloc(sizeof(struct V));//开辟一个长度为size的内存(*head).value=-100;//表头为-100(*head).next=NULL;printf(“------------线性表链式表示------------n”);int i,n=10;struct V*p=head;printf(“10个数据:n”);for(i=0;i(*p).next=(struct V*)malloc(sizeof(struct V));p=(*p).next;(*p).value=2*i;(*p).next=NULL;} PrintLink(head);//调用PrintLink函数printf(“删除第四个数据:n”);int k=4;p=head;for(i=1;ip=(*p).next;} struct V*temp=(*p).next;//k表示插入和删除的位置(*p).next=(*temp).next;free(temp);PrintLink(head);printf(“插入第十个数据:n”);k=10;p=head;for(i=1;ip=(*p).next;} temp=(*p).next;(*p).next=(struct V*)malloc(sizeof(struct V));(*(*p).next).value=-99;(*(*p).next).next=temp;PrintLink(head);}//---------线性表顺序表示-----------void seq1(){ int i,n=10,k=4;int a[10];//---------输出数组元素------------printf(“-------------线性表顺序表示---------n”);for(i=0;ia[i]=i;} printf(“数组元素为:n”);for(i=0;iprintf(“%3d”,a[i]);} printf(“n”);//--------插入一个数组元素---------int m=n+1,j=12;//插入元素12 int b[20];for(i=0;i if(i{b[i]=a[i];}else if(i==k){b[i]=j;}else{b[i]=a[i-1];} } printf(“输出插入一个元素的数组:n”);for(i=0;i{if(i{c[i]=a[i];}else{c[i]=a[i+1];} } printf(“输出删除一个元素的数组:n”);for(i=0;i printf(“数组元素为:n”);for(i=1;i<=a[0];i++){a[i]=i;} for(i=0;i<2*a[0];i++){printf(“%d,”,a[i]);} printf(“n”);//-----在k 位置插入一个元素------------for(i=a[0];i>=k;i--){a[i+1]=a[i];} a[k]=-100;++a[0];for(i=0;i<2*a[0];i++){printf(“%d,”,a[i]);} printf(“n”);//-------在k---------------for(i=0;i>k;i++){a[i]=a[i+1];} a[k]=-1;a[0]=n;--a[0];for(i=0;i<2*a[0];i++){printf(“%d,”,a[i]);} printf(“n”);} int main(int argc,char *argv[]){ seq1();seq2();Link();return 0;} 图1：实验结果截图实验分析：已在程序中按规定格式标注。
线性表的链式存储结构实验报告
线性表的链式存储结构实验报告文件编码（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.首先书上给的链表输入是倒序的，写的时候想都没想就抄上去了，结果运行时发现问题，可是上网百度依然没有把问题解决，导致最后输出链表倒序的，并且链表的合并并集依旧是倒序的。
线性表的链式表示和实现(学生成绩管理系统)
实验二：线性表的链式表示和实现一、实验目的：1、掌握线性表的链式存储结构的表示与实现，掌握线对线性链表进行创建、插入、删除和检索等操作的算法。
2、掌握算法的设计与分析过程。
3、进一步熟悉VC++开发环境，熟悉完成一个应用程序的设计过程，掌握有关编辑、调试和整合程序的方法和技巧。
二、实验要求：1、采用教材中c语言描述的单链表存储结构，模块化设计过程，设计高效的算法完成各种操作任务，针对实际数据实现各种操作。
2、完成程序编写，调试成功后，书写实验报告。
三、实验任务：1、用记事本新建一个文本文件，文件名为：“班名+序号_bk”，将10个学生的成绩信息输入到这个文件中，建议按如下形式存放。
编号学号姓名性别系名英语数学计算机1 20080010 丁勇男机械 78 63 732 20080011 董茂女英语 62 87 743 20080012 冯连军男信息 80 58 634 20080013 李红女信息 86 93 935 20080014 郭瑞男化工 76 96 816 20080015 何超超男油工 70 91 787 20080016 胡伟男信息 66 59 798 20080017 黄明强男化工 75 77 769 20080018 于晓雯女英语 68 93 6210 20080019 李成伟男信息 79 71 652、创建单链表，将文本文件中的学生成绩信息存储到单链表中。
3、显示操作，将所有成绩信息在屏幕上显示。
4、插入操作，在已经创建的单链表中进行插入操作，在第i条记录后插入1条新的记录，并显示所有信息。
5.、删除操作，在单链表中进行删除图书操作，查找第i条记录，找到后删除该条记录，并显示所有信息。
四、设计指导1、结点的定义#include<stdio.h>#include<stdlib.h>typedef struct std //学生的数据结构类型{ int no;char stunum[10];char stuname[10];char sex[5];char major[10];int english;int math;int pc;}stu;typedef struct Node// 单链表的结点类型{stu data;struct Node *next;}LNode, *LinkList;LinkList L; //定义头指针stu s1;char str[81];2、将复杂的问题分解成若干个相对容易的小问题，并设计好解决每个小问题的函数的函数名、入口参数及其返回值；设计出各个函数的程序框架及完整的主函数程序。
数据结构线性表的顺序表示和实现的实习报告
数学与计算科学学院实验报告实验项目名称线性表的顺序表示与实现所属课程名称数据结构实验类型验证型__________实验日期___________________________班级----------------------------学号____________________________姓名____________________________成绩----------------------------实验概述:【实验目的】1线性表的逻辑结构特征1.1以元素在计算机内“物理位置相邻”来表示线性表中数据元素之间的逻辑关系。
1.2有且仅有一个开始结点，没有直接前驱，且仅有一个直接后继；有且仅有一个终结结点，没有直接后继，且仅有一个直接前驱。
1.3其余内部结点都有且仅有一个直接前驱和一个直接后继。
2掌握线性表的基本操作在顺序存储结构上的实现。
【实验原理】1顺序表的特点1.1逻辑位置上相邻和物理位置上相邻1.2是一种随机存储结构，其存储位置可以用一简单直观的公式表示2顺序表的类C语言表示：#define LIST_INIT_SIZE 9 II线性表存储空间的初始分配量#define LISTINCREMENT? II线性表存储空间的分配增量typedef struct{ElemType * elem;//存储空间基址int len gth;II 当前长度int listsize;II 当前分配的存储容量(以sizeof ( ElemType)为单位)}SqList;【实验环境】VC++6.0、【实验内容】【实验方案】编写主函数，调用顺序表的初始化建空表，插入和删除算法，调试运行得出结果【实验过程】（实验步骤、记录、数据、分析）*(p+1)=*p;*q=e;++L .len gth; return OK;}Status ListDelect_Sq(SqList &L,int i,ElemType &e) {if((i<1)||(i>L.length)) return ERROR;p=&(L.elem[i-1]);e=*p;q=L.elem+L .len gth-1;for(++p;p<=q;++p)*(p-1)=*p;--L .len gth;return OK;}void main(){SqList L;int i;In itList_Sq(L); for(i=0;i<LIST_INIT_SIZE;i++){scan f("%d",&L.elem[i]); L.len gth++;} for(i=0;i<L .len gth;i++) prin tf("%d ",L .elem[i]);prin tf("\n");ElemType e;sca nf("%d%d", &i,& e);ListI nsert_Sq(L,i,e);for(i=0;i<L .len gth;i++)prin tf("%d",L.elem[i]);prin tf("\n");sca nf("%d",&i);ListDelect_Sq(L,i,e);for(i=0;i<L .len gth;i++) prin tf("%d ",L .elem[i]);prin tf("\n");}2. 调试第一次出现的错误:C214：<: syntax error : missing befcre ***: Eienriipe^ : nlssirtg storage-class or specifiers CZFhl ： ' elpn 11 : mi^ini| ?>Lordt|i?-tla^^ ur Lypt? spt?tiFiers C2146: 5i|ritax error : missing ' ;' before identif ier ' InitList _Sq C2591: 1Status * : missing storage-class or type ^pocifier£ error C130*ure»p&cted pnd oF Fil® found原因：由于许多变量未定义，以及没有头文件与宏定义所以错误许多，还有更多错 误没有显示出来3. 将以下语句编入程序中:#include "stdio.h" #inelude "stdlib.h" #define TRUE 1 #define FALSE 0 #define OK 1 #define ERROR 0 #define INFEASIBLE -1 #define OVERFLOW -2 #define LIST_INIT_SIZE 9#define LISTINCREMENT 2 typedef int ElemType; typedef int Status;4. 调试第二次出现以下错误:.cpp(9£) : error C2965; *ncMbase" : Ufidrcl^rrd identifier■ eppe 蓟 :trror 02^0; : Cdniml cutivcrt fruin 'ibl *ftv 'inL rpi rirprprpt c^^T r J c-^ryi p r cr Funrttnn^^ryip r^«；r.cpp(3S> : error '-' : cannot convert fram 'int 1 ta 1int **pe to pointer type requires i pinterprrt cast, C style cast or functioncast:umJecltireij iJentifii?r :cannot convert +rom "int 备* to or Function-style cjst ;uiideLldreL iJetitifier :cannnr cflruprt 卡ram -i nr *■ tn cast oi* Punction-ft^lc c^stcpp■ - error cpp<^) ■ -error cpp(3) ■ errorcpp(6) - 启■cpp(e ■ ■■ errorcpp(8)■■ ■aFatal .) : t-rrtirC?965: .cpp)(Ji1 > : errorC2JPiU ： * =' reinterpretoast, a C-st^le 工: trror CZ905: p".rp pl 即2》:frrur cpiuin ： ' = ■ reinterpretcast, 2 C-'inL 'inr -^es a reinterpret cast * a C-style cast or function-style cast us _cpp(52) :error C2018: unknown character * 0xa1* us _cpp<52) : error C2 018: unknown character 'Qxa!*a reinterpretcast, a C^style cast or function^style cast fvs.cppCSS) : error C2100:illegal indirection Fus.cpp(55) : error C2100: illegal indirection Fus.cpp(55) : error原因：是在每个算法中有许多变量未定义，导致许多错误 5.再将语句：int *newbase;int *q; int *p;写入插入算法中; 将语句：int *p; int *q;写入删除算法中;6. 调试第三次显示没有错误:Compiling … asFvs ・(7ppasfus.obj - & error(s), 0 warning(s) 7. 运行第一次显示结果为:FUS.cpp(52) fus .cpp(S2) FUS .cpp(52) fU5.cpp(52) Fvs«cpp(52) 丽scpp(53) error error error error error error C2 018： C2EMB ： C2018： C2 01«： unknown unknovjn unknovm unkin om character ch^ract^r character character• Oxal 1■'0xa1' 'Oxal 1C210O: illegal C2^40: indirection・:cannot convertfrom *int *pto 'int ' "es a reinterpret cast, a C^style cast or Function-st^le cast ^asFus _cpp02) tasfiis >cpp(42) ^asFus.cpp(42) ^asfus>cpp(U3) 需弓fu 与 _cpp<51) IQS F US _C PPCE1) idsFus .cpp (51 j idsFu^ >cpp(51) ^asfu^.cpp(51) error error error error error □ rr or error error err or C21OO: illegal indirectioin C21oo ： illegal indirectionC2196: 1=' : left operand must be 1-ualueC210C: illegalC2018: C20i8:C2918： C2C18： unknown unicnoun unknown unknownC244C ：' indirection character 10xa11character '* character '0xa1* character 'Oxa1*:cannot conuert from 'int to * int' C2106: • : left operand must be 1-ualueuunt xyui auxutt. i 忖丄Compiling ____asfvs.cppasfus.ob j - Q error(s)r0 warning(s)13.运行第四次显示结果为:*H:\De bug時临恚或咗序表尹W实現芒灼耳请输入您想构建的顺序表（元素为9个）=1 2 3 4 E 6 7 S 9您构建的顺序表杲：■£22456789请输入您想在第几个元素位置前插入元素二18输入的数字错误.（只乘U下瞅重新输入符合要求的数字的机会）常入的数字错误.（只剩Ft枕重新输入符合要求的数字的机会）｛青输入您想插入的数：6183形成的新顺序表为；彳7 4 4 C 仇 ~（曲4 £."5 Q o睛输入您想删除的是第几个元素：13输入的数字诸误.（只剩下2次重新输入符合要求的数字的机会）易入的数字错误，（只剩下丄次重新输入符合要求的数字的机会）电除的数为：協咸的新顺序表为=1 2 3 4 5 6183 ? 8 9Press ani^ y to comtinue1 刑这样那么程序就完整了，清晰明了，用户运行的时候也容易知道自己要输入什么了【实验结论】（结果）i 曲％谍性義的1驚表示与实现心b L 口 |屈*3^附录1源程序\n",p);附录2：实验报告填写说明1．实验项目名称：要求与实验教学大纲一致。
线性表的链式表示和实现讲解
访问第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)。
浙江大学城市学院实验报告课程名称数据结构基础实验项目名称实验五线性表的链式表示和实现学生姓名专业班级学号实验成绩指导老师（签名）日期一.实验目的和要求1、了解线性表的链式存储结构，学会定义线性表的链式存储结构。
2、掌握单链表、循环单链表的一些基本操作实现函数。
二.实验内容1、设线性表采用带表头附加结点的单链表存储结构，请编写线性表抽象数据类型各基本操作的实现函数，并存放在头文件LinkList.h中（注：教材上为不带表头附加结点）。
同时建立一个验证操作实现的主函数文件test5.cpp，编译并调试程序，直到正确运行。
提示：⑴单向链表的存储结构可定义如下：struct LNode { // 定义单链表节点类型ElemType data; // 存放结点中的数据信息LNode *next; // 指示下一个结点地址的指针}⑵线性表基本操作可包括如下一些：①void InitList (LNode *&H) //初始化单链表②void ClearList(LNode *&H) //清除单链表③int LengthList (LNode *H) //求单链表长度④bool EmptyList (LNode *H) //判断单链表是否为空表⑤ElemType GetList (LNode *H, int pos)//取单链表第pos 位置上的元素⑥void TraverseList(LNode *H) //遍历单链表⑦bool InsertList ( LNode *&H, ElemType item, int pos)//向单链表插入一个元素⑧bool DeleteList ( LNode *&H, ElemType &item, int pos)//从单链表中删除一个元素⑶带表头附加结点的单链表初始化操作的实现可参考如下：void InitList(LNode *&H){ //构造一个空的线性链表H，即为链表设置一个头结点，//头结点的data数据域不赋任何值，头结点的指针域next则为空H=(LNode *)malloc(sizeof(LNode)); // 产生头结点Hif (!H) exit(0); // 存储分配失败，退出系统H->next=NULL; // 指针域为空}2、选做部分：编写一个函数void MergeList(LNode *&La, LNode *&Lb, LNode *&Lc)，实现将两个有序单链表La和Lb合并成一个新的有序单链表Lc，同时销毁原有单链表La和Lb。
要求把该函数添加到文件LinkList.h中，并在主函数文件test5.cpp中添加相应语句进行测试。
3、填写实验报告，实验报告文件取名为report5.doc。
4、上传实验报告文件report5.doc 、源程序文件test5.cpp及LinkList.h到Ftp 服务器上（ftp://10.66.28.222:2007 ）自己的文件夹下。
三. 函数的功能说明及算法思路（包括每个函数的功能说明，及一些重要函数的算法实现思路）①void InitList (LNode *&H) //初始化单链表②void ClearList(LNode *&H) //清除单链表③int LengthList (LNode *H) //求单链表长度④bool EmptyList (LNode *H) //判断单链表是否为空表⑤ElemType GetList (LNode *H, int pos)//取单链表第pos 位置上的元素⑥void TraverseList(LNode *H) //遍历单链表⑦bool InsertList ( LNode *&H, ElemType item, int pos)//向单链表插入一个元素⑧bool DeleteList ( LNode *&H, ElemType &item, int pos)//从单链表中删除一个元素void MergeList(LNode *&La, LNode *&Lb, LNode *&Lc)，实现将两个有序单链表La和Lb合并成一个新的有序单链表Lc，同时销毁原有单链表La和Lb四. 实验结果与分析（包括运行结果截图、结果分析等）1.2.五. 心得体会要多看书多注意程序的完整性【附录----源程序】1. test5.cpp#include <stdio.h>#include <iostream.h>#include <stdlib.h>typedef int ElemType;typedef struct Node{ElemType data;struct Node *next;}LNode;#include"LinkList.h"void main(){LNode *Head;ElemType x;int i;InitList(Head);for(i=1;i<=5;i++){cin >> x;InsertList(Head,x,0);}TraverseList(Head);cin >> x;InsertList(Head,x,0);TraverseList(Head);DeleteList(Head,x,3);cout << "被删除的元素" << x << endl;TraverseList(Head);ClearList(Head);}LinkList.hvoid InitList (LNode *&H); //初始化单链表void ClearList(LNode *&H); //清除单链表int LengthList (LNode *H); //求单链表长度bool EmptyList (LNode *H); //判断单链表是否为空表ElemType GetList (LNode *H, int pos);//取单链表第pos 位置上的元素void TraverseList(LNode *H); //遍历单链表bool InsertList ( LNode *&H, ElemType item, int pos);//向单链表插入一个元素bool DeleteList ( LNode *&H, ElemType &item, int pos);//从单链表中删除一个元素void InitList(LNode *&H){ //构造一个空的线性链表H，即为链表设置一个头结点，//头结点的data数据域不赋任何值，头结点的指针域next则为空H=(LNode *)malloc(sizeof(LNode)); // 产生头结点Hif (!H) exit(0); // 存储分配失败，退出系统H->next=NULL; // 指针域为空}void ClearList(LNode *&H){ //释放动态申请的内存空间LNode *cp, *np; //当前结点指针与后继结点指针cp=H;while(cp!=NULL) //按顺序遍历单链表，释放每个结点{np=cp->next; // 保存下一个结点free(cp);cp=np; //使下一个结点成为当前结点}H=NULL; //置单链表为空}int LengthList (LNode *H){LNode *p=H->next; //用来遍历链表结点int i=0; //用来统计结点个数while(p!=NULL){i++;p=p->next;}return i;}bool EmptyList (LNode *H){return H->next == NULL;}ElemType GetList (LNode *H, int pos){LNode *p=H->next; //用来遍历链表结点int i=0; //用来统计已查找的结点个数if (pos<1) {cerr<< "pos is out range!"<<endl;exit(1);}while (p!=NULL) { //遍历到第pos个结点或最后一个结点为止i++;if (i==pos) break;p=p->next;}if (p!=NULL) return p->data;else //pos值大于表长{ cerr<<"pos is out range!"<<endl;exit(1);}}bool FindList (LNode *H, ElemType item){LNode *p=H->next; //用来遍历链表结点while(p!=NULL){ if (p->data==item)return true;elsep=p->next;}return false;}void TraverseList(LNode *H){LNode *p=H->next;while ( p!=NULL ) {cout<<p->data<<" ";p=p->next;}cout<<endl;}bool InsertList ( LNode *&H, ElemType item, int pos){LNode *newptr, *cp, *ap;if (pos<-1){cout<<"参数不合法"<<endl;return false;}//寻找新结点的插入位置，使得在ap和cp间插入cp=H->next;ap=H;if (pos == 0) { //按值有序插入情况while ( cp != NULL) {if ( item < cp->data )break;else {ap=cp; cp=cp->next;}}}else if ( pos == -1 ) //在表尾插入情况while ( cp != NULL) {ap=cp; cp=cp->next;}else { //按指定位置插入情况int i=0;while ( cp != NULL) {i++;if (i==pos) break;else {ap=cp;cp=cp->next;}}if ( cp==NULL && i+1<pos ) {cout<<"参数不合法"<<endl;return false;}}//完成新结点的动态分配, 赋值与插入newptr = (LNode *)malloc(sizeof(LNode));newptr ->data = item;newptr->next=cp;ap->next=newptr;return true;}bool DeleteList ( LNode *&H, ElemType &item, int pos){LNode *cp, *ap;if (H->next==NULL){cerr<<"空表，不能删除!"<<endl;return false;}if (pos<-1) {cout<<"参数不合法!"<<endl;return false;}//寻找删除位置，使得cp指向待删除结点，ap指向cp的前一个结点cp=H->next;ap=H;if (pos == 0) { //按值删除情况while ( cp != NULL) {if ( item == cp->data )break;else {ap=cp; cp=cp->next;}}if (cp==NULL) {cout<<"没有相应结点可删除!"<<endl;return false;}}else if ( pos == -1 ) //删除表尾结点情况while ( cp->next != NULL) {ap=cp; cp=cp->next;}else { //删除指定位置结点情况int i=0;while ( cp != NULL) {i++;if (i==pos) break;else { ap=cp; cp=cp->next; }}if ( cp==NULL) {cout<<"参数不合法!"<<endl;return false;}}item = cp->data;ap->next=cp->next; //删除非表头结点，即cp所指的结点free(cp);return true;}2.test5_2.cpp#include <stdio.h>#include <iostream.h>#include <stdlib.h>typedef int ElemType;typedef struct Node{ElemType data;struct Node *next;}LNode;#include"LinkList_2.h"void main(){LNode *H1,*H2,*H3;ElemType x;int i;InitList(H1);InitList(H2);for(i=1;i<=5;i++){cin >> x;InsertList(H1,x,0);}TraverseList(H1);for(i=1;i<=3;i++){cin >> x;InsertList(H2,x,0);}TraverseList(H2);MergeList(H1,H2,H3);TraverseList(H3);ClearList(H1);}LinkList2.hvoid InitList (LNode *&H); //初始化单链表void ClearList(LNode *&H); //清除单链表int LengthList (LNode *H); //求单链表长度bool EmptyList (LNode *H); //判断单链表是否为空表ElemType GetList (LNode *H, int pos);//取单链表第pos 位置上的元素void TraverseList(LNode *H); //遍历单链表bool InsertList ( LNode *&H, ElemType item, int pos);//向单链表插入一个元素bool DeleteList ( LNode *&H, ElemType &item, int pos);//从单链表中删除一个元素void MergeList(LNode *&La, LNode *&Lb, LNode *&Lc);void InitList(LNode *&H){ //构造一个空的线性链表H，即为链表设置一个头结点，//头结点的data数据域不赋任何值，头结点的指针域next则为空H=(LNode *)malloc(sizeof(LNode)); // 产生头结点Hif (!H) exit(0); // 存储分配失败，退出系统H->next=NULL; // 指针域为空}void ClearList(LNode *&H){ //释放动态申请的内存空间LNode *cp, *np; //当前结点指针与后继结点指针cp=H;while(cp!=NULL) //按顺序遍历单链表，释放每个结点{np=cp->next; // 保存下一个结点free(cp);cp=np; //使下一个结点成为当前结点}H=NULL; //置单链表为空}int LengthList (LNode *H){LNode *p=H->next; //用来遍历链表结点int i=0; //用来统计结点个数while(p!=NULL){i++;p=p->next;}return i;}bool EmptyList (LNode *H){return H->next == NULL;}ElemType GetList (LNode *H, int pos){LNode *p=H->next; //用来遍历链表结点int i=0; //用来统计已查找的结点个数if (pos<1) {cerr<< "pos is out range!"<<endl;exit(1);}while (p!=NULL) { //遍历到第pos个结点或最后一个结点为止i++;if (i==pos) break;p=p->next;}if (p!=NULL) return p->data;else //pos值大于表长{ cerr<<"pos is out range!"<<endl;exit(1);}}bool FindList (LNode *H, ElemType item){LNode *p=H->next; //用来遍历链表结点while(p!=NULL){ if (p->data==item)return true;elsep=p->next;}return false;}void TraverseList(LNode *H){LNode *p=H->next;while ( p!=NULL ) {cout<<p->data<<" ";p=p->next;}cout<<endl;}bool InsertList ( LNode *&H, ElemType item, int pos){LNode *newptr, *cp, *ap;if (pos<-1){cout<<"参数不合法"<<endl;return false;}//寻找新结点的插入位置，使得在ap和cp间插入cp=H->next;ap=H;if (pos == 0) { //按值有序插入情况while ( cp != NULL) {if ( item < cp->data )break;else {ap=cp; cp=cp->next;}}}else if ( pos == -1 ) //在表尾插入情况while ( cp != NULL) {ap=cp; cp=cp->next;}else { //按指定位置插入情况int i=0;while ( cp != NULL) {i++;if (i==pos) break;else {ap=cp;cp=cp->next;}}if ( cp==NULL && i+1<pos ) {cout<<"参数不合法"<<endl;return false;}}//完成新结点的动态分配, 赋值与插入newptr = (LNode *)malloc(sizeof(LNode));newptr ->data = item;newptr->next=cp;ap->next=newptr;return true;}bool DeleteList ( LNode *&H, ElemType &item, int pos){LNode *cp, *ap;if (H->next==NULL){cerr<<"空表，不能删除!"<<endl;return false;}if (pos<-1) {cout<<"参数不合法!"<<endl;return false;}//寻找删除位置，使得cp指向待删除结点，ap指向cp的前一个结点cp=H->next;ap=H;if (pos == 0) { //按值删除情况while ( cp != NULL) {if ( item == cp->data )break;else {ap=cp; cp=cp->next;}}if (cp==NULL) {cout<<"没有相应结点可删除!"<<endl;return false;}}else if ( pos == -1 ) //删除表尾结点情况while ( cp->next != NULL) {ap=cp; cp=cp->next;}else { //删除指定位置结点情况int i=0;while ( cp != NULL) {i++;if (i==pos) break;else { ap=cp; cp=cp->next; }}if ( cp==NULL) {cout<<"参数不合法!"<<endl;return false;}}item = cp->data;ap->next=cp->next; //删除非表头结点，即cp所指的结点free(cp);return true;}void MergeList(LNode *&La, LNode *&Lb, LNode *&Lc){LNode * r;InitList(Lc);La = La->next;Lb = Lb->next;r = Lc;while(La && Lb){if(La->data < Lb->data){r->next = La;La = La->next;r = r->next;}else{r->next = Lb;Lb = Lb->next;r = r->next;}}while(!La && Lb){r->next = Lb;Lb = Lb->next;r = r->next;}while(La &&!Lb){r->next = La;La = La->next;r = r->next;}ClearList(Lb);}。