单链表的基本操作实验报告
单链表的基本操作实验报告
单链表的基本操作实验报告单链表的基本操作实验报告引言：单链表是一种常见的数据结构，它由一系列节点组成，每个节点包含一个数据元素和一个指向下一个节点的指针。
在本次实验中，我们将学习和实践单链表的基本操作，包括创建链表、插入节点、删除节点以及遍历链表等。
一、实验目的本次实验的主要目的是掌握单链表的基本操作，包括链表的创建、插入节点、删除节点和遍历链表。
通过实践操作，加深对单链表的理解，并掌握如何应用单链表解决实际问题。
二、实验过程1. 创建链表首先，我们需要创建一个空链表。
链表可以通过一个头节点来表示，头节点不存储数据，只用于标识链表的起始位置。
我们可以定义一个指针变量head，将其指向头节点。
2. 插入节点在链表中插入节点是常见的操作。
我们可以选择在链表的头部、尾部或者指定位置插入节点。
插入节点的过程可以分为以下几个步骤：a. 创建一个新节点，并为其赋值；b. 找到要插入位置的前一个节点；c. 将新节点的指针指向前一个节点的下一个节点；d. 将前一个节点的指针指向新节点。
3. 删除节点删除节点是另一个常见的操作。
我们可以选择删除链表的头节点、尾节点或者指定位置的节点。
删除节点的过程可以分为以下几个步骤：a. 找到要删除节点的前一个节点；b. 将前一个节点的指针指向要删除节点的下一个节点；c. 释放要删除节点的内存空间。
4. 遍历链表遍历链表是为了查看链表中的元素。
我们可以从头节点开始，依次访问每个节点，并输出节点的值。
三、实验结果在本次实验中，我们成功完成了单链表的基本操作。
通过创建链表、插入节点、删除节点和遍历链表等操作，我们可以方便地对链表进行增删改查操作。
四、实验总结通过本次实验，我们对单链表的基本操作有了更深入的了解。
单链表是一种非常重要的数据结构，广泛应用于各个领域。
掌握了单链表的基本操作，我们可以更好地解决实际问题，并且为以后学习更复杂的数据结构打下坚实的基础。
在实验过程中，我们还发现了一些问题和不足之处。
单链表的实验报告
单链表的实验报告单链表的实验报告引言：单链表是一种常用的数据结构，它由一系列节点组成，每个节点包含一个数据元素和一个指向下一个节点的指针。
在本次实验中，我们将学习如何使用单链表来实现一些基本的操作，并通过实验验证其功能和效率。
一、实验目的本次实验的主要目的是掌握单链表的基本概念和操作方法，包括插入、删除、查找等操作，并通过实际操作来验证其正确性和效率。
二、实验过程1. 单链表的定义和初始化首先，我们需要定义一个单链表的结构，并初始化一个空链表。
链表的结构可以使用C语言中的结构体来表示，其中包含一个数据域和一个指向下一个节点的指针。
2. 插入操作在已有链表中插入一个新的节点，可以分为两种情况：在链表头部插入和在链表中间插入。
我们可以通过修改指针的指向来实现插入操作。
3. 删除操作删除链表中的一个节点，同样可以分为两种情况：删除头节点和删除中间节点。
删除操作需要注意指针的重新连接，以防止链表断裂。
4. 查找操作在链表中查找指定的元素，可以通过遍历链表的方式来实现。
从链表头开始，依次比较节点的数据域，直到找到目标元素或者遍历到链表尾部。
5. 其他操作在实际应用中，还可以对链表进行排序、逆序、合并等操作，这些操作都可以通过适当的算法来实现。
三、实验结果通过实际操作，我们验证了单链表的各种操作方法的正确性和效率。
在插入、删除和查找操作中，链表的时间复杂度为O(n)，其中n为链表的长度。
而在其他操作中，时间复杂度则根据具体算法的实现方式而定。
四、实验总结通过本次实验，我们深入了解了单链表的结构和操作方法，并通过实际操作来验证了其功能和效率。
单链表作为一种常用的数据结构，在实际应用中具有广泛的用途，例如链表可以用来实现栈、队列等其他数据结构，也可以用于解决一些实际问题，如链表的反转、环的检测等。
总之，掌握单链表的基本概念和操作方法对于学习和理解数据结构具有重要意义。
通过实验的方式，我们不仅能够加深对单链表的理解，还能够提高编程能力和解决实际问题的能力。
数据结构实验报告--单链表
数据结构实验报告--单链表数据结构实验报告--单链表1.引言1.1 研究目的本实验旨在通过实践的方式，深入了解单链表的数据结构以及相关操作，提升对数据结构的理解和应用能力。
1.2 实验内容本实验主要包括以下几个方面的内容：●单链表的基本定义和实现●单链表的插入、删除、遍历操作●单链表的逆置操作●单链表的查找和修改操作2.理论基础2.1 单链表的定义单链表是一种常见的线性数据结构，它由一系列的节点组成，每个节点包含数据和指向下一个节点的指针。
2.2 单链表的基本操作①单链表的插入操作在单链表中，可以通过插入操作在指定位置插入一个新节点，该操作主要包括以下步骤：●创建一个新的节点，并为其赋值●将新节点的next指针指向插入位置的后一个节点●将插入位置的前一个节点的next指针指向新节点②单链表的删除操作在单链表中，可以通过删除操作删除指定位置的节点，该操作主要包括以下步骤：●将删除位置的前一个节点的next指针指向删除位置的后一个节点●释放删除节点的内存③单链表的遍历操作单链表的遍历操作主要是依次访问链表中的每一个节点，并执行相应的操作。
④单链表的逆置操作单链表的逆置操作可以将一个单链表中的节点顺序进行颠倒。
⑤单链表的查找操作在单链表中，可以通过查找操作找到指定值的节点。
⑥单链表的修改操作在单链表中，可以通过修改操作修改指定位置的节点的值。
3.实验过程3.1 实验环境本次实验使用C语言进行编程，需要先安装相应的编程环境，如gcc编译器。
3.2 实验步骤①单链表的创建和初始化首先创建一个空链表，并初始化链表的头指针。
②单链表的插入操作按照需求，在链表的指定位置插入一个新节点。
③单链表的删除操作按照需求，删除链表中的指定位置的节点。
④单链表的遍历操作依次访问链表中的每一个节点，并输出其值。
⑤单链表的逆置操作将单链表中的节点顺序进行逆置。
⑥单链表的查找操作按照需求，在链表中查找指定值的节点。
3.2.7 单链表的修改操作按照需求，修改链表中指定位置的节点的值。
数据结构单链表实验报告
数据结构单链表实验报告实验目的：掌握单链表的基本操作，学会使用单链表实现各种算法。
实验内容：实现单链表的基本操作，包括创建、插入、删除、访问等。
利用单链表完成以下算法：- 单链表逆序- 查找单链表中的中间节点- 删除单链表中的倒数第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指向的节点即为要删除的节点。
单链表的基本操作实验报告
湖南第一师范学院信息科学与工程系实验报告课程名称：数据结构与算法成绩评定：实验项目名称：单链表的基本操作指导教师：学生姓名：沈丽桃学号： 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里的一对双引号不是英文状态下的。
数据结构单链表实验报告
数据结构单链表实验报告范本：数据结构单链表实验报告一、引言本实验旨在掌握数据结构中单链表的基本概念、操作和应用。
通过实际操作，理解单链表的结构与实现，提高数据结构的编程能力和问题解决能力。
二、实验目的1. 理解单链表的概念和特点；2. 掌握单链表的基本操作，包括插入、删除、遍历；3. 学会使用单链表解决实际问题。
三、实验内容1. 单链表的定义和结构设计；2. 单链表的基本操作的实现，包括插入节点、删除节点、遍历；3. 针对具体的问题，设计相应的单链表操作。
四、实验步骤1. 单链表的定义和结构设计：（1）定义单链表的结构体，包含数据域和指针域；（2）实现单链表的初始化函数；（3）实现单链表的销毁函数。
2. 单链表的基本操作的实现：（1）实现单链表的插入节点操作；（2）实现单链表的删除节点操作；（3）实现单链表的遍历操作。
3. 针对具体问题的单链表操作：（1）根据具体需求，设计并实现相应的操作函数；（2）利用单链表解决具体问题。
五、实验结果与分析1. 在实验过程中，成功实现了单链表的定义和结构设计，包括数据域和指针域的正确设置。
2. 实验中实现了插入节点、删除节点和遍历等基本操作。
3. 针对具体问题，通过单链表操作解决了相应的问题。
六、实验总结通过本次实验，加深了对单链表的理解和掌握。
掌握了单链表的基本操作和应用实现，提高了数据结构的编程能力和问题解决能力。
附件：1. 本文所涉及的代码文件；2. 实验过程中所用到的数据文件。
法律名词及注释：1. 数据结构：指的是一组数据的表示方法和相应的操作。
在计算机科学中，数据结构是计算机中存储、组织数据的方式。
2. 单链表：是一种链式存储结构，每个节点包含数据域和指针域。
数据域用于存储数据，指针域用于指向下一个节点。
链表基本操作实验报告
while(p&&j<i) {p=p->next;j++;} if(p==NULL||j>i)
printf("插入位置不正确\n"); else{s=(LNode *)malloc(sizeof(LNode));
{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; }
8.向链表中插入元素
插入元素之后的链表 9.从链表中删除元素
删除位置为 6 的元素(是 3)
10.清空单链表
五、 实验体会
经过这次单链表基本操作实验，自己的编程能力有了进一步的提高，认识到自 己以前在思考一个问题上思路不够开阔，不能灵活的表达出自己的想法，虽然在 打完源代码之后出现了一些错误，但是经过认真查找、修改，最终将错误一一修 正，主要是在写算法分析的时候出现了障碍，经过从网上查找资料，自己也对程 序做了仔细的分析，对单链表创建、插入、删除算法画了详细的 N-S 流程图。
r=L; r 指向头结点
使用 malloc 函数动态分配存储空间，指针 p 指向新开辟的结点，并将元素存
放到新开辟结点的数据域，
单链表操作实验报告
for(q=head;(q!=NULL)&&(j<=i-1);j++)
q=q->next;
if(q!=NULL)
{
printf("\t插入成功！\n");
s->next=q->next;
q->next=s;
}
else printf("\t插入失败！\n");
return(head);
case 4:head=Linkdelete(head);Linkprint(head);break;
case 5:Linkprint(head);break;
case 6:exit(0);
}
}
}
五．测试结果
1.程序运行界面
{
p=p->next;
i++;
}
if(p->data==x)
{
printf("\t查找成功！\n");
printf("\t输出查找的数据所在位置为:%d\n",i);
}
else printf("\t查找结点不存在！\n");
}
linklist *Linkinsert(linklist *head)
{
printf("\t5.输出单链表\n");
printf("\t6.退出\n");
do{
printf("\t请输入选择的功能：");
scanf("%d",&k);
printf(" -------------------------------\n");
单链表的各种基本运算的实现 实验报告
软件技术基础实验一——单链表的各种基本运算的实现一、实验题目编写一个程序，实现单链表的各种基本运算，并在此基础上设计一个主程序完成如下功能：（1）初始化单链表（2）依次采用尾插法插入a,b,c,d,e元素（3）输出单链表（4）在第四个元素位置上插入f元素（5）删除该单链表的第三个元素二、实验目的1、理解单链表的概念及结构特点；2、掌握单链表的基本操作：查找、插入、删除等运算在链接存储结构上的运算。
三、调试通过并正确执行给定功能要求的实验代码#include "stdafx.h"#include<malloc.h>#include<iostream.h>struct link{char data;link *next;};link *rcreat(link *head,char x) //尾插法建立单链表{link *s,*r;r=head;s=new link;s->data=x;r->next=s;r=s;r->next=NULL;return r;}link *get(link *head,int i) //查找第i个元素，返回其地址{int j;link *p;j=1;p=head->next ;while((j<i-1)&&(p!=NULL)){j++;p=p->next;}return p;}void insert(link *head,int num,char y) //元素y之后插入x {link *p,*s;s=new link;s->data=y;if(head->next==NULL){head->next=s;s->next=NULL;}p=get(head,num);if(p==NULL) cout<<"插入位置非法";else{s->next=p->next;p->next=s;}}void delet(link *head,char x) //将指定元素x删除{link * p, * q;q=head;p=head->next;while((p!=NULL)&&(p->data!=x)){q=p;p=p->next;}if(p==NULL) cout<<"要删除的元素不存在";else{q->next=p->next;delete(p);}}void print(link *head) //输出单链表{link *p;p=head->next;while(p->next!=NULL){cout<<p->data<<"->";p=p->next;}cout<<p->data<<endl;}void main(int argc, char* argv[]){link *head,*p,*q,*r;char x,y;int n,dele,i=1,j=1;head=new link;head->next=NULL;r=head;while(j<=5){cout<<"请输入要插入的元素：";cin>>x;r=rcreat(r,x);j=j+1;}print(head);cout<<"请输入要插入元素的位置：";cin>>n;cout<<"请输入要插入的元素：";cin>>y;insert(head,n,y);cout<<"输出插入后的单链表："<<endl;print(head);cout<<"请输入要删除元素的位置：";cin>>dele;q=head;p=head->next;while(i<dele){q=p;p=p->next;i=i+1;}q->next=p->next;delete (p);cout<<"删除后的链表如下："<<endl;print(head);}四、实验结果。
单链表的操作实验报告
单链表的操作实验报告《单链表的操作实验报告》在计算机科学领域，数据结构是非常重要的基础知识之一。
而单链表作为一种常见的数据结构，经常被用来存储和操作数据。
在本次实验中，我们将对单链表的操作进行实验，并撰写实验报告以总结和分享我们的实验结果。
实验目的：1. 了解单链表的基本概念和操作方法。
2. 掌握单链表的插入、删除、查找等操作。
3. 通过实际操作加深对单链表的理解和掌握。
实验环境：1. 编程语言：C/C++2. 开发环境：Visual Studio Code3. 实验工具：GCC编译器实验步骤：1. 定义单链表的结构体，并实现初始化、插入、删除、查找等操作的函数。
2. 编写测试用例，对单链表的各种操作进行测试。
3. 分析实验结果，总结操作的时间复杂度和空间复杂度。
4. 撰写实验报告，分享实验过程和结果。
实验结果：经过实验，我们成功实现了单链表的初始化、插入、删除、查找等操作，并对这些操作进行了充分的测试。
我们发现单链表的插入和删除操作的时间复杂度为O(1)，而查找操作的时间复杂度为O(n)，其中n为链表的长度。
这些结果与我们的预期相符合，说明我们对单链表的操作有了较好的掌握。
实验总结：通过本次实验，我们不仅加深了对单链表的理解，还提高了编程能力和数据结构的应用能力。
我们对单链表的操作有了更深入的了解，为以后在实际项目中应用单链表打下了良好的基础。
结语：单链表作为一种常见的数据结构，在实际应用中具有重要的作用。
通过本次实验，我们对单链表的操作有了更深入的了解，相信在以后的学习和工作中能够更好地应用和运用单链表。
希望本次实验报告能够对读者有所帮助，也欢迎大家对实验结果进行讨论和交流。
数据结构实验报告单链表
数据结构实验报告_单链表数据结构实验报告——单链表一、实验目的1.掌握单链表的基本概念和原理。
2.了解单链表在计算机科学中的应用。
3.掌握单链表的基本操作，如插入、删除、遍历等。
4.通过实验，加深对理论知识的理解，提高编程能力。
二、实验内容1.实验原理：单链表是一种线性数据结构，由一系列节点组成，每个节点包含数据域和指针域。
其中，指针域指向下一个节点，最后一个节点的指针域指向空。
单链表的主要操作包括插入、删除、遍历等。
2.实验步骤：（1）创建一个单链表。
（2）实现插入操作，即在链表的末尾插入一个新节点。
（3）实现删除操作，即删除链表中的一个指定节点。
（4）实现遍历操作，即输出链表中所有节点的数据。
3.实验代码：下面是使用Python语言实现的单链表及其基本操作的示例代码。
class Node:def __init__(self, data):self.data = dataself.next = Noneclass LinkedList:def __init__(self):self.head = Nonedef insert(self, data):new_node = Node(data)if self.head is None:self.head = new_nodeelse:current = self.headwhile current.next is not None:current = current.nextcurrent.next = new_nodedef delete(self, data):if self.head is None:returnif self.head.data == data:self.head = self.head.nextreturncurrent = self.headwhile current.next is not None and current.next.data != data:current = current.nextif current.next is None:returncurrent.next = current.next.nextdef traverse(self):current = self.headwhile current is not None:print(current.data)current = current.next4.实验结果：通过运行上述代码，我们可以看到单链表的基本操作得到了实现。
实验报告单链表
课程名称: 单链表班级：14物联网2班姓名：许环智日期2016.04.27 实验题目：单链表的基本操作。
实验目的：理解单链表的逻辑结构和存储结构，熟练掌握单练表的相关操作。
1、问题描述：用箭头表示链域中的指针于是单链表就可以直观的画成用箭头链接起来的结点序列，单链表中每个结点的储存地址存放的其直接前驱的指针域中，因此访问单链表的每一个结点必须从表头指针开始进行。
对单链表的操作主要有：建立单链表、查找、插入一个结点、删除一个结点、求表长。
2、数据结构设计：单链表的结点结构如下Typedef struct node{ //单链表结点结构ElemType data;Structnode *next;}LinkList;3、功能（函数）设计:InitList1(LinkList *&head)//初始化不带头指针的链表指针linklist *CreateList_R(); //尾插法创建链表linklist *GetElem(linklist *h, int pos); //通过位置查找节点linklist *LocateElem(linklist *h, char dat, int *i); //按值查找节点int Linklist_Insert(linklist *h, int pos, char dat);//按位置插入节点int Linklist_Delete(linklist *h, int pos); //按位置删除节点void ShowLinklist(linklist *h); //输出显示链表4、界面设计5、编码实现课程名称: 单链表班级：14物联网2班姓名：许环智日期2016.04.27 6、运行测试：附件：#include<stdio.h>#include<malloc.h>#include<stdlib.h>typedef struct list{char data;struct list *next;}linklist;linklist *CreateList_R()//尾插法建立的单链表{linklist *l,*p,*r;int ch,i,n;l=(linklist*)malloc(sizeof(linklist));r=l;课程名称: 单链表班级：14物联网2班姓名：许环智日期2016.04.27ch=getchar();for(i=0;i<n;i++){p=(linklist*)malloc(sizeof(linklist));p->data=i;r->next=p;r=p;ch=getchar();getchar();}r->next=NULL; //表示当前链表结束return l;}linklist *GetElem(linklist *l,int pos){linklist *p;int i=1;while(i<pos&&p!=NULL){p=p->next; //p指向下一个结点i++;}if(i==pos)return p; //i不合法 i>n或i=<0elsereturn NULL;}linklist *LocateElem(linklist *l,char dat,int *i) //再带头结点的单链表L中查找e的元素{课程名称: 单链表班级：14物联网2班姓名：许环智日期2016.04.27linklist *p;p=l->next; //初始化p指向首元结点*i=1;while(p!=NULL){if(p->data!=dat){*i=*i+1;p=p->next;}elsebreak;}return p;}int linklist_Insert(linklist *l,int pos,char dat) ///再带头结点的单链表L中再i位置插入为e的新结点{linklist *p,*h;int i=0;p=l;while(i<pos-1&&p->next!=NULL) //以j<i-1找i-1的位置{ i++;p=p->next;}if(i==pos-1);{h=(linklist*)malloc(sizeof(linklist));h->data=dat; //将结点的*s的数据域置为eh->next=p->next; //将结点*s的指针域指向结点aip->next=1; //将结点*p的指针域指向结点*sgetchar();}return 1;}课程名称: 单链表班级：14物联网2班姓名：许环智日期2016.04.27int Linklist_Delete(linklist *h, int pos){linklist *p, *s;int i = 0;p = h;while(i<pos-1 && p->next != NULL) //搜索指定位置前一个节点{i++;p = p->next;}if(i != pos-1 || p->next == NULL) //查找位置非法return 0;s = p->next;p->next = s->next;free(s);return 1;}//输出显示节点void ShowLinklist(linklist *l){linklist *p;p = l->next;while(p != NULL){printf("%c ", p->data);p = p->next;}printf("\n");}int main(void)课程名称: 单链表班级：14物联网2班姓名：许环智日期2016.04.27{linklist *l, *p;int choice, pos, ans;char dat;printf("单链表的相关操作练习\n");printf("尾插法创建一个链表，请依次输入节点字符数据，空格隔开('#'表示输入结束)：\n");l = CreateList_R();while(1){printf("-----选择将要进行的操作-----\n");printf("1.按位置查找节点\n");printf("2.按值查找节点\n");printf("3.按位置插入节点\n");printf("4.按位置删除节点\n");printf("5.输出显示链表\n");printf("6.退出程序\n");printf("做出选择：\n");scanf("%d", &choice);getchar(); //消除回车键对后面输入带来的影响.switch(choice){case 1:printf("输入想要查找节点的位置:");scanf("%d", &pos);p = GetElem(l, pos);if(p)printf("第%d个节点数据为:%c\n", pos, p->data);elseprintf("查找的节点不存在\n");break;case 2:printf("输入想要查找的节点的字符数据：");scanf("%c", &dat);p = LocateElem(l, dat, &pos);if(p){printf("你查找的节点所在数据为：%c\n", p->data);printf("节点所在的位置为:%d\n", pos);课程名称: 单链表班级：14物联网2班姓名：许环智日期2016.04.27}else{printf("你查找的节点不存在！\n");}break;case 3:printf("请输入你想插入的节点字符数据及位置(空格隔开):");scanf("%c %d", &dat, &pos);ans = Linklist_Insert(l, pos, dat);if(ans)printf("插入节点成功!\n");elseprintf("插入节点失败\n");break;case 4:printf("请输入你想删除节点所在的位置：");scanf("%d", &pos);ans = Linklist_Delete(l, pos);if(ans)printf("删除节点成功!\n");elseprintf("删除节点失败！\n");break;case 5:printf("节点数据依次为:");ShowLinklist(l);break;case 6:return 0;break;default:printf("输入的选择无效!\n");break;}}}。
数据结构实验报告-单链表的基本操作
湖南文理学院实验报告课题名称：数据结构实验实验名称：单链表的基本操作学生姓名：学号：专业：计算机科学与技术班级:计科11102班实验日期：2012.11.02成绩：一、实验目的1.学会定义单链表的结点类型，实现对单链表的一些基本操作和具体的函数定义，了解并掌握单链表的类定义以及成员函数的定义与调用。
2.掌握单链表基本操作及两个有序表归并、单链表逆置等操作的实现。
二、实验内容1．编写程序完成单链表的下列基本操作：(1)初始化单链表La。
(2)在La中插入一个新结点。
(3)删除La中的某一个结点。
(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所指的结点之后。
三、实验源代码1.建立新链表void INlist(linklist&head,int n){linklist q;head=(list*)malloc(LEN);head->next=NULL;q=head;for(int i=0;i<n;i++){p=(list*)malloc(LEN);scanf("%d",&(p->data));p->next=NULL;q->next=p;q=p;}q->next=NULL;p=head;//head=head->next;}2.输出链表void printlist(linklist L){L=L->next;while(L){printf("%d",L->data);L=L->next;}printf("\n");}3.插入节点bool listinsert(linklist&L,int n){p=L;linklist q;int j=0;while(p&&j<n-1){p=p->next;j++;}if(!p||j>n-1)return false;q=(list*)malloc(LEN);printf("请输入你需要的值：");scanf("%d",&(q->data));q->next=p->next;p->next=q;return true;}4.删除节点bool delist(linklist&L,int n){p=L;linklist q;int i=0;if(p->next==NULL)return false;/*if(n==1){q=p;p=p->next;free(q);}*/while(p->next&&i<n-1){p=p->next;i++;}if(!(p->next)&&i>n-1)return false;q=p->next;printf("删除的值为：%d\n",q->data);p->next=q->next;free(q);return true;}5.合并两个链表void merlist(linklist&La,linklist&Lb,linklist&Lc){linklist pa,pb;Lc=p=La;pb=Lb->next;pa=La->next;while(pa&&pb){if(pa->data<=pb->data){p->next=pa;p=pa;pa=pa->next;} else{p->next=pb;p=pb;pb=pb->next;}}p->next=pa?pa:pb;free(Lb);}6.主函数int main(){int n;linklist la,lb,lc;printf("请输入第一个链表的长度：");scanf("%d",&n);printf("请输入这些数：");INlist(la,n);printf("输入这些数为：");printlist(la)printf("请输入你需要在哪个节点前插入：")；scanf("%d",&n);if(listinsert(la,n))printf("插入成功！\n");elseprintf("失败！\n");printf("输出这些数为：");printlist(la);printf("请输入第二个链表的长度：");scanf("%d",&n);printf("请输入这些数：");INlist(lb,n);printf("输出这些数为：");printlist(lb);printf("请输入你需要删除哪个节点：");scanf("%d",&n);if(delist(lb,n))printf("删除成功！\n")；else printf("失败！\n");printf("输出这些数为：");printlist(lb);printf("合并并输出两个链表为:");merlist(la,lb,lc);printlist(lc);return0;}7.头文件#include<stdio.h>#include<malloc.h>#define LEN sizeof(list)typedef int ET;typedef struct list{ET data;struct list*next;}list,*linklist;linklist p;四、实验结果五、实验分析1.刚开始运行程序时我将数字无序输入，导致无序输出，不符合实验要求，后来有序输入结果符合要求；2.主函数中“printf("合并并输出两个链表为:")；merlist(la,lb,lc);printlist(lc);”语句必须写在最后面，否则将无法实现合并两条链表的功能，甚至导致程序运行出错。
单链表的操作实验报告
单链表的操作实验报告单链表的操作实验报告引言：单链表是一种常见的数据结构，它由一系列节点组成，每个节点包含数据和指向下一个节点的指针。
在本次实验中，我们将学习如何使用C语言实现单链表的基本操作，包括插入、删除和查找等。
一、单链表的定义和初始化单链表由节点组成，每个节点包含数据和指向下一个节点的指针。
首先，我们需要定义一个节点的结构体，如下所示：```struct Node {int data; // 节点数据struct Node* next; // 指向下一个节点的指针};```在初始化单链表之前，我们需要创建一个头节点，它不存储任何数据，只用于指向第一个节点。
初始化单链表的代码如下：```struct Node* head = NULL; // 头节点初始化为空```二、单链表的插入操作插入操作是向单链表中添加新节点的过程。
我们可以在链表的头部、尾部或者指定位置插入新节点。
下面以在链表头部插入新节点为例进行说明。
首先，我们需要创建一个新节点，并为其分配内存空间：```struct Node* newNode = (struct Node*)malloc(sizeof(struct Node));```然后，为新节点赋值并将其插入到链表头部：```newNode->data = 10; // 赋值新节点的数据newNode->next = head; // 将新节点的指针指向原头节点head = newNode; // 将头节点指向新节点```三、单链表的删除操作删除操作是从单链表中删除指定节点的过程。
我们可以根据节点的位置或者数据进行删除。
下面以删除链表中指定数据的节点为例进行说明。
首先，我们需要遍历链表找到要删除的节点，并记录其前一个节点的地址：```struct Node* current = head;struct Node* previous = NULL;int targetData = 10; // 要删除的节点数据while (current != NULL && current->data != targetData) {previous = current;current = current->next;}```然后，将前一个节点的指针指向要删除节点的下一个节点，并释放要删除节点的内存空间：```previous->next = current->next;free(current);```四、单链表的查找操作查找操作是在单链表中查找指定数据的节点。
单链表操作实验报告
线性表一、实验目的1. 了解线性表的逻辑结构特征，以及这种特性在计算机内的两种存储结构。
2. 掌握线性表的顺序存储结构的定义及其 C语言实现。
3. 掌握线性表的链式村粗结构一一单链表的定义及其C语言实现。
4. 掌握线性表在顺序存储结构即顺序表中的各种基本操作。
5. 掌握线性表在链式存储结构一一单链表中的各种基本操作。
二、实验要求1. 认真阅读和掌握本实验的程序。
2. 上机运行本程序。
3. 保存和打印出程序的运行结果，并结合程序进行分析。
4. 按照对顺序表和单链表的操作需要，重新改写主程序并运行，打印出文件清单和运行结果三、实验内容请编写C程序，利用链式存储方式来实现线性表的创建、插入、删除和查找等操作。
具体地说，就是要根据键盘输入的数据建立一个单链表，并输出该单链表；然后根据屏幕菜单的选择，可以进行数据的插入或删除，并在插入或删除数据后，再输出单链表；然后在屏幕菜单中选择 0,即可结束程序的运行。
四、解题思路本实验要求分别写出在带头结点的单链表中第 i （从1开始计数）个位置之后插入元素、创建带头结点的单链表中删除第 i个位置的元素、顺序输出单链表的内容等的算法。
五、程序清单#i nclude<stdio.h>#i nclude<stdlib.h>#in clude<math.h>typedef int ElemType;typedef struct LNode{ ElemType data;struct LNode *n ext;}LNode;LNode *L;LNode *creat_L();void out_L(LNode *L);void in sert_L(LNode *L,i nt i,ElemType e); ElemType delete_L(LNode *L,i nt i); int locat_L(LNode *L,ElemType e);void mai n(){ int i,k,loc;ElemType e,x;char ch;do{ printf("\n");prin tf("\n1. printf("\n 2.prin tf("\n3. prin tf("\n4. prin tf("\n 0. 建立单链表"); 插入元素"); 删除元素"); 查找元素"); 结束程序运行"); ======================================")请输入您的选择(1, 2, 3, 4, 0)");请输入插入位置："); 请输入要插入元素的值："); prin tf("\n prin tf("\nscan f("%d",&k);switch(k){ case 1:{ L=creat_L();out_L(L);}break;case 2:{ prin tf("\nscan f("%d",&i); printf("\n scanf("%d",&e); insert_L(L,i,e);out_L(L); }break;case 3:{ prin tf("\nscan f("%d",&i);删除的元素为：%d\n",x);删除％4后的单链表为：\n",x);out_L(L);}else prin tf("\n }break;case 4:{ prin tf("\n scan f("%d",&e);loc=locat_L(L,e);if(loc==-1) prin tf("\nelse prin tf("\n请输入要删除元素的位置：")x=delete_L(L,i); out_L(L); if(x!=-1) {pri ntf("\nprintf("要删除的元素不存在！");请输入要查找的元素值：");为找到指定元素！");已找到，元素位置是%d",loc);}break;}printf("\n ------- ");}while(k>=1 &&k<5);printf("\n 按回车键，返回...\n");ch=getchar();}LNode *creat_L(){ LNode *h,*p,*s; ElemType x;h=(LNode *)malloc(sizeof(LNode));h-> next=NULL;p=h;prin tf("\n 请输入第一个数据元素：");sca nf("%d", &x);while(x!=-999){ s=(LNode *)malloc (sizeof(LNode));s->data=x; s->n ext=NULL;p->n ext=s; p=s;printf(" 请输入下一个数据：(输入-999表示结束。
数据结构单链表实验报告
数据结构单链表实验报告实验目的：本实验的目的是通过实现单链表数据结构，加深对数据结构的理解，并掌握单链表的基本操作和算法。
实验内容：1、单链表的定义单链表由若干个节点组成，每个节点包含数据域和指针域，数据域存储具体数据，指针域指向下一个节点。
单链表的头指针指向链表的第一个节点。
2、单链表的基本操作2.1 初始化链表初始化链表时，将头指针置空，表示链表为空。
2.2 插入节点插入节点可以分为头插法和尾插法。
- 头插法：将新节点插入链表头部，新节点的指针域指向原头节点，头指针指向新节点。
- 尾插法：将新节点插入链表尾部，新节点的指针域置空，原尾节点的指针域指向新节点。
2.3 删除节点删除节点可以分为按位置删除和按值删除两种方式。
- 按位置删除：给定要删除节点的位置，修改前一节点的指针域即可。
- 按值删除：给定要删除节点的值，遍历链表找到对应节点，修改前一节点的指针域即可。
2.4 遍历链表遍历链表即按顺序访问链表的每个节点，并输出节点的数据。
2.5 查找节点查找节点可以分为按位置查找和按值查找两种方式。
- 按位置查找：给定节点的位置，通过遍历链表找到对应节点。
- 按值查找：给定节点的值，通过遍历链表找到第一个匹配的节点。
实验步骤：1、根据实验目的，定义单链表的结构体和基本操作函数。
2、实现初始化链表的函数，将头指针置空。
3、实现头插法或尾插法插入节点的函数。
4、实现按位置删除节点的函数。
5、实现按值删除节点的函数。
6、实现遍历链表的函数，输出节点的数据。
7、实现按位置查找节点的函数。
8、实现按值查找节点的函数。
9、设计实验样例，测试单链表的各种操作。
实验结果与分析：通过测试实验样例，我们可以验证单链表的各种操作是否正确。
如果出现异常情况，可通过调试找出问题所在，并进行修改。
单链表的操作时间复杂度与操作的位置有关，对于查找操作，时间复杂度为O(n)；对于插入和删除操作，时间复杂度也为O(n)。
附件：1、单链表的定义和基本操作的源代码文件。
单链表实验报告
单链表实验报告单链表的基本操作1.实验题目问题描述：实现带头结点的单链表的建立、求长度，取元素、修改元素、插入、删除等单链表的基本操作。
通过代码的编写理解并掌握单链表的过程编写以及作用。
2.实验要求（1）依次从键盘读入数据，建立一个单链表并将单链表的初始化设置为空；（2）通过操作选择，输出单链表中的数据元素（3）显示单链表的长度；（4）根据指定条件能够查找出元素和修改元素；（5）实现在指定位置插入和删除元素的功能（6）显示操作后的结果3.算法设计（1）用到的结构（逻辑结构、存储结构）逻辑结构：线性结构存储结构：带头结点的单链表（2）算法设计思路定义结点类型LNode，每个结点包括数据域data和指针域next。
定义头指针LinkList。
编写如下函数：1、createlist(LinkList &L)；用尾插法创建一个带头结点的单链表。
2、print(LinkList L)；输出该单链表中的数据元素。
3、ListLength(LinkList L)；求该单链表的长度。
4、GetElem(LinkList &L,int i,ElemType &e)；查找第i个元素。
5、SetElem(LinkList &L,int i,ElemType m)；修改第i个元素。
6、ListInsert (LinkList &L, int i, ElemType e )；在第i个元素前插入一个元素。
7、ListDelete(LinkList &L,int i,ElemType &e2)；删除第i个元素。
8、main()；通过case结构来调用createlist(LinkList &L)、GetElem(LinkList&L,int i,ElemType &e)、SetElem(LinkList &L,int i,ElemType m)、ListInsert (LinkList &L, int i, ElemType e )、ListDelete(LinkList &L,int i,ElemType &e2)4.调试和测试调试过程总结经过多次调试，本程序能很好的完成实验要求的各项功能。
数据结构单链表实验报告
数据结构单链表实验报告一、实验目的本次实验旨在深入理解和掌握数据结构中单链表的基本概念、操作原理及实现方法。
通过实际编程实现单链表的创建、插入、删除、查找等基本操作，提高对数据结构的理解和编程能力。
二、实验环境本次实验使用的编程环境为具体编程语言，编译工具为具体编译工具名称。
三、实验原理1、单链表的定义单链表是一种线性表的数据结构，它由一系列节点组成，每个节点包含数据域和指针域。
数据域用于存储节点的数据，指针域用于指向下一个节点的地址。
通过这种方式，将各个节点连接起来，形成一个链表。
2、单链表的基本操作创建单链表：从无到有构建一个单链表，可以通过逐个插入节点来实现。
插入节点：可以在链表的头部、尾部或指定位置插入新的节点。
删除节点：根据给定的条件或位置删除链表中的节点。
查找节点：在链表中查找满足特定条件的节点。
四、实验内容1、单链表节点的定义｀｀｀具体编程语言typedef struct Node ｛int data;struct Node next;｝ Node;｀｀｀2、创建单链表｀｀｀具体编程语言Node createList(）｛Node head ＝ NULL;Node newNode;int data;printf(＂请输入节点数据（输入－1 结束）：＂）；scanf(＂％d"，＆data)；while （data!＝－1) ｛newNode ＝（Node ）malloc(sizeof(Node)）；newNode>data ＝ data;newNode>next ＝ NULL;if （head ＝＝ NULL) ｛head ＝ newNode;｝ else ｛Node temp ＝ head;while （temp>next!＝ NULL) ｛temp ＝ temp>next;｝temp>next ＝ newNode;｝printf(＂请输入节点数据（输入－1 结束）：＂）；scanf(＂％d"，＆data)；｝return head;｝｀｀｀3、插入节点在头部插入｀｀｀具体编程语言Node insertAtHead(Node head, int data) ｛Node newNode ＝（Node ）malloc(sizeof(Node)）；newNode>data ＝ data;newNode>next ＝ head;head ＝ newNode;return head;｝｀｀｀在尾部插入｀｀｀具体编程语言void insertAtTail(Node head, int data) ｛Node newNode ＝（Node ）malloc(sizeof(Node)）；newNode>data ＝ data;newNode>next ＝ NULL;Node temp ＝ head;while （temp>next!＝ NULL) ｛temp ＝ temp>next;｝temp>next ＝ newNode;｝｀｀｀在指定位置插入｀｀｀具体编程语言void insertAtPosition(Node head, int position, int data) ｛Node newNode ＝（Node ）malloc(sizeof(Node)）；newNode>data ＝ data;if （position ＝＝ 1) ｛newNode>next ＝ head;head ＝ newNode;return;｝Node temp ＝ head;int count ＝ 1;while （temp!＝ NULL ＆＆ count ＜ position 1) ｛temp ＝ temp>next;count+＋；｝if （temp ＝＝ NULL) ｛printf(＂位置无效\n"）；return;｝newNode>next ＝ temp>next;temp>next ＝ newNode;｝｀｀｀4、删除节点删除头部节点｀｀｀具体编程语言Node deleteAtHead(Node head) ｛if （head ＝＝ NULL) ｛printf(＂链表为空，无法删除\n"）；return NULL;｝Node temp ＝ head;head ＝ head>next;free(temp)；return head;｝｀｀｀删除尾部节点｀｀｀具体编程语言void deleteAtTail(Node head) ｛if （head ＝＝ NULL) ｛printf(＂链表为空，无法删除\n"）；return;｝Node prev ＝ NULL;Node temp ＝ head;while （temp>next!＝ NULL) ｛prev ＝ temp;temp ＝ temp>next;｝if （prev ＝＝ NULL) ｛head ＝ NULL;｝ else ｛prev>next ＝ NULL;｝free(temp)；｝｀｀｀删除指定节点｀｀｀具体编程语言void deleteNode(Node head, int data) ｛Node prev ＝ NULL;Node temp ＝ head;while （temp!＝ NULL ＆＆ temp>data!＝ data) ｛prev ＝ temp;temp ＝ temp>next;｝if （temp ＝＝ NULL) ｛printf(＂未找到要删除的数据\n"）；return;｝if （prev ＝＝ NULL) ｛head ＝ temp>next;｝ else ｛prev>next ＝ temp>next;｝free(temp)；｝｀｀｀5、查找节点｀｀｀具体编程语言Node search(Node head, int data) ｛Node temp ＝ head;while （temp!＝ NULL) ｛if （temp>data ＝＝ data) ｛return temp;｝temp ＝ temp>next;｝return NULL;｝｀｀｀6、打印单链表｀｀｀具体编程语言void printList(Node head) ｛Node temp ＝ head;while （temp!＝ NULL) ｛printf(＂％d ＂， temp>data)；temp ＝ temp>next;｝printf(＂＼n"）；｝｀｀｀五、实验结果1、成功创建了不同数据的单链表，并能够正确打印出链表中的数据。
单链表实验报告
单链表实验报告第一篇：单链表实验报告《数据结构》实验报告二分校：学号：日期：班级：姓名：程序名： L2311.CPP一、上机实验的问题和要求：单链表的查找、插入与删除。
设计算法，实现线性结构上的单链表的产生以及元素的查找、插入与删除。
具体实现要求：1.从键盘输入20个整数，产生带表头的单链表，并输入结点值。
2.从键盘输入1个整数，在单链表中查找该结点。
若找到，则显示“找到了”；否则，则显示“找不到”。
3.从键盘输入2个整数，一个表示欲插入的位置i，另一个表示欲插入的数值x，将x插入在对应位置上，输出单链表所有结点值，观察输出结果。
4.从键盘输入1个整数，表示欲删除结点的位置，输出单链表所有结点值，观察输出结果。
5.将单链表中值重复的结点删除，使所得的结果表中个结点值均不相同，输出单链表所有结点值，观察输出结果。
6.删除其中所有数据值为偶数的结点，输出单链表所有结点值，观察输出结果。
7.把单链表变成带表头结点的循环链表，输出循环单链表所有结点值，观察输出结果。
8.（★）将单链表分解成两个单链表A和B，使A链表中含有原链表中序号为奇数的元素，而B链表中含有原链表中序号为偶数的元素，且保持原来的相对顺序，分别输出单链表A和单链表B的所有结点值，观察输出结果。
二、程序设计的基本思想，原理和算法描述：（包括程序的结构，数据结构，输入/输出设计，符号名说明等）三、源程序及注释：四、运行输出结果：五、调试和运行程序过程中产生的问题及采取的措施：六、对算法的程序的讨论、分析，改进设想，其它经验教训：七、对实验方式、组织、设备、题目的意见和建议：第二篇：北邮数据结构实验报告单链表北京邮电大学数据结构试验报告实验名称：实验一线性表学生姓名：班级：班内序号：学号：日期： 2014年1月3日实验目的⌝熟悉C++语言的基本编程方法，掌握集成编译环境的调试方法⌝学习指针、模板类、异常处理的使用⌝掌握线性表的操作的实现方法⌝学习使用线性表解决实际问题的能力实验内容2.1题目1 根据线性表的抽象数据类型的定义，选择下面任一种链式结构实现线性表，并完成线性表的基本功能。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
湖南第一师范学院信息科学与工程系实验报告
课程名称：数据结构与算法成绩评定：
实验项目名称：单链表的基本操作指导教师：
学生姓名：沈丽桃学号： 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 identifier
error C4024:’printf’:different types for formal and actual parameter 1
error C4047:’function’:’const*differs in levers of indirection from ’int’error C2146:syntaxerror:missing’)’before identifier’option’
error C2017:illegal escape sequence
error C2059:syntax error:’)’
error C2143:syntax error:missing’)’before’%’
出现了很多错误，主要是因为printf里的一对双引号不是英文状态下的。
将双引号改好后，错误消失，输入时应注意细节，最好直接在编译环境下输程序
error C2043:illegal break
error C2043:illegal case
error C2198:’scanf’:too few actual parameters
这里是由于每一个case间应有缩进，或者用大括号括起来。
error C2065：’t’:undeclared identifier
warning C4047:’=’:’struct celltype*’differs in levers of indirection
这个错误是p->next=x,应改为p->element=x
error C2223:left of’->next’must point to struct/union
这里是由于t没有定义，还有最后一个语句后没有分号。
四、实验体会
注意细节，像拼写错误就该避免，要注意所有符号必须是英文状态下的。
所有变量必须定义清楚，在用switch语句时，注意每个case的写法，必要时用break跳出循环。
最好是用do来引导，注意括号的配对。
还有查插删操作的基本思想和程序思路，掌握量表操作的实质，灵活运用指针。
struct celltype*p不对，*前应空格。
还要多练习写程序，从C语言的基础开始，每一个知识都要掌握。