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

最新推荐文章于 2022-07-15 10:09:28 发布
最新推荐文章于 2022-07-15 10:09:28 发布
阅读量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 算法精介----链表->双向链表
TTc 's share
02-02 558
双向链表 双向链表,如同名字所暗示的那样，链表元素之间由2个指针链接，双向链表中的每一个元素都有3部分组成：除了数据成员和指针next外，新增加了一个指针prev，指向其前驱元素的指针。下图清晰绘出双向链表的结构： // // DList.c // Algorithms&Data_structures // // Created by TTc on
数据结构 链表 LinkList
08-02
数据结构 链表 LinkList，为大家提供一些参考
04、双向循环链表DLinkList
大王怕我去巡山
12-13 1118
双向循环链表初始化 往里面插入元素 测试插入： 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...
python——数据结构之双向链表
Cherry的博客
04-30 129
class Node(object): """双向链表节点""" def __init__(self, item): self.item = item self.next = None self.prev = None class DLinkList(object): """双向链表""" def __in...
SlinkList（不带头节点的单链表）20171003
学无止境，Fighting！
10-03 473
#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
DLinkList
gaozigeng的博客
07-15 148
双链表 静态链表
dLinkList_双链表_
10-04
双链表的基本形式，包括头文件和主函数，实现了线性表的基本功能
数据结构答案
03-19
（3）链式存储结构（双链表） typedef struct node {ElemType data; struct node *prior,*next； }dlinklist; （4）静态链表 typedef struct {ElemType data; int next; }node; node sa[MAXSIZE];
数据结构实践
01-15
双循环链表 DLinkList 静态链表 SlinkList 应用 集合并 MerGroup 多项式求和 Poly 3 栈 顺序栈 SqStack 链栈 LinkStack 栈应用 数制转换 Conversion 表达式计算 Expresion 4 队列 循环队列 CirQueue 链队 ...
单链表、双向链表实现
08-25
本程序实现了单链表和双向链表的一些基本操作，包括建表，插入，删除等，对学习数据结构的人会有帮助！！！
数据结构学习笔记之Linklist
nerd_coder
06-11 880
Data Structrue1. LinkListLinkListLinklist形式如图Linklist 定义：typedef struct Node * PtrToNode;// typedef PtrToNode List;//表示链表，指向链表的头节点 typedef PtrToNode Position; struct Node｛ ElementType Element； Po
用Python实现数据结构中的双向链表
蜉蝣的博客
04-05 226
双向链表 一种更复杂的链表是“双向链表”或“双面链表”。每个节点有两个链接：一个指向前一个节点，当此节点为第一个节点时，指向空值；而另一个指向下一个节点，当此节点为最后一个节点时，指向空值。 操作 is_empty() 链表是否为空 length() 链表长度 travel() 遍历链表 add(item) 链表头部添加 append(item) 链表尾部添加 insert(p...
数据结构之双向链表----Python
程序员晓老九
07-16 145
双向链表 双向链表是指节点有三部分，数据、前向指针和后向指针。简单的图示可以参考看图轻松理解数据结构与算法系列(双向链表) 作者：程序员老九 掘金：https://juejin.im/post/5d1365c7e51d4510a73280f6 来源：请关注我的掘金博客 #定义一个节点类 class Node: def __init__(self,dataval): self.d...
python 数据结构与算法 双向链表
ruguowoshiyu的博客
09-28 274
利用python实现了双向链表，方法如下 1 is_empty() 判断链表是否为空 2 clear() 清空链表 3 len() 链表的长度 4 iteration() 遍历链表返回一个链表内容的list 5 leftappend(item) 从头部插入一个 节点 6 append(item) 从尾部追加一个节点 7 exist(item) 判断item是否在链表中 8 inse...
05、约瑟夫环-DLinkList的使用
大王怕我去巡山
12-19 579
有100个士兵，编号从1到100，围城一个圈，他们按照顺时针方向进行报数，报数为m的人出列，这样重复下去，直到所有的人都出列。 使用双向循环链表来解决约瑟夫换问题： 1、首先创建一个带头节点的双向循环链表。 2、注意头节点head不参与报数 void Josephus(DLinkList head, int n, int m, int k) /*在长度为n的双向循环链表中，从第k个人开始报数，数到m的人出列*/ { DListNode *p, *q; int i; p = head;
void LocateNode(DLinkList *&L, ElemType x)
Halfopen的专栏
10-06 2385
void LocateNode(DLinkList *&L, ElemType x) {    DLinkList *p = L->next, *t,*a,*b,*c;     while(p !=NULL)     {    //printf("1,%p,%d f:%d next,%p\n",p,p->data,p->freq,p->next);         //getchar();
数据结构 链表_双向链表的实现与分析
weixin_30746117的博客
11-19 88
双向链表的实现与分析 双向链表的组成 ：1、数据成员；2、指向下一个元素的next指针；3、指向前一个元素的prev指针。 数据结构DListElmt：代表双向链表中的单个元素（节点）。 数据结构DList：代表双向链表数据结构，该结构的成员同前面介绍的单链表相似。 示例1：双向链表抽象数据类型的头文件 /*dlist.h*/ #ifndef DLIST...
在结点类型为DLink Node 的双链表中将p所指结点（非尾结点）与其后继结点交换的操作
暴力扬
03-25 3006
在结点类型为DLink Node 的双链表中将p所指结点（非尾结点）与其后继结点交换的操作
线性表 之 双链表
weixin_46540768的博客
09-02 535
目录 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..
顺序表，单向链表双向链表的初始化，插入和删除操作函数怎么写
最新发布
05-12
顺序表的初始化： ```c #define MAXSIZE 100 // 假设顺序表的最大长度为100 typedef struct { int data[MAXSIZE]; // 用数组存储数据元素 int length; // 顺序表的当前长度 } SqList; void InitList(SqList *L) { for(int i = 0; i < MAXSIZE; i++) { L->data[i] = 0; // 将所有元素初始化为0 } L->length = 0; // 初始化长度为0 } ``` 顺序表的插入操作： ```c bool InsertList(SqList *L, int i, int e) { if(i < 1 || i > L->length + 1) { // 判断插入位置是否合法 return false; } if(L->length >= MAXSIZE) { // 判断顺序表是否已满 return false; } for(int j = L->length; j >= i; j--) { // 将第i个元素及之后的元素后移 L->data[j] = L->data[j-1]; } L->data[i-1] = e; // 插入新元素 L->length++; // 长度加1 return true; } ``` 顺序表的删除操作： ```c bool DeleteList(SqList *L, int i) { if(i < 1 || i > L->length) { // 判断删除位置是否合法 return false; } for(int j = i; j < L->length; j++) { // 将第i个元素之后的元素前移 L->data[j-1] = L->data[j]; } L->length--; // 长度减1 return true; } ``` 单向链表的初始化： ```c typedef struct Node { int data; struct Node *next; } Node, *LinkList; void InitList(LinkList *L) { *L = (LinkList) malloc(sizeof(Node)); // 分配头结点空间 (*L)->next = NULL; // 头结点指针域置为空 } ``` 单向链表的插入操作： ```c bool InsertList(LinkList *L, int i, int e) { if(i < 1) { // 判断插入位置是否合法 return false; } Node *p = *L; int j = 0; while(p && j < i-1) { // 查找第i-1个结点 p = p->next; j++; } if(!p || j > i-1) { // 插入位置不合法 return false; } Node *s = (Node*) malloc(sizeof(Node)); // 分配新结点空间 s->data = e; // 插入新结点 s->next = p->next; p->next = s; return true; } ``` 单向链表的删除操作： ```c bool DeleteList(LinkList *L, int i) { if(i < 1) { // 判断删除位置是否合法 return false; } Node *p = *L; int j = 0; while(p->next && j < i-1) { // 查找第i-1个结点 p = p->next; j++; } if(!(p->next) || j > i-1) { // 删除位置不合法 return false; } Node *q = p->next; // 删除结点 p->next = q->next; free(q); return true; } ``` 双向链表的初始化： ```c typedef struct DNode { int data; struct DNode *prior, *next; } DNode, *DLinkList; void InitList(DLinkList *L) { *L = (DLinkList) malloc(sizeof(DNode)); // 分配头结点空间 (*L)->prior = NULL; // 头结点的前驱指针置为空 (*L)->next = NULL; // 头结点的后继指针置为空 } ``` 双向链表的插入操作： ```c bool InsertList(DLinkList *L, int i, int e) { if(i < 1) { // 判断插入位置是否合法 return false; } DNode *p = *L; int j = 0; while(p && j < i-1) { // 查找第i-1个结点 p = p->next; j++; } if(!p || j > i-1) { // 插入位置不合法 return false; } DNode *s = (DNode*) malloc(sizeof(DNode)); // 分配新结点空间 s->data = e; // 插入新结点 s->prior = p; s->next = p->next; if(p->next) { // 如果p不是最后一个结点 p->next->prior = s; } p->next = s; return true; } ``` 双向链表的删除操作： ```c bool DeleteList(DLinkList *L, int i) { if(i < 1) { // 判断删除位置是否合法 return false; } DNode *p = *L; int j = 0; while(p->next && j < i-1) { // 查找第i-1个结点 p = p->next; j++; } if(!(p->next) || j > i-1) { // 删除位置不合法 return false; } DNode *q = p->next; // 删除结点 if(q->next) { // 如果q不是最后一个结点 q->next->prior = p; } p->next = q->next; free(q); return true; } ```

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值