75、双向链表

最新推荐文章于 2024-09-24 21:14:08 发布
最新推荐文章于 2024-09-24 21:14:08 发布
阅读量363 收藏 5
点赞数 8
文章标签： 链表 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_52137184/article/details/141305490
版权

单链表的局限

单链表的结点都只有一个指向下一个结点的指针

单链表的数据元素无法直接访问其前驱元素

逆序访问单链表中的元素是极其耗时的操作！！！

单链表的改进

双向链表的定义

在单链表的结点中增加一个指向其前驱的pre指针

循环链表的操作

双向链表拥有单链表的所有操作

■ 创建链表

■ 销毁链表

■ 获取链表长度

■ 清空链表

■ 获取第pos个元素操作

■ 插入元素到位置pos

■ 删除位置pos处的元素

双向链表的插入操作

双向链表的删除操作

将单链表改写成双向链表

DLinkList.h

#ifndef _DLINKLIST_H_
#define _DLINKLIST_H_

typedef void DLinkList;
typedef struct _tag_DLinkListNode DLinkListNode;
struct _tag_DLinkListNode
{
    DLinkListNode* next;//指向后继节点
    DLinkListNode* pre;//指向前驱节点
};

DLinkList* DLinkList_Create();

void DLinkList_Destroy(DLinkList* list);

void DLinkList_Clear(DLinkList* list);

int DLinkList_Length(DLinkList* list);

int DLinkList_Insert(DLinkList* list, DLinkListNode* node, int pos);

DLinkListNode* DLinkList_Get(DLinkList* list, int pos);

DLinkListNode* DLinkList_Delete(DLinkList* list, int pos);

DLinkListNode* DLinkList_DeleteNode(DLinkList* list, DLinkListNode* node);

DLinkListNode* DLinkList_Reset(DLinkList* list);

DLinkListNode* DLinkList_Current(DLinkList* list);

DLinkListNode* DLinkList_Next(DLinkList* list);

DLinkListNode* DLinkList_Pre(DLinkList* list);

#endif

DLinkList.c

#include <stdio.h>
#include <malloc.h>
#include "DLinkList.h"

typedef struct _tag_DLinkList
{
    DLinkListNode header;
    DLinkListNode* slider;
    int length;
} TDLinkList;

DLinkList* DLinkList_Create() // O(1)
{
    TDLinkList* ret = (TDLinkList*)malloc(sizeof(TDLinkList));
    
    if( ret != NULL )
    {
        ret->length = 0;
        ret->header.next = NULL;
        ret->header.pre = NULL;
        ret->slider = NULL;
    }
    
    return ret;
}

void DLinkList_Destroy(DLinkList* list) // O(1)
{
    free(list);
}

void DLinkList_Clear(DLinkList* list) // O(1)
{
    TDLinkList* sList = (TDLinkList*)list;
    
    if( sList != NULL )
    {
        sList->length = 0;
        sList->header.next = NULL;
        sList->header.pre = NULL;
        sList->slider = NULL;
    }
}

int DLinkList_Length(DLinkList* list) // O(1)
{
    TDLinkList* sList = (TDLinkList*)list;
    int ret = -1;
    
    if( sList != NULL )
    {
        ret = sList->length;
    }
    
    return ret;
}

int DLinkList_Insert(DLinkList* list, DLinkListNode* node, int pos) // O(n)
{ 
    TDLinkList* sList = (TDLinkList*)list;
    int ret = (sList != NULL) && (pos >= 0) && (node != NULL);
    int i = 0;
    
    if( ret )
    {
        DLinkListNode* current = (DLinkListNode*)sList;//
        DLinkListNode* next = NULL;// 用于保存当前节点的后继节点  
        
        // 找到要插入位置的前一个节点  
        for(i=0; (i<pos) && (current->next != NULL); i++)
        {
            current = current->next;
        }
        
        next = current->next;// 保存当前节点的后继节点  
        
        current->next = node; // 插入新节点  
        node->next = next;

        if( next != NULL )//如果next是空，那么没pre，不执行第三步
        {
            next->pre = node;//第三步
        }
        
        node->pre = current;
        
        if( sList->length == 0 )//判断插入的是不是第一个元素
        {
            node->pre = NULL;
            sList->slider = node;
        }
        
        sList->length++;
    }
    
    return ret;
}

DLinkListNode* DLinkList_Get(DLinkList* list, int pos) // O(n)
{
    TDLinkList* sList = (TDLinkList*)list;
    DLinkListNode* ret = NULL;
    int i = 0;
    
    if( (sList != NULL) && (0 <= pos) && (pos < sList->length) )
    {
        DLinkListNode* current = (DLinkListNode*)sList;
        
        for(i=0; i<pos; i++)
        {
            current = current->next;
        }
        
        ret = current->next;
    }
    
    return ret;
}

DLinkListNode* DLinkList_Delete(DLinkList* list, int pos) // O(n)
{
    TDLinkList* sList = (TDLinkList*)list;
    DLinkListNode* ret = NULL;
    int i = 0;
    
    if( (sList != NULL) && (0 <= pos) && (pos < sList->length) )
    {
        DLinkListNode* current = (DLinkListNode*)sList;
        DLinkListNode* next = NULL;
        
        // 找到要被删除的元素前一个元素
        for(i=0; i<pos; i++)
        {
            current = current->next;
        }
        
        ret = current->next;//找到要被删的元素
        next = ret->next;//被删元素的后继节点，存储到next指针中
        
        current->next = next;//当前元素的next指针指向被删除元素下一个元素
        
        if( next != NULL )//判断被删除元素是否是最后一个元素
        {
            next->pre = current;
            
            if( current == (DLinkListNode*)sList )//判断被删的元素是否是第一个元素
            {
                next->pre = NULL;
            }
        }
        
        if( sList->slider == ret )//判断要删除的元素是否是游标指向的元素
        {
            sList->slider = next;
        }
        
        sList->length--;
    }
    
    return ret;
}

DLinkListNode* DLinkList_DeleteNode(DLinkList* list, DLinkListNode* node)
{
    TDLinkList* sList = (TDLinkList*)list;
    DLinkListNode* ret = NULL;
    int i = 0;
    
    if( sList != NULL )
    {
        DLinkListNode* current = (DLinkListNode*)sList;
        
        for(i=0; i<sList->length; i++)//查找要删除的元素
        {
            if( current->next == node )
            {
                ret = current->next;
                break;
            }
            
            current = current->next;
        }
        
        if( ret != NULL )//不为空，找到
        {
            DLinkList_Delete(sList, i);
        }
    }
    
    return ret;
}

DLinkListNode* DLinkList_Reset(DLinkList* list)
{
    TDLinkList* sList = (TDLinkList*)list;
    DLinkListNode* ret = NULL;
    
    if( sList != NULL )
    {
        sList->slider = sList->header.next;
        ret = sList->slider;
    }
    
    return ret;
}

DLinkListNode* DLinkList_Current(DLinkList* list)
{
    TDLinkList* sList = (TDLinkList*)list;
    DLinkListNode* ret = NULL;
    
    if( sList != NULL )
    {
        ret = sList->slider;
    }
    
    return ret;
}

DLinkListNode* DLinkList_Next(DLinkList* list)
{
    TDLinkList* sList = (TDLinkList*)list;
    DLinkListNode* ret = NULL;
    
    if( (sList != NULL) && (sList->slider != NULL) )
    {
        ret = sList->slider;
        sList->slider = ret->next;
    }
    
    return ret;
}

DLinkListNode* DLinkList_Pre(DLinkList* list)
{
    TDLinkList* sList = (TDLinkList*)list;
    DLinkListNode* ret = NULL;
    
    if( (sList != NULL) && (sList->slider != NULL) )
    {
        ret = sList->slider;
        sList->slider = ret->pre;
    }
    
    return ret;
}

main.c

#include <stdio.h>
#include <stdlib.h>
#include "DLinkList.h"
/* run this program using the console pauser or add your own getch, system("pause") or input loop */

struct Value
{
    DLinkListNode header;//表头，节点头
    int v;
};

int main(int argc, char *argv[])
{
    int i = 0;
    DLinkList* list = DLinkList_Create();
    struct Value* pv = NULL;
    struct Value v1;
    struct Value v2;
    struct Value v3;
    struct Value v4;
    struct Value v5;
    
    v1.v = 1;
    v2.v = 2;
    v3.v = 3;
    v4.v = 4;
    v5.v = 5;
    
    DLinkList_Insert(list, (DLinkListNode*)&v1, DLinkList_Length(list));
    DLinkList_Insert(list, (DLinkListNode*)&v2, DLinkList_Length(list));
    DLinkList_Insert(list, (DLinkListNode*)&v3, DLinkList_Length(list));
    DLinkList_Insert(list, (DLinkListNode*)&v4, DLinkList_Length(list));
    DLinkList_Insert(list, (DLinkListNode*)&v5, DLinkList_Length(list));
    
    for(i=0; i<DLinkList_Length(list); i++)
    {
        pv = (struct Value*)DLinkList_Get(list, i);
        
        printf("%d\n", pv->v);//12345
    }
    
    printf("\n");
    
    DLinkList_Delete(list, DLinkList_Length(list)-1);//删除最后一个元素
    DLinkList_Delete(list, 0);//删除第一个元素
    //234
    for(i=0; i<DLinkList_Length(list); i++)
    {
        pv = (struct Value*)DLinkList_Next(list);
        
        printf("%d\n", pv->v);//
    }
    
    printf("\n");
    
    DLinkList_Reset(list);//游标指向第一个元素
    DLinkList_Next(list);//移动一个单位，游标指向第二个元素，3
    
    pv = (struct Value*)DLinkList_Current(list);
    
    printf("%d\n", pv->v);//3
    
    DLinkList_DeleteNode(list, (DLinkListNode*)pv);
    
    pv = (struct Value*)DLinkList_Current(list);
    
    printf("%d\n", pv->v);//4
    
    DLinkList_Pre(list);
    
    pv = (struct Value*)DLinkList_Current(list);
    
    printf("%d\n", pv->v);//2
    
    printf("Length: %d\n", DLinkList_Length(list));//2

    printf("\n");
    for(i=0; i<DLinkList_Length(list); i++)
    {
        pv = (struct Value*)DLinkList_Next(list);
        printf("%d\n", pv->v);//2,4
    }
    
    DLinkList_Destroy(list);
    
	return 0;
}

双向链表的新操作

  • 获取当前游标指向的数据元素

    • DLinkListNode*DLinkList_Current(DLinkList*list);

  • 将游标重置指向链表中的第一个数据元素

    • DLinkListNode*DLinkList_Reset(DLinkList*list);

  • 将游标移动指向到链表中的下一个数据元素

    • DLinkListNode*DLinkList_Next(DLinkList*list);

  • 将游标移动指向到链表中的上一个数据元素

    • DLinkListNode*DLinkList_Pre(DLinkList*list);

  • 直接指定删除链表中的某个数据元素

    • DLinkListNode*DLinkList_DeleteNode(DLinkList*list,DLinkListNode*node);

添加双向链表的新操作

(见上述程序)

小结

  • 双向链表在单链表的基础上增加了指向前驱的指针

  • 功能上双向链表可以完全取代单链表的使用

  • 循环链表的Next，Pre和Current操作可以高效的遍历链表中的所有元素

ᥬTff᭄
关注
Python单向链表和双向链表原理与用法实例详解
09-20
在Python中，我们可以自定义链表结构来实现单向链表和双向链表。 单向链表（Single Linked List）的特点是每个节点只包含一个指向下一个节点的引用。在单向链表中，遍历只能从头节点开始，按顺序访问每个节点，无法...
双向链表.cpp 双向链表类定义及测试代码 c++
12-02
双向链表类定义及测试文件 对应于数据机构与算法分析（c++版）第三版或第二版 Clifford A.Shaffer 重庆大学使用教材
双向链表
GaoChuang_的博客
04-10 293
一、单链表的局限性               1.单链表的结点都只有一个指向下一个结点的指针。                     2.单链表的数据元素无法直接访问其前驱的元素 二、双向链表的定义             在链表的指针中增加一个指向其前驱的pre指针            三、双向链表的操作       1.插入操作  
C 双向链表
weixin_33748818的博客
09-13 158
单链表的结点都只有一个指向下一个结点的指针 单链表的数据元素无法直接访问其前驱元素 逆序访问单链表中的元素是极其耗时的操作！ len = LinkList_Length(list); for (i=len-1; len&gt;=0; i++) //O(n) { LinkListNode *p = LinkList_Get(list, i); //O(n)...
单向链表与双向链表
qq_57106106的博客
07-29 906
可以解决顺序表存储空间上限，插入和删除效率低的问题链表：链式存储的线性表链表的组成：由一个个节点组成节点：由数据域和指针域组成数据域：存放数据的区域指针域：存放下一个节点地址的指针单向链表，双向链表，循环链表只能通过头节点或者头指针单向的访问后继节点的链表，称为单向链表。每个节点的指针域只记录其后继节点的地址。（火车结构）头节点结构体格式：int len；//头节点的数据域普通节点结构体格式：int data；//普通节点的数据域unionint len；//头节点的数据域。
数据结构--双向链表
m0_62706197的博客
06-24 1008
为了和前几篇文章的链表做比较，双向链表结构体也尽量定义相似的。// 前驱指针// 后驱指针。
数据结构——双向链表
麦麦的博客
03-11 2257
数据结构——双向链表：本文对双向链表的功能实现进行了详细地讲解，并与单链表的实现进行对比，干货满满，图文并茂，过万好文，不容错过！！！
Java实现双向链表
weixin_64448174的博客
06-01 4351
一、双向链表的简单理解 1、双向链表是什么？ 在前面的文章中，我们仔细讲解了单向链表，并且用代码实现了单向链表。单向链表的好处很多，虽然单链表能 100% 解决逻辑关系为 "一对一" 数据的存储问题，但在解决某些特殊问题时，单链表并不是效率最优的存储结构。比如说，如果算法中需要大量地找某指定结点的前趋结点，使用单链表无疑是灾难性的，因为单链表更适合 "从前往后" 找，而 "从后往前" 找并不是它的强项，因此我们就有了双向链表这个东西，双向链表顾名思义就是链表的高级版，他与单向链表有所不同的一点在于在具有
双向链表介绍
MHD0815的博客
08-22 681
双向链表（也称为双链表）是链表的一种重要数据结构，其特点在于每个数据节点中都有两个指针，分别指向其直接前驱和直接后继节点。这种结构使得从双向链表中的任意一个节点开始，都可以方便地访问其前驱和后继节点。
数据结构—双向链表
LEE_C17的博客
09-04 978
主要结构是由，这三个结构组成，通过prev找到前一个节点，next指向下一个节点。结构：节点（Node）：每个节点包含三部分：数据（Data）：存储节点的值。前指针（Prev）：指向链表中前一个节点的指针。后指针（Next）：指向链表中下一个节点的指针。在双向链表中同样可以实现单向链表中的头插，尾插，头删等操作。此外，如用到结构体，结构体可以整体赋值。特点：单向遍历：单向链表只能从头节点开始，按顺序向下遍历，直到链表的末尾。无法逆向遍历。
什么是双向链表，一篇搞懂双向链表
hahaha_1112的博客
03-12 1026
双向链表，python3
python实现双向链表
谁家的喵
04-27 3424
写一个双向链表，实现append,pop,insert,remove,__iter__，__getitem__功能。最后将链表改造为容器和带头链表
创建双向链表_双向链表_
09-30
双向链表是一种特殊类型的数据结构，与常见的单向链表相比，它具有更丰富的操作能力，可以支持前后两个方向的遍历。本篇文章将深入探讨如何创建双向链表以及其在增加和删除操作中的应用。 双向链表的每个节点不仅...
操作系统课设-线程安全的双向链表
04-25
操作系统课程设计中实现线程安全的双向链表是一项重要的实践任务，这涉及到多线程编程、数据结构以及并发控制等核心知识点。在这个项目中，我们主要关注如何在多线程环境下构建一个能够正确操作（如插入、删除）而不...
C语言中双向链表和双向循环链表详解
08-30
C语言中双向链表和双向循环链表详解 本文主要介绍了C语言中双向链表和双向循环链表的实现与操作，包括双向链表和双向循环链表的定义、初始化、插入操作、删除操作等。 一、双向链表和双向循环链表的定义 在C语言...
考研数据结构——C语言实现插入排序
最新发布
weixin_58879477的博客
09-24 405
C语言实现插入排序
数据结构：树、森林
pranaa的博客
09-24 849
此外，访问子节点和父节点的索引计算也会变得复杂，因为需要额外的数据结构（如指针或索引数组）来跟踪每个节点的子节点位置。在转换为二叉树时，我们可以将节点的第一个孩子视为二叉树的左孩子，将节点的下一个兄弟视为二叉树的右孩子。这种转换在处理树形结构的问题时非常有用，因为二叉树具有一些特殊的性质（如左子树和右子树的明确区分）和高效的算法（如二叉搜索树、堆等）。二叉树和树的顺序存储结构在本质上是相似的，但由于二叉树结构的特殊性，它在顺序存储中更加高效和直接。二叉树转换为树的过程是上述转换的逆过程。
javaScript 数据结构可变性和不可变性
everyStudy的博客
09-24 404
【代码】javaScript 数据结构可变性和不可变性。
Java-数据结构-排序(三) |ू･ω･` )
2303_80388948的博客
09-24 735
OK，到这里呢我们的排序呢就结束了，这次关于排序的代码呢还是比较多的，要认真的理解它们，同时要画图的去理解它们的执行流程。下一篇博客呢我们就要介绍关于Map与Set的知识啦，让我们尽情期待吧！！！拜拜~~~
双向链表数据管理
"多重双向链表的实现及操作" 多重双向链表是一种复杂的数据结构，它不仅包含元素节点，还包含多个指向不同属性的链接。在这个实现中，链表用于存储具有姓名、性别、信仰和职务等信息的员工数据。链表的每个节点...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值