数据结构——双向链表

最新推荐文章于 2023-06-28 15:05:06 发布
最新推荐文章于 2023-06-28 15:05:06 发布
阅读量235 收藏
点赞数 1
分类专栏： 常用数据结构 文章标签： 链表 数据结构 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ttdffmm/article/details/130065530
版权

概念：

双向链表也叫做双向表，是链表的一种，有多个结点组成，每隔结点都有一个数据域和两个指针域，数据域用来存数据，其中一个指针域用来指向后继结点，另一个指针域指向前驱结点。链表的头结点的数据域不存数据。指向前驱结点的指针域为NULL,指向后驱结点的指针域指向第一个真正存储数据的结点。

下边直接上代码。

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define FALSE 0
#define TRUE 1

typedef int  ElemType;
typedef unsigned int  uint;
//双向链表的结点，的结构体
typedef struct DullNode
{
    ElemType data;
    struct DullNode *per;//指向当前结点的前驱结点的指针
    struct DullNode *next;//指向当前节点的后继结点的指
}DullNode,*DuLinkList;//结构体定义类型定义两种类型
//普通结构体类型，和指针型

//带信息结点的双向链表结构体定义
typedef struct infoNode
{
    DullNode *head;//指向头结点的指针
    DullNode *tail;//指向尾结点的指针
    uint len;//链表长度
    char *desc;//存储链表的描述信息
}infoNode,*PinfoNode;

/*
 * @brief 带信息的双向链表的结构体定义
 * @param void
 * @return 成功返回TRUE 失败返回FALSE
 *
 * */
infoNode *List_infrom_Init(void)
{
    infoNode *L;
    L=(infoNode *)malloc(sizeof(infoNode));

    //创建一个头结点
    L->head=(DullNode *)malloc(sizeof(DullNode));
    L->head->next = NULL;
    L->tail=NULL;
    L->len = 0;
    L->desc=(char *)malloc(32);
    strcpy(L->desc,"test list");
    return L;
}



/*
 * @brief 从头节点链表打印函数
 * @param head  双向链表的头指针
 * @return 成功返回TRUE 失败返回FALSE
 *
 * */
void printf_list_from_head(DuLinkList head)
{
    if(NULL==head)
    {
        return;
    }
    DuLinkList t=head->next;
    while (t!=NULL)
    {
        printf("%d ",t->data);
        t=t->next;
    }
    printf("\n");
}

/*
 * @brief 从尾结点链表打印链表
 * @param head  双向链表的头指针
 * @return 成功返回TRUE 失败返回FALSE
 *
 * */
void printf_list_from_break(DullNode * pTail)
{
    if(NULL==pTail)
    {
        return ;
    }
    DullNode * t=pTail;
    //一直往前遍历直到遍历到头结点
    while (t->per!=NULL)
    {
        printf("%d ",t->data);
        t=t->per;
    }
    printf("\n");
}


//初始化链表
//可行性
/*
 * @brief 初始化双向链表
 * @param void
 * @return 成功返回TRUE 失败返回FALSE
 *
 * */
DullNode * Lis_Init(void)
{
    //创建一个头结点
    DuLinkList head = (DuLinkList)(malloc)(sizeof(DullNode));

    head->next=NULL;
    head->per=NULL;

    //将链表的头指针返回
    return head;
}

//双向链表的头插法
/*
 * @brief 双向链表头插法
 * @param head  双向链表的头指针
 * @param pTail 双向链表尾指针地址
 * @param data 需要插入的元素的值
 * @return 成功返回TRUE 失败返回FALSE
 *
 * */
int head_insert(DuLinkList head,DullNode ** pTail,ElemType data)
{
    if(NULL==head)
    {
        printf("[%s %d] head point is NULL",__FUNCTION__ ,__LINE__);
        return FALSE;
    }

    //创建一个新的结点
    DullNode *p=(DullNode *)malloc(sizeof(DullNode));
    p->per=NULL;
    p->next=NULL;
    p->data=data;

    //当链表为空的时候第一个被插入的结点就是链表的尾结点。
    if(NULL==head->next)
    {
        * pTail = p;
        p->per = head;
        head->next=p;
        return TRUE;
    }

    //将新的信号结点的next指向原来链表的第一个数据结点
    p->next=head->next;
    //将原来链表上的第一个数据结点的前驱指针指向新的结点
    head->next->per=p;
    //头结点的nest指向新的结点
    head->next = p;
    //将新的结点的前驱结点指向头结点
    p->per=head;

    return  TRUE;


}

//尾插法
/*
 * @brief 双向链表尾插法
 * @param head  双向链表的头指针
 * @param pTail 双向链表尾指针地址
 * @param data 需要插入的元素的值
 * @return 成功返回TRUE 失败返回FALSE
 *
 * */
int Tail_insert(DuLinkList head,DullNode ** pTail,ElemType data)
{
    if(NULL==head)
    {
        printf("[%s %d] head point is NULL",__FUNCTION__ ,__LINE__);
        return FALSE;
    }

    //创建一个新的结点
    DullNode *p=(DullNode *)malloc(sizeof(DullNode));
    p->per=NULL;
    p->next=NULL;
    p->data=data;

    //判断链表是否为空
    if(NULL==head->next)
    {
        head->next = p;
        p->per = head;
        *pTail = p;
        return TRUE;
    }

    (*pTail)->next=p;//(*pTail)->next不指向NULL指向新的结点
    p->per=*pTail;//
    *pTail=p;//尾指针指向新的结点
    return TRUE;
}

//在指定位置插入结点
/*
 * @brief 双向链表尾插法
 * @param head  双向链表的头指针
 * @param index 指定位置
 * @param data 需要插入的元素的值
 * @return 成功返回TRUE 失败返回FALSE
 *
 * */
int insert_by_index(DuLinkList head,uint index,ElemType data)
{
    if(NULL==head)
    {
        printf("[%s %d] head point is NULL",__FUNCTION__ ,__LINE__);
        return FALSE;
    }

    //创建一个新的结点
    DullNode *p=(DullNode *)malloc(sizeof(DullNode));
    p->per=NULL;
    p->next=NULL;
    p->data=data;

    int i=1;
    DullNode *t = head->next;//定义临时指针指向第一个结点
    while (i<index&&t!=NULL)
    {
        i++;
        t=t->next;//往下轮询
    }
    if(t==NULL)//调试语句
    {
        printf("[%s %d] index out of range ...",__FUNCTION__ ,__LINE__);
        return FALSE;
    }
    p->next=t;//新的结点的next指向t,
    t->per->next=p;//结点t的前驱结点的next指向新的结点
    p->per=t->per;//新的结点的前驱结点指向t的前驱结点
    t->per = p;//t的前驱结点指针指向新的结点

}

//在双向链表插入一个节点保持原列表升序
/*
 * @brief 双向链表尾插法
 * @param head  双向链表的头指针
 * @param pTail 双向链表尾指针地址
 * @param data 需要插入的元素的值
 * @return 成功返回TRUE 失败返回FALSE
 *
 * */
int ascending_insert(DuLinkList head,DullNode ** pTail,ElemType data)
{
    if(NULL==head)
    {
        printf("[%s %d] head point is NULL",__FUNCTION__ ,__LINE__);
        return FALSE;
    }

    //创建一个新的结点
    DullNode *p=(DullNode *)malloc(sizeof(DullNode));
    p->per=NULL;
    p->next=NULL;
    p->data=data;

    //先判断是否为空
    if(NULL==head->next)
    {
        head->next = p;
        p->per=head;
        *pTail = p;
        return TRUE;
    }
    DullNode *t = head->next;//定义临时指针指向第一个结点

    while (t!=NULL)
    {
        if(t->data<=data)
        {
            t=t->next;
            continue;
        }
        p->next=t;//新的结点的next指向t,
        t->per->next=p;//结点t的前驱结点的next指向新的结点
        p->per=t->per;//新的结点的前驱结点指向t的前驱结点
        t->per = p;//t的前驱结点指针指向新的结点
        return TRUE;
    }
    //如果链表遍历完毕，相当于尾插法
    (*pTail)->next=p;
    p->per=*pTail;
    *pTail = p;
    /*
     * 假如没有尾指针，遍历链表的时候，当遍历到链表的最后一个结点的时候就要停止遍历
     * */
    return TRUE;
}

//删除链表上的指定位置的结点
/*
 * @brief 双向链表尾插法
 * @param head  双向链表的头指针
 * @param index 指定位置
 * @return 成功返回TRUE 失败返回FALSE
 *
 * */
int Delete_node(DuLinkList head,uint index)
{
    if(NULL==head)
    {
        printf("[%s %d] head point is NULL",__FUNCTION__ ,__LINE__);
        return FALSE;
    }

    DullNode *t = head->next;//定义临时指针指向第一个结点
    int i=1;
    while (i<index&&t!=NULL)
    {
        i++;
        t=t->next;
    }
//先判断是否超范围
    if(NULL==t)
    {
        printf("[%s %d] index out of range ...",__FUNCTION__ ,__LINE__);
        return FALSE;
    }

    t->per->next=t->next;
    t->next->per=t->per;
    free(t);

    return TRUE;

}

//删除链表的指定元素
/*
 * @brief 双向链表尾插法
 * @param head  双向链表的头指针
 * * @param data 指定元素值
 * @return 成功返回TRUE 失败返回FALSE
 *
 * */
int Delete_Value(DuLinkList head,ElemType data)
{
    if(NULL==head)
    {
        printf("[%s %d] head point is NULL",__FUNCTION__ ,__LINE__);
        return FALSE;
    }

    DullNode *t = head->next;//定义临时指针指向第一个结点
//先判断是否超范围
    if(NULL==t)
    {
        printf("[%s %d] index out of range ...",__FUNCTION__ ,__LINE__);
        return FALSE;
    }
    while (t!=NULL)
    {
        if(t->data == data)
        {
            t->per->next=t->next;
            t->next->per=t->per;
            free(t);//释放链表空间
        }
        t=t->next;
    }

    return TRUE;

}

/*
* @brief 销毁链表
* @param head 双向链表头指针
* @param pTail 双向链表尾指针地址
* @return 成功返回TRUE 失败返回FALSE
*/
int Destroy_list(DuLinkList head,DullNode **pTail)
{
    if(NULL==head)
    {
        printf("[%s %d] head point is NULL",__FUNCTION__ ,__LINE__);
        return FALSE;
    }

    DullNode * t=head->next;//定义临时指针指向第一个结点
    while (t->next!=NULL)
    {
        head->next=t->next;
        t->next->per=head;
        free(t);
        t=head->next;
    }

    head->next=NULL;
    free(t);//释放最后一个结点
    free(head);//释放头结点
    *pTail=NULL;//防止尾指针成为野指针
    printf("The linked list was destroyed successfully");
    return TRUE;
}


int main() {
    printf("Hello, World!\n");

    DuLinkList head=Lis_Init();
    DullNode *tail = NULL;//尾指针

    int i;
    //验证头插法
    for(i=0;i<10;i++)
    {
    head_insert(head,&tail,100+i);
    }
    //打印
    printf_list_from_head(head);
    printf_list_from_break(tail);

    //验证尾插法
    for(i=0;i<10;i++)
    {
        Tail_insert(head,&tail,100+i);
    }
    //打印
    printf_list_from_head(head);

    //验证指定位置插入节点
    insert_by_index(head,2,1000);
    //打印
    printf_list_from_head(head);

    //删除链表上的指定位置的结点
     Delete_node( head,1);
    printf_list_from_head(head);

    //删除链表上的指定元素
    Delete_Value(head,100);
    printf_list_from_head(head);

    //销毁链表
    Destroy_list(head,&tail);



    return 0;
}

逸兴云飞~
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构-链表结构-双向链表
qq_44715376的博客
08-01 3203
双向链表
双向链表及其应用——实现多项式的加法及乘法
10-23
定义了线性表的抽象类，以及双向链表类及其结点类，实现双向链表的基本功能，还进一步应用到一元多项式的储存、加法和乘法，里面包含了项目文件，测试文件以及报告文件（一元多项式实现的思路）。
双向链表（Double Linked List）
热门推荐
Hacket_Xu的博客
08-28 1万+
虽然单向链表能够100%解决逻辑关系为“一对一”数据的存储问题，但在解决那些需要大量查找前趋节点的问题是，单向链表无疑是不能用了，因为单向链表适合“从前往后”查找，并不适合“从后往前”查找。如果要提高链表的查找效率，那双向链表（双链表）无疑是首选。双向链表字面上的意思是“双向”的链表，如图1所示。图1 - 双向链表示意图双向指各个节点之间的逻辑关系是双向的，该链表通常只有一个头节点。......
数据结构——双向链表（保姆级教程，包学包会）
m0_74459304的博客
05-14 6595
1.双向链表的概念 双向链表就是带头双向循环链表 我们在学完单链表之后，就感觉这个非常简单了，他的主要表现就是拥有头节点，链表永不为空，不需要二级指针；可以通过一个节点找到上一个或者下一个节点；头尾相连呈环状。 他主要结构是由prev、next、data，这三个结构组成，通过prev找到前一个节点，next就不用多说了。
【数据结构】双向链表
m0_73648729的博客
06-28 5737
和单向链表一样，双向链表每个节点都是由结构体组成的数据类型，但是双向链表结构体中增加了一个指向前一个节点的指针。//方便修改数据类型//指向下一个节点的指针//指向前一个节点的指针//存储的数据}LTNode;我们今天要将的是带哨兵卫头节点的双向循环链表，它的头节点不存储有效数据，头节点中的prev指针指向最后一个节点。
双向链表详解
m0_74859835的博客
06-02 2635
顾名思义，就是在头节点之前插入一个节点，并将其变成头节点。2. 看下标是不是头节点，尾节点，是的话直接调用头插法，尾插法。2. 判断是不是头节点，如果是且不只有一个元素。1. 要先判断他输入的下标合不合法。遍历链表 - 将所有值置为空。1. 先找到key所在的位置。
数据结构与算法 —— Java 实现（链表）
01-21
数据结构与算法 —— Java 实现（链表）一、单链表1.1 链表的定义1.2 链表添加一个新的节点1.3 判断当前节点是否为最后一个节点 （isLast）1.4 删除下一节点 （removeNext）1.5 显示节点信息（show）1.6 插入一个...
特殊的链表——双向、循环、静态
01-20
双向链表 定义 ：每个节点有两个指针域，分别知道直接前驱和直接后继节点 ， 特点是可以重任意节点出发，从两个方向遍历链表 数据结构 typedef struct node { int data; struct node *font ; struct node *next; ...
数据结构学习笔记——单链表
12-21
链表（linked list）是一种在物理上非连续，非顺序的数据结构，由若干节点（node）组成 单链表每一个节点又包含两部分，1是存放数据的变量data，2是存放指向下一个结点的指针next 双向链表每一个节点包含三部分，在...
【Java演示】什么是链表？数据结构（三）
01-20
专栏《两周干掉数据结构》 本博文的大部分插图来自于《漫画算法——小灰》，也复制了该书部分文字 我加了一些自己的总结、代码（我代码实现是参考了本书以及java自带LinkedList的源代码） 我发现本书有关链表的代码...
数据结构 —— 双向链表（超详细图解 & 接口函数实现）
十里坡小白的博客
08-08 6152
数据结构是计算机存储、组织数据的方式。数据结构是指相互之间存在一种或多种特定关系的数据元素的集合。博主将会用代码结合大量图解，对数据结构进行深度剖析。
链表------双向链表详解
weixin_51134816的博客
05-05 1564
双链表在增删改查方面比单链表方便很多，但在存储空间方面，单链表是比双链表更优的，根据场景不同，两种链表都能发挥出其优点。在学习链表方面，还是要注意区分头指针和头结点！不懂就查，不懂就问，不会就多练！
数据结构之链表详解(2)——双向链表
weixin_69283129的博客
08-29 8983
C语言版万字详解：数据结构之链表详解(2)——双向链表的结构和功能实现
【数据结构】--双向链表
m0_74044018的博客
04-15 916
1、主要讲述了双向循环链表的实现细节 2、再述了顺序表和链表的优缺点
数据结构——双向链表（双向连接的图解、双向链表的创建、操作双向链表）
qq_52301431的博客
08-23 4009
举个例子: 假设一个文本编辑用链表来存储文本. 每一行用一个String对象存储在链表的一个节点中. 当编辑器用户向下移动光标时, 链表直接操作到下一个节点即可. 但是当用于将光标向上移动呢?- 我们可以轻松的到达下一个节点, 但是回到前一个节点是很难的. 但是, 在实际开发中, 经常会遇到需要回到上一个节点的情况。- 也就是链表相连的过程是单向的. 实现的原理是上一个链表中有一个指向下一个的引用.- 一个节点既有向前连接的引用, 也有一个向后连接的引用.- 既可以从头遍历到尾, 又可以从尾遍历到头。
数据结构链表之双向链表
weixin_68927648的博客
04-23 420
3.让temp的下一个节点的prev换成temp的上一个节点temp.next.prev=temp.prev。双链是双向的，每一个节点内都存放了数据、下一个节点的地址next、上一个节点的地址prev。2.让temp的前一个节点指向temp的下一个节点temp.prev.next=temp.next。2）单链表节点不能自我删除，需要找到待删除节点的前一个节点，而双向链表可以自我删除。双链表比单链表多了一个prev用来存放上一个节点的地址.1)单链表只能向后查找，而双链表可以向前向后查找。
单循环链表和双向链表
最新发布
08-26
- *1* *2* [数据结构——单向循环链表&双向循环链表](https://blog.csdn.net/qq_56668869/article/details/126498355)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值