史上最全单链表的增删改查反转等操作汇总以及5种排序算法(C语言)

最新推荐文章于 2024-08-25 00:48:45 发布
最新推荐文章于 2024-08-25 00:48:45 发布
阅读量1.2w 收藏 196
点赞数 68
分类专栏： 数据结构与算法分析 文章标签： 单链表 排序算法 增删改查反转 C语言 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_16933601/article/details/105125038
版权

文章目录

1.链表的定义

  链表，别名链式存储结构或单链表，用于存储逻辑关系为 “一对一” 的数据。链表中每个数据的存储都由以下两部分组成：
  1.数据元素本身，其所在的区域称为数据域。
  2.指向直接后继元素的指针，所在的区域称为指针域。
在这里插入图片描述

  图 3 所示的结构在链表中称为节点。也就是说。链表实际存储的是一个一个的节点，真正的数据元素包含在这些节点中，如图 4 所示：
在这里插入图片描述

  因此，链表中每个节点的具体实现，需要使用 C 语言中的结构体，具体实现代码如下。

2.准备工作

  首先包含头文件，定义链表结构体，产生随即链表的范围，定义全局头尾节点。

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define MAX 10
/*定义链表*/
typedef struct Node 
{
    int data;
    struct Node *next;  
}Node;
/*定义全局头尾节点*/
Node *head = NULL;
Node *end = NULL;

3.创建链表

/*根据传入的参数添加链表节点*/
int CreatList(int a)
{
    /*定义临时结构体并分配空间*/
    Node *temp = (Node *)malloc(sizeof(Node));
    if (temp ==NULL)
    {
        printf("malloc error!");
        return -1;
    }
    else
	{
		/*给数据类型赋值*/
		temp->data = a;
		temp->next = NULL;
		/*如果链表长度为0*/
		if (head == NULL)
		{
			head = temp; 
			end = temp;    
		}
		else
		{
			end->next = temp;
			end = temp;
		}
    }  
}

4.打印链表

/*打印链表*/
void PrintList(Node *temp)
{
    if(temp == NULL)
    {
        printf("Empty List！\r\n");
    }
    while (temp)
    {
       printf("%d",temp->data);
       temp = temp->next;
	   if(temp)
	   printf("->");
    }
    printf("\r\n");
}

5.在节点后面插入元素

  向链表中增添元素，根据添加位置不同，可分为以下 3 种情况：
  1.插入到链表的头部（头节点之后），作为首元节点；
  2.插入到链表中间的某个位置；
  3.插入到链表的最末端，作为链表中最后一个数据元素；

  虽然新元素的插入位置不固定，但是链表插入元素的思想是固定的，只需做以下两步操作，即可将新元素插入到指定的位置：
  a.将新结点的 next 指针指向插入位置后的结点；
  b.将插入位置前结点的 next 指针指向插入结点；

  例如，我们在链表 {1,2,3,4} 的基础上分别实现在头部、中间部位、尾部插入新元素 5，其实现过程如图 所示：

在这里插入图片描述

/*根据传入的数，在其后面增加元素*/
int InsertListEnd(int index,int a)
{
    if (head == NULL)
    {
        printf("Empty List！\r\n");
        return 0;
    }
	if (FindList(index)->next == FindList(a))
		return 0;
	else
	{
	  /*找到传入值的位置并保存*/
		Node *temp = FindList(index);
		/*分配空间存放新的传入的值*/
		Node *pt = (Node *)malloc(sizeof(Node));
		pt->data = a;
		/*是否是最后一个元素*/
		if (temp == end)
		{
			//尾巴的下一个指向新插入的节点
			end->next = pt;
			//新的尾巴
			end = pt;
			end->next = NULL;
		}
		else
		{
			// 先连后面 （先将要插入的节点指针指向原来找到节点的下一个）
			pt->next = temp->next;
			//后连前面
			temp->next = pt;
			printf("The list after insert %d is \r\n",a);
			PrintList(head);
		}
	}

}

6.在元素前面插入元素

/*根据传入的数，在其前面增加元素*/
int InsertListHead(int index,int a)
{
    if (head == NULL)
    {
        printf("Empty List！\r\n");
        return 0;
    }

	   /*找到传入值的位置并保存*/
		Node *temp = FindList(index);
		/*分配空间存放新的传入的值*/
		Node *pt = (Node *)malloc(sizeof(Node));
		pt->data = a;
		/*是否是第一个元素*/
		if (temp == head)
		{
			//尾巴的下一个指向新插入的节点
			pt->next = head;
			//新的头
			head = pt;
		}
		else
		{
			/*寻找到要插入位置的前驱节点*/
			Node *pre = FindPreNode(temp);
			pre->next = pt;
			pt->next = temp;
			printf("The list after insert %d is \r\n",a);
			PrintList(head);
		}


}

### 7.删除链表元素，要注意删除链表尾还是链表头
&emsp;&emsp;从链表中删除指定数据元素时，实则就是将存有该数据元素的节点从链表中摘除，但作为一名合格的程序员，要对存储空间负责，对不再利用的存储空间要及时释放。因此，从链表中删除数据元素需要进行以下 2 步操作：

&emsp;&emsp;1.将结点从链表中摘下来;
&emsp;&emsp;2.手动释放掉结点，回收被结点占用的存储空间;

&emsp;&emsp;其中，从链表上摘除某节点的实现非常简单，只需找到该节点的直接前驱节点 temp，执行一行程序：

```c
temp->next=temp->next->next;
```

&emsp;&emsp;例如，从存有 {1,2,3,4} 的链表中删除元素 3，则此代码的执行效果如图 2 所示：

在这里插入图片描述

/*删除链表头*/
void DeleteListHead()
{ //记住旧头
	Node *temp = head;
	//链表检测
	if (NULL == head)
	{
		printf("Empty list!\n");
		return;
	}

	head = head->next; //头的第二个节点变成新的头
	free(temp);
}
/*尾删除————删*/
void DeleteListTail()
{
	if (NULL == end)
	{
		printf("链表为空，无需删除\n");
		return;
	}
	//链表不为空
	//链表有一个节点
	if (head == end)
	{
		free(head);
		head = NULL;
		end = NULL;
	}
	else
	{
		//找到尾巴前一个节点
		Node *temp = head;
		while (temp->next != end)
		{
			temp = temp->next;
		}
		//找到了，删尾巴
		//释放尾巴
		free(end);
		//尾巴迁移
		end = temp;
		//尾巴指针为NULL
		end->next = NULL;
	}
}
/*删除链表任意元素*/
void DeleteList(int a)
{
   //链表判断 是不是没有东西
	if (NULL == head)
	{
		printf("Empty list!\n");
		return;
	}
	//链表有东西，找这个节点
	 Node *temp = FindList(a);
	if (NULL == temp)
	{
		printf("%d not find\r\n",a);
		return;
	}
	//找到了,且只有一个节点
	if (head == end)
	{
		free(head);
		head = NULL;
		end = NULL;
        printf("The list after delete %d is empty!\r\n",a);
       
	}
	else if (head->next == end) //有两个节点
	{
		//看是删除头还是删除尾
		if (end == temp)
		{
			DeleteListTail();
            printf("The list after delete %d is \r\n",a);
            PrintList(head);
		}
		else if (temp == head)
		{
			DeleteListHead();
            printf("The list after delete %d is \r\n",a);
            PrintList(head);
		}
	}
	else //多个节点
	{
		//看是删除头还是删除尾
		if (end == temp)
			DeleteListTail();
		else if (temp == head)
			DeleteListHead();
		else //删除中间某个节点
		{	//找要删除temp前一个，遍历
			Node *pt = head;
			while (pt->next != temp)
			{
				pt = pt->next;
			}
			//找到了
			//让前一个直接连接后一个 跳过指定的即可
			pt->next = temp->next;
			free(temp);
            printf("The list after delete %d is \r\n",a);
            PrintList(head);
		}
	}
    
}

防止恶意转载
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_16933601/article/details/105125038

8.根据传入的数值查询链表

/*根据传入的数值，查询链表*/
Node *FindList(int a)
{
    Node *temp = head;
    if(head == NULL)
    {
        printf("Empty List！\r\n");
        return NULL;
    }
  
    else
    {
       while (temp)
       {
           if (temp->data == a)
           {
                printf("%d find!\r\n",a);
                return temp;
           }
           temp = temp->next;
       }
            printf("%d not find!\r\n",a);
            return 0;
    }
    
}

9.修改链表元素

/*修改链表元素,element为要修改的元素，modify为修改后的值*/
void ModifyList(Node *phead,int element,int modify)
{
	Node *temp = phead;
	while((temp!= NULL))
	{
		
		if(temp->data == element)
		{
			temp->data	= modify;
			
		}	
		temp = temp->next;
	}
}

10.求链表长度

/*求链表长度并返回*/
int LengthList(Node *temp)
{
    int length = 0;
    while (temp)
    {
        length++;
        temp = temp->next;
    }
    return length;
    
}

11.前驱，后继节点的查找

Node *FindPreNode(Node *p)
{
	Node *temp = head;
	/*寻找p的前驱节点*/
	if(p == head)
	{
		printf("%d is head node\r\n",p->data);
		return NULL;
	}
	else
	{
		while((temp->next != p) && (temp !=NULL))
		{
			
			temp = temp->next;

		}
		return temp;		
	}

}
Node *FindNextNode(Node *p)
{
	Node *temp = head;
	/*寻找p的后继节点*/
	while(temp &&(temp != p))
	{
		temp = temp->next;

	}
	/*先不判断是否为尾节点，尾节点NULL也可以赋值*/
	temp = temp->next;
	return temp;
	 
}

12.倒置链表

/*方法一：倒置链表*/
Node *InvertList(Node *phead)
{
        if(phead == NULL || phead->next == NULL)
		{
                return phead;
        }
		else
		{
                Node *p = phead;
                Node *q = NULL;
                Node *r = NULL;
                while(p != NULL)
				{
						/*保存下一个节点*/
                        q = p->next;
						/*让该节点指向上一个节点*/
                        p->next = r;
						/*上一个节点走到当前节点*/
                        r = p;
						/*当前节点走到下一个节点*/
                        p = q;
                }
				head = r;
                return head;
        }
}
/*方法二：倒置链表*/
 Node *ReverseList(Node *phead)
    {
		/*创建一个新链*/
		/*两个指针，一个指向新的链表，一个指向单个断开的节点元素。连接起来*/
        Node *ptmp = NULL;
        Node *tmp = NULL;
		/*处理链表为空*/
        if(NULL == phead)
		{
                printf("link is empty\n");
                return NULL;
        }else
		{
				/*将旧链上的结点链到新链上*/
                while(phead != NULL)
				{
                        tmp = phead;
                        phead = phead->next;
						/*连接到上一次存下来的连表上。第一次时，ptmp为空，整个链表赋值给tmp后只剩下第一个元素*/
                        tmp->next = ptmp;
						/*新的链表赋值给ptmp*/
                        ptmp = tmp;
                }
        }
		head = ptmp;
        return ptmp;
}

13.判断链表是否有环

/*判断链表有环*/
int Is_Circular(Node *phead)
{
        if(phead == NULL || phead->next == NULL){
                return 0;       
        }
		/*快慢指针，当二者相等时，一定有环*/
        Node *p1 = phead;
        Node *p2 = phead;
        while(p1 != NULL && p2 != NULL){
                p2 = p2->next; 
                if(p1 == p2)
                        return 1;
                p2 = p2->next;
                p1 = p1->next;
        }
        return 0;
}

测试函数

int main ()
{
    int i = 0;  
    /*设置获得随机数的种子（固定代码，没有这句，随机数是固定不变的）测试可以不加*/
	srand((int)time(0)); 
    for (i =5;i>0;i--)
	CreatList(rand()%MAX);
	// CreatList(i);
	printf("新创建的的链表为:");
	PrintList(head);
	InsertListHead(4,10);
	printf("在4前插入10后的链表为:");
	PrintList(head);
	InsertListEnd(4,10);
	printf("在4后插入10后的链表为:");
	PrintList(head);
	DeleteList(0);
	printf("删除0后的链表为:");
	PrintList(head);
	Node *p = FindList(7);
	Node *q = FindList(4);
	ModifyList(head,1,15);
	printf("修改1为15后的链表为:");
	PrintList(head);
	ReverseList(head);
	printf("反转后的链表为:");
	PrintList(head);
	printf("链表长度为:%d",LengthList(head));
    return 0;
}

测试截图
在这里插入图片描述
关于排序算法的讲解将在下节单链表的5种排序算法介绍。

以上代码均为测试后的代码。如有错误和不妥的地方，欢迎指出。

嵌入式与Linux那些事
关注
专栏目录
Java单链表增删改查的实现
08-15
下面我们将详细探讨如何在Java中实现单链表的增、删、改、查功能，以及如何进行选择排序、冒泡排序和反转排序。 1. **单链表的定义**： - 单链表的每个节点通常包括两部分：数据域（存储元素）和指针域（存储下一...
单链表——基本操作（求表长、查找、插入、删除）(java)
IFollowRivers
04-13 2590
public class LinkedList { public Node first;//定义头结点 public LinkedList(){ this.first=null; } //定义节点类 public class Node{ int data; Node next=null; public Node(int data){ this.data=
链表的增删改查
最新发布
l602248的博客
08-25 547
以下为链表的增删改查的代码，大家如果有疑问，欢迎在评论区说出你的疑问，我们一起探讨。增：添加(创建)节点。
数据结构：（c实现）单向链表，单链表的头增，尾增，头删，尾删，任意位置的删除与插入。
qq_51004011的博客
05-13 1286
一：什么是单链表 （1）单链表节点数据结构 （2）单链表结构物理图解 二：单链表的几种接口函数的实现 （1）单链表的尾插函数（顺序插入） (2)单链 链表一般分成两块：一部分存储数据，另一部分存储下一个节点的指针。 链表与顺序表不同，链表的存储形式不是一块物理地址连续的空间。而是在内存中随机存储。需要存入一个新的数据时，就malloc开辟一个新的节点。并将新开辟的空间的地址放置到上一个节点的指针中。 再将该节点的指针赋NULL。 ...
单链表的创建、插入、删除、查找、遍历等功能（C语言实现）
weixin_46626833的博客
05-25 4754
下面展示一些 内联代码片。 //用到的头文件、结构体 #include <stdio.h> #include <stdlib.h> typedef int elemtype; typedef struct node { elemtype data; struct node *next; }LinkList; int i;//记录链表节点的个数(除头结点) //头插法创建链表 LinkList *creat_LinkListF() { i = 0;
c语言单链表的实现，包括链表的创建、插入、查询、删除、打印、长度计算
weixin_44818115的博客
11-25 636
#include <stdio.h> #include <stdlib.h> typedef struct node{ char data; struct node *next; }LINKLIST; // 链表初始化操作,返回一个空链表 LINKLIST *INITLIST() { LINKLIST *head; head = (LINKLIST*)malloc(sizeof(LINKLIST)); head->next = NULL; return h
JS实现数组的增删改查操作示例
10-18
本篇文章将深入讲解如何使用JavaScript实现数组的增删改查操作，这些操作是编程中不可或缺的基础技能。 1. **数组的增加** - `push()` 方法用于在数组的末尾添加一个或多个元素，并返回新的长度。例如： ```...
ssm.zip_ssm+bootstrap_ssm增删改查
09-21
这个"ssm.zip_ssm+bootstrap_ssm增删改查"项目，显然是一个用于教学目的的实例，旨在帮助新手理解和掌握如何在SSM基础上集成Bootstrap实现数据的增删改查功能。 首先，Spring框架作为核心，主要用于控制反转（IoC）...
JavaScript数组常用的增删改查与其他属性详解
10-14
JavaScript数组是编程中常用的数据结构，它提供了丰富的操作方法，用于执行增删改查等操作。本文将深入探讨这些常用的方法及其应用场景。 1. **数组的插入** - `push()` 方法：向数组的末尾添加一个或多个元素，并...
使用C语言写带头结点的链表，含有创建、输出、查找、删除、插入、合并
hua_you_qiang的博客
03-15 4766
用C语言写出带头结点的链表那些带头结点的链表的题目必要代码定义一个结构体创建一个带头结点的单链表 今天有一位学弟在网上向我吐血求助，让我帮他写c语言带头结点的链表题目。 我想了想，c语言我有一年半载没有接触了。正好温习温习一下，就写下此博客，来回顾一下我学习c语言的汗(Lei)水(Shui)与快(Tong)乐(Ku)。尽管我没有老师写的那么详尽，也没有教科书式的讲的那么专业。但我是站在学生的角度去...
C语言版数据结构中单链表的插入，查找，删除，排序与逆置
qq_55921267的博客
10-03 1830
感言 其实吧，这是我第一次在csdn里上传我写的代码，其实我写这个的初衷是为了和大家分享自己的一些思路，听取他人的意见，弥补自己不足（本人刚开始接触数据结构，是个在校大学生）。初来咋到，不足处还望各位海涵，如果代码中有什么不好，或者不对的用法，欢迎在评论区留言，一起讨论，一起进步。 单链表 单链表~~删除线格式~~ ...
c语言 链表操作,单链表及基本操作（C语言）
weixin_33585909的博客
05-19 502
#include #include /*** 含头节点单链表定义及基本操作*///基本操作函数用到的状态码#define TRUE 1;#define FALSE 0;#define OK 1;#define ERROR 0;#define INFEASIBLE -1; //当不可行时const int OVERFLOW = -2; //当溢出时//Status是新定义的一种函数返回值类型...
初学单链表，分享两道作业题（C语言）
qq_27846147的博客
04-13 1006
【题目1】有一个带头结点的单链表L，其数据元素递增有序。插入任一数据e使其元素仍然有序。 代码实现： #include "stdio.h" #include "stdlib.h" #define error -1 #define ok 1 typedef struct LNode{ int data; struct LNode *next; }LNode; void create_list(LNode *L) { printf("Please input numbers until '9999' is
[数据结构（C语言）]单链表的定义，实现初始化、创建、插入、增、删、改、查等基本操作
DuFengYa的博客
06-06 3990
首先，让我们回顾一下顺序表的优缺点： 采用链式存储结构的线性表称为链表。 链表有单链表、循环链表和双向链表等多种类型。链表中，不仅需要存储每个数据元素，还需存储其直接后继的存储地址，这两部分数据信息组 合起来称为结点。 每个结点只包含一个指针域的链表，称为单链表。 最后一个结点的指针域为NULL，在图中记为^。first是头指针，指向链表中的第一个结点，链表中的第一个结点称为头结点 目录头文件及函数声明等：菜单函数：初始化链表：显示元素：添加元素：​编辑插入元素：​编辑删除元素：​编辑 查找元素：修改元素：
【数据结构 C++】线性表（二）链式存储
qq_45397526的博客
03-28 1297
链式存储与顺序存储有一些不同的地方，而且比顺序存储要难。 在了解链式存储之前，我们先回顾一下指针。 链式存储一、指针1、什么是指针2、指针变量1）、定义指针变量：int *p；2）、程序中的*p（除定义外）3、指针与数组1）、指针与数组名2）、指针数组二、链表1、链表定义2、头结点3、链表实现1）、定义节点类2）、定义链表类3）、构造函数4）、析构函数5）、返回链表的长度6）、返回链表i处的节点值...
数据结构与算法——链式存储（链表）的插入及删除
业精于勤荒于嬉
05-10 9416
持续分享嵌入式技术，操作系统，算法，c语言/python等，欢迎小友关注支持 上篇文章我们讲述了链表的基本概念及一些查找遍历的方法，本篇我们主要将一下链表的插入删除操作，以及采用堆栈方式如何创建链表。 链表的插入 首先我们先看一下链表的插入是如何实现的 在单链表中第i个数据元素之前插入一个数据元素，需要首先在单链表中找到第i-1个结点并由指针pre指示，然后申请一个新的结点并由指针p指示，其数据域的值为x，并让p结点的指针域指向第i个结点，然后修改第i-1个结点的指针使其指向s 算法.
【数据结构】线性表：链式存储--链表（8种） C语言实现
crr411422的博客
03-23 1929
线性表的链式存储结构的特点是用一组任意的存储单元存储线性表的数据元素（这组存储单元可以是连续的，也可以是不连续的）。每个数据元素除了存储其本身的信息之外，还存储一个指示其直接后继的信息（基地址指针），所以数据元素有两个域：数据域和指针域。
评论 21
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

嵌入式与Linux那些事

您的鼓励将使我写出更好的文章

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值