《数据结构与算法》双向链表专题

已于 2024-06-03 19:27:45 修改
阅读量748 收藏 12
点赞数 19
文章标签： 链表 数据结构
于 2024-06-02 17:37:02 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_79722165/article/details/139388264
版权

1 双向链表的结构

带头双向循环链表

2c742cccf2734891820f41272d922c5a.png

 注意：这里的“带头”跟前面我们说的“头节点”是两个概念，实际前面在单链表阶段的称呼并不严谨，为了我们更好的理解就直接成为单链表的头节点。

带头链表的头节点实际为“哨兵位”，哨兵位节点不存储任何有效的元素，只是站在这里“放哨”的。

“哨兵位”存在的意义：遍历循环链表避免死循环。

当链表中只有哨兵位节点的时候，我们称该链表为空链表，即哨兵位是不能删除的。

2 双向链表的实现

List.h  定义双向链表的结构，双向链表要实现的接口/方法

List.c  具体实现双向链表里定义的接口/方法

test.c  测试双向链表

2.1 准备工作

List.h

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

//定义双向链表中节点的结构
typedef int LTDataType;
typedef struct ListNode
{
  LTDataType data;
  struct ListNode* prev;    //指向前驱节点
  struct ListNode* next;    //指向后继节点
}LTNode;

LTNOde* LTBuyNode(LTDataType x)    //开辟新节点
{
  LTNode* newnode = (LTNode*)malloc(sizeof(LTNode));
  if(newnode == NULL)
  {
    perror("malloc fail!!");
    exit(1);
  }
  newnode->data = x;
  newnode->next = nwenode->prev = newnode;

  return newnode;
}

List.c 

#include"List.h"

2.2 打印双向链表

List.h

void LTPrint(LTNode* phead);

List.c 

void LTPrint(LTNode* phead)
{
  assert(phead);    //phead不能为空
  LTNode* pcur = phead->next;
  while(pcur != phead)
  {
    printf("%d->", pcur->data);
    pcur = pcur->next;
  }
  printf("\n");
}

2.3 初始化双向链表

初始化有两种方式：

  • 一种是传参的(不用参数接收返回值)
  • 一种是不传参的（需要参数接收返回值）

两种的效果是一样的

注意：双向链表是带有哨兵位的，插入数据之前链表中必须要先初始化一个哨兵位

List.h

//传参的初始化
void LInit01(LTNode** pphead);

//不传参的初始化
LTNode* LTInit02();

List.c 

//传参的初始化
void LInit01(LTNode** pphead)    //需要修改哨兵位，所以我们要传二级指针
{
  *pphead = LTNOde* LTBuyNode(-1)
}

//不传参的初始化
LTNode* LTInit02()
{
  LTNode* phead = LTNOde* LTBuyNode(-1);

  return phead;
}

 test.c

#inlcude"List.h"

//传参
void ListTest01()
{
  LTNode* plist = NULL;
  LTInit01(&plist);
}

//不传参
void ListTest02()
{
  LTNode* plist = LTInit();
}

int main()
{
  //ListTest01();
 ListTest02();
 
 return 0;
}

2.4 双向链表的尾插

我们先来思考一个问题：双向链表尾插需不需要找尾操作？

答案是：不需要，因为可通过头节点的前驱节点找到，即ptail = head->prev

尾插：在哨兵位之前插入节点/最后一个有效节点之后插入数据。

List.h

void LTPushBack(LTNode* phead, LTDataType x);

List.c 

void LTPushBack(LTNode* phead, LTDataType x)
{
  assert(phead);    //哨兵位不能为空，哨兵位为空就说明还没初始化链表
  LTNode* newnode = LTBuyNode(x);
  
  newnode->next = phead;
  newnode->prev = phead-prev;

  phead->prev->next = newnode;
  phead->prev = newnode;
}

test.c

void ListTest()
{
  LTNode* plist = LTInit();
  LTPushBcak(plist,1);
  LTPushBcak(plist,2);
  LTPushBcak(plist,3);
  LTPushBcak(plist,4);

  LTPrint(plist);
}

int main()
{
  ListTest();
  return 0;
}

 输出结果为

1->2->3->4->

2.5 双向链表的头插

头插：在第一个有效节点之前插入。

List.h

void LTPushFront(LTNode* phead, LTDataType x);

List.c

void LTPushFront(LTNode* phead, LTDataType x)
{
  assert(phead);
  
  LTNode* newnode = LTBuuyNode(x);
  
  newnode->next = phead->next;
  newnode->prev = phead;

  phead->next->prev = newnode;
  phead->next = newnode;
}

test.c 

void ListTest()
{
  LTNode* plist = LTInit();
  LTPushFront(plist,1);
  LTPushFront(plist,2);
  LTPushFront(plist,3);
  LTPushFront(plist,4);

  LTPrint(plist);
}

int main()
{
  ListTest();
  return 0;
}

输出结果为

4->3->2->1->

2.6 双向链表的尾删

List.h

void LTPopBack(LTNode* phead);

 List.c

void LTPopBack(LTNode* phead)
{
  assert(phead);
  assert(phead->next != phead);    //链表为空：只有一个哨兵位节点

  LTNode* del = phead->prev;    //要删除的节点（尾节点）
  LTNode* prev = del->prev;    //要删除节点的前驱节点
  
  prev->next = phead;
  phead=>prev = prev;

  free(del);
  del = NULL;
}

 test.c

void ListTest()
{
  LTNode* plist = LTInit();
  LTPushFront(plist,1);
  LTPushFront(plist,2);
  LTPushFront(plist,3);
  LTPushFront(plist,4);

  LTPrint(plist);

  LTPopBack(plist);
  LTPrint(plist);
  LTPopBack(plist);
  LTPrint(plist);
  LTPopBack(plist);
  LTPrint(plist);
}

int main()
{
  ListTest();
  return 0;
}

 输出结果为

4->3->2->1->
4->3->2->
4->3->
4->

2.7 双向链表的头删 

List.h 

void LTPopFront(LTNode* phead);

 List.c

void LTPopFront(LTNode* phead)
{
  assert(phead);
  assert(phead->next != phead);  

  LTNode* del = phead->next;    //要删除的节点（第一个节点）
  LTNode* next = del->next;    //要删除节点的后继节点

  next->prev = phead;
  phead->next = next;

  free(del);
  del = NULL;
}

 test.c

void ListTest()
{
  LTNode* plist = LTInit();
  LTPushFront(plist,1);
  LTPushFront(plist,2);
  LTPushFront(plist,3);
  LTPushFront(plist,4);

  LTPrint(plist);

  LTPopFront(plist);
  LTPrint(plist);
  LTPopFront(plist);
  LTPrint(plist);
  LTPopFront(plist);
  LTPrint(plist);
}

int main()
{
  ListTest();
  return 0;
}

输出结果为

4->3->2->1->
3->2->1->
2->1->
1->

2.8 查找双向链表

List.h

LTNode* LTFind(LTNode* phead, LTDataType x);

List.c

LTNode* LTFind(LTNode* phead, LTDataType x)
{
  assert(phead);
  LTNode* pcur = phead->next;
  while(pcur != phead)
  {
    if(pcur->data == x)
    {
      return pcur;
    }
    pcur = pcur->next;
  }
  return NULL;
}

test.c

void ListTest()
{
  LTNode* plist = LTInit();
  LTPushFront(plist,1);
  LTPushFront(plist,2);
  LTPushFront(plist,3);
  LTPushFront(plist,4);

  LTPrint(plist);

  LTNode* findRet01 = LTFind(plist, 4);
  if(findRet01 == NULL)
  {
    printf("未找到！！\n");
  }
  else
  {
  printf("找到啦！！\n");
  }

  LTNode* findRet02 = LTFind(plist, 520);
  if(findRet02 == NULL)
  {
    printf("未找到！！\n");
  }
  else
  {
  printf("找到啦！！\n");
  }
}

int main()
{
  ListTest();
  return 0;
}

输出结果为

4->3->2->1->
找到啦！！
未找到！！

2.9 指定位置之后插入数据 

List.h 

void LTInsert(LTNode* pos, LTDataType x);

 List.c

void LTInsert(LTNode* pos, LTDataType x)
{
  assert(pos);
  LtNode* newnode = LTBuyNode(x);
  
  newnode->next = pos->next;
  newnode->prev = pos;
  
  pos->next->prev = newnode;    //注意顺序
  pos->next = newnode;
}

 test.c

void ListTest()
{
  LTNode* plist = LTInit();
  LTPushFront(plist,1);
  LTPushFront(plist,2);
  LTPushFront(plist,3);
  LTPushFront(plist,4);

  LTPrint(plist);

  LTNode* findRet = LTFind(plist,1);
  LTInsert(findRet, 66);
  LTPrint(plist);
}

int main()
{
  ListTest();
  return 0;
}

输出结果为

4->3->2->1->
4->3->2->1->66->

2.10 删除指定位置数据

List.h 

void LTErase(LTNode* pos);

List.c

void LTErase(LTNode* pos)
{
  assert(pos);

  pos->next->prev = pos->prev;
  pos->prev->next = pos->next;

  free(pos);
  pos = NULL;
}

test.c

void ListTest()
{
  LTNode* plist = LTInit();
  LTPushFront(plist,1);
  LTPushFront(plist,2);
  LTPushFront(plist,3);
  LTPushFront(plist,4);

  LTPrint(plist);

  LTNode* findRet = LTFind(plist,3);
  LTErase(findRet);
  LTPrint(plist);
}

int main()
{
  ListTest();
  return 0;
}

输出结果为

4->3->2->1->
4->2->1->

2.11 销毁双向链表

可以有两种销毁方法

  • 传二级指针，调用完之后自动对哨兵位置NULL
  • 传一级指针，调用完要手动置NULL（推荐这种，因为可以保持接口一致性）

List.h

//传二级指针
void LTDesTory01(LTNode** pphead);
//传一级指针
void LTDesTory01(LTNode* phead);

 List.c

//传二级指针
void LTDesTory(LTNode** pphead)
{
  assert(pphead);
  //哨兵位不能为空
  assert(*pphead);

  LTNode* pcur = (*pphead)->next;
  while(pcur != *pphead)
  {
    LTNode* next = pcur->next;
    free(pcur);
    pcur = next;
  }
  //链表中只有一个哨兵位
  free(*pphead);
  *pphead = NULL;
}

//传一级指针
void LTDesTory(LTNode* phead)
{
  //哨兵位不能为空
  assert(phead);

  LTNode* pcur = phead->next;
  while(pcur != phead)
  {
    LTNode* next = pcur->next;
    free(pcur);
    pcur = next;
  }
  //链表中只有一个哨兵位
  free(phead);
  phead = NULL;
}

3 整理双链表代码

List.h

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

//定义双向链表中节点的结构
typedef int LTDataType;
typedef struct ListNode
{
  LTDataType data;
  struct ListNode* prev;    //指向前驱节点
  struct ListNode* next;    //指向后继节点
}LTNode;

//注意，双向链表是带有哨兵位的，插入数据之前链表中必须要先初始化一个哨兵位

LTNOde* LTBuyNode(LTDataType x)    //开辟新节点
{
  LTNode* newnode = (LTNode*)malloc(sizeof(LTNode));
  if(newnode == NULL)
  {
    perror("malloc fail!!");
    exit(1);
  }
  newnode->data = x;
  newnode->next = nwenode->prev = newnode;

  return newnode;
}

//打印
void LTPrint(LTNode* phead);

//初始化
//传参的初始化
void LInit01(LTNode** pphead);
//不传参的初始化
LTNode* LTInit02();

//尾插
void LTPushBack(LTNode* phead, LTDataType x);

//头插
void LTPushFront(LTNode* phead, LTDataType x);

//尾删
void LTPopBack(LTNode* phead);

//头删
void LTPopFront(LTNode* phead);

//查找
LTNode* LTFind(LTNode* phead, LTDataType x);

//指定位置之后插入数据
void LTInsert(LTNode* pos, LTDataType x);

//删除指定位置数据
void LTErase(LTNode* pos);

//销毁
//传二级指针
void LTDesTory01(LTNode** pphead);
//传一级指针
void LTDesTory01(LTNode* phead);

List.c

#include"List.h"

//打印
void LTPrint(LTNode* phead)
{
  assert(phead);    //phead不能为空
  LTNode* pcur = phead->next;
  while(pcur != phead)
  {
    printf("%d->", pcur->data);
    pcur = pcur->next;
  }
  printf("\n");
}

//初始化
//传参的初始化
void LInit01(LTNode** pphead)    //需要修改哨兵位，所以我们要传二级指针
{
  *pphead = LTNOde* LTBuyNode(-1)
}

//不传参的初始化
LTNode* LTInit02()
{
  LTNode* phead = LTNOde* LTBuyNode(-1);

  return phead;
}

//尾插
void LTPushBack(LTNode* phead, LTDataType x)
{
  assert(phead);    //哨兵位不能为空，哨兵位为空就说明还没初始化链表
  LTNode* newnode = LTBuyNode(x);
  
  newnode->next = phead;
  newnode->prev = phead-prev;

  phead->prev->next = newnode;
  phead->prev = newnode;
}

//头插
void LTPushFront(LTNode* phead, LTDataType x)
{
  assert(phead);
  
  LTNode* newnode = LTBuuyNode(x);
  
  newnode->next = phead->next;
  newnode->prev = phead;

  phead->next->prev = newnode;
  phead->next = newnode;
}

//尾删
void LTPopBack(LTNode* phead)
{
  assert(phead);
  assert(phead->next != phead);    //链表为空：只有一个哨兵位节点

  LTNode* del = phead->prev;    //要删除的节点（尾节点）
  LTNode* prev = del->prev;    //要删除节点的前驱节点
  
  prev->next = phead;
  phead=>prev = prev;

  free(del);
  del = NULL;
}

//头删
void LTPopFront(LTNode* phead)
{
  assert(phead);
  assert(phead->next != phead);  

  LTNode* del = phead->next;    //要删除的节点（第一个节点）
  LTNode* next = del->next;    //要删除节点的后继节点

  next->prev = phead;
  phead->next = next;

  free(del);
  del = NULL;
}

//查找
LTNode* LTFind(LTNode* phead, LTDataType x)
{
  assert(phead);
  LTNode* pcur = phead->next;
  while(pcur != phead)
  {
    if(pcur->data == x)
    {
      return pcur;
    }
    pcur = pcur->next;
  }
  return NULL;
}

//指定位置之后插入数据
void LTInsert(LTNode* pos, LTDataType x)
{
  assert(pos);
  LtNode* newnode = LTBuyNode(x);
  
  newnode->next = pos->next;
  newnode->prev = pos;
  
  pos->next->prev = newnode;    //注意顺序
  pos->next = newnode;
}

//删除指定位置数据
void LTErase(LTNode* pos)
{
  assert(pos);

  pos->next->prev = pos->prev;
  pos->prev->next = pos->next;

  free(pos);
  pos = NULL;
}

//销毁
//传二级指针
void LTDesTory(LTNode** pphead)
{
  assert(pphead);
  //哨兵位不能为空
  assert(*pphead);

  LTNode* pcur = (*pphead)->next;
  while(pcur != *pphead)
  {
    LTNode* next = pcur->next;
    free(pcur);
    pcur = next;
  }
  //链表中只有一个哨兵位
  free(*pphead);
  *pphead = NULL;
}

//传一级指针
void LTDesTory(LTNode* phead)
{
  //哨兵位不能为空
  assert(phead);

  LTNode* pcur = phead->next;
  while(pcur != phead)
  {
    LTNode* next = pcur->next;
    free(pcur);
    pcur = next;
  }
  //链表中只有一个哨兵位
  free(phead);
  phead = NULL;
}

4 顺序表和双向链表的优缺点

24f5918228574bb290a0a85700c9bf1e.png

 

敲皮裤的代码
关注
  • 19
    点赞
  • 踩
  • 12
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
【Java数据结构与算法】双向链表
12-21
1. **遍历**：遍历双向链表与单向链表类似，但可以选择向前或向后。可以通过头节点开始，然后依次访问每个节点直到达到链表末尾。 2. **添加节点**：默认情况下，新节点通常被添加到链表的末尾。首先找到链表的最后...
JavaScript数据结构与算法之链表
10-22
在JavaScript中，链表是一种非连续的线性数据结构，它通过节点间的引用关系来组织数据，而不是像数组那样按照连续的内存位置存储。链表的主要优势在于它可以在不预先知道数据大小的情况下灵活地添加和删除元素，因为...
Java数据结构与算法——双向链表
★★光亭★★
03-11 6105
Java数据结构与算法——双向链表
数据结构与算法学习笔记
热门推荐
ityqing的博客
09-25 33万+
本文是王争老师的《算法与数据结构之美》的学习笔记，详细内容请看王争的专栏。有不懂的地方指出来，我做修改。 数据结构与算法思维导图 数据结构指的是“一组数据的存储结构”，算法指的是“操作数据的一组方法”。 数据结构是为算法服务的，算法是要作用再特定的数据结构上的。 最常用的数据结构预算法: 数据结构：数组、链表、栈、队列、散列表、二叉树‘、堆、跳表、图、Tire树 算法： 递归...
数据结构与算法——线性表（链表篇）
小田是个程序员的博客欢迎你的到来呀~
06-20 2万+
本篇文章，主要详细解读和总结线性表的链式存储结构——链表，包括单链表、双链表、静态链表以及循环链表，讲解较为全面，图文并茂，总结各链表的特性以及基本操作，干货满满，各位小伙伴们请细细品读，你会收获你想要的知识的！.........
数据结构与算法——链表（双向链表，顺序表与链表的比较)
weixin_68773927的博客
10-25 1030
在双向链表中有此操作（如：ListLength，GetElem等）因此涉及一个方向的指针。故它们的算法与线性表相同，但在插入，删除时则需要同时修改两个方向上的指针，两者的操作的时间复杂度均为T(n)=O(n)双向链表：在单链表的每个结点里在增加一个指向其直接前驱的指针域prior 这样链表就形成了有两个方向不同的链。p的后继结点的前驱结点为自身。即：p的前驱结点的后继结点为它自身。
双向链表（数据结构与算法）
weixin_74967884的博客
12-11 2642
双链表的详细介绍，还有利用相关的图介绍，生动形象。
数据结构与算法：链表.pptx
05-11
总之，链表是计算机科学中不可或缺的数据结构，它提供了灵活的内存管理方式和高效的动态数据操作手段，广泛应用于各种算法和数据结构设计中。理解和熟练掌握链表的原理和操作对编程人员来说至关重要。
【数据结构与算法 - 链表】
04-18
在实际应用中，链表常用于实现队列、栈、哈希表等高级数据结构，以及解决各种算法问题，如LRU缓存、图的深度优先搜索等。 总的来说，掌握链表及其C语言实现对于提升编程能力至关重要。通过模块化的设计，我们可以更...
C#数据结构与算法揭秘四 双向链表
12-31
双向链表结点的定义与单链表的结点的定义很相似， ，只是双向链表多了一个字段 prev。其实，双向链表更像是一根链条一样，你连我，我连你，不清楚，请看图。 双向链表结点类的实现如下所示 //一个链条的类 public ...
数据结构之顺序表
m0_73634434的博客
07-10 420
线性表(List)由零个或多个数据组成的有限数列，线性表是一种在实际中广泛使用的数据结构，常见的线性表：顺序表，链表，栈，队列，字符串。
数据结构和算法（0-1）----递归
yanminghe66666的博客
07-09 612
递归算法，爬楼梯等解法
设备管理中的数据结构
yuanwu932730169的博客
07-11 434
它包含了通道标识符、通道状态（如忙/闲）、与通道连接的控制器表的指针、通道队列的队首指针和队尾指针等信息。功能：DCT主要用于记录单个设备的详细信息，包括设备类型、设备标识符、设备状态（如忙/闲、等待/不等待）、指向控制器表的指针、重复执行次数或时间、设备队列的队首指针等。功能：SDT是系统级别的数据结构，用于记录系统中所有物理设备的情况。功能：COCT主要用于记录单个控制器的详细信息，包括控制器标识符、控制器状态（如忙/闲）、与控制器连接的通道表指针、控制器队列的队首指针和队尾指针等。
二分查找和斐波那契查找
最新发布
weixin_50960004的博客
07-13 344
表面上看，后一调整存在风险，此时只能确定切分点arr[mid]＞target ，“贸然”地将arr[mi]排除在进一步的查找范围之外，似乎可能因遗漏这些元素，而导致本应成功的查找以失败告终。也就是说，无论朝哪个方向深入，都只需做1次元素的大小比较，其二，统一沿两个方向深入所需要执行的比较次数，比如都统一为一次。在有序向量中的查找，遇到重复的元素时会返回秩最大的那个，上述查找无法实现这个功能，因此加以改进。所以这样的话，想进入左半区间，进行一次比较，想进入右半区间，会进行两次比较，右侧比较会多。
代码随想录第十二天|226.翻转二叉树、 101.对称二叉树、104.二叉树的最大深度、111.二叉树的最小深度
semirc9的博客
07-09 773
二叉树
数据结构day6链式队列
picians的博客
07-10 607
主程序dequeue(Q);Q=NULL;return 0;源程序free(Q);Q=NULL;H->len=0;Q->head=H;Q->tail=H;return Q;return -1;return new;return;return;=NULL)
Redis 底层数据结构
xsgnzb的专栏
07-09 419
是列表和哈希表底层的实现之一，当只包含数字和短的字符串时，使用这个结构。由压缩列表和节点构成。压缩链表包含字节大小、尾指针偏移量、节点个数、节点列表、结束标识。编码类型包括int16、int32、int64，元素数组里的类型和编码类型相同。是有序集合的底层实现之一，由跳跃表和跳跃表节点组成。当新元素比元素数组里存放的类型比大时，会进行类型升级，重新分配空间和排序。跳跃表和平衡数的区别是，跳跃表查询复杂度平均跟平衡树一样是logn，最差是n²，但是它的实现很简单。上个节点的长度是动态的，分为1字节和5字节。
数据结构模板2
cocoack的博客
07-10 834
具体就是先确定一个把字符串映射成一个数的函数，我们可以把它看出p进制再mod Q，A,B,等赋予不同的权值（最好不要0，否则AA,A就是同一个了），这里有个经验值，我们一般取p=131或者13331,Q=2^64,我们可以认为此时没有冲突值。这里有个技巧：我们开unsigned long long 这样modQ就可以用溢出直接代替了。这样+前缀哈希就可以计算出所有子串的哈希值：h[r]-h[l]*p^(r-l+1).哈希表：按照存储结构可以分为开放寻址法以及拉链法。
数据结构之链表详解及示例（C，C#，C++）
qq_35320456的博客
07-13 720
链表是一种灵活且强大的数据结构，适用于需要频繁插入和删除操作的场景。本文通过C、C#、C++三种语言展示了链表的基本操作，帮助读者理解链表的工作原理。在实际应用中，应根据具体需求选择合适的链表变种，如单向链表、双向链表或循环链表。掌握链表是成为优秀程序员的必经之路。
软考辅导-数据结构与算法(“结点”文档)共134张.pptx
12-01
软考辅导-数据结构与算法(“结点”文档)共134张.pptx

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值