数据结构之双链表（双链表的创建头插法和尾插法详解）

原创 于 2025-11-05 19:43:00 发布 · 696 阅读 · 3 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#数据结构

一.前言

双链表的内容比较多，而且更加繁琐，我会分成几次来更新，所以会更的很慢，老实说我自己也不清楚能不能把数据结构更完，我写这个专栏主要还是为了利用费曼学习法来让自己更加深刻认识到数据结构的内容，在编程中还是会有很多我不清楚的地方，要走的路还有很多

二.认识双链表

双链表与链表的结构很相像，唯一不同的是，双链表里面有两个指针域，一个指向下一个节点，一个指向前一个节点，这就是他们之间最大的区别，在定义上，还是利用结构体

#include <stdio.h>
#include <stdlib.h>

typedef struct Node{
    int Data;
    struct Node* next;    //指向下一个节点
    struct Node* prev;    //指向上一个节点
}Node;

三.双链表的创建

双链表的建立和链表也基本一致，依旧是利用malloc来动态申请内存

Node* Node_Create(int value){
    Node* New_Node = (Node*)malloc(sizeof(Node));
    if(New_Node == NULL){
        printf("内存申请失败\r\n");
        return NULL;
    }
    New_Node->Data = value;
    New_Node->next = NULL;
    New_Node->prev = NULL;
    return New_Node;
}

创造的双链表，两个指针域都指向空

四.双链表的头插法

在这里的时候我是受到了一个人的启发，就是通过设置接口来选择函数里面的参数（作者并不是计算机专业的，所以对这个不是特别了解）我将从头插法到尾插法来依次操作

第一次我的思路

通过头插法，将后插入的节点插在旧节点的前面，一次插入一个节点

//头插法
//对head进行一次解引用，则表示头节点本身的地址；对head进行二次解引用则是这个结构体本身
Node* Node_head(Node** head, int value) {
	Node* New_Node = Node_Create(value);
	if (New_Node == NULL) {
		printf("插入失败\r\n");
		return NULL;
	}

	New_Node->next = *head;	//插入新节点在之前头节点之前
	New_Node->prev = NULL;	//插入新节点的前驱指针指向空

	if (*head != NULL) {	        //头节点存在
		(*head)->prev = New_Node;	//原来头节点的前驱节点指向新节点
	}

	*head = New_Node;	//更新头指针

	return *head;
}

但是可以注意到，我这个写法其实不是很规范。这其实是属于融合了两种写法，显得有点不伦不类了，一般而言，这样的函数接口一般是有两种格式。

第一种：通过返回Node*类型，在函数里面的参数采用正常的指针，然后将变化的头指针给返回出去

第二种：通过返回void类型，直接在函数里面的参数里使用二级指针，然后在函数里面改变这个头指针，返回值就不会返回任何东西

所以按照这个思路，我就开始了第二次写法

第二次我的思路

方法一：

//插入一个节点
//头插法2.1
//直接返回节点地址，参数不需要为二级指针
Node* Node_head_1(Node* head, int value) {
	Node* New_Node = Node_Create(value);
	if (New_Node == NULL) {
		printf("插入失败\r\n");
		return NULL;
	}
	New_Node->next = head;
	New_Node->prev = NULL;

	if(head != NULL) {
		head->prev = New_Node;
	}
	head = New_Node;
	return head;
}

方法二：

//头插法2.2
//返回值为void类型，在函数里面直接改变头指针，没有返回值
void Node_head_2(Node** head, int value) {
	Node* New_Node = Node_Create(value);
	if (New_Node == NULL) {
		printf("插入失败\r\n");
		return;
	}

	New_Node->next = *head;
	New_Node->prev = NULL;

	if(*head != NULL) {
		(*head)->prev = New_Node;
	}
	*head = New_Node;
	return;
}

再此之后，我开始想到一次插入多个节点，也是根据这两种方法

第三次我的思路

方法一：

//插入多个节点
//头插法3.1
//返回头指针
Node* Node_head_2_1(Node* head, int n, int value[]) {
	int index = n-1;
	for (int j = 0; j <= index; j++) {
		Node* New_Node = Node_Create(value[j]);
		if (New_Node == NULL)
		{
			printf("插入失败\r\n");
			return NULL;
		}
		New_Node->next = head;
		New_Node->prev = NULL;

		if (head != NULL) {
			head->prev = New_Node;
		}
		head = New_Node;
	}
	return head;
}

方法二：

void Node_head_2_2(Node** head, int n, int value[]) {
	int index = n - 1;
	for (int j = 0; j <= index; j++) {
		Node* New_Node = Node_Create(value[j]);
		if (New_Node == NULL) {
			printf("插入失败\r\n");
			return;
		}
		New_Node->next = *head;
		New_Node->prev = NULL;

		if (*head != NULL) {
			(*head)->prev = New_Node;
		}
		*head = New_Node;
	}
	return;
}

当然，如果你觉得只要有一次插入失败就全盘推出不符合你的需求，也可以在那一部分改成


		if (New_Node == NULL) {
			printf("这是在第%d个插入失败的\r\n",j);
			continue;
		}

将return改成continue就可以了

五.双链表的尾插法

通过尾插法，将新节点放到旧节点的后面，感觉更符合人的一般规律，所以我也更喜欢使用尾插法

也是一样的，我将根据两次不一样的接口来写代码

第一次每次插入一个节点

第一次我的思路

方法一：

//尾插法1.1
void Node_tail_1(Node** head, int value) {
	Node* New_Node = Node_Create(value);
	if (New_Node == NULL) {
		printf("插入失败\r\n");
		return;
	}
	if (*head == NULL) {
		//链表为空
		*head = New_Node;
		return;
	}
	//链表不为空
	Node* tail = *head;
	while (tail->next != NULL) {
		tail = tail->next;
	}
	tail->next = New_Node;
	New_Node->prev = tail;
	//tail = New_Node;由于tail是一个局部变量，在这里不需要更新尾指针
	return;
}

方法二：

//尾插法1.2
Node* Node_tail_2(Node* head, int value) {
	Node* New_Node = Node_Create(value);
	if (New_Node == NULL) {
		printf("插入失败\r\n");
		return NULL;
	}
	if (head == NULL) {
		//链表为空
		head = New_Node;
		return head;
	}
	//链表不为空
	Node* tail = head;
	while (tail->next != NULL) {
		tail = tail->next;
	}
	tail->next = New_Node;
	New_Node->prev = tail;
	//tail = New_Node;
	return head;
}

第二次我的想法也自然而然转到了插入多个节点上

第二次我的思路

方法一：

//尾插法2.1
//一次插入多个节点
//但是这个复杂度达到了O(n²) ，每次都要从头找尾
void Node_tail_2_1(Node** head, int n, int value[]) {
	for (int j = 0; j < n; j++) {
		Node* New_Node = Node_Create(value[j]);
		if (New_Node == NULL) {
			printf("插入失败\r\n");
			return;
		}
		if (*head == NULL) {
			//链表为空
			*head = New_Node;
			continue;	//进入下一轮
		}
		//链表不为空
		Node* tail = *head;
		while(tail->next != NULL) {
			tail = tail->next;
		}
		tail->next = New_Node;
		New_Node->prev = tail;
		//tail = New_Node;
	}
	return;
}

方法二：

//尾插法2.2
//一次插入多个节点
Node* Node_tail_2_2(Node* head, int n, int value[]) {
	for (int j = 0; j < n; j++) {
		Node* New_Node = Node_Create(value[j]);
		if (New_Node == NULL) {
			printf("插入失败\r\n");
			return NULL;
		}
		if (head == NULL) {
			//链表为空
			head = New_Node;
			continue;
		}
		//链表不为空
		Node* tail = head;
		while (tail->next != NULL) {
			tail = tail->next;
		}
		tail->next = New_Node;
		New_Node->prev = tail;
		//tail = New__Node;
	}
	return head;
}

但很明显，这两个代码的都会从头开始遍历一遍链表，复杂度加大，很明显会有很简单的方法

第三次我的思路

方法一：

//尾插法3.1
void Node_tail_3_1(Node** head, int n, const int value[])
{
	if (!head) return;          //防野指针
	if (value == NULL || n <= 0) return head;
	Node* tail = *head;         //缓存当前尾节点
	if (tail)                   //找到真尾
		while (tail->next)
			tail = tail->next;

	for (int j = 0; j < n; ++j)
	{
		Node* new_node = Node_Create(value[j]);
		if (!new_node)
		{
			printf("第 %d 个节点申请失败，已插 %d 个\n", j, j);
			continue;           //保留已插节点
		}

		new_node->next = NULL;
		new_node->prev = tail;

		if (tail)               //非空表
			tail->next = new_node;
		else                    //空表
			*head = new_node;

		tail = new_node;        //更新尾指针
	}
}

方法二：

//尾插法3.2
Node* Node_tail_3_2(Node* head, int n, int value[]) {
	if (value == NULL || n <= 0) return head;
	Node* tail = head;
	if (tail != NULL) {
		while (tail->next != NULL) {
			tail = tail->next;
		}
	}
	for (int j = 0; j < n; j++) {
		Node* New_Node = Node_Create(value[j]);
		if (New_Node == NULL) {
			printf("第%d个节点插入失败，已插入%d个\r\n", j, j);
			continue;
		}
		New_Node->prev = tail;
		New_Node->next = NULL;

		if (tail != NULL) {
			tail->next = New_Node;
		}
		else {
			head = New_Node;
		}
		tail = New_Node;
	}
	return head;
}

六.双链表的遍历

按照数组的规则，我习惯上将第一个字节命名为第0个

//遍历双链表
void Node_Printf(Node* head) {
	Node* L = head;
	int i = 0;
	while(L != NULL){
		printf("第%d个节点是%d\r\n", i, L->Data);
		i++;
		L = L->next;
	}
	return;
}

七.总结

主要还是一些很简单的内容，逻辑还是最重要的，然后其他的增删改查之类的操作，我打算放在下一讲

头插法建立双向链表
qq_40741513的博客
07-12 7144
单链表只能向后访问其他节点的数据，若需要寻找某节点前面节点的数据，则需要从表头开始，重新进行遍历，效率不高，为了克服单链表单向性的缺点，可以利用双向链表 双向链表有两个指针域，一个指向直接后继，一个指向直接前驱，头插法建立双链表的方法如下 结构体定义如下 typedef struct DuLNode{ int data; struct DuLNode *prior, *next; }DuLNode, *DuLNode; prior代表前驱，next代表后继 初始化头节点head,
数据结构：图文详解双向链表的各种操作（头插法，尾插法，任意位置插入，查询节点，删除节点，求链表的长度... ...）
luming的博客
12-03 6061
双向链表（Doubly Linked List）是一种数据结构，它与单向链表相似，但每个节点不仅包含指向下一个节点的指针，还包含指向上一个节点的指针。 双向链表的每个节点通常包含以下两个指针： - prev：指向上一个节点； - next：指向下一个节点。 通过这两个指针，可以在双向链表中沿着两个方向遍历。 相比于单向链表，双向链表能够更方便地进行插入和删除操作。因为每个节点包含指向前一个节点的指针，所以在删除或插入一个节点时，只需要修改该节点前后节点的指针即可。而在单向链表中，则需要... ...
头插法和尾插法的详细区别
SHIJIAHUAN1的博客
12-31 2万+
关于数据结构中头插法和尾插法的详细区别和优缺点
单链表建立——头插法和尾插法
SG_teresa's blog
05-20 3万+
引言 当我们准备采用单链表形式实现线性表，第一步就是要建立单链表，即初始化。由于链表是一个动态结构，不需要预先分配空间，因此生成链表的过程就是“逐个插入”的过程，插入结点的位置可以让我们自由选择，故有了“头插法”和“尾插法”这两种方法。 1、头插法（前插法） 课本的解释：通过将新结点逐个插入链表的头部（头节点之后）来创建链表，每次申请一个新结点，读入相应的数据元素值，然后将新结点插入到头结点之后。 重点：每次生成的新结点都是要与头结点相连接的，每个新结点都插在了原来第一个结点的前面。通过这种方法建立的链表是
【数据结构】单链表建立的头插法和尾插法
ly020111的博客
11-19 1万+
此篇文章主要介绍存在头结点的情况下的头插法和尾插法。 头插法与尾插法 1.头插法与尾插法的优缺点 头插法：优点：在不是空表的情况下，插入结点不需要从头到尾查找直到找到尾结点，效率较高 缺点：插入的顺序相反 尾插法：优点：插人的顺序相同 缺点：在不是空表的情况下，插人结点需要从头到尾查找直到找到尾结点，效率低 2.头插法实现与演示 头插法是如何实现的呢 首先，我得先拥有一个空表头，并把头结点指向最后一个录入的结点 以下...
数据结构——顺序表讲解（2）
dongxue727504的博客
02-26 1716
7000字博客，顺序表剩余内容讲解，顺序表的完成
“头插法”与“尾插法”建立线性链表的异同
爱学习的草莓熊
12-29 1万+
当我们建立一个线性链表的时候，可以使用不同的插入方式，一种被称为“头插法”，另一种被称为“尾插法”，这两种方法都能够建立链表，但最终使用时稍有区别。 采用头插法建立链表时，新加入的元素指向链表头，链表头指向新加入的元素。 假如现在有一个待插入数据的链表指针Head,程序中你用malloc()动态开辟了一个链表节点，并用一个叫temp的指针指向该节点，下面两句话能够将新节点以头插法链入链表
数据结构之双向链表详解
最新发布
小源_ 的博客
12-20 4174
本文着重讲解了LinkedList(无头双向单链表)的实现和LinkedList的使用。内附代码和图文分析，看完就会！
链表插入操作详解：头插法与尾插法入门指导
综上所述，链表的尾插法和头插法是构建链表时常用的基本操作，初学者通过实际编码练习这两种方法，可以快速掌握链表的基本操作和数据结构的特点。对于初学者来说，理解这些概念和方法对于学习更高级的数据结构和算法...
链表的头插法、尾插法与中间插入操作详解
综上所述，头插法、尾插法和中间插入作为链表的基本操作，不仅体现了链表灵活高效的特性，也为进一步掌握高级数据结构和算法打下坚实基础。熟练掌握这三种插入方法的原理、实现细节及其优缺点，对于提升编程能力、...
C++带头结点尾插法创建链表详解与实现
资源摘要信息:"带头结点尾插法创建链表是一种在数据结构中常用的技术，用于动态构建单向链表。该方法的核心思想是：在链表的末尾（即“尾部”）插入新的结点，从而保持数据的顺序性。本文档以C++语言为基础，结合...
数据结构（使用头插法实现双链表）
DMHY123的博客
07-20 1554
为什么使用双链表？
hashmap头插法和尾插法区别_一个跟面试官扯皮半个小时的HashMap（看这一篇就足够了）
Hanko的专栏
12-24 3883
前言 HashMap 应该算是 Java 后端工程师面试的必问题，因为其中的知识点太多，很适合用来考察面试者的 Java 基础。 开场 面试官: 你先自我介绍一下吧！ 安琪拉: 我是安琪拉，草丛三婊之一，最强中单（钟馗不服）！哦，不对，串场了，我是**，目前在–公司做–系统开发。 面试官: 看你简历上写熟悉 Java 集合，HashMap 用过的吧？ 安琪拉: 用过的。(还是熟悉的味道) 面试官: 那你跟我讲讲 HashMap 的内部数据结构？ 安琪拉: 目前我用的是 JDK1.8 版本的，内部使用数组 +
【数据结构】：单链表之头插法和尾插法（动图+图解）
热门推荐
仔仔木的博客
07-08 7万+
单链表，头插法和尾插法，有头结点，无头结点，详细解析，图解
双链表的初始化（头插和尾插）,插入，删除操作
Boyt1317的博客
10-16 2276
双链表的创建（全），插入和删除操作
双向循环链表的头插法和尾插法
weixin_50722786的博客
12-04 1830
我们平常学链表的时候会学单向不循环链表，单向循环链表，双向不循环链表，双向循环链表及内核链表，各种格式的链表。今天我因为忘记双向循环链表的头插法和尾插法的顺序了，特意写一篇文章来巩固一下。首先我根据顺序画一张图（尾插法） 尾插法示意图 头插法如下
头插法和尾插法
qq_36754161的博客
03-16 3041
链表的头插法和尾插法 表结构的声明 typedef int ElemType; typedef struct node //定义链表的结点的结构 { ElemType data;//定义链表的数据域 struct node *next;//定义链表中的指针域 }slink; 头插法 1，从一个空表开始，重复读入数据，生成新结点。 2，将读入数据存放到新结点的数据域中。 3，将新结点插入到当前...
Hashmap的结构，1.7和1.8有哪些区别
weixin_49193222的博客
12-04 1432
不同点： （1）JDK1.7用的是头插法，而JDK1.8及之后使用的都是尾插法，那么他们为什么要这样做呢？因为JDK1.7是用单链表进行的纵向延伸，当采用头插法时会容易出现逆序且环形链表死循环问题。但是在JDK1.8之后是因为加入了红黑树使用尾插法，能够避免出现逆序且链表死循环的问题。 （2）扩容后数据存储位置的计算方式也不一样：1. 在JDK1.7的时候是直接用hash值和需要扩容的二进制数进行&（这里就是为什么扩容的时候为啥一定必须是2的多少次幂的原因所在，因为如果只有2的n次幂的情况...
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值