五、创建一个可复用的双向链表

最新推荐文章于 2023-05-13 19:36:07 发布
最新推荐文章于 2023-05-13 19:36:07 发布
阅读量454 收藏
点赞数
CC 4.0 BY-SA版权
分类专栏： 数据结构 文章标签： 结构 链表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/liuchuangjin/article/details/45972271
本文深入解析了DLinkList API的实现细节，包括创建、销毁、清空、长度、插入、获取、删除、重置、当前元素、下一元素、上一元素等操作，提供了一个全面的链表管理解决方案。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

一、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;   //多了一个指向其前驱的pre指针初始化 
        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;  //多了一个指向其前驱的pre指针初始化 
        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;//next初始化 
        
        for(i=0; (i<pos) && (current->next != NULL); i++)  //通过遍历获取当前元素指针指向要删除的元素 
        {
            current = current->next;
        }
        
        next = current->next; //初始化next作为current的下一个元素 
        
        current->next = node;  //将当前元素的后指针域指向插入的元素 
        node->next = next;    //将插入元素的后指针域指向next元素 
        
        if( next != NULL )   //判断next的地址是否有效 
        {
            next->pre = node;  //将next前驱指针指向插入的元素 
        }
        
        node->pre = current;   //将插入的元素的前指针域指向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;//ret理解为要删除的元素，现初始化 
        next = ret->next;    //初始化要删除元素的后一个元素 
        
        current->next = next;  //删除的元素的前一个元素，后指针域直接指向删除元素的后一个元素 
        
        if( next != NULL )//判读next是否有效 
        {
            next->pre = current; //next前驱的pre指针指向current  
            
            if( current == (DLinkListNode*)sList )  //如果将链表的最后一个删除，则将next->pre初始化为NULL 
            {
                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);
    }
    
    printf("\n");
    
    DLinkList_Delete(list, DLinkList_Length(list)-1);
    DLinkList_Delete(list, 0);
    
    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);
    
    pv = (struct Value*)DLinkList_Current(list);
    
    printf("%d\n", pv->v);
    
    DLinkList_DeleteNode(list, (DLinkListNode*)pv);
    
    pv = (struct Value*)DLinkList_Current(list);
    
    printf("%d\n", pv->v);
    
    DLinkList_Pre(list);
    
    pv = (struct Value*)DLinkList_Current(list);
    
    printf("%d\n", pv->v);
    
    printf("Length: %d\n", DLinkList_Length(list));
    
    DLinkList_Destroy(list);
    
return 0;
}


【数据结构】链表其实并不难 —— 手把手带你实现双向链表
StackFrame
11-10 3419
简述双向链表概念、C语言实现双向链表
七、栈实现c语言符号的匹配
liuchuangjin的博客
05-26 2516
1、LinkList.h #ifndef _LINKLIST_H_ #define _LINKLIST_H_ typedef void LinkList; typedef struct _tag_LinkListNode LinkListNode; struct _tag_LinkListNode {     LinkListNode* next; }; Link
数据结构-----双链表的创建
aa804738534的博客
02-05 539
#include <stdio.h> #include <stdlib.h> //节点结构 typedef struct line{ struct line *prior; int data; struct line *next; }line; //双链表的创建函数 line* initLine(line *head) { //创建一个首元节点，链表的头指针为 head head=(line *)malloc(sizeof(line...
可复用的双向链表
qq1471409117的专栏
01-29 593
#ifndef _DLINKLIST_H_ #define _DLINKLIST_H_ typedef void DLinkList; typedef struct _tag_DLinkListNode DLinkListNode; struct _tag_DLinkListNode {     DLinkListNode* next;     DLinkListNode*
可复用单链表的实现
你若成风
05-18 1228
/******************LinkList.h**********************/ #ifndef LINKLIST_H_ #define LINKLIST_H_ typedef void LinkList; //定义结点指针域 typedef struct _tag_LinkListNode LinkListNode ; struct _tag_LinkListNod
链表基础4（超简单）--创建一个长度为n的双向链表（代码可运行）
玫瑰花店的博客
11-14 1124
单链表的基础知识，创建，增删，逆序可以看我前几篇博客。点下面相应就可以跳过去咯！ 链表基础1（超简单）–创建一个长度为n的单链表 链表基础2（超简单）–单链表的插入和删除 链表基础3（超简单）–单链表的逆序 首先我们来理解一下什么是双向链表，话不多说上图： head是头节点地址，a1、a2分别是后面两个节点地址。 单项链表不就是a1的B存放head的地址嘛，a2的B存放a1的地址，这样不就连接起来了嘛 双向链表也是一样，只是在节点结构上比单项链表多了一个指针域，就是上图的A。尾节点a2的A中存放a1的地址
SlinkList（不带头节点的单链表）20171003
学无止境，Fighting！
10-03 555
#include typedef int Datatype; typedef struct link_node { Datatype info; struct link_node *next; }node; node *init(node *head) { return NULL; } void display(node *head) { if (!head
【数据结构】双向链表的实现
adcxhw的博客
04-07 1580
又是一篇万字文章，建议收藏。
数据结构——双向链表
麦麦的博客
03-11 2681
数据结构——双向链表：本文对双向链表的功能实现进行了详细地讲解，并与单链表的实现进行对比，干货满满，图文并茂，过万好文，不容错过！！！
双向链表--C语言实现数据结构
2201_76062618的博客
05-13 5297
本文详细介绍带头双向循环链表，内容较为丰富
C语言实现双向链表（双向带头循环）
2301_76269963的博客
03-21 1334
C语言实现双链表(双向带头循环)
双向链表代码
11-30
通常，`main.c`会创建一个双向链表，插入一些元素，然后可能进行一些遍历、搜索、插入或删除操作，最后可能会打印链表的状态或者释放内存资源。 **知识点总结** 1. 双向链表的基本概念和优势：双向遍历、插入和删除...
带头结点的双向循环链表
07-17
首先，双向循环链表与单链表的主要区别在于每个节点不仅包含数据，还包含两个指针：一个指向前一个节点，另一个指向后一个节点。在双向循环链表中，最后一个节点的“后继”指针会指向头结点，而头结点的“前驱”指针...
双向链表实现
12-05
本文将详细介绍如何使用C语言实现一个完全可复用的双向链表。 首先，我们需要定义双向链表的节点结构。在C语言中，我们可以创建一个结构体来表示节点，它通常包含三个部分：数据、指向下一个节点的指针和指向前一个...
C语言实现双向链表可复用代码
双向链表是一种特殊类型的链表，其中每个节点不仅有指向下一个节点的指针，还有一个指向前一个节点的指针。这种结构允许双向遍历，即可以从头节点开始向前或向后遍历链表。 【双向链表基础知识】 1. 节点结构：...
六、栈的实现两种方式
liuchuangjin的博客
05-26 994
前言：栈的特点：先进先出，只在栈顶进行操作。栈低密封，不进行操作，栈的实现有两种方式，通过对线性表实现进行复用。安全性高。 实现栈的方式：                          第一种：以顺序结构的方式实现：将顺序表的队尾作为栈顶                          第二种：以链式结构的方式实现：将链式表的队头作为栈顶 第一种实现方式(顺序结构)：
十一、实现队列的方法二（单链表的复用）
liuchuangjin的博客
05-29 977
通过对单链表代码的复用，实现队列 一、LinkList.h #ifndef _LINKLIST_H_ #define _LINKLIST_H_ typedef void LinkList; typedef struct _tag_LinkListNode LinkListNode; struct _tag_LinkListNode {     LinkLis
十二、队列的实现方法三（顺序表的优化）
liuchuangjin的博客
05-29 941
由于通过顺序表代码的复用实现队列的过程中，进队列要从队列的最后一个元素进入，所以造成时间复杂度加大，现通过引进front、rear优化队列实现方法 front：代表头元素的下标 rear：代表队尾下一个元素的下标 一、SeqQueue.h #ifndef _SEQQUEUE_H_ #define _SEQQUEUE_H_ typedef void S
十、队列的实现方法一（顺序表的复用）
liuchuangjin的博客
05-29 856
方法一、通过对顺序表代码的复用实现队列 一、SeqList.h #ifndef _SEQLIST_H_ #define _SEQLIST_H_ typedef void SeqList; typedef void SeqListNode; SeqList* SeqList_Create(int capacity); void SeqList_D
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值