双向链表介绍

简介: 带头链表⾥的头节点,实际为“哨兵位”,哨兵位节点不存储任何有效元素,只是站在这⾥“放哨的”。哨兵位存在的意义:避免链表出现死循环。

带头链表⾥的头节点,实际为“哨兵位”,哨兵位节点不存储任何有效元素,只是站在这⾥“放哨的”。哨兵位存在的意义:避免链表出现死循环

 双向链表的结构:数据+指向下一个节点的指针+指向前一个节点的指针

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

双向链表为空,只有一个头结点。

首先我们进行初始化

void LTInit(LTNode**pphead);//双向链表的初始化
LTNode* LTBuyNode(LTDataType x)
{
   LTNode*node=(LTNode*)malloc(sizeof(LTNode));
   if(node==NULL)
   {
       perror("malloc fail");
       exit(1);
    }
   node->data=x;
   node->next=node->prev=node;
   return node;
}
   
 
void LTPushBack(//插入链表之前,链表必须初始化到只有一个头节点的情况
{
    //给链表创建一个哨兵位
    *pphead=LTBuyNode(-1);
}

插入数据

首先我们要申请一个新的节点,再改变指针的指向。

void LTPushBack(LTNode* pphead,LTDataType x)//不改变头结点的位置,只用传一级指针就可以
{
    assert(phead);//首先头指针不能为空
    //先把newnode插入链表,再改变原链表前驱节点和后继节点指针的指向
    newnode->prev=phead->prev;
    newnode->next=phead;
    phead->prev->next=newnode;//先改变原头节点的前驱节点的后继节点
    phead->prev=newnode;
}
    

这个函数对空链表的情况也满足。

打印链表

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

头插

往头结点的后面插入

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

尾删

void LTPopBack(LTNode* phead)
{
    //链表必须有效且链表不能为空
   assert(phead&&phead->next!=phead);
   LTNode*del=phead->prev;//把头结点的上一个节点储存起来
   del->prev->next=phead;
   phead->prev=del->prev;
   free(del);
   del=NULL:
}

头删

void LTPopFront(LTNode* phead)
{
    assert(phead&&phead->next!=phead);
    LTNode* del=phead->next;
    phead->next=del->next;
    del->next->prev=phead;
    free(del);
    del=NULL;
}

在pos位置之后插入数据

void LTFind(LTNode* phead,LTDataType x)
{
     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;
    newnodeprev=pos;
    pos->next->prev=newnode;
    pos->next=newnode;
}

LTInsert方法包含了头插


删除pos节点

void LTErase(LTNode* pos)
{
     assert(pos);
     pos->next->prev=pos->prev;
     pos->prev->next=pos->next;
     free(pos);
     pos=NULL;
}

销毁链表

void LTDestory(LTNode* phead)
{
   assert(phead);
   LTNode* pcur=phead->next;
   while(pcur!=phead)
   {
        LTNode* next=pcur->next;
        free(pcur);
        pcur=next;
    }
    //此时pcur指向phead,而phead还没有被销毁
   free(phead);
   phead=NULL;
}

相关文章
|
1月前
|
存储
双向链表
单链表每个结点有一个指针域和一个数据域,要访问任何结点都需知道头结点,不能逆着进行。双向链表则添加了一个指针域,通过两个指针域分别指向结点的前一个结点和后一个结点。这样的话,可以通过双链表的任何结点访问到它的前一个结点和后一个结点。 两个指针域一个存储直接后继结点的地址,一般称为右链域,另一个存储直接前驱结点,一般称为左链域。
|
2月前
|
存储
双向链表(详解)
双向链表(详解)
37 1
|
6月前
|
存储
双向链表专题
双向链表专题
51 6
|
6月前
双向链表的实现
双向链表的实现
24 0
|
6月前
|
存储 算法 前端开发
【C/数据结构与算法】:链表的实现(单向链表+双向链表)
【C/数据结构与算法】:链表的实现(单向链表+双向链表)
32 0
|
7月前
秒懂双向链表
秒懂双向链表
33 0
|
7月前
|
Java
7.双向链表最佳实现
7.双向链表最佳实现
62 1
|
存储 算法 搜索推荐
双向链表
双向链表是一种链式存储结构,每个节点包含两个指针,分别指向其前驱和后继。相比于单向链表,双向链表可以在常数时间内向前或向后遍历整个链表。因此,双向链表在需要频繁遍历链表的场景中具有优势。
59 7
|
Python
单向链表
单向链表是一种线性数据结构,每个节点只包含一个指向下一个节点的指针。单向链表的第一个节点称为头节点,最后一个节点称为尾节点。单向链表的特点是只能从前往后遍历,不能倒序遍历。
64 8
10 双向链表
10 双向链表
44 0