数据结构与算法-双向链表知识详解

最新推荐文章于 2024-04-19 18:08:13 发布
最新推荐文章于 2024-04-19 18:08:13 发布
阅读量747 收藏 1
点赞数
分类专栏： # 算法与数据结构Java版 文章标签： 链表 指针 数据结构 java 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/shark_chili3007/article/details/107776512
版权

概述

鉴于党项链表添加、修改等操作的复杂度，我们可以使用双向链表提升链表的综合性能

在这里插入图片描述

双向链表的实现

添加元素

图解过程

常规插入

插入过程如下图所示，整个过程大致为：

  1. 新结点的prev指针指向原索引为1的结点的前驱节点
  2. 新节点的next指针指向原索引为1的结点
  3. 此时，新结点的前驱结点next指针指向新结点
  4. 此时，新结点的后继节点的prev指针指向新结点

注：这种操作衍生出一种特殊情况，即在表头插入，第三步的操作改为first指向新结点即可

在这里插入图片描述

插入到链表末尾

操作过程如下图所示，插入到链表尾巴只要操作四个指针即可，具体过程为：

  1. 新结点prev指向原先的last结点，next不指向任何结点，置为null
  2. 原last的next指针指向新的尾结点
  3. last指针指向新尾结点

注：这种操作衍生出一种特殊情况，即链表为空，操作只需将上述的第二步改为first指向新结点即可

在这里插入图片描述

代码

  @Override
    public void add(int index, E element) {
        rangeCheckForAdd(index);
        Node<E> newNode;
        if (index == size) {
            Node<E> oldLast = this.last;
            last = new Node<E>(last, element, null);
            if (oldLast == null) {
                first = last;
            } else {
                oldLast.next = last;

            }

        } else {
            Node<E> newNextNode = findNode(index);
            Node<E> newPrevNode = newNextNode.prev;
            newNode = new Node<E>(newPrevNode, element, newNextNode);
            newNextNode.prev = newNode;

            if (newPrevNode == null) {
                first = newNode;
            } else {
                newPrevNode.next = newNode;
            }
        }

        size++;
    }

修改元素

代码

 @Override
    public E set(int index, E element) {
        Node<E> node = findNode(index);
        E oldElement = node.element;
        node.element = element;


        return oldElement;
    }

删除元素

图解过程

如下所示，操作步骤大致为：

  1. 找到要删除的元素
  2. 待删元素的前驱结点next指针指向待删元素的后继结点
  3. 待删元素的后继结点指向待删元素的前驱结点

注： 这里的删除的结点若是first结点和last结点需特殊处理：

  1. 若删除的是first，则将第2步改为first指向first结点的前一个
  2. 若删除的是last，则将第3步改为last指向last结点的前一个

ps:看到下图操作，可能会有读者问为什么待删元素的prev和next不需要手动处理嘛？其实是不必的，java的gc root会回收那些没有被栈区(局部变量)指向的对象，这就是用java写数据结构比C语言方便的地方。

在这里插入图片描述

代码

 @Override
    public E remove(int index) {
        Node<E> delNode = findNode(index);
        Node<E> delPrevNode =delNode.prev;
        Node<E> delNextNode = delNode.next;

        if (delPrevNode == null) {
            first = delNextNode;
        } else {
            delPrevNode.next = delNextNode;
        }


        if (delNextNode == null) {
            last = delPrevNode;
        } else {
            delNextNode.prev = delPrevNode;
        }
        size--;
        return delNode.element;
    }

查找元素

代码

这里查找相比单向链表快很多，因为有了前后双指针，所以若要找的元素在前半部分，就用first去遍历。若要找后半部分，则用last指针往前遍历

public Node<E> findNode(int index) {
        rangeCheck(index);
        Node<E> node = null;
        if (index < size >> 1) {
            node = this.first;
            for (int i = 0; i < index; i++) {

                node = node.next;
            }

        } else {
            node = this.last;
            for (int i = size - 1; i > index; i--) {
                node = node.prev;
            }
        }

        return node;
    }

清空元素

代码


    @Override
    public void clear() {
        first = null;
        last = null;
        size = 0;
    }

完整代码

package com.study.doubleLinkListDemo;

import com.study.singlelinkDemo.AbstractList;
import com.study.singlelinkDemo.List;


/**
 * Created by Zsy on 2020/8/4.
 */
public class DoubleLinkList<E> extends AbstractList<E> {
    private Node<E> first;
    private Node<E> last;

    private static class Node<E> {
        E element;
        Node<E> prev;
        Node<E> next;

        public Node(Node<E> prev, E element, Node<E> next) {
            this.prev = prev;
            this.element = element;
            this.next = next;
        }
    }


    @Override
    public void clear() {
        first = null;
        last = null;
        size = 0;
    }

    @Override
    public int size() {
        return size;
    }

    public Node<E> findNode(int index) {
        rangeCheck(index);
        Node<E> node = null;
        if (index < size >> 1) {
            node = this.first;
            for (int i = 0; i < index; i++) {

                node = node.next;
            }

        } else {
            node = this.last;
            for (int i = size - 1; i > index; i--) {
                node = node.prev;
            }
        }

        return node;
    }


    @Override
    public E get(int index) {
        return findNode(index).element;
    }

    @Override
    public E set(int index, E element) {
        Node<E> node = findNode(index);
        E oldElement = node.element;
        node.element = element;


        return oldElement;
    }

    @Override
    public void add(int index, E element) {
        rangeCheckForAdd(index);
        Node<E> newNode;
        if (index == size) {
            Node<E> oldLast = this.last;
            last = new Node<E>(last, element, null);
            if (oldLast == null) {
                first = last;
            } else {
                oldLast.next = last;

            }

        } else {
            Node<E> newNextNode = findNode(index);
            Node<E> newPrevNode = newNextNode.prev;
            newNode = new Node<E>(newPrevNode, element, newNextNode);
            newNextNode.prev = newNode;

            if (newPrevNode == null) {
                first = newNode;
            } else {
                newPrevNode.next = newNode;
            }
        }

        size++;
    }

    @Override
    public E remove(int index) {
        Node<E> delNode = findNode(index);
        Node<E> delPrevNode =delNode.prev;
        Node<E> delNextNode = delNode.next;

        if (delPrevNode == null) {
            first = delNextNode;
        } else {
            delPrevNode.next = delNextNode;
        }


        if (delNextNode == null) {
            last = delPrevNode;
        } else {
            delNextNode.prev = delPrevNode;
        }
        size--;
        return delNode.element;
    }

    @Override
    public int indexOf(E element) {
        if (element == null) {
            Node<E> node = first;
            for (int i = 0; i < size; i++) {
                if (node.element == null) return i;

                node = node.next;
            }
        } else {
            Node<E> node = first;
            for (int i = 0; i < size; i++) {
                if (element.equals(node.element)) return i;

                node = node.next;
            }
        }
        return ELEMENT_NOT_FOUND;
    }

    @Override
    public String toString() {
        StringBuilder string = new StringBuilder();
        string.append("size=").append(size).append(", [");
        Node<E> node = first;
        for (int i = 0; i < size; i++) {
            if (i != 0) {
                string.append(", ");
            }

            string.append(node.element);

            node = node.next;
        }
        string.append("]");
        return string.toString();
    }
}

小结

与单向链表的比较

删除

单向链表的复杂度为：
总规模：1+2+3+4+…n=(n+1)*n/2=n/2+n^2/2
除n求平均复杂度=(n+1)/2=>1/2+n/2

双向链表的复杂度为：
总规模：(1+2+3+4+…n/2)*2=n/2+n^2/4
除n求平均复杂度=1/2+n/4

综上所述：
双向链表操作过程将近缩减一半

与动态数组的比较

动态数组：开辟、销毁内存空间相对较小，但可能出现内存空间浪费的情况

双向链表：开辟、销毁内存空间相对较多，但不会出现内存空间浪费的情况

使用场景分析

如果频繁在尾结点add、remove操作，动态数组和双向链表均可
如果频繁在头结点add、remove操作，双向链表合适
如果需要频繁查询指定位置的元素，动态数组合适

shark-chili
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
Python实现的数据结构与算法之链表详解
12-24
本文实例讲述了Python实现的数据结构与算法之链表。分享给大家供大家参考。具体分析如下： 一、概述 链表（linked list）是一组数据项的集合，其中每个数据项都是一个节点的一部分，每个节点还包含指向下一个节点的...
单链表和双向链表的区别与使用场景
mlyhzt的博客
10-20 2420
单向链表：只有一个指向下一个节点的指针。 优点：单向链表增加删除节点简单。遍历时候不会死循环； 缺点：只能从头到尾遍历。只能找到后继，无法找到前驱，也就是只能前进。 适用于节点的增加删除。   双向链表：有两个指针，一个指向前一个节点，一个后一个节点。 优点：可以找到前驱和后继，可进可退； 缺点：增加删除节点复杂，需要多分配一个指针存储空间。 适用于需要双向查找节点值的情况。 ...
双向循环链表(图文讲解)
deroy
02-25 2202
文章目录双向循环链表结构体初始化函数添加数据头插删除数据显示函数示例程序一(简易版本)：运行结果：示例程序二 双向循环链表 结构体 typedef struct node { int data; struct node* pre; //指向前驱 struct node* next; //指向后继 }NODE; 双链表是链表的一种，由节点组成，每个数据结点中都有两个指针，分别指向直接后继和直接前驱。 初始化函数 NODE * Init() { NODE* head = (NODE*)mall
数据结构与算法 — 双向链表
我会二进制
07-30 552
双向链表定义 双向链表也叫双链表，是链表的一种，它的每个数据结点中都有两个指针，分别指向直接后继和直接前驱。所以，从双向链表中的任意一个结点开始，都可以很方便地访问它的前驱结点和后继结点。 双向链表与单链表 单向链表优缺点： 1、优点：单向链表增加删除节点简单。遍历时候不会死循环； 2、缺点：只能从头到尾遍历。只能找到后继，无法找到前驱，也就是只能前进。 双向链表优缺点： 1、优点：可以找到前驱和后继，可进可退； 2、缺点：增加节点和删除节点复杂，多需要分配一个指针存储空间。 代码实现与思路 1.定义结点
双链表各种基本运算的算法
Hey3399的博客
05-04 4633
初始化双链表 //初始化线性表 void InitList(DLinkNode *&L) { //创建头结点 L=(DLinkNode *)malloc(sizeof(DLinkNode)); L->next=L->prior=NULL; } 头插法建立双链表 //采用头插法建立双链表 void CreateListF(DLinkNode *&L,ElemType a[],int n) { DLink...
数据结构及算法：双向链表
m0_55644719的博客
04-26 1009
文章目录一.双向链表的意义二.双向链表的使用1.头插法 一.双向链表的意义 单链表：单向链表，默认只能从链表的头部遍历到链表的尾部，实际中的应用很少见，太局限，只能从头遍历到尾部。 双向链表：对于该链表中的任意节点，即可通过该节点向后走，也可以通过该节点向前走。双向链表实际工程中应用非常广泛，是使用链表这个结构的首选。 二.双向链表的使用 1.头插法 ...
数据结构 双向链表的创建和读取详解及实例代码
12-26
数据结构 双向链表的创建和读取 双向链表是为了满足更加方便的查找前驱，而付出空间的代价的一个数据结构。双向链表的节点定义如下： typedef struct node { int x; struct node *prior,*next; }DLNode; 双向...
详解java数据结构与算法之双链表设计与实现
08-30
本篇文章主要介绍了详解java数据结构与算法之双链表设计与实现，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
C#数据结构之双向链表(DbLinkList)实例详解
12-31
本文实例讲述了C#数据结构之双向链表(DbLinkList)。分享给大家供大家参考，具体如下： 这是继上一篇《C#数据结构之单链表(LinkList)实例详解》的继续，对于双向链接，节点上除了Next属性外，还要有Prev属性用来指向...
python数据结构与算法详解与源码
08-20
数据结构与算法（Python） 一、引入概念 1-01算法引入 1-02 时间复杂度与大O表示法 1-03-最坏时间复杂度与计算规则 1-04-常见时间复杂度与大小关系 1-05-代码执行时间测量模块 1-06-Python列表类型不同操作的...
单双向链表算法
02-19
package 单双向链表; /** * 单向链表增删改查操作 * */ public class LinkTest { public static void main(String[] args) { Link l=new Link(); l.addNode("A"); l.addNode("B"); l.addNode("C"); l.addNode("D"); l.addNode("E"); l.printNode(); System.out.println("\n是否包含D:"+l.contains("D")); System.out.println("==========删除之前的内容=========="); l.printNode(); System.out.println("\n==========删除之后的内容=========="); l.deleteNode("A"); l.printNode(); } } class Link{//链表的完成类 class Node{//保存每个节点 private String data;//节点内容 private Node next;//下一个节点 public Node(String data){ this.data=data; } public void add(Node newNode) {//将节点加入到合适的位置 if(this.next==null){ this.next=newNode; }else{ this.next.add(newNode); } } public void print() {//输出节点的内容 System.out.print(this.data+"\t"); if(this.next!=null){ this.next.print();//递归调用输出 } } public boolean search(String data){//内部搜索的方法 if(data.equals(this.data)){ return true; }else{ if(this.next!=null){//向下继续判断 return this.next.search(data); }else{ return false; } } } public void delete(Node previous, String data) { if(data.equals(this.data)){//找到了匹配的节点 previous.next=this.next;//空出当前的节点 }else{ if(this.next!=null){ this.next.delete(this, data);//继续查找 } } } } private Node root;//链表中的根节点 public void addNode(String data){//增加节点 Node newNode=new Node(data); if(root==null){ root=newNode; }else{ root.add(newNode); } } public void printNode(){//链表的输出 if(root!=null){ root.print(); } } public boolean contains(String name){//判断元素是否存在 return this.root.search(name); } public void deleteNode(String data){//链表删除节点 if(this.contains(data)){ if(this.root.data.equals(data)){//如果是根节点 this.root=this.root.next;//修改根节点 }else{ this.root.next.delete(root,data);//把下一个节点的前节点和要删除的节点内容一起传入 } } } }
经典的双向链表排序算法。
04-16
经典的双向链表排序算法。涵盖创建，删除，排序，获取，增加等
C++经典算法 双向链表
12-13
C++经典算法 双向链表 采用了结构体，链表的知识。
数据结构之链表详解(2)——双向链表
weixin_69283129的博客
08-29 8945
C语言版万字详解：数据结构之链表详解(2)——双向链表的结构和功能实现
【BOOST C++容器专题03】【07】Boost.Intrusive
gongdiwudu的专栏
10-22 3030
Boost.Intrusive 是一个特别适合在高性能程序中使用的库。该库提供了创建侵入式容器的工具。这些容器替换了标准库中的已知容器。它们的缺点是它们不能像 std::list 或 std::set 那样容易使用。
双链表详解
weixin_63246064的博客
02-15 6036
目录 一.双链表的定义 二.要实现的功能 三.功能实现 0、创建结点 1、初始化 2、打印 3、尾插 4、尾删 5、头插 6、头删 7、任意插入 8、任意删除 9、查找 四.全部代码的实现 1、text.c 2、List.c 3、List.h 一.双链表的定义 由图这就是一个双链表，可以看出它是一个由尾和头双向指向的环，且每个结点之间都是双向指向的。 二.要实现的功能 双链表是一种数据结构，所谓数据结构就是用来储存数据的工具，功能大致就和基本储存数据的
数据结构与算法——双向链表
qq_45767014的博客
05-27 216
前言     为了面试，时隔一年不得不重新复习数据结构与算法，这次重新复习很有收获，以前在上课总有不清晰的知识，通过这次手写一遍和敲一遍代码，以前不清晰的知识都变得清晰了，果然学编程还是得多敲代码，多敲代码，多敲代码，也要多总结，多总结，多总结。 学习资源 视频 黑马程序员  数据结构与算法 双向链表     双向链表也叫双向表，是链表的一种，它由多个结点组成，每个结点都由一个数据域和两个指针域组成，数据域用来存储数据，其中一个指针域用来指向其后继结点，另一个指针域用来指向前驱结点。链表的头结点
算法和数据结构简介
m0_69266818的博客
04-19 349
介绍了数据结构和算法的大致分类，还有反转链表，链表相加，合并俩个有序链表，划分链表
【数据结构】串（String）
最新发布
2201_75475240的博客
04-19 921
本文章介绍数据结构中的串的基本知识，包括串的顺序存储结构和模式匹配（BP和KMP），且还包含一些课后习题（附有解析）。此外，含有关于串的全部具体实现代码
数据结构与算法-线性表
09-13
数据结构与算法-线性表是一种用于存储数据的数据结构，它可以按照一定的逻辑顺序来存储和访问数据。线性表的定义是一个有限个相同类型的数据元素的集合，每个数据元素都有一个唯一的前驱和后继。线性表可以用顺序...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

shark-chili

您的鼓励将是我创作的动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值