数据结构-带头双向链表的建立，详细教程

已于 2024-04-06 16:26:15 修改
阅读量685 收藏 3
点赞数 1
文章标签： 数据结构 链表 算法
于 2022-05-21 16:35:00 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42976474/article/details/124899087
版权

前言

上一篇文章中我们学习了单链表的实现 本节将带大家学习带头双向链表的实现，希望能够对大家有一些帮助，话不多说，直接开干！！

文章目录

一、带头双向链表的概念和结构

概念：带头双向链表是一种 带不存储数据的哨兵卫，循环，双向的一种链表结构。它的每个数据结点中都有两个指针，分别指向直接后继和直接前驱。
特点:

  • 在数据结构中具有双向指针
  • 插入数据的时候方便找到上一个
  • 同样，删除数据的是有也需要考虑前后方向的操作
    在这里插入图片描述

和单链表的比较：

1.无头单向非循环链表：结构简单，但一般不会单独用来存数据。实际中更多是作为其他数据结构的子结构，如哈希桶，图的邻接表等等。另外，这种结构在笔试中出现很多。。
2.带头双向循环链表：结构最复杂，一般用在单独存储数据。实际中使用的链表数据结构，都是带头双向循环链表。另外，这个结构虽然结构复杂，但是使用代码实现以后会发现结构会带来很多优势，实现反而简单。后面我们代码实现了就知道了。
在这里插入图片描述
在这里插入图片描述

看代码

typedef int LTDataType;
typedef struct ListNode
{
    LTDataType data;
    struct ListNode* next;
    struct ListNode* prev;
}ListNode;

首先我们定义了一个结构体，结构体里的data被叫做数据域用来存放数据，next是指针域用来存放下一个节点的地址,prev是指针域用来存放上一个节点的地址。

二. 带头双向链表的接口实现

我们要实现如下的一些接口：

// 创建返回链表的头结点.
ListNode* ListCreate();
// 双向链表销毁
void ListDestory(ListNode** pHead);
// 双向链表打印
void ListPrint(ListNode* pHead);
// 双向链表尾插
void ListPushBack(ListNode* pHead, LTDataType x);
// 双向链表尾删
void ListPopBack(ListNode* pHead);
// 双向链表头插
void ListPushFront(ListNode* pHead, LTDataType x);
// 双向链表头删
void ListPopFront(ListNode* pHead);
// 双向链表查找
ListNode* ListFind(ListNode* pHead, LTDataType x);
// 双向链表在pos的前面进行插入
void ListInsert(ListNode* pos, LTDataType x);
// 双向链表删除pos位置的节点
void ListErase(ListNode* pos);

2.1 打印

*注意：头指针的位置不要轻易的去改动，所以在这定义了一个Cur来代替我们的头指针。

代码示例如下

// 单链表打印
void ListPrint(ListNode* pHead)
{
   assert(pHead);
  ListNode* cur=pHead->next;
  while(cur!=pHead) //这个条件很重要的
  {
      printf("%d->",cur->data);
      cur=cur->next;
  }
printf("NULL\n");
}

2.2 初始化

  • 注意：带头双向链表的初始化 需要创建一个哨兵卫的头指针，该位置不存储有效数据 。
// 创建返回链表的头结点.
ListNode* ListCreate()
{
   ListNode* phead=BuySListNode(-1);
   phead->next=phead;
   phead->prev=phead;
   return phead;
}

2.3 开辟节点

**当我们插入的时候需要开辟新的节点，而我们有头插、尾插和任意位置插，每次写这些插入的时候都要<br /> 
申请节点，所以我们不妨写一个函数就直接申请节点，后面只需要调用就好了**

代码实现：

LTDataType* BuySListNode(LTDataType x)
{
    LTDataType* newnode=(LTDataType*) malloc(sizeof(ListNode));
    assert(newnode);
    newnode->data=x;
    newnode->next=NULL;
    newnode->prev=NULL;
    return newnode;
}

2.4 尾部插入节点

要尾插的话，我们首先得要开辟一个结点才能插啊，其次是要找到尾结点，那么如何找到尾结点呢？很简单，一个while循环就搞定了。
代码示例如下：

// 单链表尾插
void ListPushBack(ListNode* pHead, LTDataType x)
{
  	ListNode* newNode = BuySListNode(x);
	// 先不断开原链表，然后新节点连接到链表中
	newNode->prev = pHead->prev;
	newNode->next = pHead;
	newNode->prev->next = newNode;
	pHead->prev = newNode;
}

2.5 尾部删除节点

示例代码如下：

void ListPopBack(ListNode* pHead)
{
   assert(pHead);
   %除哨兵结点外，链表为空的时候，就不能再删除了，用assert()
   assert(pHead->next!=pHead);
   
   ListNode* tail=pHead->prev;
   ListNode* tailPrev=tail->prev;
   free(tail);
   tailPrev->next=pHead;
   pHead->next=tailPrev;
}

2.6 头部插入节点

示例代码如下：

void ListPushFront(ListNode* pHead, LTDataType x)
{
  assert(pHead);
   ListNode* newnode=BuySListNode( x);
   ListNode* next=pHead->next;
   pHead->next=newnode;
   newnode->next=next;
   newnode->prev=pHead;
   next->prev=newnode;
}

2.7 头部删除节点

示例代码如下：

void ListPopFront(ListNode* pHead)
{
  assert(pHead);
  %除哨兵结点外，链表为空的时候，就不能再删除了，用assert()
  assert(pHead->next!=pHead);
  ListNode* next=pHead->next;
   pHead->next=next->next;
   next->next->prev=pHead;
   free(next);
}

2.8 查找

// 双向链表查找
ListNode* ListFind(ListNode* pHead, LTDataType x)
{
    assert(pHead);
 ListNode* cur=pHead->next;
  while(cur!=pHead)
  {
      if(cur->data==x)
      {
          return cur;
      }
      cur=cur->next;
  }
 return NULL;
}

2.9 在Pos位置前插入

注意：Insert最大的作用是：头插和尾插可以进行复用。
示例代码如下：

// 双向链表在pos的前面进行插入
void ListInsert(ListNode* pos, LTDataType x)
{
   assert(pos);
    ListNode* newnode=BuySListNode(x);
   ListNode* prev=pos->prev;
   prev->next=newnode;
   newnode->next=pos;
   newnode->prev=prev;
   pos->prev=newnode;
}

2.10 在Pos位置删除

示例代码如下：

// 双向链表删除pos位置的节点
void ListErase(ListNode* pos)
{
   assert(pos);
   ListNode* next=pos->next;
   ListNode* prev=pos->prev;
   prev->next=next;
   next->prev=prev;
   free(pos);
}

2.11 销毁链表

示例代码如下：

// 双向链表销毁
void ListDestory(ListNode** pHead)
{
 assert(phead);
  ListNode* cur=(*pHead)->next;
  while(cur!=*pHead)
  {
      ListNode* next=cur->next;
      free(cur);
      cur=next;
  }
   free(*pHead);
   *pHead=NULL;
}

总结

List.h完整代码：

#pragma once//防止头文件重复包含
 
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
 
// 带头+双向+循环链表增删查改实现
typedef int LTDataType;
typedef struct ListNode
{
    LTDataType data;
    struct ListNode* next;
    struct ListNode* prev;
}ListNode;

// 创建返回链表的头结点.
ListNode* ListCreate();
// 双向链表销毁
void ListDestory(ListNode** pHead);
// 双向链表打印
void ListPrint(ListNode* pHead);
// 双向链表尾插
void ListPushBack(ListNode* pHead, LTDataType x);
// 双向链表尾删
void ListPopBack(ListNode* pHead);
// 双向链表头插
void ListPushFront(ListNode* pHead, LTDataType x);
// 双向链表头删
void ListPopFront(ListNode* pHead);
// 双向链表查找
ListNode* ListFind(ListNode* pHead, LTDataType x);
// 双向链表在pos的前面进行插入
void ListInsert(ListNode* pos, LTDataType x);
// 双向链表删除pos位置的节点
void ListErase(ListNode* pos);

List.c
完整代码：

#define _CRT_SECURE_NO_WARNINGS 1
#include "SList.h"
// 动态申请一个节点

LTDataType* BuySListNode(LTDataType x)

{
    LTDataType* newnode=(LTDataType*) malloc(sizeof(ListNode));
    assert(newnode);
    newnode->data=x;
    newnode->next=NULL;
    newnode->prev=NULL;
    return newnode;
}


// 创建返回链表的头结点.

ListNode* ListCreate()
{
   ListNode* phead=BuySListNode(-1);
   phead->next=phead;
   phead->prev=phead;
   return phead;
}

// 双向链表销毁

void ListDestory(ListNode** pHead)
{
 assert(phead);
  ListNode* cur=(*pHead)->next;
  while(cur!=*pHead)
  {
      ListNode* next=cur->next;
      free(cur);
      cur=next;
  }
   free(*pHead);
   *pHead=NULL;
}

// 双向链表打印
void ListPrint(ListNode* pHead)
{
    assert(pHead);
  ListNode* cur=pHead->next;
  while(cur!=pHead) //这个条件很重要的
  {
      printf("%d->",cur->data);
      cur=cur->next;
  }
printf("NULL\n");
}
// 双向链表尾插
void ListPushBack(ListNode* pHead, LTDataType x)
{
  	ListNode* newNode = BuySListNode(x);
	// 先不断开原链表，然后新节点连接到链表中
	newNode->prev = pHead->prev;
	newNode->next = pHead;
	newNode->prev->next = newNode;
	pHead->prev = newNode;
}
// 双向链表尾删

void ListPopBack(ListNode* pHead)

{
    assert(pHead);
    assert(pHead->next!=pHead);
ListNode* cur=pHead->next;
  while(cur!=pHead)
  {
      ListNode* prev=cur;
      cur=cur->next;
  }
  prev->next=pHead;
  pHead->next=prev;
  free(cur);
}

// 双向链表头插
void ListPushFront(ListNode* pHead, LTDataType x)
{
  assert(pHead);
   ListNode* newnode=BuySListNode( x);
   ListNode* next=pHead->next;
   pHead->next=newnode;
   newnode->next=next;
   newnode->prev=pHead;
   next->prev=newnode;
}

// 双向链表头删
void ListPopFront(ListNode* pHead)
{
  assert(pHead);
  assert(pHead->next!=pHead);
  ListNode* next=pHead->next;
   pHead->next=next->next;
   next->next->prev=pHead;
   free(next);
}


// 双向链表查找
ListNode* ListFind(ListNode* pHead, LTDataType x)
{
    assert(pHead);
 ListNode* cur=pHead->next;
  while(cur!=pHead)
  {
      if(cur->data==x)
      {
          return cur;
      }
      cur=cur->next;
  }
 return NULL;
}



// 双向链表在pos的前面进行插入
void ListInsert(ListNode* pos, LTDataType x)
{
   assert(pos);
    ListNode* newnode=BuySListNode(x);
   ListNode* prev=pos->prev;
   prev->next=newnode;
   newnode->next=pos;
   newnode->prev=prev;
   pos->prev=newnode;
}



// 双向链表删除pos位置的节点
void ListErase(ListNode* pos)
{
   assert(pos);
   ListNode* next=pos->next;
   ListNode* prev=pos->prev;
   prev->next=next;
   next->prev=prev;
   free(pos);
}

码字不易，如果觉得内容有用的话，就给博主三连吧！！！

在这里插入图片描述

我爱小白羊
关注
  • 1
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
带头双向链表实现(带图详解)
fw5884179的博客
08-07 534
带头双向链表实现
数据结构c版（1）-线性表之双向带头循环链表代码
11-19
在本篇文章中，我们将深入探讨一个特定的数据结构——双向带头循环链表，它是线性表的一种实现方式。在C语言中，这种数据结构尤其常见，因为C语言提供底层内存管理和指针操作的能力，使得我们能够直接构建复杂的链式...
双向链表（带头结点）
bentao1997719的博客
05-24 844
双链表 - 两个方向 带头节点 节点的定义 typedef int data_t; typedef struct link_node{ data_t data; //数据域，用来保存数据 struct link_node *next; //保存后面一个节点的地址 struct link_node *pre; //用来保存前一个节点的地址 }link_node_t; 创建带头结点的双链表 link_node_t *create_link_list(void) { //定义头结点，在堆上分配
【数据结构与算法】(6)：带头结点的双向循环链表
更新C/C++，数据结构与算法，计算机视觉，深度学习，目标检测
05-31 2920
带头结点的双向循环链表
链表基础4——带头双向循环链表（c语言实现）
最新发布
2301_80224556的博客
04-21 895
/存储的数据类型//数据域//前驱指针//后继指针}ListNode;
数据结构——双向链表
ttdffmm的博客
04-15 251
双向链表也叫做双向表，是链表的一种，有多个结点组成，每隔结点都有一个数据域和两个指针域，数据域用来存数据，其中一个指针域用来指向后继结点，另一个指针域指向前驱结点。链表的头结点的数据域不存数据。指向前驱结点的指针域为NULL,指向后驱结点的指针域指向第一个真正存储数据的结点。
双链表——双链表的定义及其基本操作（初始化、头插法尾插法建表、插入、查找、删除、判空等）
热门推荐
薛定谔的猫的博客
04-18 2万+
文章目录双链表的定义双链表上的操作初始化插入操作建立双链表头插法建立双链表尾插法建立双链表遍历操作求双链表的长度查找操作按值查找按位查找删除操作判空操作完整代码及实例总结 双链表的定义  为什么引入双链表？  单链表的结点中只有一个指向其后继的指针，使得单链表要访问某个结点的前驱结点时，只能从头开始遍历，访问后驱结点的复杂度为O(1)，访问前驱结点的复杂度为O(n)。为了克服上述缺点，引入了双链表。  双链表的结点中有两个指针prior和next，分别指向前驱结点和后继结点。  双链表中结点类型的描述： t
【数据结构初阶】第四篇——双链表（实现+图解）
weixin_58450087的博客
10-29 1865
这篇博客，我要给大家分享双链表的知识，上一篇博客，我给大家分享了有关单链表的知识，单链表相比双链表而言结构比较简单，但事实上，双链表的实现比单链表要方便很多，下面我就来给大家聊一聊双链表的那些事儿~ 博客代码已上传至gitee：https://gitee.com/byte-binxin/data-structure/tree/master/List_2.0 目录带头双向链表的结构带头双向链表的接口实现初始化双链表打印双链表双链表的销毁双链表的尾插双链表的尾删双链表的头插双链表的头删双链表任意位置查找双链.
011.带头结点的双向链表
weixin_49043978的博客
04-21 109
main.c #include "list.h" #include <stdio.h> int main() { LIST * L = create_list(); insert_node(L,1); insert_node(L,2); insert_node(L,3); insert_node(L,4); printf_list(L); delete_list_x(L,4); printf_list(L); } list.c #include "list.h" #inclu
漫话数据结构-单循环链表及基本操作.pptx
11-03
在这个主题中，我们将专注于单循环链表，一种结合了链式存储和循环特性的数据结构。单循环链表是线性表的链式存储实现，它提供了一种灵活的方法来处理数据的插入、删除和访问操作。 首先，让我们理解单循环链表的...
数据结构-链表的C语言使用
03-25
链表是一种基础且重要的数据结构，它在计算机科学中扮演着关键角色，特别是在处理动态数据集合时。在C语言中，链表不像是数组那样在内存中连续存储元素，而是通过一系列分散的内存块（称为节点）来表示数据。每个...
带头结点的双向循环链表数据结构
01-08
【带头结点的双向循环链表数据结构】 在数据结构中，双向循环链表是一种特殊类型的数据结构，它允许从两个方向遍历链表。在本案例中，我们需要使用C++和Java分别实现这种数据结构，并确保它们符合指定的要求。 在...
C语言实现数据结构和双向链表操作
08-31
C语言实现数据结构和双向链表操作 本文主要介绍了C语言实现数据结构双向链表操作的相关知识点。...本文详细介绍了C语言实现数据结构双向链表操作的相关知识点，包括双向链表的类型描述、特点、操作等方面的内容。
数据结构：双向链表的头插法，尾插法，顺序插入，添加，修改、删除以及查询遍历等
weixin_48524739的博客
06-28 1649
双向链表
双链表中插入节点（C语言实现）
zsx0728的博客
07-15 8526
文章目录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）的指针，该指针指向前一节点
建立循环双链表（头插法）
muyu_muyu的博客
12-12 1311
该方法从一个空表开始，读取数组a中元素，生成新节点，将读取的数据存在该节点的数据域中，然后将该新节点插入到当前节点的表头上，直到结束为止。 双链表的存储结构： typedef strcut DLinkList{ int data; DLinkList *next; DLinkList *prior; } 思路： 1.创建头结点L,这里是循环链表，注意表头和表尾是相连的 2.通过for循环，创建新节点。然后将节点插入在头结点后，首结点之前。 注意循环
【C语言数据结构】双链表详解（带头双向循环链表）
谁在夜里看海.的博客
04-05 2217
我们把要存放的数据类型重命名，接着定义一个含有三个参数的结构体，分别用于存放数据，指向下一节点与指向上一节点。}ListNode;我们在进行插入操作以及建立头节点的时候都需要进行申请节点的操作，因此我们可以把它分装成一个函数。不管是进行插入还是删除操作，我们都需要传入哨兵位头节点，我们可以把哨兵位头节点的创立也分装成一个函数。然后剩下的的就是链表的通用功能：增删查改，pos位置的插入与删除以及链表的销毁。//双链表申请一个新节点// 创建返回链表的头结点// 双向链表打印。
如何创建带头结点的双链表
weixin_45866832的博客
09-18 943
深度 在创建带头结点的双链表前我们需要先了解什么是双链表： 双链表是在单链表的基础上多了一个 指向其直接前驱的指针初始状态因为只有一个头结点所以，L->next=NULL;L-.prior=NULLL;这样在任何一个结点都可以很方便的访问其前驱结点和后继结点 在访问其前驱和后继是时间复杂度都为O（1） 创建头结点的双链表可以使用头插法和尾插法来实现 下面依次讲解： ...
带头结点的双向循环链表的基础操作
qq_67303660的博客
01-07 315
最完善健全的一种链表——带头结点的双向循环链表
循环链表和双向链表.ppt
09-20
资源内容： 带头结点的链表、循环链表和双向链表的特征，基本运算。 对于循环链表要突出掌握判断链表空满的条件； 双向链表要强调插入和删除算法的实现。 最后通过多项式加法的示例，介绍线性表的应用。 预期目标： 我希望大家都学习点算法，提升下内功，别整天就知道CRUD，ok。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值