双向链表的定义及相关功能实现

原创 已于 2023-08-02 19:37:18 修改 · 189 阅读 · 1 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#链表 #数据结构

于 2023-08-01 20:30:14 首次发布
本文详细介绍了双向链表的概念，包括其逻辑结构和接口实现，如定义双向链表的结构体、创建空链表、插入节点以及处理头尾指针。展示了如何在指定位置插入数据，以及删除和查找操作的方法。

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

  1. 单向链表
    1. 有头
    2. 无头
  1. 单向循环链表
  2. 链式栈（无头单向链表）
  3. 链式队列（有头单向链表）

以上链表均只能从头往后找。即结点只有数据域和一个指向后继结点的指针域next。

双向链表即可以从前往后或者从后往前找，这就意味着链表的结点就不能只有一个指针域next了，还需要一个指向前期结点的指针域prior。

1.概念

  1. 逻辑结构：线性结构
  2. 存储结构：链式存储

2. 接口实现

2.1. 定义操作双向链表的结构体

双向链表结点结构体

typedef int DLLNDataType;

typedef struct DoubleLinkListNode
{
    DLLNDataType data;
    struct DoubleLinkListNode *next;
    struct DoubleLinkListNode *prior;
}LLN, *LL;

想要遍历该双向链表的话，除了拿到头指针后通过next从前往后遍历，还可以拿到尾指针通过prior从后往前遍历。

这样就意味着操作双向链表又需要两个指针，一个head头指针，一个tail尾指针，类比链式队列，将头尾指针放到一个操作双向链表的结构体里面去。

操作双向链表的结构体

typedef struct DoubleLinkList
{
    LL head;	// 头指针
    LL tail;	// 尾指针
    int len;    // 记录链表长度
} DLL;

假如链表有一百个结点那么长，我想删除98位结点，如果结构体中有链表的长度，可以更加方便的使用尾指针进行操作。

2.2. 创建空的双向链表

2.3. 插入

插入位置结点与其前驱以及新结点三者之间建立联系示意图：

向双向链表指定位置插入数据

// 3. 向双向链表指定位置插入数据
int DLLInsert(DLL *PD, int post, DLLNDataType data)
{
    // 3.1 容错判断 [0, PD->len]
    if (post < 0 || post > PD->len)
    {
        printf("DLLInsert failed, post not at [0, PD->len].\n");
        return -1;
    }

    // 3.2 创建新节点保存插入数据
    LL PNew = (LL)malloc(sizeof(LLN));
    if (NULL == PNew)
    {
        printf("DLLInsert failed, PNew malloc err.\n");
        return -1;
    }
    PNew->data = data;
    PNew->next = PNew->prior = NULL;

    // 3.3 判断插入位置（三种情况）
    // 3.3.1 尾插(尾结点和新结点互相指)
    if (post == PD->len)
    {
        // 互相指
        PNew->prior = PD->tail;
        PD->tail->next = PNew;
        // 尾指针tail后移
        PD->tail = PNew;
        // 长度++
        PD->len++;
    }
    // 3.3.2 中间插
    else
    {
        // 定义伪指针，代替头指针PD->head或尾指针PD->tail去移动
        LL PTemp = NULL;
        // 中间插前半段，PTemp为伪头指针，代替头指针移动。
        if (post < PD->len / 2)
        {
            // PTemp代替头指针移动
            PTemp = PD->head;
            // 移动伪头指针
            for (int i = 0; i <= post; i++)
                PTemp = PTemp->next;
        }
        // 中间插后半段，PTemp为伪尾指针，代替尾指针移动。
        else
        {
            // PTemp代替尾指针移动
            PTemp = PD->tail;
            // 移动伪尾指针
            for (int i = PD->len-1; i > post; i--)
                PTemp = PTemp->prior;
        }
        // 进行插入动作，先前再后
        // 前
        PNew->prior = PTemp->prior;
        PTemp->prior->next = PNew;
        // 后
        PNew->next = PTemp;
        PTemp->prior = PNew;

        // 插入完成后长度+1
        PD->len++;
    }
    return 0;
}

DoubleLinkList.h文件

双向链表功能函数

插入函数int DLLInsert(DLL *PD, int post, DLLNDataType data);
打印函数void DLLPrint(DLL PD);
删除函数(按位置)int DLLDeletePost(DLL *PD, int post);
查找内容函数(返回下标)int DLLFind(DLL PD, DLLNDataType data);
修改内容函数int DLLModify(DLL *PD , int post , DLLNDataType data);
删除函数(按内容)void DLLDeleteData(DLL *PD, DLLNDataType data);
#ifndef _DOUBLELINKLIST_H_
#define _DOUBLELINKLIST_H_

#include<stdio.h>
#include<stdlib.h>
typedef int DLLNDataType;

typedef struct DoubleLinkListNode
{
    DLLNDataType data;
    struct DoubleLinkListNode *next;
    struct DoubleLinkListNode *prior;
}LLN, *LL;

typedef struct DoubleLinkList
{
    LL head;
    LL tail;
    int len;
}DLL;

DLL *DLLInit();
int DLLInsert(DLL *PD, int post, DLLNDataType data);
void DLLPrint(DLL PD);
int DLLDeletePost(DLL *PD, int post);
int DLLFind(DLL PD, DLLNDataType data);
int DLLModify(DLL *PD , int post , DLLNDataType data);
void DLLDeleteData(DLL *PD, DLLNDataType data);
#endif

DoubleLinkList.c文件

#include "DoubleLinkList.h"

DLL *DLLInit()
{
    DLL *PD = (DLL *)malloc(sizeof(DLL));
    if (NULL == PD)
    {
        printf("DLLInit failed, PD malloc err.\n");
        return NULL;
    }
    PD->head = PD->tail = (LL)malloc(sizeof(LLN));
    if (NULL == PD->head || NULL == PD->tail)
    {
        printf("DLLInit failed, PD->head or PD->tail malloc err.\n");
        return NULL;
    }
    PD->head->next = PD->head->prior = NULL;
    PD->len = 0;
    return PD;
}

int DLLInsert(DLL *PD, int post, DLLNDataType data)
{
    if (post < 0 || post > PD->len)
    {
        printf("DLLInsert failed, post illegal.\n");
        return -1;
    }
    LL PNew = (LL)malloc(sizeof(LLN));
    if (NULL == PNew)
    {
        printf("DLLInsert failed, PNew malloc err.\n");
        return -1;
    }
    PNew->data = data;
    PNew->next = PNew->prior = NULL;
    if (post == PD->len) //尾插
    {
        PD->tail->next = PNew;
        PNew->prior = PD->tail;
        PD->tail = PNew;
        PD->len++;
    }
    else //中间插入
    {
        LL PTemp = NULL;
        if (post < PD->len / 2) //len前半段插入
        {
            PTemp = PD->head;
            for (int i = 0; i <= post; i++)
                PTemp = PTemp->next;
        }
        else
        {
            PTemp = PD->tail;
            for (int i = PD->len - 1; i > post; i--) //i = 0 ; i<len-post-1;i++;
                PTemp = PTemp->prior;
        }
        PTemp->prior->next = PNew;
        PNew->prior = PTemp->prior;
        PTemp->prior = PNew;
        PNew->next = PTemp;
        PD->len++;
    }
    return 0;
}

void DLLPrint(DLL PD)
{
    if (PD.head == PD.tail)
    {
        printf("DLLPrint failed, DLL is empty.\n");
        return;
    }
    printf("DoubleLinkList data is ");
    while (PD.head != PD.tail)
    {
        PD.head = PD.head->next;
        printf("%d ", PD.head->data);
    }
    putchar(10);
}

int DLLDeletePost(DLL *PD, int post)
{
    if (post < 0 || post >= PD->len)
    {
        printf("DLLDeletePost failed, post illegal.\n");
        return -1;
    }
    if (post == PD->len - 1) //尾删
    {
        PD->tail = PD->tail->prior;
        free(PD->tail->next);
        PD->tail->next = NULL;
    }
    else
    {
        LL PTemp = NULL;
        if (post < PD->len / 2) //len前半段删除
        {
            PTemp = PD->head;
            for (int i = 0; i <= post; i++)
                PTemp = PTemp->next;
        }
        else
        {
            PTemp = PD->tail;
            for (int i = 0; i < PD->len - post - 1; i++)
                PTemp = PTemp->prior;
        }
        PTemp->prior->next = PTemp->next;
        PTemp->next->prior = PTemp->prior;
        free(PTemp);
        PTemp = NULL;
        PD->len--;
    }
    return 0;
}

int DLLFind(DLL PD, DLLNDataType data)
{
    if (PD.head == PD.tail)
    {
        printf("DLLFind failed, DLL is empty.\n");
        return -1;
    }
    int post = 0;
    while (PD.head != PD.tail)
    {
        PD.head = PD.head->next;
        if (data == PD.head->data)
        {
            printf("data %d's post is %d\n", data, post);
        }
        post++;
    }
    return -1;
}

int DLLModify(DLL *PD, int post, DLLNDataType data)
{
    if (post < 0 || post >= PD->len)
    {
        printf("DLLDeletePost failed, post illegal.\n");
        return -1;
    }
    LL PTemp = NULL;
    if (post < PD->len / 2) //len前半段删除
    {
        PTemp = PD->head;
        for (int i = 0; i <= post; i++)
            PTemp = PTemp->next;
    }
    else
    {
        PTemp = PD->tail;
        for (int i = 0; i < PD->len - post - 1; i++)
            PTemp = PTemp->prior;
    }
    PTemp->data = data;
    return 0;
}

void DLLDeleteData(DLL *PD, DLLNDataType data)
{
    LL H = PD->head->next;
    while (H)
    {
        if (H->data == data)
        {
            if (H == PD->tail)
            {
                PD->tail = PD->tail->prior;
                free(PD->tail->next);
                PD->tail->next = NULL;
            }
            else
            {
                H->prior->next = H->next;
                H->next->prior = H->prior;
                LL PDel = H;
                H = H->next;
                free(PDel);
                PDel = NULL;
                PD->len--;
            }
        }
        else
            H = H->next;
        
    }
}

test.c文件

#include "DoubleLinkList.h"

int main(int argc, char const *argv[])
{
    DLL *PD = DLLInit();
    DLLInsert(PD, 0, 101);
    DLLInsert(PD, 0, 102);
    DLLInsert(PD, 0, 103);
    DLLInsert(PD, 0, 104);
    DLLInsert(PD, 0, 105);
    DLLInsert(PD, 0, 101);
    DLLInsert(PD, 0, 101);
    DLLInsert(PD, 0, 101);
    DLLInsert(PD, 0, 101);
    DLLInsert(PD, 0, 101);
    DLLPrint(*PD);
    DLLInsert(PD, 5, 102);
    DLLInsert(PD, 6, 103);
    DLLInsert(PD, 7, 104);
    DLLInsert(PD, 8, 105);
    DLLPrint(*PD);
    DLLDeletePost(PD, 0);
    DLLPrint(*PD);
    DLLFind(*PD, 102);
    DLLModify(PD, 3, 200);
    DLLPrint(*PD);
    DLLDeleteData(PD,101);
    DLLPrint(*PD);
    return 0;
}

运行结果

makefile文件

CC=gcc
OBJS=test.o DoubleLinkList.o
CFLAGS=-c -g -Wall
# CC=none-linux-gnueabi-gcc
test:$(OBJS)
	$(CC) -o test $(OBJS)
%.o:%.c
	$(CC) $(CFLAGS) $< -o $@
.PHONY:clean
clean:
	$(RM) *.o test

L.Messi
关注
双向链表的定义及基本操作
IT80hcbz的博客
03-31 564
《匠人的算法课II》为数据结构和算法系列课程的进阶课程。本讲为第一讲，大家详细介绍双向链表的定义以及基本操作。
java双向链表解析实现双向链表的创建含代码
Freedom的博客
11-11 1573
想要删除任意节点可以直接通过访问下一个节点使其prev获取想要删除的上一个节点，然后将想要删除的上一个节点.next获取到被删除对象下一个节点的指向这里我们可以模拟实现MyListCode类中的一些方法，入头插法、尾叉法、任意位置插入节点、指定元素删除含有该元素的第一个节点、指定元素删除含有该元素的所有节点等…
链式存储结构之双向链表
qq_43411563的博客
04-17 1043
我们在单链表中，有了next指针这就使得我们查找下一个元素的时间复杂度为O(1),但是如果查找上一个结点的最坏的时间复杂度就得是O(n)，因为我们每次都得从头遍历。为了解决这一问题，我们就得了解双向链表的相关特性。本篇博客我们就来说一下双向链表的有关知识，以及双向链表的相关实现。 一、双向链表的定义 双向链表是在单链表的每个结点中在设置一个指向其前驱结点的指针。所以双向链表中就会有两个指针域，一个...
链式存储-双向链表
z1360408752的博客
05-21 376
双向链表的定义 //双向链表的定义 typedef struct DualNode { ElemType Data; //数据域 struct DualNode* prior; //前驱结点 struct DualNode* next; //后继结点 }DualNode,*DuLinkList; 双向链表结点的插入 s -> prior = p; //把p赋值给s的前驱，如图① s -> next = p+1; //把p->next赋值给s的后继，如图中的② p ->
双向链表详解
qq_44729609的博客
05-27 408
双向链表（Doubly Linked List）是一种链式数据结构，每个节点包含三个部分：数据域、指向前驱节点的指针（prev）、指向后继节点的指针（next）。与单向链表相比，双向链表可以方便地进行前向和后向遍历，插入和删除操作也更加灵活高效。// 数据类型定义​// 双向链表节点结构体// 数据域// 指向前驱节点// 指向后继节点} LTNode;双向链表是链表家族中非常重要的一员，适合需要频繁在两端或中间插入、删除元素的场景。
链式存储结构-双向链表
测试
06-28 293
目录 链式存储结构-双向链表 链式存储结构-双向链表 //duolist.c #include <stdlib.h> #include <stdio.h> //wuy@farsight.cn // //类型 typedef struct nod...
链式存储结构--双向循环链表的实现（JAVA）
Thano_xu的博客
07-08 613
用Java实现双向链表（简单易懂）
2、链式存储的双向循环链表
十七阿哥的博客
08-05 566
双向链表 双向链表也叫双向表，是链表的一种，它由多个结点组成，每个结点都由一个数据域和两个指针域组成，数据域用 来存储数据，其中一个指针域用来指向其后继结点，另一个指针域用来指向前驱结点。链表的头结点的数据域不存 储数据，指向前驱结点的指针域值为null，指向后继结点的指针域指向第一个真正存储数据的结点。 1、带头结点的双向循环链表 每个结构体都知道自己的前驱和后继 空表： [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-mVTQ9JFJ-1628123529840)(D:
双向链表.cpp 双向链表类定义及测试代码 c++
12-02
双向链表类定义及测试文件 对应于数据机构与算法分析（c++版）第三版或第二版 Clifford A.Shaffer 重庆大学使用教材
C++语言实现完整功能双向链表代码
最新发布
06-26
通过本资源提供的完整功能双向链表代码，学习者不仅能够学习到双向链表的设计与实现，还能够通过实践加深对C++编程的理解。通过不断的学习和实践，最终能够达到提升编程能力和解决实际问题能力的目的。
C++ 实现双向链表的实例
08-30
本文将详细介绍 C++ 实现双向链表的实例的相关知识点，包括双向链表的概念、实现方法、代码分析等。 双向链表的概念 双向链表是一种特殊的链表结构，它允许在链表中插入、删除节点，并且可以从头到尾、从尾到头...
[数据结构]双链表的链式存储-双链表，链式栈，链式队列
qq_61109509的博客
03-22 3227
文章目录双链表输出双链表中各个结点的值查找双链表中第i个结点双链表结点的插入在最前面插入在双链表中某个位置插入x的结点在q所指结点的后面插入值为x的新结点在q所指结点(最后一个结点)的后面插入值为x的新结点双链表结点的删除双链表中只有唯一结点被删除的是双链表中第一个结点被删除的q是双链表中的最后一个结点被删除的结点在中间的某一个位置链式栈建立一个空的链式栈判断链式栈是否为空输出链式栈中个结点的值链式栈的插入链式栈的删除操作(出栈)链式队列建立一个空的链式队列取得链式队列的队首结点值 双链表 在链表中，每个结
【数据结构】双向链表
热门推荐
m0_73648729的博客
06-28 1万+
和单向链表一样，双向链表每个节点都是由结构体组成的数据类型，但是双向链表结构体中增加了一个指向前一个节点的指针。//方便修改数据类型//指向下一个节点的指针//指向前一个节点的指针//存储的数据}LTNode;我们今天要将的是带哨兵卫头节点的双向循环链表，它的头节点不存储有效数据，头节点中的prev指针指向最后一个节点。
数据结构-链表结构-双向链表
陆卿之的博客
08-01 4216
双向链表
数据结构 —— 双向链表（超详细图解 & 接口函数实现）
十里坡小白的博客
08-08 7244
数据结构是计算机存储、组织数据的方式。数据结构是指相互之间存在一种或多种特定关系的数据元素的集合。博主将会用代码结合大量图解，对数据结构进行深度剖析。
数据结构：双向链表
2401_86551514的博客
08-03 1539
这里的“带头”跟“头节点”是两个概念，带头链表里的头节点，实际为“哨兵位”，哨兵位节点不存储任何有效元素，只是站在这里“放哨 的” ，存在的意义： 遍历循环链表避免死循环。虽然有这么多的链表的结构，但是我们实际中最常用还是两种结构：单链表和双向带头循环链表，上一篇我们已经讲了单链表，今天就来了解一下双向链表并将其实现。顺序表和链表我们都学了，两者各有各的优缺点，根据需求的不通，运用在不同的场景。本篇的内容就到这里了，希望对各位有帮助，如果有错误欢迎指出。还是老样子，在头文件里写出我们需要功能的函数名。
数据结构之链表详解(2)——双向链表
weixin_69283129的博客
08-29 9641
C语言版万字详解：数据结构之链表详解(2)——双向链表的结构和功能实现
【数据结构】--双向链表
m0_74044018的博客
04-15 1056
1、主要讲述了双向循环链表的实现细节 2、再述了顺序表和链表的优缺点
数据结构——双向链表（双向连接的图解、双向链表的创建、操作双向链表）
qq_52301431的博客
08-23 4382
举个例子: 假设一个文本编辑用链表来存储文本. 每一行用一个String对象存储在链表的一个节点中. 当编辑器用户向下移动光标时, 链表直接操作到下一个节点即可. 但是当用于将光标向上移动呢?- 我们可以轻松的到达下一个节点, 但是回到前一个节点是很难的. 但是, 在实际开发中, 经常会遇到需要回到上一个节点的情况。- 也就是链表相连的过程是单向的. 实现的原理是上一个链表中有一个指向下一个的引用.- 一个节点既有向前连接的引用, 也有一个向后连接的引用.- 既可以从头遍历到尾, 又可以从尾遍历到头。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值