单链表的创建、插入和删除

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");}一次执行结果：。

昆明理工大学信息工程与自动化学院学生实验报告（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) 将数据元素从键盘依次输⼊，分别完成头插法和尾插法建⽴单链表4) 输出单链表的长度5) 实现按位查找和按值查找6) 实现插⼊和删除操作7) 实现遍历单链表操作#include <cstdio>#include <cstring>#include <cstdlib>//查找1.内容2.序号//插⼊//删除typedef struct student{int num;char name[10];}STU;typedef struct Node{STU data;struct Node * next;}Node;void denglu(Node *L);//登录函数void chazhao(Node *L);//查找函数void Printf(Node *L);//输出函数void CreateFromHead(Node *L);//头插法void CreateFormTail(Node *L);//尾插法void panduan(Node *L);//判断头插还是尾插void Get(Node *L);//按序号结点查找void Locate(Node *L);//按内容查找（值）void Inslist(Node *L);//插⼊void Dellist(Node *L);//删除void Dellist(Node *L)//删除{system("CLS");int n;printf("请输⼊要删除的结点\n");scanf("%d",&n);if(n<=0){printf("输⼊的数据不合法,请重新输⼊\n");Dellist(L);}Node *pre,*r;int k=0;pre=L;while(pre->next !=NULL&&k<n-1){pre=pre->next;k=k+1;}if(pre->next==NULL){printf("没有找到该结点,请重新输⼊\n");Dellist(L);}r=pre->next;pre->next=r->next;free(r);printf("删除成功!\n");denglu(L);}void Inslist(Node *L)//插⼊{system("CLS");int n;printf("请输⼊在第⼏个位置插⼊数据\n");scanf("%d",&n);printf("请输⼊插⼊的学号,姓名\n");int num1;char name1[10];scanf("%d %s",&num1,name1);Node *pre,*s;int k=0;if(n<=0){printf("输⼊的数据不合法,请重新输⼊\n");Inslist(L);}pre=L;while(pre!=NULL&&k<n-1){pre=pre->next;k=k+1;}if(pre==NULL){printf("⽆法找到该节点,请重新输⼊\n");Inslist(L);}s=(Node*)malloc(sizeof(Node));strcpy(s->data .name ,name1);s->data.num=num1;s->next =pre->next ;pre->next =s;printf("插⼊成功!\n");denglu(L);}void Locate(Node *L)//按内容查找（值）{system("CLS");int n;printf("请输⼊要查找的学号\n");scanf("%d",&n);Node *p;p=L->next;while(p!=NULL){if(p->data.num!=n){p=p->next;}elsebreak;}printf("你要查找的学号所对应的信息为%d %s\n",p->data.num,p->);denglu(L);}void Get(Node *L)//按序号结点查找{system("CLS");int n;printf("请输⼊你要查找的结点\n");scanf("%d",&n);if(n<=0){printf("输⼊的数据不合法,请重新输⼊\n");Get(L);}Node *p;p=L;int j=0;while((p->next!=NULL)&&(j<n)){p=p->next;j++;}if(n==j){printf("你要查找的结点的储存位置的数据为%d %s\n",p->data.num,p->); }denglu(L);}void Printf(Node *L){int q=0;Node *p=L->next;while(p!=NULL){q++;printf("%d %s\n",p->data.num,p->); p=p->next;}printf("单链表长度为%d\n",q);denglu(L);}void chazhao(Node *L){printf("1.按序号查找\n");printf("2.按内容查找\n");printf("3.返回主界⾯\n");int aa;scanf("%d",&aa);switch(aa){case 1:Get(L);case 2:Locate(L);case 3:denglu(L);break;default:printf("输⼊错误请重新输⼊\n");chazhao(L);}}void denglu(Node *L){int a;printf("请选择你要做什么\n");printf("1.查找\n");printf("2.插⼊\n");printf("3.删除\n");printf("4.打印现有的学⽣信息及单链表长度\n"); printf("5.退出\n");scanf("%d",&a);switch(a){case 1:chazhao(L);case 2:Inslist(L);case 3:Dellist(L);case 4:Printf(L);case 5:printf("谢谢使⽤\n");exit(0);default:printf("输⼊错误请重新输⼊\n");denglu(L);}}void CreateFromHead(Node *L)//头插法{Node *s;int n;//n为元素个数printf("请输⼊元素个数\n");scanf("%d",&n);printf("请输⼊学号姓名\n");for(int i=1;i<=n;i++){s=(Node *)malloc(sizeof(Node));scanf("%d %s",&s->data.num,s->); s->next=L->next;L->next=s;}}void CreateFormTail(Node *L)//尾插法{Node *s,*r;r=L;int n;//n为元素个数printf("请输⼊元素个数\n");scanf("%d",&n);printf("请输⼊学号姓名\n");for(int i=1;i<=n;i++){s=(Node *)malloc(sizeof(Node));scanf("%d %s",&s->data.num,s->);r->next=s;r=s;if(i==n){r->next=NULL;}}}Node *InitList(Node *L)//初始化单链表{L=(Node *)malloc(sizeof(Node));L->next=NULL;return L;}void panduan(Node *L){int q;printf("请选择⽤哪种⽅式建⽴链表\n");printf("1.头插法\n");printf("2.尾插法\n");scanf("%d",&q);switch(q){case (1):CreateFromHead(L);printf("输⼊成功！\n");break;case (2):CreateFormTail(L);printf("输⼊成功！\n");break;default:printf("输⼊错误请重新输⼊\n");panduan(L);}}int main(){Node *L=NULL;L=InitList(L);panduan(L);denglu(L);return 0;}ps.贴上来的代码空格有点⼩奇怪啊。

「C语⾔」单链表双向链表的建⽴遍历插⼊删除最近临近期末的C语⾔课程设计⽐平时练习作业⼀下难了不⽌⼀个档次，第⼀次接触到了C语⾔的框架开发，了解了View（界⾯层）、Service（业务逻辑层）、Persistence（持久化层）的分离和耦合，⼀种⾯向过程的MVC的感觉。

⽽这⼀切的基础就在于对链表的创建、删除、输出、写⼊⽂件、从⽂件读出......本篇⽂章在于巩固链表的基础知识（整理⾃《C语⾔程序设计教程--⼈民邮电出版社》第⼗章——指针与链表），只对链表的概念及增删改查作出探讨，欢迎指教。

⼀、链表结构和静态/动态链表⼆、单链表的建⽴与遍历三、单链表的插⼊与删除四、双向链表的概念五、双向链表的建⽴与遍历六、双向链表的元素查找七、循环链表的概念⼋、合并两个链表的实例九、链表实战拓展思维、拉到最后去看看 (•ᴗ•)و⼀、链表结构和静态/动态链表链表是⼀种常见的数据结构——与数组不同的是：1.数组⾸先需要在定义时声明数组⼤⼩，如果像这个数组中加⼊的元素个数超过了数组的长度时，便不能正确保存所有内容；链表可以根据⼤⼩需要进⾏拓展。

2.其次数组是同⼀数据类型的元素集合，在内存中是按⼀定顺序连续排列存放的；链表常⽤malloc等函数动态随机分配空间，⽤指针相连。

链表结构⽰意图如下所⽰：在链表中，每⼀个元素包含两个部分；数据部分和指针部分。

数据部分⽤来存放元素所包含的数据，指针部分⽤来指向下⼀个元素。

最后⼀个元素的指针指向NULL，表⽰指向的地址为空。

整体⽤结构体来定义，指针部分定义为指向本结构体类型的指针类型。

静态链表需要数组来实现，即把线性表的元素存放在数组中。

数组单元存放链表结点，结点的链域指向下⼀个元素的位置，即下⼀个元素所在数组单元的下标。

这些元素可能在物理上是连续存放的，也有可能是不连续的，它们之间通过逻辑关系来连接——这就要涉及到数组长度定义的问题，实现⽆法预知定义多⼤的数组，动态链表随即出现。

动态链表指在程序执⾏过程中从⽆到有地建⽴起⼀个链表，即⼀个⼀个地开辟结点和输⼊各结点的数据，并建⽴起前后相连的关系。

单链表插入和删除节点的代码摘要：1.单链表的定义和结构2.插入节点的基本原理3.插入节点的具体实现4.删除节点的基本原理5.删除节点的具体实现正文：一、单链表的定义和结构单链表是一种常见的数据结构，它由一系列节点组成，每个节点包含两个部分：数据域和指针域。

数据域用于存储数据，指针域则指向下一个节点。

单链表的头节点（首元节点）和尾节点（末元节点）分别表示链表的开始和结束。

二、插入节点的基本原理在单链表中插入一个新节点，需要找到插入位置，然后将新节点与原有节点连接。

插入位置可以是在链表的头部、尾部或者任意位置。

三、插入节点的具体实现以下是在单链表中插入新节点的具体步骤：1.定义一个新节点，包含数据域和指针域。

2.遍历链表，找到插入位置。

3.将新节点的指针域指向原有节点的指针域。

4.将原有节点的指针域指向新节点。

5.如果是在链表头部插入，将新节点的指针域指向原头节点；如果是在链表尾部插入，将原尾节点的指针域指向新节点。

四、删除节点的基本原理删除单链表中的节点，需要找到待删除节点的前一个节点，然后将待删除节点从链表中移除。

五、删除节点的具体实现以下是在单链表中删除节点的具体步骤：1.定位待删除节点的前一个节点。

2.将待删除节点的数据域复制到前一个节点的数据域中。

3.更新前一个节点的指针域，使其指向待删除节点的后一个节点（若存在）。

4.如果是链表头部节点被删除，将原头节点的指针域指向待删除节点的后一个节点；如果是链表尾部节点被删除，更新原尾节点的指针域，使其指向待删除节点的前一个节点。

5.如果待删除节点是链表唯一的节点，需同时删除头节点和尾节点，并更新指针域。

通过以上步骤，我们可以在单链表中插入和删除节点。

实现单链表的各种基本运算
单链表是一种重要的数据结构，在实际开发中应用广泛。

实现单链表的各种基本运算是数据结构学习的必备内容。

其中，包括单链表的创建、插入、删除、查找以及遍历等操作。

首先，单链表的创建需要定义单链表节点的结构体，并通过malloc函数动态分配节点内存。

然后，将各个节点通过指针相连，形成链表。

其次，单链表的插入操作可以在链表的任意位置插入新节点。

具体实现方式是，先通过遍历找到待插入节点的位置，然后将新节点插入到该位置前面即可。

再次，单链表的删除操作可以删除任意位置的节点。

具体实现方式是，先通过遍历找到待删除节点的位置，然后将其前一个节点的指针指向其后一个节点，再通过free函数释放该节点的内存即可。

另外，单链表的查找操作可以通过遍历实现。

对于有序链表，还可以采用二分查找法提高查找效率。

最后，单链表的遍历操作可以通过while循环遍历整个链表，依次输出每个节点的值。

总之，实现单链表的基本运算是数据结构学习中非常重要的一部分。

掌握了这些操作，可以为日后的开发工作打下坚实的基础。

- 1 -。

实验一、单链表的插入和删除一、目的了解和掌握线性表的逻辑结构和链式存储结构，掌握单链表的基本算法及相关的时间性能分析。

二、要求：建立一个数据域定义为字符串的单链表，在链表中不允许有重复的字符串；根据输入的字符串，先找到相应的结点，后删除之。

三、程序源代码#include"stdio.h"#include"string.h"#include"stdlib.h"#include"ctype.h"typedef struct node //定义结点{char data[10]; //结点的数据域为字符串struct node *next; //结点的指针域}ListNode;typedef ListNode * LinkList; // 自定义LinkList单链表类型LinkList CreatListR1(); //函数，用尾插入法建立带头结点的单链表ListNode *LocateNode(); //函数，按值查找结点void DeleteList(); //函数，删除指定值的结点void printlist(); //函数，打印链表中的所有值void DeleteAll(); //函数，删除所有结点，释放内存//==========主函数==============void main(){char ch[10],num[10];LinkList head;head=CreatListR1(); //用尾插入法建立单链表，返回头指针 printlist(head); //遍历链表输出其值printf(" Delete node (y/n):");//输入“y”或“n”去选择是否删除结点scanf("%s",num);if(strcmp(num,"y")==0 || strcmp(num,"Y")==0){ printf("Please input Delete_data:");scanf("%s",ch); //输入要删除的字符串 DeleteList(head,ch);printlist(head);}DeleteAll(head); //删除所有结点，释放内存}//==========用尾插入法建立带头结点的单链表===========LinkList CreatListR1(void){char ch[10];LinkList head=(LinkList)malloc(sizeof(ListNode)); //生成头结点ListNode *s,*r,*pp;r=head;r->next=NULL;printf("Input # to end "); //输入“#”代表输入结束printf("Please input Node_data:");scanf("%s",ch); //输入各结点的字符串while(strcmp(ch,"#")!=0) {pp=LocateNode(head,ch); //按值查找结点，返回结点指针 if(pp==NULL) { //没有重复的字符串，插入到链表中s=(ListNode *)malloc(sizeof(ListNode));strcpy(s->data,ch);r->next=s;r=s;r->next=NULL;}printf("Input # to end ");printf("Please input Node_data:");scanf("%s",ch);}return head; //返回头指针}//==========按值查找结点，找到则返回该结点的位置，否则返回NULL==========ListNode *LocateNode(LinkList head, char *key){ListNode *p=head->next; //从开始结点比较while(p&&strcmp(p->data,key)!=0 ) //直到p为NULL或p-> data为key止p=p->next; //扫描下一个结点return p; //若p=NULL则查找失败，否则p指向找到的值key的结点}//==========删除带头结点的单链表中的指定结点=======void DeleteList(LinkList head,char *key){ListNode *p,*r,*q=head;p=LocateNode(head,key); //按key值查找结点的if(p==NULL ) { //若没有找到结点，退出printf("position error");exit(0);}while(q->next!=p) //p为要删除的结点，q为p的前结点q=q->next;r=q->next;q->next=r->next;free(r); //释放结点}//===========打印链表=======void printlist(LinkList head){ListNode *p=head->next; //从开始结点打印while(p){printf("%s, ",p->data);p=p->next;}printf("\n");}//==========删除所有结点，释放空间===========void DeleteAll(LinkList head){ListNode *p=head,*r;while(p->next){r=p->next;free(p);p=r;}free(p);}运行结果：加的添加结点的代码：int Insert(ListNode *head) // the insert function {ListNode *in,*p,*q;int wh;printf("input the insert node:");in=(ListNode *)malloc(sizeof(ListNode));in->next=NULL;p=(ListNode *)malloc(sizeof(ListNode));p->next=NULL;q=(ListNode *)malloc(sizeof(ListNode));q->next=NULL;if(!in)return 0;scanf("%s",in->data);printf("input the place where you want to insert you data:");scanf("%d",&wh);for(p=head;wh>0;p=p->next,wh--);q=p->next;p->next=in;in->next=q;return 1;}运行结果：最后提示为OK 添加成功。