链表基本操作实验报告记录
单链表的基本操作实验报告
单链表的基本操作实验报告单链表的基本操作实验报告引言：单链表是一种常见的数据结构，它由一系列节点组成，每个节点包含一个数据元素和一个指向下一个节点的指针。
在本次实验中，我们将学习和实践单链表的基本操作，包括创建链表、插入节点、删除节点以及遍历链表等。
一、实验目的本次实验的主要目的是掌握单链表的基本操作，包括链表的创建、插入节点、删除节点和遍历链表。
通过实践操作，加深对单链表的理解，并掌握如何应用单链表解决实际问题。
二、实验过程1. 创建链表首先，我们需要创建一个空链表。
链表可以通过一个头节点来表示，头节点不存储数据，只用于标识链表的起始位置。
我们可以定义一个指针变量head，将其指向头节点。
2. 插入节点在链表中插入节点是常见的操作。
我们可以选择在链表的头部、尾部或者指定位置插入节点。
插入节点的过程可以分为以下几个步骤：a. 创建一个新节点，并为其赋值；b. 找到要插入位置的前一个节点；c. 将新节点的指针指向前一个节点的下一个节点；d. 将前一个节点的指针指向新节点。
3. 删除节点删除节点是另一个常见的操作。
我们可以选择删除链表的头节点、尾节点或者指定位置的节点。
删除节点的过程可以分为以下几个步骤：a. 找到要删除节点的前一个节点；b. 将前一个节点的指针指向要删除节点的下一个节点；c. 释放要删除节点的内存空间。
4. 遍历链表遍历链表是为了查看链表中的元素。
我们可以从头节点开始，依次访问每个节点，并输出节点的值。
三、实验结果在本次实验中，我们成功完成了单链表的基本操作。
通过创建链表、插入节点、删除节点和遍历链表等操作，我们可以方便地对链表进行增删改查操作。
四、实验总结通过本次实验，我们对单链表的基本操作有了更深入的了解。
单链表是一种非常重要的数据结构，广泛应用于各个领域。
掌握了单链表的基本操作，我们可以更好地解决实际问题，并且为以后学习更复杂的数据结构打下坚实的基础。
在实验过程中，我们还发现了一些问题和不足之处。
创建链表和链表操作实验报告
创建链表和链表操作实验报告数据结构实验报告报告名称创建链表和链表操作专业网络工程班级1001 学号20XX03120XX9 姓名张剑指导教师陈淑红李珍辉黄哲20XX年5月4 日、实验目的：掌握线性表的基本操作：插删除、查找以及线性表入、合并等运算在顺序存储结构和链接存储结构上的运算。
二、实验内容与基本要求：实验内容：1. 创建单链表2. 在链表上进行插入、删除操作；3 .设计一个程序，用两个单链表分别表示两个集合，并求出这两个集合的并集。
实验要求：1. 在上机前写出全部源程序； 2 .能在机器上正确运行程序；3 .用户界面友好；三、概要设计：1.单链表的存储结构：teypedef structLNode{ ElemType date;struct LNond *next; }LNode *LinkList;2. 单链表的插入操作：Status ListTnsert-L(LinkLIst &L, int i, ElemType e ){//再带头结点的单链线性表L中的第i个位置之前插入元素 e P=l; j=0;While(p&&jnext;++j;}//寻找第i-1个结点if(!p||j>i-1) return ERROR; //i 小小于1 或者大于表长+1 s=(LinkList) malloc (sizeof(LNode)); //生成新结点s->date=e; s->next=p->next; // 插入L 中p->next=s; return ok;}//ListTnsert L3. 单链表的删除操作：Status ListDelete-L(LinkLlst &L, int i, ElemType &e ){//在带头结点单链线性表L中，删除低i个元素，并e返回其值p=l; j=0;while(p->next&&jnext; ++j; }if(!(p->next)||j>i-1)return ERROR; // 删除位置不合理q=p->n ext ; p->n ext=q->n ext; //删除并释放结点e=q->date free(q); return OK;} //ListDelete-L4. 链表的合并操作：void MergeList-L(LinkList & La, LinkList & Lb, LinkList &Lc){ // 已知单链表La和Lb的元素值//合并单链表La和Lb，得到新的单链表Lc pa=La->next; pb=Lb->next;lc=pc=La; //用La的头结点作为Lc的头结点while(pa&&pb){ if(pa->datedate){pc->n ext =pa; pc=pa; pa=pa->n ext; }else {pc->n ext=pb;pc=pb;pb=pb->n ext;} }Pc->next=pa pa:pb; // 插入剩余段free(Lb); // 释放Lb头结点} //MergeList-L 四、详细设计：#include #include #include #include typedefint status;typedef char ElemType; typedef struct Lnode {ElemType data;//定义链表结点类型 struct Lnode *next; }Lnode,*Linklist;status initlist(Linklist *L) {// 单链表的初始化 *L=(Lnode *)malloc(sizeof(Lnode)); //创建头结点(*L)->next=NULL;return 1;}status Createlist(Linklist L) { Lnode *p,*q;int i,j=1,n;ElemType m,M; q=L;请输入你要输入单链中元素的个数\\n\{p=(Lnode *)malloc(sizeof(Lnode)); 请输入％个元素:\scanf(\p->n ext=q->n ext;j++;} return 1;}status Listinsert(Linklist { int j=0;输入错误!\\n\ returnscanf(\ scanf(\for(i=n;i>0;i--)scanf(\ p->data=M; q->n ext=p;q=p;L,int i,ElemType e)++j; }Lnode *p=L,*s; while(p&&jnext;0; }s=(Lnode *)malloc(sizeof(Lnode)); s->data=e;//创建自己规定长度的单链表//回车缓冲区//回车缓冲区//向单链表指定位置插入一个元素s->next=p->next; p->next=s; return 1; }status Listdelete(Linklist L,int i,ElemType *e){ //删除单链表指定位置的元素，返回删除后的。
单链表的基本操作实验报告
湖南第一师范学院信息科学与工程系实验报告课程名称：数据结构与算法成绩评定：实验项目名称：单链表的基本操作指导教师：学生姓名：沈丽桃学号： 10403080118 专业班级： 10教育技术实验项目类型：验证实验地点：科B305 实验时间： 2011 年 10 月20 日一、实验目的与要求：实验目的：实现线性链表的创建、查找、插入、删除与输出。
基本原理：单链表的基本操作二、实验环境：（硬件环境、软件环境）1.硬件环境：奔ⅣPC。
2.软件环境：Windows XP 操作系统，TC2.0或VC＋＋。
三、实验内容：（原理、操作步骤、程序代码等）#include<stdio.h>#include<stdlib.h>#include<malloc.h>struct celltype{int element;struct celltype*next;};typedef int position;void main(){struct celltype*head,*p;int x,choice;void INSERT(int x,struct celltype*p);void LOCATE(int x,struct celltype*p);void DELETE(int x,struct celltype*p);p=(struct celltype*)malloc(sizeof(struct celltype));head=p;p->element=0;p->next=NULL;printf(“Please option:1:Insert 2:Locate 3:Delete\n”);printf(“Please choose:”);scanf(“%d”,&choice);switch(choice)case 1:printf(“Please input a node:”);scanf(“%d”,&x);p=head;INSERT(x,p);for(p=head;p!=NULL;p=p->next)printf(“%d”,p->element);printf(“\n”);break;case 2:printf(“Please input the data you want to locate:”); scanf(“%d”,&x);p=head;LOCATE(x,p);break;case 3:printf(“Please input the data you want to delete:”); scanf(“%d”,&x);DELETE(x,p);for(p=head;p!=NULL;p=p->next)printf(“%d”,p->next);printf(“\n”);break;}void INSERT(int x,struct celltype*p){struct celltype*t,*q;q=(struct celltype*)malloc(sizeof(struct celltype)); q->next=x;while((x>p->element)&&(p!=NULL)){t=p;p=p->next;}if((x>p->element)&&(p->next!=NULL)){p->next=q;q->next=NULL;}else{q->next=p;t->next=q;}}void LOCATE(int x,struct celltype*p){while(p->next!=NULL)if(p->next->element==x)printf(“the number %d is in %d\n”,x,p);else printf(“the number not exist!\n”);}void DELETE(int x,struct celltype*p){while((p->element!=x)&&(p->next!=NULL)){t=p;p=p->next;}if(p->element==x)t->next=p->next}error C2018:unknown character ’Oxal’error C2065:’Please’:undeclared identifiererror C4024:’printf’:different types for formal and actual parameter 1error C4047:’function’:’const*differs in levers of indirection from ’int’error C2146:syntaxerror:missing’)’before identifier’option’error C2017:illegal escape sequenceerror C2059:syntax error:’)’error C2143:syntax error:missing’)’before’%’出现了很多错误，主要是因为printf里的一对双引号不是英文状态下的。
链表实验报告
C 语言程序设计实验报告实验一：链表的基本操作一·实验目的1. 掌握链表的建立方法2. 掌握链表中节点的查找与删除3. 掌握输出链表节点的方法4. 掌握链表节点排序的一种方法5. 掌握C 语言创建菜单的方法6. 掌握结构化程序设计的方法二·实验环境1. 硬件环境：当前所有电脑硬件环境均支持2. 软件环境：Visual C++6.0三.函数功能1. CreateList // 声明创建链表函数2.TraverseList // 声明遍历链表函数3. InsertList // 声明链表插入函数4.DeleteTheList // 声明删除整个链表函数5. FindList // 声明链表查询函数 四．程序流程图五．程序代码#include<stdio.h>#include<stdlib.h>typedef int Elemtype;typedef int Status;typedef struct node//定义存储节点{int data;//数据域struct node *next;//结构体指针} *linklist,node;//结构体变量，结构体名称linklist creat (int n)//创建单链表{linklist head,r,p;//定义头指针r,p,指针int x,i;head=(node *)malloc(sizeof(node));//生成头结点 声明函数 主函数 main 创建链表函数定义CreateList 定义链表遍历函数TraverseList定义链表查询函数FindList 定义链表插入函数在链表位置第pos 节点前插入包含数据val 的节点InsertList(PNode List, int pos, int val) 插入节点 定义删除整个链表函数 DeleteTheList定义删除链表元素函数删除链表中的第pos 节点DeleteList(PNode List, int pos) 删除节点r=head;//r指向头结点printf("输入数字:\n");for(i=n;i>0;i--)//for 循环用于生成第一个节点并读入数据{scanf("%d",&x);p=(node *)malloc(sizeof(node));p->data=x;//读入第一个节点的数据r->next=p;//把第一个节点连在头结点的后面r=p;//循环以便于生成第二个节点}r->next=0;//生成链表后的断开符return head;//返回头指针}void output (linklist head)//输出链表{linklist p;p=head->next;do{printf("%3d",p->data);p=p->next;}while(p);printf("\n")}Status insert ( linklist &l,int i, Elemtype e)//插入操作{int j=0;linklist p=l,s;while(j<i-1 && p){p=p->next;++j;}if(!p || j>i-1)return -1;else{s=(node *)malloc(sizeof(node));s->data=e;s->next=p->next;p->next=s;return 1;}}Status delect ( linklist &l,int i, Elemtype &e)//删除操作{int j=0;linklist p=l,q;while(j<i-1 && p->next){p=p->next;++j;}if(!p->next || j>i-1)return -1;else{q=p->next;p->next=q->next;e=q->data;free(q);return 1;}}void combine(linklist la,linklist lb)//合并单链表{node *pa,*pb,*pc;linklist lc;pa=la->next;pb=lb->next;lc=pc=la;while(pa && pb){if(pa->data<=pb->data){pc->next=pa;pc=pa;pa=pa->next;}else{pc->next=pb;pc=pb;pb=pb->next;} }pc->next=pa?pa:pb;free(lb);}Status GetElem(linklist l,int i,Elemtype &e )//查找操作 {linklist p;int j;p=l->next;j=1;while(p && j<i){p=p->next;++j;}if(!p || j>i)return -2;e=p->data;return e;}void main(){linklist la,lb;int n;int i,j;Elemtype e;printf("请输入第一个链表:\n");printf("输入链表元素的个数:\n");scanf("%d",&n);la=creat(n);printf("输出链表:\n");output(la);printf("请输入要查找元素的位置:\n");scanf("%d",&i);j=GetElem(la,i,e);printf("所要查找的元素是%d\n",j);printf("请输入插入位置和元素:\n");scanf("%d%d",&i,&e);insert(la,i,e);printf("插入后的链表:\n");output(la);printf("请输入要删除的位置:\n");scanf("%d",&i);delect(la,i,e);printf("删除的那个元素是:%d\n",e);printf("输出删除后的顺序表:\n");output(la);printf("请输入第一个非递减链表:\n");printf("输入链表元素的个数:\n");scanf("%d",&n);la=creat(n);printf("输出链表:\n");output(la);printf("请输入第二个非递减链表:\n");printf("输入链表元素的个数:\n");scanf("%d",&n);lb=creat(n);printf("输出链表:\n");output(lb);combine(la,lb);printf("输出合并后的链表:\n");output(la);六．运行结果七．心得体会通过本次实验我对链表有了更深的了解，对链表的插删操作、遍历、查找等基本上掌握了。
北工大实验报告
一、实验名称数据结构实验二：链表的基本操作二、实验目的1. 理解链表的基本概念和结构。
2. 掌握链表的创建、插入、删除、查找等基本操作。
3. 提高编程能力，巩固数据结构知识。
三、实验环境1. 操作系统：Windows 102. 编程语言：C++3. 开发环境：Visual Studio 2019四、实验原理链表是一种常见的线性数据结构，它由一系列节点组成，每个节点包含数据和指向下一个节点的指针。
链表具有以下特点：1. 无固定长度，可以根据需要动态地添加或删除节点。
2. 链接方式灵活，便于实现各种操作。
3. 适合存储具有动态变化的数据。
本实验主要实现以下功能：1. 创建链表：根据用户输入的数据，创建一个单链表。
2. 插入节点：在链表的指定位置插入一个新节点。
3. 删除节点：删除链表中的指定节点。
4. 查找节点：在链表中查找一个指定的节点。
5. 打印链表：遍历链表并打印所有节点数据。
五、实验步骤1. 创建链表```cppstruct ListNode {int data;ListNode next;ListNode(int x) : data(x), next(nullptr) {}};ListNode createList() {ListNode head = nullptr, tail = nullptr;int data;cout << "请输入链表数据（输入-1结束）：" << endl; while (cin >> data && data != -1) {ListNode node = new ListNode(data);if (head == nullptr) {head = node;tail = node;} else {tail->next = node;tail = node;}}return head;}```2. 插入节点```cppvoid insertNode(ListNode head, int data, int position) { ListNode node = new ListNode(data);if (position == 0) {node->next = head;head = node;} else {ListNode current = head;for (int i = 0; i < position - 1; ++i) {if (current == nullptr) {cout << "插入位置超出链表长度！" << endl; return;}current = current->next;}node->next = current->next;current->next = node;}}```3. 删除节点```cppvoid deleteNode(ListNode head, int position) {if (head == nullptr) {cout << "链表为空！" << endl;return;}if (position == 0) {ListNode temp = head;head = head->next;delete temp;} else {ListNode current = head;for (int i = 0; i < position - 1; ++i) {if (current == nullptr) {cout << "删除位置超出链表长度！" << endl; return;}current = current->next;}if (current->next == nullptr) {cout << "删除位置超出链表长度！" << endl;return;}ListNode temp = current->next;current->next = temp->next;delete temp;}}```4. 查找节点```cppListNode findNode(ListNode head, int data) { ListNode current = head;while (current != nullptr) {if (current->data == data) {return current;}current = current->next;}return nullptr;}```5. 打印链表```cppvoid printList(ListNode head) {ListNode current = head;while (current != nullptr) {cout << current->data << " ";current = current->next;}cout << endl;}```六、实验结果与分析通过以上步骤，成功实现了链表的基本操作。
数据结构单链表实验报告
数据结构单链表实验报告实验目的：掌握单链表的基本操作，学会使用单链表实现各种算法。
实验内容：实现单链表的基本操作，包括创建、插入、删除、访问等。
利用单链表完成以下算法：- 单链表逆序- 查找单链表中的中间节点- 删除单链表中的倒数第K个节点- 合并两个有序单链表为一个有序单链表实验步骤：1. 创建单链表在创建单链表时，先定义一个结构体Node来表示链表中的节点，节点包括数据域和指针域，指针域指向下一个节点。
然后，用指针p指向链表的头节点，将头节点的指针域初始化为NULL。
2. 插入节点在单链表中插入节点的操作分为两种情况：- 在链表头插入节点- 在链表中间或尾部插入节点无论是哪种情况，先将新节点的指针域指向要插入的位置的下一个节点，再将要插入的位置的指针域指向新节点即可。
3. 删除节点删除链表节点的操作同样分为两种情况：- 删除头节点- 删除中间或尾部节点要删除头节点，先用一个指针将头节点指向的下一个节点保存起来，再将头节点释放掉。
要删除中间或尾部节点，先用一个指针指向要删除节点的前一个节点，然后将指向要删除节点的前一个节点的指针域指向要删除节点的下一个节点，最后将要删除的节点释放掉。
4. 单链表逆序单链表逆序可以使用三个指针来完成，分别为pre指针、cur指针和next指针。
首先将pre指针和cur指针指向NULL，然后循环遍历链表，将cur指针指向当前节点，将next指针指向当前节点的下一个节点，然后将当前节点的指针域指向pre指针，最后将pre指针和cur指针向前移动一个节点，继续进行循环。
5. 查找单链表中的中间节点查找单链表中的中间节点可以使用双指针法，将两个指针p1和p2都指向链表头，然后p1每次向前移动一个节点，而p2每次向前移动两个节点，当p2指向了链表尾部时，p1指向的节点即为中间节点。
6. 删除单链表中的倒数第K个节点删除单链表中的倒数第K个节点可以使用双指针法，在链表中定义两个指针p1和p2，p1指向链表头，p2指向第K个节点，然后p1和p2同时向前移动，直到p2指向链表尾部，此时p1指向的节点即为要删除的节点。
c语言链表实验报告
c语言链表实验报告C语言链表实验报告引言：链表是一种常见的数据结构，它在计算机科学中有着广泛的应用。
通过链表，我们可以动态地存储和操作数据，实现各种复杂的算法和数据结构。
本实验旨在通过使用C语言，实现一个简单的链表结构，并演示其基本操作和应用。
一、链表的定义和基本概念链表是由一系列节点组成的数据结构，每个节点包含数据和指向下一个节点的指针。
相比于数组，链表具有动态性，可以根据需要动态地分配和释放内存空间。
链表的基本概念包括头节点、尾节点、节点插入和节点删除等。
二、链表的实现1. 定义节点结构体在C语言中，我们可以通过定义结构体来表示链表的节点。
结构体中包含一个数据成员和一个指向下一个节点的指针成员。
2. 创建链表为了创建一个链表，我们首先需要定义一个头节点，并将其指针指向NULL。
然后，通过动态分配内存，创建其他节点，并将它们按照一定的顺序链接起来。
3. 插入节点链表的插入操作可以在链表的任意位置进行。
我们可以在头节点之后或者指定节点之后插入新的节点。
插入操作的关键是修改指针的指向，使得新节点能够正确地链接到链表中。
4. 删除节点链表的删除操作可以删除链表中的任意节点。
删除操作的关键是修改指针的指向，使得被删除节点的前一个节点和后一个节点能够正确地链接起来，并释放被删除节点的内存空间。
三、链表的应用链表作为一种常见的数据结构，有着广泛的应用。
以下是链表的一些常见应用场景：1. 队列和栈链表可以用来实现队列和栈这两种常见的数据结构。
通过在链表的头部或尾部进行插入和删除操作，可以实现队列和栈的基本功能。
2. 图的表示在图的表示中，链表可以用来表示图的邻接表。
每个顶点对应一个链表，链表中存储该顶点的邻接点。
通过链表的插入和删除操作，可以方便地修改图的结构。
3. 文件系统在文件系统中，链表可以用来表示文件的目录结构。
每个目录对应一个链表，链表中存储该目录下的文件和子目录。
通过链表的插入和删除操作，可以方便地管理文件和目录。
链表实验报告1
1、熟练掌握线性表的基本操作在两种存储结构上的实现。
2、会用线性链表解决简单的实际问题。
该程序的功能是实现单链表的定义和操作。
该程序包括单链表结构类型以及对单链表操作的具体的函数定义和主函数。
其中，程序中的单链表(带头结点)结点为结构类型，结点值为整型。
单链表操作的选择以菜单形式浮现，如下所示：please input the operation：1.初始化2.清空3.求链表长度4.检查链表是否为空5.检查链表是否为满 6.遍历链表(设为输出元素) 7.从链表中查找元素 8.从链表中查找与给定元素值相同的元素在表中的位置9.向链表中插入元素 10. 从链表中删除元素其他键退出。
设编号为 1，2，3，……， n 的 n(n>0)个人按顺时针方向围坐一圈，每一个人持有一个正整数密码。
开始时任选一个正整数做为报数上限 m，从第一个人开始顺时针方向自 1 起顺序报数，报到 m 时住手报数，报 m 的人出列，将他的密码作为新的m 值，从他的下一个人开始重新从 1 报数。
如此下去，直到所有人全部出列为止。
令n 最大值取 30。
要求设计一个程序摹拟此过程，求出出列编号序列。
struct node //结点结构{int number; /* 人的序号*/int cipher; /* 密码*/struct node *next; /* 指向下一个节点的指针*/};/* 定义 DataType 为 int 类型 */typedef int DataType;/* 单链表的结点类型 */typedef struct LNode{ DataType data;struct LNode *next;}LNode,*LinkedList;LinkedList LinkedListInit(){ //函数功能：对链表进行初始化参数：链表(linklist L) 成功初始化返回 1, 否则返回 0 }void LinkedListClear(LinkedList &L){//函数功能：把链表清空参数：链表(linklist L) 成功清空链表返回 1 }int LinkedListEmpty(LinkedList L){ //函数功能:判断链表是否为空参数：链表(linklist L) 链表为空时返回 0, 不为空返回 1 }void LinkedListTraverse(LinkedList L){ //函数功能:遍历链表,输出每一个节点的 elem 值参数：链表(linklist L) 通过循环逐个输出节点的 elem 值 }int LinkedListLength(LinkedList L){ //函数功能:返回链表的长度参数：链表(linklistL) 函数返回链表的长度 }LinkedList LinkedListGet(LinkedList L,int i){ //函数功能: 从链表中查找有无给定元素参数;链表(linklist L),给定元素 (int i) 如果链表中有给定元素(i)则返回 1,否则返回 0 }LinkedList LinkedListLocate(LinkedList L, DataType x){//函数功能: 从链表中查找给定元素的位置参数;链表(linklist L),给定元素(int i) 如果链表中有给定元素 i 则返回元素的位置, 没有则返回 0 }void LinkedListInsert(LinkedList &L,int i,DataType x)}void LinkedListDel(LinkedList &L,DataType x)i 个结点 }(二)、zhujiemian();cin>>a;do{switch(a){case 1:if(init(L)==1)cout<<"成功初始化！ "<<endl;elsecout<<"初始化失败！ "<<endl;break;case 2:if(makeempty(L)==1)cout<<"链表已清空！ "<<endl;elsecout<<"链表清空失败！ "<<endl;break;case 3:b=getlength(L);cout<<"链表的长度为： "<<b<<endl;break;case 4:if(isempty(L)==1)cout<<"链表不为空！ "<<endl;elsecout<<"链表为空！ "<<endl;break;case 5:if(isfull(L)==1)cout<<"链表不满！ "<<endl;elsecout<<"链表已满！ "<<endl;break;case 6:show(L);break;case 7:cout<<"输入您要查找的元素： ";cin>>b;if(find(L,b)==1)cout<<"链表中有该元素"<<b<<endl;elsecout<<"链表中没有您要查找的元素"<<b<<endl;break;case 8:cout<<"您要查找的元素为： "<<endl;cin>>b;if(location(L,b)==0)cout<<"没有您要查找的元素"<<b<<endl;elsecout<<"您查找的元素 "<<b<<"在第"<<location(L,b)<<"个位置。
链表实验报告
链表实验报告一、实验目的链表是一种常见的数据结构，本次实验的主要目的是深入理解链表的概念、原理和操作，通过实际编程实现链表的创建、插入、删除、遍历等基本操作，掌握链表在数据存储和处理中的应用，提高对数据结构的理解和编程能力。
二、实验环境本次实验使用的编程语言为 C 语言，开发工具为 Visual Studio Code。
三、实验原理链表是一种动态的数据结构，它由一系列节点组成，每个节点包含数据和指向下一个节点的指针。
链表的优点是可以灵活地进行插入和删除操作，不需要像数组那样移动大量的数据。
链表分为单向链表、双向链表和循环链表等。
单向链表只有一个指向下一个节点的指针，双向链表有指向前一个节点和后一个节点的指针，循环链表的尾节点指向头节点，形成一个环形结构。
四、实验步骤1、单向链表的创建定义链表节点结构体，包含数据域和指针域。
编写创建链表的函数，通过动态分配内存创建链表节点，并将节点连接起来。
2、单向链表的插入操作实现头部插入、尾部插入和中间插入的函数。
在插入时，需要处理指针的更新，确保链表的连接正确。
3、单向链表的删除操作编写删除指定节点的函数。
删除节点时，要释放被删除节点的内存，并更新相邻节点的指针。
4、单向链表的遍历实现遍历链表并打印节点数据的函数。
5、双向链表的创建与操作类似于单向链表，定义双向链表节点结构体，并实现创建、插入、删除和遍历的函数。
注意双向链表中指针的更新方式与单向链表的不同。
6、循环链表的创建与操作定义循环链表节点结构体，创建循环链表。
实现循环链表的插入、删除和遍历操作，处理好尾节点与头节点的连接。
五、实验结果与分析1、单向链表成功创建了单向链表，并能够正确进行头部、尾部和中间的插入操作。
删除操作也能准确删除指定节点，并释放内存。
遍历输出的结果与预期相符。
2、双向链表双向链表的创建和各种操作都能正常执行，指针的更新没有出现错误。
在双向链表中，插入和删除操作的效率相对单向链表有所提高，因为可以直接通过前向指针进行操作。
实验一 链表操作实验报告
实验内容按实验内容与步骤阅读理解数据结构及主函数，并完成各子函数的功能。
#include <stdio.h>#include <stdlib.h>typedef struct node{int num; //学号float height; //身高struct node *next;}Node,*Link;Link CreateLink();//创建链表Link Delete(Link H,int n); //删除节点Node *GetNode(Link H,int n);//获取节点Link Insert(Link H,Node *N);//插入节点int print(Link H);//输出/* 创建链表 */Link CreateLink(){Link H=NULL;Node *p,*q;int num=-1;//保存学号float hei=-1.0;//保存身高int min=1;//计数，至少插入3个节点printf("请输入学号:num=");scanf("%d",&num);fflush(stdin);//清空输入缓冲区，确保不影响后面的数据读取printf("请输入身高:hei=");scanf("%f",&hei);printf("\n");fflush(stdin);//清空输入缓冲区，确保不影响后面的数据读取while(num!=-1 || min<=3){if(H==NULL){p=(Node *)malloc(sizeof(Node));p->num=num;p->height=hei;p->next=NULL;min++; //计数加一H=p;}else{q=(Node *)malloc(sizeof(Node));q->num=num;q->height=hei;q->next=NULL;min++;p->next=q;p=p->next;}lab1: printf("请输入学号:num=");scanf("%d",&num);fflush(stdin);if(num==-1 && min<=3){printf("\n请至少输入3个节点\n\n");goto lab1; //跳到 lab1}if(num==-1 && min>3) //退出输入break;printf("请输入身高:hei=");scanf("%f",&hei);printf("\n");fflush(stdin);}return H;}/* 删除节点 *//* 参数 H 为表头节点 */ /* 参数 n 为删除第几个节点 */ Link Delete(Link H,int n){int i=1;Node *p,*q;if(n==1) //删除的是第一个节点{H=H->next;return H;}p=H;while(p!=NULL){if(i==(n-1)) //删除节点的前一个节点break;p=p->next;i++;}if(i==(n-1))//存在n-1个节点{q=p->next;p->next=q->next;free(q); //释放q节点}else{printf("不存在第%d个节点!\n",n);}return H;}/* 获取节点 *//* 参数 H 为表头节点 */ /* 参数 n 为第几个节点 */ Node *GetNode(Link H,int n){int i=1;Node *p,*q;p=H;q=H;if(n==1) //取的是第一个节点{p=p->next;return p;}while(p!=NULL){if(i==(n-1))//删除节点的前一个节点break;p=p->next;i++;}if(i==(n-1))//存在n-1个节点{q=p->next;p->next=q->next;return q;}else{printf("不存在第%d个节点!\n",n);return NULL;}}/* 输出 *//* 参数 H 为表头节点 */ /* 参数 N 为插入的节点节点 */Link Insert(Link H,Node *N){Node *p,*q; //q保存前一个节点if(N->num < H->num) //插入在表头之前{N->next=H;H=N;return H;}p=H;q=H;while(p!=NULL){if(N->num<=p->num){N->next=q->next;q->next=N;break;}q=p;p=p->next;}if(p==NULL) //插入在最后一个节点之后{q->next=N;N->next=NULL;}return H;}/* 输出 *//* 参数 H 为表头节点 */ int print(Link H){Node *p;p=H;if(p==NULL){printf("\n数据为空!!\n\n");return 0;}printf("\n\t学号\t\t身高\n");while(p){printf("\t %d \t\t%f\n",p->num,p->height);p=p->next;}return 0;}void main(){Link L1,L2;Node *N;printf("1：创建2个链表\n");printf("\n创建链表一\n\n");L1=CreateLink();printf("\n创建链表二\n\n");L2=CreateLink();printf("\n\n2：遍历2个链表\n");printf("\n遍历链表一:\n");print(L1);printf("\n遍历链表二:\n");print(L2);printf("\n\n3：删除第一个链表中的第二个节点 \n\n");L1=Delete(L1,2);printf("删除后的链表一:\n");print(L1);printf("\n\n 4：将第一个链表中的第二个结点移动到第二个链表适当的位置\n\n");printf("获取链表一的第二个节点...\n");N=GetNode(L1,2);printf("将链表一的第二个结点移动到链表二适当的位置");if(N!=NULL)L2=Insert(L2,N);printf("移动后的链表一\n");print(L1);printf("移动后的链表二\n");print(L2);}完成情况：（本部分详细描述运行结果情况，1）完成实验内容的要求；2）展示运行的结果。
创建链表和链表操作实验报告
创建链表和链表操作实验报告数据结构实验报告报告名称创建链表和链表操作专业网络工程班级1001 学号20XX03120XX9 姓名张剑指导教师陈淑红李珍辉黄哲20XX年5月4 日、实验目的：掌握线性表的基本操作：插删除、查找以及线性表入、合并等运算在顺序存储结构和链接存储结构上的运算。
二、实验内容与基本要求：实验内容：1. 创建单链表2. 在链表上进行插入、删除操作；3 .设计一个程序，用两个单链表分别表示两个集合，并求出这两个集合的并集。
实验要求：1. 在上机前写出全部源程序； 2 .能在机器上正确运行程序；3 .用户界面友好；三、概要设计：1.单链表的存储结构：teypedef structLNode{ ElemType date;struct LNond *next; }LNode *LinkList;2. 单链表的插入操作：Status ListTnsert-L(LinkLIst &L, int i, ElemType e ){//再带头结点的单链线性表L中的第i个位置之前插入元素 e P=l; j=0;While(p&&jnext;++j;}//寻找第i-1个结点if(!p||j>i-1) return ERROR; //i 小小于1 或者大于表长+1 s=(LinkList) malloc (sizeof(LNode)); //生成新结点s->date=e; s->next=p->next; // 插入L 中p->next=s; return ok;}//ListTnsert L3. 单链表的删除操作：Status ListDelete-L(LinkLlst &L, int i, ElemType &e ){//在带头结点单链线性表L中，删除低i个元素，并e返回其值p=l; j=0;while(p->next&&jnext; ++j; }if(!(p->next)||j>i-1)return ERROR; // 删除位置不合理q=p->n ext ; p->n ext=q->n ext; //删除并释放结点e=q->date free(q); return OK;} //ListDelete-L4. 链表的合并操作：void MergeList-L(LinkList & La, LinkList & Lb, LinkList &Lc){ // 已知单链表La和Lb的元素值//合并单链表La和Lb，得到新的单链表Lc pa=La->next; pb=Lb->next;lc=pc=La; //用La的头结点作为Lc的头结点while(pa&&pb){ if(pa->datedate){pc->n ext =pa; pc=pa; pa=pa->n ext; }else {pc->n ext=pb;pc=pb;pb=pb->n ext;} }Pc->next=pa pa:pb; // 插入剩余段free(Lb); // 释放Lb头结点} //MergeList-L 四、详细设计：#include #include #include #include typedefint status;typedef char ElemType; typedef struct Lnode {ElemType data;//定义链表结点类型 struct Lnode *next; }Lnode,*Linklist;status initlist(Linklist *L) {// 单链表的初始化 *L=(Lnode *)malloc(sizeof(Lnode)); //创建头结点(*L)->next=NULL;return 1;}status Createlist(Linklist L) { Lnode *p,*q;int i,j=1,n;ElemType m,M; q=L;请输入你要输入单链中元素的个数\\n\{p=(Lnode *)malloc(sizeof(Lnode)); 请输入％个元素:\scanf(\p->n ext=q->n ext;j++;} return 1;}status Listinsert(Linklist { int j=0;输入错误!\\n\ returnscanf(\ scanf(\for(i=n;i>0;i--)scanf(\ p->data=M; q->n ext=p;q=p;L,int i,ElemType e)++j; }Lnode *p=L,*s; while(p&&jnext;。
链表的基本操作实验报告
链表的基本操作实验报告链表的基本操作实验报告引言：链表是一种常见的数据结构，它由一系列节点组成，每个节点包含数据和指向下一个节点的指针。
链表相较于数组拥有更灵活的操作，能够动态地增删节点。
本实验旨在通过实际操作链表，加深对链表基本操作的理解和掌握。
实验目的：1. 理解链表的基本概念和结构；2. 学会链表的插入、删除和遍历操作；3. 掌握链表的相关算法。
实验过程：1. 创建链表首先，我们需要创建一个链表。
链表可以是单链表、双链表或循环链表，本次实验我们选择创建一个单链表。
创建链表的过程如下：（1）定义一个链表的节点结构，包含数据和指向下一个节点的指针；（2）创建头节点，并将头节点的指针指向NULL，表示链表为空。
2. 插入节点链表的插入操作可以在链表的任意位置插入节点。
我们可以选择在链表的头部、尾部或指定位置插入节点。
下面以在链表头部插入节点为例，介绍插入节点的过程：（1）创建一个新节点，设置新节点的数据；（2）将新节点的指针指向原头节点；（3）将头节点的指针指向新节点，完成插入操作。
3. 删除节点链表的删除操作可以删除链表中的任意节点。
同样，我们可以选择删除链表的头部、尾部或指定位置的节点。
以下是删除链表头部节点的步骤：（1）将头节点的指针指向下一个节点，跳过原头节点；（2）释放原头节点的内存空间。
4. 遍历链表链表的遍历操作用于访问链表中的每个节点。
通过遍历链表，我们可以获取链表中的所有数据或执行特定的操作。
链表的遍历操作如下：（1）从链表的头节点开始，依次访问每个节点；（2）对每个节点执行相应的操作，如打印节点的数据。
实验结果：通过以上实验过程，我们成功地创建了一个链表，并实现了链表的插入、删除和遍历操作。
链表的基本操作能够灵活地处理数据，适用于各种场景。
链表的插入和删除操作可以在O(1)时间内完成，相较于数组的插入和删除操作具有更高的效率。
实验总结：链表作为一种常见的数据结构，具有灵活性和高效性的特点。
链表基本操作实验报告
链表基本操作实验报告#include#include#define TRUE 1#define FALSE 0#define OK 1#define ERROR 0#define OVERFLOW -1typedef int ElemType ;typedef int Status ;typedef struct LNode {ElemType data ;struct LNode *next ;} *Link,*Position ;typedef struct {Link head,tail;int len;} LinkList;Status InitList ( LinkList &L ){L.head=L.tail=new LNode;L.head->next=L.tail->next=NULL;if(!L.head||!L.tail)return OVERFLOW;L.len=0;return OK;}Status MakeNode(Link &p,ElemType e) { p=new LNode;if(!p)return ERROR;p->data=e;return OK;}void FreeNode(Link &p){delete p;p=NULL;}Status ClearList(LinkList &L) { Link p,q;if(L.head!=L.tail){p=q=L.head->next;L.head->next=NULL;while(p!=L.tail){p=q->next;delete q;q=p;}delete q;L.tail=L.head;L.len=0;}return OK;}Status DestroyList(LinkList &L) { ClearList(L);FreeNode(L.head);L.tail=NULL;L.len=0;return OK;}Status ListEmpty(LinkList L) {if(L.head==NULL)return OVERFLOW; if(L.len)return FALSE;elsereturn TRUE;}int ListLength(LinkList L){return L.len;}Position GetHead(LinkList L){return L.head;}Position GetLast(LinkList L){return L.tail;}Status InsFirst(LinkList &L,Link h,Link s) { h->next=s;s->next=h->next;if(h==L.tail)L.tail=h->next;L.len+=1;return OK;}Status DelFirst(LinkList &L,Link h,Link &q) { q=h->next;h->next=q->next;if(!q)L.tail=h;L.len-=1;return OK;}Status Append(LinkList &L,Link s){Link h;h=L.head;while(h->next!=L.tail)h=h->next;while(s->next!=NULL){h=s;s=s->next;h=h->next;L.len+=1;}s->next=L.tail;L.tail=NULL;return OK;}Status Remove(LinkList &L,Link &q) {Link h;if(ListEmpty(L)==0){q=NULL;return FALSE;}q=L.head;while(q->next!=L.tail)q=q->next;h=q;q=q->next;L.len-=1;return OK;}Position PriorPos(LinkList L,Link p) {Link q=L.head;if(p==q)return NULL;while(q->next!=L.tail){if(q->next==p)return q;q=q->next;}return q;}Status InsBefore(LinkList &L,Link &p,Link s) {Link q;q=PriorPos( L, p);if(!q)q=L.head;q->next=s;s->next=p;p=s;L.len+=1;return OK;}Status LocatePos(LinkList L,int i,Link &p){int j;if(i<=0||i>L.len)return ERROR;else{p=L.head;for(j=1;j<=i;j++)p=p->next;return OK;}}Status compare(ElemType c1,ElemType c2){if(c1==c2)return TRUE;elsereturn FALSE;}Position LocateElem(LinkList L,ElemType e,Status (*compare)(ElemType c1,ElemType c2)) //important{Link p=L.head;while(p!=L.tail){p=p->next;if(compare(e,p->data) )return p;}return FALSE;}int main(){LinkList L;Link p,h,q;int n,j;ElemType e,f;InitList (L);cout<<"请输入项数"<<endl;< bdsfid="292" p=""></endl;<> cin>>n;cout<<"请输入数据"<<endl;< bdsfid="295" p=""></endl;<> for(int i=0;i<n;i++)< bdsfid="297" p=""></n;i++)<>{cin>>e;MakeNode(p, e);InsFirst(L,L.tail,p);}cout<<"输入后的线性表的长度:"<<listlength(l)<<endl;< bdsfid="304" p=""></listlength(l)<<endl;<>DelFirst(L, L.head,q);cout<<"删除数据为:"<<endl;< bdsfid="307" p=""></endl;<> cout<data<<endl;< bdsfid="310" p=""></endl;<>cout<<"删除后的线性表的长度:"<<listlength(l)<<endl;<bdsfid="312" p=""></listlength(l)<<endl;<>cout<<"请输入要查找数据位序"<<endl;< bdsfid="314" p=""></endl;<>cin>>j;LocatePos( L,j,p);cout<data<<endl;< bdsfid="319" p=""></endl;<>cout<<"请输入要查找数据"<<endl;< bdsfid="321" p=""></endl;<>cin>>f;h=LocateElem(L,f,compare); //重要cout<data<<endl;< bdsfid="326" p=""></endl;<>ClearList(L);return 0;}。
C语言链表实验报告
链表实验报告一、实验名称链表操作的实现--学生信息库的构建二、实验目的（1）理解单链表的存储结构及基本操作的定义（2）掌握单链表存储基本操作（3）学会设计实验数据验证程序【实验仪器及环境】计算机 Window XP操作系统三、实验内容1、建立一个学生成绩信息（学号，姓名，成绩）的单链表，按学号排序2、对链表进行插入、删除、遍历、修改操作。
3、对链表进行读取（读文件）、存储（写文件）四、实验要求（1）给出终结报告（包括设计过程，程序）-打印版（2）对程序进行答辩五、实验过程、详细内容1、概念及过程中需要调用的函数（1）链表的概念结点定义结构的递归定义struct stud_node{int num;char name[20];int score;struct stud_node *next;};（2）链表的建立1、手动输入struct stud_node*Create_Stu_Doc(){struct stud_node *head,*p;int num,score;char name[20];int size=sizeof(struct stud_node);【链表建立流程图】2、从文件中直接获取 先建立一个(3)链表的遍历（4（5）删除结点（6）动态储存分配函数malloc （） void *malloc(unsigned size)①在内存的动态存储区中分配一连续空间，其长度为size②若申请成功，则返回一个指向所分配内存空间的起始地址的指针 ③若申请不成功，则返回NULL （值为0） ④返回值类型：(void *) ·通用指针的一个重要用途·将malloc 的返回值转换到特定指针类型，赋给一个指针【链表建立流程图】ptrptrptr->numptr->score ptr=ptr->nexthead pt rs s->next = ptr->next ptr->next = s 先连后断 ptr2=ptr1->nextptr1->next=ptr2->nextfree （ptr2）（7）动态储存释放函数free（）当某个动态分配的存储块不再用时，要及时将它释放void free(void *ptr)释放由动态存储分配函数申请到的整块内存空间，ptr为指向要释放空间的首地址。
链表实验报告
C语言实验报告实验目的：链表的基本操作添加，删除，排序#include <iostream.h>#include <string.h>#include <stdlib.h>struct StuNode{char ID[10];char Name[10];int Height;StuNode *next;};typedef StuNode stulist;void Addafter (stulist * list,char * id,char * name,int height){if(!list||!id) return;StuNode *p=new StuNode;strcpy(p->ID,id);strcpy(p->Name,name);p->Height=height;StuNode *q=list;while(q->next){q=q->next;}q->next=p;p->next=NULL;}void ShowNode(stulist * list){cout<<"现有数据是："<<endl;StuNode *p=list->next;while(p){cout<<p->ID<<" "<<p->Name<<" "<<p->Height<<endl;p=p->next;}cout<<endl<<"*************************************"<<endl; }void Insert (stulist * list){char Beid[10]="2014002";char id[10]="1112223";char name[10]="狗蛋";int height=177;if(!list||!id) return;StuNode *p=new StuNode;strcpy(p->ID,id);strcpy(p->Name,name);p->Height=height;StuNode *q=list;while(strcmp(q->ID,Beid)!=0){q=q->next;}p->next=q->next;q->next=p;}void Delete(stulist * list){char id[10]="2014001";StuNode *q=list;StuNode *d=q->next;while(strcmp(d->ID,id)!=0){q=q->next;d=d->next;}q->next=d->next;delete d;}void main(){stulist list_1;list_1.next=NULL;char name[10],id[10];int height;Addafter(&list_1,"2014001","张三",175);Addafter(&list_1,"2014002","李四",180);Addafter(&list_1,"2014003","王二",173);Addafter(&list_1,"2014004","麻子",179);ShowNode(&list_1);cout<<"现在添加马六"<<endl;Addafter(&list_1,"2014999","马六",180);ShowNode(&list_1);cout<<"现在把狗蛋插入到李四后面"<<endl;Insert(&list_1);ShowNode(&list_1);cout<<"现在删除张三"<<endl;Delete(&list_1);ShowNode(&list_1);}实验总结：通过学习链表的操作，让知道了C语言和C++是有着紧密联系的，让我能更加熟练了数组，指针，结构体等一些基本的c++语言知识，而且知道了怎么添加修改和排序的一些方法。
链表的基本操作数据结构实验报告记录
链表的基本操作数据结构实验报告记录————————————————————————————————作者：————————————————————————————————日期：大学数据结构实验报告课程名称数据结构实验第（四）次实验实验名称链表的基本操作学生姓名于歌专业班级学号实验成绩指导老师（签名）日期2018年10月01日一、实验目的1. 学会定义单链表的结点类型，实现对单链表的一些基本操作和具体的函数定义，了解并掌握单链表的类定义以及成员函数的定义与调用。
2. 掌握单链表基本操作及两个有序表归并、单链表逆置等操作的实现。
二、实验要求1．预习C语言中结构体的定义与基本操作方法。
2．对单链表的每个基本操作用单独的函数实现。
3．编写完整程序完成下面的实验内容并上机运行。
4．整理并上交实验报告。
三、实验内容：1．编写程序完成单链表的下列基本操作：（1）初始化单链表La（2）在La中插入一个新结点（3）删除La中的某一个结点（4）在La中查找某结点并返回其位置（5）打印输出La中的结点元素值（6）清空链表（7）销毁链表2 .构造两个带有表头结点的有序单链表La、Lb，编写程序实现将La、Lb合并成一个有序单链表Lc。
四、思考与提高：1．如果上面实验内容2中合并的表内不允许有重复的数据该如何操作？2．如何将一个带头结点的单链表La分解成两个同样结构的单链表Lb，Lc，使得Lb中只含La表中奇数结点，Lc中含有La表的偶数结点？五、实验设计1．编写程序完成单链表的下列基本操作：（1）初始化单链表LaLinkList InitList(){int i,value,n;LinkList H=(LinkList)malloc(sizeof(LNode));LinkList P=H;P->next=NULL;do{printf("请输入链表的长度:");scanf("%d",&n);if(n<=0)printf("输入有误请重新输入！\n");}while(n<=0);printf("请输入各个元素:\n");for(i=0; i<n; i++){scanf("%d",&value);LinkList NEW = (LinkList)malloc(sizeof(LNode)); NEW->data=value;P->next=NEW;NEW->next=NULL;P=NEW;}printf("链表建立成功！\n");return H->next;}（2）在La中插入一个新结点LinkList InsertList(LinkList L,int i,ElemType value) {LinkList h,q,t=NewLNode(t,value);int x=0;h=q=L;if(i==1)t->next=h, h=t;else{while(x++<i-2)q=q->next;t->next=q->next;q->next=t;}printf("插入成功！\n");return h;}（3）删除La中的某一个结点LinkList DeleteList(LinkList L,int i){LinkList h,q,de;int x=0;h=q=L;int t;if(i==1)h=h->next;else{while(x++<i-2)q=q->next;de=q->next;if(de->next==NULL)q->next=NULL;elseq->next=de->next;}printf("删除成功！\n");return h;}（4）在La中查找某结点并返回其位置Status LocateList(LinkList L,ElemType value){LinkList q=L;int i=0,t;while(q!=NULL){i++;if(q->data==value){printf("该结点在链表中的位置为第%d个\n",i); return OK;}q=q->next;}printf("该链表中没有该结点！\n");return ERROR;}（5）打印输出La中的结点元素值Status Print(LinkList L){LinkList q=L;printf("该链表的每个元素为:\n");while(q!=NULL){printf("%8d",q->data);q=q->next;}printf("\n");return OK;}（6）清空链表LinkList EmptyList(LinkList L){free(L->data);L->next=NULL;printf("清空成功！\n");return L;}（7）销毁链表LinkList FreeList(LinkList L){printf("释放成功！\n");free(L);}（8）主函数int main(){LinkList L=InitList();int n,i,j;Pr();scanf("%d",&n);while(n>0&&n<7){switch(n){case 1:printf("请输入要插入的结点的值和插入的位置:"); scanf("%d %d",&i,&j);InsertList(L,j,i);break;case 2:printf("请输入要删除的结点的位置:");scanf("%d",&i);DeleteList(L,i);break;case 3:printf("请输入要查找的结点的值:");scanf("%d",&i);LocateList(L,i);break;case 4:Print(L);break;case 5:EmptyList(L);break;case 6:FreeList(L);break;}Pr();scanf("%d",&n);}if(n==7)printf("退出成功！");return 0;}2．构造两个带有表头结点的有序单链表La、Lb，编写程序实现将La、Lb合并成一个有序单链表LcLinkList ConnectList(LinkList La,LinkList Lb){LinkList Lc,a,b,c;a=La;b=Lb;if(La->data<Lb->data)Lc=La,a=a->next;elseLc=Lb,b=b->next;c=Lc;while(a!=NULL||b!=NULL){if(a==NULL)c->next=b,break;if(b==NULL)c->next=a;break;if(a->data<b->data)c->next=a,a=a->next,c=c->next;elsec->next=b,b=b->next,c=c->next;return Lc;}3．如果上面实验内容2中合并的表内不允许有重复的数据该如何操作LinkList ConnectList(LinkList La,LinkList Lb){int i=1;LinkList Lc,a,b,c,q,p;a=La;b=Lb;if(La->data<Lb->data)Lc=La;a=a->next;elseLc=Lb;b=b->next;c=Lc;while(a!=NULL||b!=NULL){if(a==NULL)c->next=b，break;if(b==NULL)c->next=a，break;if(a->data<b->data)c->next=a，a=a->next，c=c->next;elsec->next=b，b=b->next，c=c->next;}c=Lc;q=c->next;while(q!=NULL){if(c->data==q->data){c->next=q->next;}c=c->next;q=c->next;}return Lc;}4．如何将一个带头结点的单链表La分解成两个同样结构的单链表Lb，Lc，使得Lb中只含La表中奇数结点，Lc中含有La表的偶数结点？Status PartList(LinkList Lc){int n1=0,n2=0;LinkList La,Lb,L;LinkList a,b;L=Lc;while(L!=NULL){if(L->data%2==0){if(n1==0){a=La=L;L=L->next;}else{a->next=L;L=L->next;}}else{if(n2==0){b=Lb=L;L=L->next;}else{b->next=L;L=L->next;}}}a->next=NULL;b->next=NULL;return OK;}六、实验测试1．编写程序完成单链表的下列基本操作：七、总结附录1：源代码#include<stdio.h>#include<stdlib.h>#define OK 1#define ERROR 0#define OVERFLOW -2typedef int ElemType;typedef int Status;typedef struct LNode{ElemType data;struct LNode *next;} LNode,*LinkList;LinkList NewLNode(LNode *P,ElemType data){P = (LNode *)malloc(sizeof(LNode));P->data = data;P->next = NULL;return P;}LinkList InitList(){int i,value,n;LinkList H=(LinkList)malloc(sizeof(LNode));LinkList P=H;P->next=NULL;do{printf("请输入链表的长度:");scanf("%d",&n);if(n<=0)printf("输入有误请重新输入！\n");}while(n<=0);printf("请输入各个元素:\n");for(i=0; i<n; i++){scanf("%d",&value);LinkList NEW = (LinkList)malloc(sizeof(LNode)); NEW->data=value;P->next=NEW;NEW->next=NULL;P=NEW;}printf("链表建立成功！\n");return H->next;}LinkList InsertList(LinkList L,int i,ElemType value) {LinkList h,q,t=NewLNode(t,value);int x=0;h=q=L;if(i==1){t->next=h;h=t;}else{while(x++<i-2)q=q->next;t->next=q->next;q->next=t;}printf("插入成功！\n");return h;}LinkList DeleteList(LinkList L,int i){LinkList h,q,de;int x=0;h=q=L;int t;if(i==1)h=h->next;else{while(x++<i-2)q=q->next;de=q->next;if(de->next==NULL)q->next=NULL;elseq->next=de->next;}printf("删除成功！\n");return h;}Status LocateList(LinkList L,ElemType value){LinkList q=L;int i=0,t;while(q!=NULL){i++;if(q->data==value){printf("该结点在链表中的位置为第%d个\n",i); return OK;}q=q->next;}printf("该链表中没有该结点！\n");return ERROR;}Status Print(LinkList L){LinkList q=L;printf("该链表的每个元素为:\n");while(q!=NULL){printf("%8d",q->data);q=q->next;}printf("\n");return OK;}LinkList EmptyList(LinkList L){free(L->data);L->next=NULL;printf("清空成功！\n");return L;}LinkList FreeList(LinkList L){printf("释放成功！\n");free(L);}void Pr(){printf("\n1.插入新结点\n");printf("2.删除链表中的结点\n");printf("3.查找结点\n");printf("4.输出链表\n");printf("5.清空链表\n");printf("6.销毁链表\n");printf("7.退出\n");printf("请输入要使用的功能:");}int main(){LinkList L=InitList();int n,i,j;Pr();scanf("%d",&n);while(n>0&&n<7){switch(n){case 1:printf("请输入要插入的结点的值和插入的位置:"); scanf("%d %d",&i,&j);InsertList(L,j,i);break;case 2:printf("请输入要删除的结点的位置:");scanf("%d",&i);DeleteList(L,i);break;case 3:printf("请输入要查找的结点的值:");scanf("%d",&i);LocateList(L,i);break;case 4:Print(L);break;case 5:EmptyList(L);break;case 6:FreeList(L);break;}Pr();scanf("%d",&n);}if(n==7)printf("退出成功！"); return 0;}。
双向链表的基本操作和应用实验报告
双向链表的基本操作和应用一、实验目的：1.掌握双向线性表的逻辑特征2.熟练掌握带头结点的双向链式表的指针操作、能完成双向链表的插入、删除、获取指定位序结点指针、遍历、和复杂应用；二、实验内容（双向链式线性表）1.熟悉Visual Studio 6.0，会设置断点，会查看运行过程中的指针情况；2.编写双向链表的插入、删除、获取指定位序的结点、遍历函数；3.实现将a1,a2,a3…an的双向链表转变为：a1,a3…a4,a2；三、实验结果#include <stdio.h>typedef struct DuLNode{char date;struct DuLNode *prior;struct DuLNode *next;}DuLNode,*DuLinkList;void DuLinkedListInsert_L(DuLinkList &L, int locate, char c){DuLNode* p=new DuLNode;p->date=c;DuLNode* q=L;for(int j=0;j<locate;j++)q=q->next;p->next=q->next;q->next->prior=p;p->prior=q;q->next=p;++L->date;}// DuLinkedListInsert_Lvoid DuLinkedListDelete_L(DuLinkList &L, int locate, char &e){DuLNode* q=L;for(int j=0;j<locate;j++)q=q->next;e=q->date;q->next->prior=q->prior;q->prior->next=q->next;--L->date;delete q;}// DuLinkedListDelete_Lvoid PrintfDuList(DuLinkList L){DuLNode*p=L->next;while(p!=L){printf("%2c",p->date);p=p->next;}printf("\n");}// PrintfDuListvoid DuLinkedListexchangete_L (DuLinkList &L){char e;DuLNode* q=L;for(int j=2;j< (L->date+3)/2;j++){DuLinkedListDelete_L(L, j, e);DuLinkedListInsert_L(L, L->date-j+2, e);}}// DuLinkedListexchangete_Lvoid main(){char c,e;int i,j;i=0;DuLNode* A=new DuLNode;A->date=0;A->next=A;A->prior=A;printf("请输入A单词，以回车结束：");scanf("%c",&c);while(c!=10){DuLinkedListInsert_L(A, i, c);i++;scanf("%c",&c);}printf("表A的元素个数为：%d\n",A->date);printf("带头结点的双向循环链表A的数据为：\n");PrintfDuList(A);DuLinkedListexchangete_L (A);PrintfDuList(A);printf("表A的元素个数为：%d\n",A->date);printf("请输入要删除在表中的位置：\n");scanf("%d",&j);DuLinkedListDelete_L(A,j,e);printf("被删除的数据为：%c\n",e);printf("被删除数据后的双向循环链表A的数据为：\n");PrintfDuList(A);printf("被删除数据后的双向循环链表A的元素个数为：%d\n",A->date);}四、实验中遇到的问题及解决方法遇到的问题：能不能利用修改原表实现数据重排功能。
链表-实验报告
实验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.裁图说明实验结果【心得体会、问题和建议】成绩：指导教师签名批阅日期：。
链表的基本操作实验报告
《数据结构》实验报告学号1445203105 姓名王胜博班级软件5班成绩实验名称实验三链表的基本操作是否原创是一、实验要求编程实现链表下教材第二章定义的线性表的基本操作，最好用菜单形式对应各个操作，使其编程一个完整的小软件。
二、实验目的通过该实验，深入理解链表的逻辑结构、物理结构等概念，掌握链表基本操作的编程实现，熟练掌握C语言中指针的操作。
和实验2对比，掌握线性结构两种不同存储方式的区别。
三、设计思想用函数执行各个功能，随机插入元素四、主要源代码#include<stdio.h>#include<stdlib.h>#include<time.h>typedef int ElemType;typedef struct Node{ElemType data;struct Node *next;}Node, *LinkList;void InitList(LinkList *L){*L=(LinkList)malloc(sizeof(Node));if(!(*L))printf("存储分配失败\n");(*L)->next=NULL;}void DestroyList(LinkList L){LinkList p;while(L){p=L->next;free(L);L=p;}}int ListLength(LinkList L){LinkList p;int i=0;p=L->next;while(p){i++;p=p->next;}return i;}int GetElem(LinkList L,int i,ElemType &e){ LinkList p;p=L->next;int j=1;while(p&&j<i){p=p->next;++j;}e=p->data;return e;}int GetElemLo(LinkList L,int i,ElemType &e){ LinkList p;p=L->next;int j=1;while(p->data!=i&&j<=ListLength(L)){p=p->next;++j;}e=j;return e;}void FindPre(LinkList L,int x){LinkList p;p=L;if(p->next->data==x){printf("第一个元素没有前驱\n");}else{while(p->next){if(p->next->data==x){printf("%d的前驱结点是:%d\n",x,p->data);break;}else{p=p->next;}}}}void FindNext(LinkList L,int x){LinkList p;p=L->next;while(p){if(p->data==x){printf("%d的后继结点是:%d\n",x,p->next->data);break;}else{p=p->next;}if(p->next==NULL){printf("最后一个元素没有后继\n");break;}}}void LinkInset_L(LinkList &L,int i,ElemType e){ LinkList p;p=L;int j=0;while(p&&j<i-1){p=p->next;++j;}if(!p||j>i-1)printf("i小于1或者i大于表长加1\n");LinkList s;s=(LinkList)malloc(sizeof (Node));s->data=e;s->next=p->next;p->next=s;}void ListDelete_L(LinkList &L,int i,ElemType &e){ LinkList p,q;p=L;int j=0;while(p->next && j<i-1){p=p->next;++j;}if(!p->next ||j>i-1)printf("删除位置不合理\n");q=p->next;p->next=q->next;e=q->data;free(q);printf("已删除的元素是:%d\n",e);}void visit(ElemType e){printf("%d,",e);}void ListTraverse(LinkList L){LinkList p=L->next;while(p){visit(p->data);p=p->next;}printf("\n");}void CreatListTail(LinkList *L,int n){LinkList p,r;int i;srand(time(0));*L=(LinkList)malloc(sizeof(Node));r=*L;for(i=0;i<n;i++){p=(Node *)malloc(sizeof(Node));p->data=rand()%100+1;r->next=p;r=p;}r->next=NULL;}int main(){LinkList L;int opp;printf("可执行的操作有:\n");printf("1.初始化或重置链表\n");printf("2.随机插入元素\n");printf("3.显示链表中数据元素个数\n");printf("4.输出所输入的链表元素\n");printf("5.所指位序的元素值\n");printf("6.链表已存在元素的位序\n");printf("7.请输入元素，求直接前驱\n");printf("8.请输入元素，求直接后继\n");printf("9.在第i个位置插入元素\n");printf("10.删除第i个元素\n");printf("11.销毁链表\n");printf("12.退出\n");printf("\n");printf("请输入你的选择:\n");do{scanf("%d",&opp);switch(opp){case 1:{InitList(&L);printf("链表已初始化\n");printf("下一步操作:");break;}case 2:{int n;printf("输入插入元素个数:");scanf("%d",&n);CreatListTail(&L,n);printf("下一步操作:");break;}case 3:{printf("链表中元素的个数是:%d\n",ListLength(L));printf("下一步操作:");break;}case 4:{ListTraverse(L);printf("下一步操作:");break;}case 5:{int m,e;printf("输入要取元素的位置:");scanf("%d",&m);if(m>ListLength(L)){printf("输入有误\n");}else{GetElem(L,m,e);printf("该元素是:%d\n",e);}printf("下一步操作:");break;}case 6:{int i,e;printf("输入要取的元素:");scanf("%d",&i);GetElemLo(L,i,e);printf("该元素的位置是:%d\n",e);printf("下一步操作:");break;}case 7:{int x;printf("要求哪个元素的前驱？");scanf("%d",&x);FindPre(L,x);printf("下一步操作:");break;}case 8:{int x;printf("要求哪个元素的后继？");scanf("%d",&x);FindNext(L,x);printf("下一步操作:");break;}case 9:{int i,e;printf("在哪个位置插入元素?");scanf("%d",&i);if(i>ListLength(L))printf("输入有误\n");else{printf("插入的新元素是:");scanf("%d",&e);LinkInset_L(L,i,e);printf("新链表:");ListTraverse(L);}printf("下一步操作:");break;}case 10:{int i,e;printf("要删除哪个位置的元素？");scanf("%d",&i);if(i>ListLength(L))printf("输入有误\n");else{ListDelete_L(L,i,e);printf("新链表:");ListTraverse(L);}printf("下一步操作:");break;}case 11:{DestroyList(L);printf("链表已销毁!\n");printf("下一步操作:");break;}case 12:{printf("谢谢使用\n");break;}default:{printf("输入错误，请重新输入\n");break;}}}while(opp!=12);return 0;}五、调试与测试数据六、实验总结。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
链表基本操作实验报告记录————————————————————————————————作者：————————————————————————————————日期：实验2链表基本操作实验一、实验目的1．定义单链表的结点类型。
2．熟悉对单链表的一些基本操作和具体的函数定义。
3．通过单链表的定义掌握线性表的链式存储结构的特点。
二、实验内容与要求该程序的功能是实现单链表的定义和主要操作。
如：单链表建立、输出、插入、删除、查找等操作。
该程序包括单链表结构类型以及对单链表操作的具体的函数定义和主函数。
程序中的单链表（带头结点）结点为结构类型，结点值为整型。
要求：同学们可参考指导书实验2程序、教材算法及其他资料编程实现单链表相关操作。
必须包括单链表创建、输出、插入、删除操作，其他操作根据个人情况增减。
三、算法分析与设计。
1.创建单链表：LinkedList LinkedListCreat( ) 创建链表函数LinkedList L=LinkedListInit(),p, r; 调用初始化链表函数r=L; r指向头结点使用malloc函数动态分配存储空间，指针p指向新开辟的结点，并将元素存放到新开辟结点的数据域，p=(LinkedList)malloc(sizeof(LNode));p->data=x;r->next=p; 将新的结点链接到头结点r之后r=p; r指向p结点scanf("%d",&x); 满足条件循环输入链表元素while(x!=flag) 当输入不为-1时循环r->next=NULL; return L; 将链表结尾赋空值，返回头结点L头结点L L......^^AnA1 A22.单链表插入pss->data=x; s->next=p->next; p->next=s;3.单链表的删除：pp->next=p->next->next;void LinkedListInsert(LinkedList L,int i,ElemType x) 链表插入函数 （L 头指针，i 插入位置，x 插入元素）LinkedList p,s;定义结构体类型指针p,sj=1;p=L; 定义整型j 计数，寻找插入位置，p 指针指向头结点 p=p->next;j++; 满足条件时p 指针后移，j 自加1while(p&&j<i) 当p 为真且j<i 时循环p=NULL||j<i YNprintf("插入位置不正确\n");s=(LNode *)malloc(sizeof(LNode));使用malloc 函数动态分配存储空间，指针s 指向新开辟的结点，并将插入元素x 存放到新开辟结点s 的数据域，将结点s 指向i+1结点位置，第i 个结点指向s ，实现了链表元素插入。
abxbc四、运行结果1.单链表初始化2.创建单链表3.求链表长度4.检查链表是否为空5.遍历链表6.从链表中查找元素7.从链表中查找与给定元素值相同的元素在顺序表中的位置8.向链表中插入元素插入元素之后的链表9.从链表中删除元素删除位置为6的元素(是3)10.清空单链表五、实验体会经过这次单链表基本操作实验，自己的编程能力有了进一步的提高，认识到自己以前在思考一个问题上思路不够开阔，不能灵活的表达出自己的想法，虽然在打完源代码之后出现了一些错误，但是经过认真查找、修改，最终将错误一一修正，主要是在写算法分析的时候出现了障碍，经过从网上查找资料，自己也对程序做了仔细的分析，对单链表创建、插入、删除算法画了详细的N-S流程图。
六、C语言版原代码# include<stdio.h># include<stdlib.h>/* 定义ElemType 为int类型*/typedef int ElemType;# define TRUE 1# define FALSE 0# define NULL 0# define flag -1/*单链表的结点类型*/typedef struct LNode{ElemType data;struct LNode *next;}LNode,*LinkedList;/*初始化单链表*/LinkedList LinkedListInit(){LinkedList L;L=(LinkedList)malloc(sizeof(LNode));L->next=NULL;return L;}/*清空单链表*/void LinkedListClear(LinkedList L){L->next=NULL;printf("链表已经清空\n");}/*检查单链表是否为空*/int LinkedListEmpty(LinkedList L){if(L->next==NULL) return TRUE;else return FALSE;}/*遍历单链表*/void LinkedListTraverse(LinkedList L) {LinkedList p;p=L->next;if(p==NULL) printf("单链表为空表\n");else{printf("链表中的元素为：\n");while(p!=NULL){printf("%d ",p->data); p=p->next;}}printf("\n");}int LinkedListLength (LinkedList L){LinkedList p;int j;p=L->next;j=0;while(p!=NULL){j++;p=p->next;}return j;}LinkedList LinkedListGet(LinkedList L,int i) {LinkedList p;int j;p=L->next;j=1;while(p!=NULL&&j<i){p=p->next;j++;}if(j==i) return p;else return NULL;}int LinkedListLocate(LinkedList L,ElemType x) {LinkedList p;int j;p=L->next;j=1;while(p!=NULL&&p->data!=x){p=p->next;j++;}if(p) return j;else return 0;}void LinkedListInsert(LinkedList L,int i,ElemType x) {LinkedList p,s;int j;j=1;p=L;while(p&&j<i){p=p->next;j++;}if(p==NULL||j>i)printf("插入位置不正确\n");else{s=(LNode *)malloc(sizeof(LNode));s->data=x;s->next=p->next;p->next=s;printf("%d 已插入到链表中\n",x);}}void LinkedListDel(LinkedList L,int i) {LinkedList p,q;int j;j=1;p=L;while(p->next&&j<i){p=p->next;j++;}if(p->next==NULL)printf("删除位置不正确\n");else{q=p->next;p->next=q->next;free(q);printf("第%d 个元素已从链表中删除\n",i);}}LinkedList LinkedListCreat(){LinkedList L=LinkedListInit(),p,r;ElemType x;r=L;printf("请依次输入链表中的元素，输入-1结束\n"); scanf("%d",&x);while(x!=flag){p=(LinkedList)malloc(sizeof(LNode));p->data=x;r->next=p;r=p;scanf("%d",&x);}r->next=NULL;return L;}int scan(){int d;printf("请选择要进行的操作\n");printf("-------------------------------------------------------\n"); printf("1.初始化 2.清空 3.求链表长度 4.检查链表是否为空\n"); printf("-------------------------------------------------------\n"); printf("5.遍历链表 6.从链表中查找元素\n");printf("-------------------------------------------------------\n"); printf("7.从链表中查找与给定元素值相同的元素在顺序表中的位置\n"); printf("-------------------------------------------------------\n"); printf("8.向链表中插入元素 9.从链表中删除元素 10创建线性表\n"); printf("-------------------------------------------------------\n"); printf("其他键退出。
\n");printf("输入: ");scanf("%d",&d);return(d);}main(){int quit=0;int i,locate;ElemType e;LinkedList L,p;while(!quit)switch(scan()){case 1:L=LinkedListInit();printf("\n");break;case 2:LinkedListClear(L);printf("\n");break;case 3:printf("链表长度为 %d\n",LinkedListLength(L));break;case 4:if(LinkedListEmpty(L))printf("链表为空\n");else printf("链表非空\n");break;case 5:LinkedListTraverse(L);break;case 6:printf("请输入待查询元素在链表中的位置:");scanf("%d",&i);p=LinkedListGet(L,i);if(p) printf("链表第%d个元素的值为:%d\n",i,p->data);else printf("查询位置不正确\n");break;case 7:printf("请输入待查询元素的值:");scanf("%d",&e);locate=LinkedListLocate(L,e);if(locate)printf("%d在链表中的位置是:%d\n",e,locate);else printf("链表中没有值为%d的元素\n",e);break;case 8:printf("请输入插入元素的位置和值(中间以空格或回车分隔):\n");scanf("%d%d",&i,&e);LinkedListInsert(L,i,e);break;case 9:if(LinkedListLength(L)==0)printf("链表已经为空，不能删除!\n");else{printf("请输入待删除元素的位置: ");scanf("%d",&i);LinkedListDel(L,i);}break;case 10:L=LinkedListCreat();printf("\n");break;default:quit=1;}}。