数据结构：双向链表

已于 2024-07-26 11:46:16 修改
阅读量129 收藏
点赞数 8
文章标签： 数据结构 链表
于 2024-07-24 15:36:40 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_71751116/article/details/140634873
版权

一、基本概念

        解决顺序存储的缺点，插入和删除，动态存储（在编写代码阶段，不需要预估存储的大小，内存使用率较高）问题。

特点：
    线性表链式存储结构的特点是一组任意的存储单位存储线性表的数据元素，存储单元可以是连续的，也可以不连续。可以被存储在任意内存未被占用的位置上。
    
    所以前面的顺序表只需要存储数据元素信息就可以了。在链式结构中还需要一个元素存储下一个元素的地址。
    
    为了表示每个数据元素，ai与其直接后继数据元素ai+1之间的逻辑关系，对ai来说，除了存储其本身的信息外，还需要存一个指示器直接后续的信息。把存储元素信息的域叫数据域，把存储直接后继位置的域叫指针域。这两部分信息组成数据元素ai的存储映像，叫结点(Node);

二、基本函数

单链表中，c语言的描述
typedef struct person {
    char name[32];
    char sex;
    int age;
    int score;
}DATATYPE;

typedef struct node {
    DATATYPE data;
    struct node *next,*prev;
}LinkNode;

typedef struct list {
    LinkNode *head;
    int tlen;//元素总结点个数
    int clen;//当前链表里结点个数
}LinkList;

1.DouLinkList* CreateDouLinkList();
2.int InsertHeadLinkList(DouLinkList *list, DATATYPE *data);
3.int ShowDouLinkList(DouLinkList *list,DIRECT direct);
4.int GetSizeDouLinkList(DouLinkList *list);
5.int RevertDouLinkList(DouLinkList *list);
6.DouLinkNode *FindLinkList(DouLinkList *list, PFUN fun,void* arg);
7.int DeleteLinkList(DouLinkList *list, PFUN fun,void* arg);
8.int IsEmptyDouLinkList(DouLinkList *list);
9.int ModifyDouLinkList(DouLinkList *list,PFUN fun,void* arg,DATATYPE *data);
10.int DestroyDouLinkList(DouLinkList **list);
11.int InserPosDouLinkList(DouLinkList *list,DATATYPE *data,int pos);

1. CreateDouLinkList  创建双向链表

DouLinkList *CreateDouLinkList()
{
    DouLinkList* dl = (DouLinkList*)malloc(sizeof(DouLinkList));
    if(NULL == dl)
    {
        perror("CreateDouLinkList malloc");
        return NULL;
    }
    dl->head =NULL;
    dl->clen = 0 ;

    return dl;
}

 2. InsertHeadDouLinkList  头插

int InsertHeadLinkList(DouLinkList *list, DATATYPE *data)
{
    DouLinkNode*newnode = malloc(sizeof(DouLinkNode));
    if(NULL == newnode)
    {
        perror("InsertHeadLinkList malloc");
        return 1;
    }
    memcpy(&newnode->data,data,sizeof(DATATYPE));
    newnode->next = NULL;
    newnode->prev= NULL;

    if(0==list->clen)//empty
    {
        list->head = newnode;
    }
    else
    {
        newnode->next = list->head;
        list->head->prev = newnode;
        list->head = newnode;
    }
    list->clen++;
    return 0;
}

 3. ShowDouLinkList 打印

xxx.h

typedef enum{DIR_FORWARD,DIR_BACKWARD}DIRECT;

xxx.c

int ShowDouLinkList(DouLinkList *list, DIRECT direct)
{
    int i = 0 ;
    DouLinkNode* tmp = list->head;
    if(direct==DIR_FORWARD)
    {
        for(i=0;i<GetSizeDouLinkList(list);i++)
        {
            printf("%s %c %d %d\n",tmp->data.name,tmp->data.sex,tmp->data.age,tmp->data.score);
            tmp=tmp->next;
        }
    }
    else
    {
        while(tmp->next)
        {
            tmp=tmp->next;
        }
        for(i=0;i<GetSizeDouLinkList(list);i++)
        {
            printf("%s %c %d %d\n",tmp->data.name,tmp->data.sex,tmp->data.age,tmp->data.score);
            tmp=tmp->prev;
        }
    }
    return 0;
}

(注意：如果是头插的方式，选择顺序打印，打印的效果是相反的)

4. GetSizeDouLinkList 获取当前元素个数 

int GetSizeDouLinkList(DouLinkList *list)
{
    return list->clen;
}

 5.RevertDouLinkList  逆序

 逆序前准备：

逆序具体操作：


int RevertDouLinkList(DouLinkList *list)
{
    int size = GetSizeDouLinkList(list);
    if(size<2)
    {
        return 0;
    }

    DouLinkNode* prev= NULL;
    DouLinkNode* tmp = list->head;
    DouLinkNode*next= tmp->next;
    while(1)
    {
        tmp->next = prev;
        tmp->prev = next;
        prev= tmp;
        tmp = next;
        if(NULL == tmp)
        {
            break;
        }
        next =next->next;
    }
    list->head = prev;
    return 0;
}

6. FindDouLinkList 查找 

 xxx.h

typedef int (*PFUN)(DATATYPE*data,void* arg);

xxx.c

DouLinkNode *FindLinkList(DouLinkList *list, PFUN fun, void *arg)
{
    DouLinkNode* tmp = list->head;
    int size = GetSizeDouLinkList(list);
    int i =  0;
    for(i = 0 ;i<size;i++)
    {
        //if(0==strcmp(tmp->data.name))
        if(fun(&tmp->data,arg))
        {
            return tmp;
        }
        tmp= tmp->next;
    }
    return NULL;
}

main.c

int findbyname(DATATYPE*data,void* arg)
{
    return (0 == strcmp(data->name,(char*)arg));
}
int findbyage(DATATYPE*data,void* arg)
{
    return data->age == *(int*)arg;
}


int main()
{
    DATATYPE data[5]={
        {"zhangsan",'m',20,70},
        {"lisi",'f',21,60},
        {"wangmazi",'m',25,80},
        {"liubei",'f',30,85},
        {"caocao",'f',40,90},
    };
    char want_name[]="lisi";
    DouLinkNode* tmp = FindLinkList(dl,findbyname,want_name);
    int want_age = 25;
    DouLinkNode* tmp = FindLinkList(dl,findbyage,&want_age);
    if(NULL == tmp)
    {
        printf("can't find person ,name:%s\n",want_name);
    }
    else
    {
       printf("%s:%d\n",tmp->data.name,tmp->data.score);
    }
    return 0;
}

7. DeleteDouLinkList 删除链表中某个结点

 xxx.h

int DeleteLinkList(DouLinkList *list, PFUN fun,void* arg);

xxx.c

int DeleteLinkList(DouLinkList *list, PFUN fun, void *arg)
{
    if(NULL == list)
    {
        fprintf(stderr,"DouLinkList is null");
        return 1;
    }
    if(IsEmptyDouLinkList(list))
    {
        fprintf(stderr,"DouLinkList is empty");
        return 1;
    }
    DouLinkNode* ret = FindLinkList(list,fun,arg);
    if(NULL==ret)
    {
        fprintf(stderr,"DeleteLinkList error,cant find\n");
        return 1;
    }
    if(ret == list->head)
    {
        list->head = ret->next;
        list->head->prev = NULL;
    }
    else
    {
        if(ret->next)
        ret->next->prev = ret->prev;
        ret->prev->next = ret->next;
    }

    free(ret);
    list->clen--;
    return 0;
}

main.c

int findbyname(DATATYPE*data,void* arg)
{
    return (0 == strcmp(data->name,(char*)arg));
}
int findbyage(DATATYPE*data,void* arg)
{
    return data->age == *(int*)arg;
}

int main()
{
    DATATYPE data[5]={
        {"zhangsan",'m',20,70},
        {"lisi",'f',21,60},
        {"wangmazi",'m',25,80},
        {"liubei",'f',30,85},
        {"caocao",'f',40,90},
    };

    DeleteLinkList(dl,findbyname,"lisi");
    return 0;
}

8.  IsEmptyDouLinkList 判断链表元素是否为空

int IsEmptyDouLinkList(DouLinkList *list)
{
    return 0 == list->clen;
}

9. ModifyDouLinkList 修改结点内容

 xxx.h

typedef int (*PFUN)(DATATYPE*data,void* arg);
int ModifyDouLinkList(DouLinkList *list,PFUN fun,void* arg,DATATYPE *data);

xxx.c

int ModifyDouLinkList(DouLinkList *list, PFUN fun, void *arg, DATATYPE *data)
{
    DouLinkNode* ret = FindLinkList(list,fun,arg);
    if(NULL == ret)
    {
        fprintf(stderr,"ModifyDouLinkList error,cant find\n");
        return 1;
    }
    memcpy(&ret->data,data,sizeof(DATATYPE));
    return 0;
}

main.c

int findbyname(DATATYPE*data,void* arg)
{
    return (0 == strcmp(data->name,(char*)arg));
}
int findbyage(DATATYPE*data,void* arg)
{
    return data->age == *(int*)arg;
}

int main()
{
    DATATYPE data[5]={
        {"zhangsan",'m',20,70},
        {"lisi",'f',21,60},
        {"wangmazi",'m',25,80},
        {"liubei",'f',30,85},
        {"caocao",'f',40,90},
    };

    ModifyDouLinkList(dl,findbyname,"zhangsan",&data[3]);
    return 0;
}

10. DestroyDouLinkList  销毁链表

int DestroyDouLinkList(DouLinkList **list)
{
    DouLinkNode* tmp=(*list)->head;
    while(tmp)
    {
    (*list)->head=(*list)->head->next;
    free(tmp);
    tmp = (*list)->head;

    }
    free(*list);
    (*list)= NULL;
    return 0;
}

11.  InserPosDouLinkList 随机位置插入结点

xxx.h

int InserPosDouLinkList(DouLinkList *list,DATATYPE *data,int pos);

 xxx.c

int InserPosDouLinkList(DouLinkList *list, DATATYPE *data,int pos)
{
    if(pos<0 ||pos>GetSizeDouLinkList(list))
    {
        fprintf(stderr,"InserPosDouLinkList error,index error\n");
        return 1;

    }
    if(IsEmptyDouLinkList(list) || 0 == pos)
    {
        return InsertHeadLinkList(list,data);
    }
    else
    {
        DouLinkNode* tmp = list->head;
        tmp= list->head;
        DouLinkNode* newnode = (DouLinkNode*)malloc(sizeof(DouLinkNode));
        if(NULL == newnode)
        {
            perror("InserPosDouLinkList malloc");
            return 1;
        }
        memcpy(&newnode->data,data,sizeof(DATATYPE));
        newnode->prev = NULL;
        newnode->next = NULL;
        int i = pos-1;
        while(i--)
        {
            tmp=tmp->next;
        }
        newnode ->prev = tmp;
        newnode->next = tmp->next;

        if(tmp->next)
        {
        tmp->next->prev = newnode;
        }
        tmp->next = newnode;
    }
    list->clen++;
    return 0;
}

main.c

int main()
{
    DATATYPE data[5]={
        {"zhangsan",'m',20,70},
        {"lisi",'f',21,60},
        {"wangmazi",'m',25,80},
        {"liubei",'f',30,85},
        {"caocao",'f',40,90},
    };

    InserPosDouLinkList(dl,&data[3],3);
    return 0;
}

三、顺序表和链表 优缺点

    存储方式：
        顺序表是一段连续的存储单元
        链表是逻辑结构连续，物理结构（在内存中的表现形式）不连续
    
    时间性能：
        查找  顺序表O(1)
                 链表  O(n)
        插入和删除
                 顺序表 O(n)
                 链表   O(1)
            
    空间性能
            顺序表，需要预先分配空间，大小固定
            链表，不需要预先分配，大小可变，动态分配            
            
    循环链表
        简单的来说，就是将原来单链表中最有一个元素的next指针指向第一个元素或头结点，链表就成了一个环，头尾相连，就成了循环链表。circultlar linker list        
        注意非空表，和空表。多数会加入头结点。
        原来结束的条件是
        p->next != NULL ------->>>>> 此时遍历结束条件：p->next != Head 
        
    双向链表
    double link list。    
    typedef struct DulNode
    {
        ElemType date;
        struct DulNode *pri;
        sturct DulNode *next；
    }DulNode,*DuLinkList;

Yao_xiiiin.
关注
  • 8
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
数据结构：双向链表p结点前插入q
m0_60341379的博客
10-15 3925
双向链表P结点前插入q_哔哩哔哩_bilibilihttps://www.bilibili.com/video/BV1w54y1J7kK?from=search&seid=17934594539040246906&spm_id_from=333.337.0.0插值前提：链条不能断 data:放数据 prior:放P前一个节点的地址，通过prior可以找到前一个节点，p->prior == s next:放P后一个节点的地址，通过next可以找到后一个节点 p-...
数据结构：双向链表源码
07-02
双向链表是一种重要的线性数据结构，与单向链表相比，它提供了更灵活的访问和操作方式。本文将深入探讨双向链表的概念、结构以及其源码实现。 双向链表的每个节点不仅包含数据元素，还包含两个指针，一个指向前一个...
探索数据结构：双向链表的灵活优势
Bettysweetyaaa的博客
03-15 2150
这篇博客将深入探讨C语言中双向链表的实现和应用。通过介绍双向链表的结构和操作方法，读者将了解如何在C语言中灵活地利用双向链表来管理数据。我们将讨论双向链表的插入、删除和遍历操作，以及如何避免常见的错误和内存泄漏问题。
C语言简单的数据结构：双向链表的实现
2302_82004664的博客
04-14 1114
目录： 1.双向链表的结构和初始化 1.1双向链表的结构 1.2双向链表的初始化 2.双向链表的相关操作 2.1双向链表的尾插、打印和头插 2.11双向链表的尾插 2.12双向链表的打印 2.13双向链表的头插 2.2双向链表的尾删和头删 2.21双向链表的尾删 2.22双向链表的头删 2.3双向链表查找和任意位置插入、删除 2.31双向链表查找 2.32双向链表任意位置之后插入 2.33双向链表任意位置删除 2.4双向链表的销毁
数据结构：双向链表的使用
Rain的博客
05-10 1339
双向链表 为什么需要双向链表？ 在单链表中，有了next指针，这就使得要查找的下一个结点的时间复杂度为O(1)，可是要查找是上一个结点的话，最坏的时间复杂度是O(n)了，所以为了克服这一缺点提出双向链表。 双向链表：双向链表是在单链表的每个结点中，再设置一个指向其前驱结点的指针域。 双向链表中每个结点都有两个指针域：一个指向直接后继，一个指向直接前驱。 双向链表中循环的带头结点的空链表： 非空的...
数据结构：双向链表的基本程序
07-13
数据结构：双向链表的基本程序
数据结构：双向链表的实现和测试(C++).doc
10-10
数据结构中的双向链表是一种线性数据结构，与单向链表不同，它在每个节点中不仅包含指向下一个节点的指针，还包含一个指向前一个节点的指针。这使得双向链表支持双向遍历，增加了操作的灵活性。本文将深入探讨C++中...
数据结构 双向链表（C++）
06-07
双向链表是一种特殊的数据结构，它在计算机程序设计中扮演着重要角色，特别是在C++这样的编程语言中。本节将深入探讨双向链表的概念、其结构、操作以及C++中的实现。 双向链表与单链表不同，它允许每个节点不仅有一...
数据结构(5.3_3)——由遍历序列构造二叉树
m0_65240792的博客
07-25 100
若只给出一棵二叉树的前/中/后/层 序遍历序列中的一种，不能唯一确定一棵二叉树 例：前序遍历序列：DAEFBCHGI 中序遍历序列：DAEFBCHGI
学习记录day19——数据结构 查找算法
weixin_64918301的博客
07-25 185
在给定数据元素的某个值，在查找表中确定一个其关键字等于给定值的数据元素的操作，叫做查找。
【数据结构】单链表的增删改查
最新发布
2302_78914800的博客
07-25 635
链表是有序的列表，但是它在内存中是如下存储的：①链表以节点的方式进行存储，是链式存储的②每个节点包含 data 域、next 域：指向下一节点③链表的各个节点不一定是连续存放的④链表分为有头节点的链表和没有头节点的链表head节点1.不存放具体数据2.作用就是表示单链表头。
数据结构之初始二叉树（4）
我要学编程的博客
07-22 1217
二叉树的前序遍历、二叉树的层序遍历、根据二叉树的前序和中序遍历构造二叉树、二叉树的最近公共祖先、根据二叉树创建字符串
数据结构---二叉树
weixin_47808575的博客
07-22 266
参考：二叉树遍历方法——前、中、后序遍历（图解）_二叉树遍历前序中序后序-CSDN博客
重生之“我打数据结构，真的假的？”--3.栈和队列
2301_80374809的博客
07-21 700
栈：一种特殊的线性表，其只允许在进行插入和删除元素操作。进行数据插入和删除操作的一端称为栈顶，另一端称为栈底。栈中的数据元素遵守LIFO（Last In First Out）的原则。
数据结构~~顺序表
TU^的博客
07-22 886
定义：顺序表是用一组连续的存储单元依次存储数据元素的线性结构。特点：1. 逻辑顺序与物理顺序一致：元素顺序存储，相邻元素物理位置相邻。2. 可以快速访问任意元素：通过索引直接访问元素。优点：1. 实现简单。2. 随机访问方便。缺点：1. 插入、删除操作可能需要移动大量元素，效率较低。2. 需要预先确定固定的存储空间，可能造成空间浪费或不足。基本操作：包括初始化、插入、删除、查找、遍历等。
【数据结构】搜索二叉树
dab112的博客
07-24 1021
介绍了二叉搜索树的实现与模拟
数据结构：顺序表的实现
2303_81073778的博客
07-25 105
3.test.c文件。
【数据结构-前缀和】力扣2550.统计范围内的元音字符串数
sjsjs11的博客
07-22 439
计算前缀和数组的时间是 O(n)，然后计算 q 个查询的答案，计算每个查询的答案的时间是 O(1)，因此时间复杂度是 O(n+q)。输入：words = [“aba”,“bcb”,“ece”,“aa”,“e”], queries = [[0,2],[1,4],[1,1]]输入：words = [“a”,“e”,“i”], queries = [[0,2],[0,1],[2,2]]查询 [1,4] 结果为 3（字符串 “ece”、“aa”、“e”）。返回结果 [2,3,0]。输出：[3,2,1]
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值