03--图解数据结构之双链表实现容器

最新推荐文章于 2024-10-03 16:51:18 发布
最新推荐文章于 2024-10-03 16:51:18 发布
阅读量59 收藏
点赞数
原文链接：http://www.cnblogs.com/toly-top/p/9781868.html
版权
零、前言
链表是一种数据结构，用来承载数据，每个表节点装载一个数据元素
双链表是每个节点出来数据元素外还分别持有前、后两个节点的引用
为了统一节点的操作，一般在真实链表的首尾各加一个虚拟节点，称为头节点和尾节点
一、链表的操作

下图是一个三个节点的双链表

9414344-e5b7ba3a7ccb3200.png
双链表.png 
/**
 * 作者：张风捷特烈
 * 时间：2018/9/18 0018:7:35
 * 邮箱：1981462002@qq.com
 * 说明：双链表
 */
public class DoubleLink<T> {
    /**
     * 虚拟头结点
     */
    private Node headNode;
    /**
     * 虚拟尾节点
     */
    private Node tailNode;
    /**
    * 链表长度(节点数)
    */
    private int size;

    /**
     * 节点类
     * @param <T>
     */
    private static class Node<T> {
        /**
         * 数据
         */
        public T data;
        /**
         * 前节点
         */
        public Node prev;
        /**
         * 后节点
         */
        public Node next;

        public Node(Node prev, Node next, T data) {
            this.data = data;
            this.prev = prev;
            this.next = next;
        }
    }
}
1.插入操作：addBefore()

假如在第二个元素处插入，会发生什么：
1---新建一个node,将前、后指向分别指向目标前节点和目标节点
2---目标前节点next指向新节点
3---目标节点prev指向新节点
3---链表长度+1

9414344-28ba687c6b8ff5df.png
双链表前插入.png 
/**
 * 根据目标节点插入新节点
 * @param target 目标节点
 * @param data 新节点数据
 */
private void addNodeBefore(Node<T> target, T data) {
    //新建一个node,将前、后指向分别指向目标前节点和目标节点
    Node<T> newNode = new Node<>(target.prev, target, data);
    //目标前节点next指向新节点
    target.prev.next = newNode;
    //目标节点prev指向新节点
    target.prev = newNode;
    //链表长度+1
    size++;
}
2.移除操作：removeNode()

假如在删除第二个元素，会发生什么：
1---目标前节点的next指向目标节点后节点
2---目标后节点的prev指向目标节点前节点

3---链表长度-1
4---返回删除的数据

9414344-9b335b6918a8955b.png
双链表移除节点.png 
/**
 * 移除目标节点
 *
 * @param target 目标节点
 * @return 目标节点数据
 */
private T removeNode(Node<T> target) {
    //目标前节点的next指向目标节点后节点
    target.prev.next = target.next;
    //目标后节点的prev指向目标节点前节点
    target.next.prev = target.prev;
    //链表长度-1
    size--;
    return target.data;
}
3.清空操作：clearNode()

思路和删除一样：首尾虚拟节点互指，中间的元素就被孤立了，从而从链表上全部删除
1---实例化头结点
2---实例化尾节点，并将prev指向头
3---头结点的next指向尾节点
4---链表长度置零

9414344-c46dce50ab3364fb.png
双链表清空.png 
/**
 * 清空所有节点
 */
private void clearNode() {
    //实例化头结点
    headNode = new Node<T>(null, null, null);
    //实例化尾节点，并将prev指向头
    tailNode = new Node<T>(headNode, null, null);
    headNode.next = tailNode;
    //链表长度置零
    size = 0;
}
4.获取操作：getNode

思路：链表查找只能一个一个挨着找，就像排队报数样。
为了尽量高效，判断一下索引在前半还是后半，来采取前报数，还是后报数。

 /**
  * 根据索引获取节点
  *
  * @param index 索引
  * @return 索引处节点
  */
 private Node<T> getNode(int index) {
     //声明目标节点
     Node<T> targetNode;
     //索引越界处理
     if (index < 0 || index > size - 1) {
         throw new IndexOutOfBoundsException();
     }
     //如果索引在前半,前序查找
     if (index < size / 2) {
         targetNode = headNode.next;
         for (int i = 0; i < index; i++) {
             targetNode = targetNode.next;
         }
     } else {  //如果索引在后半,反序查找
         targetNode = tailNode.prev;
         for (int i = size - 1; i < index; i++) {
             targetNode = targetNode.prev;
         }
     }
     return targetNode;
 }
二、利用链表实现对数据的操作

链表只是对节点的操作，只是一种结构，并非真正目的，在集合类中要让链表对外完全不可见,就像人的骨骼之于躯体
躯体的任何动作是骨骼以支撑,而骨骼并不可见，从外来看只是躯体的动作而已，数据结构就是这样的骨架，数据便是躯体。
我们需要的是按照这种结构对数据进行增删改查等操作，并暴露接口由外方调用

1.普通集合操作：增删改查
public class DoubleLinkedGroup<T> extends Group<T> {

    /**
     * 虚拟头结点
     */
    private Node headNode;

    /**
     * 虚拟尾节点
     */
    private Node tailNode;

    public DoubleLinkedGroup() {
        clear();
    }

    @Override
    public void add(int index, T el) {
        if (index < 0 || index > size) {
            throw new IllegalArgumentException("Add failed. Illegal index");
        }
        addNodeBefore(getNode(index), el);
    }

    @Override
    public T remove(int index) {
        if (index < 0 || index > size) {
            throw new IllegalArgumentException("Remove failed. Illegal index");
        }
        return removeNode(getNode(index));
    }

    @Override
    public void clear() {
        clearNode();
    }

    @Override
    public T set(int index, T el) {
        if (index < 0 || index > size) {
            throw new IllegalArgumentException("Set failed. Illegal index");
        }
        Node<T> node = getNode(index);
        T oldData = node.el;
        node.el = el;
        return oldData;
    }

    @Override
    public T get(int index) {
        if (index < 0 || index > size) {
            throw new IllegalArgumentException("Get failed. Illegal index");
        }
        return getNode(index).el;
    }
    
        @Override
    public void addLast(T el) {
        add(size, el);
    }
}
2.普通方法测试：
    private static void baseTest() {
        DoubleLinkedGroup<String> list = new DoubleLinkedGroup<>();
        //添加测试
        list.addFirst("特");
        list.addFirst("张");
        list.add(1,"风");
        list.add(2,"捷");
        list.addLast("烈");

        //输出测试
        System.out.println(list);
        //head: 张->风->捷->特->烈->null->

        //移除测试
        list.remove(3);
        System.out.println(list);
        //head: 张->风->捷->烈->null->

        //修改测试
        list.set(2,"神");
        System.out.println(list);
        //head: 张->风->神->烈->null->

        //获取测试
        for (int i = 0; i < list.size(); i++) {
            System.out.print(list.get(i));//张风神烈
        }

        //大小测试
        System.out.println(list.size());//4
        //是否为空测试
        System.out.println(list.isEmpty());//false

        //清空测试
        list.clear();
        System.out.println(list.isEmpty());//true
    }
}
二、其他方法测试

定元素查询索引、删除
两个双链表式集合定点连接

1.代码实现
    @Override
    public int[] getIndex(T el) {
        //临时数组
        int[] tempArray = new int[size];
        //重复个数
        int index = 0;
        int count = 0;
        Node node = headNode.next;
        while (node != null) {
            if (el.equals(node.el)) {
                tempArray[index] = -1;
                count++;
            }
            index++;
            node = node.next;
        }
        //将临时数组压缩
        int[] indexArray = new int[count];
        int indexCount = 0;
        for (int i = 0; i < tempArray.length; i++) {
            if (tempArray[i] == -1) {
                indexArray[indexCount] = i;
                indexCount++;
            }
        }
        return indexArray;
    }

    @Override
    public Group<T> contact(int index, Group<T> group) {
        if (index < 0 || index > size) {
            throw new IllegalArgumentException("Contact failed. Illegal index");
        }

        DoubleLinkedGroup linkedGroup = (DoubleLinkedGroup) group;
        Node targetNode = getNode(index);
        Node targetNextNode = targetNode.next;

        //目标节点的next指向待接链表的第一个节点
        targetNode.next = linkedGroup.getHeadNode().next;
        //向待接链表的第一个节点的prev指向目标节点
        linkedGroup.getHeadNode().next.prev = targetNode;

        //目标节点的下一节点指的prev向待接链表的最后一个节点
        targetNextNode.prev = linkedGroup.getTailNode().prev;
        //向待接链表的最后一个节点的next指向目标节点的下一节点的
        linkedGroup.getTailNode().prev.next = targetNextNode;

        return this;
    }

    public Node getHeadNode() {
        return headNode;
    }

    public Node getTailNode() {
        return tailNode;
    }
2.其他方法测试
    /**
     * 其他方法测试
     */
    private static void otherTest() {
        DoubleLinkedGroup<String> linkedGroup = new DoubleLinkedGroup<>();
        linkedGroup.addLast("a");
        linkedGroup.addLast("b");
        linkedGroup.addLast("a");
        linkedGroup.addLast("c");
        linkedGroup.addLast("a");

        System.out.println(linkedGroup);
        //head: a->b->a->c->a->null->

        //获取a元素的所有索引位置
        int[] as = linkedGroup.getIndex("a");
        for (int a : as) {
            System.out.print(a + " ");//0 2 4
        }

        //删除a元素第一次出现的地方---
        linkedGroup.removeEl("a");
        System.out.println(linkedGroup);
        //head: b->a->c->a->null->

        //查看a元素是否存在
        boolean b = linkedGroup.contains("a");
        System.out.println(b);//true

        //删除所有a元素出现的地方---
        linkedGroup.removeEls("a");
        System.out.println(linkedGroup);
        //head: b->c->NULL

        //双链表合并测试
        DoubleLinkedGroup<String> linkedGroup2 = new DoubleLinkedGroup<>();

        linkedGroup2.addLast("1");
        linkedGroup2.addLast("3");
        linkedGroup2.addLast("2");

        linkedGroup.contact(0, linkedGroup2);
        System.out.println(linkedGroup);
        //head: b->1->3->2->c->null->

    }
后记、
1.声明：

[1]本文由张风捷特烈原创,各图均由本人亲自所画，转载请注明

[2]欢迎广大编程爱好者共同交流
[3]个人能力有限，如有不正之处欢迎大家批评指证，必定虚心改正
[4]你的喜欢与支持将是我最大的动力

2.连接传送门：

更多数据结构知识欢迎访问:图解数据结构
项目源码均在我的github/DS：欢迎star
张风捷特烈个人网站，编程笔记请访问：http://www.toly1994.com

3.联系我

QQ:1981462002
邮箱：1981462002@qq.com
微信：zdl1994328

4.欢迎关注我的微信公众号，最新精彩文章，及时送达：
9414344-c474349cd3bd4b82.jpg
公众号.jpg

转载于:https://www.cnblogs.com/toly-top/p/9781868.html

dianju8374
关注
数据结构《LinkeList 双向链表》
m0_66483195的博客
11-13 1177
LinkeList 的模拟和使用
图解链表 —— JAVA 中的双向链表
AlinaQ05的博客
05-22 5119
1. 双向链表 前面提到了单向链表，单链表的特点是只能从前向后遍历，但是如果我们已知一个节点在链表靠后的位置，这时如果使用单链表效率就会很低，因此引入了双向链表就可以快速的找到靠后的节点。双向链表与单向链表的区别就是它不仅有后继节点，还有前驱节点。这样就既存储了下一个节点的地址，也存储了前一个节点的地址。 2. 双向链表的定义 节点类： class DoubleNode { // 指向前驱节点 DoubleNode prev; // 具体存储的数据
【数据结构】双向链表 C++
m0_73020012的博客
04-04 1788
双向链表也叫双链表，是链表的一种，它的每个数据结点中都有两个指针，分别指向直接后继和直接前驱。所以，从双向链表中的任意一个结点开始，都可以很方便地访问它的前驱结点和后继结点。val：存储每个节点的权值；last：指向每个节点的前面的第一个节点；next：指向每个节点的后面的第一个节点；T value;value=0;
[图解数据结构之Java实现](2) --- 线性表之链表实现
梦蓝樱飞(一点一滴, 记录个人成长之路)
10-07 884
本文行文思路结构一. 线性表 二. Java中的指针 三. 表的简单链表实现 四. 表的各种基本操作 --- 增删改查 1. 图解分析 2. 代码实现 五. 完整代码Demo 六. 总结一. 线性表部分定义和解释见下面链接: http://blog.csdn.net/menglanyingfei/article/details/71519202二. Java中的”指针”首先, 学过
图解双向链表(含完整C代码)+剖析STL顺序容器List(C++)
weixin_54186646的博客
03-19 4235
双向链表动图解析，对比双向链表在STL中的操作，内含完整代码
nginx_图解nginx关键数据结构_双向链表ngx_queue_t
AlexanderGan的博客
04-26 268
nginx_图解nginx关键数据结构_双向链表ngx_queue_t 一、结构解析   ngx_queue_t是一种环形双向链表的数据结构，这个链表不会负责分配内存来存放元素，ngx_queue_t只是将已经分配好内存的元素用双向链表连接起来。   链表的优势在于，可以高效的执行插入、删除、合并等操作。移动链表元素的时候只需要修改链表的指向，因此适合频繁修改容器的情况。   nginx中，ngx_queue_t主要功能有 （1）实现了简单的插入排序 （2）支持两个链表的合并与拆分 （3）获取
《数据结构》--链表【包含跳表概念】
Stark的博客
10-03 1774
不知道大家对熟悉还是陌生，我们秉着基础不牢，地动山摇的原则，会一点点的介绍链表的，毕竟链表涉及的也很重要的。在这之前，我们认识过的顺序表，它其实就是一个特殊的数组。那链表到底是什么？又有什么用呢？与顺序结构有什么不一样呢？
数据结构之链表及java实现（二）
星回昭以烂的博客
09-28 193
合并有序链表的递归方法 上次的尾巴，实现合并两个有序的链表的递归方法： 思路： 比较两个链表头结点的值，较小的就可以挪出，然后剩下的比较，合并即可。 每次的返回值，是排序好 的链表头。 public ListNode MergeRec(ListNode list1,ListNode list2){ if(list1==null&&list2==null){ return null; } if (list1==null
数据结构－双向链表
x13262608581的博客
02-05 911
数据结构，链表
图解数据结构C++版源码
01-13
《图解数据结构》是一本深受程序员喜爱的书籍，它以直观易懂的方式介绍了各种重要的数据结构及其在C++中的实现。源码是学习和理解数据结构的关键辅助工具，能够帮助读者更深入地掌握每种数据结构的工作原理。在这个...
图解数据结构使用C++范例程序
11-04
《图解数据结构使用C++范例程序》是一本深入浅出的数据结构学习资源，它以C++语言为工具，通过实例程序详细讲解了各种重要的数据结构及其应用。在这个压缩包中，你将找到一系列与数据结构相关的C++源代码，帮助你更...
NovelReader，“天下书阁”小说阅读器是一款基于Re.zip
11-01
NovelReader，“天下书阁”小说阅读器是一款基于Re
PCL 绕任意轴旋转的旋转平移矩阵的计算
11-01
PCL 绕任意轴旋转的旋转平移矩阵的计算
数据库卸载与安装.mp4
11-01
数据库卸载与安装.mp4
1201-01骰子.mp4
11-01
1201-01骰子.mp4
最新单手机版双融/金融系统 带静态推广官网
最新发布
11-01
测试环境PHP5.6+Mysql5.5+Apache 修改数据库配置application/database.php 后台/admin.php 账号admin密码admin404 伪静态 RewriteEngine On RewriteCond %{REQUEST_FILENAME} !-d RewriteCond %{REQUEST_FILENAME} !-f RewriteRule ^(.*)$ index.php?s=/$1 [QSA,PT,L]
资管软件源码/信管家软件源码/通达信配资/博易大师软件/外汇模拟/MT4外汇
11-01
仿信管家交易模式，操作简单。产品全新YII2框架开发，修复滑点不准确漏洞。玩完完整整服务器打包 注意：本产品数据源为收费数据源,需要客户自行购买 可封装exe软件和手机app 前后台全新优化
基于SSM的学生就业服务平台.zip
11-01
基于SSM的毕业设计源码
CIM是一套基于netty框架下的推送系统或许有一些企业有着.zip
11-01
CIM是一套基于netty框架下的推送系统或许有一些企业有着
数据结构课设：链表实现文本分析
数据机构课设是一份针对数据...此课设要求学生运用数据结构知识，特别是链表的实现，来设计和实现一个简单的文本编辑器，具有实用性和理论学习的双重价值。完成这样的作业有助于巩固对数据结构的理解，提升编程技能。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值