实验二 链表操作实现
实验二 链表的基本操作
实验二链表的基本操作链表是一种常见的数据结构，它由一系列节点组成，每个节点包含数据和指向下一个节点的指针。
链表的基本操作包括插入、删除和查找节点，这些操作在实际编程中非常常见且重要。
我们来看链表的插入操作。
链表的插入操作可以将新节点插入到链表的任意位置，包括链表的头部、尾部或者中间位置。
插入操作的具体步骤如下：1. 创建一个新节点，并为新节点赋值。
2. 将新节点的指针指向原链表中要插入位置的前一个节点。
3. 将原链表中要插入位置的前一个节点的指针指向新节点。
4. 将新节点的指针指向原链表中要插入位置的后一个节点。
接下来是链表的删除操作。
链表的删除操作可以删除链表中的任意节点，包括链表的头部、尾部或者中间位置。
删除操作的具体步骤如下：1. 找到要删除的节点的前一个节点。
2. 将要删除的节点的前一个节点的指针指向要删除的节点的下一个节点。
3. 释放要删除的节点的内存空间。
最后是链表的查找操作。
链表的查找操作可以根据节点的值或者位置来查找节点。
查找操作的具体步骤如下：1. 遍历链表，依次比较节点的值或者位置，直到找到目标节点。
2. 返回目标节点的值或者位置。
除了基本的插入、删除和查找操作，链表还有一些其他的操作，如获取链表的长度、反转链表等。
获取链表的长度可以通过遍历链表并计数节点的数量来实现。
反转链表可以通过修改节点的指针的指向来实现，具体步骤如下：1. 遍历链表，依次修改每个节点的指针的指向，将指针指向上一个节点。
2. 最后将头节点的指针指向空。
链表的基本操作在实际编程中非常常见且重要。
它们可以用于实现各种功能和算法，如链表的排序、合并两个链表等。
在使用链表的过程中，我们需要注意链表为空或者操作位置无效的情况，以避免出现错误。
链表是一种常见的数据结构，具有灵活性和高效性。
了解链表的基本操作对于编程非常重要，它们可以帮助我们实现各种功能和算法。
通过学习和掌握链表的基本操作，我们可以更好地应用链表来解决实际问题。
实验二 单链表基本操作的实现
实验二单链表基本操作的实现【实验课程名称】数据结构【实验项目名称】单链表基本操作的实现【实验目的】1 理解单链表的存储结构及基本操作的定义；2掌握单链表存储基本操作；3学会设计实验数据验证程序。
【实验仪器及环境】计算机，window xp操作系统，VC++6.0【实验内容及步骤】1．单链表顺序存储基本操作存储结构定义：typedef struct LNode{ //结点类型ElemType data;struct LNode *next;}*Link,*Position;typedef struct{ //链表类型Link head,tail;int len;}LinkList;实现的基本操作：#include<iostream>#include<malloc.h>#include<stdlib.h>#include<iomanip>using namespace std;#define TRUE 1#define FALSE 0#define OK 1#define ERROR 0#define INFEASIBLE -1#define OVERFLOW -2typedef int Status;typedef int ElemType;typedef struct LNode{ //结点类型ElemType data;struct LNode *next;}*Link,*Position;typedef struct{ //链表类型Link head,tail;int len;Position MakeNode_L(Link &p,ElemType e) //创建结点{p=(Link)malloc(sizeof(LNode));if(!p) return ERROR;p->data=e;p->next=NULL;return p;}void FreeNode_L(Link &q) //释放结点{free(q);}Status InitList_L(LinkList &L){//初始化L为一个带头结点的空链表,头尾指针指向头结点，表长赋ElemType e;e=-1;//实际应用中此初始化语句需要修改if(!MakeNode_L(L.head,e))return ERROR;//开辟头结点L.tail=L.head;L.len=0;return OK;}//InitList_LStatus DestroyList_L(LinkList &L){//销毁链表LLink p;while(p=L.head->next){//依次释放有序链表中第一个元素至最后一个元素所占用空间;L.head->next=p->next;free(p);}free(L.head);L.head=NULL;L.tail=NULL;L.len=0;cout<<endl<<"The list has been destroyed!"<<endl;return OK;}//DestroyList_LStatus ClearList_L(LinkList &L) {//清空线性单链表Link p,q;p=L.head->next;while(p){q=p->next;free(p);p=q;}L.tail=L.head;return OK;}Status InsFirst_L(LinkList &L,Link s) //在首元素前插入一个结点{s->next=L.head->next;if(!L.head->next)L.tail=s;L.head->next=s;L.len++;return OK;}Status DelFirst_L(LinkList &L,Link h,Link &q) //删除首结点{h=L.head;q=L.head->next;if(q){h->next=q->next;q->next=NULL;if(!h->next)L.tail=h;L.len--;return OK;}elsereturn ERROR;}Status Append_L(LinkList &L,Link s) //将两个链表跟一个字符串连接起来{Link q;if(!L.head->next)L.head->next=q=s;elseL.tail->next=q=s;while(q->next){q=q->next;}L.tail=q;return OK;}Position Remove_L(LinkList &L,Link &q) //删除尾结点{Link p;p=L.head;if(!L.head->next) cout<<"The LinkList is empty!"<<endl;else{while(p->next!=L.tail)p=p->next;q=L.tail;L.tail=p;L.tail->next=NULL;L.len--;}return q;}Status InsBefore_L(LinkList &L,Link &p,Link s) //在p指向的结点前插入一个结点{Link q;q=L.head;if(p==L.head) cout<<" 不能在这个地方插入元素!"<<endl;else{while(q->next!=p)q=q->next;s->next=p;q->next=s;}L.len++;return OK;}Status InsAfter_L(LinkList &L,Link &p,Link s) //在p指向的结点后插入一个结点{if(p==L.tail) L.tail=s;s->next=p->next;p->next=s;L.len++;return OK;}Status SetCurElem_L(Link &p,ElemType e) //改变p指向的结点的内容{p->data=e;return OK;ElemType GetCurElem_L(Link p) //获取p指向的结点的内容{return p->data;}int ListLength_L(LinkList L) //获取单链表的长度值{return L.len;}Status ListEmpty_L(LinkList L) //判断单链表是否为空，是返回，否返回{if(L.head==L.tail) return TRUE;else return FALSE;}Position GetHead_L(LinkList L) //获取头指针的地址{return L.head;}Position GetLast_L(LinkList L) //获取尾指针的地址{return L.tail;}Position PriorPos_L(LinkList L,Link p) //获取p的前驱{Link q;q=L.head;if(p==L.head->next) return NULL;elsewhile(q->next!=p)q=q->next;return q;}Position NextPos_L(LinkList L,Link p) //获取p的后继{if(!p->next) return NULL;return p->next;}Status LocatePos_L(LinkList L,int i,Link &p) //查找p在单链表中的位置iint j;if(i<1) return ERROR;p=L.head->next;for(j=1;j<i;j++)p=p->next;if(!p) return ERROR;return OK;}Status compare(ElemType x,ElemType y) //比较函数{if(x==y)return 1;elsereturn 0;}Status LocateElem_L(LinkList L,ElemType e,Link &p) //返回跟e相同的值，没有的话返回空指针{int i=0;p=L.head;do{i++;p=p->next;}while(p&&!compare(p->data,e));if(p)cout<<i<<endl;elsecout<<"It is not in here!"<<endl;return OK;}Status ListTraverse_L(LinkList L,Status(*visit(ElemType))) //每一个元素调用visit()函数{Link p;p=L.head->next;while(p->next){visit(p->data);p=p->next;}return OK;}Status ListInsert_L(LinkList &L,int i,ElemType e) //在第i个位置后插入一个元素{int j;Link p,s;s=(Link)malloc(sizeof(LNode));p=L.head->next;for(j=1;j<i;j++)p=p->next;s->data=e;s->next=p->next;p->next=s;L.len++;return OK;}Status ListDelete_L(LinkList &L,int i) //删除第i个元素的结点{if(i>L.len) return ERROR;int j;Link p;p=L.head->next;for(j=1;j<i-1;j++)p=p->next;p->next=p->next->next;L.len--;return OK;}Status MergeList_L(LinkList La,LinkList Lb,LinkList &Lc) //将两个字符串连接起来{Link p,q,t;p=La.head->next;q=Lb.head->next;while(p&&q){if(p->data<q->data){MakeNode_L(t,p->data);InsFirst_L(Lc,t);p=p->next;}else{MakeNode_L(t,q->data);InsFirst_L(Lc,t);q=q->next;}}while(p){MakeNode_L(t,p->data);InsFirst_L(Lc,t);p=p->next;}while(q){MakeNode_L(t,q->data);InsFirst_L(Lc,t);q=q->next;}return OK;}【测试数据及实验结果】int main(){LinkList la,lb,lc;Link p,q,s,k,t;InitList_L(la);InitList_L(lb);InitList_L(lc);cout<<"建立一个有个数据的顺序表La，各节点值依次为：,4,6,8,10,12，….,38,40"<<endl;cout<<"-----------------------------------"<<endl;for(int i=20;i>=1;i--){MakeNode_L(p,2*i);InsFirst_L(la,p);}q=la.head->next;while(q){cout<<setw(3)<<q->data;q=q->next;}cout<<endl;cout<<endl<<"删除，节点"<<endl;cout<<"----------------------------------"<<endl;ListDelete_L(la,8);ListDelete_L(la,30);q=la.head->next;while(q){cout<<setw(3)<<q->data;q=q->next;}cout<<endl;cout<<"-----------------------------------"<<endl;cout<<"表长为："<<la.len<<endl;cout<<"-----------------------------------"<<endl;cout<<" 在第五个结点后插入一个结点"<<endl;cout<<"-----------------------------------"<<endl;ListInsert_L(la,5,11);q=la.head->next;while(q){cout<<setw(3)<<q->data;q=q->next;}cout<<endl;cout<<"-----------------------------------"<<endl;cout<<"分别查找值为,45的元素"<<endl;cout<<"-----------------------------------"<<endl;LocateElem_L(la,28,s);LocateElem_L(la,45,s);cout<<"-----------------------------------"<<endl;cout<<"建立线性表Lb，各结点值依次为："<<endl;cout<<"3,8,13,18,23,28,33,38,43,48,53,58,63,68,73,78"<<endl;cout<<"-----------------------------------"<<endl;for(int i=7;i>=0;i--){MakeNode_L(p,i*10+8);InsFirst_L(lb,p);MakeNode_L(p,i*10+3);InsFirst_L(lb,p);}q=lb.head->next;while(q){cout<<setw(3)<<q->data;q=q->next;}cout<<endl;cout<<"-----------------------------------"<<endl;cout<<"将La和Lb合并为线性表Lc"<<endl;cout<<"-----------------------------------"<<endl;MergeList_L(la,lb,lc);q=la.head->next;cout<<"-----------------------------------"<<endl;cout<<"输出La，Lb，Lc的以及各表的表长"<<endl;cout<<"-----------------------------------"<<endl;while(q){cout<<setw(3)<<q->data;q=q->next;}cout<<endl;q=lb.head->next;while(q){cout<<setw(3)<<q->data;q=q->next;}cout<<endl;q=lc.tail;while(q){cout<<setw(3)<<q->data;q=PriorPos_L(lc,q);}cout<<endl;cout<<"-----------------------------------"<<endl;cout<<"清空线性表La，Lb；输出La，Lb的表长"<<endl;cout<<"-----------------------------------"<<endl;cout<<la.len<<endl<<lb.len<<endl<<lc.len<<endl;ClearList_L(la);cout<<la.len<<endl;ClearList_L(lb);cout<<lb.len<<endl;return 0;}【实验小结】举例说明求解什么样的问题用顺序存储，什么样的问题用链式存储较好？答:使用顺序存储结构的情况:(1)空间利用率较高；(2)存取某个元素速度快；(3)插入元素和删除元素存在元素移动,速度慢,耗时；(4)有空间限制,当需要存取的元素个数可能多于顺序表的元素个数时,会出现"溢出"问题.当元素个数远少于预先分配的空间时,空间浪费巨大。
实验二、线性表-单链表的实现
实验二单链表的实现
一、实验目的
1.熟练掌握指针的使用；
2.熟练掌握使用分支语句进行决策；熟练掌握使用循环语句提高效率；
3.熟练掌握函数的使用。
4.熟练掌握链表的使用
二、实验要求
1.在上机前完成源程序；
2.能在机器上正确、调试运行程序；
3.本实验需提交实验报告。
4.实验报告文件命名方法：实验2_信管12xx_学号后两位_姓名.doc
三、实验内容和步骤
1.基于带头结点的单链表实现线性表的以下操作：
a)单链表初始化
b)插入
c)删除
d)查找
e)单链表判空
f)打印顺序表中的所有元素
g)* 删除递增有序单链表中所有值大于mink且小于maxk的元素。
h)* 将x插入到单链表的适当位置上，以保持单链表中元素的有序性。
i)* 将单链表进行就地逆置。
j)* 将两个单链表表合并为一个单链表。
k)* 若两个元素按值递增有序排列的单链表A和B，且同一表中的元素值各不相同。
试构造一个单链表C，其元素为A和B中元素的交集，且表
C中的元素也按值递增有序排列。
l)* 删除第i个开始的k个元素。
2.备份自己程序。
三、实验成绩考核方法
成绩考核方法主要为：
教师抽查部分学生，让他们演示自己写的程序。
教师提出问题，确定学生对程序的把握程度和熟练程度。
实验2-链表的应用
实验2 链表的应用一、实验目的●了解并掌握链表的概念与定义●能够实现并运用链表●熟练运用链表的基本操作二、实验环境●个人计算机一台，CPU主频1GHz以上，1GB以上内存，2GB以上硬盘剩余空间。
●Windows2000、Windows XP或Win 7操作系统●Code::Blocks(版本12.11或近似版本，英文版)，或VC++ 6.0三、实验内容1 基本部分(必做)1．单向链表的创建与操作设单向链表中节点的数据域的数据类型为整型，编写函数实现以下操作：（1）实现单向链表的创建（包括初始化）与输出操作，节点的个数及节点的数据由用户输入。
（源代码：ds3-1.c）（2）查找给定的单链表中的第i个节点，并将其地址返回。
若不存在第i 个节点，则返回空地址。
（源代码：ds3-2.c）（3）查找给定的单链表中值为n的节点，并将其地址返回。
若不存在值为n的节点，则返回空地址。
同时，还应通过参数传回该节点的序号。
（源代码：ds3-3.c）（4）删除给定的单链表中的第i个节点，成功返回1，失败返回0。
（源代码：ds3-4.c）（5）删除给定的单链表中值为n的节点，成功返回1，失败返回0。
（源代码：ds3-5.c）（6）在给定的单链表的第i位上插入值为n的节点。
（源代码：ds3-6.c）（7）在给定单链表的值为m的节点的前面插入一个值为n的节点。
（源代码：ds3-7.c）2．双向循环链表的创建与操作设双向链表中节点的数据域的数据类型为整型，编写函数实现以下操作：（1）实现双向循环链表的创建（包括初始化）与输出操作，节点的个数及节点的数据可以在程序中直接确定。
（源代码：ds4-1.c）（2）删除给定的双向循环链表中值为n的节点，成功返回1，失败返回0。
（源代码：ds4-2.c）（3）在给定的双向循环链表中的第i位上插入值为n的节点，成功返回1，失败返回0。
（源代码：ds4-3.c）2 提高部分(选做)已知链表A和B中节点的值都按照从小到大的顺序排序，且任何两个节点的值都不相同。
数据结构-实验2-链表的基本操作
实验2链表的基本操作一、需求分析1，初始化链表2，调用插入函数建立一个链表3，链表的插入和删除4，链表元素的查找4，将链表分为奇链表和偶链表5，链表的逆置二、概要设计1.基础题1)编写链表基本操作函数typedefstruct list{Int data;Struct list* next}LIST;LIST* InitList() //初始化LIST* InsertList(LIST * L,int item,int re) //向链表指定位置插入元素LIST* InsertOrderList(LIST *L,int item) //向有序链表指定位置插入元素void FindList(LIST*L, int item)//查找链表中的元素void display(LIST *L)//显示链表void divide(LIST* La, LIST *Lb)//拆分链表LIST * turn(LIST *L)//转置链表2)调用上述函数实现下列操作，操作步骤如下。
A.初始化链表B.调用插入函数建立一个链表C.在链表中寻找指定的元素D.在链表中删除指定值的元素E.遍历并输出链表注意每完成一个步骤，必须及时输出顺序表元素，便于观察操作结果2.提高题a)将一个首结点指针为a的单链表A分解成两个单链表A和B，其首结点指针分别为a，b，使得链表A中含有原链表A中序号为奇数的元素，而链表B中含有原链表A中序号为偶数的元素，且保持原来的相对顺序。
解题思路将单链表A中含有序号为偶数的元素删除，并在删除时把这些结点链接起来构成单链表B即可。
b)将链接存储线性表逆置，即最后一个结点变成第一个结点原来倒数第二个结点变成第二个结点，如此等等。
解题思路依次遍历源链表，将每个元素依次赋给一个新链表并将新链表从后到前连接。
3.主函数void main(){LIST *L1,*L2,*L3;int i;L1=InitList();printf("创建链表L1:\n");for(i=1;i<=5;i++){L1=InsertList(L1,i*2,i);}display(L1);for(i=1;i<=9;i+=4){printf("在L1的%d位置插入3:\n",i);L1=InsertList(L1,3,i);display(L1);}//有序表L2 = InitList();printf("\n有序表实验:\n");printf("创建链表L2:\n");for (i = 1; i <= 5; i++){L2 = InsertList(L2, i * 2, i); }display(L2);for (i = 1; i <= 13; i +=6 ){printf("插入%d:\n",i);L2 = InsertOrderList(L2,i);display(L2);}//删除元素实验printf("\n删除元素实验:\n"); printf("L2插入1:\n", i);L2 = InsertList(L2,1,1);display(L2);for (i = 1; i < 12; i += 5){printf("删除L2中%d\n",i);L2 = DeleteList(L2, i);display(L2);}//查找printf("\n查找元素实验:\n"); printf("查找L2中%d\n", 13); FindList(L2,13);printf("查找L2中%d\n", 6); FindList(L2, 6);//分解printf("\n分解实验:\n");printf("L2:\n");display(L2);L3 = InitList();printf("将L2偶序数拆分到L3\n"); divide(L2,L3);printf("L2:\n");display(L2);printf("L3:\n");display(L3);printf("\n逆序实验:\n");printf("L2:\n");display(L2);L2 = turn(L2);printf("转置L2:\n");display(L2);}三、详细分析插入实验，函数能够在链表前、中、后插入元素，并判断插入位置是否超过链表长度，若超过则接入链尾。
实验二 单链表基本操作
实验二单链表基本操作一、实验目的1．掌握握单链表的基本操作：新建、插入、删除、查找等运算。
二、实验要求1．认真阅读和掌握本实验的程序。
2．上机运行本程序。
3．保存和打印出程序的运行结果，并结合程序中的问题进行分析。
三、实验内容单链表基本操作的实现，这个程序中演示了单链表的创建、插入、删除和查找。
程序如下：#include<malloc.h>typedef struct node{int data;struct node *next;} NODE;/******************************************/NODE *Create()//问题1：该函数创建的带头结点的单链表，还是不带头结点的单链表？{NODE *p,*head;int x;head=(NODE *)malloc(sizeof(NODE));head->next=NULL;printf("Input data,-1 to End!\n");scanf("%d",&x);while(x!=-1){p=(NODE *)malloc(sizeof(NODE));p->data=x;p->next=head->next;head->next=p;scanf("%d",&x);}return(head);}/******************************************/void Output(NODE *head){NODE *p;p=head;printf("Begin to dump the LinkList...\n");while(p->next!=NULL){printf("->%d",p->next->data);p=p->next;}printf("\nThe LinkList ended!\n");}/******************************************/int Listlen(NODE *head){int i=0;NODE *p=head;while(p->next!=NULL){i++;p=p->next;}return(i);}/******************************************/int Get(NODE *head,int i)//问题2：将该函数修改成返回第i个元素的指针，若不存在，返回空{int j=0;NODE *p=head;while(p->next&&j<i){j++;p=p->next;}if(!p->next||j>i) return(0);else return(p->data);}/******************************************/void Del(NODE *head,int i){NODE *p=head;int j=0;while(p->next&&j<i-1){j++;p=p->next;}if(!p->next||j>i-1) printf("the position is wrong\n");elsep->next=p->next->next;}/******************************************/void Ins(NODE *head,int i,int e){NODE *p=head,*q;int j=0;while(p->next&&j<i-1){j++;p=p->next;}if(!p->next&&j>i-1) printf("Wrong position\n" );else{q=(NODE *)malloc(sizeof(NODE));q->data=e;q->next=p->next;p->next=q;}}/******************************************/main(){NODE *head;int length;int i,element;head=Create();Output(head);//以下函数调用（求长度、插入、删除、查找）能否改成菜单形式？如何改？length=Listlen(head);printf("the length of the link is %d\n",length);printf("input the order :\n");scanf("%d",&i);element=Get(head,i);printf("the element of the order is %d\n",element);printf("input the del position \n");scanf("%d",&i);Del(head,i);Output(head);printf("Input the insert posion and element:\n");scanf("%d%d",&i,&element);Ins(head,i,element);Output(head);}}。
实验二 链表操作实现
实验二链表操作实现实验日期：2017 年 3 月16 日实验目的及要求1. 熟练掌握线性表的基本操作在链式存储上的实现；2. 以线性表的各种操作（建立、插入、删除、遍历等）的实现为重点；3. 掌握线性表的链式存储结构的定义和基本操作的实现；4. 通过本实验加深对C语言的使用（特别是函数的参数调用、指针类型的应用）。
实验内容已知程序文件linklist.cpp已给出学生身高信息链表的类型定义和基本运算函数定义。
（1）链表类型定义typedef struct {int xh; /*学号*/float sg; /*身高*/int sex; /*性别，0为男生，1为女生*/} datatype;typedef struct node{datatype data; /*数据域*/struct node *next; /*指针域*/} LinkNode, *LinkList;（2）带头结点的单链表的基本运算函数原型LinkList initList();/*置一个空表（带头结点）*/void createList_1(LinkList head);/*创建单链表*/void createList_2(LinkList head);/* 创建单链表*/void sort_xh(LinkList head);/*单链表排序*/void reverse(LinkList head);/*对单链表进行结点倒置*/void Error(char *s);/*自定义错误处理函数*/void pntList(LinkList head);/*打印单链表*/void save(LinkList head,char strname[]);/*保存单链表到文件*/任务一创建程序文件linklist.cpp，其代码如下所示，理解LinkList类型和基本运算函数后回答下列问题。
#include <stdio.h>#include <stdlib.h>/*单链表结点类型*/typedef struct {int xh; /*学号*/float sg; /*身高*/int sex; /*性别，0为男生，1为女生*/} datatype;typedef struct node{datatype data; /*数据域*/struct node *next; /*指针域*/} LinkNode, *LinkList;/*带表头的单链表的基本运算函数*/LinkList initList();/*置一个空表（带头结点）*/void createList_1(LinkList head);/*创建单链表*/void createList_2(LinkList head);/*创建单链表*/void sort_xh(LinkList head);/*单链表排序*/void reverse(LinkList head);/*单链表倒置*/void Error(char *s);/*自定义错误处理函数*/void pntList(LinkList head);/*打印单链表*/void save(LinkList head,char strname[]);/*保存单链表到文件*//*置一个空表*/LinkList initList(){ LinkList p;p=(LinkList)malloc(sizeof(LinkNode));p->next=NULL;return p;}/*创建单链表*/void createList_1(LinkList head){ FILE *fp;int xh;float sg;int sex;LinkList p;if((fp=fopen("records.txt","r"))==NULL){ Error("can not open file !");return ;}while(!feof(fp)){ fscanf(fp,"%d%f%d",&xh,&sg,&sex);p=(LinkList)malloc(sizeof(LinkNode));p->data.xh=xh;p->data.sg=sg;p->data.sex=sex;p->next=head->next;head->next=p;}fclose(fp);}/*创建单链表*/void createList_2(LinkList head){ FILE *fp;int xh;float sg;int sex;LinkList p,rear;if((fp=fopen("records.txt","r"))==NULL){ Error("can not open file !");return ;}rear=head;while(!feof(fp)){ fscanf(fp,"%d%f%d",&xh,&sg,&sex);p=(LinkList)malloc(sizeof(LinkNode));p->data.xh=xh;p->data.sg=sg;p->data.sex=sex;p->next=NULL;rear->next=p;rear=p;}fclose(fp);}/*单链表排序*/void sort_xh(LinkList head){LinkList q,p,u;p=head->next;head->next=NULL;/*利用原表头结点建新的空表*/while(p){ q=p; /*q为被插入的结点*/p=p->next;/*用p记录后继结点*//*遍历新链表查找插入位置*/u=head;while(u->next!=NULL)/*查找插入位置*/{ if(u->next->data.xh>q->data.xh)break;u=u->next;}/*插入在u结点的后面*/q->next=u->next;u->next=q;}}/*单链表倒置*/void reverse(LinkList head){ LinkList p, r;p=head->next;head->next=NULL;while(p){ r=p;p=p->next;/*r指向结点头插到链表*/r->next=head->next;head->next=r;}}/*输出单链表*/void pntList(LinkList head){ LinkList p;p=head->next;while(p!=NULL){printf("%2d: %.2f %d\n",p->data.xh,p->data.sg,p->data .sex);p=p->next;}}/*自定义错误处理函数*/void Error(char *s){ printf("\n %s", s);exit(1); /*返回OS,该函数定义在stdlib.h中*/}/*保存单链表到文件*/void save(LinkList head,char strname[]){ FILE *fp;LinkList p;if((fp=fopen(strname,"w"))==NULL){ printf("can not open file !");return ;}p=head->next;while(p!=NULL){ fprintf(fp,"%2d %5.2f %2d\n",p->data.xh,p->data.sg,p->data.sex);p=p->next;}fclose(fp);}请回答下列问题：（1）由单链表结点类型定义可知，该链表结点类型名为 LinkNode ，结点的指针类型为 LinkList ，向系统申请一个学生结点空间并把起始地址存于上述结点指针变量new 中的语句是： p=(LinkList)malloc(sizeof(LinkNode)); 。
数据结构实验二链表
数据结构实验二1、实验目的∙熟练掌握线性表的链式存储结构定义及基本操作∙理解循环链表和双链表的特点和基本运算2、实验内容：建立单链表，完成链表（带表头结点）的基本操作：建立链表、插入、删除、查找、输出、求前驱、求后继、两个有序链表的合并操作。
其他基本操作还有销毁链表、将链表置为空表、求链表的长度、获取某位置结点的内容、搜索结点。
1．问题描述：利用线性表的链式存储结构,设计一组输入数据（假定为一组整数），能够对单链表进行如下操作：∙初始化一个带表头结点的空链表;∙创建一个单链表是从无到有地建立起一个链表，即一个一个地输入各结点数据，并建立起前后相互链接的关系。
又分为逆位序(插在表头)输入n 个元素的值和正位序(插在表尾)输入n 个元素的值;∙插入结点可以根据给定位置进行插入（位置插入），也可以根据结点的值插入到已知的链表中（值插入），且保持结点的数据按原来的递增次序排列，形成有序链表。
∙删除结点可以根据给定位置进行删除（位置删除），也可以把链表中查找结点的值为搜索对象的结点全部删除（值删除）;∙输出单链表的内容是将链表中各结点的数据依次显示，直到链表尾结点;∙求前驱结点是根据给定结点的值，在单链表中搜索其当前结点的后继结点值为给定的值，将当前结点返回;∙求后继结点是根据给定结点的值，在单链表中搜索其当前结点的值为给定的值，将后继结点返回;∙两个有序链表的合并是分别将两个单链表的结点依次插入到第3 个单链表中，继续保持结点有序;编写主程序，实现对各不同的算法调用。
其它的操作算法描述略。
2．实现要求：对链表的各项操作一定要编写成为C（C++）语言函数，组合成模块化的形式，还要针对每个算法的实现从时间复杂度和空间复杂度上进行评价。
∙“初始化算法”的操作结果：构造一个空的线性表L，产生头结点,并使L 指向此头结点;∙“建立链表算法”初始条件：空链存在;操作结果：选择逆位序或正位序的方法，建立一个单链表，并且返回完成的结果;∙“链表（位置）插入算法”初始条件：已知单链表L 存在;操作结果：在带头结点的单链线性表L 中第i 个位置之前插入元素e;∙“链表（位置）删除算法”初始条件：已知单链表L 存在;操作结果：在带头结点的单链线性表L 中，删除第i 个元素,并由e 返回其值;∙“输出算法”初始条件：链表L 已存在;操作结果：依次输出链表的各个结点的值;∙“求前驱算法”初始条件: 线性表L 已存在;操作结果: 若cur_e 是L 的数据元素,且不是第一个,则用pre_e 返回它的前驱;∙“求后继算法”初始条件: 线性表L 已存在;操作结果: 若cur_e 是L 的数据元素,且不是最后一个,则用next_e 返回它的后继;∙“两个有序链表的合并算法”初始条件: 线性表单链线性表La 和Lb 的元素按值非递减排列;操作结果:归并La 和Lb 得到新的单链表。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
实验二链表操作实现实验日期： 2017 年 3 月 16 日实验目的及要求1. 熟练掌握线性表的基本操作在链式存储上的实现；2. 以线性表的各种操作（建立、插入、删除、遍历等）的实现为重点；3. 掌握线性表的链式存储结构的定义和基本操作的实现；4. 通过本实验加深对C语言的使用（特别是函数的参数调用、指针类型的应用）。
实验容已知程序文件linklist.cpp已给出学生身高信息链表的类型定义和基本运算函数定义。
（1）链表类型定义typedef struct {int xh; /*学号*/float sg; /*身高*/int sex; /*性别，0为男生，1为女生*/} datatype;typedef struct node{datatype data; /*数据域*/struct node *next; /*指针域*/} LinkNode, *LinkList;（2）带头结点的单链表的基本运算函数原型LinkList initList();/*置一个空表（带头结点）*/void createList_1(LinkList head);/*创建单链表*/void createList_2(LinkList head);/* 创建单链表*/void sort_xh(LinkList head);/*单链表排序*/void reverse(LinkList head);/*对单链表进行结点倒置*/void Error(char *s);/*自定义错误处理函数*/void pntList(LinkList head);/*打印单链表*/void save(LinkList head,char strname[]);/*保存单链表到文件*/任务一创建程序文件linklist.cpp，其代码如下所示，理解LinkList类型和基本运算函数后回答下列问题。
#include <stdio.h>#include <stdlib.h>/*单链表结点类型*/typedef struct {int xh; /*学号*/float sg; /*身高*/int sex; /*性别，0为男生，1为女生*/} datatype;typedef struct node{datatype data; /*数据域*/struct node *next; /*指针域*/} LinkNode, *LinkList;/*带表头的单链表的基本运算函数*/LinkList initList();/*置一个空表（带头结点）*/void createList_1(LinkList head);/*创建单链表*/void createList_2(LinkList head);/*创建单链表*/void sort_xh(LinkList head);/*单链表排序*/void reverse(LinkList head);/*单链表倒置*/void Error(char *s);/*自定义错误处理函数*/void pntList(LinkList head);/*打印单链表*/void save(LinkList head,char strname[]);/*保存单链表到文件*//*置一个空表*/LinkList initList(){ LinkList p;p=(LinkList)malloc(sizeof(LinkNode));p->next=NULL;return p;}/*创建单链表*/void createList_1(LinkList head){ FILE *fp;int xh;float sg;int sex;LinkList p;if((fp=fopen("records.txt","r"))==NULL){ Error("can not open file !");return ;}while(!feof(fp)){ fscanf(fp,"%d%f%d",&xh,&sg,&sex);p=(LinkList)malloc(sizeof(LinkNode));p->data.xh=xh;p->data.sg=sg;p->data.sex=sex;p->next=head->next;head->next=p;}fclose(fp);}/*创建单链表*/void createList_2(LinkList head){ FILE *fp;int xh;float sg;int sex;LinkList p,rear;if((fp=fopen("records.txt","r"))==NULL){ Error("can not open file !");return ;}rear=head;while(!feof(fp)){ fscanf(fp,"%d%f%d",&xh,&sg,&sex);p=(LinkList)malloc(sizeof(LinkNode));p->data.xh=xh;p->data.sg=sg;p->data.sex=sex;p->next=NULL;rear->next=p;rear=p;}fclose(fp);}/*单链表排序*/void sort_xh(LinkList head){LinkList q,p,u;p=head->next;head->next=NULL;/*利用原表头结点建新的空表*/while(p){ q=p; /*q为被插入的结点*/p=p->next;/*用p记录后继结点*//*遍历新链表查找插入位置*/u=head;while(u->next!=NULL)/*查找插入位置*/{ if(u->next->data.xh>q->data.xh)break;u=u->next;}/*插入在u结点的后面*/q->next=u->next;u->next=q;}}/*单链表倒置*/void reverse(LinkList head){ LinkList p, r;p=head->next;head->next=NULL;while(p){ r=p;p=p->next;/*r指向结点头插到链表*/r->next=head->next;head->next=r;}}/*输出单链表*/void pntList(LinkList head){ LinkList p;p=head->next;while(p!=NULL){printf("%2d: %.2f %d\n",p->data.xh,p->data.sg,p->data .sex);p=p->next;}}/*自定义错误处理函数*/void Error(char *s){ printf("\n %s", s);exit(1); /*返回OS,该函数定义在stdlib.h中*//*保存单链表到文件*/void save(LinkList head,char strname[]){ FILE *fp;LinkList p;if((fp=fopen(strname,"w"))==NULL){ printf("can not open file !");return ;}p=head->next;while(p!=NULL){ fprintf(fp,"%2d %5.2f %2d\n",p->data.xh,p->data.sg,p->data.sex);p=p->next;}fclose(fp);}请回答下列问题：（1）由单链表结点类型定义可知，该链表结点类型名为 LinkNode ，结点的指针类型为 LinkList ，向系统申请一个学生结点空间并把起始地址存于上述结点指针变量new中的语句是： p=(LinkList)malloc(sizeof(LinkNode)); 。
（2）回答问题：a）已知：LinkList head ; 画出执行head=initList();语句后的链表结构示意图head*顺序：1-13-7-15-2b）在a)操作的基础上，根据records.txt中的数据，画出执行createList_1(head);语句后的链表结构示意图c）在b)操作的基础上，画出执行sort_xh(head) ;语句后的链表结构示意图d）在c)操作的基础上，画出执行reverse(head) ;语句后的链表结构示意图heade）在d)操作的基础上，写出执行pntList(head) ;语句后屏幕输出结果（3）写出下列操作对应的执行语句（以下的指针变量的类型都是上述定义的结点指针类型）a）把一个new指针指向的结点头插到以h为头指针带表头结点的单链表中的语句new->next=h->next;h->next=new;b）把一个new指针指向的结点头插到以h为头指针不带表头结点的单链表中的语句new->next=h;h=new;c）在单链表中删除r所指结点的后继结点（假设存在）的语句r->next=r->next->nextd）分别写出循环及非循环单链表中判断r所指结点是尾结点（假设存在）15 13 7 2 1 ^的条件循环：r->next= =NULL非循环：r->next!=NULL任务二1．题目要求创建一个新的程序文件sy12.cpp，请调用linklist.cpp提供的功能函数（以#include “linklist.cpp”方式导入函数库）及自定义的函数完成以下操作：●从数据文件records.txt中读取学生信息，建立与源数据同序的学生链表并打印在屏幕上；●统计学生链表中身高达标人数（男女生的身高达标值由键盘输入），并打印结果；●从键盘输入一位学生的相关信息插入到已排序的学生身高链表中后仍然保持学号的有序性；●对上述操作后的学生链表进行倒置，结果输出到数据文件result.txt中；●删除链表中身高为指定值的所有学生结点并打印；在程序文件sy12.cpp需再定义以下三个功能函数：（1）int count(LinkList head,float sg_fm,float sg_m)功能：已知女生达标身高为sg_fm，男生达标身高为sg_m，统计head为头指针的学生链表中身高达标人数并返回；（2）void insertX(LinkList head, datatype x)功能：在学号从小到大排序的学生链表中插入值为x的学生仍保持学号的有序性（3）int delete(LinkList head,float sg)功能：删除head为头指针的学生链表中指定身高的所有学生结点，删除成功返回1，否则返回0；2．请根据题目功能要求或程序中的注释完整sy12.cpp代码#include "linklist.cpp"int count(LinkList head,float sg_fm,float sg_m);/*统计head为头指针的学生链表中身高达标人数并返回*/void insertX(LinkList head, datatype x);/*在学号从小到大排序的学生链表中插入值为x的学生仍保持学号的有序性*/int delete(LinkList head,float sg);/*删除head为头指针的学生链表中指定身高的所有学生结点，删除成功返回1，否则返回0*/void main(){ LinkList head;int c,flag;float sg,sg_fm,sg_m;datatype x;/*建立与源数据文件同序的学生链表并输出；*/head= initList() ; /*建空链表*/createList_2(head) ; /*调用建链表函数建立所需链表*/printf("\n与数据文件同序的学生链表：\n");pntList(head) ; /*调用函数打印输出链表息*/getchar();/*统计学生链表中身高达标人数（男女生的身高达标值由键盘输入）并打印结果；*/printf("\n输入达标的女生、男生身高值：");scanf("%f%f",&sg_fm,&sg_m);c=count( head, sg_fm, sg_m );printf("\n达标学生人数为：%d",c);getchar();/*对学生链表按学号进行排序*/sort_xh(head);/*在学生链表中插入指定的学生元素后使链表仍按学号有序*/x.xh=3;x.sg=1.67;x.sex=0;insertX( head, x );printf("\n new list after insert:\n");pntList(head);getchar();/*对学生链表进行倒置，结果输出到文件result.txt中；*/reverse(head);save(head,"result.txt");getchar();/*删除链表中身高为指定值的所有学生结点;*/sg=1.67;flag= dele(head, sg) ;if(flag)printf("\ndelete succeed!\n");elseprintf("\ndelete failed\n");printf("\n new list after delete:\n");pntList(head);getchar();//统计学生链表中身高达标人数并返回(sg_fm女生身高达标值、sg_m男生身高达标值)int count(LinkList head,float sg_fm,float sg_m){ int n=0;LinkList p;p = head->next;while (p != NULL){if (p->data.sex == 1)/*sex：1 女生*/{if (p->data.sg >= sg_fm)n++;}else{if (p->data.sg >= sg_m)n++;}p = p->next;}return n;}//在学号从小到大排序的学生链表中插入值为x的学生仍保持学号的有序性void insertX(LinkList head, datatype x){LinkList p, u;p = (LinkList)malloc(sizeof(LinkNode));p->data.xh = x.xh;p->data.sg = x.sg;p->data.sex = x.sex;u = head;while (u->next != NULL){if (u->next->data.xh>x.xh)break;u = u->next;}p->next = u->next;u->next = p;}//删除学生链表中指定身高(存于sg中)的所有学生结点，删除成功返回1，否则返回0int delete(LinkList head,float sg){LinkList p,q,v;int flag=0;q=head;p=head->next;while(p!=NULL){if(p->data.sg==sg){ /*删除p所指结点*/v = p;p = p->next;q->next = p;free(v);flag=1;}else{q = p;p = p->next;}}return flag; /*删除成功返回1,否则返回0*/}实验总结分析（本程序的重点与难点，调试中出现的问题及解决方法等）。