单链表的初始化,建立,插入,查找,删除
C语言之单链表的插入、删除与查找

C语⾔之单链表的插⼊、删除与查找单链表是⼀种链式存取的数据结构,⽤⼀组地址任意的存储单元存放线性表中的数据元素。
要实现对单链表中节点的插⼊、删除与查找的功能,就要先进⾏的单链表的初始化、创建和遍历,进⽽实现各功能,以下是对单链表节点的插⼊、删除、查找功能的具体实现:#include<stdio.h>#include<stdlib.h>#include<string.h>typedef int ElemType;/***链表通⽤类型*ElemType 代表⾃定义的数据类型*struct Node *next 代表结构体指针(指向下⼀个结构体,完成链表动作)*/typedef struct Node{ElemType data;struct Node *next;}Node;/*==========单链表的初始化================*//**头结点指针数据域设置为空*/void initList(Node **pNode){*pNode=NULL;}/*===========单链表的创建=================*//**功能实现:通过⽤户不断输⼊数据,创建链表*利⽤游标俩个指针(p1,p2),将申请下的数据块(存⼊⽤户输⼊数据),链接起来*/Node *create(Node *pHead){Node *p1;Node *p2;p1=p2=(Node *)malloc(sizeof(Node)); //申请内存空间memset(p1,0,sizeof(Node)); //存⼊数据域清空scanf("%d",&p1->data);p1->next=NULL;while(p1->data>0){ //输⼊负数结束if(pHead==NULL)pHead=p1;elsep2->next=p1;p2=p1;p1=(Node *)malloc(sizeof(Node));memset(p1,0,sizeof(Node));scanf("%d",&p1->data);p1->next=NULL;}return pHead;}/*=================链表的遍历==================*//***从头结点开始,不断遍历出数据域的内容将表遍历*/void printList(Node *pHead){if(NULL==pHead)printf("链表为空\n");else{while(pHead!=NULL){printf("%d ",pHead->data);pHead=pHead->next;}}printf("\n");}/*===============插⼊节点==================*//***Node **pNode 传⼊头结点空间地址*int i 传⼊要插⼊的结点位置*/void insert_data(Node **pNode,int i){Node *temp;Node *target;Node *p;int item;int j=1;printf("输⼊要插⼊的节点值:");scanf("%d",&item);target=*pNode;for(;j<i-1;target=target->next,++j); //不断移动target位置,到要插⼊结点位置,temp=(Node *)malloc(sizeof(Node)); //申请内存空间temp->data=item; //存⼊要存⼊的数据位置p=target->next;target->next=temp;temp->next=p;}/*===============删除节点====================*//***删除结点后,释放内存空间free(temp)*/void delete_data(Node **pNode,int i){Node *target;Node *temp;int j=1;target=*pNode;for(;j<i-1;target=target->next,++j);temp=target->next;target->next=temp->next;free(temp);}/*===============查找结点====================*/int search_data(Node *pNode,int elem){Node *target;int i=1;for(target=pNode;target->data!=elem && target->next!=NULL;++i,target=target->next); if(target->next==NULL)return 0;elsereturn i;}int main(){int i;Node *pHead=NULL;initList(&pHead);pHead=create(pHead);printList(pHead);printf("输⼊插⼊节点位置\n");scanf("%d",&i);insert_data(&pHead,i);printList(pHead);printf("输⼊删除节点位置\n");scanf("%d",&i);delete_data(&pHead,i);printList(pHead);printf("输⼊查找节点\n");scanf("%d",&i);printf("节点所在位置:%d",search_data(pHead,i));return 0;}通过以上各功能的实现,希望对⼤家单链表的学习有所帮助。
单链表的实验报告总结

单链表的实验报告总结单链表是一种常用的数据结构,它由一系列节点组成,每个节点包含了数据和指向下一个节点的指针。
在实验中,我们对单链表进行了操作和实现,通过此次实验,我深刻理解了单链表的特点和应用。
以下是我对此次实验的总结和体会。
在实验中我们实现了单链表的创建和初始化。
通过创建一个头节点,并将头节点的指针指向空,我们成功地初始化了一个空的单链表。
这为后续的操作打下了基础。
接着,我们实现了单链表的插入操作。
通过指定要插入的位置和值,我们可以在单链表的任意位置插入一个新的节点。
这个操作非常灵活,让我感受到了单链表的动态性和可变性。
通过插入操作,我们可以在单链表中任意位置插入新的元素,从而灵活地调整单链表的结构和内容。
在实验中,我们还实现了单链表的删除操作。
通过指定要删除的节点位置,我们可以将该节点从单链表中删除。
这个操作也非常重要,可以帮助我们对单链表中的数据进行动态管理。
通过删除操作,我们可以方便地删除单链表中的某个元素,从而保持单链表的整洁和有序。
除了插入和删除操作,我们还实现了单链表的查找操作。
通过指定要查找的值,我们可以在单链表中查找到对应的节点。
这个操作非常实用,可以帮助我们快速定位和访问单链表中的数据。
通过查找操作,我们可以方便地获取单链表中特定元素的值,从而满足我们对数据的需求。
在实验中,我们还实现了单链表的修改操作。
通过指定要修改的节点位置和新的值,我们可以将单链表中某个节点的值进行修改。
这个操作也非常有用,可以帮助我们对单链表中的数据进行更新和改进。
通过修改操作,我们可以方便地对单链表中的某个元素进行数值的调整,从而满足我们对数据的要求。
通过本次实验,我对单链表的原理和操作有了更深入的理解。
单链表是一种非常灵活和实用的数据结构,可以应用于各种场景和问题。
它的特点是插入和删除操作的效率很高,但查找和修改操作的效率较低。
因此,在实际应用中,我们需要根据具体的需求和场景选择合适的数据结构。
数据结构 单链表基本操作代码

数据结构单链表基本操作代码```一、单链表基本概念单链表是一种常见的线性存储结构,由一系列节点组成。
每个节点包括数据域和指针域,数据域存储具体的数据,指针域指向下一个节点。
二、单链表基本操作2.1 创建链表创建一个空链表,即没有任何节点。
可以选择初始化一个头节点,也可以直接初始化为空。
2.2 在链表头部插入节点在链表头部插入新节点。
将新节点的指针域指向原头节点,然后更新头节点指针,使其指向新节点。
2.3 在链表尾部插入节点在链表尾部插入新节点。
遍历链表找到尾节点,然后将尾节点的指针域指向新节点。
2.4 在指定位置插入节点在链表的指定位置插入新节点。
遍历链表找到指定位置的节点,然后将新节点的指针域指向下一个节点,再将指定位置的节点的指针域指向新节点。
2.5 删除链表头节点删除链表头节点,即将头节点的指针指向下一个节点,然后删除原头节点。
2.6 删除链表尾节点删除链表尾节点,即遍历链表找到尾节点的上一个节点,将其指针域置空,然后删除尾节点。
2.7 删除指定位置的节点删除链表的指定位置节点,即遍历链表找到指定位置节点的上一个节点,将其指针域指向下一个节点,然后删除指定位置节点。
2.8查找链表中是否存在某个元素遍历链表,逐个比较节点的数据域与目标元素,直到找到匹配或遍历到链表末尾。
2.9获取链表长度遍历链表,计数节点的个数,直到遍历到链表末尾。
三、附件暂无附件。
四、法律名词及注释本文档未涉及任何法律名词及其注释。
```。
单链表基本操作的实现

单链表基本操作的实现单链表是一种常见的数据结构,它由多个节点组合而成,每个节点包含一个数据元素和一个指向下一个节点的指针。
通过指针,我们可以方便地在单链表中进行插入、删除和遍历等操作。
以下是关于单链表基本操作的实现。
1. 单链表的创建单链表的创建需要定义一个空的头结点,它的作用是方便在链表的头部进行添加和删除节点操作。
一个空的头节点可以在链表初始化的过程中进行创建。
```typedef struct Node{int data;struct Node *next;}Node;Node *createList(){Node *head = (Node*)malloc(sizeof(Node)); //创建空的头节点head->next = NULL;return head; //返回头节点的地址}```2. 单链表的插入单链表的插入可以分为在链表头部插入、在链表尾部插入和在链表中间插入三种情况。
a. 在链表头部插入节点:```void insertAtHead(Node *head, int data){Node *node = (Node*)malloc(sizeof(Node));node->data = data;node->next = head->next;head->next = node;}```b. 在链表尾部插入节点:```void insertAtTail(Node *head, int data){Node *node = (Node*)malloc(sizeof(Node));node->data = data;node->next = NULL;Node *p = head;while(p->next != NULL){p = p->next;}p->next = node;}```c. 在链表中间插入节点:```void insertAtMid(Node *head, int data, int pos){ Node *node = (Node*)malloc(sizeof(Node)); node->data = data;node->next = NULL;Node *p = head;int count = 0;while(p->next != NULL && count < pos-1){ p = p->next;count++;}if(count == pos-1){node->next = p->next;p->next = node;}else{printf("插入位置错误!");}}```3. 单链表的删除单链表的删除可以分为在链表头部删除、在链表尾部删除和在链表中间删除三种情况。
数据结构单链表实验报告

数据结构单链表实验报告一、实验目的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、理解数据结构中单链表的定义和建立。
2、掌握单链表中结点结构的C语言描述。
3、熟练掌握单链表的插入、删除和修改等算法的设计与C语言实现。
4、将理论与实际相结合,切实提高自己的逻辑能力和动手能力。
二、设计内容1、输入单链表长度,创建一个单链表。
2、对建立好的单链表进行插入操作。
3、对建立好的单链表进行删除操作。
4、对建立好的单链表进行合并操作。
三、概要设计抽象数据类型线性表的定义如下:ADTA List{数据对象:D={ai I ai∈ElemSet , i=1 ,2 , … , n n>=0 }数据关系:R1={<ai-1 , ai> I ai-1 , ai∈D , i=2 , … , n }基本操作:Creates( &L )操作结果:构建一个空的线性表L。
Insertsl( &L , k ,i)初始条件:线性表L已存在。
操作结果:在带有头结点单链表的第k个元素之前插入元素i。
Deletesl( &L , i, j )初始条件:线性表L已存在。
操作结果:删除指定位置j元素i。
Hebing( &L )初始条件:线性表L已存在。
操作结果:清除新链表中相同的元素。
}ADT List四、算法流程图五、算法源代码#include <stdio.h> #include <malloc.h>typedef struct node {int data;struct node *next; }node;node *head;int k;node * creates(){node *p,*s,*h;int j=1,x, n;p=h=(node*)malloc(sizeof(node));h->next=NULL;printf("请输入链表长度:");scanf("%d",&n);printf("请输入 %d 个数字创建链表:",n);while(j<=n){scanf("%d",&x);s=(node*)malloc(sizeof(node));s->data=x;p->next=s;p=s;j++;}p->next=NULL;return h;}void insertsl(node *head, int k, int i){/*在带有头结点单链表的第k个元素之前插入元素i*/ int j;node *p, *t;p=head;j=0;while ( p&&j<k-1 ) /*若p不指向空,并且没有找到合适位置则继续循环*/ {p = p->next;j++;}if (!p||j>k-1) /*k小于1或大于表长*/printf("插入位置不对。
单链表基本操作

单链表基本操作在计算机科学里,链表是一种常见的数据结构,它可以用来解决各种复杂的问题。
其中,单链表是最常见的一种,它由一系列节点组成,每个节点包含了一个数据元素和一个指针,指向下一个节点。
这篇文章将介绍单链表的基本操作,包括创建、插入、删除和遍历等。
创建单链表创建单链表是基本操作之一,它有两种方法:头插法和尾插法。
头插法是从链表的头节点开始,逐个将新节点插入。
具体来说,创建一个空链表,设置一个头节点,将头节点的指针指向空;依次输入新节点,将新节点的指针指向表头,将表头的指针指向新节点。
这样,每插入一个新节点就成为了新的表头,即最后插入的节点为新的表头。
尾插法则是从链表的尾节点开始,逐个将新节点插入。
具体来说,创建一个空链表,设置一个头节点,将头节点的指针指向空;依次输入新节点,将新节点的指针指向空,将最后一个节点的指针指向新节点。
这样,最后插入的节点为尾节点,它的指针值为空。
插入节点插入节点是指在单链表的任意位置插入一个新节点。
插入节点的前提是找到插入位置,可以通过遍历单链表来查找插入位置。
插入新节点的基本步骤如下:1、创建新节点;2、将新节点的指针指向待插入节点的后继节点;3、将待插入节点的指针指向新节点。
删除节点删除节点是指删除单链表中的任意节点。
删除节点的前提是找到删除的节点位置,可以通过遍历单链表来查找删除位置。
删除节点的基本步骤如下:1、找到要删除的节点;2、将该节点的前驱节点的指针指向该节点的后继节点;3、删除该节点。
遍历节点遍历节点是指按照链表的顺序依次访问链表中的各个节点。
遍历节点的基本步骤如下:1、从链表的头节点开始遍历;2、依次访问每个节点的数据元素;3、通过指针访问下一个节点,直到遇到尾节点。
优缺点单链表的优点是简单,灵活,易于实现和扩展,可以方便地进行插入和删除等操作。
其缺点是存在指针开销,查找元素时需要遍历整个链表,不能直接访问链表中任意位置的节点。
总结单链表是一种最常用的数据结构,它是由一系列节点组成,每个节点包含一个数据元素和一个指针,指向下一个节点。
带头节点的循环单链表

带头节点的循环单链表带头节点的循环单链表是一种特殊的链表结构,它在普通的循环单链表的基础上增加了一个头节点。
本文将详细介绍带头节点的循环单链表的特点、操作以及应用场景。
一、带头节点的循环单链表的特点带头节点的循环单链表与普通的循环单链表相比,多了一个头节点,头节点不存储任何数据,仅作为链表的标志和辅助作用。
头节点的存在使得链表的插入、删除等操作更加方便,同时也能避免一些特殊情况的处理。
1. 初始化链表:创建一个头节点,并将头节点的指针指向自身,表示链表为空。
2. 判断链表是否为空:通过判断头节点的指针是否指向自身,即可判断链表是否为空。
3. 插入节点:在链表的指定位置插入一个新节点。
首先找到插入位置的前一个节点,然后将新节点的指针指向前一个节点的下一个节点,再将前一个节点的指针指向新节点。
4. 删除节点:删除链表中指定位置的节点。
首先找到要删除节点的前一个节点,然后将前一个节点的指针指向要删除节点的下一个节点,最后释放被删除节点的内存空间。
5. 遍历链表:从头节点开始,按照指针的方向遍历链表,直到回到头节点为止,输出每个节点的数据。
三、带头节点的循环单链表的应用场景带头节点的循环单链表在实际应用中有着广泛的应用场景,以下是几个典型的应用场景:1. 约瑟夫环问题:约瑟夫环是一种数学问题,通过使用带头节点的循环单链表可以很方便地解决该问题。
2. 循环队列:循环队列是一种常见的队列结构,使用带头节点的循环单链表可以实现循环队列的操作。
3. 循环链表:带头节点的循环单链表本身就是一种循环链表,可以用于解决一些需要循环访问的问题。
总结:带头节点的循环单链表是一种特殊的链表结构,通过增加一个头节点,使得链表的操作更加方便,并且能够避免一些特殊情况的处理。
带头节点的循环单链表可以用于解决一些需要循环访问的问题,例如约瑟夫环问题和循环队列等。
掌握带头节点的循环单链表的基本操作,对于理解和应用链表结构具有重要的意义。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
单链表的初始化,建立,插入,查找,删除。
#include <stdio.h>
#include <stdlib.h>
typedef int ElemType;
//定义结点类型
typedef struct Node
{
ElemType
data;
//单链表中的数据域
struct Node
*next;
//单链表的指针域
}Node,*LinkedList;
//单链表的初始化
LinkedList LinkedListInit() {
Node
*L;
L = (Node
*)malloc(sizeof(Node));
//申请结点空间
if(L ==
NULL)
//判断是否有足够的内存空间
printf("申请内存空间失败\n");
L->next =
NULL;
//将next设置为NULL,初始长度为0的单链表return L;
}
//单链表的建立1,头插法建立单链表
LinkedList LinkedListCreatH()
{
Node
*L;
L = (Node
*)malloc(sizeof(Node));
//申请头结点空间
L->next =
NULL;
//初始化一个空链表
ElemType
x;
//x为链表数据域中的数据
while(scanf("%d",&x) != EOF) {
Node *p;
p = (Node
*)malloc(sizeof(Node));
//申请新的结点
p->data =
x;
//结点数据域赋值
p->next =
L->next;
//将结点插入到表头L-->|2|-->|1|-->NULL L->next = p;
}
return
L;
}
//单链表的建立2,尾插法建立单链表
LinkedList LinkedListCreatT() {
Node
*L;
L = (Node
*)malloc(sizeof(Node));
//申请头结点空间
L->next =
NULL;
//初始化一个空链表
Node
*r;
r =
L;
//r始终指向终端结点,开始时指向头结点
ElemType
x;
//x为链表数据域中的数据
while(scanf("%d",&x) != EOF)
{
Node *p;
p = (Node
*)malloc(sizeof(Node));
//申请新的结点
p->data =
x;
//结点数据域赋值
r->next =
p;
//将结点插入到表头L-->|1|-->|2|-->NULL r = p;
}
r->next = NULL;
return
L;
}
//单链表的插入,在链表的第i个位置插入x的元素
LinkedList LinkedListInsert(LinkedList L,int i,ElemType x) {
Node
*pre;
//pre为前驱结点
pre =
L;
int tempi =
0;
for (tempi =
1; tempi < i; tempi++)
pre =
pre->next;
//查找第i个位置的前驱结点
Node
*p;
//插入的结点为p
p = (Node
*)malloc(sizeof(Node));
p->data = x;
p->next = pre->next;
pre->next = p;
return
L;
}
//单链表的删除,在链表中删除值为x的元素
LinkedList LinkedListDelete(LinkedList L,ElemType x) {
Node
*p,*pre;
//pre为前驱结点,p为查找的结点。
p =
L->next;
while(p->data !=
x)
//查找值为x的元素
{
pre = p;
p = p->next;
}
pre->next =
p->next;
//删除操作,将其前驱next指向其后继。
free(p);
return
L;
}
int main()
{
LinkedList
list,start;
printf("请输入单链表的数据:");
list =
LinkedListCreatH();
for(start =
list->next; start != NULL; start = start->next)
printf("%d ",start->data);
printf("\n");
int
i;
ElemType
x;
printf("请输入插入数据的位置:"); scanf("%d",&i);
printf("请输入插入数据的值:"); scanf("%d",&x); LinkedListInsert(list,i,x);
for(start =
list->next; start != NULL; start =
start->next)
printf("%d ",start->data);
printf("\n");
printf("请输入要删除的元素的值:"); scanf("%d",&x); LinkedListDelete(list,x);
for(start =
list->next; start != NULL; start = start->next)
printf("%d ",start->data); printf("\n");
return
0;
}。