实验2-不带头结点的单链表
数据结构习题及答案与实验指导(线性表)2
第2章线性表线性表是一种最基本、最常用的数据结构，它有两种存储结构——顺序表和链表。
本章主要介绍线性表的定义、表示和基本运算的实现。
重点讨论了线性表的存储结构，以及在顺序、链式两种存储结构上基本运算的实现。
重点提示：●线性表的逻辑结构特征●线性表的顺序存储和链式存储两种存储结构的特点●在两种存储结构下基本操作的实现2-1 重点难点指导2-1-1 相关术语1．线性表线性表是具有相同数据类型的n（n≥0）个数据元素的有限序列，通常记为：(a1,a2,…,a n)，其中n为表长，n=0时称为空表。
要点：一种逻辑结构，其数据元素属于相同数据类型，之间的关系是线性关系。
2．顺序表顺序存储的线性表。
要点：按线性表中的元素的逻辑顺序依次存放在地址连续的存储单元里，其存储特点：用物理上的相邻实现逻辑上的相邻。
3．链表用链表存储的线性表。
要点：链表是通过每个结点的链域将线性表的n个结点按其逻辑顺序链接在一起的，对每个结点的地址是否连续没有要求。
4．单链表每个结点除了数据域外还有一个指向其后继的指针域。
要点：通常将每个元素的值和其直接后继的地址作为一个结点，通过每个结点中指向后继结点的指针表示线性表的逻辑结构。
5．头指针要点：头指针是一个指针变量，里面存放的是链表中首结点的地址，并以此来标识一个链表。
如链表H，链表L等，表示链表中第一个结点的地址存放在指针变量H、L中。
通常用头指针来惟一标识一个链表。
6．头结点要点：附加在第一个元素结点之前的一个结点，头指针指向头结点。
当该链表表示一个非空的线性表时，头结点的指针域指向第一个元素结点；为空表时，该指针域为空。
7．头结点的作用要点：其作用有两个，一是使对空表和非空表的处理得到统一；二是在链表的第一个位置上的操作和在其他位置上的操作一致，无需特殊处理。
2-1-2 线性表的顺序存储1．顺序表顺序存储的线性表称为顺序表。
其特点是：用一组地址连续的存储单元来依次存放线性表的数据元素，因此数据元素的逻辑顺序和物理次序一致（这是顺序存储的核心所在）。
数据结构___头插法和尾插法建立链表(各分有无头结点)
实验一链表的建立及基本操作方法实现一、【实验目的】1、理解和掌握单链表的类型定义方法和结点生成方法。
2、掌握利用头插法和尾插法建立单链表和显示单链表元素的算法。
3、掌握单链表的查找（按序号）算法。
4、掌握单链表的插入、删除算法。
二、【实验内容】1、利用头插法和尾插法建立一个无头结点单链表，并从屏幕显示单链表元素列表。
2、利用头插法和尾插法建立一个有头结点单链表，并从屏幕显示单链表元素列表。
3、将测试数据结果用截图的方式粘贴在程序代码后面。
重点和难点：尾插法和头插法建立单链表的区别。
建立带头结点和无头结点单链表的区别。
带头结点和无头结点单链表元素显示方法的区别三、【算法思想】1) 利用头插法和尾插法建立一个无头结点单链表链表无头结点，则在创建链表时，初始化链表指针L=NULL。
当用头插法插入元素时，首先要判断头指针是否为空，若为空，则直接将新结点赋给L,新结点next指向空，即L=p,p->next=NULL，若表中已经有元素了，则将新结点的next指向首结点，然后将新结点赋给L即（p->next=L,L=p）。
当用尾插法插入元素时，首先设置一个尾指针tailPointer以便随时指向最后一个结点，初始化tailPointer和头指针一样即tailPointer=L。
插入元素时，首先判断链表是否为空，若为空，则直接将新结点赋给L即L=p，若不为空，else将最后一个元素的next指向新结点即tailPointer->next=p，然后跳出这个if,else语句，将新结点next指向空，并且将tailPointer指向新结点即p->next=NULL,tailPointer=p。
2) 利用头插法和尾插法建立一个有头结点单链表链表有头结点，则在创建链表时，初始化链表指针L->next = NULL。
与无头结点区别在于，判断链表为空是根据L->next是否为空。
用头插法插入元素时，要判断链表是否为空，若为空则将新结点next指向空，作为表尾，若不为空，则直接插入，将新结点next指向头结点next的指向，再将头结点next指向新结点即p->next=L->next,L->next=p。
不带头结点的循环单链表的初始化
不带头结点的循环单链表的初始化在数据结构中，循环单链表是一种非常常见的数据结构。
它与普通的单链表相似，区别在于循环单链表的尾结点指针不为空，而是指向头结点。
从而形成了一个闭环。
循环单链表在实际开发中有着广泛的应用，比如约瑟夫问题、舞蹈链等算法都是基于循环单链表实现的。
循环单链表的初始化是操作中的一个重要步骤。
不带头结点的循环单链表与带头结点的初始化稍有不同，但同样需要注意一些细节。
在这篇文章中，我们将深入探讨不带头结点的循环单链表的初始化过程，以及一些相关的知识点。
一、不带头结点的循环单链表的初始化在不带头结点的循环单链表中，我们需要特别注意链表为空的情况。
因为没有头结点，所以需要对第一个节点进行特殊处理。
在初始化过程中，我们需要将第一个节点指向自己，形成一个闭环。
代码实现如下：```C++typedef struct Node {int data;struct Node* next;} Node;void InitList(Node*& L) {L = (Node*)malloc(sizeof(Node));if (L == NULL) {// 内存分配失败处理exit(0);}L->next = NULL; // 头节点初始化为空}```以上代码中，我们使用了C++的结构体来定义循环单链表的节点。
在进行初始化时，我们为头结点分配内存，并将其next指针指向NULL，表示链表为空。
二、注意事项在不带头结点的循环单链表中，我们需要特别注意以下几点：1. 空链表的处理：在初始化过程中，需要将第一个节点指向自己，形成一个闭环。
这样链表为空时，也能正常进行插入、删除等操作。
2. 头节点的处理：由于没有头结点，插入和删除操作时需要特别处理第一个节点。
3. 遍历链表：由于没有头结点，遍历链表时需要单独考虑第一个节点。
以上是不带头结点的循环单链表初始化的一些注意事项，在实际应用中需要特别留意这些细节，避免出现错误。
实验2 单链表基本操作
实验1#include<stdio.h>#include<stdlib.h>#include <malloc.h>#define OK 1#define ERROR 0typedef int Status;typedef int ElemType;//定义存储结构typedef struct Lnode{int data; /*每个元素数据信息*/struct Lnode *next; /*存放后继元素的地址*/} LNode,*LinkList;int main(){void Create_L(LinkList &L,int n);void Print_L(LinkList L);Status ListInsert_L(LinkList &L,int i,ElemType e);Status ListDelete_L(LinkList &L,int i,ElemType &e);Status Find_L(LinkList L,int e);LinkList La;//创建单链表Laint n;printf("请输入链表La中的元素个数:\n");scanf("%d",&n);Create_L(La,n);//初始化单链表printf("现在La中的元素为:\n");Print_L(La);printf("-------------------------------------\n\ n");printf("现在准备插入元素，请输入插入位置及所插入元素的值\n");int i,e;scanf("%d %d",&i,&e);ListInsert_L(La,i,e);printf("插入后La中的元素为:\n");Print_L(La);printf("-------------------------------------\n\ n");printf("现在准备删除元素，请输入删除位置\n");scanf("%d",&i);ListDelete_L(La,i,e);printf("删除后La中的元素为:\n");Print_L(La);printf("-------------------------------------\n\n");printf("请输入所要查找元素的值:\n");scanf("%d",&e);Find_L(La,e);printf("所要查找元素的位置为:%d\n",Find_L(La,e));}void Create_L(LinkList &L,int n){int j=1;L=(LinkList)malloc(sizeof(Lnode));L->next =NULL;//先建立一个带头结点的单链线性表Lfor(int i=n;i>0;--i){LinkListp=(LinkList)malloc(sizeof(Lnode));printf("请输入链表La中的第%d个元素:\n",j++);scanf("%d",&p->data);p->next=L->next;L->next =p;}//(逆序实现)/*LinkList q=L;for(int i=1;i<=n;i++){LinkList p=(LinkList)malloc (sizeof(Lnode));q->next=p;p->next=NULL;q=q->next ;printf("请输入链表La中的第%d个元素:\n",i);scanf("%d",&p->data);}//(正序实现)*/}//初始化单链表//输出单链表void Print_L(LinkList L){LinkList p;p=L->next;while(p){printf("%d ",p->data );p=p->next;}printf("\n");}//在单链表L的第i个位置前插入元素e Status ListInsert_L(LinkList &L,int i,ElemType e){LinkList p=L;int j=0;while(p&&j<i-1){p=p->next; ++j;}if(!p||j>i-1) return ERROR;LinkLists=(LinkList)malloc(sizeof(LNode));s->data=e; s->next=p->next;p->next=s;return OK;} //ListInsert_L//删除单链表L中第i个位置上的元素Status ListDelete_L(LinkList &L,int i,ElemType &e){LinkList p=L;int j=0;while( p->next && j<i-1){p=p->next; ++j;}if(!p->next||j>i-1) return ERROR;LinkList q=p->next; p->next=q->next;e=q->data;free(q);return OK;}//LinkDelete_L/*查找元素并返回位置*/Status Find_L(LinkList L,int e){LinkList p=L->next;int j=1;while(p->data!=e&&p->next){p=p->next;j++;}if(p->data==e) return j;else{printf("无当前元素\n");return ERROR;}if(!p){printf("无当前元素\n");return ERROR;}}//定位实验2#include<stdio.h>#include<stdlib.h>#include <malloc.h>#define OK 1#define ERROR 0typedef int Status;typedef int ElemType;//定义存储结构typedef struct Lnode{int data; /*每个元素数据信息*/struct Lnode *next; /*存放后继元素的地址*/} LNode,*LinkList; int main(){void Create_L(LinkList &L,int n);void Print_L(LinkList L);void MergeList_L(LinkList &La, LinkList &Lb,LinkList &Lc);LinkList La,Lb,Lc;//创建单链表La,Lb,Lcint n;printf("请输入链表La中的元素个数:\n");scanf("%d",&n);Create_L(La,n);//初始化单链表printf("现在La中的元素为:\n");Print_L(La);printf("请输入链表Lb中的元素个数:\n");scanf("%d",&n);Create_L(Lb,n);//初始化单链表printf("现在Lb中的元素为:\n");Print_L(Lb);Create_L(Lc,0);printf("-------------------------------------\n\ n");printf("开始合并:\n");MergeList_L(La, Lb,Lc);printf("-------------------------------------\n\ n");printf("合并后，Lc的元素为\n");Print_L(Lc);}void Create_L(LinkList &L,int n){int j=1;L=(LinkList)malloc(sizeof(Lnode));L->next =NULL;//先建立一个带头结点的单链线性表Lfor(int i=n;i>0;--i){LinkListp=(LinkList)malloc(sizeof(Lnode));printf("请输入链表中的第%d个元素:\n",j++);scanf("%d",&p->data);p->next=L->next;L->next =p;}//(逆序实现)/*LinkList q=L;for(int i=1;i<=n;i++){LinkList p=(LinkList)malloc (sizeof(Lnode));q->next=p;p->next=NULL;q=q->next ;printf("请输入链表La中的第%d个元素:\n",i);scanf("%d",&p->data);}//(正序实现)*/}//初始化单链表//有序单链表La和Lb的归并void MergeList_L(LinkList &La, LinkList &Lb,LinkList &Lc){LinkList pa=La->next;LinkList pb=Lb->next;LinkList pc;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);printf("");}//MergeList//输出单链表void Print_L(LinkList L){LinkList p;p=L->next;while(p){printf("%d ",p->data );p=p->next;}printf("\n");}实验3#include<stdio.h>#include<stdlib.h>#include <malloc.h>//定义存储结构typedef struct Lnode{int data; /*每个元素数据信息*/struct Lnode *next; /*存放后继元素的地址*/} LNode,*LinkList;int main(){void Create_L(LinkList &L,int n);void Print_L(LinkList L);void ReverseList(LinkList L);LinkList La;//创建单链表Laint n;printf("请输入链表La中的元素个数:\n");scanf("%d",&n);Create_L(La,n);//初始化单链表printf("现在La中的元素顺序为:\n");Print_L(La);printf("-------------------------------------\n\ n");ReverseList(La);printf("逆置后，La的元素顺序为:\n");Print_L(La);}void Create_L(LinkList &L,int n){int j=1;L=(LinkList)malloc(sizeof(Lnode));L->next =NULL;//先建立一个带头结点的单链线性表Lfor(int i=n;i>0;--i){LinkListp=(LinkList)malloc(sizeof(Lnode));printf("请输入链表中的第%d个元素:\n",j++);scanf("%d",&p->data);p->next=L->next;L->next =p;}//(逆序实现)/*LinkList q=L;for(int i=1;i<=n;i++){LinkList p=(LinkList)malloc (sizeof(Lnode));q->next=p;p->next=NULL;q=q->next ;printf("请输入链表La中的第%d个元素:\n",i);scanf("%d",&p->data);}//(正序实现)*/}//初始化单链表//输出单链表void Print_L(LinkList L){LinkList p;p=L->next;while(p){printf("%d ",p->data );p=p->next;}printf("\n");}void ReverseList(LinkList L){LinkList p,q;p=L->next;L->next=NULL;while(p!=NULL){q=p->next; /*q指针保留p->next得值*/p->next=L->next;L->next=p; /*将p结点头插入到单链表L中*/p=q; /*p指向下一个要插入的结点*/}} 思考1#include<stdio.h>#include<stdlib.h>#include <malloc.h>#define OK 1#define ERROR 0typedef int Status;typedef int ElemType;//定义存储结构typedef struct Lnode{int data; /*每个元素数据信息*/struct Lnode *next; /*存放后继元素的地址*/} LNode,*LinkList;int main(){void Create_L(LinkList &L,int n);void Print_L(LinkList L);void MergeList_L(LinkList &La, LinkList &Lb,LinkList &Lc);LinkList La,Lb,Lc;//创建单链表La,Lb,Lcint n;printf("请输入链表La中的元素个数:\n");scanf("%d",&n);Create_L(La,n);//初始化单链表printf("现在La中的元素为:\n");Print_L(La);printf("请输入链表Lb中的元素个数:\n");scanf("%d",&n);Create_L(Lb,n);//初始化单链表printf("现在Lb中的元素为:\n");Print_L(Lb);Create_L(Lc,0);printf("-------------------------------------\n\n");printf("开始合并:\n");MergeList_L(La, Lb,Lc);printf("-------------------------------------\n\n");printf("合并后，Lc的元素为\n"); Print_L(Lc);}void Create_L(LinkList &L,int n){int j=1;L=(LinkList)malloc(sizeof(Lnode)); L->next =NULL;//先建立一个带头结点的单链线性表L/*for(int i=n;i>0;--i){LinkListp=(LinkList)malloc(sizeof(Lnode));printf("请输入链表中的第%d个元素:\n",j++);scanf("%d",&p->data);p->next=L->next;L->next =p;}//(逆序实现)*/LinkList q=L;for(int i=1;i<=n;i++){LinkList p=(LinkList)malloc (sizeof(Lnode));q->next=p;p->next=NULL;q=q->next ;printf("请输入链表La中的第%d 个元素:\n",i);scanf("%d",&p->data);}//(正序实现) }//初始化单链表//有序单链表La和Lb的归并void MergeList_L(LinkList &La, LinkList &Lb,LinkList &Lc){ LinkList q;LinkList pa=La->next;LinkList pb=Lb->next;LinkList pc;Lc=pc=La;while (pa&&pb){if (pa->data<pb->data){pc->next=pa;pc=pa;pa=pa->next;}elseif(pa->data>pb->data){pc->next=pb;pc=pb;pb=pb->next; }else{pc->next=pa;pc=pa;pa=pa->next;q=pb->next;delete pb;pb=q;}}pc->next=pa?pa:pb;delete Lb;printf("");}//MergeList//输出单链表void Print_L(LinkList L){LinkList p;p=L->next;while(p){printf("%d ",p->data );p=p->next;}printf("\n");}void Delete_LinkList(LinkList &L) {LinkList p=NULL,s,t;if(L){p=p->next;while(p!=NULL){}}} 思考2#include<stdio.h>#include<stdlib.h>typedef struct node{int data;//数据域struct node *next;//指针域}L;void Initial_List(L * &h){L *p;//用于插入L *r;//尾结点h=(L *)malloc(sizeof(L));h->next = NULL;r=h;//尾结点始指向结点printf("输入数据(空格间隔数据回车结束):\n");//尾插入结点do{p=(L *)malloc(sizeof(L));scanf("%d",&(p->data));r->next = p;r = p;}while(getchar()!='\n');r->next = NULL;}void Disp_List(L * h){L *p=h->next;if(!p){printf("空!\n");return;}while(p){printf("%-3d",p->data);p=p->next;}printf("\n");}void Separate(L * &la,L * &lb,L *lc)//链表l3l1l2 l1保存奇数号结点l2保存偶数号结点{int flag=0;//结点号标记L *p = lc->next;//用于遍历链表l3L *r1,*r2,*x,*y;la=(L *)malloc(sizeof(L));lb=(L *)malloc(sizeof(L));r1=la;r2=lb;la->next = lb->next =NULL;while(p){flag++;if(flag%2 == 1){x=(L *)malloc(sizeof(L));x->data = p->data;r1->next = x;r1 = x;}else{y = (L *)malloc(sizeof(L));y->data = p->data;r2->next = y;r2 = y;}p=p->next;}r1->next = r2->next = NULL; }int main(){L *la,*lb,*lc;Initial_List(lc); Separate(la,lb,lc); printf("lc:\n"); Disp_List(lc); printf("la:\n"); Disp_List(la); printf("lb:\n"); Disp_List(lb); return 0;}。
第一部分习题答案
第⼀部分习题答案第⼀部分习题⼀、选择1、下列叙述中关于好的编程风格，正确的描述是：CA、程序中的注释是可有可⽆的为了增强可读性我们要在必要语句之后加注释B、对递归定义的数据结构不要使⽤递归过程递归的可读性强C、递归应是封闭的，尽量少使⽤全局变量D、多采⽤⼀些技巧以提⾼程序运⾏效率2、通常从正确性、易读性、健壮性、⾼效性等四个⽅⾯评价算法(包括程序)的质量。
以下解释错误的是 ( C )A、正确性算法应能正确地实现预定的功能(即处理要求)B、易读性算法应易于阅读和理解以便于调试修改和扩充C、健壮性当环境发⽣变化时，算法能适当地做出反应或进⾏处理，不会产⽣不需要的运⾏结果见课本14页D、⾼效性即达到所需要的时间性能3、以下说法正确的是 ( D )A、数据元素是数据的最⼩单位B、数据项是数据的基本单位C、数据结构是带有结构的各数据项的集合D、数据结构是带有结构的数据元素的集合4、对于顺序表，以下说法错误的是（ A ）A、顺序表是⽤⼀维数组实现的线性表，数组的下标可以看成是元素的绝对地址B、顺序表的所有存储结点按相应数据元素间的逻辑关系决定的次序依次排列C、顺序表的特点是:逻辑结构中相邻的结点在存储结构中仍相邻D、顺序表的特点是:逻辑上相邻的元素，存储在物理位置也相邻的单元中5、对顺序表上的插⼊、删除算法的时间复杂性分析来说，通常以（B ）为标准操作A、条件判断B、结点移动C、算术表达式D、赋值语句6、对于顺序表的优缺点，以下说法错误的是（ C ）A、⽆需为表⽰结点间的逻辑关系⽽增加额外的存储空间B、可以⽅便地随机存取表中的任⼀结点C、插⼊和删除运算较⽅便D、容易造成⼀部分空间长期闲置⽽得不到充分利⽤7、链表不具有的特点是：AA、可随机访问任⼀个元素B、插⼊删除不需要移动元素C、不必事先估计存储空间D、所需空间与线性表长度成正⽐8、若线性表最常⽤的操作是存取第i个元素及其前驱的值，则采⽤（D ）存储⽅式节省时间A单链表B、双向链表C、单循环链表D、顺序表9、有时为了叙述⽅便，可以对⼀些概念进⾏简称，以下说法错误的是（D ）A将“指针型变量”简称为“指针”B将“头指针变量”称为“头指针”C将“修改某指针型变量的值”称为“修改某指针”D将“p中指针所指结点”称为“P值”10．设指针P指向双链表的某⼀结点，则双链表结构的对称性可⽤（C ）式来刻画A p->prior->next->==p->next->nextB p->prior->prior->==p->next->priorC p->prior->next->==p->next->priorD p->next->next==p->prior->prior11.以下说错误的是（ A ）A对循环来说，从表中任⼀结点出发都能通过前后操作⽽扫描整个循环链表B对单链表来说，只有从头结点开始才能扫描表中全部结点C双链表的特点是找结点的前趋和后继都很容易D对双链表来说，结点*P的存储位置既存放在其前趋结点的后继指针域中，也存放在它的后继结点的前趋指针域中。
不带头结点的单链表head为空的条件
不带头结点的单链表head为空的条件：
判定该链表为非空的条件是：head->next！=null。
带头节点的情况下，链表空时还会存在一个节点，所以head不为空，head->next为空不带头节点的情况下，链表空时，没有任何节点，head指向null。
无论是否有头结点，头指针始终指向链表的第一个结点。
如果有头结点，头指针就指向头结点。
头结点的作用是使所有链表的头指针非空，并使对单链表的插入、删除操作不需要区分是否为空表或是否在第一个位置进行，从而与其他位置的插入、删除操作一致。
头结点与链表状态的关系：防止单链表是空的而设的。
当链表为空的时候，带头结点的头指针就指向头结点。
如果当链表为空的时候，头结点的指针域的数值为NULL。
方便单链表的特殊操作,插入在表头或者删除第一个结点.这样就保持了单链表操作的统一性!单链表加上头结点之后，无论单链表是否为空，头指针始终指向头结点，因此空表和非空表的处理也统一了，方便了单链表的操作，也减少了程序的复杂性和出现bug的机会。
对单链表的多数操作应明确对哪个结点以及该结点的前驱。
不带头结点的链表对首元结点、中间结点分别处理等。
而带头结点的链表因为有头结点，首元结点、中间结点的操作相同,从而减少分支，使算法变得简单，流程清晰。
单链表实验报告总结
单链表实验报告总结单链表实验报告总结篇一：单链表实验报告实验一线性表基本操作的编程实现 --线性表在链表存储下的主要操作实现班级:T523-1 姓名:王娟学号:33 完成日期:201X.0 4.04 地点:5502 学时:2学时一、需求分析【实验目的】通过本次实验，对课堂上线性表的知识进行巩固，进一步熟悉线性表的链接存储及相应的基本操作；并熟练掌握VC++6.0操作平台，学会调试程序，以及编写电子实验报告【实验要求】编写线性表的基本操作，有构造线性表，线性表的遍历，插入，删除，查找，求表长等基本功能，在此基础上能够加入DS下的图形界面以及学会文件的操作等功能，为以后的学习打下基础。
【实验任务】(1).线性表基本操作的编程实现，掌握线性表的建立、遍历、插入、删除等基本操作的编程实现，也可以进一步编程实现查找、逆序、排序等操作，存储结构可以在顺序结构或链表结构中任选，可以完成部分主要功能，也可以用菜单进行管理完成大部分功能。
还鼓励学生利用基本操作进行一些更实际的应用型程序设计。
(2).用菜单管理，把线性表的顺序存储和链表存储的数据插入、删除运算进行程序实现。
建议实现键盘数据输入实现改实验的通用性。
为了体现功能的正常性，至少要编制遍历数据的函数.(3).注意事项:开发语言使用C++，尽量使用面向对象的思想和实现方法，可以改编成应用软件. 【实验类型】验证型实验二、概要设计需要实现线性表的以下功能:1、创建单链表2、删除链表中的某个结点3、输出单链表(遍历)4、释放结点所占空间5、查找第i个结点6、插入一个结点7、求链表的长度二、详细设计(1).数据结构线性表的线性结构觉决定了它的性质：数据元素之间是一种线性关系，数据元素一个接一个的排列，除了最后一个数据，其他的数据面临的下一个数据有且仅有一个。
数据结构第二章试题
第2章线性表一、选择题1.链表不具备的特点是（）。
A．可随机访问任意结点B.插入删除不需要移动元素C.不必事先估计存储空间D.所需空间与其长度成正比2.不带头结点的单链表head为空的判定条件是（）。
==NULLB. head->next==NULL >next==head!=NULL3.带头结点的单链表head为空的判定条件是（）。
==NULLB. head->next==NULL >next==head!=NULL4．带头结点的双循环链表L为空表的条件是（）。
A．L==NULL B．L->next->==NULL C．L->prior==NULL >next==L5.非空的循环链表head的尾结点（由P所指向）满足（）。
A．p->next==NULL B．p==NULL C．p->next==head ==head6.在循环双链表的p所指结点之前插入s所指结点的操作是（）。
A．p->prior=s;s->next=p;p->prior->next=s;s->prior=p->prior;B．p->prior=s;p->prior->next=s;s->next=p;s->prior=p->prior;C．s->next=p;s->prior=p->prior;p->prior=s;p->right->next=s;D. s->next=p;s->prior=p->prior;p->prior->next=s;p->prior=s;7.若某表最常用的操作是在最后一个结点之后插入一个结点或删除最后一个结点，则采用（）存储方式最节省运算时间。
A．单链表B．给出表头指针的单循环链表C．双链表D.带头结点的双循环链表8.某线性表最常用的操作是在最后一个结点之后插入一个节点或删除第一个结点，故采用（）存储方式最节省运算时间。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
上海电力学院
数据结构实验报告
（2014/2015 学年第2学期）课程编号 250504704 课程名称数据结构
院（系）
专业
班级
学号
姓名
实验名称实验2 不带头结点的单链表
任课老师卢芳芳
实验2 不带头结点的单链表
1【实验目的与要求】
1、熟练掌握动态链表结构及有关算法的设计方法。
2、理解不带表头结点的单链表的特点，掌握其基本操作。
3、熟练掌握运用不带头结点链表表示特定形式的数据的方法，并设计出有关算法。
2【实验内容和步骤】
已知不带头结点的链表结构定义及头插法建表、尾插法建表和打印链表等函数定义如下（详见slnklist.h文件），基于该文件完成实验题1-实验4.
#include <stdio.h>
#include <stdlib.h>
/**************************************/
/* 链表实现的头文件，文件名slnklist.h */
/**************************************/
typedef int datatype;
typedef struct link_node{
datatype info;
struct link_node *next;
}node;
typedef node *linklist;
/**********************************/
/*函数名称：creatbystack() */
/*函数功能：头插法建立单链表*/
/**********************************/
linklist creatbystack()
{ linklist head,s;
datatype x;
head=NULL;
printf("请输入若干整数序列:\n");
scanf("%d",&x);
while (x!=0) /*以0结束输入*/
{ s=(linklist)malloc(sizeof(node)); /*生成待插入结点*/
s->info=x;
s->next=head; /*将新结点插入到链表最前面*/
head=s;
scanf("%d",&x);
}
return head; /*返回建立的单链表*/
}
/**********************************/
/*函数名称：creatbyqueue() */
/*函数功能：尾插法建立单链表*/
/**********************************/
linklist creatbyqueue()
{
linklist head,r,s;
datatype x;
head=r=NULL;
printf("请输入若干整数序列:\n");
scanf("%d",&x);
while (x!=0) /*以0结束输入*/
{ s=(linklist)malloc(sizeof(node));
s->info=x;
if (head==NULL) /*将新结点插入到链表最后面*/
head=s;
else
r->next=s;
r=s;
scanf("%d",&x);
}
if (r) r->next=NULL;
return head; /*返回建立的单链表*/
}
/**********************************/
/*函数名称：print() */
/*函数功能：输出不带头结点的单链表*/
/**********************************/
void print(linklist head)
{ linklist p;
int i=0;
p=head;
printf("List is:\n");
while(p)
{
printf("%5d",p->info);
p=p->next;
i++;
if (i%10==0) printf("\n");
}
printf("\n");
}
/**********************************/
/*函数名称：delList() */
/*函数功能：释放不带头结点的单链表*/
/**********************************/
void delList(linklist head)
{ linklist p=head;
while (p)
{ head=p->next;
free(p);
p=head;
}
}
1.编写函数lnklist delx(linklist head, datatype x)，删除不带头结点单链表head中第一个值为x 的结点。
并构造测试用例进行测试。
●程序源代码（注意添加注释）
●运行结果（直接截取结果图）
2.线性表（a1, a2, a3, …, a n）采用不带头结点的单链表存储，请设计算法函数linklist reverse1(linklist head)和void reverse2(linklist *head)将不带头结点的单链表head倒置，使表变成（a n, a n-1, a n-2, …, a2, a1）. 。
并构造测试用例
进行测试。
●程序源代码（注意添加注释）
●运行结果（直接截取结果图）
3.假设不带头结点的单链表head是升序排列的，设计算法函数linklist insert(linklist head,datatype x)，将值为x 的结点插入到链表head中，并保持链表有序性。
分别构造插入到表头、表中和表尾三种情况的测试用例进行测试。
●程序源代码（注意添加注释）
●运行结果（直接截取结果图）
4.编写函数lnklist delallx(linklist head, datatype x)，删除不带头结点单链表head中所有值为x 的结点。
并构造测试用例进行测试。
●程序源代码（注意添加注释）
●运行结果（直接截取结果图）
3【实验遇到的问题及解决方法】
4【实验结论与体会】
1、结合上课内容，写出程序，并调试程序，要给出测试数据和实验结果。
2、添加适当注释，注意书写的层次结构。
3、整理上机步骤，总结经验和体会。
4、上交实验报告。