高效率（内存）的双向指针链表

最新推荐文章于 2024-02-02 11:18:57 发布
最新推荐文章于 2024-02-02 11:18:57 发布
阅读量846 收藏 4
点赞数
分类专栏： 高级数据结构 文章标签： 内存 数据结构 链表 高效率 双向链表

问题：
如何只用一个指针节点实现双向链表？

英语能力有限，翻译起来不会很准确，因此在这里先做一下这篇文章的核心思想阐述：
使用一个指针，通过异或保存上一个节点的地址以及下一个节点的地址。
比如：

2^3 = 1; // 保存 1，就是本文中 ptrdiff 保存的值
2^3^2 = 3; // 异或 2 之后可以得到 3
假设现在有三个节点 prev, current, next
current->ptrdiff =(Node*) prev ^ next;
这样我们就通通过一个节点保存了另个地址，现在如何拿到前一个节点？显然
Node *tmp = (Node*)current->ptrdiff ^ next;

对于小型设备来说，每一小块内存都弥足珍贵。设备制造商需要考虑如何节省内存的使用。一种办法是，为日常使用的抽象数据结构寻找另一种实现。例如双向指针链表。

在本文中，我会用传统的方法和另一种替代方法来实现双指针链表，该双指针链表会有插入、遍历和删除操作。同时，我会打印出内存和时间使用情况，以供参考。这种替代实现的方法是基于指针距离（pointer distance），因此在本文中，我们称为指针距离实现（the pointer distance implementation）。每一个节点只需要一个指针域，就能实现向前或者向后遍历。在传统的实现中，我们需要一个指针指向前一个节点，以及另一个指针指向后一个节点。传统的节点的内存利用率只有34%，而指针距离实现的节点内存利用率是50%。如果我们使用多维的双向指针链表，比如动态网格，节点内存利用率还会更低。

在这里，我们不会讨论过多的去讨论传统的双向指针链表实现，你随便谷歌一下，会有很多相关文章。

节点定义：
typedef int T;
typedef struct listNode{
    T elm;
    struct listNode * ptrdiff;
};

ptrdiff 存着当前这个节点和下一个节点的差别（difference）以及当前这个节点和前一个节点的差别（difference）。指针区别是通过 异或 运算得到的。任何这种链表实例，都一个StartNode和一个EndNode。StartNode 指向链表的头部，EndNode 指向链表的尾部。我们定义StartNode 指向的前一个节点是 NULL 节点，EndNode 指向的下一个节点是NULL 节点。对于单节点链表，它的前一个节点和下一个节点都是NULL 。 简单来说就是当前节点的 ptrdiff 保存着当前节点的前一个节点和下一个节点的异或结果。

遍历

一个特定节点的插入和删除操作都依赖于遍历。我们很容易就能实现向前或者向后遍历。如果把 StartNode 作为一个参数，并且因为它的前一个节点是 NULL，那么，很显然，这是一个从左往右遍历的操作。同样的，如果把EndNode 作为一个参数，那么，就是从右往左遍历。在本文中，尚未支持从链表中间遍历，但是要支持这种操作并不难。

NextNode() 定义如下

typedef listNode * plistNode;
plistNode NextNode( plistNode pNode,
                    plistNode pPrevNode){
    return ((plistNode)
      ((int) pNode->ptrdiff ^ ( int)pPrevNode) );
}

给定一个元素元素（element），用 ptrdiff 来保存这个元素和下一个节点以及前一个节点的异或结果。因此，如何和前一个节点再做一次异或操作，那么指针就会指向下一个节点。

插入

给定一个新的节点和一个已经存在的节点元素，通过遍历找到这个元素所在的节点，然后将新的节点插到后面（看链表1）。将一个新的节点插入到双向链表，需要三个节点：当前节点，当前节点的上一个和下一个节点。如果所给的元素是最后一个节点的元素，就把新节点插到链表的最后面。如果在insertAfter() 轮询中，没有找到给定的元素，则放弃插入新的节点。

Listing 1. Function to Insert a New Node
void insertAfter(plistNode pNew, T theElm)
{
   plistNode pPrev, pCurrent, pNext;
   pPrev = NULL;
   pCurrent = pStart;

   while (pCurrent) {
      pNext = NextNode(pCurrent, pPrev);
      if (pCurrent->elm == theElm) {
         /* traversal is done */
         if (pNext) {
            /* fix the existing next node */
            pNext->ptrdiff =
                (plistNode) ((int) pNext->ptrdiff
                           ^ (int) pCurrent
                           ^ (int) pNew);

            /* fix the current node */
            pCurrent->ptrdiff =
              (plistNode) ((int) pNew ^ (int) pNext
                         ^ (int) pCurrent->ptrdiff);

            /* fix the new node */
            pNew->ptrdiff =
                (plistNode) ((int) pCurrent
                           ^ (int) pNext);
         break;
      }
      pPrev = pCurrent;
      pCurrent = pNext;
   }
}

首先通过 nextNode() 和遍历找到给定元素所在的节点，如果找到把新的节点插入到该节点的后面。

因为下一个节点有ptrdiff，可以通过和已经找到的节点进行异或操作解出地址。
接着，和新节点做异或操作，将新节点作为前一个节点。同样的，当前节点也是一样的逻辑。首先通过和下一个节点做异或操作解出ptrdiff；接着和新节点再做一次异或操作，这样就可以得到正确的ptrdiff。 最后，因为新节点处于已经找到的节点和下一个节点中间，通过和它们做异或操作得到了ptrdiff。

删除

当前的删除操作支持删除整个链表。因为本文旨在阐述这种实现的动态内存分配和执行时间的消耗。因此这里不会实现各种双向链表的操作，但是实现它们不会太难。

因为我们的遍历依赖于指向两个节点的指针，因此没有办法在找到下一个节点的时候就可以直接删除当前节点。因此，我们依赖于下面这种规则，当找到下一个节点的时候，删除前一个节点。如果，当前节点是最后一个节点，当它被释放之后，删除结束。如果 nextNode() 返回 NULL，当前节点就是最后一个节点。

内存和时间的使用

这里不翻译，只贴上我自己运行的结果。
运行效率几乎相同，但是内存省了一大半。

地址实现方式
Before insert(prt.dist.) Thu Apr 12 19:39:56 2018

After insert(prt.dist.) Thu Apr 12 19:39:59 2018

Total Memory taken by ptr distance structure = 480000 bytes.
Before traverse(pStart) of (prt.dist.)  Thu Apr 12 19:39:59 2018

After traverse(pStart) of(prt.dist.)  Thu Apr 12 19:39:59 2018

Before traverse(pEnd) of (prt.dist.)  Thu Apr 12 19:39:59 2018

After traverse(pEnd) of (prt.dist.)  Thu Apr 12 19:39:59 2018

Before delList () of (prt.dist.)  Thu Apr 12 19:39:59 2018

 Final node being deleted in prt.dist. =29999
After delList () of (prt.dist.)  Thu Apr 12 19:39:59 2018

--------------
传统实现方式
Before conventional insert() Thu Apr 12 19:39:59 2018

After conventional insert()  Thu Apr 12 19:40:02 2018

Total Memory taken by conventional structure = 720000 bytes.
Before conventioal  dtraversefw(pdHead )  Thu Apr 12 19:40:02 2018

After conventioal  dtraversefw(pdHead )  Thu Apr 12 19:40:02 2018

Before conventioal dtraversebw(pdEnd)  Thu Apr 12 19:40:02 2018

After conventioal dtraversebw(pdEnd)  Thu Apr 12 19:40:02 2018

Before conventioal ddelList ()  Thu Apr 12 19:40:02 2018

After conventioal ddelList ()  Thu Apr 12 19:40:02 2018

源代码地址 GitHub

A Memory-Efficient Doubly Linked List

还可以阅读 XOR linked list

卖鱼的小白菜
关注
  • 0
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C语言的双链表
04-01
二.内核链表 内核链表是一种链表，Linux内核中的链表都是用这种形式实现的 1.特性 内核链表是一种双向循环链表，内核链表的节点节点结构中只有指针域 使用内核链表的时候，将内核链表作为一个成员放入到一个结构体中使用 我们在链表中找到内核链表结构的地址，通过这个地址就可以找到外部大结构体的地址，通过大结构体就可以访问其中的成员 优势： 内核链表突破了保存数据的限制，可以用内核链表来保存任何数据(使用一种链表表示各种类型的数据，通用性很强) 内核链表中只有指针域，维护起来更加方便，效率更高 2.使用 内核链表在内核中已经被实现，我们只需要调用其接口直接使用即可 内核链表的实现代码在内核源代码的list.h文件中 3.源代码分析 （1）节点结构： struct list_head { struct list_head *next, *prev;//前置指针 后置指针 }; （2）初始化 #define INIT_LIST_HEAD(ptr) do { \ (ptr)->next = (ptr); (ptr)->prev = (ptr); \ } while (0) （3）插入 //从头部插入 static inline void list_add(struct list_head *new, struct list_head *head)//传入要插入的节点和要插入的链表 { __list_add(new, head, head->next); } //从尾部插入 static inline void list_add_tail(struct list_head *new, struct list_head *head) { __list_add(new, head->prev, head); } （4）通过节点找到外部结构体的地址 //返回外部结构体的地址，第一个参数是节点地址，第二个参数是外部结构体的类型名，第三个参数是节点在外部结构体中的成员名 #define list_entry(ptr, type, member) ((type *)((char *)(ptr)-(unsigned long)(&((type *)0)->member))) （5）遍历内核链表 //遍历内核链表 #define list_for_each(pos, head) \ for (pos = (head)->next; pos != (head); \ pos = pos->next) //安全遍历内核链表 #define list_for_each_safe(pos, n, head) \ for (pos = (head)->next, n = pos->next; pos != (head); \ pos = n, n = pos->next) C语言的双链表，可以增加。插入，删除，修改，销毁等函数接口。
C语言的单链表
04-01
二.内核链表 内核链表是一种链表，Linux内核中的链表都是用这种形式实现的 1.特性 内核链表是一种双向循环链表，内核链表的节点节点结构中只有指针域 使用内核链表的时候，将内核链表作为一个成员放入到一个结构体中使用 我们在链表中找到内核链表结构的地址，通过这个地址就可以找到外部大结构体的地址，通过大结构体就可以访问其中的成员 优势： 内核链表突破了保存数据的限制，可以用内核链表来保存任何数据(使用一种链表表示各种类型的数据，通用性很强) 内核链表中只有指针域，维护起来更加方便，效率更高 2.使用 内核链表在内核中已经被实现，我们只需要调用其接口直接使用即可 内核链表的实现代码在内核源代码的list.h文件中 3.源代码分析 （1）节点结构： struct list_head { struct list_head *next, *prev;//前置指针 后置指针 }; （2）初始化 #define INIT_LIST_HEAD(ptr) do { \ (ptr)->next = (ptr); (ptr)->prev = (ptr); \ } while (0) （3）插入 //从头部插入 static inline void list_add(struct list_head *new, struct list_head *head)//传入要插入的节点和要插入的链表 { __list_add(new, head, head->next); } //从尾部插入 static inline void list_add_tail(struct list_head *new, struct list_head *head) { __list_add(new, head->prev, head); } （4）通过节点找到外部结构体的地址 //返回外部结构体的地址，第一个参数是节点地址，第二个参数是外部结构体的类型名，第三个参数是节点在外部结构体中的成员名 #define list_entry(ptr, type, member) ((type *)((char *)(ptr)-(unsigned long)(&((type *)0)->member))) （5）遍历内核链表 //遍历内核链表 #define list_for_each(pos, head) \ for (pos = (head)->next; pos != (head); \ pos = pos->next) //安全遍历内核链表 #define list_for_each_safe(pos, n, head) \ for (pos = (head)->next, n = pos->next; pos != (head); \ pos = n, n = pos->next) 二.内核链表 内核链表是一种链表，Linux内核中的链表都是用这种形式实现的 1.特性 内核链表是一种双向循环链表，内核链表的节点节点结构中只有指针域 使用内核链表的时候，将内核链表作为一个成员放入到一个结构体中使用 我们在链表中找到内核链表结构的地址，通过这个地址就可以找到外部大结构体的地址，通过大结构体就可以访问其中的成员 优势： 内核链表突破了保存数据的限制，可以用内核链表来保存任何数据(使用一种链表表示各种类型的数据，通用性很强) 内核链表中只有指针域，维护起来更加方便，效率更高 2.使用 内核链表在内核中已经被实现，我们只需要调用其接口直接使用即可 内核链表的实现代码在内核源代码的list.h文件中 3.源代码分析 （1）节点结构： struct list_head { struct list_head *next, *prev;//前置指针 后置指针 }; （2）初始化 #define INIT_LIST_HEAD(ptr) do { \ (ptr)->next = (ptr); (ptr)->prev = (ptr); \ } while (0) （3）插入 //从头部插入 static inline void list_add(struct list_head *new, struct list_head *head)//传入要插入的节点和要插入的链表 { __list_add(new, head, head->next); } //从尾部插入 static inline void list_add_tail(struct list_head *new, struct list_head *head) { __list_add(new, head->prev, head); } （4）通过节点找到外部结构体的地址 //返回外部结构体的地址，第一个参数是节点地址，第二个参数是外部结构体的类型名，第三个参数是节点在外部结构体中的成员名 #define list_entry(ptr, type, member) ((type *)((char *)(ptr)-(unsigned long)(&((type *)0)->member))) （5）遍历内核链表 //遍历内核链表 #define list_for_each(pos, head) \ for (pos = (head)->next; pos != (head); \ pos = pos->next) //安全遍历内核链表 #define list_for_each_safe(pos, n, head) \ for (pos = (head)->next, n = pos->next; pos != (head); \ pos = n, n = pos->next) 二.内核链表 内核链表是一种链表，Linux内核中的链表都是用这种形式实现的 1.特性 内核链表是一种双向循环链表，内核链表的节点节点结构中只有指针域 使用内核链表的时候，将内核链表作为一个成员放入到一个结构体中使用 我们在链表中找到内核链表结构的地址，通过这个地址就可以找到外部大结构体的地址，通过大结构体就可以访问其中的成员 优势： 内核链表突破了保存数据的限制，可以用内核链表来保存任何数据(使用一种链表表示各种类型的数据，通用性很强) 内核链表中只有指针域，维护起来更加方便，效率更高 2.使用 内核链表在内核中已经被实现，我们只需要调用其接口直接使用即可 内核链表的实现代码在内核源代码的list.h文件中 3.源代码分析 （1）节点结构： struct list_head { struct list_head *next, *prev;//前置指针 后置指针 }; （2）初始化 #define INIT_LIST_HEAD(ptr) do { \ (ptr)->next = (ptr); (ptr)->prev = (ptr); \ } while (0) （3）插入 //从头部插入 static inline void list_add(struct list_head *new, struct list_head *head)//传入要插入的节点和要插入的链表 { __list_add(new, head, head->next); } //从尾部插入 static inline void list_add_tail(struct list_head *new, struct list_head *head) { __list_add(new, head->prev, head); } （4）通过节点找到外部结构体的地址 //返回外部结构体的地址，第一个参数是节点地址，第二个参数是外部结构体的类型名，第三个参数是节点在外部结构体中的成员名 #define list_entry(ptr, type, member) ((type *)((char *)(ptr)-(unsigned long)(&((type *)0)->member))) （5）遍历内核链表 //遍历内核链表 #define list_for_each(pos, head) \ for (pos = (head)->next; pos != (head); \ pos = pos->next) //安全遍历内核链表 #define list_for_each_safe(pos, n, head) \ for (pos = (head)->next, n = pos->next; pos != (head); \ pos = n, n = pos->next) C语言下的单链表，可以增加，删除，查找，销毁节点。
【数据结构】双向链表 超详细 （含：何时用一级指针或二级指针；指针域的指针是否要释放）
2301_79499548的博客
02-02 1105
主要讲解 双链表（双向循环带头链表） 的 概念原理 和 代码实现讲解 含：何时用一级指针或二级指针；指针域的指针是否要释放 两个问题的解释
约瑟夫环leetcode-algorithm-learn-start:算法学习开始
07-06
约瑟夫环 leetcode algorithm-learn-start 总结 一、什么是链表？ 1.和数组一样，链表也是一种线性表。 2.从内存结构来看，链表的内存结构是不连续的内存空间，是将一组零散的内存块串联起来，从而进行数据存储的数据结构。 3.链表中的每一个内存块被称为节点Node。节点除了存储数据外，还需记录链上下一个节点的地址，即后继指针next。 二、为什么使用链表？即链表的特点 1.插入、删除数据效率高O(1)级别（只需更改指针指向即可），随机访问效率低O(n)级别（需要从链头至链尾进行遍历）。 2.和数组相比，内存空间消耗更大，因为每个存储数据的节点都需要额外的空间存储后继指针。 三、常用链表：单链表、循环链表和双向链表 1.单链表 1）每个节点只包含一个指针，即后继指针。 2）单链表有两个特殊的节点，即首节点和尾节点。为什么特殊？用首节点地址表示整条链表，尾节点的后继指针指向空地址null。 3）性能特点：插入和删除节点的时间复杂度为O（1），查找的时间复杂度为O(n)。 2.循环链表 1）除了尾节点的后继指针指向首节点的地址外均与单链表一致。 2）适用于存储有循环
算法套路二:相向双指针
Pistachiout的学习博客
03-06 501
相向双指针故套路如下: 比较 s = numbers[left] + numbers[right]与**固定值target**（关键为找到该固定值） 如果s > target，right-- 如果s < target，left++
双向指针——盛最多水的容器
luanleluanle的博客
04-20 69
LeetCode（11）：盛最多水的容器题目描述解题思路代码实现执行效率 题目描述 给你 n 个非负整数 a1，a2，…，an，每个数代表坐标中的一个点 (i, ai) 。在坐标内画 n 条垂直线，垂直线 i 的两个端点分别为 (i, ai) 和 (i, 0) 。找出其中的两条线，使得它们与 x 轴共同构成的容器可以容纳最多的水。不能倾斜容器。 解题思路 若有两个坐标（i,ai) 和 (j,aj)，则容器的容量为 |(j-i)| *min(ai,aj)。容易发现容量的大小有两个变量所决定。如果我们可以知道两
双指针问题--链表--双向链表
gy的博客
05-31 756
双向链表的特性：元素的由他的值和链各个指针组成，左指针指向上一元素， 右指针指向下一元素 class Node(object): def __init__(self, item): self.item = item self.next = None self.prev = None class DoubleLink(object): ...
数据结构 - 双向链表
weixin_73869209的博客
09-07 896
如上图所示,双向链表中包含了两个指针,一个指向前驱结点,一个指向后继节点,其中头结点没有前驱节点,尾结点没有后继节点前驱: 前驱指的是当前节点的前一个节点，即在链表中位于当前节点之前的节点。它可以通过前向指针（previous pointer）来访问。后继: 后继指的是当前节点的后一个节点，即在链表中位于当前节点之后的节点。它可以通过后向指针（next pointer）来访问。这篇博客大家应重点关注链表的设计,代码这个东西面试考的更多的是单链表,大家刷题更多的也是单链表,双向链表相对于就没有那么重要了。
数据结构之链表详解(2)——双向链表
weixin_69283129的博客
08-29 8929
C语言版万字详解：数据结构之链表详解(2)——双向链表的结构和功能实现
手动实现List集合(ArrayList、LinkedList) 数组扩容和双向链表
coderlzy的博客
03-21 376
文章目录模拟实现List集合特别注意一、ArrayList实现二、LinkedList实现 模拟实现List集合 个人理解，大佬勿喷！为了巩固集合的基础，模拟一下List集合的实现过程(ArrayList和LinkedList都是线程不安全的，Vector实现步骤和ArrayList差不多，只是多了同步的操作，这里不做实现) 特别注意 这个手动实现的ArrayList和LinkedList的查询和删除都是 以当前第某个元素来操作，源码中以下标为第某个元素来操作的 。想要实现一样的，可以根据源码改。例如：查
数组的扩容和链表结构.zip
11-07
java数组扩容存储和java链表结构存储，恰同学少年，风华正茂，挥斥方遒
C#，双向链表（Doubly Linked List）快速排序（Quick Sort）算法与源代码
最新发布
03-24
双向链表也叫双链表，是链表的一种，它的每个数据结点中都有两个指针，分别指向直接后继和直接前驱。所以，从双向链表中的任意一个结点开始，都可以很方便地访问它的前驱结点和后继结点。一般我们都构造双向循环链表...
谭浩强C语言程序设计，C++程序设计，严蔚敏数据结构，高一凡数据结构算法分析与实现.rar
06-13
11.9 链表的概念 182 11.10 枚举类型 184 11.10.1 枚举类型的定义和枚举变量的说明 184 11.10.2 枚举类型变量的赋值和使用 185 11.11 类型定义符typedef 12 位运算 12.1 位运算符Ｃ语言提供了六种位运算符： 189 ...
数据结构和算法之双指针算法
smallteddy.blog.csdn.net
05-07 964
1、什么是双指针 双指针，指的是在遍历对象的过程中，不是普通的使用单个指针进行访问，而是使用两个相同方向（快慢指针）或者相反方向（对撞指针）的指针进行扫描，从而达到相应的目的。 换言之，双指针法充分使用了数组有序这一特征，从而在某些情况下能够简化一些运算。 2、快慢指针 1、说明 快慢指针也是双指针，但是两个指针从同一侧开始遍历数组，将这两个指针分别定义为快指针（fast）和慢指针（slow），两个指针以不同的策略移动，直到两个指针的值相等（或其他特殊条件）为止，如fast每次增长两个，slow每次增长一个
双向循环链表涉及双向指针的基本操作(C语言)
weixin_30763455的博客
12-20 1014
　　链表大概分为有无头指针，有无尾指针，是否循环，单向还是双向， 这些都很简单，前提是你要把指针和单链表理解透彻。这些都是基于单链表 的变形，要根据实际问题，选择链表的类型。 　　头指针的指针域储存着储存头节点的地址，其数据域我们不使用。 尾指针同理。 　　循环链表的最后一个节点指向头节点(如果有头指针，则是指向头指针)， 非循环链表的最后一个节点指向NUll。 　　单向链...
双向指针
双杯献酒的专栏
05-15 565
// 双向指针 #include <iostream> #include <memory> #include <utility> #include <vector> template <typename T1, typename T2> struct Linked { friend struct Linked<T2, T1>; Linked(T2* t) { other = nullptr; data .
【经典算法】双指针（尺取法）：爱，是双向奔赴，还是你追我赶？
子夜的个人博客
01-23 4073
双指针法又称尺取法，顾名思义，在区间操作时，使用两个指针同时遍历区间，从而实现高效操作。两个指针，就像是一男一女，他们遍历区间的过程，又何尝不像是一对男女彼此追求爱情的过程呢？接下来一起学习双指针的恋爱过程。
初次了解ListNode，针对ListNode的理解
热门推荐
qq_38271904的博客
03-02 4万+
关于ListNode public class ListNode{ int val; ListNode next; //链表指向的下一个值的指针 ListNode(int x){val = x;} //这个方式赋值 } 我想到的几点事项 定义链表ListNode时， 链表的首个值不能为0，当首个参数为0时，代表着链表为空。 只需要定义一个List...
单向链表和双向链表的优缺点
03-22
综上所述，单向链表的优点是插入和删除节点的操作效率高，但查找节点的效率较低；双向链表相对于单向链表在插入和删除节点时更加灵活，并且可以实现正向和反向遍历，但需要额外的空间来存储前一个节点的指针。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值