数据结构封装之《DLinkList双向链表》

最新推荐文章于 2022-09-25 11:18:40 发布
最新推荐文章于 2022-09-25 11:18:40 发布
阅读量1.1k 收藏 2
点赞数 3
分类专栏： 数据与数据库 汇编（逆向） 文章标签： 数据结构 链表 数据 指针
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/BeiJiaan/article/details/77676866
版权

说明：

  1. 双向链表的每个数据节点中有2个指针，分别指向前一个节点和后一个节点；

  2. 该链表有一个链表头，header->next指向第一个数据节点，slider为游标，length记录当前节点的数量；

  3. 存储的数据需要一个结构体，格式如下：
    　struct Value
    　{
    　　　DLinkListNode header;//指针域
    　　　int（←这里可以任意类型） v;//数据域
    　};

  4. 具有高效的逆序访问的功能；

下面将给出该数据结构的代码，每个函数的结构分析 ，以及个别主要函数的汇编分析

代码：

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() 
{
    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)
{
    free(list);
}

//清空链表
void DLinkList_Clear(DLinkList* list) 
{
    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)
{
    TDLinkList* sList = (TDLinkList*)list;
    int ret = -1;

    if( sList != NULL )
    {
        ret = sList->length;
    }

    return ret;
}

//指定位置插入数据元素，并返回是否成功
int DLinkList_Insert(DLinkList* list, DLinkListNode* node, int pos) 
{ 
    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 = 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) 
{
    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) 
{
    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;

        current->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"

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;
}

函数结构分析：

1.DLinkList_Create

2.DLinkList_Destroy

3.DLinkList_Clear

4.DLinkList_Length

5.DLinkList_Insert

6.DLinkList_Get

7.DLinkList_Delete

8.DLinkList_Reset

9.DLinkList_Current

10.DLinkList_Next

11.DLinkList_Next

汇编分析：

1.DLinkList_Create

2.DLinkList_Insert

3.DLinkList_Delete

BeiJiaan
关注
  • 3
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C语言数据结构 双向链表的建立与基本操作
08-31
C语言数据结构 双向链表的建立与基本操作 C语言数据结构中，双向链表是一种常用的数据结构形式，它可以实现链表的前序和后序遍历，提高了链表的灵活性和可读性。本文将主要介绍双向链表的建立和基本操作，包括双向...
数据结构——线性表
ywx200203的博客
05-05 753
前置知识 1.数据结构三要素——逻辑结构、数据的运算、存储结构（物理结构） 2.存储结构不同，数据运算的实现方式不同 逻辑结构：一个个前赴后继的信息世是线性结构。逻辑结构有集合结构、线性结构、树结构、图结构或网状结构。与数据元素本身的形式、内容、相对位置、个数无关。 存储结构：有顺序存储结构和链式存储结构。链接存储的存储结构所占存储空间分两部分，一部分存放结点值，另一部分存放表示结点间关系的指针。 3.值得注意的代码问题！！！ （1）如何判空 （2）如何判断节点p石头是表头/表尾节点（向前/后
在结点类型为DLink Node 的双链表中将p所指结点（非尾结点）与其后继结点交换的操作
暴力扬
03-25 3014
在结点类型为DLink Node 的双链表中将p所指结点（非尾结点）与其后继结点交换的操作
SlinkList（不带头节点的单链表）20171003
学无止境，Fighting！
10-03 480
#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
双链表结点交换
m0_61156547的博客
09-25 823
在结点类型为DLinkNode的带头结点的双链表L中给出将p所指结点（非尾结点）与其后继结点交换的算法。
线性表 之 双链表
weixin_46540768的博客
09-02 541
目录 1.效果截图： 2.双链表结点类型DLinkNode声明 3.整体建立双链表 4.添加头文件 5.基本运算算法（9个） 6.主函数： 7.遇到的问题 在codeblocks 中建立C++ 控制台项目 将4,5,6,的代码都放进去,即可运行！ 1.效果截图： 2.双链表结点类型DLinkNode声明 typedef char ElemType; typedef struct DNode { ElemType data;//存放元素值 struct DNo..
C++ 实现双向链表的实例
08-30
双向链表是一种特殊的链表结构，它允许在链表中插入、删除节点，并且可以从头到尾、从尾到头遍历链表。双向链表的每个节点都包含一个指向前一个节点的指针（prior）和一个指向后一个节点的指针（next），这样可以...
04_双向链表_链表_declaredzfw_双向链表_
10-01
总之，双向链表是一种灵活且强大的数据结构，它提供了在链表中前后移动的能力，使得在实现某些特定算法或功能时更加方便。通过阅读和理解`dlinklist.c`和`main.c`的源码，你可以深入了解双向链表的工作原理，并将其...
双向链表代码
11-30
`DLinkList.h` 是头文件，它定义了双向链表相关的数据结构和函数原型，供其他源文件（如 `main.c`）使用。在该文件中，我们可以看到`struct Node`的定义，它包含数据域和两个指针域。同时，也会有前面提到的函数声明...
python双向链表原理与实现方法详解
09-18
Python中的双向链表是一种数据结构，它允许在链表的两个方向上进行遍历和操作。与单链表不同，每个节点不仅包含数据，还包含两个指针，一个指向前一个节点（prev），另一个指向后一个节点（next）。这种设计使得在...
数据结构教程（第5版）课后题参考答案第二章
10-16
数据结构教程（第5版）课后题参考答案，第二章线性表，清华大学出版社，李春bao主编
编写一个程序实现循环双链表的各种基本运算（假设顺序表的元数基本类型为Char）
张旺华的博客
07-01 4396
/* *Copyright (c) 2016, 烟台大学计算机学院 *All rights reserved. *文件名称：main.cpp *作者：张旺华 *完成日期： 2016 年 7 月 1 日 *版本号：v1.0 *问题描述：编写一个程序实现循环双链表的各种基本运算（假设顺序表的元数基本类型为Char） * */ #include #include #include
04、双向循环链表DLinkList
大王怕我去巡山
12-13 1120
双向循环链表初始化 往里面插入元素 测试插入： DLinkList.h #pragma once typedef int DataType; typedef struct DNode { DataType data; struct DNode* piror; struct DNode* next; }DListNode,*DLinkList; int InitList(DLinkList* head);/*初始化单链表*/ int ListEmpty(DLinkList...
实现双链表各种基本运算的算法
yyy_zxc的博客
11-04 1438
//---------------实现双链表各种基本运算的算法----------- #include <stdio.h> #include<malloc.h> #define ElemType int //声明结点类型 typedef struct DNode{ ElemType data; struct DNode *prior; //指向前驱结点 struct DNode *next; //指向后继结点 }NLinkNode; /...
数据结构：图的遍历--深度优先、广度优先
热门推荐
CCPP Blog
08-02 6万+
图的遍历是指从图中的某一顶点出发，按照一定的策略访问图中的每一个顶点。当然，每个顶点有且只能被访问一次。 在图的遍历中，深度优先和广度优先是最常使用的两种遍历方式。这两种遍历方式对无向图和有向图都是适用的，并且都是从指定的顶点开始遍历的。先看下两种遍历方式的遍历规则： 深度优先 深度优先遍历也叫深度优先搜索(Depth First Search)。它的遍历规则：不断地沿着顶点的深度方向遍历。顶点的深度方向是指它的邻接点方向。
链式存储的LinkList.h代码
lt159159的博客
06-21 2089
1. LinkList.h#ifndef _LINKLIST_H#define _LINKLIST_Htypedef void LinkList;typedef struct _tag_LinkListNode LinkListNode;struct _tag_LinkListNode { LinkListNode* next;};LinkList* LinkList_Creat();void L
LinkList集合详解
柒的博客
04-28 1万+
LinkList集合详解 1、LinkedList简介 LinkedList类是一个继承于AbstractSequentialList的双向循环链表，它是非同步的，也是非线程安全的。 LinkedList实现了List接口，能对它进行队列操作。 LinkedList实现了Deque接口，能当作双端队列操作 LinkedList实现了CloneClass接口，能进行克隆操作。 LinkedList实现了SerialiableClass接口，能进行序列化操作。 2、List数据结构 LinkedL
LinkedList浅析
GhostSugar
08-27 3万+
LinkedList简介 LinkedList 是一个继承于AbstractSequentialList的双向链表。它也可以被当作堆栈、队列或双端队列进行操作。 LinkedList 实现 List 接口，能对它进行队列操作。 LinkedList 实现 Deque 接口，即能将LinkedList当作双端队列使用。 LinkedList 实现了Cloneable接口，即覆盖了函数clon...
LinkList 单链表的实现
Spades_J 的博客
07-27 5413
LinkList.h#include "stdio.h" #include "math.h" #include "malloc.h" #include "stdlib.h"//typedef int DataType;//LinkNode是链表的结点类型，LinkList是指向链表的指针类型 //如果定义了 LinkList L;则定义了一个链表，L指向该链表的第一个结点 //不带头结点，链表为空，
顺序表，单向链表双向链表的初始化，插入和删除操作函数怎么写
最新发布
05-12
双向链表的插入操作： ```c bool InsertList(DLinkList *L, int i, int e) { if(i ) { // 判断插入位置是否合法 return false; } DNode *p = *L; int j = 0; while(p && j ) { // 查找第i-1个结点 p = p->...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值