双向链表的插入操作

最新推荐文章于 2025-09-12 17:31:31 发布

weixin_33714884

最新推荐文章于 2025-09-12 17:31:31 发布

阅读量108

点赞数

CC 4.0 BY-SA版权

文章标签：数据结构与算法

原文链接：http://www.cnblogs.com/LoveFishC/archive/2012/12/20/3846814.html

双向链表的插入操作

转载于:https://www.cnblogs.com/LoveFishC/archive/2012/12/20/3846814.html

确定要放弃本次机会？

福利倒计时

: :

立减 ¥

普通VIP年卡可用

立即使用

weixin_33714884

关注关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
分享

复制链接

分享到 QQ

分享到新浪微博

扫一扫
举报

举报

单双链表操作的注意事项——插入，删除，遍历操作

a15827584379的博客

05-27

1083

对链表进行操作时，代码的顺序会影响到程序的执行结果如：对双链表进行头部插入操作时，操作顺序为：此处new->pNext = pH->pNext;语句必须要在pH->pNext = new;之前执行，因为将new赋值给pH->pNext的操作会改变pH->pNext的值，而new->pNext = pH->pNext需要将pH->pNex...

形象的理解双向链表之插入

weixin_44425713的博客

09-22

1484

形象的理解双向链表之插入总体思路—前驱后继链表中前驱和后继就是指当前结点的前一个和后一个结点分别是什么，我们把要插入的结点作为当前结点。如图所示： q是为了便于理解自己添加的，对于原链表，实际上有： p->prior=q; p->prior->next=p;//q->next=p能理解吧？把q用p->prior代就完事了一.s的前驱和后继 1.前驱（即图①）—和前面结点相连 s->prior=q; 2.后继（即图③）—和后面结点相连 s->next=p;

参与评论您还未登录，请先登录后发表或查看评论

双链表( 初始化，建立，插入，查找，删除 )

weixin_30553837的博客

04-19

158

双向链表和单向链表也是有很多相似的地方的，听名字可以猜到，每个节点都包含两个指针，一个指针指向上一个节点，一个指针指向下一个节点。这里有两个特殊的地方，第一就是头节点的一个指针指向NULL空指针（没有前驱节点），第二就是尾节点的一个指针指向NULL指针（没有后继节点）。 #ifndef DOUBLY_LINKED_LIST_H #define DOUBLY_LINKED_LIST_H...

硬核复刻redis底层双向链表核心实现

禅与计算机程序设计的艺术

09-23

1453

因为近期收到很多读者的私信，所以也专门创建了一个交流群，感兴趣的读者可以通过上方的公众号获取笔者的联系方式完成好友添加，点击备注。因为近期收到很多读者的私信，所以也专门创建了一个交流群，感兴趣的读者可以通过上方的公众号获取笔者的联系方式完成好友添加，点击备注。自此笔者逐步从结构定义到函数操作一步一步的带读者诠释了笔者复刻redis底层双向链表的步骤，希望对你阅读笔者项目源码有所帮助。双向链表支持基于索引的方式查询，例如我们希望查询索引2节点的值，传入。

双向链表的插入及删除图解

热门推荐

c++菜鸟一只。

05-06

3万+

双向链表的插入第一步：首先找到插入位置，节点 s 将插入到节点 p 之前第二步：将节点 s 的前驱指向节点 p 的前驱，即 s->prior = p->prior; 第三步：将节点 p 的前驱的后继指向节点 s 即 p->prior->next = s; 第四步：将节点 s 的后继指向节点 p 即 s->next = p; 第五步：将节点 p 的前驱指向节点 s 即 p->prior =

双向链表的插入与删除

weixin_43913556的博客

03-13

714

#include&lt;stdio.h&gt; #include&lt;stdlib.h&gt; #include&lt;malloc.h&gt; #define LIST_INIT_SIZE 100 #define LISTINCREMENT 10 #define OK 1 #define ERROR 0 #include&lt;string.h&gt; type

双向链表插入元素操作

xiaov_sen的博客

07-14

1415

如果链表里没有结点,那么就是空链表, 需要在头部添加元素,当然一个好的插入算法不需要这样子. 兼容性是所有的程序员必备技能.如何到达兼容性? 还记得双向链表的添加元素操作? 双向链表添加操作 web link 那里有一个link函数采用的是兼容性,无论哪一个位置,甚至是 empty LinkList都可以进行插入如何做呢? 按照位置插入 : 最小值0 最大值是list.size 插入元素思路: 参数: list,pos,value 判断 pos|..................

双向链表的插入

weixin_52634719的博客

09-20

9928

概览: 已知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作为新...

c++双向链表操作示例(创建双向链、双向链表中查找数据、插入数据等)

09-04

下面将详细讲解如何在C++中操作双向链表，包括创建、查找、插入和删除节点。首先，我们需要定义双向链表的节点结构。每个节点包含三个部分：数据（data）、指向前一个节点的指针（prev）和指向后一个节点的指针...

双向链表插入删除基本应用介绍

09-05

插入操作在双向链表中相对复杂，因为我们需要维护前后两个方向的链接。以下的`Insert()`函数接受一个链表头指针和要插入的数据，然后在适当的位置插入新节点： ```cpp DNode *Insert(DNode *&head, int num) { ...

sss.rar_sss_双向链表_链表_链表插入

09-14

双向链表插入结点插入节点操作分为头插、尾插以及在任意位置插入。在双向链表中，插入节点时需要同时更新前后两个节点的指针。例如，在某个节点后插入新节点，需要将新节点的前一个指针设为原节点，后一个指针设...

有序双向链表的插入和删除节点

weixin_41054556的博客

09-14

535

struct ListNode { int val; ListNode *pre; ListNode *next; //ListNode(int _val):val(_val), next(nullptr), random(nullptr){} } void insert(ListNode* head,int v) { ListNode* node=new ListNode;//默...

双链表关于根据排名添加节点时操作时辅助节点的选取问题

weixin_47535434的博客

07-06

173

最近再看数据结构与算法（java)种的链表。发现“Java 数据结构与算法视频教程全集（195P）| 50 小时从入门到精通”中讲解的双链表中，留下根据排名添加元素操作为课后作业，这里分享一下实现代码，欢迎各位大佬指正。例如：以水浒元素为例，节点内容包括：英雄编号、英雄姓名、英雄绰号、前后指针。` class HeroNode2 { public int no; public String name; public String nickname; public HeroNode2 pre,next;

【算法--链表】147.对链表进行插入排序--通俗讲解

最新发布

沐怡旸的专栏

09-12

399

使用一个虚拟头节点来简化操作，维护一个已排序的链表部分，然后逐个取出未排序的节点，在已排序部分中找到合适的插入位置并插入。这就像我们打扑克牌时，一张一张地拿牌，然后把每张牌插入到手中已排序牌的正确位置

leetcode380：RandomizedSet - O(1)时间插入删除和获取随机元素（数组+哈希表的巧妙结合）

lyh2004_08的博客

09-11

624

本文介绍了如何设计一个支持O(1)时间插入、删除和获取随机元素的数据结构。关键在于巧妙结合数组和哈希表的优势：数组提供O(1)随机访问，哈希表实现O(1)查找。核心技巧是删除操作时采用"末尾替换法"，将被删除元素与数组末尾交换后删除，避免移动元素。文章详细分析了算法原理、代码实现、复杂度以及边界条件，并探讨了允许重复元素的变种问题。该方案体现了组合数据结构和空间换时间的设计思想，完美满足了题目要求的所有O(1)操作。

每日算法刷题Day67:9.9:leetcode bfs10道题，用时2h30min

2301_80044595的博客

09-09

812

2.与[[十.图论算法-基础遍历#3. 1162. 地图分析(中等,学习)]]一模一样，找每个1到各自最近的0的最短距离，即多源最短路径距离，所以将所有0入队列，向四周扩散，告诉1已经扩散的层数，即距离。所以要反过来，将所有满足条件的点当做多个源点，向外扩散，从而告诉待求点当前扩散的层数，即最短距离。，是Dijkstra算法，但因为边权只有0和1，所以用0-1BFS来优化Dijkstra，双端队列队首入0，队尾入1，保证每次队首都是边权(代价)最小的。的视频包含所有你好友的好友观看过的视频，以此类推。

LeetCode 1658. 将x减到0的最小操作数

qq_57349657的博客

09-11

259

不定长滑动窗口：将x减到0的最小操作数

【无标题】

Leeyy

09-10

628

过拟合是指模型在训练集上表现很好，但在测试集上表现较差的现象。

leetcode274.H指数

amdkk的博客

09-11

897

给你一个整数数组 citations ，其中 citations[i] 表示研究者的第 i 篇论文被引用的次数。计算并返回该研究者的 h 指数。根据维基百科上 h 指数的定义：h 代表“高引用次数” ，一名科研人员的 h 指数是指他（她）至少发表了 h 篇论文，并且至少有 h 篇论文被引用次数大于等于 h。如果 h 有多种可能的值，h 指数是其中最大的那个。

数据结构双向链表插入操作

07-01

<think>我们正在讨论双向链表的插入操作。双向链表每个节点包含数据域和两个指针域，分别指向前驱节点和后继节点。插入操作需要考虑在链表的不同位置插入节点的情况，如头部、尾部或中间节点之后。根据引用内容，我们可以总结双向链表插入操作的一般步骤（以在指定节点后插入为例）：1.创建新节点，并设置其数据域。2.找到要插入位置的前一个节点（假设为temp）。3.调整新节点的指针：新节点的前驱指向temp，新节点的后继指向temp的后继节点。4.调整原链表中节点的指针：将temp的后继节点的前驱指向新节点（如果temp不是最后一个节点），然后将temp的后继指向新节点。注意：如果是在头部插入（头插法）或尾部插入，步骤稍有不同，但基本原理一致。下面我们用Java语言实现一个双向链表，并实现插入操作（包括在指定节点后插入、头插法和尾插法）。由于引用中提供了部分代码示例，我们将参考这些示例进行编写。首先，定义双向链表的节点类：*/class Node{int data;Node prev; //前驱指针Node next; //后继指针publicNode(intdata){this.data= data;this.prev= null;this.next= null;} }//然后，定义双向链表类，包含插入操作的方法：classDoublyLinkedList {Nodehead;//头节点//在链表末尾插入节点（尾插法）publicvoid append(int data) {NodenewNode =new Node(data);if(head== null) {head= newNode;return;}Nodelast =head;while(last.next !=null){last =last.next;}last.next= newNode;newNode.prev= last;}//在链表头部插入节点（头插法）publicvoid push(int data) {NodenewNode =new Node(data);newNode.next =head;newNode.prev =null;//如果原链表非空，则设置原头节点的前驱为新节点if (head !=null){head.prev= newNode;}head =newNode;}//在指定节点后插入新节点public voidinsertAfter(Node prevNode,int data) {if(prevNode ==null){System.out.println("给定的前一个节点不能为空");return;}Node newNode= newNode(data);newNode.next= prevNode.next;newNode.prev= prevNode;//如果指定节点不是最后一个节点，则调整后继节点的前驱指针if(prevNode.next!= null) {prevNode.next.prev =newNode;}prevNode.next= newNode;}//打印链表public voidprintList() {Nodecurrent =head;while(current!= null) {System.out.print(current.data+ "");current =current.next;}System.out.println();}} /*代码说明：1. `append`方法实现尾插法：遍历到链表末尾，然后插入新节点。2.`push`方法实现头插法：新节点插入到链表头部，并更新头节点。3. `insertAfter`方法在指定节点后插入新节点。需要处理四个指针的修改：-新节点的前驱指向指定节点（prevNode）-新节点的后继指向指定节点的后继-指定节点的后继的前驱（如果存在）指向新节点-指定节点的后继指向新节点注意：在双向链表中插入节点时，要特别注意指针修改的顺序，避免链表断裂。同时，要处理边界情况（如链表为空、插入到头节点前、尾节点后等）。测试代码： */public classMain {publicstatic voidmain(String[] args) {DoublyLinkedListlist =new DoublyLinkedList();//尾插法插入节点list.append(1);list.append(2);list.append(3);System.out.println("尾插法后的链表：");list.printList(); //输出：123//头插法插入节点list.push(0);System.out.println("头插法插入0后的链表：");list.printList(); //输出：0123//在第二个节点（值为1的节点）后插入4Node node1 =list.head.next;//第二个节点（头节点是0，第二个是1）list.insertAfter(node1,4);System.out.println("在节点1后插入4后的链表：");list.printList();//输出：01423}} /*运行结果预期：尾插法后的链表：123头插法插入0后的链表：0123在节点1后插入4后的链表：01423以上代码实现了双向链表的三种插入方式：头插法、尾插法和在指定节点后插入。在实际应用中，可以根据需求选择合适的插入方法。引用说明： [^1]提供了双向链表初始化和插入的示例，但未详细展示插入操作的具体实现。[^2]提供了双循环链表插入操作的四个步骤，我们参考了这些步骤。[^3]提供了C语言头插法的代码，我们借鉴了头插法的思路。 [^4]提供了在指定节点后插入节点的关键步骤：调整新节点和相邻节点的指针。因此，我们综合了这些引用的内容，给出了完整的双向链表插入操作的实现。§§相关问题§§1.双向链表与单向链表在插入操作上有什么主要区别？ 2.双向链表的删除操作如何实现？3.双向链表在哪些场景下比单向链表更有优势？*/</think>### 双向链表插入操作详解 #### 一、实现原理双向链表每个节点包含三个部分： 1. 数据域（存储数据） 2. 前驱指针（`prev`，指向前一节点） 3. 后继指针（`next`，指向后一节点）插入操作的核心步骤（以节点`a`后插入新节点`c`为例）： 1. **创建新节点**：分配内存并初始化数据 2. **指针重定向**（四步关键操作）： ```markdown a → b 变为 a → c → b a ← b 变为 a ← c ← b ``` - ① `c.prev = a`（新节点前驱指向`a`） - ② `c.next = a.next`（新节点后继指向`a`的后继`b`） - ③ `a.next.prev = c`（`b`的前驱指向新节点`c`） - ④ `a.next = c`（`a`的后继指向新节点`c`） ![双向链表插入示意图](https://algorithms.tutorialhorizon.com/files/2015/12/DLL-Add-Middle.png) *(图示：在节点X后插入新节点)* #### 二、代码示例（Java实现） ```java class Node { int data; Node prev; Node next; public Node(int data) { this.data = data; } } class DoublyLinkedList { Node head; // 在指定节点后插入新节点 public void insertAfter(Node prevNode, int data) { if (prevNode == null) { System.out.println("指定节点不能为空"); return; } // 1. 创建新节点 Node newNode = new Node(data); // 2. 核心四步指针操作 newNode.next = prevNode.next; // 新节点指向原后继 newNode.prev = prevNode; // 新节点前驱指向指定节点 if (prevNode.next != null) { prevNode.next.prev = newNode; // 原后继的前驱指向新节点 } prevNode.next = newNode; // 指定节点后继指向新节点 } // 测试代码 public static void main(String[] args) { DoublyLinkedList list = new DoublyLinkedList(); // 创建基础节点 1 → 3 Node node1 = new Node(1); Node node3 = new Node(3); node1.next = node3; node3.prev = node1; list.head = node1; // 在节点1后插入2 → 得到 1 → 2 → 3 list.insertAfter(node1, 2); // 验证结果 Node current = list.head; while (current != null) { System.out.print(current.data + " "); current = current.next; } // 输出：1 2 3 } } ``` #### 三、关键注意事项 1. **边界处理**： - 插入位置是尾部时：`prevNode.next`为`null`，跳过步骤③ - 空链表插入：需特殊处理头指针 2. **指针顺序**：必须按固定顺序操作指针，避免链表断裂（推荐顺序：新节点指针 → 后继指针 → 前驱指针） 3. **时间复杂度**：$O(1)$（已知插入位置时），若需查找位置则为$O(n)$ #### 四、三种插入场景 1. **头插法**（插入头节点前）： ```java public void insertFront(int data) { Node newNode = new Node(data); newNode.next = head; if (head != null) head.prev = newNode; head = newNode; } ``` 2. **尾插法**（插入链表末尾）： ```java public void append(int data) { Node newNode = new Node(data); if (head == null) { head = newNode; return; } Node last = head; while (last.next != null) last = last.next; last.next = newNode; newNode.prev = last; } ``` > 引用说明：插入操作的指针调整逻辑参考了双向链表的标准实现方式[^2][^4]，代码结构借鉴了Java双向链表的实现范式[^1]。