双向链表c语言实现 doublelinklist.h 和 doublelinklist.c

最新推荐文章于 2024-06-15 09:00:00 发布
最新推荐文章于 2024-06-15 09:00:00 发布
阅读量1.2k 收藏 2
点赞数
分类专栏： 数据结构 文章标签： c语言 双向链表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/chen1540524015/article/details/74885783
版权

doublelinklist.h 文件

#ifndef _DOUBLE_LINK_LIST_H_
#define _DOUBLE_LINK_LIST_H_
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
//链表就是一个一个的表通过关系节点连接的
//双向链表
//链表操作精髓在于操作关系节点，引入辅助指针pcurrent,pnext.从表头开始遍历各关系节点。

typedef void List;
typedef void ListNode;


#ifndef bool
#define bool int
#define true 1
#define false 0
#endif

//定义双向链表的关系小节点
typedef struct _tag_DoubleLinkListConnectedNode
{
    struct _tag_DoubleLinkListConnectedNode* next;
    struct _tag_DoubleLinkListConnectedNode* pre;
}DoubleLinkListConnectedNode;

typedef struct _tag_DoubleLinkList
{
    DoubleLinkListConnectedNode head;
    DoubleLinkListConnectedNode* slider;
    int length;
}DoubleLinkList;

List* DoubleLinkList_Create();
bool DoubleLinkList_Destory(List* list );
bool DoubleLinkList_Clear(List* list);
int DoubleLinkList_GetLength(List* list);
bool DoubleLinkList_InsertOneNode(List* list,ListNode* listnode,int pos);
ListNode* DoubleLinkList_GetOneNode(List* list, int pos);
ListNode* DoubleLinkList_DeleteOneNode(List* list ,int pos);
bool DoubleLinkList_DeleteAllNode(List* list);
ListNode* DoubleLinkList_DeleteOneNodeByNodePointer(List* list,ListNode* listnode);
ListNode* DoubleLinkList_ResetSlider(List* list);
ListNode* DoubleLinkList_GetCurrentSlider(List* list);
ListNode* DoubleLinkList_SliderMoveToNext(List* list);

#endif

doublelinklist.c 文件

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "doublelinklist.h"
//链表就是一个一个的表通过关系节点连接的
//链表操作精髓在于操作关系节点，引入辅助指针pcurrent,pnext.从表头开始遍历各关系节点。

List* DoubleLinkList_Create()
{
    List* ret = NULL;
    DoubleLinkList* temp_doublelinklist = NULL;
    temp_doublelinklist = (DoubleLinkList*)malloc(sizeof(DoubleLinkList));
    if (temp_doublelinklist == NULL)
    {
        return NULL;
    }
    temp_doublelinklist->head.next = NULL;
    temp_doublelinklist->head.pre = NULL;
    temp_doublelinklist->slider = NULL;
    temp_doublelinklist->length = 0;
    ret = (List*)temp_doublelinklist;
    return ret;
}

bool DoubleLinkList_Destory(List* list )
{
    DoubleLinkList* temp_doublelinklist = NULL;
    if (list == NULL)
    {
        return false;
    }
    temp_doublelinklist = (DoubleLinkList*)list;
    free(temp_doublelinklist);
    temp_doublelinklist = NULL;
    return true;
}

bool DoubleLinkList_Clear(List* list)
{
    DoubleLinkList* temp_doublelinklist = NULL;
    if (list == NULL)
    {
        return false;
    }
    temp_doublelinklist = (DoubleLinkList*)list;
    temp_doublelinklist->head.next = NULL;
    temp_doublelinklist->head.pre = NULL;
    temp_doublelinklist->slider = NULL;
    temp_doublelinklist->length = 0;
    return true;
}

int DoubleLinkList_GetLength(List* list)
{
    int ret = 0;
    DoubleLinkList* temp_doublelinklist = NULL;
    if (list == NULL)
    {
        return -1;
    }
    temp_doublelinklist = (DoubleLinkList*)list;
    ret = temp_doublelinklist->length;
    return ret;
}

bool DoubleLinkList_InsertOneNode(List* list,ListNode* listnode,int pos)
{
    DoubleLinkList* temp_doublelinklist = NULL;
    DoubleLinkListConnectedNode* temp_doublelinklistconnectednode_insert = NULL;
    DoubleLinkListConnectedNode* pcurrent = NULL;   //辅助指针
    DoubleLinkListConnectedNode* pnext = NULL;      //辅助指针的下一节点
    int i = 0;
    if (list == NULL || listnode == NULL || pos < 0)
    {
        return false;
    }
    temp_doublelinklist = (DoubleLinkList*)list;
    temp_doublelinklistconnectednode_insert = (DoubleLinkListConnectedNode*)listnode;
    //辅助指针指向链表头部即首地址
    pcurrent = (DoubleLinkListConnectedNode*)temp_doublelinklist;
    //辅助指针跳到pos-1处
    for (i = 0; (i < pos && pcurrent->next != NULL); i++)
    {
        pcurrent = pcurrent->next;
    }
    //pcurrent 为要 插入节点 的前一节点，pnext为要 插入节点 的后一节点
    //pcurrent  pnext 三者的顺序关系 listnode插入前
    //pcurrent listnode pnext     listnode插入后
    //得到pnext
    pnext = pcurrent->next;
    //开始插入新节点 
    //正向连
    pcurrent->next = temp_doublelinklistconnectednode_insert;
    temp_doublelinklistconnectednode_insert->next = pnext;
    //反向连时 判断pnext是否为空，就是表头后面插入第一个节点时要处理
    if (pnext != NULL)
    {
        pnext->pre = temp_doublelinklistconnectednode_insert;
    }
    temp_doublelinklistconnectednode_insert->pre = pcurrent;
    //第一次插入时，游标指向第一个插入的节点
    if (temp_doublelinklist->length == 0)
    {
        temp_doublelinklist->slider = temp_doublelinklistconnectednode_insert;
    }
    //第一次插入的节点即0号位置的节点pre为null,插入的节点指向null
    if (pcurrent == (DoubleLinkListConnectedNode*)temp_doublelinklist)
    {
        temp_doublelinklistconnectednode_insert->pre = NULL;
    }
    temp_doublelinklist->length++;
    return true;
}

ListNode* DoubleLinkList_GetOneNode(List* list, int pos)
{

    ListNode* ret = NULL;
    DoubleLinkList* temp_doublelinklist = NULL;
    DoubleLinkListConnectedNode* temp_doublelinklistconnectednode = NULL;
    DoubleLinkListConnectedNode* pcurrent = NULL;   //辅助指针
    int i = 0;
    if (list == NULL || pos < 0)
    {
        return NULL;
    }
    temp_doublelinklist = (DoubleLinkList*)list;
    if (temp_doublelinklist->length <= 0 || pos >= temp_doublelinklist->length)
    {
        return NULL;
    }
    //辅助指针指向链表头部即首地址
    pcurrent = (DoubleLinkListConnectedNode*)temp_doublelinklist;
    //辅助指针跳到pos-1处
    for (i = 0; (i < pos && pcurrent->next != NULL); i++)
    {
        pcurrent = pcurrent->next;
    }
    temp_doublelinklistconnectednode = pcurrent->next;
    ret = (ListNode*)temp_doublelinklistconnectednode;
    return ret;
}


ListNode* DoubleLinkList_DeleteOneNode(List* list ,int pos)
{
    ListNode* ret = NULL;
    DoubleLinkList* temp_doublelinklist = NULL;
    DoubleLinkListConnectedNode* temp_doublelinklistconnectednode_delete = NULL;
    DoubleLinkListConnectedNode* pcurrent = NULL;   //辅助指针
    DoubleLinkListConnectedNode* pnext = NULL;      //辅助指针的下一节点
    int i = 0;
    if (list == NULL || pos < 0)
    {
        return false;
    }
    temp_doublelinklist = (DoubleLinkList*)list;
    if (temp_doublelinklist->length <= 0 || pos >= temp_doublelinklist->length)
    {
        return NULL;
    }
    //辅助指针指向链表头部即首地址
    pcurrent = (DoubleLinkListConnectedNode*)temp_doublelinklist;
    //辅助指针跳到pos-1处
    for (i = 0; (i < pos && pcurrent->next != NULL); i++)
    {
        pcurrent = pcurrent->next;
    }
    //得到pcurrent 和 pnext
    temp_doublelinklistconnectednode_delete = pcurrent->next;
    pnext = temp_doublelinklistconnectednode_delete->next;
    //连线连接
    pcurrent->next = pnext;

    //判断链表中是否只有一个业务节点
    //如果只有一个pcurrent即头部直接指向空就处理完毕，上一句就可以搞定了
    //pnext不为空，不止一个业务节点
    if (pnext != NULL)
    {
        pnext->pre = pcurrent;
        //0号位置的节点删除后，补上来的节点特殊处理
        if (pcurrent == (DoubleLinkListConnectedNode*)temp_doublelinklist)
        {
            pnext->pre = NULL;
        }
    }

    //删除游标指向的节点，游标指向下一个节点
    if (temp_doublelinklist->slider == temp_doublelinklistconnectednode_delete)
    {
        temp_doublelinklist->slider = pnext;
    }

    temp_doublelinklist->length--;
    ret = (ListNode*)temp_doublelinklistconnectednode_delete;
    return ret;
}

bool DoubleLinkList_DeleteAllNode(List* list)
{
    DoubleLinkList* temp_doublelinklist = NULL;
    if (list == NULL)
    {
        return false;
    }
    temp_doublelinklist = (DoubleLinkList*)list;
    while(temp_doublelinklist->length > 0)
    {
        DoubleLinkList_DeleteOneNode((List*)temp_doublelinklist,0);
    }
    return true;
}

ListNode* DoubleLinkList_DeleteOneNodeByNodePointer(List* list,ListNode* listnode)
{
    DoubleLinkList* temp_doublelinklist = NULL;
    DoubleLinkListConnectedNode* temp_doublelinklistconnected_delete = NULL;
    DoubleLinkListConnectedNode* pcurrent = NULL;
    DoubleLinkListConnectedNode* temp_doublelinklistconnectednode_ret = NULL;
    ListNode* ret = NULL;
    int i = 0;
    if (list == NULL || listnode == NULL)
    {
        return NULL;
    }
    temp_doublelinklist = (DoubleLinkList*)list;
    temp_doublelinklistconnected_delete = (DoubleLinkListConnectedNode*)listnode;
    if (temp_doublelinklist->length <= 0)
    {
        return NULL;
    }
    //得到辅助指针pos-1
    pcurrent = (DoubleLinkListConnectedNode*)temp_doublelinklist;
    //找同地址节点时
    for (i = 0; i < temp_doublelinklist->length; i ++ )
    {
        //链表头不存业务节点，此处就可以先指向0位置的业务节点后再判断
        pcurrent = pcurrent->next;
        if (pcurrent == temp_doublelinklistconnected_delete)
        {
            temp_doublelinklistconnectednode_ret = temp_doublelinklistconnected_delete;
            break;
        }

    }
    if (temp_doublelinklistconnectednode_ret == NULL)
    {
        return NULL;
    }
    DoubleLinkList_DeleteOneNode((List*)temp_doublelinklist,i);
    ret = (ListNode*)temp_doublelinklistconnectednode_ret;
    return ret;

}

//重置游标
ListNode* DoubleLinkList_ResetSlider(List* list)
{
    DoubleLinkList* temp_doublelinklist = NULL;
    DoubleLinkListConnectedNode* temp_doublelinklistconnected_node = NULL;
    ListNode* ret = NULL;
    if (list == NULL)
    {
        return NULL;
    }
    temp_doublelinklist = (DoubleLinkList*)list;
    temp_doublelinklist->slider = temp_doublelinklist->head.next;

    temp_doublelinklistconnected_node = temp_doublelinklist->slider;
    ret = (ListNode* )temp_doublelinklistconnected_node;
    return ret;
}

//返回当前游标，
ListNode* DoubleLinkList_GetCurrentSlider(List* list)
{
    DoubleLinkList* temp_doublelinklist = NULL;
    DoubleLinkListConnectedNode* temp_doublelinklistconnected_node = NULL;
    ListNode* ret = NULL;
    if (list == NULL)
    {
        return NULL;
    }
    temp_doublelinklist = (DoubleLinkList*)list;
    temp_doublelinklistconnected_node = temp_doublelinklist->slider;
    ret = (ListNode*)temp_doublelinklistconnected_node;
    return ret;
}

//游标下移，并返回游标下移之前的节点
ListNode* DoubleLinkList_SliderMoveToNext(List* list)
{
    DoubleLinkList* temp_doublelinklist = NULL;
    DoubleLinkListConnectedNode* temp_doublelinklistconnected_node = NULL;
    ListNode* ret = NULL;
    if (list == NULL)
    {
        return NULL;
    }
    temp_doublelinklist = (DoubleLinkList*)list;
    temp_doublelinklistconnected_node = temp_doublelinklist->slider;
    temp_doublelinklist->slider = temp_doublelinklistconnected_node->next;
    ret = (ListNode*)temp_doublelinklistconnected_node;
    return ret;
}


/**************************以下是测试代码*************************/

/*
typedef struct _tag_Teacher
{

    DoubleLinkListConnectedNode node;
    int age ;
    char name[];
}Teacher;

void main()
{
    List* list = NULL;
    Teacher t1,t2,t3,t4,t5;
    int kk = 0;
    Teacher* teacher = NULL;
    t1.age = 21;t2.age = 22;t3.age = 23;t4.age = 24;t5.age = 25;
    list = DoubleLinkList_Create();
    if (list == NULL)
    {
        printf("创建list失败");
    }
    //尾插法
    DoubleLinkList_InsertOneNode(list,(ListNode*)&t1,DoubleLinkList_GetLength(list));
    DoubleLinkList_InsertOneNode(list,(ListNode*)&t2,DoubleLinkList_GetLength(list));
    DoubleLinkList_InsertOneNode(list,(ListNode*)&t3,DoubleLinkList_GetLength(list));
    DoubleLinkList_InsertOneNode(list,(ListNode*)&t4,DoubleLinkList_GetLength(list));
    DoubleLinkList_InsertOneNode(list,(ListNode*)&t5,DoubleLinkList_GetLength(list));

    //
    for (kk = 0; kk < DoubleLinkList_GetLength(list); kk ++)
    {
         teacher = (Teacher* )DoubleLinkList_GetOneNode(list,kk);
         printf("老师%d的年龄是%d",kk,teacher->age);
         printf("\n");
    }
    printf("链表长度%d \n",DoubleLinkList_GetLength(list));

    DoubleLinkList_DeleteOneNodeByNodePointer(list,(ListNode*)&t5);
    //DoubleLinkList_DeleteOneNode(list,0);
    printf("链表长度%d \n",DoubleLinkList_GetLength(list));

    for (kk = 0; kk < DoubleLinkList_GetLength(list); kk ++)
    {
        teacher = (Teacher* )DoubleLinkList_GetOneNode(list,kk);
        printf("老师%d的年龄是%d",kk,teacher->age);
        printf("\n");
    }
    printf("链表长度%d \n",DoubleLinkList_GetLength(list));
    DoubleLinkList_DeleteAllNode(list);
    printf("链表长度%d \n",DoubleLinkList_GetLength(list));
    DoubleLinkList_Destory(list);
    system("pause");
}
*/

可能会调用其它头文件或源文件，如果调用，请翻看我的其它博客，对其头文件或源文件的实现。
good luck !

夏天不热 冬天不冷
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C语言实现双向链表
Yz529的博客
05-31 320
双向链表与单链表基本上类似，只是在删除和插入时有所不同因为其一个节点中多了一个指向其前驱的头指针，注意在插入和删除一个元素时，通用的插入和删除操作对最后一个元素不起作用，即不能在最后一个元素的后面继续插入元素（能通过尾插法插入），不能删除最后一个元素（能通过查找到最后一个元素，直接将其释放），在双向链表的创建时，若用头插法，需要注意第一个节点元素的插入与后续的节点插入的方法不一样，因为第一个节点元素在插入时并没有后继元素。 #include <stdio.h> #include <stdl
c语言实现的双向链表
07-31
用心去写的，codeblocks下经过很多测试，程序不会崩，visual studio下经过少量修改即可运行
双向链表详解及C++实现
最新发布
Weirdo的博客
06-15 479
本文详细介绍了双向链表的基本结构、操作实现以及C++代码示例。双向链表通过引入两个指针（prev和next）来实现对前后节点的访问，从而在插入、删除和遍历等操作上提供了更高的灵活性。在实际应用中，双向链表常用于需要频繁进行节点插入和删除的场景，如LRU（最近最少使用）缓存淘汰算法等。通过掌握双向链表的基本原理和实现方法，读者可以更好地理解和应用这种数据结构。
双向循环链表-C语言实现.doc
09-21
这篇文档主要介绍的是如何在C语言中实现双向循环链表的...总的来说，这篇文档详细介绍了如何使用C语言实现双向循环链表的初始化、插入、删除和查找操作，对于理解链表数据结构以及在C语言中操作链表有很好的指导作用。
使用C语言实现贪吃蛇小游戏（双向链表实现）snake.c
03-28
使用纯C实现贪吃蛇小游戏，欢迎小伙伴探讨使用纯C实现的其他算法。感兴趣的伙伴可以自己也试着写一下，如果纯C不太容易，使用其他面向对象的语言实现会轻松不少。可使用上/下/左/右键或A/S/D/W键控制贪吃蛇移动方向
C语言通讯录（双向链表实现）.zip
06-21
本项目"**C语言通讯录（双向链表实现）**"是利用C语言实现了一个通讯录系统，该系统的核心数据结构是双向链表。双向链表是一种线性数据结构，它不同于单链表，每个节点不仅包含数据，还包含两个指针，一个指向前一个...
链表去重c语言实现.md
09-25
链表去重c语言
C语言实现双向链表DuLiST.c
03-24
总的来说，"C语言实现双向链表DuLiST.c"项目提供了一个基础但实用的双向链表实现，它展示了如何用C语言有效地管理内存和操作链表结构。对于学习数据结构、C语言编程或者需要使用链表功能的开发者来说，这是一个很好...
双向链表C语言实现
12-13
通过双向链表实现按照ID序列插入，可以排序实现插入、删除、更新、修改；
双链表C语言实现
06-03
双链表C语言实现，详细参考博客 https://blog.csdn.net/qq_28261343/article/details/53584995#t40
c语言实现双链表
angelbrain0923的博客
01-10 69
　　中午写了一篇关于单链表的博客。好吧，我并没有搜到我写的这篇文章。但我还是要写下去，万一有人看到了呢……不过，呵呵。。。 双链表和单链表的操作大同小异，只是多了一个前驱指针，我是这样定义的。 typedef struct node { int data; struct node * previous; struct node * next; }...
C语言实现双链表
Aiden_yan的博客
10-01 754
C语言实现双链表 文章目录C语言实现双链表说明实现的功能结构体定义初始化插入结点删除结点输出所有元素全部代码测试 说明 图片自己画的，有点丑，不要介意。 本文来自专栏：数据结构 后续还会继续coding。如果有需要可以关注点赞一波。 实现的功能 插入结点 删除结点 从头到尾遍历输出所有元素 获取某个结点的前驱和其后继结点 获取前驱和后继主要是为了测试双链表是否编写正确，因为双链表可以访问前驱，这是与单链表不同的地方。 结构体定义 typedef struct BiLinkNode { Elem
【数据结构】C语言实现双链表
weixin_44104992的博客
07-31 548
C语言实现双链表
双向链表c语言实现,C语言实现双向链表
weixin_42306054的博客
05-19 426
这个小代码是我凭自己对指针和链表的理解和认识，自己实现的，没有参考其他人的代码，如果有相同的地方，那真的只是巧合，代码我在ubuntu 15.04下测试通过，可能存在很多错误和漏洞．doublelist.c/*************************************************************************> File Name: doublel...
C语言实现双向链表（双向带头循环）
2301_76269963的博客
03-21 1119
C语言实现双链表(双向带头循环)
Linux List.h深度解析：双向链表与数据结构实现
在Linux内核源码中，List.h文件是双向循环链表操作的核心部分，它位于`include/linux`目录下，用于构建复杂的数据结构，如队列和堆栈。双向循环链表相较于单链表，每个节点包含前后两个指针，提供了更灵活的插入和...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值