数据结构之双向链表

已于 2023-01-03 21:48:42 修改
阅读量513 收藏
点赞数
分类专栏： 数据结构-牛刀小试 文章标签： 数据结构 双向链表 链表 C语言
于 2023-01-03 21:46:04 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yjhqukq/article/details/128530986
版权

双向链表与单向链表较为类似，单向链表有一个指针域，用来指向后继结点，而双向链表有两个指针域，分别用来指向前驱结点和后继结点。玩双向链表时一定要从单向链表的思维中跳出来，否则在操作双向链表时就会出现各种问题。在玩双向链表时，一定要动手画图或者在脑子里画图，考虑好每个操作细节。 

 一、双向链表的基本操作

双向链表的数据结构：

typedef struct node//定义双向链表的数据结构
{
    int data;
    struct node * prior;
    struct node * next;
}Node;

这里以整型作为结点数据域的数据类型

1. 初始化链表

        Node * initialize();

       创建头结点，初始化头结点的各个成员变量，返回头结点的指针

 2.头插法添加结点

        void insertFirst(Node * head,int data);

        方法形参上需传入头结点指针和新结点的数据，方法内会创建新结点，之后操作新结点、头结点、首结点，将新结点插入首结点的位置

3.尾插法添加结点

        void append(Node * head,int data);

        方法形参上需传入头结点指针和新结点的数据，方法内会创建新结点，之后操作头结点、末结点、新结点，将新结点插入到末结点的后面

4.删除结点

        int delete(Node * head,int data);

         方法形参上需传入头结点指针和结点的数据，方法内会从首结点向末结点遍历，查找指定数据的结点，若查找成功，则删除该结点，返回1，若查找无果，返回0

5.反转链表

        void reverse(Node * head);

          方法形参上需传入头结点指针,方法内会将链表的首尾顺序进行颠倒，原先的首结点作尾结点，原先的尾结点作首结点

6.正向遍历链表

        void traverse(Node * head);

          方法形参上需传入头结点指针，方法内输出链表的所有结点数据，不包括头结点

7.反向遍历链表

        void traverseReversely(Node * head);

        方法形参上需传入头结点指针，方法内从末结点到首结点进行数据输出，不输出头结点

二、代码实现


/*
双向链表
    初始化链表
    增加结点(头插法、尾插法)
    删除结点
    反转链表
    遍历链表(正向遍历，反向遍历)
*/
#include<stdio.h>
#include<stdlib.h>

typedef struct node//定义双向链表的数据结构
{
    int data;
    struct node * prior;
    struct node * next;
}Node;

Node * initialize();//初始化链表
void insertFirst(Node * head,int data);//头插法添加结点
void append(Node * head,int data);//尾插法添加结点
int delete(Node * head,int data);//删除结点
void reverse(Node * head);//反转链表
void traverse(Node * head);//正向遍历链表
void traverseReversely(Node * head);//反向遍历链表

int main(int argc,char * argv[])
{
    puts("------------------初始化链表------------------");
    Node * head=initialize();
    printf("head->prior=%p\n",head->prior);   
    printf("head->next=%p\n",head->next);   
    printf("head->data=%i\n",head->data);   

    puts("------------------头插法插入30，50，80------------------");
    insertFirst(head,30);
    insertFirst(head,50);
    insertFirst(head,80);
    
    puts("------------------正向遍历链表------------------");
    traverse(head);
    puts("------------------反向遍历链表------------------");
    traverseReversely(head);

    puts("------------------尾插法插入18，19，20------------------");
    append(head,18);
    append(head,19);
    append(head,20);
    puts("------------------正向遍历链表------------------");
    traverse(head);
    puts("------------------反向遍历链表------------------");
    traverseReversely(head);
    
    puts("------------------删除数据为20的结点------------------");
    puts(delete(head,20)?"删除成功":"删除失败");
    traverse(head);

    puts("------------------删除数据为80的结点------------------");
    puts(delete(head,80)?"删除成功":"删除失败");
    traverse(head);
   
    puts("------------------删除数据为30的结点------------------");
    puts(delete(head,30)?"删除成功":"删除失败");
    traverse(head);

    puts("------------------尾插法插入90，150------------------");
    append(head,90);
    append(head,150);
    traverse(head);
    
    puts("------------------反转链表------------------");
    reverse(head);
    traverse(head);
    
    puts("------------------再反转链表------------------");
    reverse(head);
    traverse(head);

    return 0;
}

Node * initialize()//初始化链表
{
    Node * head=(Node *)malloc(sizeof(Node));
    head->data=0;//头结点的数据域用来存储链表中结点的数量，不包括头结点
    head->prior=NULL;//头结点的前指针域置为空，在整个程序的运行过程中不作改变
    head->next=NULL;//头结点的后指针域暂时置为空，在整个程序的运行过程中会产生变化
    return head;
}

void insertFirst(Node * head,int data)//头插法添加结点
{
    Node * newborn=(Node *)malloc(sizeof(Node));//创建新结点
    newborn->data=data;//为新结点的数据域赋值
    /*
    采用头插法为双向链表添加结点时，
    注意：链表中只有一个头结点时，有三个指针变量需要赋值，
        分别是新结点前指针域、后指针域，头结点的后指针域
        链表中除了头结点外，还存在其它结点，有四个指针变量需要赋值
        分别是新结点前指针域、后指针域，原先的首结点的前指针域，头结点的后指针域
    */
    newborn->prior=head;
    newborn->next=head->next;
    if(head->next!=NULL)//链表中不是只有头结点，头结点有后继结点，该后继结点就是首结点
    {
        head->next->prior=newborn;//将首结点的前指针域指向新结点
    }
    head->next=newborn;//头结点的后指针域指向新结点
    head->data++;//头结点的数据域自增
}

void append(Node * head,int data)//尾插法添加结点
{
    Node * begin=head;//定义指针变量begin，初始值为头结点的指针，将其作为循环变量
    for(;begin->next!=NULL;begin=begin->next);//遍历至末结点
    
    Node * newborn=(Node *)malloc(sizeof(Node));//创建新结点
    newborn->data=data;//为新结点的数据域赋值
    newborn->prior=begin;//新结点的前指针域指向末结点
    newborn->next=begin->next;//把末结点后指针域的值赋给新结点的后指针域
    begin->next=newborn;  //末结点的后指针域指向新结点
    head->data++;//链表中结点数量自增
}

int delete(Node * head,int data)//删除结点
{
    for(Node * begin=head->next;begin;begin=begin->next)//从首结点向尾结点进行遍历
    {
        if(begin->data==data)//若查找到指定数据的结点,先问问该结点是否为末结点
        {
            if(begin->next!=NULL)//若非末结点
            {
                begin->prior->next=begin->next;
                begin->next->prior=begin->prior;
            }else//若为末结点
            {
                begin->prior->next=begin->next;
            }
            free(begin);//释放要删除的结点空间
            head->data--;//链表中的结点数量自减
            return 1;
        }
    }
    return 0;
}

void reverse(Node * head)//反转链表
{
    //反转链表使用头插法完成
    Node * temporary;//临时变量，作一个中间存储
    Node * begin=head->next;//定义指针变量begin，存储首结点的指针
    head->next=NULL;//头结点的后指针域置为空
    while(begin)//从首结点向末结点进行遍历
    {
        temporary=begin->next;//将当前结点的后继结点指针存储到指针变量temporary中，
        //当前结点的两个指针域重新赋值后，就无法确定原先的后继结点，这里先把其后续结点指针存储起来
        begin->prior=head;//当前结点的前指针域指向头结点
        begin->next=head->next;//当前结点的后指针域指向头结点后指针域的指向
        if(head->next!=NULL)//若头结点后指针域不为空，则说明链表中不是只有头结点
        {
            head->next->prior=begin;//头结点的后继结点前指针域指向当前结点
        }
        head->next=begin;//头结点的后指针域指向当前结点
        begin=temporary;//指针变量begin从当前结点转到下一个结点
    }
}

void traverse(Node * head)//正向遍历链表
{
    //头结点的数据域不进行展示,这里直接用head->next表示其它结点
    //用前驱的后指针域表示后继结点
    if(head->next->next==NULL)//到达末结点
    {
        printf("%d\n",head->next->data);
        return;
    }
    printf("%d , ",head->next->data);
    traverse(head->next);
}

void traverseReversely(Node * head)//反向遍历链表
{
    Node * begin=head->next;//将首结点的指针赋给指针变量begin
    while(begin->next!=NULL)//将指针变量begin作为循环变量进行遍历，循环条件是begin未到达末结点
    {
        begin=begin->next;//指针变量begin向末结点遍历
    }
    while(begin!=head)
    {
        if(begin->prior==head)//到达首结点
        {
            printf("%d\n",begin->data);
        }else
        {
            printf("%d , ",begin->data);
        }
        begin=begin->prior;
    }
}

三、运行展示

 四、总结

        玩双向链表，画图第一步，代码第二步，运行第三步。细心、耐心、恒心即可把玩双链表。

yjhqukq
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
数据结构 —— 双向链表（超详细图解 & 接口函数实现）
十里坡小白的博客
08-08 6345
数据结构是计算机存储、组织数据的方式。数据结构是指相互之间存在一种或多种特定关系的数据元素的集合。博主将会用代码结合大量图解，对数据结构进行深度剖析。
数据结构之链表详解(2)——双向链表
weixin_69283129的博客
08-29 9060
C语言版万字详解：数据结构之链表详解(2)——双向链表的结构和功能实现
【Java 数据结构】双向链表
程序猿教你打篮球的博客
11-16 2530
本期主要讲解： 1、什么是双向链表 2、实现一个双向链表 2.1 实现前的约定 2.2 addFirst 方法 2.3 addLast 方法 2.4 addIndex 方法 2.5 contains 方法 2.6 removeAllKey 方法 3、LinkedList 的学习 3.1认识下 LinkedList 3.2 LinkedList 的构造方法 3.3 LinkedList 的遍历 4、ArrayList 和 LinkedList的区别
【数据结构】双向链表
m0_73648729的博客
06-28 6634
和单向链表一样，双向链表每个节点都是由结构体组成的数据类型，但是双向链表结构体中增加了一个指向前一个节点的指针。//方便修改数据类型//指向下一个节点的指针//指向前一个节点的指针//存储的数据}LTNode;我们今天要将的是带哨兵卫头节点的双向循环链表，它的头节点不存储有效数据，头节点中的prev指针指向最后一个节点。
数据结构——双向链表（保姆级教程，包学包会）
m0_74459304的博客
05-14 7562
1.双向链表的概念 双向链表就是带头双向循环链表 我们在学完单链表之后，就感觉这个非常简单了，他的主要表现就是拥有头节点，链表永不为空，不需要二级指针；可以通过一个节点找到上一个或者下一个节点；头尾相连呈环状。 他主要结构是由prev、next、data，这三个结构组成，通过prev找到前一个节点，next就不用多说了。
C#数据结构之双向链表(DbLinkList)实例详解
09-03
在C#中，双向链表（Double-Linked List，简称DbLinkList）是一种重要的数据结构，它允许在列表中的每个元素都有两个链接：一个指向前一个元素，另一个指向后一个元素。这种数据结构使得在链表中进行前向和后向遍历变...
Python数据结构之双向链表的定义与使用方法示例
09-20
Python中的双向链表是一种线性数据结构，与单链表相比，它在每个节点中不仅包含指向下一个节点的指针，还包含一个指向前一个节点的指针。这使得双向链表可以在正向和反向两个方向上进行遍历，提高了操作的灵活性。 ...
JavaScript数据结构之双向链表定义与使用方法示例
10-19
在JavaScript中，数据结构是构建高效算法的基础，而双向链表是一种重要的线性数据结构。本文将深入探讨双向链表的定义、工作原理以及如何在JavaScript中实现和使用它。 双向链表，顾名思义，是每个节点不仅包含指向...
JavaScript数据结构之双向链表和双向循环链表的实现
10-18
在JavaScript中，数据结构是构建复杂程序的基础，其中双向链表和双向循环链表是两种重要的线性数据结构。本文将深入探讨这两种链表的实现原理，并通过代码示例进行详细解析。 首先，双向链表（Doubly Linked List）...
数据结构——双向链表
qq_62960549的博客
05-03 5997
1.双链表的定义 双向链表基于单链表。单链表是单向的，有一个头结点，一个尾结点，要访问任何结点，都必须知道头结点，不能逆着进行。而双链表添加了一个指针域，通过两个指针域，分别指向结点的前结点和后结点。这样的话，可以通过双链表的任何结点，访问到它的前结点和后结点。 在双向链表中，结点除含有数据域外，还有两个链域，一个存储直接后继结点的地址，一般称为右链域；一个存储直接前驱结点地址，一般称之为左链域。 双向链表结构示意图： /*随机数的范围*/#define MAX 10e/*节点结构*/ typ
数据结构-链表结构-双向链表
最新发布
qq_44715376的博客
08-01 3565
双向链表
数据结构——双向链表（双向连接的图解、双向链表的创建、操作双向链表）
qq_52301431的博客
08-23 4078
举个例子: 假设一个文本编辑用链表来存储文本. 每一行用一个String对象存储在链表的一个节点中. 当编辑器用户向下移动光标时, 链表直接操作到下一个节点即可. 但是当用于将光标向上移动呢?- 我们可以轻松的到达下一个节点, 但是回到前一个节点是很难的. 但是, 在实际开发中, 经常会遇到需要回到上一个节点的情况。- 也就是链表相连的过程是单向的. 实现的原理是上一个链表中有一个指向下一个的引用.- 一个节点既有向前连接的引用, 也有一个向后连接的引用.- 既可以从头遍历到尾, 又可以从尾遍历到头。
C语言---双向链表（详解）---数据结构
weixin_57535054的博客
02-07 7403
双向链表所需要头文件 首先重定义类型名 意义我前几篇讲过几次了，这里就不在赘述了，（顺序表，单链表的开头都有说明） 然后我们需要一个结构体 结构体包含 ： 存储数据的 a 指向一个节点的指针 next 指向上一个节点的指针 prve 双向链表实现的函数功能有 ：1.申请动态内存空间 2.初始化 3.双向链表的头，尾的插入与删除，在合法的任意位置进行插入和删除 4.释放链表，5.打印链表 1.申请动态内存空间 因为进行插入和初始化需要用到此函数 所以我们要先实现此功能 1.先申.
数据结构-双向链表
热门推荐
aaa0329的博客
05-03 1万+
双向链表也叫双链表，是链表的一种，它的每个数据结点中都有两个指针，分别指向直接后继和直接前驱。所以，从双向链表中的任意一个结点开始，都可以很方便地访问它的前驱结点和后继结点 ...
数据结构·双向链表
weixin_67595436的博客
08-08 226
链表的分类 带头双向循环链表的实现 顺序表和链表的区别
数据结构-----双向链表
weixin_63032791的博客
09-24 209
思路：找到需要删除的结点的前一个结点，然后新定义一个指针变量来存储删除结点，然后直接将删除结点的前一个的Next指向删除结点的后一个结点，然后将后一个结点的前驱指针指向删除结点的前一个结点。然后释放掉删除结点的内存空间。思路讲解：创建一个新结点，使用动态内存分配空间。双向链表就是在单向链表的基础上，增加了反向输出的功能，所以难度只是比单链表难理解一点点。头结点的下一个结点的前驱指针指向新节点，新节点的前驱指针指向头节点。查询操作：可以使用单链表查询的方法，除此之外，可以倒着往回找。建立前驱指针和后继指针。
数据结构C三双向链表
qq_62936495的博客
05-03 580
双链表是给链表中的每一个节点多加一个指针域，这个指针域将指向它的前驱，因此在双链表上，既方便查找后继，又方便查找节点的前驱。抄写并理解代码。 1.双向链表的存储，建立链表。 typedef struct DoubleLinkedNode{ char data; struct DoubleLinkedNode *previous; struct DoubleLinkedNode *next; }DLNode, *DLNodePtr; 2.双向链表初始化 DLNodePtr initLinkL
hashmap是单向链表吗_面试中HashMap链表成环的问题你答出了吗
weixin_39633102的博客
01-04 135
HashMap作为老生常谈的问题，备受面试官的青睐，甚至成为了面试必问的问题。由于大量的针对HashMap的解析横空出世，面试官对HashMap的要求越来越高，就像面试官对JVM掌握要求越来越高一样，今天我们来研究下HashMap的链表环化的问题，你知道其中的原理嘛？在JDK1.7版本下，有个线程安全的问题，经常会被问到，很多求职者可能还在对比Hashtable线程安全性...
数据结构-双向链表前插操作详解
这篇讲义主要讲解了数据结构中的一个重要概念——双向链表，并提供了前插操作的算法。双向链表是一种特殊的数据结构，每个节点不仅包含数据，还包含指向下一个节点和上一个节点的指针。这使得在链表中进行插入和删除...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值