实验二 链表操作实现
实验二 链表的基本操作
实验二链表的基本操作链表是一种常见的数据结构，它由一系列节点组成，每个节点包含数据和指向下一个节点的指针。
链表的基本操作包括插入、删除和查找节点，这些操作在实际编程中非常常见且重要。
我们来看链表的插入操作。
链表的插入操作可以将新节点插入到链表的任意位置，包括链表的头部、尾部或者中间位置。
插入操作的具体步骤如下：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 得到新的单链表。
实验二：单链表基本运算实现
{
int data; //存放表结点值
struct node *next; //存放表结点的直接后驱元素的地址
} ListNode,*LinkList;
//头插法创建初始链表
LinkList create_h(int size)
{
;//将工作指针p指向后一个结点
;//计数器累加
}
return i;
}
//打印链表中的现有元素
printList(LinkList head)
{
LinkList p;
;//将工作指针p指向第1个结点
{
p=(LinkList)malloc(sizeof(ListNode));//申请新结点的存储空间
scanf("%d",&p->data);//读入新结点的值到data域中
;//将新增结点插到头结点的后面
;//将新增结点插到头结点的后面
printf("————头插法建立链表(1)\n");
printf("————尾插法建立链表(2)\n");
printf("————按位查找元素(3)\n");
printf("————按值查找元素(4)\n");
printf("————插入元素(5)\n");
printf("————删除元素(6)\n");
printList(h);
break;
case 5:
printf("插入元素,请输入要插入元素的值:\n");
实验二 单链表基本操作
实验二单链表基本操作一实验目的1.学会定义单链表的结点类型，实现对单链表的一些基本操作和具体的函数定义，了解并掌握单链表的类定义以及成员函数的定义与调用。
2.掌握单链表基本操作及两个有序表归并、单链表逆置等操作的实现。
二实验要求1．预习C语言中结构体的定义与基本操作方法。
2．对单链表的每个基本操作用单独的函数实现。
3．编写完整程序完成下面的实验内容并上机运行。
4．整理并上交实验报告。
三实验内容1．编写程序完成单链表的下列基本操作：(1)初始化单链表La。
(2)在La中第i个元素之前插入一个新结点。
(3)删除La中的第i个元素结点。
(4)在La中查找某结点并返回其位置。
(5)打印输出La中的结点元素值。
2 .构造两个带有表头结点的有序单链表La、Lb，编写程序实现将La、Lb合并成一个有序单链表Lc。
合并思想是：程序需要3个指针：pa、pb、pc，其中pa，pb分别指向La表与Lb表中当前待比较插入的结点，pc 指向Lc表中当前最后一个结点。
依次扫描La和Lb中的元素，比较当前元素的值，将较小者链接到*pc 之后，如此重复直到La或Lb结束为止，再将另一个链表余下的内容链接到pc所指的结点之后。
3．构造一个单链表L，其头结点指针为head，编写程序实现将L逆置。
（即最后一个结点变成第一个结点，原来倒数第二个结点变成第二个结点，如此等等。
）四思考与提高1．如果上面实验内容2中合并的表内不允许有重复的数据该如何操作？2．如何将一个带头结点的单链表La分解成两个同样结构的单链表Lb，Lc，使得Lb中只含La表中奇数结点，Lc中含有La表的偶数结点？1．编写程序完成单链表的下列基本操作：(1)初始化单链表La。
(2)在La中第i个元素之前插入一个新结点。
(3)删除La中的第i个元素结点。
(4)在La中查找某结点并返回其位置。
(5)打印输出La中的结点元素值。
#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;//先建立一个带头结点的单链线性表L for(int i=n;i>0;--i){LinkList p=(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个位置前插入元素eStatus 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;LinkList s=(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 .构造两个带有表头结点的有序单链表La、Lb，编写程序实现将La、Lb合并成一个有序单链表Lc。
实验2 链表的基本操作
实验目的：熟悉链表的逻辑特性、存储表示方法的特点和链式表的基本操作。
实验要求：了解并熟悉链式表的逻辑特性、存储表示方法和链式表的基本操作的实现和应用。
实验内容：1、编写一个程序建立存放学生成绩的有序链表并实现相关操作，要求如下：（1）设学生成绩表中的数据元素由学生姓名和学生成绩字段组成，实现这样的线性表的链式存储表示。
（2）键盘输入10个（或若干个，特殊数据来标记输入数据的结束）数据元素，利用链表的基本操作建立学生成绩单链表，要求该表为有序表并带有头结点。
（用于比较的字段为分数）。
（3）输入关键字值x，打印出表中所有关键字值<=x的结点。
（用于比较的关键字字段为分数）。
（4）输入关键字值x，删除表中所有关键字值<=x的结点。
（用于比较的关键字字段为分数）。
实验实现#include "stdio.h"#include "malloc.h"#include "string.h"typedef struct LNode{char nam e[10];int cj;struct LNode *next;}student;void creatLink(student *head){student *p;char nam e[10];printf("请输入学生姓名成绩(输入end结束)\n");while(1){scanf("%s",name);if(nam e[0]=='e'&&nam e[1]=='n'&&name[2]=='d') break;p=(student*)m alloc(sizeof(student));strcpy(p->name,name);scanf("%d",&p->cj);p->next=head->next;head->next=p;} }void printLink(student *head){ student *p=head;if(head->next==NULL) printf("此链表为空\n");while(p->next!=NULL){p=p->next;printf("%s %d\n",p->name,p->cj);} }void printLessLink(student *head,int x){ int b=1;student *p=head;if(head->next==NULL) printf("此链表为空\n");while(p->next!=NULL){ p=p->next;if(p->cj<=x){ printf("%s %d\n",p->name,p->cj);b=0;} }if(b) printf("此链表没有成绩<=%d的结点\n",x);}void delLessLink(student *head,int x){ student *p=head,*temp;if(head->next==NULL) printf("此链表为空\n"); while(p->next!=NULL){ if(p->next->cj<=x){ temp=p->next;p->next=tem p->next;free(tem p);}else{ p=p->next;} } }void main(){ int x,b=0;student *head;head=(student*)malloc(sizeof(student));head->next=NULL;creatLink(head);while(1){ printf("1:输出所有结点\n");printf("2:输出分数小于等于X的结点\n");printf("3:删除分数小于等于X的结点\n");printf("0:退出\n");scanf("%d",&x);switch(x){ case 1:{ printLink(head);break;}case 2:{ printf("X=");scanf("%d",&x);printLessLink(head,x);break;}case 3:{ printf("X=");scanf("%d",&x);delLessLink(head,x);break;}case 0: b=1;}if(b) break;}}。
实验二(链表的操作)
程序：#include<stdio.h>#include<malloc.h>#include<stdlib.h>#include<iostream>usingnamespace std;typedefstruct LNode //链表结点{int data;struct LNode *next;}LNode,*LinkList;int over_flag=0;void create(LinkList &L);void chazhao(LinkList L);void charu(LinkList &L);int lengthList(LinkList L);void shanchu(LinkList &L);void shanchu1(LinkList &L);void shanchu2(LinkList &L);void zhuanhua(LinkList &L);void fenjie(LinkList &L);int lengthList(LinkList L){int i=0;LinkList p=L->next;while(p){p=p->next;i++;}return i;}void create(LinkList &L){int i,n,temp;printf("\n请输入链表的结点数量:");scanf("%d",&n);L = (LinkList)malloc(sizeof(LNode));L->next = NULL;LinkList q=L;printf("创建链表：\n请输入创建链表所需的整数值:\n"); for(i=1;i<=n;i++){scanf("%d",&temp);LinkList p;p = (LinkList)malloc(sizeof(LNode));p->data = temp;p->next = NULL;q->next = p;q = q->next;}printf("所建立的单链表为:\n");LinkList p=L->next;for(i=1;i<=n;i++){printf("%d ",p->data);p=p->next;}}void chazhao(LinkList L){ if(!L)printf("错误：链表未创建！");int element;printf("查询数值：\n输入要查询的数值：");scanf("%d",&element);LinkList p=L->next;int i =1;while(p){if(p->data==element){printf("找到了，它是链表的第%d个元素。
实验二：链表的操作
【实验结果或总结】 （对实验结果进行相应分析，或总结实验的心得体会，并提出实验的改进意见）
指导教师签名： 20 年 月 日
【备注】
【实验环境】 （含主要设计设备、器材、软件等） 运行 VC++的电脑一台 【实验步骤、过程】 （含原理图、流程图、关键代码，或实验过程中的记录、数据等） #include "Onering.h" void display(Onering &ring,int s,int d) { int j=0; OnelinkNode *p=ring.head; while(j<s-1) { j++; p=p->next; } while(p->next!=p) { j=1; while(j<d-1) { j++; p=p->next; } ring.remove(p); p=p->next; // 删除 p 的后继结点 //计数 // 多于一个结点时循环 // 计数起始点 // } cout<<"The final person is "<<p->data<<"\n"; //最后一个人 } void main(void) { int n=5,s=1,d=2; Onering ring1(n); ring1.output(); display(ring1,s,d); } // 建立有 n 个结点的单向循环链表
【实验内容】 （1） （2） 实现链式存储的相关运算（在一个程序中实现链表的建立、查找、插入、删除和输入操作） 提高题：某百货公司仓库中有一批电视机，试按价格从高到底的次序建立一个循环链表，每个结 点有价格、数量和链指针三个域。现新到 m 台价格为 h 的电视机，修改原链表并输出修改后链表 的所有内容。
数据结构 实验二：单链表的基本操作
数据结构实验二：单链表的基本操作数据结构实验二：单链表的基本操作实验二：单链表的基本操作一、【实验目的】1、理解和掌握单链表的类型定义方法和结点生成方法。
2、掌握建立单链表和显示单链表元素的算法。
3、掌握单链表的查找、插入和删除算法二、【实验内容】1、建立一个整形数的单链表，手动输入10个数，并从屏幕显示单链表元素列表。
2、从键盘输入一个数，查找在以上创建的单链表中是否存在该数;如果存在，显示它的位置;如果不存在，给出相应提示。
3、删除上述单链表中指定位置的元素。
以下就是程序部分代码，恳请调试并补足并使之恰当运转：１．linlist.htypedefstructnode{datatypedata;structnode*next;}slnode;voidlistinitiate(slnode**head)/*初始化*/{/*如果有内存空间，申请头结点空间并使头指针head指向头结点*/if((*head=(slnode*)malloc(sizeof(slnode)))==null)exit(1);(*head)->next=null;/*置链尾标记null*/}intlistlength(slnode*head){slnode*p=head;/*p指向首元结点*/intsize=0;/*size初始为0*/while(p->next!=null)/*循环计数*/{p=p->next;size++;}returnsize;}intlistinsert(slnode*head,inti,datatypex)/*在带头结点的单链表head的数据元素ai（0≤i≤size）结点前*//*填入一个存放数据元素x的结点*/{slnode*p,*q;intj;p=head;/*p指向首元结点*/j=-1;/*j起始为-1*/while(p->next!=null&&j<i-1)/*最终让指针p指向数据元素ai-1结点*/{p=p->next;j++;}if(j!=i-1){printf(\填入边线参数弄错！\return0;}/*生成新结点由指针q指示*/if((q=(slnode*)malloc(sizeof(slnode)))==null)exit(1);q->data=x;q->next=p->next;/*给指针q->next赋值*/p->next=q;/*给指针p->next重新赋值*/return1;}intlistdelete(slnode*head,inti,datatype*x)/*删除带头结点的单链表head的数据元素ai（0≤i≤size-1）结点*//*删除结点的数据元素域值由x带回。
实验二 单链表操作
实验二单链表操作一、实验目的1．掌握握单链表的基本操作：插入、删除、查找等运算。
二、实验要求1．认真阅读和掌握本实验的程序。
2．上机运行本程序。
3．保存和打印出程序的运行结果，并结合程序进行分析。
4．按照你对单链表的操作需要，重新改写主程序并运行，打印出文件清单和运行结果三、实验内容单链表基本操作的实现四、实验步骤1、定义单链表的结构typedef struct Lnode{int *base;int *top;int stacksize;} *LinkList;2、定义单链表的几个常用操作：单链表的创建、插入、删除和查找。
void CreateList_L(LinkList &L,int n){L=(LinkList)malloc(sizeof(LNode));L->next=NULL;LNode *p;printf("请输入%d个元素\n",n);for(int i=n;i>0;--i){p=(LinkList)malloc(sizeof(LNode));scanf("%d",&p->data);p->next=L->next;L->next=p;}}单链表插入,删除和查找int ListInsert_L(LinkList &L,int i,int e){//找到第i-1个元素，让p指向它LNode *p=L;int j=0;while(p&&j<i-1){p=p->next;j++;}//没有找到的情况,i<1或者i>表长if(!p||j>i-1)return -1;//为新结点申请内存LNode *s=(LinkList)malloc(sizeof(LNode));s->data=e;//插入新结点s->next=p->next;p->next=s;return 1;}3、编写主函数测试单链表的操作void main(){LinkList L;int length;printf("输入你要创建单链表的长度\n");scanf("%d",&length);CreateList_L(L,length);Output(L);length=Listlen(L);printf("单链表的长度是：%d\n",length);int i;ElemType element;printf("输入你要查找的元素的位置:\n");scanf("%d",&i);GetElem_L(L,i,element);printf("第%d个元素的值是: ",i);printf(" %d\n",element);printf("输入你要插入的元素的位置:\n");scanf("%d",&i);printf("输入你要插入的元素的值:\n");scanf("%d",&element);ListInsert_L(L,i,element);printf("插入后的线性表是: ");Output(L);printf("输入你要删除的元素的位置:\n");scanf("%d",&i);ListDelete_L(L,i,element);printf("删除后的线性表是: ");Output(L);五、实验总结：附录：完整程序#include<malloc.h>#include <stdio.h>typedef int ElemType; //定义数据元素的类型为int，你也可以在这里把它改成其它数据类型//单链表结点的定义typedef struct LNode{int *base;int *top;int stacksize;} *LinkList;/*创建单链表*****************************************/void CreateList_L(LinkList &L,int n){L=(LinkList)malloc(sizeof(LNode));L->next=NULL;LNode *p;printf("请输入%d个元素\n",n);for(int i=n;i>0;--i){p=(LinkList)malloc(sizeof(LNode));scanf("%d",&p->data);p->next=L->next;L->next=p;}}/*输出单链表*****************************************/void Output(LinkList &L){//……//部分代码printf("开始输出单链表各个元素\n");//……printf("\n单链表结束!\n");}/*单链表的长度*****************************************/int Listlen(LinkList &L){//1、分配内存L.elem=(ElemType *)malloc(LIST_INIT_SIZE*sizeof(ElemType));if(!L.elem)//申请内存失败的情况exit(OVERFLOW);L.length=0; //线性表的长度L.listsize=LIST_INIT_SIZE;//线性表L的容量return OK;}/*得到单链表中第i个元素的值*****************************************/ int GetElem_L(LinkList &L,int i,ElemType &e){}/*删除第i个元素*****************************************/int ListDelete_L(LinkList &L,int i,ElemType &e)/*在第i个位置上插入一个新的元素*****************************************/int ListInsert_L(LinkList &L,int i,ElemType e){//1、判断插入位置i是不是正确if(i<1||i>L.length+1)return ERROR;//2、判断线性表的存储空间是否已满if(L.length>=L.listsize){//满则追加内存ElemType *newbase=(ElemType *)realloc(L.elem,(L.listsize+LISTINCREMENT)*sizeof(ElemType) );//判断申请内存是否成功if(!newbase)//申请失败exit(OVERFLOW);//申请成功L.elem=newbase;L.listsize+=LISTINCREMENT;}//从第n个元素至第i个元素依次向后移动一个位置ElemType * q= &(L.elem[i-1]);//用q保存第i个元素的地址ElemType *p=&(L.elem[L.length-1]);//用p保存第n个元素的地址for( ;p>=q;--p){*(p+1)=*p;}*q=e;//将q插入到第i个位置++L.length;return OK;}/******************************************/void main(){LinkList L;int length;printf("输入你要创建单链表的长度\n");scanf("%d",&length);CreateList_L(L,length);Output(L);length=Listlen(L);printf("单链表的长度是：%d\n",length);int i;ElemType element;printf("输入你要查找的元素的位置:\n");scanf("%d",&i);GetElem_L(L,i,element);printf("第%d个元素的值是: ",i);printf(" %d\n",element);printf("输入你要插入的元素的位置:\n");scanf("%d",&i);printf("输入你要插入的元素的值:\n");scanf("%d",&element);ListInsert_L(L,i,element);printf("插入后的线性表是: ");Output(L);printf("输入你要删除的元素的位置:\n");scanf("%d",&i);ListDelete_L(L,i,element);printf("删除后的线性表是: ");Output(L);}。
链表-实验报告
实验2 链表实验概述：一、实验目的本次实习的主要目的是为了使学生熟练掌握链表的基本操作以及在链式存储结构上的实现，包括创建、插入、删除、查找、以及合并等操作。
二、实验要求掌握链表存储方式，熟悉链式存储结构。
三、实验步骤用链表结构实现对多项式初始化、创建、插入、删除等运算。
步骤：输入第一个多项式：7x+2x3输入第二个多项式：8x+9x5输出第一个多项式输出第二个多项式输出两个多项式相加的结果：15x+2x3+9x5实验结果如图：四、实验环境（使用的软件和设备）（1）实习器材：多媒体计算机。
（2）实习地点：校内多媒体机房。
（3）实习软件: Win-TC实验内容：【实验过程】（实验步骤、记录、数据、分析）实验过程（提示）输入第一个多项式：7x+2x3输入第二个多项式：8x+9x5输出第一个多项式输出第二个多项式输出两个多项式相加的结果：15x+2x3+9x5【结果实验记录】（图形或图像）1.说明掌握情况#include<stdio.h>#include<stdlib.h>typedef struct{int sat1,sat2,sat3,sat4;}ElemType;typedef struct LNode{ElemType data;struct LNode *next;}LNode,*LinkList;LinkList InitList(){ LinkList L;L=(LinkList)malloc(sizeof(LNode)); L->next=NULL;return(L);}void InsLNode(LinkList L,ElemType x){ LinkList s,p;s=(LinkList)malloc(sizeof(LNode));s->data=x;p=L;while(p->next)p=p->next;s->next=NULL;p->next=s;}void AddPolyn(LinkList La,LinkList Lb){int sum;int a,b;LinkList pa,pb;pa=La->next;pb=Lb->next;a=pa->data.sat1;b=pb->data.sat1;sum=a+b;printf(" %dx%d exp",sum,pa->data.sat2);printf("+");printf(" %dx%d exp+",pa->data.sat3,pa->data.sat4); printf(" %dx%d exp\n",pb->data.sat3,pb->data.sat4);}void Print(LinkList L){ LinkList p;p=L->next;printf(" %dx%d exp",p->data.sat1,p->data.sat2); printf("+");printf(" %dx%d exp",p->data.sat3,p->data.sat4);}main() {LinkList La,Lb;ElemType c,b;int a,i;La=InitList();Lb= InitList();printf("Please input polynomial La:\n");scanf("%d %d",&c.sat1,&c.sat2);scanf("%d %d",&c.sat3,&c.sat4);InsLNode(La,c);printf("Please input polynomial Lb:\n");scanf("%d %d",&b.sat1,&b.sat2);scanf("%d %d",&b.sat3,&b.sat4);InsLNode(Lb,b);printf("polynomial La:");printf("\n");Print(La);printf("\n");printf("polynomial Lb:");printf("\n");Print(Lb);printf("\n");printf("La+Lb:");printf("\n");AddPolyn(La,Lb);printf("\n");getch();}2.裁图说明实验结果【心得体会、问题和建议】成绩：指导教师签名批阅日期：。
实验二 单链表操作(C++)
实验二单链表操作实验目的1．会定义单链表的结点类型。
2．熟悉对单链表的一些基本操作和具体的函数定义。
3．了解和掌握单链表的类定义以及成员函数的定义与调用格式。
实验要求1．认真阅读和掌握本实验内容所给的全部程序。
2．从本实验内容中任选一个程序上机运行。
3．保存和打印出程序运行结果，并结合程序进行分析。
4．按照你对单链表操作的需要，重新改写主文件并运行，打印出主文件清单和运行结果。
当然也可以根据你的需要改写或增删进行单链表操作的函数。
实验内容下面程序用来实现单链表的定义和操作，程序由头文件、实现文件和主文件所组成。
程序中的单链表采用类的定义，操作函数为类中的成员函数，单链表中每个结点的值为整型。
//链表类.htypedef int ElemType;struct sNode{ElemType data;sNode* next;};class ListClassLink{struct sNode *Head;public:ListClassLink(void);ElemType GetElemList(int pos);bool FindList(ElemType& item);bool ModifyList(const ElemType& item);void InsertList(ElemType item);bool DeleteList(ElemType item);bool EmptyList(void);int LenthList(void);void OutputList(void);~ListClassLink(void);};//链表类实现文件.cpp#include<iostream.h>#include<stdlib.h>#include"链表类.h"ListClassLink::ListClassLink(void){sNode* np=new sNode;Head=np;np->next=NULL;}ElemType ListClassLink::GetElemList(int pos){ if(pos<1){cerr<<"pos is out range!"<<endl;exit(1);}int n=0;sNode *p=Head->next;while(p!=NULL){n++;if(n==pos)break;p=p->next;}if(p!=NULL)return p->data;else{cerr<<"pos 值无效!"<<endl;exit(1);}}bool ListClassLink::FindList(ElemType& item){ sNode *p=Head->next;while(p!=NULL){if(p->data==item)break;else p=p->next;}if(p!=NULL){item=p->data;return true;}else return false;}bool ListClassLink::ModifyList(const ElemType& item){ sNode *p=Head->next;while(p!=NULL){if(p->data==item)break;else p=p->next;}if(p!=NULL){p->data=item;return true;}else return false;}void ListClassLink::InsertList(ElemType item){ sNode *newp=new sNode;newp->data=item;sNode *q=Head,*p=q->next;newp->next=p;q->next=newp;}bool ListClassLink::DeleteList(ElemType item){ sNode *p=Head->next,*q=p;while(p!=NULL){if(p->data==item)break;else{q=p;p=p->next;}}if(p==NULL)return false;else q->next=p->next;delete p;return true;}bool ListClassLink::EmptyList(void){return Head->next==NULL;}int ListClassLink::LenthList(void){int n=0;sNode *p=Head->next;while(p!=NULL){n++;p=p->next;}return n;}void ListClassLink::OutputList(void){sNode *p=Head->next;while(p!=NULL){cout<<p->data<<' ';p=p->next;}cout<<endl;}ListClassLink::~ListClassLink(void){sNode *p=Head->next,*q;while(p!=NULL){q=p->next;delete p;p=q;}Head->next=NULL;}//链表类主文件.cpp#include<iostream.h>#include<stdlib.h>#include"链表类实现文件.cpp"void main(){int c1[8]={23,45,62,78,94,40,83,62};int c2[7]={36,78,48,23,78,90,78};ListClassLink a,b;for(int i=0;i<8;i++)a.InsertList(c1[i]);a.OutputList();for(i=0;i<7;i++)b.InsertList(c2[i]);b.OutputList();cout<<a.LenthList()<<' '<<a.EmptyList()<<endl;cout<<b.LenthList()<<' '<<b.EmptyList()<<endl;cout<<a.GetElemList(4)<<' '<<b.GetElemList(4)<<endl;int x=94;if(a.FindList(x)) cout<<"Yes"<<endl;else cout<<"No"<<endl;if(b.ModifyList(90)) cout<<"Yes"<<endl;else cout<<"No"<<endl;}。
实验二链表的实现和应用[最新]
![实验二链表的实现和应用[最新]](https://img.taocdn.com/s3/m/0366383ccec789eb172ded630b1c59eef8c79a2c.png)
实验二链表的实现和应用一、实验目的掌握线性表的链式存储结构设计与基本操作的实现二、实验内容与要求⑴定义线性表的链式存储表示；⑵基于所设计的存储结构实现线性表的基本操作；⑶编写一个主程序对所实现的线性表进行测试；⑷线性表的应用：①设线性表L1和L2分别代表集合A和B，试设计算法求A和B的并集C，并用线性表L3代表集合C；②设线性表L1和L2中的数据元素为整数，且均已按值非递减有序排列，试设计算法对L1和L2进行合并，用线性表L3保存合并结果，要求L3中的数据元素也按值非递减有序排列。
三、数据结构设计在主函数中实现函数的调用，从而实现线性表的插入、删除、创建、显示等。
四、测试结果通过输入不同的数字（1~6）实现不同的操作，在两个线性表结合时，线性表二在源程序中已给出的，通过操作可以得到非单调递减的有序数列五、心得体会在写程序的过程中要注意分析，参照其他标准程序，多上机运行一点点的改正错误，这样才会有所提高。
MAIN.C 方丽平信计1203班1130112321 最后修改时间2014/3/31#include<stdio.h>#include<stdlib.h>#define maxsize 1024typedef int datatype;typedef struct node{datatype data;struct node * next;}linkList;int main(){linkList * CREATE();int INSERT(linkList *head, int value, int position);int DELETE(linkList *head, int position);int DISPLAY(linkList *head);linkList * COMBINE(linkList *head1, linkList *head2); linkList * head1;linkList * head2;linkList * head3;linkList * head;linkList * p1,* p2,* s1,* s2,* r1,* r2;int position, value, i;head1 = malloc(sizeof(linkList));r1 = head1;head2 = malloc(sizeof(linkList));r2 = head2;for(i = 0; i< 20; i++){s1 = malloc(sizeof(linkList));s1 ->data = i;r1 ->next = s1;r1 = s1;s2 = malloc(sizeof(linkList));s2 ->data = i + 2;r2 ->next = s2;r2 = s2;}r2 -> next = NULL;r1 -> next = NULL;while(1){printf("the program \n");printf("can realize to create,insert,delete,display,etc\n"); printf("1:create the ranked list\n");printf("2:insert a data\n");printf("3:delete a data\n");printf("4:display all the data\n");printf("5:Combine two link lists of operation\n"); printf("6:return,end of the program\n");printf("selection of operation\n");scanf("%d",&i);while ( i < 1 || i > 6 ){printf("please input again\n");scanf("%d",&i);}switch(i){case 1:head = CREATE();break;case 2:/*INSERT(p);*/printf("Please input insert place\n");scanf("%d",&position);printf("Please input insert value\n");scanf("%d",&value);INSERT(head, value, position);break;case 3:printf("Please input delete position\n");scanf("%d",&value);DELETE(head, position);break;case 4:DISPLAY(head);break;case 5:printf("The list 1:\n");DISPLAY(head1);printf("The list 2:\n");DISPLAY(head2);printf("The combine list:\n");head3 = COMBINE(head1, head2);DISPLAY(head3);break;case 6:exit(0);break;}}}linkList * CREATE(){int value;linkList * head,* s,* r;head = malloc(sizeof(linkList));r = head;printf("input the data of the number,input 55 over!");scanf("%d",&value);do{s = malloc(sizeof(linkList));s ->data = value;r ->next = s;r = s;printf("input the data of the number");scanf("%d",&value);}while(value != 55);r -> next = NULL;return head;}int INSERT(linkList *head,int value, int position){int j = 1;linkList *p,*s,*n;s = malloc(sizeof(linkList));s ->data = value;p = head;printf("Note:if the position is greater than the length of the table will be put in the final");while(j < position){if( (p -> next) != NULL ){p = p -> next;}j ++;}n = p -> next;s -> next =n;p -> next = s;return 0;}int DELETE(linkList *head, int position){int j;linkList *p;linkList *s;p = head;printf("Note:if the position is greater than the length of the table will be delete nothing!");for(j = 1;j < position; j ++){if( (p -> next) != NULL ){p = p -> next;}else{return 0;}}s = p -> next;if((s -> next) != NULL){(*p).next = (*s).next;}s = NULL;return 0;}int DISPLAY(linkList *head){linkList *p;int i;i = 0;p = head -> next;while(p != NULL){printf("%5d",(*p).data);p = p -> next;i ++;if(i % 5 == 0)printf("\n");}return 0;}linkList * COMBINE(linkList *head1, linkList *head2) {linkList *head,*r;linkList *p1, *p2,*s;head = malloc(sizeof(linkList));r = head;p1 = malloc(sizeof(linkList));p2 = malloc(sizeof(linkList));p1 = head1 -> next;p2 = head2 -> next;do{s = malloc(sizeof(linkList));if( (p1 != NULL) && (p2 != NULL) ){if(p1 -> data < p2 -> data ){s -> data = p1 -> data;p1 = p1 ->next;}else{s -> data = p2 -> data;p2 = p2 ->next;}}else if( (p1 != NULL) && (p2 == NULL) ){s -> data = p1 -> data;p1 = p1 ->next;}else if( (p2 != NULL) && (p1 == NULL) ){s -> data = p2 -> data;p2 = p2 ->next;}r ->next = s;r = s;}while( (p1 != NULL) || (p2 != NULL) );return head;}。
实验二：线性表的链式表示和实现
实验二：线性表的链式表示和实现一、实验目的：1．掌握线性表的链式存储结构的表示与实现.2．掌握对链表进行创建、插入、删除和查找等操作的算法。
3．掌握算法的设计与分析过程。
4．进一步熟悉VC++开发环境，熟悉完成一个应用程序的设计过程，掌握有关编辑、调试和整合程序的方法和技巧。
二、实验要求：1．采用教材中c语言描述的单链表存储结构，模块化设计过程，设计高效的算法完成各种操作任务，针对实际数据实现各种操作。
2．完成程序编写，调试成功后，书写实验报告。
三、实验任务：1．创建有n（n为正整数）数据元素的单链表，数据从键盘输入。
2．查找第i个结点，找到返回其值，否则返回0；3．对已经创建的单链表分别进行插入结点操作，在第i个元素之前插入1个结点。
4．删除结点，将第i个结点的元素删除。
5．将单链表进行就地逆转。
6．将链表按值的奇偶数分解成两个链表。
要求：创建单链表后，其他操作可以是任意选择进行的。
（考虑设计菜单调用各功能模块）四、设计指导：1．结点的定义#include<stdio.h>#include<stdlib.h>typedef int DataType;typedef struct node{DataType data;struct node *next;}LNode,*LinkList;2．将复杂的问题分解成若干个相对容易的小问题，并设计好解决每个小问题的函数的函数名、入口参数及其返回值；设计出各个函数的程序框架及完整的主函数程序。
（注：每个功能一个函数）如：//输出链表数据void Display(LinkList L){ LinkList p;p=L->next;while(p){printf("%4d",p->data);p=p->next;}printf("\n");}//单链表初始化LinkList ListInit( LinkList L){L=(LinkList)malloc(sizeof(LNode)); L->next=NULL;return L;}//单链表的创建LinkList ListCreate(LinkList L,int a) { int i;LinkList p;//具体操作请大家自己完成Display(L);return L;}void ListSearch(){}//单链表插入LinkList ListInsert(LinkList L){LinkList p,q;p=L;//具体操作请大家自己完成Display(L);return L;}//单链表删除LinkList ListDelete(LinkList L){ LinkList p,q;p=L;//具体操作请大家自己完成return L;}void main(){int i;int a,b,c;LinkList L;L=ListInit(L);while(1){printf("*****单链表*****\n");printf("*****1.创建*****\n");printf("*****2.查找*****\n");printf("*****3.插入*****\n");printf("*****4.删除*****\n");printf("*****0.退出*****\n");printf("请输入您的选择：\n");scanf("%d",&i);switch(i){case 1:printf("请输入元素个数：\n");scanf("%d",&a);ListCreate(L,a);break;case 2:ListSearch();break;case 3:ListInsert(L);break;case 4:ListDelete(L);Display(L);break;case 0:exit(0);default:printf("您的输入有误，请重新输入!\n");}}}。
- 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*/}实验总结分析（本程序的重点与难点，调试中出现的问题及解决方法等）。