单链表基本操作实验
单链表的基本操作实验报告
单链表的基本操作实验报告单链表的基本操作实验报告引言：单链表是一种常见的数据结构，它由一系列节点组成，每个节点包含一个数据元素和一个指向下一个节点的指针。
在本次实验中，我们将学习和实践单链表的基本操作，包括创建链表、插入节点、删除节点以及遍历链表等。
一、实验目的本次实验的主要目的是掌握单链表的基本操作，包括链表的创建、插入节点、删除节点和遍历链表。
通过实践操作，加深对单链表的理解，并掌握如何应用单链表解决实际问题。
二、实验过程1. 创建链表首先，我们需要创建一个空链表。
链表可以通过一个头节点来表示，头节点不存储数据，只用于标识链表的起始位置。
我们可以定义一个指针变量head，将其指向头节点。
2. 插入节点在链表中插入节点是常见的操作。
我们可以选择在链表的头部、尾部或者指定位置插入节点。
插入节点的过程可以分为以下几个步骤：a. 创建一个新节点，并为其赋值；b. 找到要插入位置的前一个节点；c. 将新节点的指针指向前一个节点的下一个节点；d. 将前一个节点的指针指向新节点。
3. 删除节点删除节点是另一个常见的操作。
我们可以选择删除链表的头节点、尾节点或者指定位置的节点。
删除节点的过程可以分为以下几个步骤：a. 找到要删除节点的前一个节点；b. 将前一个节点的指针指向要删除节点的下一个节点；c. 释放要删除节点的内存空间。
4. 遍历链表遍历链表是为了查看链表中的元素。
我们可以从头节点开始，依次访问每个节点，并输出节点的值。
三、实验结果在本次实验中，我们成功完成了单链表的基本操作。
通过创建链表、插入节点、删除节点和遍历链表等操作，我们可以方便地对链表进行增删改查操作。
四、实验总结通过本次实验，我们对单链表的基本操作有了更深入的了解。
单链表是一种非常重要的数据结构，广泛应用于各个领域。
掌握了单链表的基本操作，我们可以更好地解决实际问题，并且为以后学习更复杂的数据结构打下坚实的基础。
在实验过程中，我们还发现了一些问题和不足之处。
单链表的基本操作实验报告
湖南第一师范学院信息科学与工程系实验报告课程名称：数据结构与算法成绩评定：实验项目名称：单链表的基本操作指导教师：学生姓名：沈丽桃学号： 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. 单链表的定义和初始化首先，我们需要定义一个单链表的结构，并初始化一个空链表。
链表的结构可以使用C语言中的结构体来表示，其中包含一个数据域和一个指向下一个节点的指针。
2. 插入操作在已有链表中插入一个新的节点，可以分为两种情况：在链表头部插入和在链表中间插入。
我们可以通过修改指针的指向来实现插入操作。
3. 删除操作删除链表中的一个节点，同样可以分为两种情况：删除头节点和删除中间节点。
删除操作需要注意指针的重新连接，以防止链表断裂。
4. 查找操作在链表中查找指定的元素，可以通过遍历链表的方式来实现。
从链表头开始，依次比较节点的数据域，直到找到目标元素或者遍历到链表尾部。
5. 其他操作在实际应用中，还可以对链表进行排序、逆序、合并等操作，这些操作都可以通过适当的算法来实现。
三、实验结果通过实际操作，我们验证了单链表的各种操作方法的正确性和效率。
在插入、删除和查找操作中，链表的时间复杂度为O(n)，其中n为链表的长度。
而在其他操作中，时间复杂度则根据具体算法的实现方式而定。
四、实验总结通过本次实验，我们深入了解了单链表的结构和操作方法，并通过实际操作来验证了其功能和效率。
单链表作为一种常用的数据结构，在实际应用中具有广泛的用途，例如链表可以用来实现栈、队列等其他数据结构，也可以用于解决一些实际问题，如链表的反转、环的检测等。
总之，掌握单链表的基本概念和操作方法对于学习和理解数据结构具有重要意义。
通过实验的方式，我们不仅能够加深对单链表的理解，还能够提高编程能力和解决实际问题的能力。
单链表的基本操作
单链表的基本操作一、实验目的1、掌握线性链表的操作特点，即指针是逻辑关系的映像。
2、掌握动态产生单链表的方法。
3、熟练掌握单链表的插入、删除操作特点，即指针赋值的先后次序。
4、熟练掌握单链表的取元素操作二、实验内容1、定义单链表类型并动态创建单链表2、实现线性表链式存储结构下元素的插入操作3、实现线性表链式存储结构下元素的删除操作4、实现线性表链式存储结构下取元素操作三、实验环境TC或VC++或Java四、实验步骤1、单链表的存储定义2、从键盘上依次输入21、18、30、75、42、56，逆序创建单链表，并输出单链表中的各元素值。
3、分别在单链表的第3个位置和第9个位置插入67和10，给出插入成功或失败的信息，并输出单链表中的各元素值。
4、删除单链表中的第6个数据元素和第8个数据元素，给出删除成功或失败的信息，并输出单链表中的各元素值。
5、取单链表中的第5个数据元素和第7个数据元素五、问题讨论1、单链表具有什么优缺点？2、单链表的定义与顺序表的定义有什么区别？3、逆序创建单链表有什么好处？4、为什么单链表中取元素、插入和删除操作在开始不判断给定位置i的合法性？5、如何改进单链表的定义，使其可以在操作前判断判断给定位置i的合法性？六、实验报告内容1、实验目的2、实验内容和具体要求3、完成情况和实验记录，实验记录为实验过程中遇到的问题及解决方法4、程序清单5、所输入的数据及相应的运行结果6、问题回答7、实验心得实验代码：#include<stdio.h>#include<stdlib.h>#include<malloc.h>#define ERROR 0;typedef struct LNode{int data;struct LNode *next;}LNode,*LinkList;LinkList InitList(LinkList L){LinkList node = NULL;node = (LinkList)malloc(sizeof(LNode));if(!node){return ERROR;}node->next = NULL;L = node;return L;}int ListLength(LinkList L){LinkList p = NULL;int count = 0;p = L;while(p->next){count++;p = p->next;}return count;}LinkList CreateList_L(LinkList L,int n){int i;LinkList p = NULL;for(i=n;i>0;i--){p = (LinkList)malloc(sizeof(LNode)); scanf("%d",&p->data);p->next = L->next;L->next = p;}return L;}LinkList ListInsert(LinkList L,int i,int e) {int j = 0;LinkList s = NULL,p = NULL;p = L;while(p&&j<i-1){p = p->next;j++;}if(!p||j>i-1){printf("输入的位置不合法！！！\n"); return L;}s = (LinkList)malloc(sizeof(LNode));s->data = e;s->next = p->next;p->next = s;return L;}LinkList ListDelete(LinkList L,int i){int j;LinkList q = NULL,p = NULL;p = L;j = 0;while(p->next&&j<i-1){p = p->next;j++;}if(!(p->next)||j>i-1){printf("输入的位置不合法！！！\n"); return L;}q = p->next;p->next = q->next;free(q);return L;}int GetElem(LinkList L,int i){int j,e;LinkList p = NULL;if(i<1||i>ListLength(L)){printf("输入的位置不合法！！！\n");return;}p = L->next;j = 1;while(j<i){p = p->next;j++;}e = p->data;printf("第%d位的数据元素为%d\n",i,e);}void menu(){printf("*************目录**************\n"); printf("输出单链表中的各元素值 1\n"); printf("在单链表中插入数据元素 2\n"); printf("在单链表中删除数据元素 3\n"); printf("取出单链表中的数据元素 4\n"); printf(" 结束程序 0\n"); printf("*******************************\n"); }void main(){int n,m,i,e;LinkList L = NULL,p = NULL;L = InitList(L);printf("请输入元素个数：");scanf("%d",&n);printf("依次输入%d个数据元素：",n);L = CreateList_L(L,n);do{printf("\n \n");menu();printf("请输入你的选择：");scanf("%d",&m);switch(m){case 1:printf("现在链表的元素为：");p = L->next;while(p!=NULL){printf("%d ",p->data);p = p->next;}printf("\n");break;case 2:printf("依次输入插入位置和数据元素(空格隔开)：");scanf("%d %d",&i,&e);L = ListInsert(L,i,e);break;case 3:printf("输入需要删除的元素的位置：");scanf("%d",&i);L = ListDelete(L,i);break;case 4:printf("输入需要取出的元素的位置：");scanf("%d",&i);GetElem(L,i);break;case 0:printf("已结束程序！！！\n"); break;default:printf("输入错误！！！\n"); }}while(m!=0);}。
数据结构单链表实验报告
数据结构单链表实验报告实验目的：掌握单链表的基本操作，学会使用单链表实现各种算法。
实验内容：实现单链表的基本操作，包括创建、插入、删除、访问等。
利用单链表完成以下算法：- 单链表逆序- 查找单链表中的中间节点- 删除单链表中的倒数第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指向的节点即为要删除的节点。
实验三 单链表的基本操作
实验三单链表的基本操作一、实验目的1、掌握线性表的链式存贮结构及基本操作，深入了解链表的基本特性，以便在实际问题背景下灵活运用它们。
2、巩固该存贮结构的构造方法，深入理解和灵活掌握链表的插入、删除等操作。
二、实验要求1、定义一链表类型，并定义带有头结点的单链表。
2、将教材中链表的建立、初始化、插入、删除等函数实现。
3、链表能够存储10名学生的基本信息（包括姓名、学号和成绩）。
4、由主函数按照用户要求对各个链表操作访问。
5、每操作之前要有明确的说明，操作后要输出操作结果。
6、分析顺序表链表的插入、删除、查找的时间和空间复杂度。
三、实验内容1、在自己的U盘的“姓名+学号”文件夹中创建“实验3”文件夹，本次实验的所有程序和数据都要求存储到本文件夹中。
2、完成链表操作的如下函数：单链表的建立、插入、删除#include<stdio.h>#include<stdlib.h>static int N=5;typedef struct _sy{ char name[12];int no;struct _sy *next;}stud;stud *Create(int m) //创建链表{ int i;stud *h,*p,*q;h=(stud*)malloc(sizeof(stud));if(h!=NULL){ p=h;for(i=0;i<m;i++){ q=(stud*)malloc(sizeof(stud));if(q!=NULL){ printf("依次输入第%d个人的姓名和学号：\n",i+1);scanf("%s%d",q->name,&q->no);q->next=NULL;p->next=q;p=q;}}}printf("\n");return(h);}stud *Delete(stud *sy,int post) //删除一个学生的数据{ int i;stud *cur,*pre;cur=sy;if(0==post){ return(sy);}else{ if(1==post){ cur=cur->next;sy->next=cur->next;free(cur);}else{ for(i=2;i<post+1;i++){ cur=cur->next;pre=cur;}cur=cur->next;pre->next=cur->next;free(cur);}return(sy); }}stud *Insert(stud *sy,int post) //插入一个新的学生的数据 { int i;stud *cur,*pre,*node;if(sy!=NULL){ cur=sy;node=(stud*)malloc(sizeof(stud));if(node!=NULL){ printf("请输入新人的姓名和学号：\n");scanf("%s%d",node->name,&node->no);if(1==post){ node->next=sy->next;sy->next=node;}else{ for(i=2;i<post+2;i++){ pre=cur;cur=cur->next;}node->next=pre->next;pre->next=node;}}}printf("\n");return(sy);}void Print(stud *sy) //输出学生信息{ int post=1;stud *cur;cur=sy->next;printf("当前的学生信息如下所示：\n");while(cur!=NULL){ printf("第%d个人的姓名是：%s，学号为：%d\n",post,cur->name,cur->no); cur=cur->next;post++;}N=--post;}int main(){ int mm,post,i;stud *head;head=Create(N);Print(head);for(i=0;i<1;i++){ printf("请输入要删除的学号的位置：\n");scanf("%d",&mm);Delete(head,mm);Print(head);printf("请输入要插入学号的位置：\n");scanf("%d",&post);Insert(head,post);Print(head);}return 0;}。
链表基本操作实验报告
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 指向新开辟的结点，并将元素存
放到新开辟结点的数据域，
数据结构单链表实验报告
数据结构单链表实验报告一、实验目的1、深入理解单链表的数据结构及其基本操作。
2、掌握单链表的创建、插入、删除、查找等操作的实现方法。
3、通过实际编程，提高对数据结构和算法的理解和应用能力。
二、实验环境1、操作系统：Windows 102、编程语言：C 语言3、开发工具：Visual Studio 2019三、实验原理单链表是一种常见的数据结构，它由一系列节点组成，每个节点包含数据域和指针域。
指针域用于指向下一个节点，从而形成链表的链式结构。
单链表的基本操作包括：1、创建链表：通过动态分配内存创建链表的头节点，并初始化链表为空。
2、插入节点：可以在链表的头部、尾部或指定位置插入新的节点。
3、删除节点：根据给定的条件删除链表中的节点。
4、查找节点：在链表中查找满足特定条件的节点。
四、实验内容（一）单链表的创建｀｀｀cinclude ＜stdioh>include ＜stdlibh>／／定义链表节点结构体typedef struct Node ｛int data;struct Node next;｝ Node;／／创建单链表Node createList(）｛Node head ＝（Node)malloc(sizeof(Node)）；if （head ＝＝ NULL) ｛printf(＂内存分配失败！＼n"）；return NULL;｝head>data ＝ 0;head>next ＝ NULL;return head;｝int main(）｛Node list ＝ createList(）；／／后续操作return 0;｝｀｀｀在创建单链表时，首先为头节点分配内存空间。
若内存分配失败，则提示错误信息并返回｀NULL`。
成功分配内存后，初始化头节点的数据域和指针域。
（二）单链表的插入操作插入操作分为三种情况：头部插入、尾部插入和指定位置插入。
1、头部插入｀｀｀cvoid insertAtHead(Node head, int data) ｛Node newNode ＝（Node)malloc(sizeof(Node)）；if （newNode ＝＝ NULL) ｛printf(＂内存分配失败！＼n"）；return;｝newNode>data ＝ data;newNode>next ＝ head>next;head>next ＝ newNode;｝｀｀｀头部插入时，创建新节点，将新节点的数据域赋值，并将其指针域指向原头节点的下一个节点，然后更新头节点的指针域指向新节点。
实验二 单链表基本操作
实验二单链表基本操作一、实验目的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);}}。
单链表的基本操作
实验二:单链表的基本操作编写一个完整的程序,实现单链表的建立、插入、删除、输出等基本操作。
(1)建立一个带头结点的单链表。
(2)计算单链表的长度,然后输出单链表。
(3)查找值为x的直接前驱结点q。
(4)删除值为x的结点。
(5)把单向链表中元素逆置(不允许申请新的结点空间)。
(6)已知单链表中元素递增有序,请写出一个高效的算法,删除表中所有值大于mink且小于maxk的元素(若表中存在这样的元素),同时释放被删结点空间,并分析你的算法的时间复杂度(注意:mink和maxk是给定的两个参变量,他们的值可以和表中的元素相同,也可以不同)。
(7)同(6)的条件,试写一高效的算法,删除表中所有值相同的多余元素(使得操作后的线性表中所有元素的值均不相同),同时释放被删结点空间,并分析你的算法时间复杂度。
(8)利用(1)建立的链表,实现将其分解成两个链表,其中一个全部为奇数,另一个全部为偶数(尽量利用已知的存储空间)。
(9)在主函数中设计一个简单的菜单,分别测试上述算法。
# include <stdio.h># include <stdlib.h>typedef struct node{int data;struct node * next;}Lnode, * LinkList;int m=sizeof(Lnode);//建立新的链表void Bulid_List(LinkList root){int num;LinkList s,p;s=root->next;int n;printf("请输入新建链表的长度n数据:\n"); scanf("%d",&n);printf("请依次建立链表:");for(int i=0;i<n;i++){scanf("%d",&num);s->data=num;p=(LinkList)malloc(m);s->next=p;s=p;s->next=NULL;}printf("链表已建立!\n");}//对链表的输出,包括长度和元素void OutPut_list(LinkList root) {int len=0;LinkList s;s=root->next;if(s->next==NULL)printf("单链表无数据,请先新建单链表。
实验二 单链表基本操作
实验二单链表基本操作一实验目的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。
单链表的操作实验报告
单链表的操作实验报告《单链表的操作实验报告》在计算机科学领域，数据结构是非常重要的基础知识之一。
而单链表作为一种常见的数据结构，经常被用来存储和操作数据。
在本次实验中，我们将对单链表的操作进行实验，并撰写实验报告以总结和分享我们的实验结果。
实验目的：1. 了解单链表的基本概念和操作方法。
2. 掌握单链表的插入、删除、查找等操作。
3. 通过实际操作加深对单链表的理解和掌握。
实验环境：1. 编程语言：C/C++2. 开发环境：Visual Studio Code3. 实验工具：GCC编译器实验步骤：1. 定义单链表的结构体，并实现初始化、插入、删除、查找等操作的函数。
2. 编写测试用例，对单链表的各种操作进行测试。
3. 分析实验结果，总结操作的时间复杂度和空间复杂度。
4. 撰写实验报告，分享实验过程和结果。
实验结果：经过实验，我们成功实现了单链表的初始化、插入、删除、查找等操作，并对这些操作进行了充分的测试。
我们发现单链表的插入和删除操作的时间复杂度为O(1)，而查找操作的时间复杂度为O(n)，其中n为链表的长度。
这些结果与我们的预期相符合，说明我们对单链表的操作有了较好的掌握。
实验总结：通过本次实验，我们不仅加深了对单链表的理解，还提高了编程能力和数据结构的应用能力。
我们对单链表的操作有了更深入的了解，为以后在实际项目中应用单链表打下了良好的基础。
结语：单链表作为一种常见的数据结构，在实际应用中具有重要的作用。
通过本次实验，我们对单链表的操作有了更深入的了解，相信在以后的学习和工作中能够更好地应用和运用单链表。
希望本次实验报告能够对读者有所帮助，也欢迎大家对实验结果进行讨论和交流。
单链表的操作实验报告
单链表的操作实验报告单链表的操作实验报告引言：单链表是一种常见的数据结构，它由一系列节点组成，每个节点包含数据和指向下一个节点的指针。
在本次实验中，我们将学习如何使用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);```四、单链表的查找操作查找操作是在单链表中查找指定数据的节点。
单链表操作实验报告
单链表基本操作报告姓名：张航学号：201100814205辅导老师：高艳霞实验日期：2012.09.27实现单链表的各种基本运算一、实验目的1、帮助读者复习C++语言程序设计中的知识。
2、熟悉线性表的逻辑结构。
3、熟悉线性表的基本运算在两种存储结构上的实现，其中以熟悉链表的操作为侧重点。
二、实验内容单链表的基本操作实现带头结点的单链表的建立、求长度，取元素、修改元素、插入、删除等单链表的基本操作。
三、实验步骤1.程序源码#include<stdio.h>#include<stdlib.h>#define LEN sizeof(linklist)#define NULL 0typedef struct nodeint data; /*结点的数据域*/struct node *next; /*结点的指针域*/}linklist;linklist *Linkcreat() /*建立单链表函数*/{int x;linklist *head,*p,*rear;printf("\t你选择的是尾插法建立链表功能：\n");head=(struct node*)malloc(LEN);head->data=-999; /* rear=head; / printf("\t请输入一组正整数以0结束输入：\n\t");scanf("%d",&x);while(x!=0){p=(struct node*)malloc(LEN); /*生成一个新结点*/p->data=x;rear->next=p; /*新结点插入到表尾*rear之后*/rear=p;scanf("%d",&x);}rear->next=NULL;printf("\t建立链表成功！\n");return(head);}void Linksearch(linklist *head) /*查找单链表结点函数*/ {int x;int i=0;linklist *p;printf("\t你选择的是查找功能：\n");printf("\t请输入要查找节点的值：");scanf("%d",&x);p=head;while((p->next!=NULL)&&(p->data!=x)){p=p->next;i++;}if(p->data==x){printf("\t查找成功！\n");printf("\t输出查找的数据所在位置为:%d\n",i);}else printf("\t查找结点不存在！\n");}linklist *Linkinsert(linklist *head) /*单链表结点插入函数*/ {int x,i,j=1;linklist *s,*q;printf("\t你选择的是尾插法插入功能：\n");printf("\t请输入要插入的位置：");scanf("%d",&i);printf("\t请输入要插入的数据：");scanf("%d",&x);s=(struct node*)malloc(LEN); /*建立插入数据的结点*/s->data=x;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);}linklist *Linkdelete(linklist *head) /*删除单链表结点函数*/ {linklist *p,*q;int i,j=1;printf("\t输入要删除的位置："); /*输入删除的位置*/scanf("%d",&i);p=head;while((p->next!=NULL)&&(j<i){p=p->next;j++;}if(p->next!=NULL) /*若该结点存在删除该结点*/ {q=p->next;printf("\t删除成功！\n");printf("\t删除的数据为：");printf("%d\n",q->data); /*输出删除结点数据*/p->next=q->next;free(q); /*释放删除结点空间q*/ }else printf("\t删除失败！");return(head);}void Linkprint(linklist *head) /*输出单链表函数*/{linklist *p;p=head;if(p==NULL)printf("\t输出失败！\n");printf("\t输出链表为：");while(p->next!=NULL){p=p->next;printf("%3d",p->data);}printf("\n");}int Select() /*菜单显示函数*/ {int k;printf(" -------------------------------\n");printf("\t1.建立单链表\n");printf("\t2.查找单链表\n");printf("\t3.插入结点\n");printf("\t4.删除结点\n");printf("\t5.输出单链表\n");printf("\t6.退出\n");do{printf("\t请输入选择的功能：");scanf("%d",&k); /*输入选择的功能*/ printf(" -------------------------------\n");}while((k<1)||(k>6));return(k);}void main() /*主函数*/{int n;linklist *head;while(1){n=Select(); /*输入选择功能*/switch(n){case 1:head=Linkcreat();Linkprint(head);break; /*建立单链表函数*/case 2:Linksearch(head);break; /*建立单链表函数*/case 3:head=Linkinsert(head);Linkprint(head);break; /*单链表结点插入函数*/ case 4:head=Linkdelete(head);Linkprint(head);break; /*删除单链表结点函数*/ case 5:Linkprint(head);break; /*输出单链表函数*/case 6:exit(0);}}2.运行程序}四、实验总结（结果分析和体会）通过本次实验我对链表有了更深的了解，对链表的插删操作、遍历、查找等基本上掌握了。
实验二 单链表操作
注意事项：在磁盘上创建一个目录，专门用于存储数据结构实验的程序。
因为机房机器有还原卡，请同学们将文件夹建立在最后一个盘中，以学号为文件夹名。
实验二单链表操作一、实验目的掌握单链表的基本操作：插入、删除、查找等运算。
二、实验要求1．认真阅读和掌握单链表相关操作的算法。
2．将操作函数的算法转成程序并运行（将函数剩余部分补齐）。
三、实验内容程序1：线性单链表基本操作的实现（以带头结点的单链表为例）实现单链表的创建、插入、删除和查找。
参考程序如下：#include<iostream.h>#include<malloc.h>#include<conio.h>#define ERROR 0#define OK 1typedef int ElemType;struct LNODE{ElemType data;struct LNODE *next;};typedef struct LNODE LNode;typedef struct LNODE *LinkList;//初始化单链表int init(LinkList &L){L=(LNode *)malloc(sizeof(LNode));if(!L) return(ERROR);L->next=NULL;return OK;}/*init *///求表长int ListLength(LinkList L){}//获取表中第i个元素的值int GetElem(LinkList L,int i,ElemType &e) {}//确定元素e在该链表中的位序int LocateElem(LinkList La,ElemType e){LinkList p;p=La;int i=0;while(p->next){p=p->next;i++;if(p->data==e)return i;}return 0;}//打印表中元素值void PrintList(LinkList L){LinkList p;p=L;while(p->next){p=p->next;cout<<p->data<<ends;}cout<<endl;}//插入操作int ListInsert(LinkList &L,int i,ElemType e) {}/*ListInsert Before i *///删除操作Int ListDelete(LinkList &L,int i,ElemType &e) {}//建表（头插法或尾插法都可）int CreateList(LinkList &L,int n){}//合并两个有序表void MergeList(LinkList La,LinkList Lb,LinkList &Lc){}void main(){LinkList La,Lb,Lc;ElemType e;cout<<"\n\n-------------------List Demo is running...----------------\n\n";cout<<"First is InsertList function.\n";init(La);int n;cout<<"请输入La表中元素个数:";cin>>n;cout<<endl<<"请输入"<<n<<"个元素值：";CreateList(La,n);PrintList(La);cout<<"La的表长为："<<ListLength(La)<<endl;//取值cout<<"取第i位元素的值：\n请输入位序：";cin>>n;GetElem(La,n,e);cout<<endl<<"第"<<n<<"位元素的值为："<<e<<endl;//定位cout<<"定位操作：\n请输入要查找的元素:";cin>>e;cout<<endl<<" 所要查找的元素在表中第"<<LocateElem(La,e)<<"位\n"; //删除cout<<"删除操作：\n输入要删除元素的位序：";cin>>n;ListDelete(La,n,e);cout<<"\n要删除的元素值为："<<e<<endl;cout<<"删除后表中值有："PrintList(La);init(Lb);cout<<"请输入Lb表中元素个数:";cin>>n;cout<<endl<<"请输入"<<n<<"个元素值：";CreateList(Lb,n);PrintList(Lb);cout<<"Lb的表长为："<<ListLength(Lb)<<endl; cout<<"合并两个有序表：\n";MergeList(La,Lb,Lc);PrintList(Lc);getch();}。
实验1_单链表操作
实验1：单链表操作1.1验证性实验一. 实验目的掌握握单链表的基本操作：插入、删除、查找等运算。
二. 实验内容与要求【任务一】：阅读理解阅读后面的程序，并将其输入到计算机中。
程序中存在一些错误，将其调试、修改成功，运算出结果。
这个程序中我们以模板方式实现了一个单链表类的部分功能，演示了单链表的创建、插入、和拼接操作。
实验说明：①实验用的程序设计语言不限，可以用C/C++语言，也可以使用java语言②如果使用C/C++语言，开发环境建议使用VC 6.0②建议使用java语言//////////////////////////#include//单链表程序如下：templateclass Lnode{public:T data;Lnode *next;Lnode(): next(0){};Lnode(T d): data(d),next(0){};Lnode(T d,Lnode *nxt): data(d),next(nxt){ };};///////////////////////////////////////////////templateclass List{protected:Lnode *first;int num;public://......void Printlist(){Lnode<int> *p=first;while(p){cout<<p->data<<" "; p=p->next;}cout<<endl;}void main() {List<int> list;list.Insert(10);list.Insert(8);list.Insert(15);list.Insert(5);list.Insert(2);list.Printlist();}【任务二】：完善功能在上面所给的类List 中加入下面三个函数，并在主函数中完成对你所添加函数的测试 //void copy (list &L); 将L 所表示的链表复制到当前链表//void sort(); 对链表进行排序//void reverse(); 对链表进行逆转1.2 设计性实验【问题描述】：任意给定两个多项式,例如：()()101045201085235235101++++=+++=x x x x x p x x x x p则，)(1x p 与)(2x p 相加后的结果为：()30101413523510+++++=x x x x x x p【实现提示】① 多项式“项”的表示。
数据结构 实验二：单链表的基本操作
数据结构实验二：单链表的基本操作数据结构实验二：单链表的基本操作实验二：单链表的基本操作一、【实验目的】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);}。
单链表的基本操作实验问题与对策
【单链表的基本操作实验问题与对策】01. 简介在计算机科学领域，数据结构是学习和理解的重要基础，而单链表作为其中的一种基本数据结构，在学习过程中通常需要进行一些操作实验。
然而，很多学生在进行单链表的基本操作实验时会遇到一些问题，本文将对这些问题进行全面评估，并提出对策，帮助读者更好地理解和掌握单链表的基本操作。
02. 常见问题在进行单链表的基本操作实验时，学生常常会遇到以下一些问题：- 对单链表的基本概念理解不深：学生可能对单链表的定义、结构和操作方法理解不够透彻，导致在实验中无法正确编写相关代码。
- 插入、删除和查找操作的实现困难：学生在实验中往往会遇到关于单链表插入、删除和查找等操作的实现困难，无法正确理解和编写相关算法。
03. 对策建议针对上述问题，本文提出以下对策建议：- 加强基础知识的学习：在进行单链表操作实验之前，学生首先应加强对单链表的基本概念的学习，包括单链表的定义、结构、操作方法等，以确保对单链表有一个清晰透彻的理解。
- 多实践、多编程：学生在进行实验的过程中，应多进行实践操作，多编写单链表操作的相关代码，熟练掌握插入、删除和查找等操作的实现方法，加深对单链表操作的理解和掌握。
- 多思考、多讨论：在实验中，学生还应不断思考和讨论单链表操作的相关问题，尝试寻找不同的解决方法和思路，加深对单链表操作问题的理解和掌握。
04. 个人观点和理解对于单链表的基本操作问题，我个人认为加强基础知识的学习是至关重要的，只有对单链表的基本概念有一个清晰透彻的理解，才能更好地解决在实验中遇到的各类问题。
多实践、多编程也是非常重要的，只有通过不断的实践操作和编写代码，才能更好地掌握单链表的基本操作，提高解决问题的能力和水平。
总结通过对单链表的基本操作实验问题的全面评估，并提出对策建议，希望能帮助学生更好地理解和掌握单链表的基本操作，提高实验的效果和水平。
至此，我们共享了解单链表的基本操作实验问题和对策建议，希望对您有所帮助。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
实验2 链表的操作实验容：1）基础题：编写链表基本操作函数，链表带有头结点（1）CreatList_h()//用头插法建立链表（2）CreateList_t()//用尾插法建立链表（3）InsertList（）向链表的指定位置插入元素（4）DeleteList（）删除链表中指定元素值（5）FindList（）查找链表中的元素（6）OutputList（）输出链表中元素2）提高题：（1）将一个头节点指针为heada的单链表A分解成两个单链表A和B，其头结点指针分别为heada和headb，使得A表中含有原单链表A中序号为奇数的元素，B表中含有原链表A中序号为偶数的元素，且保持原来的相对顺序。
（2）将一个单链表就地逆置。
即原表（a1，a2，。
an），逆置后新表（an，an-1，。
a1）/*程序功能 :单链表基本功能操作编程者 :天啸日期 :2016-04-14版本号 :3.0*/#include <stdio.h>#include <stdlib.h>typedef struct List{int data;struct List *next;}List;void CreatList_h(List *L) //头插法{int i = 0;int n = 0;int goal;List *p;printf("请输入数据的个数:\n");scanf("%d",&n);L -> next = NULL;for(i=0;i<n;i++){printf("请输入第%d个数:\n",i+1);scanf("%d",&goal);p = (struct List*)malloc(sizeof(struct List));p -> data = goal;p -> next = L->next; //将L指向的地址赋值给p;L -> next = p;}}void CreateList_t(List *L) //尾插法{int i;int n;int goal;List *p;List *q=L;printf("请输入数据的个数:\n");scanf("%d",&n);for (i=0;i<n;i++){printf("请输入第%d个数:\n",i+1);scanf("%d",&goal);p = (struct List*)malloc(sizeof(struct List));p -> data = goal;q -> next = p;q = p;}q -> next = NULL;}void InsList(List *L,int i,int e) //插入{List *s;List *p = L;int j = 0;while (p&&j<i-1){p = p->next;++j;}s = (struct List*)malloc(sizeof(struct List));s -> data = e; //插入L中s -> next = p -> next;p -> next = s;return ;}void DeleteList(List*L,int e) //删除{List *q;List *p = L;while (p->next&&p->next->data!=e){p = p -> next;}if (!(p->next)){printf("不存在该元素!\n");exit(0);}q = p -> next;p -> next = q->next;e = q -> data;free(q);return ;}void FindList(List*L,int e) //查找元素{int j = 1;List *p = L->next;while (p&&p->data!=e){p = p->next;++j;}if (!p){printf("不存在该元素!\n");exit(0);}printf("您查找的元素位置为：%d\n",j);return ;}void DisPlay(List *L) //输出链表{List *p = L->next;printf("您输入的数据为：\n");while (p!=NULL){printf ("%d ",p->data);p = p -> next;}printf("\n");}void Inverse(List*L) //单链表就地逆置{List *q;List *p = L->next;L -> next = NULL;while (p != NULL){q = p -> next; //q指针保留原链表当前处理节点的下一个节点p -> next = L -> next; //将当前处理节点p插入到逆置L的表头L -> next = p;p = q; //p指向下一个待插入的节点}}void DisCreat(List*L) //链表拆分{int i = 0; //i记录表A中结点的序号List *p;List *B = (struct List*)malloc(sizeof(struct List)); //创建 B 表表头B -> next = NULL; //B表初始化List*ra = L,*rb = B; //ra和rb将分别指向将创建的A 表和B表的尾结点p = L -> next; //p指向待处理的结点L -> next = NULL; //置空新的 A 表 while (p != NULL){i++; //序号加 1if (i%2 == 0){ //处理序号为偶数的链表结点rb -> next = p; // 若B表尾描入新结点rb = p; //rb指向新的尾结点}else{ //处理原序号为奇数的结点ra -> next = p; //在A表尾插入新结点ra = p;}p = p->next; //将p指向新的待处理结点}ra -> next = NULL;rb -> next = NULL;p = L -> next;printf("奇数位数据为：\n"); //输出奇数位数据while (p != NULL){printf ("%d ",p -> data);p = p -> next;}printf("\n");List *q = B->next;printf("偶数位数据为：\n"); //输出偶数位数据while(q != NULL){printf ("%d ",q->data);q = q -> next;}printf("\n");return ;}int main(){int n;int i;int e;int No;List*L = (struct List*)malloc(sizeof(struct List));List*B = (struct List*)malloc(sizeof(struct List));char yes_no = 'y';while(yes_no=='y'||yes_no=='Y') //循坏开始{system("cls");printf("\t\t\t|---------------------------------|\n"); //交互式界面printf("\t\t\t| 单链表基本操作 |\n");printf("\t\t\t|---------------------------------|\n");printf("\t\t\t| 1---头插法建立链表 |\n");printf("\t\t\t| 2---尾差法建立链表 |\n");printf("\t\t\t| 3---指定位置插入 |\n");printf("\t\t\t| 4---指定元素删除 |\n");printf("\t\t\t| 5---查找链表元素 |\n");printf("\t\t\t| 6---输出链表元素 |\n");printf("\t\t\t| 7---单链表就地逆置 |\n");printf("\t\t\t| 8---单链表拆分 |\n");printf("\t\t\t| 0---退出 |\n");printf("\t\t\t|---------------------------------|\n");printf("\t\t\t| 计科14-2 第5组^_^|\n");printf("\t\t\t|---------------------------------|\n");printf("请选择运算方式:\n");scanf ("%d",&No);switch(No){case 1:{CreatList_h(L);DisPlay(L);break;}case 2:{CreateList_t(L);DisPlay(L);break;}case 3:{printf("请输入需要插入元素的位置:\n");scanf("%d",&i);printf("请输入需要插入的元素:\n");scanf("%d",&e);InsList(L,i,e);DisPlay(L);break;}case 4:{printf("请输入需要删除的元素:\n");scanf("%d",&e);DeleteList(L,e);DisPlay(L);break;}case 5:{printf("请输入需要查找的元素:\n");scanf("%d",&e);FindList(L,e);DisPlay(L);break;}case 6:{DisPlay(L);break;}case 7:{Inverse(L);DisPlay(L);break;}case 8:{DisCreat(L);break;}case 0:system("cls");printf("\n\n\n\t\t\t尚有很多不足之处，望多多指教!");exit(0);break;default:printf(" 请输入正确的数字。