数据结构和算法（三）--双向（循环）链表（LinkedList）

最新推荐文章于 2022-12-20 20:51:09 发布
最新推荐文章于 2022-12-20 20:51:09 发布
阅读量284 收藏
点赞数
分类专栏： 数据结构和算法 文章标签： 数据结构 算法 链表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45405982/article/details/111300742
版权

数据结构和算法（三）–双向（循环）链表（LinkedList）

双向链表的基本数据结构
  • 双向链表区别于单向链表，节点中不仅仅有next指向下一个节点，还有prev字段指向上一个节点
  • 双向链表中有first和last字段指向第一个节点和最后一个节点
  • 双向链表可以提升链表的综合性能
    双向链表数据结构
双向链表方法设计思路
  1. obtainNode(int index)
    根据传入的index和实际size进行对比，假如index小于size/2则从firstNode进行遍历，否则从lastNode进行遍历，还要注意一点，就是从最后一个节点进行遍历的时候，i的起始值以及范围
  2. add(E element)
    直接调用add(E element ,int index)方法往最后一个位置添加元素
  3. remove(int index)
    把此节点的上一个节点的next指向此节点的下一个节点，把此节点的下一个节点的prev指向此节点的上一个节点
  4. add(E element,int index)
    要根据不同的情况进行处理，当index和size都是0时，要把firstNode和lastNode指向新建出来的节点；当size不为0时则不需要把lastNode指向新建出来的节点；当传入的index等于size时说明是往最后一个节点添加元素，则要把原来最后一个节点的next指向它，把lastNode也要指向它；其他情况则是从中间添加元素，要把原来节点的上一个节点的next指向新节点，把原节点的下一个节点的prev指向它，新建节点它的上一个节点是原节点的上一个节点，下一个节点是原节点
  5. set(E element ,int index)
    先查找出index处的节点，再把节点的element属性设置为传入值
  6. indexOf(E element)
    循环遍历链表，进行equals比较，当传入值为null时需要特殊处理
  7. clear()
    firstNode设置为null，lastNode设置为null，size设置为0
代码实现（配合上面设计思路观看）
/**
 * 自定义双向链表
 *
 * @author maolin yuan
 * @version 1.0
 * @date 2020/12/15 20:04
 */
public class CustomLinkedListPlus<T> implements CustomList<T> {

    private int size;
    private Node<T> firstNode;
    private Node<T> lastNode;

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

    @Override
    public boolean isEmpty() {
        return size == 0;
    }

    @Override
    public boolean contains(T element) {
        return indexOf(element) != -1;
    }

    @Override
    public void add(T element) {
        add(size, element);
    }

    @Override
    public T get(int index) {
        return obtainNode(index).element;
    }

    @Override
    public T set(int index, T element) {
        T oldElement = get(index);
        obtainNode(index).element = element;
        return oldElement;
    }

    @Override
    public void add(int index, T element) {
        if (index == 0) {
            Node<T> nowNode = new Node<>(element, firstNode, null);
            firstNode = nowNode;
            if (size == 0){
                lastNode = nowNode;
            }
        } else if (index == size) {
            Node<T> preNode = obtainNode(index - 1);
            Node<T> nowNode = new Node<>(element, null, preNode);
            preNode.next = nowNode;
            lastNode = nowNode;
        } else {
            Node<T> preNode = obtainNode(index - 1);
            Node<T> node = preNode.next;
            Node<T> nowNode = new Node<>(element, node, preNode);
            preNode.next = nowNode;
            node.prev = nowNode;
        }
        size++;
    }

    @Override
    public T remove(int index) {
        T oldElement = get(index);
        Node<T> node = obtainNode(index);
        node.prev.next = node.next;
        node.next.prev = node.prev;
        size--;
        return oldElement;

    }

    @Override
    public int indexOf(T element) {
        Node<T> first = this.firstNode;
        for (int i = 0; i < size; i++) {
            if (element == null) {
                if (first.element == null) {
                    return i;
                }
            } else {
                if (element.equals(first.element)) {
                    return i;
                }
            }
            first = first.next;
        }
        return -1;
    }

    @Override
    public void clear() {
        firstNode = null;
        lastNode = null;
        size = 0;
    }


    /**
     * 获取对应index处的节点，根据index靠近头还是尾选择正向遍历还是反向遍历
     *
     * @param index 传入的索引值
     * @return 返回的节点对象
     */
    private Node<T> obtainNode(int index) {
        checkIndex(index);
        Node<T> node = null;
        if (index < size / 2) {
            node = firstNode;
            for (int i = 0; i < index; i++) {
                node = node.next;
            }
        } else {
            node = lastNode;
            for (int i = size - 1; i > index; i--) {
                node = node.prev;
            }
        }
        return node;
    }

    /**
     * 索引越界检查
     *
     * @param index 传入索引
     */
    private void checkIndex(int index) {
        if (index < 0 || index >= size) {
            throw new RuntimeException("索引越界错误");
        }
    }

    /**
     * 节点对象，内部类
     *
     * @param <T>
     */
    private static class Node<T> {
        T element;
        Node<T> next;
        Node<T> prev;

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

    @Override
    public String toString() {
        CustomLinkedListPlus.Node<T> node = this.firstNode;
        StringBuilder stringBuilder = new StringBuilder();
        for (int i = 0; i < size; i++) {
            if (i == 0) {
                stringBuilder.append("[");
            } else {
                stringBuilder.append(",");
            }
            stringBuilder.append(node.element);
            node = node.next;
        }
        stringBuilder.append("]").append(" ==> 链表长度为：").append(size);
        return stringBuilder.toString();
    }
}
时间复杂度分析
  1. add(int index, E element)
    • 最大时间复杂度：O(n)
    • 最小时间复杂度：O(1)
    • 平均时间复杂度：O(n)
  2. get(int index)
    • 最大时间复杂度：O(n)
    • 最小时间复杂度：O(1)
    • 平均时间复杂度：O(n)
  3. set(int index, E element)
    • 最大时间复杂度：O(n)
    • 最小时间复杂度：O(1)
    • 平均时间复杂度：O(n)
  4. remove(int index)
    • 最大时间复杂度：O(n)
    • 最小时间复杂度：O(1)
    • 平均时间复杂度：O(n)
  5. indexOf(E element)
    • 最大时间复杂度：O(n)
    • 最小时间复杂度：O(1)
    • 平均时间复杂度：O(n)
链表与动态数组的选择
  • 查询较多时（随机访问次数比较多），选择动态数组
  • 在头部增加或者删除元素较多，可以选择链表，在尾部增加或删除元素较多，都可以选择
  • 如果在随机位置增加或删除元素较多，选择双向链表
  • 动态数组可能会导致内存浪费（预留容量），开辟和销毁内存的次数较少
  • 链表不会导致内存浪费（使用时创建对象），开辟和销毁内存的次数较多
  • 双向链表比单项链表查询某一个节点操作循环次数少了一半，但是需要更多的内存存储上一个节点的地址（以空间换时间）
双向循环链表
  • 双向循环链表和双向链表的区别就是，头节点的prev指向最后一个节点，尾节点的next指向头节点
循环链表实现思路分析
  1. 双向循环链表和单向循环链表需要注意的事情差不多，也是主要在增加和删除方法上有改动
  2. add(int index,T element)
    在传入的index==0时，要对size是否等于0进行不同处理，当等于0时，新建的节点必须手动设置其prev和next属性；当不等于0时，注意要设置新节点的prev为原来firstNode的prev。
  3. remove(int index)
    判断index的值为0或者是size-1进行特殊处理
代码实现（重点看add和remove方法和原来的有什么区别）
/**
 * 自定义双向循环链表
 *
 * @author maolin yuan
 * @version 1.0
 * @date 2020/12/15 20:04
 */
public class CustomCircleLinkedListPlus<T> implements CustomList<T> {

    private int size;
    private Node<T> firstNode;
    private Node<T> lastNode;

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

    @Override
    public boolean isEmpty() {
        return size == 0;
    }

    @Override
    public boolean contains(T element) {
        return indexOf(element) != -1;
    }

    @Override
    public void add(T element) {
        add(size, element);
    }

    @Override
    public T get(int index) {
        return obtainNode(index).element;
    }

    @Override
    public T set(int index, T element) {
        T oldElement = get(index);
        obtainNode(index).element = element;
        return oldElement;
    }

    @Override
    public void add(int index, T element) {
        if (index == 0) {
            if (size == 0) {
                Node<T> nowNode = new Node<>(element, null, null);
                firstNode = nowNode;
                lastNode = nowNode;
                firstNode.prev = nowNode;
                lastNode.next = nowNode;
            } else {
                Node<T> nowNode = new Node<>(element, firstNode, firstNode.prev);
                firstNode = nowNode;
                firstNode.next.prev = nowNode;
            }
        } else if (index == size) {
            Node<T> preNode = obtainNode(index - 1);
            Node<T> nowNode = new Node<>(element, preNode.next, preNode);
            preNode.next = nowNode;
            firstNode.prev = nowNode;
            lastNode = nowNode;
        } else {
            Node<T> preNode = obtainNode(index - 1);
            Node<T> node = preNode.next;
            Node<T> nowNode = new Node<>(element, node, preNode);
            preNode.next = nowNode;
            node.prev = nowNode;
        }
        size++;
    }

    @Override
    public T remove(int index) {
        T oldElement = get(index);
        Node<T> node = obtainNode(index);
        if (index == 0) {
            firstNode = node.next;
        } else {
            node.prev.next = node.next;
        }
        if (index == size - 1) {
            lastNode = node.prev;
        } else {
            node.next.prev = node.prev;
        }

        size--;
        return oldElement;

    }

    @Override
    public int indexOf(T element) {
        Node<T> first = this.firstNode;
        for (int i = 0; i < size; i++) {
            if (element == null) {
                if (first.element == null) {
                    return i;
                }
            } else {
                if (element.equals(first.element)) {
                    return i;
                }
            }
            first = first.next;
        }
        return -1;
    }

    @Override
    public void clear() {
        firstNode = null;
        lastNode = null;
        size = 0;
    }


    /**
     * 获取对应index处的节点，根据index靠近头还是尾选择正向遍历还是反向遍历
     *
     * @param index 传入的索引值
     * @return 返回的节点对象
     */
    private Node<T> obtainNode(int index) {
        checkIndex(index);
        Node<T> node = null;
        if (index < size / 2) {
            node = firstNode;
            for (int i = 0; i < index; i++) {
                node = node.next;
            }
        } else {
            node = lastNode;
            for (int i = size - 1; i > index; i--) {
                node = node.prev;
            }
        }
        return node;
    }

    /**
     * 索引越界检查
     *
     * @param index 传入索引
     */
    private void checkIndex(int index) {
        if (index < 0 || index >= size) {
            throw new RuntimeException("索引越界错误");
        }
    }

    /**
     * 节点对象，内部类
     *
     * @param <T>
     */
    private static class Node<T> {
        T element;
        Node<T> next;
        Node<T> prev;

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

        @Override
        public String toString() {
            return "Node{" + prev.element+
                    "=>" + element +
                    "=>" + next.element +
                    '}';
        }
    }

    @Override
    public String toString() {
        CustomCircleLinkedListPlus.Node<T> node = this.firstNode;
        StringBuilder stringBuilder = new StringBuilder();
        for (int i = 0; i < size; i++) {
            if (i == 0) {
                stringBuilder.append("[");
            } else {
                stringBuilder.append(",");
            }
            stringBuilder.append(node);
            node = node.next;
        }
        stringBuilder.append("]").append(" ==> 链表长度为：").append(size);
        return stringBuilder.toString();
    }
}
maolinyuan
关注
专栏目录
Java就业冲刺之数据结构-递归-双向链表-树
m0_72568513的博客
07-04 178
删除的节点只有一颗子树,让该节点的父节点的left/right,指向删除节点的子节点即可。删除的节点有两颗子树,让删除节点的前驱节点/后继节点来替换该节点,才能保证树已让是有序的。删除的是叶子节点,此时直接删除即可,让其父节点指向该节点的引用置为null,即可。增删元素:(默认在尾部添加)将链断开,然后重新链接,从而实现添加/删除元素。为了避免失衡二叉树,对二叉排序树进行了优化,产生了两种新的数据结构。查找元素: get(int index):E。Comparator–外比较器。
细说 单链表、双向链表 、LinkedList类（附 add 源码解读）和 ArrayList 和 LinkedList 的区别 —— 数据结构
honglan297的博客
07-25 744
本篇文章将从链表的相关概念入手，对单向、双线链表进行模拟实现，再回到 LinkedList 集合内当中进行简单分析，最后结合上一篇文章，阐述四点 LinkedList 和 ArrayLIst 区别。
用Java实现模拟双向循环链表LinkedList
02-28
这是自己写的一个Java实现模拟数据结构中的LinkedList。实现其简单的添加节点功能
LinkedList双向循环链表
weixin_43281120的博客
10-04 770
https://www.jianshu.com/p/820dd2fec5e8
javascript LinkedList js 双向循环链表 Circular Linked List
fareast_mzh的博客
07-16 743
javascript LinkedList: function Node(elem, prev, next) { this.elem = elem; this.prev = prev ? prev : null; this.next = next ? prev : null; } function LinkedList() { this.length =...
LinkedList学习（双向循环链表）
coach
07-11 203
[code="java"]/** * 双向循环链表测试 * @author coach * @param */ public class Node { private E element; //结点数据 private Node next; //上结点 private Node previous; //...
LinkedList-双向链表
weixin_43681666的博客
11-19 1331
LinkedList-双向链表 《Hash Map源码基于jdk_8》 1. 类的继承关系 双向链表实现了List和Deque(双向队列)接口 2. 变量及其含义 变量名 默认值 含义 其他补充 size 0 地球人都知道 first 头节点 last 尾节点 3.构造函数 分为无参构造和有参构造，无参构造啥也不做。有参构造以Collection为参数，并初始化。 List<String> noArgslinkedList = new Link
复合型数据结构：(双向循环)链表_第3部分：各种排序算法
weixin_46201756的博客
12-04 1634
练习使用C语言，实现双向循环链表的各种排序算法。链表排序的优势在于可以快速删减、插入结点，动态性能很好！
list-2_单链表_speakgfp_数据结构_循环链表_
10-02
在本项目中，我们将探讨三种不同的链表类型：单链表、单向循环链表和双向循环链表。下面将详细阐述这些链表的实现和它们的特性。 首先，单链表是一种线性数据结构，每个节点包含两个部分：数据元素和指向下一个节点...
LinkedList源码分析：双向循环链表实现
grace的专栏
08-08 967
java以面向对象思想实现双向循环链表 public class LinkedList { private transient Entry header = new Entry(null, null, null); private transient int size = 0; /** * 构造方法：初始化LinkedList时为header结点分
【数据结构】LinkedList与双向链表
最新发布
qq_61903414的博客
12-20 1909
LikedList类是List接口的实现类。他还实现了Deque接口，还是一个队列，也能当成双端队列来使用。虽然LinkedList是一个List集合，但是它的实现方式和ArrayList是完全不同的，ArrayList的底层是一个动态的Object[]数组，而LinkedList的底层是一个双向链表。LinkedList是基于双向循环链表实现的，他还能当作队列或者栈来使用，他是线程不安全的，适合在单线程下使用。
单链表，单向循环链表与双向循环链表（LinkedList）实现
MJ6666666的博客
01-17 720
动态链表 为了表示每个数据元素ai与其直接后继数据元素ai+1之间的逻辑关系，对数据元素ai来说，除了存储其本身的信息之外，还需要存储一个指示其直接后继的信息（即直接后继的存储位置）我们把存储数据元素信息的域称为数据域，把存储直接后继位置的域称为指针域。指针域中存储的信息称作指针或链。这两部分信息组成数据元素ai的存储映像，称为结点（Node） 头结点和头指针 头结点是指链表中的第一个结点，有真实头结点和虚拟头结点之分 真实头结点：其第一个结点用于存储数据 虚拟头结点：其第一个结点不许存储数据 头指针：仅仅
LinkedList（双向链表）
m0_68927002的博客
07-09 593
LinkedList
双向循环链表
日积月累
07-24 422
//双向循环链表 public class LinkedList implements List, Stack, Queue, Deque { private class Node { E data; Node pre; Node next; public Node(E data) { this.data = data; pre = null; next = null; } @Override public String toString() { return data.toString(); } } pr
java.实现双向循环链表LinkedList
qq_60183774的博客
02-09 785
作学习记录
LinkedList简介
it_yangkun的博客
10-05 315
LinkedList简介 LinkedList是基于双向循环链表（从源码中可以很容易看出）实现的，除了可以当作链表来操作外，它还可以当作栈，队列和双端队列来使用。 LinkedList同样是非线程安全的，只在单线程下适合使用。 LinkedList实现了Serializable接口，因此它支持序列化，能够通过序列化传输，实现了Cloneable接口，能被克隆。 Linked
LinkedList : 双向链表与实现
勇气与行动
10-22 562
转载：http://www.cnblogs.com/xiaofuwei/p/4951047.html 所谓双向链表： 　　 （由此图可见老夫深厚的画功） 链表，就是由一个一个的节点连接组成。 在这里，每一个节点都是由三部分组成：上一个节点、当前节点的元素、下一个节点 当链表中只有一个节点的时候，这个节点指向的上一个节点是空的，下一个节点也是空的 当有多个节点的时候
C#数据结构与算法：双向链表和循环链表解析
在软件开发中，数据结构和算法的学习至关重要，尤其是对于专业程序员来说。本文档主要关注链表设计的改进，包括双向链表和循环链表的概念，以及如何在C#语言环境下实现这些改进。同时，文档也强调了C#中的.NET框架库...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值