数据结构与算法单链表的实现
数据结构实验报告--单链表
数据结构实验报告--单链表数据结构实验报告--单链表1.引言1.1 研究目的本实验旨在通过实践的方式，深入了解单链表的数据结构以及相关操作，提升对数据结构的理解和应用能力。
1.2 实验内容本实验主要包括以下几个方面的内容：●单链表的基本定义和实现●单链表的插入、删除、遍历操作●单链表的逆置操作●单链表的查找和修改操作2.理论基础2.1 单链表的定义单链表是一种常见的线性数据结构，它由一系列的节点组成，每个节点包含数据和指向下一个节点的指针。
2.2 单链表的基本操作①单链表的插入操作在单链表中，可以通过插入操作在指定位置插入一个新节点，该操作主要包括以下步骤：●创建一个新的节点，并为其赋值●将新节点的next指针指向插入位置的后一个节点●将插入位置的前一个节点的next指针指向新节点②单链表的删除操作在单链表中，可以通过删除操作删除指定位置的节点，该操作主要包括以下步骤：●将删除位置的前一个节点的next指针指向删除位置的后一个节点●释放删除节点的内存③单链表的遍历操作单链表的遍历操作主要是依次访问链表中的每一个节点，并执行相应的操作。
④单链表的逆置操作单链表的逆置操作可以将一个单链表中的节点顺序进行颠倒。
⑤单链表的查找操作在单链表中，可以通过查找操作找到指定值的节点。
⑥单链表的修改操作在单链表中，可以通过修改操作修改指定位置的节点的值。
3.实验过程3.1 实验环境本次实验使用C语言进行编程，需要先安装相应的编程环境，如gcc编译器。
3.2 实验步骤①单链表的创建和初始化首先创建一个空链表，并初始化链表的头指针。
②单链表的插入操作按照需求，在链表的指定位置插入一个新节点。
③单链表的删除操作按照需求，删除链表中的指定位置的节点。
④单链表的遍历操作依次访问链表中的每一个节点，并输出其值。
⑤单链表的逆置操作将单链表中的节点顺序进行逆置。
⑥单链表的查找操作按照需求，在链表中查找指定值的节点。
3.2.7 单链表的修改操作按照需求，修改链表中指定位置的节点的值。
数据结构与算法——单链表的实现及原理
数据结构与算法——单链表的实现及原理1. 单链表的原理 链表是线性表的链式存储⽅式，逻辑上相邻的数据在计算机内的存储位置不必须相邻，那么怎么表⽰逻辑上的相邻关系呢？可以给每个元素附加⼀个指针域，指向下⼀个元素的存储位置。
如图所⽰： 从图中可以看出,每个结点包含两个域：数据域和指针域，指针域存储下⼀个结点的地址，因此指针指向的类型也是结点类型链表的核⼼要素：Ø 每个节点由数据域和指针域组成 Ø 指针域指向下⼀个节点的内存地址。
1.1 结构体定义1 Typedef struct LinkNode2 {3 ElemType data; //节点中存放数据的类型4struct LinkNode* next; //节点中存放下⼀节点的指针5 }LinkList, LinkNode;2. 单链表初始化链表的节点均单向指向下⼀个节点，形成⼀条单向访问的数据链1//单链表的初始化2 typedef struct _LinkNode3 {4int data; //结点的数据域5struct _LinkNode* next; //结点的指针域6 }LinkNode, LinkList; //链表节点、链表78bool InitList(LinkList*& L) //构造⼀个空的单链表 L9 {10 L = new LinkNode; //⽣成新结点作为头结点，⽤头指针 L 指向头结点11if(!L)return false; //⽣成结点失败12 L->next=NULL; //头结点的指针域置空13return true;14 }3. 单链表增加元素 - 单链表前插法插⼊节点的要素就是要找到要插⼊位置的前⼀个节点，将这个节点的Next赋值给新节点，然后将新节点的地址赋值给前⼀个节点的Next便可，任意位置插⼊和前插法均是如此。
1//前插法2bool ListInsert_front(LinkList * &L, LinkNode * node) //参数1 链表指针参数2 要插⼊的节点元素3 {4if (!L || !node) return false; //如果列表或节点为空返回 false5 node->next = L->next; //将头节点指向节点1的地址赋值给要插⼊节点的指针域，使要插⼊的节点先与后部相连6 L->next = node; //将插⼊节点的地址赋值给头结点的指针域，使要插⼊节点与头结点相连78return true;9 }4. 单链表增加元素 - 单链表尾插法1//尾插法2bool ListInsert_back(LinkList*& L, LinkNode* node)3 {4 LinkNode* last = NULL; //创建空指针，5if (!L || !node) return false; //如果列表或节点为空返回 false67 last = L;8while (last->next) last = last->next; //使⽤ last 找到最后⼀个节点910 node->next = NULL; //要插⼊节点由于在尾部，指针域置为 NULL11 last->next = node; //将要插⼊节点的地址赋值给之前的尾部节点的指针域，将要插⼊节点放置到尾部12return true;13 }5. 单链表增加元素 - 单链表任意位置插⼊插⼊节点的要素就是要找到要插⼊位置的前⼀个节点，将这个节点的Next赋值给新节点，然后将新节点的地址赋值给前⼀个节点的Next便可，任意位置插⼊和前插法均是如此。
数据结构单链表实验报告
数据结构单链表实验报告实验目的：掌握单链表的基本操作，学会使用单链表实现各种算法。
实验内容：实现单链表的基本操作，包括创建、插入、删除、访问等。
利用单链表完成以下算法：- 单链表逆序- 查找单链表中的中间节点- 删除单链表中的倒数第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）void InitList(LinkNode *&L)//初始化线性表{L=(LinkNode *)malloc(sizeof(LinkNode)); //创建头结点L->next=NULL;//单链表置为空表}void DestroyList(LinkNode *&L)//销毁线性表{LinkNode *pre=L,*p=pre->next;实验截图（2）bool GetElem(LinkNode *L,int i,ElemType &e) //求线性表中第i个元素值{ int j=0;if (i<=0) return false;//i错误返回假LinkNode *p=L;//p指向头结点,j置为0(即头结点的序号为0) while (j<i && p!=NULL)//找第i个结点p{ j++;p=p->next;}if (p==NULL)//存在值为e的结点,返回其逻辑序号ireturn(i);}实验截图（3）bool ListInsert(LinkNode *&L,int i,ElemType e) //插入第i个元素{ int j=0;if (i<=0) return false;//i错误返回假LinkNode *p=L,*s;//p指向头结点,j置为0(即头结点的序号为0) while (j<i-1 && p!=NULL)//查找第i-1个结点p{ j++;p=p->next;}}实验截图（4）编写exp2-2.cpp程序包含有关代码//文件名:exp2-2.cpp#include "linklist.cpp"int main(){LinkNode *h;ElemType e;printf("单链表的基本运算如下:\n");printf(" (1)初始化单链表h\n");InitList(h);printf(" (2)依次采用尾插法插入a,b,c,d,e元素\n");return 1;}实验截图（5）运行得到结果实验截图（6）。
算法与数据结构实验报告
2015-2016学年第二学期《算法与数据结构》课程实验报告专业软件工程学生姓名成晓伟班级软件141学号1410075094实验学时16实验教师徐秀芳信息工程学院实验一单链表的基本操作一、实验目的1.熟悉C语言上机环境，进一步掌握C语言的基本结构及特点。
2.掌握线性表的各种物理存储表示和C语言实现。
3.掌握单链表的各种主要操作的C语言实现。
4.通过实验理解线性表中的单链表存储表示与实现。
二、主要仪器及耗材普通计算机三、实验内容与要求1、用C语言编写一个单链表基本操作测试程序。
（1）初始化单链表（2）创建单链表（3）求单链表长度（4）输出单链表中每一个结点元素（5）指定位置插入某个元素（6）查找第i个结点元素的值（7）查找值为e 的结点，并返回该结点指针（8）删除第i个结点（9）销毁单链表2、实验要求（1）程序中用户可以选择上述基本操作。
程序启动后，在屏幕上可以菜单形式显示不同功能，当按下不同数字后完成指定的功能，按其他键，则显示错误后重新选择。
（2）要求用线性表的顺序存储结构，带头结点的单链表存储结构分别实现。
（3）主函数实现对基本操作功能的调用。
3、主要代码（1）初始化单链表LinkList *InitList(){ //创建一个空链表,初始化线性表LinkList *L;L=(LinkList *)malloc(sizeof(LinkList));L->next=NULL;return L;}（2）创建单链表//头插法void CreateListF(LinkList *L){LinkList *s;int i=1,a=0;while(1){printf("输入第%d个元素(0表示终止)",i++);scanf("%d",&a);if(a==0)break;s=(LinkList *)malloc(sizeof(LinkList));s->data=a;s->next=L->next;L->next=s;}}（3）求链表长度int ListLength(LinkList *L){ //求链表长度int n=0;LinkList *p=L;while(p->next!=NULL){p=p->next;n++;}return(n);}（4）在指定位置插入元素int InsertList(LinkList *L,int i,ElemType e){LinkList *p=L,*s;int j=0;while(p!=NULL&&j<i-1){p=p->next;j++;} //找出要插入的位置的前一个位置if(p==NULL){return 0;}else{s=(LinkList *)malloc(sizeof(LinkList));s->data=e;s->next=p->next;p->next=s;return 1;}}（5）输出链表void DispList(LinkList *L){ //输出链表LinkList *p=L->next;while(p!=NULL){printf("%d",p->data);p=p->next;}printf("\n");}（6）查找链表中指定元素int GetElem(LinkList *L,int i){ //查找链表中指定元素LinkList *p=L;int j=0;while(j<i&&p!=NULL){j++;p=p->next;}if(p==NULL){return 0;}else{return p->data;}}（7）查找值是e的结点并返回该指针LinkList *LocateElem(LinkList *L,ElemType e){ //查找值是e的结点并返回该指针int i=1;LinkList *p=L;while(p!=NULL)if(p->data==e) return p;}if(p==NULL){return NULL;}}（8）删除元素int ListDelete(LinkList *L,int i,ElemType *e){ //删除元素LinkList *p=L,*q;int j=0;while(p!=NULL&&j<i-1){p=p->next;j++;} //找到要删除元素地址的前一个地址if(p==NULL){ return 0;} //不能删除else{q=p->next;*e=q->data;p->next=q->next;free(q); //删除成功return 1;}}（9）销毁链表void DestroyList(LinkList *L){//销毁链表LinkList *pre=L,*p=L->next;while(p!=NULL){free(pre);pre=p;p=pre->next;}free(pre);}main函数：int main(){LinkList *L;ElemType e;int i;L=InitList();CreateListF(L);DispList(L);printf("输入要查找的元素位置:\n");scanf("%d",&i);e=GetElem(L,i);printf("%d\n",e);printf("单链表长度为:%d\n",ListLength(L));printf("输入要删除元素的位置:");scanf("%d",&i);if (i>ListLength(L)){printf("超出范围重新输入");scanf("%d",&i);}if(ListDelete(L,i,&e)==0){printf("未找到元素\n");}else DispList(L);printf("输入插入元素的位置和值:");scanf("%d%d",&i,&e);InsertList(L,i,e);DispList(L);return 0;}4、测试数据及测试结果输入：23 56 12 28 45输出：四、注意事项1、存储结构定义和基本操作尽可能用头文件实现。
数据结构-单链表实验报告
单链表实验报告一、实验目的1、帮助读者复习C++语言程序设计中的知识。
2、熟悉线性表的逻辑结构。
3、熟悉线性表的基本运算在两种存储结构上的实现，其中以熟悉链表的操作为侧重点。
二、实验内容[问题描述]实现带头结点的单链表的建立、求长度，取元素、修改元素、插入、删除等单链表的基本操作。
[基本要求]（1）依次从键盘读入数据，建立带头结点的单链表；（2）输出单链表中的数据元素（3）求单链表的长度；（4）根据指定条件能够取元素和修改元素；（5）实现在指定位置插入和删除元素的功能。
三、算法设计（1）建立带表头结点的单链表；首先输入结束标志，然后建立循环逐个输入数据，直到输入结束标志。
（2）输出单链表中所有结点的数据域值；首先获得表头结点地址，然后建立循环逐个输出数据，直到地址为空。
（3）输入x,y在第一个数据域值为x的结点之后插入结点y，若无结点x，则在表尾插入结点y;建立两个结构体指针，一个指向当前结点，另一个指向当前结点的上一结点，建立循环扫描链表。
当当前结点指针域不为空且数据域等于x的时候，申请结点并给此结点数据域赋值为y，然后插入当前结点后面，退出函数；当当前结点指针域为空的时候，申请结点并给此结点数据域赋值为y，插入当前结点后面，退出函数。
（4）输入k，删除单链表中所有的结点k，并输出被删除结点的个数。
建立三个结构体指针，一个指向当前结点，另一个指向当前结点的上一结点，最后一个备用；建立整形变量l=0；建立循环扫描链表。
当当前结点指针域为空的时候，如果当前结点数据域等于k，删除此结点，l++，跳出循环，结束操作；如果当前结点数据域不等于k，跳出循环，结束操作。
当当前结点指针域不为空的时候，如果当前结点数据域等于k，删除此结点，l++，继续循环操作；如果当前结点数据域不等于k，指针向后继续扫描。
循环结束后函数返回变量l的值，l便是删除的结点的个数。
四、实验结果1、新建一个链表：2、输出链表的数据：（4）插入数据：在数据为3后面插入一个数据100：（5）删除数据：删除刚刚插入的数据100：五、总结实验之前由于准备不够充分，所以堂上实验时只完成了建立单链表和数据的输出，而后面两个实验要求也是用来很多时间长完成的。
单链表数据结构
插入
if (p != NULL && j == i-1) { // 找到第i个结点
s = (LinkList) malloc ( sizeof (LNode)); // 生成新结点
s->data = e;
// 数据域赋值
s->next = p->next; //新结点指针指向后一结点
p->next = s; return OK;
6、销毁
4.6 销毁操作
while(L) { p = L->next; free(L); L=p;
// p指向第一结点(头节点为“哑结点”) // 释放首结点 // L指向p
}
// 销毁完成后，L为空(NULL)
算法的时间复杂度为：O(ListLength(L))
判空 求表长
4.7 其它操作
if(L->next==NULL) return TRUE; // 空
5、清空
4.5 清空操作
while (L->next) { p = L->next; L->next = p->next; free(p);
// p指向当前结点 // 头结点指向当前结点的后结点 // 释放当前结点内存
}
// 清空完成后，仍保留头结点L
算法的时间复杂度为：O(ListLength(L))
点。
5.1.2 逆序建立单链表
①建立一个带头结点的空单链表；
②输入数据元素ai，建立新结点p， 并把p插入在头结点之后成为第一个 结点。
③重复执行②步，直到完成单链表的 建立。
a1
a2 a1
创建出来的链表 点顺序与插入操作
顺序相反。
数据结构算法经典 -单链表
case 4:
{
printf("请输入要删除的结点: ");
scanf("%d",&g);
x4=delete(&head,g);
printf(x4);
display(&head);
void display(struct LNode **p);
main()
{
struct LNode *head,*q; /*定义静态变量*/
int select,x1,x2,x3,x4;
int i,n;
int m,g;
char e,y;
head=setnull(&head); /*建议链表并设置为空表*/
n++;
q=q->next;
}
return(n);
}
ElemType get(struct LNode **p,int i)
{
int j=1;
struct LNode *q=*p;
while (j<i&&q!=null)
{
q=q->next;
int length (struct LNode **p);
ElemType get(struct LNode **p,int i);
void insert(struct LNode **p,ElemType x,int i);
int delete(struct LNode **p,int i);
/*单链表的各种操作*/
# define null 0
typedef char ElemType; /* 字符型数据*/
数据结构单链表实验报告
数据结构单链表实验报告一、实验目的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;｝｀｀｀头部插入时，创建新节点，将新节点的数据域赋值，并将其指针域指向原头节点的下一个节点，然后更新头节点的指针域指向新节点。
数据结构C语言版 线性表的单链表存储结构表示和实现
#include 〈stdio.h>＃include <malloc。
h>＃include 〈stdlib.h>/＊数据结构C语言版线性表的单链表存储结构表示和实现P28—31编译环境：Dev-C++ 4。
9。
9。
2日期：2011年2月10日＊/typedef int ElemType;// 线性表的单链表存储结构typedef struct LNode{ElemType data; //数据域struct LNode *next；//指针域}LNode, ＊LinkList；// typedef struct LNode *LinkList；// 另一种定义LinkList的方法// 构造一个空的线性表Lint InitList（LinkList ＊L){/＊产生头结点L，并使L指向此头结点,头节点的数据域为空，不放数据的。
void ＊malloc(size_t)这里对返回值进行强制类型转换了,返回值是指向空类型的指针类型.＊/（＊L）= (LinkList）malloc（sizeof（struct LNode) ）;if( ！(＊L）)exit（0）；// 存储分配失败(＊L)-〉next = NULL；// 指针域为空return 1；}// 销毁线性表L,将包括头结点在内的所有元素释放其存储空间。
int DestroyList（LinkList ＊L）｛LinkList q;// 由于单链表的每一个元素是单独分配的，所以要一个一个的进行释放while（＊L )｛q = (*L)—〉next;free（＊L ）；//释放*L = q;}return 1；｝/*将L重置为空表,即将链表中除头结点外的所有元素释放其存储空间，但是将头结点指针域置空，这和销毁有区别哦。
不改变L，所以不需要用指针。
*/int ClearList( LinkList L )｛LinkList p，q；p = L—〉next；// p指向第一个结点while( p ) // 没到表尾则继续循环｛q = p—>next;free( p )；//释放空间p = q；}L—>next = NULL; // 头结点指针域为空,链表成了一个空表return 1;}// 若L为空表（根据头结点L—〉next来判断，为空则是空表)，则返回1，// 否则返回0.int ListEmpty(LinkList L）{if（L—>next ) // 非空return 0;elsereturn 1；｝// 返回L中数据元素个数。
数据结构 实验一：实现单链表各种基本运算的算法
- 1 -实验一：实现单链表各种基本运算的算法一、 实验目的1、 掌握单链表存储结构的类型定义；2、 实现单链表各种基本运算的算法。
二、 实验环境1、 Windows 操作系统；2、 Visual C++ 6.0三、 实验内容实现单链表各种基本运算的算法。
四、 概要设计1.存储结构的类型定义：Typedef struct LNode{ElemType data;Struct LNode *next;}LinkList;2.单链表示意图：3.项目组成图:4.algo2_2.cpp 的程序文件包含的函数原型及功能:InitList(LinkList *&L) 初始化单链表LDestroyList(LinkList *&L) 释放单链表LListEmpty(LinkList *L)判断单链表L 是否为空表ListLength(LinkList *L)返回单链表L 的元素个数DispList(LinkList *L)输出单链表LGetElem(LinkList *L,int i,ElemType &e)获取单链表L 的第i 个元素LocateElem(LinkList *L,ElemType e)在单链表L 中查找元素eListInsert(LinkList *&L,int i,ElemType e)在单链表L 中的第i 个位置上插入元素e…… head a 1 a 2 a 3 a n ∧ListDelete(LinkList *&L,int i,ElemType &e)在单链表L中删除第i个元素5.exp2_2.cpp程序文件简介:InitList(LinkList *&L) 初始化单链表LDestroyList(LinkList *&L) 释放单链表LListEmpty(LinkList *L) 判断单链表L是否为空表ListLength(LinkList *L) 返回单链表L的元素个数DispList(LinkList *L) 输出单链表LGetElem(LinkList *L,int i,ElemType &e) 获取单链表L的第i个元素LocateElem(LinkList *L,ElemType e) 在单链表L中查找元素eListInsert(LinkList *&L,int i,ElemType e) 在单链表L中的第i个位置上插入元素e ListDelete(LinkList *&L,int i,ElemType &e) 在单链表L中删除第i个元素6.proj2-2的项目的模块结构:在文件algo2-2中，(1)定义单链表结构类型；(2)初始化单链表(3)定义释放单链表的函数(4)定义判断单链表是否为空的函数(5)定义返回单链表元素个数的函数(6)定义输出单链表的函数(7)定义获取第i个元素的函数(8)定义查找元素的函数(9)定义插入元素的函数(10)定义删除元素的函数在文件exp2-2中分别调用algo2-2中所定义的函数7.函数调用关系图:五、详细设计源代码清单见附录。
使用单链表来实现集合的交并差运算数据结构
使⽤单链表来实现集合的交并差运算数据结构使⽤单链表来实现集合的交并差运算数据结构问题描述该算法的设计，要求运⾏结果如下所⽰：集合的运算如下:原集合A: c a e h原集合B: f h b g d a有序集合A: a c e h有序集合B: a b d f g h集合的并C: a b c d e f g h集合的交C: a h集合的差C: c e代码实现⾸先这⾥交并差的实现是基于链表中的元素已经从⼩到⼤排完序的链表。
这⾥排序使⽤的是冒泡排序。
//链表的冒泡排序算法bool BubbleSort(LinkList &L) //链表的冒泡排序{LinkList p, q, tail;tail=NULL;while((L->next->next)!=tail){p=L;q=L->next;while(q->next!=tail){if((q->data) > (q->next->data)){p->next=q->next;q->next=q->next->next;p->next->next=q;q=p->next;}q=q->next;p=p->next;}tail=q;}return true;}//集合的并bool merge(LinkList &L1, LinkList &L2, LinkList &L3)//集合的并这⾥的集合已经排序{LinkList p1=L1->next, p2=L2->next, p3=L3, s;while(p1!=NULL && p2!=NULL){if(p1->data!=p2->data){if(p1->data > p2->data)swap(p1, p2);while(p1!=NULL && p1->data < p2->data){s=(LinkList)malloc(sizeof(LNode));s->data=p1->data;s->next=NULL;p3->next=s;p3=s;p1=p1->next;}}elses->data=p1->data;s->next=NULL;p3->next=s;p3=s;p1=p1->next;p2=p2->next;}}if(p2!=NULL) //这⾥统⼀让p1代表链表中还有剩余元素的那条链p1=p2;while(p1!=NULL){s=(LinkList)malloc(sizeof(LNode));s->data=p1->data;s->next=NULL;p3->next=s;p3=s;p1=p1->next;}return true;}//集合的交bool intersect(LinkList &L1, LinkList &L2, LinkList &L3)//集合的交这⾥的集合已经排序{LinkList p1=L1->next, p2=L2->next, p3=L3, s;if(p1==NULL || p2==NULL)//两者中有⼀个是空链表return false;while(p1!=NULL){while(p2!=NULL){if(p2->data==p1->data){s=(LinkList)malloc(sizeof(LNode));s->data=p1->data;s->next=NULL;p3->next=s;p3=s;}if(p2->data > p1->data)break;p2=p2->next;}p1=p1->next;}return true;}//集合的差bool differ(LinkList &L1, LinkList &L2, LinkList &L3) //集合的差这⾥的集合已经排序{LinkList p1=L1->next, p2=L2->next, p3=L3, s;if(p1->next==NULL)return false;while(p1!=NULL && p2!=NULL){if(p1->data!=p2->data){if(p1->data > p2->data){while(p1->data > p2->data ) //这⾥要保证p2后⾯的值也要不能⼤于p1当前的值{p2=p2->next;}if(p1->data==p2->data)continue;}s=(LinkList)malloc(sizeof(LNode));s->data=p1->data;s->next=NULL;p3->next=s;p3=s;p1=p1->next;}else{p1=p1->next;p2=p2->next;}}while(p1!=NULL)s=(LinkList)malloc(sizeof(LNode));s->data=p1->data;s->next=NULL;p3->next=s;p3=s;p1=p1->next;}return true;}//完整的代码实现#include<bits/stdc++.h>using namespace std;typedef struct LNode{int data;struct LNode *next;}LNode, *LinkList;bool init(LinkList &L){L=(LinkList)malloc(sizeof(LNode));if(L==NULL)return false;L->next=NULL;return true;}bool search(LinkList &L, int x){LinkList p=L->next;while(p){if(p->data==x)return false;p=p->next;}return true;}bool creat_list(LinkList &L, char a[], int n) //采⽤尾插法建⽴单链表{LinkList p=L, s;for(int i=0; i<n; i++){if(search(L, a[i])==false)continue;s=(LinkList)malloc(sizeof(LNode));if(s==NULL)return false;s->data=a[i];s->next=NULL;p->next=s;p=s;}return true;}bool display(LinkList &L){LinkList p=L->next;if(p==NULL)return false;while(p){printf("%c ", p->data);p=p->next;}printf("\n");return true;}bool clear(LinkList &L){LinkList p;while(L){p=L->next;free(L);L=p;}L=NULL;return true;}bool BubbleSort(LinkList &L) //链表的冒泡排序{LinkList p, q, tail;tail=NULL;p=L;q=L->next;while(q->next!=tail){if((q->data) > (q->next->data)){p->next=q->next;q->next=q->next->next;p->next->next=q;q=p->next;}q=q->next;p=p->next;}tail=q;}return true;}bool merge(LinkList &L1, LinkList &L2, LinkList &L3)//集合的并这⾥的集合已经排序{LinkList p1=L1->next, p2=L2->next, p3=L3, s;while(p1!=NULL && p2!=NULL){if(p1->data!=p2->data){if(p1->data > p2->data)swap(p1, p2);while(p1!=NULL && p1->data < p2->data){s=(LinkList)malloc(sizeof(LNode));s->data=p1->data;s->next=NULL;p3->next=s;p3=s;p1=p1->next;}}else{s=(LinkList)malloc(sizeof(LNode));s->data=p1->data;s->next=NULL;p3->next=s;p3=s;p1=p1->next;p2=p2->next;}}if(p2!=NULL) //这⾥统⼀让p1代表链表中还有剩余元素的那条链p1=p2;while(p1!=NULL){s=(LinkList)malloc(sizeof(LNode));s->data=p1->data;s->next=NULL;p3->next=s;p3=s;p1=p1->next;}return true;}bool intersect(LinkList &L1, LinkList &L2, LinkList &L3)//集合的交这⾥的集合已经排序{LinkList p1=L1->next, p2=L2->next, p3=L3, s;if(p1==NULL || p2==NULL)//两者中有⼀个是空链表return false;while(p1!=NULL){while(p2!=NULL){if(p2->data==p1->data){s=(LinkList)malloc(sizeof(LNode));s->data=p1->data;s->next=NULL;p3->next=s;p3=s;}if(p2->data > p1->data)break;p2=p2->next;}return true;}bool differ(LinkList &L1, LinkList &L2, LinkList &L3) //集合的差这⾥的集合已经排序{LinkList p1=L1->next, p2=L2->next, p3=L3, s;if(p1->next==NULL)return false;while(p1!=NULL && p2!=NULL){if(p1->data!=p2->data){if(p1->data > p2->data){while(p1->data > p2->data ) //这⾥要保证p2后⾯的值也要不能⼤于p1当前的值{p2=p2->next;}if(p1->data==p2->data)continue;}s=(LinkList)malloc(sizeof(LNode));s->data=p1->data;s->next=NULL;p3->next=s;p3=s;p1=p1->next;}else{p1=p1->next;p2=p2->next;}}while(p1!=NULL){s=(LinkList)malloc(sizeof(LNode));s->data=p1->data;s->next=NULL;p3->next=s;p3=s;p1=p1->next;}return true;}/*产⽣n个[min, max]的随机数。
数据结构实验报告单链表
数据结构实验报告_单链表数据结构实验报告——单链表一、实验目的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.实验结果：通过运行上述代码，我们可以看到单链表的基本操作得到了实现。
数据结构单链表实验报告
{
printf("删除结点的位置i不合理!");
return ERROR;
}
r=pre->next;
pre->next=pre->next->next; /*修改指针，删除结点r*/
返回值说明：返回ERROR插入失败，返回OK插入成功;
（5）按位置查找链表元素：int GetList(LinkList L,int i,int *e);
4.详细设计
void init_linklist(LinkList *l)/*对单链表进行初始化*/{
*l=(LinkList)malloc(sizeof(Node)); /*申请结点空间*/
(*l)->next=NULL; /*置为空表*/
}
void CreateFromHead(LinkList L)
{
Node *s;
charc;
intflag=1;
while(flag) /* flag初值为1，当输入"$"时，置flag为0，建表结束*/
{
c=getchar();
if(c!='$')
*e = r->data;
free(r); /*释放被删除的结点所占的内存空间*/
printf("成功删除结点!");
return OK;
}
intListLength(LinkList L)
/*求带头结点的单链表L的长度*/
单链表的操作实验报告
单链表的操作实验报告单链表的操作实验报告引言：单链表是一种常见的数据结构，它由一系列节点组成，每个节点包含数据和指向下一个节点的指针。
在本次实验中，我们将学习如何使用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);```四、单链表的查找操作查找操作是在单链表中查找指定数据的节点。
数据结构和算法课程设计题目
北方民族大学课程设计课程名称:数据结构与算法院(部)名称:信息与计算科学学院组长姓名学号同组人员姓名指导教师姓名:纪峰设计时间:2010.6.7----2009.6.27一、《数据结构与算法》课程设计参考题目（一）参考题目一（每位同学选作一个,同组人员不得重复）1、编写函数实现顺序表的建立、查找、插入、删除运算。
2、编写函数分别实现单链表的建立、查找、插入、删除、逆置算法。
3、编写函数实现双向链表的建立、插入、删除算法。
4、编写函数实现顺序栈的进栈、退栈、取栈顶的算法。
5、编写函数实现链栈的进栈、退栈、取栈顶的算法。
6、编写函数实现双向顺序栈的判空、进栈、出栈算法。
7、编写函数实现循环队列的判队空、取队头元素、入队、出队算法。
8、编写函数实现链环队列的判队空、取队头节点、入队、出队算法。
9、编写函数实现串的，求串长、连接、求字串、插入、删除等运算。
10、分别实现顺序串和链串的模式匹配运算。
11、实现二叉树的建立，前序递归遍历和非递归遍历算法。
12、实现二叉树的建立，中序递归遍历和非递归遍历算法。
13、实现二叉树的建立，后序递归遍历和非递归遍历算法。
14、实现二叉树的中序线索化，查找*p结点中序下的前驱和后继结点。
15、分别以临接表和邻接矩阵作为存储就够实现图的深度优先搜索和广度优先搜索算法。
16、利用线性探测处理冲突的方法实现散列表的查找和插入算法。
(二)参考题目二（每三人一组，任选三个题目完成）1.运动会分数统计（限1人完成）任务：参加运动会有n个学校，学校编号为1……n。
比赛分成m个男子项目，和w个女子项目。
项目编号为男子1……m，女子m+1……m+w。
不同的项目取前五名或前三名积分；取前五名的积分分别为：7、5、3、2、1，前三名的积分分别为：5、3、2；哪些取前五名或前三名由学生自己设定。
（m<=20,n<=20）功能要求：1)可以输入各个项目的前三名或前五名的成绩；2)能统计各学校总分，3)可以按学校编号或名称、学校总分、男女团体总分排序输出；4)可以按学校编号查询学校某个项目的情况；可以按项目编号查询取得前三或前五名的学校。
数据结构单链表实验报告
数据结构单链表实验报告数据结构单链表实验报告1. 引言数据结构是计算机科学中的重要基础，它研究数据的组织、存储和管理方式。
单链表是一种基本的数据结构，它由一系列节点组成，每个节点包含数据和指向下一个节点的指针。
本实验旨在通过实践操作单链表，加深对数据结构的理解。
2. 实验目的本实验的主要目的是掌握单链表的基本操作，包括创建链表、插入节点、删除节点和遍历链表。
通过实践操作，加深对链表的理解，提高编程能力和解决问题的能力。
3. 实验环境和工具本实验使用C语言进行编程实现，可以选择任何C语言开发环境，如Dev-C++、Code::Blocks等。
在编程过程中，可以使用任何文本编辑器编写代码。
4. 实验步骤4.1 创建链表首先，需要定义一个节点结构体，包含数据和指向下一个节点的指针。
然后，通过动态内存分配来创建链表的第一个节点，并将其地址赋给头指针。
接下来，可以通过输入数据的方式，逐个创建链表的其他节点。
4.2 插入节点在链表中插入节点是一种常见的操作。
可以在链表的任意位置插入一个新节点，只需要修改相应节点的指针即可。
首先，需要找到插入位置的前一个节点，然后将新节点的指针指向原来的下一个节点，再将前一个节点的指针指向新节点。
4.3 删除节点删除链表中的节点也是一种常见的操作。
可以根据节点的值或位置来删除节点。
首先，需要找到要删除的节点的前一个节点，然后将前一个节点的指针指向要删除节点的下一个节点，最后释放要删除节点的内存空间。
4.4 遍历链表遍历链表是一种查看链表中所有节点的操作。
可以通过循环遍历链表中的每个节点，输出节点的值或进行其他操作。
需要注意的是，遍历链表时需要使用一个临时指针来指向当前节点，以便于移动到下一个节点。
5. 实验结果与分析通过实验，我们成功实现了单链表的创建、插入、删除和遍历操作。
在实际应用中，单链表可以用于实现各种数据结构和算法，如栈、队列和图等。
它具有灵活性和高效性的特点，可以方便地进行节点的插入和删除操作。
数据结构单链表实验报告
数据结构单链表实验报告实验目的：本实验的目的是通过实现单链表数据结构，加深对数据结构的理解，并掌握单链表的基本操作和算法。
实验内容：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、单链表的定义和基本操作的源代码文件。
数据结构课程设计报告---单链表表示集合---实现交并差
西安建筑科技大学华清学院课程设计（论文）题目：院（系）：专业班级：计算机姓学名：号：指导教师：2016 年9 月8 日西安建筑科技大学华清学院课程设计（论文）任务书专业班级：学生姓名：指导教师（签名）：一、课程设计（论文）题目集合运算：使用链表来表示集合，完成集合的合并，求交集等操作。
二、本次课程设计（论文）应达到的目的数据结构是实践很强的课程，课程设计是加强学生实践能力的一个强有力的手段。
课程设计要求我们完成程序设计的同时能够写出比较规范的设计报告。
严格实施课程设计这一环节，对于我们基本程序素养的培养和软件工作者工作作风的训练。
将起到显著的促进作用。
本题目要达到目的：熟练掌握链表的各种操作三、本次课程设计（论文）任务的主要内容和要求（包括原始数据、技术参数、设计要求等）输入数据：输入10个以内的字符进行程序测试。
1、自己输入两了任意集合。
2、用对话框的形式显示集合运算的结果。
3、优化对话框。
四、应收集的资料及主要参考文献：由于本课程没有安排“课内上机”学时，因此，在课程设计之前必须自己已经上机练习了“线性表”的基本操作。
参考文献：1. 数据结构-C语言描述，西安电子科技大学出版社，2011.5，耿国华编著2．数决结构与算法分析(C++版),电子工业出版社,2005.7,Clifford A.Shaffer 编著3.数据结构与算法,科学出版社,2005.08,赵文静祁飞等编著4.数据结构-C++语言描述，西安交通大学出版社，1999.01，赵文静编著5.VC++深入详解,电子工业出版社,2007.7,孙鑫,于安萍编著五、审核批准意见教研室主任（签字）设计总说明该设计主要应实现以下功能：1.利用尾差法建立单链表2.对于输入的链表进行有序排列3.删除有序链表中不符合要求的元素4.调用函数对单链表进行交，并，差运算，并输出系统主要由8 个模块组成，分别是：1. 单链表的建立2.单链表的有序排列3.删除单链表中不符合条件的元素4.集合交集5.集合并集6.集合差集7.单链表输出8.主函数1.设技种算学其的别的都过理象提的计作用3.需3.13.2可3.3用硬可误5. 概4.1数（1）（2）Check(char ch,LinkList Head)：检查p1或p2所指向数据结点该不该加入到Head为起始的集合中（2）Merge(LinkList Head1,LinkList Head2)：合并两个集合（4）IsExist(char data,LinkList Head)；IsExist2(char data,LinkList Head)：集合A中的元素，B中是否存在（5）Deprive(LinkList Head1,LinkList Head2)：两个集合的差集（6）Insection(LinkList Head1,LinkList Head2)：两个集合交集（7）PrintLinkList(LinkList Head)：打印集合元素4.2 系统包含的函数InitLinkList(LinkList Head)Check(char ch,LinkList Head)Merge(LinkList Head1,LinkList Head2)IsExist2(char data,LinkList Head)Deprive(LinkList Head1,LinkList Head2)Insection(LinkList Head1,LinkList Head2)PrintLinkList(LinkList Head)4.3 函数间的关系1.求两个集合的并集时，Merge(LinkListHead1,LinkList Head2)函数首先调用了InitLinkList(LinkList Head)函数，多次调用了Check(char ch,LinkList Head)函数。
链表的实现及应用实验原理与方法
链表的实现及应用实验原理与方法链表简介链表是一种数据结构，由一系列节点组成，每个节点包含数据和指向下一个节点的指针。
链表中的节点可以在内存中分散存储，相比于数组，链表更加灵活，动态插入和删除元素的效率更高。
链表的基本操作以下是链表的几个基本操作：1.创建链表：创建一个空链表，设置头节点为空。
2.插入节点：在链表的指定位置插入一个新节点，调整指针指向。
3.删除节点：根据给定值，在链表中找到并删除节点，调整指针指向。
4.查找节点：根据给定值，在链表中查找节点。
链表的实现方法链表可以通过不同的实现方法来实现，以下是两种常见的实现方法：单链表（Singly Linked List）单链表是最简单的链表形式，每个节点只包含一个指针指向下一个节点，最后一个节点指向空。
单链表的插入和删除操作效率高，但查找节点的效率较低。
双链表（Doubly Linked List）双链表在单链表的基础上增加了一个指向前一个节点的指针。
双链表的插入和删除操作相对复杂一些，但查找节点的效率更高，可以在双链表中前后遍历。
链表的应用链表作为一种常见的数据结构，在许多实际问题中都有广泛的应用，以下是几个常见的应用场景：1.链表用于实现栈和队列：链表可以轻松地实现栈和队列等数据结构，插入和删除操作效率高。
2.链表用于LRU缓存淘汰算法：链表可以按照访问顺序存储数据，当缓存容量不够时，可以通过删除链表尾部的节点来实现淘汰。
3.链表用于多项式求解：链表可以存储多项式的每一项，方便进行运算和求解。
链表的实验原理与方法链表的实验原理与方法可以包括以下几个方面：1.实验原理：了解链表的基本原理，包括节点结构、指针指向等。
2.实验设备：准备笔记本电脑和编程环境。
3.实验步骤：–步骤1：创建一个链表，设置头节点为空。
–步骤2：插入节点：根据需要在链表中插入节点，调整指针指向。
–步骤3：删除节点：根据需要在链表中删除节点，调整指针指向。
–步骤4：查找节点：根据给定值在链表中查找节点。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
单链表的实现实现单链表的基本操作，必须包括初始化链表(元素为空)、销毁链表、求表长、查找、插入、删除、遍历（打印）等操作。
请编写程序，实现上述单链表的基本操作。
注意：1.元素类型可以自定义2.可以是带头结点的单链表或不带头结点的单链表#include<stdio.h>#include<stdlib.h>#include<string.h>typedef int datatype;typedef struct node{datatype data;struct node *next;}LNode,*LinkList;/*//创建不带头结点的单链表Linklist Create_LinkList(){return NULL;}*///创建带头结点的单链表LinkList Create_LinkList(){LinkList L=NULL;L=(LinkList)malloc(sizeof(LNode));if(L)L->next=NULL;return L;}//打印单链表void Print_LinkList(LinkList H){if(H == NULL){printf("\n");}else{printf("head-->");LinkList p=H->next;while(p!=NULL){printf("%d",p->data);printf("-->");p=p->next;}printf("\n");}}//销毁单链表void Destroy_LinkList(LinkList *H) {LinkList p, q;p = *H;while(p){q = p;p = p->next;free(q);}*H = NULL;if(*H==NULL)printf("销毁成功，请退出\n");elseprintf("销毁失败\n");}//求表长int Length_LinkList(LinkList L){LNode *p=L;int j=0;while(p->next){p=p->next;j++;}return j;}//表长功能实现void length(LinkList L){int i=0;i=Length_LinkList(L);printf("表长：%d\n",i);}//查找操作//1)按序号查找LNode * Get_LinkList1(LinkList L,int i) {LNode *p=L;int j=0;while(p->next!=NULL&&j<i){p=p->next;j++;}if(j==i)return p;elsereturn NULL;}//2)按值查找即定位int Locate_LinkList2(LinkList L,datatype x){LNode *p=L;int i=0;while(p->data!=x){p=p->next;i++;}return i;}//查找功能实现void find(LinkList L){int i,n;LNode *p,*s;datatype x;printf("选择下列功能\n");printf("\t1)按序号查找\n");printf("\t2)按值查找即定位\n");scanf("%d",&i);switch(i){case 1:printf("请输入第几个元素：");scanf("%d",&n);p=Get_LinkList1(L,n);if(p==NULL)printf("查找失败\n");elseprintf("您所查找的元素为：%d\n",p->data);break;case 2:printf("请输入元素值：");scanf("%d",&x);i=Locate_LinkList2(L,x);if(i!=0)printf("第%d个元素\n",i);elseprintf("查找失败\n");break;}}//插入int Insert_LinkList(LinkList L,int i,datatype x) {LNode *p,*s;p=Get_LinkList1(L,i-1);if(p==NULL){printf("参数i错\n");return 0;}else{s=(LNode *)malloc(sizeof(LNode));s->data=x;s->next=p->next;p->next=s;}return 1;}//插入功能实现void Insert(LinkList L){LNode *p=L;datatype x;int i,a=1;printf("请输入要插入的数：");scanf("%d",&x);printf("请输入要插入的位置：");scanf("%d",&i);a=Insert_LinkList(L,i,x);if(a==1)printf("插入成功\n");elseprintf("插入失败\n");}//删除int Del_LinkList(LinkList L,int i){LinkList p,s;p=Get_LinkList1(L,i-1);if(p==NULL){printf("第i-1个结点不存在\n");return -1;}else{if(p->next==NULL){printf("第i个结点不存在\n");return 0;}else{s=p->next;p->next=s->next;free(s);return 1;}}}//删除功能实现void del(LinkList L){datatype x;int i,j,n,k;LNode *p;printf("选择下列功能\n");printf("\t1)按序号删除\n");printf("\t2)按元素值删除\n");scanf("%d",&i);switch(i){case 1:printf("请输入第几个元素：");scanf("%d",&n);k=Del_LinkList(L,n);if(k!=1)printf("删除失败\n");elseprintf("删除成功\n");break;case 2:printf("请输入元素值：");scanf("%d",&x);i=Locate_LinkList2(L,x);j=Del_LinkList(L,i);if(j!=1)printf("删除失败\n");elseprintf("删除成功\n");break;}}//初始化链表(元素为空)、销毁链表、求表长、查找、插入、删除、遍历（打印）等操作//main函数void printChoice(){printf("\n请选择功能：\n");printf("\t1.表长\n");printf("\t2.查找\n");printf("\t3.插入\n");printf("\t4.删除\n");printf("\t5.打印\n");printf("\t6.销毁链表\n");}int main(){LinkList L=Create_LinkList();int choice=-1;while(1){printChoice();scanf("%d",&choice);switch(choice){case 1:length(L);break;case 2:find(L);break;case 3:Insert(L);break;case 4:del(L);break;case 5:Print_LinkList(L);break;case 6:Destroy_LinkList(&L);break;default:printf("输入错误");break;}}}。