带头结点的双向链表的基本操作

最新推荐文章于 2024-06-14 09:57:50 发布
最新推荐文章于 2024-06-14 09:57:50 发布
阅读量3.7k 收藏 11
点赞数
分类专栏： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zgege/article/details/79830567
版权

这里写图片描述
准备工作

//带头结点的双向链表
#pragma once

typedef char DataType;

typedef struct Node
{
      DataType data;         //数据区
      struct Node *next;    //指向下一个节点
      struct Node *pre;     //指向前一个节点
}DLinklistNode;


//创建一个新节点
DLinklistNode* DLinklistCreatNode(DataType value)
{

    DLinklistNode* newnode=(DLinklistNode *)malloc(sizeof(DLinklistNode));

    newnode->next=newnode;
    newnode->pre=newnode;
    newnode->data=value;
    return newnode;

}

初始化

void DLinklistInit(DLinklistNode** phead)   
{
    if(  phead==NULL)
    {
        printf(  "  非法输入\n");
        return ;

    }
    *phead=DLinklistCreatNode('0');

}

这里写图片描述

//打印链表
void DLinklistPrint(DLinklistNode *phead,char* s)
{

    if(  phead==NULL)
    {
        printf(  "  非法输入\n");
        return ;

    }
    printf("\n%s\n",s);
    //打印头结点
    //printf("[%c][%p]\n",phead->data,phead);
    //从头到尾打印
    DLinklistNode *cur1=phead->next;
    while(cur1!=phead)
    {
        printf("[%c][%p]    ",cur1->data,cur1);
        cur1=cur1->next;
    }
    printf("\n");
    //从尾到头打印
    DLinklistNode *cur2=phead->pre;
    while(cur2!=phead)
    {
        printf( "[%c][%p]   ",cur2->data,cur2);
        cur2=cur2->pre;
    }

    //打印头结点
    // printf("[%c][%p] ", cur2 -> data, cur2 -> pre);
}

这里写图片描述

//尾插
void DLinklistPushBack(DLinklistNode* phead,DataType value)
{

    if(  phead==NULL)
    {
        printf(  "  非法输入\n");
        return ;

    }
    //创建一个新节点
    DLinklistNode *newnode=DLinklistCreatNode(value);

    //定义一个尾节点
    DLinklistNode* tail=phead->pre;
    //phead  vs  newnode
    newnode->next=phead;
    phead->pre=newnode;
    //tail vs newnode
    newnode->pre=tail;
    tail->next=newnode;
}

这里写图片描述

//销毁一个节点
void DLinklistDestory(DLinklistNode* to_delete)
{
    if(to_delete==NULL)
    {
        printf(  "非法操作\n");
        return;
    }
    free(to_delete);
}

//尾删
void DLinklistPopBack(DLinklistNode* phead)
{

    if(  phead==NULL)
    {
        printf(  "  非法输入\n");
        return ;
    }  
    if(  phead->next==NULL)
    {
        printf( "空链表\n");
        return;
    }
    //找到删除节点和删除节点的前一个节点
    DLinklistNode* to_delete=phead->pre;
    DLinklistNode* pre_delete=to_delete->pre;
    //phead vs pre_delete
    pre_delete->next=phead;
    phead->pre=pre_delete;
    //释放to_delete
    DLinklistDestory(to_delete);
}

这里写图片描述

//头插

这里写图片描述


void DLinklistPushFront(DLinklistNode* phead,DataType value)
{

    if(phead==NULL)
    {
        printf("非法输入\n");
        return ;
    }
    //创建新节点
    DLinklistNode* newnode=DLinklistCreatNode(value);
    //找到头结点之后的第一个节点
    DLinklistNode* after=phead->next;
    //newnode vs head
    newnode->pre=phead;
    phead->next=newnode;
    //newnode vs after
    newnode->next=after;
    after->pre=newnode;

}

这里写图片描述

//头删
void DLinklistPopFront( DLinklistNode* phead)
{

    if(  phead==NULL)
    {
        printf(  "  非法输入\n");
        return ;
    }  
    if(  phead->next==NULL)
    {
        printf( "空链表\n");
        return;
    }
    //找到删除节点和删除节点的后一个节点
    DLinklistNode* to_delete=phead->pre;
    DLinklistNode* to_delete_next=to_delete->next;
    //修改指向
    phead->next=to_delete_next;
    to_delete_next->pre=phead;
    //释放节点
    DLinklistDestory(to_delete);
}

这里写图片描述

//查找指定值的位置
DLinklistNode*  DLinklistFind(DLinklistNode* phead,DataType to_find)
{

    if(  phead==NULL)
    {
        printf(  "  非法输入\n");
        return ;
    }
    //空链表，返回NULL
    if(  phead->next==NULL)
    {
          printf(  "空链表\n");
          return NULL;

    }
    //定义一个指针遍历链表，找到返回cur指针
    DLinklistNode* cur=phead->next;
    while(cur!=phead)
    {
          if( cur->data==to_find)
          {
                return cur;
          }
          cur=cur->next;
    }
    //找不到，返回NULL
    return NULL;
}

这里写图片描述

在任意位置之后插入

这里写图片描述


void DLinklistInsert(DLinklistNode* phead,DLinklistNode*pos,DataType value)
{
      if(phead==NULL||pos==NULL)
      {
            printf( " 非法输入\n");
            return ;

      }
      //创建一个节点
      DLinklistNode* newnode=DLinklistCreatNode(value);
      //找到pos之前的节点
      DLinklistNode* cur=pos->pre;
      //newnode vs cur
      cur->next=newnode;
      newnode->pre=cur;
      //newnode vs pos
      newnode->next=pos;
      pos->pre=newnode;

}

这里写图片描述

在任意位置之后插入

这里写图片描述


void DLinklistInsert_Front(DLinklistNode* phead,DLinklistNode*pos,DataType value)
{

      if(phead==NULL||pos==NULL)
      {
            printf( " 非法输入\n");
            return ;

      }
      //创建一个节点
      DLinklistNode* newnode=DLinklistCreatNode(value);
      //找到pos之前的节点
      DLinklistNode* cur=pos->next;
      //newnode vs pos
      pos->pre=newnode;
      newnode->next=pos;
      //newnode vs cur
      newnode->pre=cur;
      cur->next=newnode;

}

这里写图片描述

//删除指定位置的值
void DLinkListErase(DLinklistNode* phead,DLinklistNode* pos)  
{

      if(phead==NULL||pos==NULL)
      {
            printf( " 非法输入\n");
            return ;


      }
      if( phead->next==NULL)
      {
          printf(  "空链表\n");
          return NULL;
      }  



    //找到pos之前和之后的节点
      DLinklistNode* before=pos->pre;
      DLinklistNode* after=pos->next;

     //before vs after
      before->next=after;
      after->pre=before;



}


//删除指定值
void DLinkListRemove(DLinklistNode* phead,DataType value)
{

      if(phead==NULL||pos==NULL)
      {
            printf( " 非法输入\n");
            return ;
      }  
      //定一个节点，遍历链表
      DLinklistNode* cur=phead->next;
      for(;cur!=phead;cur=cur->next)
      {
            //找到链表中的第一个value值，
            if(  cur->data==value)
            {
                  //保存存放value值的节点
                  DLinklistNode* tmp=cur;
                  //修改tmp节点前节点和后节点指向关系
                  cur->pre->next=cur->next;
                  cur->next->pre=cur->pre;
                  //销毁tmp节点
                  DLinklistDestory(tmp);
                  返回
                  return ;
            }
      }
}


//删除指定值的所有元素
void DLinkListRemoveAll(DLinklistNode* phead,DataType value)
{

      if(phead==NULL||pos==NULL)
      {
            printf( " 非法输入\n");
            return ;
      }  
      DLinklistNode* cur=phead->next;
      //遍历链表，找到所有value值，并删除
      for(;cur!=phead;cur=cur->next)
      {
            if(  cur->data==value)
            {
                  DLinklistNode* tmp=cur;
                  cur->pre->next=cur->next;
                  cur->next->pre=cur->pre;
                  DLinklistDestory(tmp);

            }
      }
}


//求双向链表的长度
size_t DLinkListSize(DLinklistNode* phead)
{

      if(phead==NULL||pos==NULL)
      {
            printf( " 非法输入\n");
            return ;
      } 
      //定义一个指针遍历链表，一个计数器计数
      DLinklistNode* cur=phead->next;
      size_t count=0;
      for(  ;cur!=phead;cur=cue->next)
      {
            ++count;
      }
      return count;
}


//判断链表是否为空
int DLinkListEmpty(DLinklistNode* phead)
{
      //链表为空，返回0，不为空返回1，非法操作返回-1
      if(phead==NULL||pos==NULL)
      {
            printf( " 非法输入\n");
            return -1;
      } 
     if(phead->next==NULL)
     {
           return 0;
     }
     return 1;
}

总结：

  • 在对链表进行插入删除等操作之前一定要对链表进行初始化，否则就会出现段错误，或者重复插入的情况。

  • 在任意位置插入之前，首先的找到插入位置，这个时候可以将未知问题化为已知问题。先调用查找函数，然后进行插入操作。

  • 各个节点的关系要确认清楚，尤其在任意位置之前插入和任意位置之后插入。

zgege
关注
  • 0
    点赞
  • 踩
  • 11
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
带头结点的双向循环链表
07-17
接下来，我们需要实现链表的一些基本操作，如创建、插入、删除节点以及遍历链表。创建链表时，首先创建头结点，然后可以按照需求添加节点。插入节点时，根据位置分为插入到头部、尾部或中间。删除节点则需要找到目标...
C语言实现带头结点尾结点的双向非循环链表的基本操作
10-09
以上代码实现了带头结点和尾结点的双向非循环链表的基本操作，包括创建、插入、删除、遍历和销毁链表。这样的链表设计能够方便地进行双向遍历，对于需要频繁在链表中间插入和删除节点的应用场景尤其有用。在C语言中...
带头+双向+循环链表的实现
最新发布
weixin_70238476的博客
06-14 929
【代码】带头+双向+循环链表的实现。
建立一个带头节点的双向链表
10-12
菜单：1.尾插法（用尾插法建立链表）；2.头插法（用头插法建立链表）；3.显示（打印链表）；4.求表长（输出链表长度）；5.后插（在指定节点后面插入）；...17.销毁（销毁整个链表，无法再对链表进行其他操作）；
带头结点的双向循环链表数据结构
01-08
总的来说，无论是C++还是Java实现，带头结点的双向循环链表都需要考虑链表的初始化、插入、删除、查找等基本操作，同时为了方便遍历，还需要实现相应的迭代器机制。这样的数据结构在处理需要双向访问数据的场景时...
带头节点的双向链表
10-29
在实际应用中，带头节点的双向链表常用于实现高效的数据结构和算法，如LRU缓存淘汰策略、实现高效的集合操作（如集合的并集、差集和交集）等。例如，在C++标准模板库（STL）中的`std::list`容器就是基于双向链表实现...
数据结构-顺序表实现队列的基本操作
zgege的博客
04-19 970
队列的定义 队列是另一种限定的数据结构，它只允许在表的一端插入，另一端删除。所以队列具有先进先出的特性。这与我们生活中的排队是一个道理。 在队列中允许删除的一端叫做队头，允许插入的一端叫做队尾。 队列分类 顺序队列（容易引起假溢出情况：顺序队列因多次入队，出队后出现的尚有存储空间，但不能在进行如队列的操作） 优先级队列 循环队列 本文用顺序表实现队列的基本操作 初始化 操作前提...
基于顺序表实现栈的基本操作
zgege的博客
04-10 797
栈：什么是栈？又该怎么理解呢？ 栈（stack）又名堆栈，它是一种运算受限的线性表。其限制是仅允许在表的一端进行插入和删除运算。这一端被称为栈顶，相对地，把另一端称为栈底。 栈就是一个桶，后放进去的先拿出来，它下面本来有的东西要等它出来之后才能出来（先进后出） 栈(Stack)是操作系统在建立某个进程时或者线程（在支持多线程的操作系统中是线程）为这个线程建立的存储区域，该区域具有FIFO的特性，在编
数据结构-基于双链表实现栈的基本操作
zgege的博客
04-14 773
准备工作 #pragma once #include <stdlib.h> //#include <stdio.h> typedef char LinkStackType; typedef struct LinkNode { struct LinkNode* next; struct LinkNode* pre; LinkSta...
C语言实现通讯录
zgege的博客
03-24 641
//基于顺序表实现的简易通讯录-----1 #define _CRT_SECURE_NO_WARNINGS 1 #include<stdio.h> #include<stdlib.h> #include<string.h> typedef struct stu //定义一个学生信息的结构体类型 { char name[20];
数据结构-二叉树遍历（基于递归实现）
zgege的博客
04-30 588
二叉树的存储结构主要了解二叉链表结构，也就是一个数据域，两个指针域，（分别为指向左右孩子的指针） typedef char DataType; typedef struct BinTreeNode { //左孩子 struct BinTreeNode* pleft; //右孩子 struct BinTreeNode* pright; ...
数据结构-单链表实现队列的基本操作
zgege的博客
04-19 562
头文件typedef char QueueType; typedef struct QueueNode { struct QueueNode* next; QueueType data; }QueueNode; //创建新节点 QueueNode* QueueCreat(QueueType value); //初始化 void QueueInit(QueueNode** pp
数据结构-堆的基本操作
zgege的博客
05-17 488
堆（heap）也被称为优先队列（priority queue）。队列中允许的操作是先进先出（FIFO），在队尾插入元素，在队头取出元素。而堆也是一样，在堆底插入元素，在堆顶取出元素，但是堆中元素的排列不是按照到来的先后顺序，而是按照一定的优先顺序排列的。这个优先顺序可以是元素的大小或者其他规则。如图一所示就是一个堆，堆优先顺序就是大的元素排在前面，小的元素排在后面，这样得到的堆称为最大堆。最大堆中...
数据结构-回溯法求解简单迷宫
zgege的博客
05-04 458
回溯法（探索与回溯法）是一种选优搜索法，又称为试探法，按选优条件向前搜索，以达到目标。但当探索到某一步时，发现原先选择并不优或达不到目标，就退回一步重新选择，这种走不通就退回再走的技术为回溯法，而满足回溯条件的某个状态的点称为“回溯点” 在生活中，也会出现回溯方法的运用，比如我们有些没有反向感的朋友们，去西安玩耍，走到钟楼底下环形通道迷路了，想要找到7出口，又不知道其他路径可行的情况下，就会原路...
顺序表的增删查操作
zgege的博客
03-11 349
本文目标：实现基于静态数组的顺序表的以下基本操作: 初始化 尾插 尾删 头插 头删 读任意位置元素 修改任意位置元素 查找指定元素值的下标 在任意位置插入元素 —————————————————————————————— seqlist.h#pragma once //防止头文件重复包含#include <stdlib.h> #define SeqListMaxNum 1
顺序表的基本操作
zgege的博客
03-28 274
本文目标：实现基于静态数组的顺序表的以下基本操作: 创建顺序表 #define DyataMaxSize 100 //定义顺序表的大小 typedef int DataType; //定义顺序表元素类型 typedef struct SeqList //定义一个结构体类型变量 { siz
数据结构-二叉树遍历及应用（非递归版本）
zgege的博客
05-05 251
//先序遍历 void BinTreePreOrderLoop(BinTreeNode* root) { //空树，直接返回 if(root==NULL) { return ; } //定义一个栈，并初始化 SeqStack stack; SeqStackInit(&amp;amp;amp;amp;stack);...
数据结构-单链表常见面试题
zgege的博客
04-22 224
一、题目 1、从尾到头打印单链表 (两种方法) 2、删除一个无头单链表的非尾节点（不能遍历链表） 3、在无头单链表的一个节点前插入一个节点（不能遍历链表） 4、单链表实现约瑟夫环(JosephCircle) 5、逆置/反转单链表 6、单链表排序（冒泡排序&amp;amp;快速排序） 7、合并两个有序链表,合并后依然有序 8、查找单链表的中间节点，要求只能遍历一次链表 9...
带头结点的双向循环链表操作集
04-30
双向循环链表是一种特殊的链表，它的最后一个节点的 next 指针指向第一个节点，第一个节点的 prev 指针指向最后一个节点，因此可以实现循环遍历。带头结点的双向循环链表是在双向循环链表的基础上增加了一个头结点，可以方便地进行插入、删除等操作。以下是带头结点的双向循环链表的常见操作： ```c++ // 双向循环链表节点结构体 template <typename T> struct Node { T data; Node<T>* prev; Node<T>* next; Node() : data(T()), prev(nullptr), next(nullptr) {} Node(T _data, Node<T>* _prev = nullptr, Node<T>* _next = nullptr) : data(_data), prev(_prev), next(_next) {} }; // 带头结点的双向循环链表类 template <typename T> class DoubleLinkedList { public: DoubleLinkedList() : head(new Node<T>()), size(0) { head->prev = head->next = head; } ~DoubleLinkedList() { clear(); delete head; } // 在 index 处插入元素 void insert(int index, const T& value) { if (index < 0 || index > size) { throw std::out_of_range("Index out of range."); } Node<T>* cur = head; for (int i = 0; i < index; ++i) { cur = cur->next; } Node<T>* node = new Node<T>(value, cur, cur->next); cur->next->prev = node; cur->next = node; ++size; } // 删除 index 处的元素 void remove(int index) { if (index < 0 || index >= size) { throw std::out_of_range("Index out of range."); } Node<T>* cur = head->next; for (int i = 0; i < index; ++i) { cur = cur->next; } cur->prev->next = cur->next; cur->next->prev = cur->prev; delete cur; --size; } // 清空链表 void clear() { while (size > 0) { remove(0); } } // 获取第 index 个元素 T& get(int index) const { if (index < 0 || index >= size) { throw std::out_of_range("Index out of range."); } Node<T>* cur = head->next; for (int i = 0; i < index; ++i) { cur = cur->next; } return cur->data; } // 获取链表长度 int getSize() const { return size; } // 判断链表是否为空 bool isEmpty() const { return size == 0; } private: Node<T>* head; // 头结点 int size; // 链表长度 }; ``` 以上是带头结点的双向循环链表的常见操作，可以根据实际需求进行调整和扩展。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值