双向链表(1) - 基本介绍以及插入节点

最新推荐文章于 2024-08-03 09:58:03 发布
最新推荐文章于 2024-08-03 09:58:03 发布
阅读量1.2w 收藏 37
点赞数 14
分类专栏： 数据结构和算法 文章标签： 双向链表 双向链表的插入操作 双向链表插入
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/shltsh/article/details/46485679
版权

目录

1.概念

2.与单链表对比

2.1相比单链表的优势

2.2相比单链表的缺点

3.DLL的插入操作

4.链表头部插入一个节点(5个步骤)

5.指定节点的后面插入新节点(7个步骤)

6.链表的尾部插入新节点(7个步骤)

7.指定节点的前面插入新节点(7个步骤)

8.实现所有插入操作的完整程序

1.概念

双向链表(doubly linked list - DLL)的操作，与单链表很大程度上有相似之处。在开始本篇文章前，可以先回顾下单链表的类似操作。
参考本博客中单链表系列中的这两篇文章：”单链表(1) - 介绍“， ”单链表(3) - 插入节点“。

一个双向链表包含一个额外的指针，称之为前向指针(prev pointer)，与单链表中的后向指针(next pointer)一起来标识一个节点。


下面是使用C++代码来表示一个DLL的例子：

//双向链表中的节点元素
struct Node
{
  int data;
  Node *next; // 指向下一个节点
  Node *prev; // 指向前一个节点
};

2.与单链表对比

与单链表相比，双向链表有下面的这些优点和缺点。

2.1相比单链表的优势

1) DLL支持正向和逆向的遍历方式。
2) DLL中的删除操作更有效，如果提供了要删除节点的指针。
这是因为，在单链表中如果要删除一个节点，则必须要知道前一个节点。有时为了得到这前一个节点，需要遍历整个链表，而在双向链表中，使用前向指针就可以很方便的得到前一个节点。

2.2相比单链表的缺点

1) DLL的每个节点，需要额外空间来保存前向指针。
    其实可以使用一个指针来实现双向链表。
    具体可以参考本博客的"高级数据结构"系列中的下面这两篇文章："高级链表 - 异或链表(1)" 以及 "高级链表 - 异或链表(2)"。
2) 所有的操作，都需要维护前向指针。例如，插入操作时，需要同时更改前向和后向指针。

3.DLL的插入操作

可以使用4种方式添加一个节点：
1) 在DLL的头部
2) 在一个指定节点的后面
3) 在DLL的尾部
4) 在一个指定节点的前面

4.链表头部插入一个节点(5个步骤)

新的节点通常添加到DLL的头部前面，并且变成新的头部节点。
例如，对于一个双向链表10<->15<->20<->25，在头部插入一个节点5， 则会变成了5<->10<->15<->20<->25。
假设在链表头部进行节点插入的函数称之为push()。则这个push函数需要知道头指针，因为push必须将头指针指向新的节点。
下面是具体操作的5个步骤。

// 给定链表的头指针(head)以及一个整数，插入一个新的节点至链表的头部
// 之所以传入双指针，因为函数中需要修改链表
void push(Node** head, int newData)
{
	//1. 分配新节点内存
	Node* newNode = new Node;

	//2. 赋值
	newNode->data = newData;

	//3. 将原始头节点做为新节点的后向指针，而前向指针置为NULL
	newNode->next = (*head);
	newNode->prev = NULL;

	//4. 将原始头节点的前向指针置为新的节点
	if ((*head) != NULL)
		(*head)->prev = newNode;

	//5. 将头指针置为新的节点
	(*head) = newNode;
}

上面的前4个步骤，与单链表中插入节点至头部的操作步骤是一样的。只是这里新增了一个步骤，就是改变了头部的前向指针。

5.指定节点的后面插入新节点(7个步骤)

假设指定的节点为 prevNode, 然后在此节点的后面插入新的节点。

//插入一个节点至指定节点的后面
void insertAfter(Node* prevNode, int newData)
{
	// 1. 检查指定节点是否为NULL
	if (prevNode == NULL)
	{
		std::cout << "the given previous node cannot be NULL" << std::endl;
		return;
	}

	// 2. 分配新节点内存
	Node* newNode = new Node;

	// 3. 赋值
	newNode->data = newData;

	// 4. 将指定节点的后向指针，做为新节点的后向指针
	newNode->next = prevNode->next;

	// 5. 将新节点做为指定节点的后向指针
	prevNode->next = newNode;

	// 6. 将指定节点做为新节点的前向指针
	newNode->prev = prevNode;

	// 7. 调整新节点的后续节点的前向指针
	if (newNode->next != NULL)
		newNode->next->prev = newNode;
}

上面的前5个步骤，与单链表中插入节点至指定节点的后面的操作步骤是一样的。只是这里新增了两个步骤。即新节点的前向指针，以及新节点的后续节点的前向指针。
根据step4，step5可知，修改后向指针时，是从右到左的顺序，即先改变新节点的后向指针，再改变给定节点的后向指针。
而根据step6，step7可知，修改前向指针时，是从左到右的顺序，即先改变新节点的前向指针，再改变后续节点的前向指针。

6.链表的尾部插入新节点(7个步骤)

这种情况下，新节点通常插入到最后一个节点的后面。
例如，对于双向链表5<->10<->15<->20<->25，在尾部插入新的节点30，则链表最终变成5<->10<->15<->20<->25<->30。
因为通常一个链表是用头节点来表示的，所以必须遍历整个链表，将最后一个节点的后向指针置为新节点。
下面是具体的7个实现步骤。

// 给定链表的头指针(head)以及一个整数，插入一个新的节点至链表的尾部
void append(Node** head, int newData)
{
	// 1. 分配新节点内存
	Node *newNode = new Node;
	Node *last = *head;  //链表的尾部指针，用于step5

	// 2. 赋值
	newNode->data = newData;

	// 3. 新节点将成为尾节点，所以后向指针为NULL
	newNode->next = NULL;

	// 4. 如果是空链表，则直接将新节点设置为头节点
	if (*head == NULL)
	{
		newNode->prev = NULL;
		*head = newNode;
		return;
	}

	// 5. 如果不是空链表，则遍历链表，获取尾节点
	while (last->next != NULL)
		last = last->next;

	// 6. 修改尾节点的后向指针为新节点
	last->next = newNode;

	// 7. 修改新节点的前向指针为原始尾节点
	newNode->prev = last;

	return;
}

上面的前7个步骤，与单链表中进行相应操作的前6个步骤相同。新增的1个步骤是修改新节点的前向指针。

7.指定节点的前面插入新节点(7个步骤)

假设指定的节点为 nextNode，然后在此节点的前面插入新的节点。

void insertBefore(Node* nextNode, int newData)
{
	// 1. 检查指定节点是否为NULL
	if (nextNode == NULL)
	{
		printf("the given previous node cannot be NULL");
		return;
	}

	// 2. 分配新节点内存
	Node* newNode = new Node;

	// 3. 赋值
	newNode->data = newData;

	// 4. 将指定节点的前向指针，做为新节点的前向指针
	newNode->prev = nextNode->prev;

	// 5. 将新节点做为指定节点的前向指针
	nextNode->prev = newNode;

	// 6. 将指定节点做为新节点的后向指针
	newNode->next = nextNode;

	// 7. 调整新节点的前面节点的后向指针
	if (newNode->prev != NULL)
		newNode->prev->next = newNode;
}

8.实现所有插入操作的完整程序

#include <iostream>

struct Node {
    int data;
    Node* next; // 指向下一个节点
    Node* prev; // 指向前一个节点
};

// 给定链表的头指针(head)以及一个整数，插入一个新的节点至链表的头部
// 之所以传入双指针，因为函数中需要修改链表
void push(Node** head, int newData) {
    //1. 分配新节点内存
    Node* newNode = new Node;

    //2. 赋值
    newNode->data = newData;

    //3. 将原始头节点做为新节点的后向指针，而前向指针置为NULL
    newNode->next = (*head);
    newNode->prev = NULL;

    //4. 将原始头节点的前向指针置为新的节点
    if ((*head) != NULL)
        (*head)->prev = newNode;

    //5. 将头指针置为新的节点
    (*head) = newNode;
}

//插入一个节点至指定节点的后面
void insertAfter(Node* prevNode, int newData) {
    // 1. 检查指定节点是否为NULL
    if (prevNode == NULL) {
        std::cout << "the given previous node cannot be NULL";
        return;
    }

    // 2. 分配新节点内存
    Node* newNode = new Node;

    // 3. 赋值
    newNode->data = newData;

    // 4. 将指定节点的后向指针，做为新节点的后向指针
    newNode->next = prevNode->next;

    // 5. 将新节点做为指定节点的后向指针
    prevNode->next = newNode;

    // 6. 将指定节点做为新节点的前向指针
    newNode->prev = prevNode;

    // 7. 调整新节点的后续节点的前向指针
    if (newNode->next != NULL)
        newNode->next->prev = newNode;
}

// 给定链表的头指针(head)以及一个整数，插入一个新的节点至链表的尾部
void append(Node** head, int newData) {
    // 1. 分配新节点内存
    Node* newNode = new Node;
    Node* last = *head;  //链表的尾部指针，用于step5

    // 2. 赋值
    newNode->data = newData;

    // 3. 新节点将成为尾节点，所以后向指针为NULL
    newNode->next = NULL;

    // 4. 如果是空链表，则直接将新节点设置为头节点
    if (*head == NULL) {
        newNode->prev = NULL;
        *head = newNode;
        return;
    }

    // 5. 如果不是空链表，则遍历链表，获取尾节点
    while (last->next != NULL)
        last = last->next;

    // 6. 修改尾节点的后向指针为新节点
    last->next = newNode;

    // 7. 修改新节点的前向指针为原始尾节点
    newNode->prev = last;

    return;
}

//插入一个节点至指定节点的前面
void insertBefore(Node* nextNode, int newData) {
    // 1. 检查指定节点是否为NULL
    if (nextNode == NULL) {
        printf("the given previous node cannot be NULL");
        return;
    }

    // 2. 分配新节点内存
    Node* newNode = new Node;

    // 3. 赋值
    newNode->data = newData;

    // 4. 将指定节点的前向指针，做为新节点的前向指针
    newNode->prev = nextNode->prev;

    // 5. 将新节点做为指定节点的前向指针
    nextNode->prev = newNode;

    // 6. 将指定节点做为新节点的后向指针
    newNode->next = nextNode;

    // 7. 调整新节点的前面节点的后向指针
    if (newNode->prev != NULL)
        newNode->prev->next = newNode;
}

void printList(Node* head) {
    Node* last = NULL;
    std::cout << "Traversal in forward direction " << std::endl;
    while (head != NULL) {
        std::cout << " " << head->data << " ";
        last = head;
        head = head->next;
    }
    std::cout << std::endl;

    std::cout << "Traversal in reverse direction " << std::endl;
    while (last != NULL) {
        std::cout << " " << last->data << " ";
        last = last->prev;
    }
    std::cout << std::endl;
}


int main() {
    //初始化为空链表
    Node* head = NULL;

    // 插入节点6.  链表变为：6->NULL
    append(&head, 6);

    // 插入节点7，链表变为：7->6->NULL
    push(&head, 7);

    // 头部插入节点1，链表变为：1->7->6->NULL
    push(&head, 1);

    // 尾部插入节点4，链表变为：1->7->6->4->NULL
    append(&head, 4);

    // 在节点7后面插入节点8，链表变为：1->7->8->6->4->NULL
    insertAfter(head->next, 8);
    // 节点8之前插入节点9，链表变为：1->7->9->8->6->4->NULL
    insertBefore(head->next->next, 9);

    std::cout << "Created DLL is: " << std::endl;
    printList(head);

    return 0;
}

运行结果：
Created DLL is:
Traversal in forward direction
 1  7  9  8  6  4
Traversal in reverse direction
 4  6  8  9  7  1

水草
关注
专栏目录
链表---双向链表之节点的增删改查
BEYONDmonster的博客
09-04 1174
双向链表： 双向链表是在单向链表的基础上，在每个节点上加了一个向前的指针。这俩个指针分别指向直接后继和直接前驱，使得双向链表更加方便。 Java代码实现： (代码中有注释) public class DoubleLinkedlistDemo { public static void main(String[] args) { // TODO Auto-generated method stub ...
数据结构--双向链表（图文）
SouTY_C的博客
06-26 1117
双向链表相较于单链表的优势在于可以快速访问和操作节点的相邻元素，尤其在需要频繁插入或删除元素的场景中，它提供了更高效的数据操作方式。双向链表常用于实现高级数据结构，如栈、队列、列表等，并且在某些编程语言的标准库中，如C++的STL和Java的LinkedList，都提供了双向链表的实现。双向链表在每个节点处都维护了两个指针，一个指向前一个节点（称为前驱节点），另一个指向下一个节点（称为后继节点）。：头节点的后继指针指向尾节点，尾节点的前驱指针又指回头节点，这样的双向链表形成一个环。情况一：链表只有头节点。
数据结构——11 有序双向链表中插入节点
langtaol的成长记
08-18 3307
双向链表——有序双向链表中插入节点
数据结构：双向链表
最新发布
2401_86551514的博客
08-03 797
这里的“带头”跟“头节点”是两个概念，带头链表里的头节点，实际为“哨兵位”，哨兵位节点不存储任何有效元素，只是站在这里“放哨 的” ，存在的意义： 遍历循环链表避免死循环。虽然有这么多的链表的结构，但是我们实际中最常用还是两种结构：单链表和双向带头循环链表，上一篇我们已经讲了单链表，今天就来了解一下双向链表并将其实现。顺序表和链表我们都学了，两者各有各的优缺点，根据需求的不通，运用在不同的场景。本篇的内容就到这里了，希望对各位有帮助，如果有错误欢迎指出。还是老样子，在头文件里写出我们需要功能的函数名。
双向链表内结点的插入(C++)
04-22
在双向链表内插入一个结点，注释非常详细！适合菜鸟。网上下载的，觉得不错，和大家分享。
双向链表插入节点
weixin_34384557的博客
09-12 1730
双向链表插入节点 1、根据实例分析 2、把节点之间的关系看成 是边的拆除和重建 3、为了方便叙述，给边标了号 如图所示是我们要操作的结构体和在双向链表的图。 现在我们的目的就是在ab节点之间插入x节点。 现在我把这六条线都遍上号: 在插入之前，2,6这两条边是存在的，这两条边就是：   在插入之后，2,6这两条边不存在了，存在的边为4,1,3,5，这四条边就是： ...
双链表中插入节点（C语言实现）
zsx0728的博客
07-15 8654
文章目录1. 相关背景介绍1.1 双链表概念1.2 双链表的优势与劣势1.3 双链表插入节点的位置2. 不同位置插入数据2.1 在DLL的前端添加节点2.2 在给定节点之前添加节点2.3 在DLL的末尾添加节点2.4 在给定节点之后添加节点3. 综合示例参考文献 1. 相关背景介绍 1.1 双链表概念     相比SLL（singly linked list，单链表），DLL（Doubly Linked List，双链表）多了一个名为 previous pointer （Prev）的指针，该指针指向前一节点
双链表删除/插入节点
雪儿的专栏
08-02 695
//双链表删除节点 dnode *del(dnode *head, int num) { dnode *p1, *p2; p1 = head; while (num != p1->data && p1->next != NULL) { p1 = p1->next; } if (num == p1->data) { if (p1 == head) { head = head
双向链表插入、删除节点（详细图解+代码）
热门推荐
小菜鸟的进阶
02-01 3万+
双向链表 在单链表的基础上增加了前缀结点，一定程度上提升了查找元素的速度 在查找元素时，可以反向查找前缀结点 插入结点过程（分为4步） 这四个步骤的顺序可调整，但是必须要保证需要的链不断！！比如，如果先做④再做①，画红叉的链断了，p->next为新的结点node了，那么node又怎么和后面的接结点连上呢？后面的结点已经不能通过p来找到了。 删除结点（分两步） ...
双向链表插入删除基本应用介绍
09-05
下面我们将详细讨论双向链表的基本概念、插入和删除操作。 首先，我们定义双向链表的节点结构。如下所示： ```cpp struct DNode { int data; // 存储数据的成员 struct DNode *next; // 指向下一个节点的指针 ...
双向链表的基本操作-结点插入、结点删除、整表删除、正序遍历、逆序遍历
asfd_4的博客
07-15 1089
第二期 双向链表的基本操作
关于数据结构双向链表中插入节点的核心步骤探讨.pdf
08-07
在双向链表插入节点的算法中，通常会有四个指针指向发生变化，这四个操作步骤分别是： 步骤①：将新插入节点s的前驱指针指向插入位置节点p的前驱。这一步的目的是建立新节点与前一个节点的链接关系。 步骤②：将...
链表-使用C语言实现非循环双向链表-带头结点+尾结点.zip
03-13
本篇将详细介绍如何使用C语言来实现一个非循环双向链表，包括带头结点和尾结点的链表。 首先，让我们定义链表节点的数据结构。在非循环双向链表中，每个节点包含两个指针，分别指向它的前一个节点和后一个节点。...
双向链表 删除节点 插入节点
MISSmiley
10-06 726
Attention： 当删除的是最后一个节点时，
c语言双向链表插入一个节点,在双向链表指定节点后插入节点
weixin_42576467的博客
05-24 4488
要在列表中的指定节点之后插入节点，需要跳过所需数量的节点以便到达目标节点，然后根据需要调整指针。为此，请参考使用以下步骤。为新节点分配内存。 请使用以下语句。ptr = (struct node *)malloc(sizeof(struct node));使用指针temp遍历列表以跳过所需数量的节点以到达指定节点。temp=head;for(i=0;i{temp = temp->next;/...
双向链表，插入链表节点
Noah
07-17 301
双向链表-插入元素
WJHKDGHP的博客
12-10 681
不会写CSDN博客，所以试试 双向链表在一个有序数列中插入一个数，使之依旧有序。 #include #include #include #define len sizeof(struct node) #define newp (struct node*) malloc(len) struct node{ int num; struct node *next,*pre; }; stru
双向链表中节点的插入与删除操作
yuweilong000的专栏
08-18 592
不得不说  加上头结点的链表 确实方便！ #ifndef DLIST_H_INCLUDED #define DLIST_H_INCLUDED typedef int ElemType; struct node {     ElemType data;     struct node*prior;     struct node*next; };
双向链表的插入
weixin_52634719的博客
09-20 9537
概览: 已知p指针，那么a结点的地址就在p指针所指结点的prior里存着， a结点要变成s的前驱， 所以要给s的Prior域赋值，赋的是a结点的地址，即p的prior。 接下来 将s结点变成a结点的后继，就要给a结点的next域赋值，赋的是新插入结点的地址，而他此时在s里存着 a结点的next域就是p的前驱结点的next，即p->prior->next=s; 接下来s还要作为b的前驱，则又需要修改两个指针 一个呢是b作为新...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值