单链表的创建、插入和删除
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;}通过以上各功能的实现，希望对⼤家单链表的学习有所帮助。
链表的基础操作
链表的基础操作链表是一种常用的数据结构，它由一系列节点组成，每个节点包含数据和指向下一个节点的指针。
链表的操作包括插入、删除、查找等，下面将详细介绍链表的基础操作。
一、链表的创建链表的创建可以通过逐个节点的方式进行，首先创建一个头节点，然后创建其他节点，并将它们的指针串联起来即可。
代码如下：```pythonclass Node:def __init__(self, data):self.data = dataself.next = Nonehead = Node(1)node2 = Node(2)node3 = Node(3)head.next = node2node2.next = node3```二、链表的插入链表的插入操作包括在链表的开头、中间和末尾插入节点。
具体操作如下：1. 在链表的开头插入节点：```pythonnew_node = Node(0)new_node.next = headhead = new_node```2. 在链表的中间插入节点：假设要在node2和node3之间插入一个新的节点new_node：```pythonnew_node = Node(2.5)new_node.next = node3node2.next = new_node```3. 在链表的末尾插入节点：假设要在链表末尾插入一个新的节点new_node：```pythonnew_node = Node(4)node3.next = new_node```三、链表的删除链表的删除操作可以删除链表中的任意一个节点，具体操作如下：1. 删除链表的头节点：```pythonhead = head.next```2. 删除链表的中间节点：假设要删除node2节点：```pythonnode2.next = node3.next```3. 删除链表的末尾节点：需要遍历链表，找到倒数第二个节点，将其指针指向None即可。
单链表基本操作的实现
单链表基本操作的实现单链表是一种常见的数据结构，它由多个节点组合而成，每个节点包含一个数据元素和一个指向下一个节点的指针。
通过指针，我们可以方便地在单链表中进行插入、删除和遍历等操作。
以下是关于单链表基本操作的实现。
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.结点的定义typedef int ElemType;typedef int status;typedef struct LNode{ElemType data;struct LNode *next;}LNode, *LinkList;View Code这⾥的data就是我们链表⾥的数据元素了，next就是结点了也就是我们经常看到的p->next了。
2，创建链表接下来我们讲讲创建链表，⼀个好的链表结构离不开创建函数的作⽤，其中，创建链表⼜分为头插法和尾插法，头插法：也就是每次放⼊元素的时候⼜把指针指向头指针，也称为尾插法，因为这样创建的链表输⼊的元素其实是逆序排列的，尾插法：⾸先需要设置⼀个尾结点，然后每次插⼊完了之后把指针指向尾结点，这样就能保证是顺序输⼊的了。
头插法（倒插法）：status CreateList_List(LNode*L,int n){int i,j;LNode *p; //以同样的格式定义⼀个p指针，⽤它来进⾏元素的输⼊//L=(LinkList) malloc(sizeof(LNode)); //这⾥就是给我们的链表分配存储空间了//L->next = NULL; //⾸先让L指向头指针//for(i=n;i>0;i--){p=(LinkList) malloc(sizeof(LNode)); //每输⼊⼀个数，就分配⼀个空间，这样可以有效的提⾼空间的利⽤率//printf("请输⼊该表的第%d个元素 :",i);scanf("%d",&j);p->data=j; //这⾥就是我们的元素啦//p->next=L->next; //让我们的p指针指向头结点//L->next=p; //这⾥还不是太懂，就不误导⼤家了//}printf("\n");return L; //相信有同学注意到了我的这⾥和书上是不⼀样的，没错，是真的//}因为考虑到指针返回的问题，单链表想要返回地址的话是要⽤到⼆级指针的，⼆级指针太过⿇烦了（其实是我不会啦），我在这⾥就⽤到了⼀个外部指针来接受我return的L，嘻嘻，是不是很聪明（反正我觉着还⾏）,具体的⼤家会在我下⾯的主函数⾥⾯看到。
链表的创建、删除、逆置、查找及排序
实验一链表的建立及删除要求：函数调用实现源程序：#include<stdio.h>#include<stdlib.h>typedef struct node //定义节点类型{float data; //节点的值为浮点型struct node *next;}linklist;unsigned int length=0; //记录创建的链表的长度linklist*creat(); //函数声明void dele(linklist *head,int x);void main(){linklist *head,*p;unsigned int x;head=creat();p=head->next;printf("建立的链表为：\n");while(p){printf("%f—>",p->data);p=p->next;}printf("\b\b\b");printf(" ");printf("\n");printf("请输入要删除第几个结点：第个"); printf("\b\b\b\b");scanf("%d",&x);dele(head,x);}linklist *creat() //建立带头结点的单链表子函数，返回表头指针{float a;unsigned int k=0;linklist *head,*s,*r; //head为头结点，s,r为临时指针，建立链表是用到head=(linklist *)malloc(sizeof(linklist)); //生成头结点headr=head;printf("请输入链表长度：\n");scanf("%d",&length);printf("请输入数字创建链表:\n");for(k=0;k<length;k++){scanf("%f",&a);s=(linklist *)malloc(sizeof(linklist)); //生成头新的结点s,用于存放此次输入的数据s->data=a; //s的数据域存放ar->next=s; //此刻r 所指向的结点的指针域存放s结点的地址r=s;}r->next=NULL; //最后一个节点的指针域为“空”return head; //返回表头指针}void dele(linklist *head,int x) //删除结点子函数{linklist *p,*q,*s;int i;if(x>length){printf("此节点不存在\n");}else{if(x==1) //删除第一个节点{s=head->next; //s指向第一个节点地址head=s->next; //头指针head的指针域中存放第二个结点的地址q=head; //使删除后从第一个结点开始输出链表元素printf("删除的第1个结点为：%f\n",s->data);}else //删除第一个节点以外的结点{p=head;q=head->next; //使删除后从第一个结点开始输出链表元素for(i=1;i<=x;i++){s=p; //s指向所删除的结点的前一结点p=p->next; //p指向所删除的结点}printf("删除的第%d个结点为：%f\n",x,p->data);s->next=p->next; //s的指针域存放所删除的结点的下一节点的地址}printf("删除该节点后的链表为：\n");while(q){printf("%f—>",q->data);q=q->next;}printf("\b\b\b"); printf(" "); printf("\n");}}一次执行结果：实验二链表的逆置要求：.函数调用实现源程序：#include<stdio.h>#include<stdlib.h>typedef struct node //定义节点类型{float data; //节点的值为浮点型struct node *next;}linklist;unsigned int length=0; //链表的长度linklist*creat(); //函数声明linklist *nizhi(linklist *head);void display(linklist *head);void main(){linklist *head,*s;head=creat();printf("建立的链表为：\n");display(head);head=nizhi(head);printf("逆置后链表为：\n");display(head);}linklist *creat() //建立带头结点的单链表子函数，返回表头指针{float a;unsigned int k=0;linklist *head,*s,*r; //head为头结点，s,r为临时指针，建立链表是用到head=(linklist *)malloc(sizeof(linklist)); //生成头结点headr=head;printf("请输入链表长度：\n");scanf("%d",&length);printf("请输入数字创建链表:\n");for(k=0;k<length;k++){scanf("%f",&a);s=(linklist *)malloc(sizeof(linklist)); //生成头新的结点s,用于存放此次输入的数据s->data=a; //s的数据域存放ar->next=s; //此刻r所指向的结点的指针域存放s结点的地址r=s;}r->next=NULL; //最后一个节点的指针域为“空”return head; //返回表头指针}linklist *nizhi(linklist *head) //逆置子函数{linklist *s,*q=head,*p=head,*r;unsigned int i;if(length>1){for(i=0;i<length;i++) //p指向最后一个节点p=p->next;q=q->next; //头结点放到尾节点之后变成尾节点，新的尾节点指针域指向空s=(linklist *)malloc(sizeof(linklist));s->data=q->data;p->next=s;s->next=NULL;for(i=0;i<length-2;i++){q=q->next;r=(linklist *)malloc(sizeof(linklist));r->data=q->data;p->next=r;r->next=s;s=r;}r=(linklist *)malloc(sizeof(linklist));//建立新的头结点r->next=p;return r;}}void display(linklist *head) //输出链表子函数{linklist *p;p=head->next;while(p){printf("%f—>",p->data);p=p->next;}printf("\b\b\b"); printf(" "); printf("\n");}一次执行结果：实验三链表的查找要求：函数调用实现源程序：#include<stdio.h> #include<stdlib.h>typedef struct node //定义节点类型{float data; //节点的值为浮点型struct node *next;}linklist;unsigned int length=0; //链表的长度linklist*creat(); //函数声明void search(linklist *head,float a);void display(linklist *head);void main(){linklist *head,*s;float a;head=creat();printf("建立的链表为：\n");display(head);printf("请输入搜索值：");scanf("%f",&a);printf("查找结果：\n");search(head,a);}linklist *creat() //建立带头结点的单链表子函数，返回表头指针{float a;unsigned int k=0;linklist *head,*s,*r; //head为头结点，s,r为临时指针，建立链表是用到head=(linklist *)malloc(sizeof(linklist)); //生成头结点headr=head;printf("请输入链表长度：\n");scanf("%d",&length);printf("请输入数字创建链表:\n");for(k=0;k<length;k++){scanf("%f",&a);s=(linklist *)malloc(sizeof(linklist)); //生成头新的结点s,用于存放此次输入的数据s->data=a; //s的数据域存放ar->next=s; //此刻r所指向的结点的指针域存放s结点的地址r=s;}r->next=NULL; //最后一个节点的指针域为“空”return head; //返回表头指针}void search(linklist *head,float a) //查找子函数{int i=length,j,k=0; //k记录找到查找查找项的个数linklist *p=head;p=p->next;for(j=1;j<=i;j++){if(p->data==a){printf("第%d个节点：%f\n",j,a);k++;}p=p->next;}if(k!=0)printf("共找到%d个搜索项\n",k);elseprintf("此链表中没有所查找的内容\n");}void display(linklist *head) //输出链表子函数{linklist *p;p=head->next;while(p){printf("%f—>",p->data);p=p->next;}printf("\b\b\b");printf(" ");printf("\n");}一次执行结果：实验四链表冒泡排序要求：函数调用实现源程序：#include<stdio.h>#include<stdlib.h>typedef struct node //定义节点类型{float data; //节点的值为浮点型struct node *next;}linklist;unsigned int length=0; //链表的长度linklist*creat(); //函数声明void sort(linklist *head);void display(linklist *head);void main(){linklist *head;head=creat();printf("建立的链表为：\n");display(head);sort(head);printf("从小到大排序后链表为：\n");display(head);}linklist *creat() //建立带头结点的单链表子函数，返回表头指针{float a;unsigned int k=0;linklist *head,*s,*r; //head为头结点，s,r为临时指针，建立链表是用到head=(linklist *)malloc(sizeof(linklist)); //生成头结点headr=head;printf("请输入链表长度：\n");scanf("%d",&length);printf("请输入数字创建链表:\n");for(k=0;k<length;k++){scanf("%f",&a);s=(linklist *)malloc(sizeof(linklist)); //生成头新的结点s,用于存放此次输入的数据s->data=a; //s的数据域存放ar->next=s; //此刻r所指向的结点的指针域存放s结点的地址r=s;}r->next=NULL; //最后一个节点的指针域为“空”return head; //返回表头指针}void sort(linklist *head) //排序子函数{unsigned int i,j;linklist *p=head,*q=head,*r=head;for(i=0;i<length-1;i++){p=head;q=head;q=q->next;for(j=i+1;j<length;j++){p=p->next;q=q->next;if(p->data>q->data){r->data=p->data;p->data=q->data;q->data=r->data;}}}}void display(linklist *head) //输出链表子函数{linklist *p;p=head->next;while(p){printf("%f—>",p->data); p=p->next;}printf("\b\b\b");printf(" ");printf("\n");}一次执行结果：。
数据结构实验,线性表的插入和删除,单链表操作,Huffman编码树
{ int i,j,k,x1,x2,m1,m2;
for(i=1;i<(2*n);i++)
{ t[i].pa=t[i].lc=t[i].rc=0;
if(i<=n)
t[i].data=w[i];
else
t[i].data=0;
}
for(i=1;i<n;i++)
{ m1=m2=MAX;
x1=x2=0;
for(j=1;j<(n+i);j++)
ListCount=0;
int nOperateState;
while(TRUE)
{
printf( "选择你要操作的方法，1为插入，2为删除，3为查询！4为退出\r\n ");
scanf("%d",&nOperateState);
switch(nOperateState)
{
case 1:
InsertInfo();
{
printf("请不要重复插入相同学号的信息\r\n");
LocalFree(Info);
return;
}
ptemp=ptemp->pNext;
}
}
if (ListHead)
{
if (ListCount==1)
{
ListTail=Info;
ListTail->pNext=NULL;
ListHead->pNext=ListTail;
temp->stu_num,temp->stu_age,temp->stu_english_grade);
链表的建立、插入、删除
昆明理工大学信息工程与自动化学院学生实验报告（2011—2012学年第1学期）课程名称：数据结构开课实验室：计算中心204 2011年 10 月 21日一、上机内容和目的目的：学会使用链表，熟悉并掌握链表的建立、插入、删除。
内容：链表的建立、插入、删除。
二、上机实验环境：计算中心204，操作系统:Microsoft Visual C++；软件平台：Microsoft Visual C++三、上机步骤：打开计算机进入WindowsXP→在D盘建立自己的工作目录→进入Microsoft Visual C++6.0→文件/新建/工作区/C Source File /位置/命名→输入源程序→编译/组建→运行四、程序设计思路及程序框图：链表是很常用的一种数据结构，它用一组任意的存储单元来存放线性表的节点，存储单元可以是连续的，也可以是不连续的。
要用好它就得撑握其基本性质和用法，首先创建一个空表LNode*creat_head()，然后创建一个长度为n的线性链表void creat_list(LNode *,int)，接下来就是插入和删除的操作了。
其中data域是数据域，用来存放结点的值；next域是指针域，用来存放结点的直接后继的地址。
因为开始结点没有前驱，所以要设头指针Head指向开始结点。
具体实现是主函数调用两个函数来实现的（插入函数和删除函数）。
以下是主要的函数功能：（1）插入的主要操作：s=(Llist)malloc(sizeof(LNode));s->data=x;s->next=p->next;p->next=s;其实也就是把它们的指向关系的一条线改为两条，指针p指向单链表的某一结点，指针s指向待插入的、其值为x的新节点。
（2）删除的主要操作：q=p->next;p->next=q->next;x=q->data;free(q);return (x);首先用一个指针指向被删除的结点，接着修改*p的指针域，最后释放结点q，这一操作就算完成了。
单链表插入和删除节点的代码
单链表插入和删除节点的代码摘要：1.单链表插入节点2.单链表删除节点3.代码实现与解析正文：在计算机科学中，链表是一种常见的数据结构。
链表分为单链表和双链表。
本文将介绍单链表的插入和删除节点的操作，以及相应的代码实现。
一、单链表插入节点单链表插入节点分为三种情况：1.插入到头部2.插入到尾部3.插入到指定位置以下代码实现是将节点插入到尾部：```pythonclass ListNode:def __init__(self, val=0, next=None):self.val = valself.next = nextdef insert_at_tail(head, val):new_node = ListNode(val)return new_nodecur = headwhile cur.next:cur = cur.nextcur.next = new_nodereturn head```二、单链表删除节点单链表删除节点也分为三种情况：1.删除头部节点2.删除尾部节点3.删除指定节点以下代码实现是删除尾部节点：```pythondef delete_at_tail(head):if not head or not head.next:return headcur = headwhile cur.next.next:cur = cur.nextcur.next = cur.next.next```三、代码实现与解析以下是完整的单链表插入和删除节点的代码实现：```pythonclass ListNode:def __init__(self, val=0, next=None):self.val = valself.next = nextdef insert_at_tail(head, val):new_node = ListNode(val)if not head:return new_nodecur = headwhile cur.next:cur = cur.nextcur.next = new_nodereturn headdef delete_at_tail(head):if not head or not head.next:return headcur = headwhile cur.next.next:cur = cur.nextcur.next = cur.next.nextreturn head```通过以上代码，我们可以实现单链表的插入和删除操作。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
单链表的创建、插入和删除
（数据结构）
——SVS
#include
#include
#include
typedef int ElemType;
typedef int Status;
typedef struct LNode
{
ElemType data;
struct LNode *next;
}LNode,*LinkList;
void InitList_Link(LinkList L) //创建空链表
{
L=(LinkList)malloc(sizeof(LNode));
L->next=NULL;
}
Status InsertList_Link(LinkList L,int i,ElemType e) //插入链表
{
LinkList s,p=L;
int j=0;
while(p&&j
if(!p||j>i-1)return -1;
s=(LinkList)malloc(sizeof(LNode));
s->data=e;
s->next=p->next;
p->next=s;
return 1;
}
Status DeleteList_Link(LinkList L,int i,ElemType e) //删除链表
{
LinkList q,p=L;int j=0;
while(p->next&&j
if(!(p->next)||j>i-1)return -1;
q=p->next;
e=q->data;
p->next=q->next;
free(q);
return 1;
}
void OutPutList_Link(LinkList L) //输出链表
{
printf("表中值为：");
LinkList p=L->next;
while(p)
{
printf("%d ",p->data);
p=p->next;
}
printf("\n");
}
void CreateList_Link(LinkList L,int len) //创建链表
{
int i;
LinkList s,p=L;
for(i=0;i
s=(LinkList)malloc(sizeof(LNode));
printf("N%d: ",i+1);
scanf("%d",&s->data);
s->next=NULL;
p->next=s;
p=s;
}
}
int main()
{
int len;
LinkList L;
ElemType e;
L=(LinkList)malloc(sizeof(LNode));
printf("请输入表长： ");
scanf("%d",&len);
CreateList_Link(L,len);
OutPutList_Link(L);
/*插入*/
int num1;
int num2;
printf("请输入要插入元素的位置：");
scanf("%d",&num1);
printf("请输入要插入的元素：");
scanf("%d",&num2);
InsertList_Link(L,num1,num2);
printf("插入后 :");
OutPutList_Link(L);
int a;
int b=0;
printf("请输入要删除元素的位置：");
scanf("%d",&a);
DeleteList_Link(L,a,b);
printf("删除后:");
OutPutList_Link(L);
}