第十一课，双向链表

最新推荐文章于 2024-06-25 23:03:08 发布
原创 最新推荐文章于 2024-06-25 23:03:08 发布 · 401 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#双向链表

专题三：渐入佳境。包括以下章节：

  1. 无招胜有招-静态链表
  2. 气宗门道-循环链表
  3. 剑宗门道-双向链表
  4. 课后练习

单链表的局限

  1. 单链表的结点都只有一个指向下一个结点的指针

  2. 单链表的数据元素无法直接访问其前驱元素

    • 逆序访问单链表中的元素是极其耗时的操作！！！
len = LinkList_Length(list);

for(i=len-1;len>=0;i--)
{
    LinkListNode* p= LinkList_Get(list, i);

    //访问数据元素p中的数据
    //... 
}

单链表的改进

双向链表的定义

  • 在单链表的结点中增加一个指向其前驱的pre指针

这里写图片描述

循环链表的操作

双向链表拥有单链表的所有操作

  • 创建链表
  • 销毁链表
  • 获取链表长度
  • 清空链表
  • 获取第pos个元素操作
  • 插入元素到位置pos
  • 删除位置pos处的元素

双向链表的插入操作

这里写图片描述
双向链表的删除操作

这里写图片描述

双向链表的新操作

  • 获取当前游标指向的数据元素
  • 将游标重置指向链表中的第一个数据元素
  • 将游标移动指向到链表中的下一个数据元素
  • 将游标移动指向到链表中的上一个数据元素
  • 直接指定删除链表中的某个数据元素

小结

  1. 双向链表在单链表的基础上增加了指向前驱的指针
  2. 功能上双向链表可以完全取代单链表的使用
  3. 循环链表的Next，Pre和Current操作可以高效的遍历链表中的所有元素

将单链表改写成双向链表

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

        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) // 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;
        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"
/* 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;
}
java双向链表解析实现双向链表的创建含代码
Freedom的博客
11-11 1574
想要删除任意节点可以直接通过访问下一个节点使其prev获取想要删除的上一个节点，然后将想要删除的上一个节点.next获取到被删除对象下一个节点的指向这里我们可以模拟实现MyListCode类中的一些方法，入头插法、尾叉法、任意位置插入节点、指定元素删除含有该元素的第一个节点、指定元素删除含有该元素的所有节点等…
数据结构之双向链表详解
小源_ 的博客
12-20 4069
本文着重讲解了LinkedList(无头双向单链表)的实现和LinkedList的使用。内附代码和图文分析，看完就会！
数据结构课程设计（双向链表）
06-29
双向链表（数据结构课程设计），有做课程设计的很有用啊
线性表之双向链表
_ACME_的博客
01-21 971
基本思想：在单链表的基础上加一个前驱指针域，存放前一个节点的地址。所以现在节点结构一共有三个字段，数据域，两个指针域（前驱和后继）。优点：拥有单链表的所有优点（动态增长），也拥有循环链表的优点（能够在任何位置访问到所有节点），增加尾指针后，头添加和尾添加的时间复杂度都变为0(1)，逆转表不再需要牺牲空间换时间，时间复杂度只有0(n/2)，打印表的时候，可以正着打印，还可以逆着打印。缺点：就是代码上的
线性表——双向链表
Alyson_jm的博客
09-22 766
双向链表简介 双向链表是一种特殊的链表。 在单向链表中我们要查找下一个结点非常的方便，但是要查找上一个节点就困难了，双向链表克服了单链表的单向性这个缺点， 单链表和双向链表的区别 单链表：只能向一个方向遍历 双向链表：向两边都可以遍历。 双向链表的实现 为了找到节点和前驱，我们给节点增加一个指向其前驱的指针，如下图所示 既然单链表可以循环，那么双向链表也就可以循环，如下图所示即...
线性表---双向链表
m0_58342797的博客
01-09 491
双向链表 单链表指针域存放下一个结点的地址，双向链表有两个指针域，一个指针域存放前一个结点的地址，一个指针域存放下一个结点的地址 不带有头结点的双向链表的操作 打印元素 正向打印 public void printFront(){ LinkNode p=head; while(p!=null){ System.out.print(p.val+" "); p=p.next; }
C语言-双向链表的详解和实现
最新发布
qq_42037383的博客
06-25 531
/ 双向链表节点结构int data;// 节点数据域// 指向前一个节点的指针// 指向后一个节点的指针} Node;// 双向链表结构体定义Node* head;// 头结点指针，指向链表的头部int size;// 链表中节点的数量双向链表通过每个节点存储前驱和后继节点的指针，支持从任意位置直接访问前后节点，使得插入、删除等操作在某些场景下比单链表更加高效。
双向链表C实现
02-04
产品级代码，安全可靠，包含如下功能： 1.创建链表 2.销毁链表 3.获取链表长度 4.清空链表 5.获取第pos个元素操作 ...11.将游标移动指向到链表中的上一个数据元素 12.直接指定删除链表中的某个数据元素
【C++ STL序列容器】list 双向链表
普罗米修斯的博客
04-22 956
普通数组，则 begin() 函数返回的是指向数组第一个元素的指针，同样 end() 返回指向数组中最后一个元素之后一个位置的指针。容器包含的 begin() 和 end() 成员函数的功能完全相同。必须保证新旧容器存储的元素类型一致。
线性表(双向链表(动图解析))
weixin_42567027的博客
07-02 749
双向链表 双向链表或双面链表 每个节点有两个链接：一个指向前一个节点，当此节点为第一个节点时，指向空值；而另一个指向下一个节点，当此节点为最后一个节点时，指向空值。 双向链表操作 判断链表是否为空、计算链表长度、遍历整个链表、查找指定元素的操作与单向链表相同 在头部添加元素 // An highlighted block """头部添加元素""" def add(self, item): node = DoubleLinkList(item) node.next
Java数据结构-线性表之双向链表
十六子
07-19 820
双向链表的定义：在单链表的基础上，给每个节点增加一个指针域，用来指向该节点的前驱节点，这样形成的链表称之为双向链表。 利用空间换时间。整个双向链表的形式如图所示：下面就摘了《大话数据结构》的插入操作演示： 需要注意的是保证链不要断掉，上述图中第3和第4步的顺序不要颠倒。 继续删除操作的演示： 双向链表也有循环链表，叫双向循环链表，介绍如下：
线性表的双向链表实现
全村最靓的仔
08-21 336
在我上一篇博客里面给出了线性表的单向链表实现，这一篇将给出线性表的双向链表的实现，在这之前，我们先来比较一下线性表的顺序结构和非顺序结构的优缺点，以及非顺序结构中单向链表和双向链表的优缺点。 ...
数据结构3_线性表_双向链表
毛钱儿的博客
04-09 341
数据结构3_线性表_3 总览： 线性表： 线性表是具有相同数据类型的n(n>=0)个数据元素的有序序列，其中n为表长，当n=0时线性表是一个空表。若用L命名线性表，其一般表示为： L=(a1,a2,a3,a4,∗∗∗,an) L = (a1,a2,a3,a4,***,an) L=(a1,a2,a3,a4,∗∗∗,an) a1为表头元素，an为表尾元素，除了an其他元素都有唯一的直接后继，除...
数据结构-线性表-4双向链表
weixin_49895102的博客
03-21 1357
#include<stdio.h> #include<stdlib.h> //双向链表-prior+data+next #define ElemType char #define ERROR 0 #define OK 1 typedef struct DNode { ElemType data; DNode *prior, *next; }DNode, *DoubleList; //双向链表的前插操作 int DlinkIns(DoubleList L, int i, E.
线性结构——双向链表
C学习
11-11 1299
一、概念 双向链表概念 ( double linked List) 是在单链表的每个结点中，再设置一个指向其前驱结点的指针域。所以在双向链表中的结点都有两个指针域， 一个指向直接后继，另一个指向直接前驱。 二、双向不循环链表 2.1 定义数据类型 typedef void * datatype; typedef struct list_s { struct list_s *prev; //指向直接前驱 datatype data; //数据域 struct list_s *n
C_双向链表
PepDokHa的博客
01-19 638
C语言—数据结构 实现带头双向循环链表
线性表 之 双链表
weixin_46540768的博客
09-02 744
目录 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..
线性表的链式表示——双链表
一入大数据深似海?别怕!“数据极客圈”就是你的救生圈，走对圈子跟对人，趣析数据、畅聊趋势，快进圈子!
02-22 527
定义 双向链表也叫双链表，是链表的一种，它的每个数据结点中都有两个指针，分别指向直接后继和直接前驱。所以，从双向链表中的任意一个结点开始，都可以很方便地访问它的前驱结点和后继结点。一般我们都构造双向循环链表（解决了单链表只能从头结点依次访问顺序向后遍历的问题） 双链表中结点的类型表述如下： typedef struct DNode{ //定义双链表结点类型 EleType data; ...
数据结构课程设计_双向循环链表
ol__lo的专栏
07-30 1310
package chCircleTwoLinkedList; import java.util.Scanner; public class CircleTwoLinkedList{ private int theSize=0; private Node beginMarker; private Node endMarker; static Scanner cin=new Scanner
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值