数据结构——带头双向循环链表

简介: 数据结构——带头双向循环链表

前言

``

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

一、带头双向循环链表

1.1 双向链表

双向链表也叫双链表,是链表的一种,它的每个数据结点中都有两个指针,分别指向直接后继和直接前驱。

1.2 带头双向循环链表

带头双向循环链表是在双向循环链表的基础上,引用一个哨兵位的头结点,哨兵位无任何意义,

二、带头双向循环链表的增删查改

2.1 链表头文件 List.h

链表的创建

链表增删查改的声明

2.2 链表源文件 List.c

结点的创建

LTNode* BuyLTNode(LTDataType x)
{
  LTNode* newnode = (LTNode*)malloc(sizeof(LTNode));
  if (newnode == NULL)
  {
    perror("malloc fail");
    return NULL;
  }
  newnode->data = x;
  newnode->next = NULL;
  newnode->prev = NULL;
  return newnode;
}

2.2.1 链表的初始化

链表初始化就是定义哨兵位头结点,此处phead的data值可以为任意值

LTNode* LTInit()
{
  LTNode* phead = BuyLTNode(-1);

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

  return phead;
}

2.2.2 链表的插入

尾插

在进行尾插时,最重要的一点时找到链表的尾端,又正因为时循环链表,所以链表的位段就是 phead->prev,在进行链表的链接

void LTPushBack(LTNode* phead, LTDataType x)
{
  assert(phead);

  LTNode* tail = phead->prev;
  LTNode* newnode = BuyLTNode(x);

  tail->next = newnode;
  newnode->prev = tail;

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

而在进行头插时,应该注意链表链接时的顺序,或者先标记好哨兵位的后继结点

void LTPushFront(LTNode* phead, LTDataType x)
{
  assert(phead);

  LTNode* newnode = BuyLTNode(x);
  LTNode* first = phead->next;

  newnode->next = first;
  first->prev = newnode;

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

2.2.3 链表的打印

本环节应该考虑循环多久停止,所以在循环链表中通常以phead->next为第一个结点开始遍历,当它回到phead时停止

void LTPrint(LTNode* phead)
{
  assert(phead);
  LTNode* cur = phead->next;
  printf("guard<=>");
  while (cur != phead)
  {
    printf("%d<=>", cur->data);
    cur = cur->next;
  } 
  printf("\n");
}

2.2.4 链表的删除

尾删

找到尾端与尾端的前驱结点,直接将head与tailPrev链接起来,最后释放tail

void LTPopBack(LTNode* phead)
{
  assert(phead);
  assert(!LTEmpty(phead));

  LTNode* tail = phead->prev;
  LTNode* tailPrev = tail->prev;

  free(tail);

  tailPrev->next = phead;
  phead->prev = tailPrev;
}
头删

定位到链表的第一个结点(不包括哨兵位),再进行头部的删除

void LTPopFront(LTNode* phead)
{
  assert(phead);
  assert(!LTEmpty(phead));

  LTNode* next = phead->next;

  phead->next = next->next;
  next->next->prev = phead;
  
  free(next);
}

2.2.5 链表的判空

在对链表进行删除时,我们必须考虑链表是否为空,对空链表的删除实则是个错误

bool LTEmpty(LTNode* phead)
{
  assert(phead);

  return phead->next == phead;
}

2.2.6 链表的查找

链表的查找实则为遍历一遍链表,找到符合的结点,同样要考虑循环结束的标志

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

  LTNode* cur = phead->next;

  while (cur!=phead)
  {
    if (cur->data == x)
    {
      return cur;
    }
    cur = cur->next;
  }

  return NULL;
}

2.2.7 链表的随机插入(pos之前)

只需找到并记录pos的前驱结点,再进行链接即可

void LTInsert(LTNode* pos, LTDataType x)
{
  assert(pos);

  LTNode* prev = pos->prev;
  LTNode* newnode = BuyLTNode(x);

  //prev newnode pos
  prev->next = newnode;
  newnode->prev = prev;

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

2.2.7 链表的随机删除(pos位置)

删除pos位置的值,需找到前驱结点和后继结点,并进行链接

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

  LTNode* posPrev = pos->prev;
  LTNode* posNext = pos->next;

  //posPrev pos posTail
  posPrev->next = posNext;
  posNext->prev = posPrev;
  free(pos);
}

2.2.8 链表的释放

此处释放后形参并不能改变实参,所以需在主函数中将链表置空

void LTDestory(LTNode* phead)
{
  assert(phead);

  LTNode* cur = phead->next;

  while (cur != phead)
  {
    LTNode* next = cur->next;
    free(cur);
    cur = next;
  }
  free(phead);
}

三、 结果展示

代码结果如下(示例):

四、感谢大家观看

目录
相关文章
|
19天前
|
存储 缓存 前端开发
【数据结构/C语言】深入理解 双向链表
【数据结构/C语言】深入理解 双向链表
|
19天前
|
存储 算法 C语言
【数据结构与算法 刷题系列】合并两个有序链表
【数据结构与算法 刷题系列】合并两个有序链表
|
4天前
【数据结构OJ题】合并两个有序链表
力扣题目——合并两个有序链表
24 8
【数据结构OJ题】合并两个有序链表
|
6天前
【数据结构OJ题】移除链表元素
力扣题目——移除链表元素
10 2
【数据结构OJ题】移除链表元素
|
6天前
【数据结构OJ题】链表中倒数第k个结点
牛客题目——链表中倒数第k个结点
9 1
【数据结构OJ题】链表中倒数第k个结点
|
6天前
|
存储 DataX C语言
【数据结构】双链表
数据结构中的双链表
14 1
【数据结构】双链表
|
3天前
【数据结构OJ题】链表分割
牛客题目——链表分割
4 0
【数据结构OJ题】链表分割
|
4天前
【数据结构OJ题】链表的回文结构
牛客题目——链表的回文结构
6 0
【数据结构OJ题】链表的回文结构
|
6天前
【数据结构OJ题】链表的中间结点
力扣题目——链表的中间结点
9 0
【数据结构OJ题】链表的中间结点
|
6天前
【数据结构OJ题】反转链表
力扣题目——反转链表
10 0
【数据结构OJ题】反转链表