Java-双向链表的实现

最新推荐文章于 2024-04-27 17:30:34 发布
最新推荐文章于 2024-04-27 17:30:34 发布
阅读量981 收藏 7
点赞数
分类专栏： 算法学习 源码解读 文章标签： java 链表 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xhmico/article/details/129909989
版权

文章目录

一、概述

双向链表也称为双链表，是链表的一种，它的每个数据节点都有两个指针，分别指向直接后继和直接前驱。所以，从双向链表中的任意一个节点开始，都可以很方便地访问它的前驱节点和后继节点。

在这里插入图片描述

双向列表的特点：

  1. 可以使用一个 head 和 tail 分别指向头部和尾部的节点
  2. 每个节点由三部分组成：
    • 前一个节点的指针 prev
    • 保存的元素 data
    • 后一个节点的指针 next
  3. 双向链表的第一个节点的 pre 是 null
  4. 双向链表的最后一个节点的 next 是 null

双向链表在进行增加和删除元素的时候，只需要改变 prev 和 next 的指向即可完成相关的操作。

增加节点

  • 从头端插入节点
    在这里插入图片描述

  • 从中间位置插入节点
    在这里插入图片描述

  • 从尾端插入节点
    在这里插入图片描述

删除节点

  • 从头端删除节点
    在这里插入图片描述
  • 从中间位置删除节点
    在这里插入图片描述
  • 从尾端删除节点
    在这里插入图片描述

二、手写双向链表

创建 DoubleLinkedList 类，该类中写一个内部类 Node作为节点对象，Node 中拥有的属性是 data、next、prev 分别对应 所保存的数据、下一个节点对象、上一个节点对象，DoubleLinkedList 链表对象所拥有的属性为 head、tail、size，分别对应头节点、尾节点和链表长度。

/**
 * 双向链表
 * @param <E>
 */
public class DoubleLinkedList<E> {

    // 头节点
    private Node<E> head;
    // 尾节点
    private Node<E> tail;
    // 长度
    private int size;

    public DoubleLinkedList() {
        this.head = null;
        this.tail = null;
        this.size = 0;
    }

    // 内部类：节点对象
    private static class Node<E> {
        E data;
        Node<E> next;
        Node<E> prev;

        // 无参构造
        public Node() {
            this.data = null;
            this.next = null;
            this.prev = null;
        }

        // 构造方法
        public Node(Node<E> prev, E data, Node<E> next) {
            this.data = data;
            this.next = next;
            this.prev = prev;
        }

        @Override
        public String toString() {
            return data.toString();
        }
    }
}

void add(E element) 方法

    // 往链表末端添加元素
    public void add(E element) {
        this.add(size,element);
    }

void add(int index,E element) 方法

    // 往指定位置添加元素
    public void add(int index,E element) {

        if (index > size || index < 0) {
            throw new IllegalArgumentException("Illegal Index：" + index);
        }

        Node<E> node = new Node<>();
        node.data = element;
        // 判断当前链表的长度是否为 0
        if (size == 0) {
            // 如果为 0 ，则表示当前为第一次添加元素，头节点和尾节点就是新添加的节点
            head = node;
            tail = node;
        } else {
            if (index == 0) {
                // 从头端插入元素
                node.next = head;
                head.prev = node;
                head = node;
            } else if (index == size) {
                // 从尾端插入元素
                node.prev = tail;
                tail.next = node;
                tail = node;
            } else {
                // 从链表的间件位置插入元素
                // p：表示之前在 index 位置上的节点
                // q：表示之前在 index - 1 位置上的节点
                Node<E> p,q;
                // 遍历链表
                p = head;
                int count = 0;
                while (p.next != null) {
                    if (count == index) {
                        break;
                    }
                    p = p.next;
                    count++;
                }
                q = p.prev;
                node.prev = q;
                node.next = p;
                q.next = node;
                p.prev = node;
            }
        }
        size++;
    }

E remove() 方法

    // 删除链表末端元素
    public E remove() {
        return this.remove(size);
    }

E remove(E element) 方法

    // 删除链表中指定元素
    public E remove(E element) {
        int index = indexOf(element);
        if (index != -1) {
            return this.remove(index);
        }
        return null;
    }

E remove(int index) 方法

    // 删除链表中指定下标元素
    public E remove(int index) {

        if (index >= size || index < 0) {
            throw new IllegalArgumentException("Illegal Index：" + index);
        }

        E ret;

        if (index == 0) {
            // 删除头节点
            ret = head.data;
            Node<E> node = head.next;
            head.next = null;
            node.prev = null;
            head = node;
        } else if (index == size-1) {
            // 删除尾节点
            ret = tail.data;
            Node<E> node = tail.prev;
            tail.prev = null;
            node.next = null;
            tail = node;
        } else {
            // 删除中间位置的某个元素
            // p：表示 index 位置上的节点
            // q：表示 index - 1 位置上的节点
            // y：表示 index + 1 位置上的节点
            Node<E> p,q,y;
            // 遍历链表
            p = head;
            int count = 0;
            while (p.next != null) {
                if (count == index) {
                    break;
                }
                p = p.next;
                count++;
            }
            ret = p.data;
            y = p.next;
            q = p.prev;
            q.next = y;
            y.prev = q;
        }
        size--;
        return ret;
    }

int indexOf(E element) 方法

    // 获取指定元素的下标
    public int indexOf(E element) {
        int index = 0;
        Node<E> p = head;
        while (!p.data.equals(element)) {
            index++;
            p = p.next;
            if (index >= size) {
                return -1;
            }
        }
        return index;
    }

E get(int index) 方法

    // 获取指定下标的元素
    public E get(int index) {
        if (index >= size || index < 0) {
            throw new IllegalArgumentException("Illegal Index：" + index);
        }
        if (index == 0) {
            return head.data;
        } else if (index == size-1) {
            return tail.data;
        } else {
            Node<E> p = head;
            for (int i = 0; i < index; i++) {
                p = p.next;
            }
            return p.data;
        }
    }

E set(int index,E element) 方法

    // 设置指定下标的值
    public E set(int index,E element) {

        if (index >= size || index < 0) {
            throw new IllegalArgumentException("Illegal Index：" + index);
        }

        E ret;
        if (index == 0) {
            ret = head.data;
            head.data = element;
        } else if (index == size-1) {
            ret = tail.data;
            tail.data = element;
        } else {
            Node<E> p = head;
            for (int i = 0; i < index; i++) {
                p = p.next;
            }
            ret = p.data;
            p.data = element;
        }

        return ret;
    }

int size() 方法

    // 返回链表长度
    public int size() {
        return size;
    }

boolean contains(E element) 方法

    // 指定元素是否在链表中存在
    public boolean contains(E element) {
        return indexOf(element) != -1;
    }

boolean isEmpty() 方法

    // 当前链表是否为空链表
    public boolean isEmpty() {
        return size == 0;
    }

void clear() 方法

    // 清空链表
    public void clear() {
        head = null;
        tail = null;
        size = 0;
    }

void sort(Comparator comparator) 方法

    // 排序
    public void sort(Comparator<E> comparator) {

        if (comparator == null) {
            throw new IllegalArgumentException("comparable can not null");
        }

        if (size == 0 || size == 1) {
            return;
        }
        // 选则排序
        Node<E> nodeA = head;
        Node<E> nodeB = nodeA.next;
        while (nodeA.next != tail) {
            while (nodeB != tail) {
                if (comparator.compare(nodeA.data,nodeB.data) > 0) {
                    E temp = nodeA.data;
                    nodeA.data = nodeB.data;
                    nodeB.data = temp;
                }
                nodeB = nodeB.next;
            }
            nodeA = nodeA.next;
            nodeB = nodeA.next;
        }
    }

DoubleLinkedList subList(int fromIndex,int toIndex) 方法

    // 截取链表
    public DoubleLinkedList<E> subList(int fromIndex,int toIndex) {
        if (fromIndex < 0 || toIndex >= size || fromIndex > toIndex) {
            throw new IllegalArgumentException("Illegal Index" );
        }
        Node<E> nodeA = head;
        for (int i = 0; i < fromIndex; i++) {
            nodeA = nodeA.next;
        }
        Node<E> nodeB = head;
        for (int i = 0; i < toIndex; i++) {
            nodeB = nodeB.next;
        }
        DoubleLinkedList<E> list = new DoubleLinkedList<>();
        Node<E> p = nodeA;
        while (p != nodeB) {
            list.add(p.data);
            p = p.next;
        }
        return list;
    }

四、完整代码

import java.util.Comparator;

/**
 * 双向链表
 * @param <E>
 */
public class DoubleLinkedList<E> {

    // 头节点
    private Node<E> head;
    // 尾节点
    private Node<E> tail;
    // 长度
    private int size = 0;

    public DoubleLinkedList() {
        this.head = null;
        this.tail = null;
        this.size = 0;
    }

    // 内部类：节点对象
    private static class Node<E> {
        E data;
        Node<E> next;
        Node<E> prev;

        // 无参构造
        public Node() {
            this.data = null;
            this.next = null;
            this.prev = null;
        }

        // 构造方法
        public Node(Node<E> prev, E data, Node<E> next) {
            this.data = data;
            this.next = next;
            this.prev = prev;
        }

        @Override
        public String toString() {
            return data.toString();
        }
    }

    // 往链表末端添加元素
    public void add(E element) {
        this.add(size,element);
    }

    // 往指定位置添加元素
    public void add(int index,E element) {

        if (index > size || index < 0) {
            throw new IllegalArgumentException("Illegal Index：" + index);
        }

        Node<E> node = new Node<>();
        node.data = element;
        // 判断当前链表的长度是否为 0
        if (size == 0) {
            // 如果为 0 ，则表示当前为第一次添加元素，头节点和尾节点就是新添加的节点
            head = node;
            tail = node;
        } else {
            if (index == 0) {
                // 从头端插入元素
                node.next = head;
                head.prev = node;
                head = node;
            } else if (index == size) {
                // 从尾端插入元素
                node.prev = tail;
                tail.next = node;
                tail = node;
            } else {
                // 从链表的间件位置插入元素
                // p：表示之前在 index 位置上的节点
                // q：表示之前在 index - 1 位置上的节点
                Node<E> p,q;
                // 遍历链表
                p = head;
                int count = 0;
                while (p.next != null) {
                    if (count == index) {
                        break;
                    }
                    p = p.next;
                    count++;
                }
                q = p.prev;
                node.prev = q;
                node.next = p;
                q.next = node;
                p.prev = node;
            }
        }
        size++;
    }

    // 删除链表末端元素
    public E remove() {
        return this.remove(size);
    }

    // 删除链表中指定元素
    public E remove(E element) {
        int index = indexOf(element);
        if (index != -1) {
            return this.remove(index);
        }
        return null;
    }

    // 删除链表中指定下标元素
    public E remove(int index) {

        if (index >= size || index < 0) {
            throw new IllegalArgumentException("Illegal Index：" + index);
        }

        E ret;

        if (index == 0) {
            // 删除头节点
            ret = head.data;
            Node<E> node = head.next;
            head.next = null;
            node.prev = null;
            head = node;
        } else if (index == size-1) {
            // 删除尾节点
            ret = tail.data;
            Node<E> node = tail.prev;
            tail.prev = null;
            node.next = null;
            tail = node;
        } else {
            // 删除中间位置的某个元素
            // p：表示 index 位置上的节点
            // q：表示 index - 1 位置上的节点
            // y：表示 index + 1 位置上的节点
            Node<E> p,q,y;
            // 遍历链表
            p = head;
            int count = 0;
            while (p.next != null) {
                if (count == index) {
                    break;
                }
                p = p.next;
                count++;
            }
            ret = p.data;
            y = p.next;
            q = p.prev;
            q.next = y;
            y.prev = q;
        }
        size--;
        return ret;
    }

    // 获取指定元素的下标
    public int indexOf(E element) {
        int index = 0;
        Node<E> p = head;
        while (!p.data.equals(element)) {
            index++;
            p = p.next;
            if (index >= size) {
                return -1;
            }
        }
        return index;
    }

    // 获取指定下标的元素
    public E get(int index) {
        if (index >= size || index < 0) {
            throw new IllegalArgumentException("Illegal Index：" + index);
        }
        if (index == 0) {
            return head.data;
        } else if (index == size-1) {
            return tail.data;
        } else {
            Node<E> p = head;
            for (int i = 0; i < index; i++) {
                p = p.next;
            }
            return p.data;
        }
    }

    // 设置指定下标的值
    public E set(int index,E element) {

        if (index >= size || index < 0) {
            throw new IllegalArgumentException("Illegal Index：" + index);
        }

        E ret;
        if (index == 0) {
            ret = head.data;
            head.data = element;
        } else if (index == size-1) {
            ret = tail.data;
            tail.data = element;
        } else {
            Node<E> p = head;
            for (int i = 0; i < index; i++) {
                p = p.next;
            }
            ret = p.data;
            p.data = element;
        }

        return ret;
    }

    // 返回链表长度
    public int size() {
        return size;
    }

    // 指定元素是否在链表中存在
    public boolean contains(E element) {
        return indexOf(element) != -1;
    }

    // 当前链表是否为空链表
    public boolean isEmpty() {
        return size == 0;
    }

    // 清空链表
    public void clear() {
        head = null;
        tail = null;
        size = 0;
    }

    // 排序
    public void sort(Comparator<E> comparator) {

        if (comparator == null) {
            throw new IllegalArgumentException("comparable can not null");
        }

        if (size == 0 || size == 1) {
            return;
        }
        // 选则排序
        Node<E> nodeA = head;
        Node<E> nodeB = nodeA.next;
        while (nodeA.next != tail) {
            while (nodeB != tail) {
                if (comparator.compare(nodeA.data,nodeB.data) > 0) {
                    E temp = nodeA.data;
                    nodeA.data = nodeB.data;
                    nodeB.data = temp;
                }
                nodeB = nodeB.next;
            }
            nodeA = nodeA.next;
            nodeB = nodeA.next;
        }
    }

    // 截取链表
    public DoubleLinkedList<E> subList(int fromIndex,int toIndex) {
        if (fromIndex < 0 || toIndex >= size || fromIndex > toIndex) {
            throw new IllegalArgumentException("Illegal Index" );
        }
        Node<E> nodeA = head;
        for (int i = 0; i < fromIndex; i++) {
            nodeA = nodeA.next;
        }
        Node<E> nodeB = head;
        for (int i = 0; i < toIndex; i++) {
            nodeB = nodeB.next;
        }
        DoubleLinkedList<E> list = new DoubleLinkedList<>();
        Node<E> p = nodeA;
        while (p != nodeB) {
            list.add(p.data);
            p = p.next;
        }
        return list;
    }
}

五、测试代码

public class TextDem {
    public static void main(String[] args) {
        DoubleLinkedList<String> list = new DoubleLinkedList<>();
        // 添加元素
        list.add("米大傻");
        list.add("米二傻");
        list.add("米三傻");
        list.add("米四傻");
        list.add("米五傻");
        list.add(1,"米六傻");
        list.add(0,"米七傻");
        // 删除指定下标元素
        list.remove(3);
        // 查找元素下标
        int index = list.indexOf("米四傻");
        System.out.println("index = " + index);
        // 设置指定下标的值
        list.set(2,"李大霄");

        // 遍历集合
        for (int i = 0; i < list.size(); i++) {
            System.out.println(list.get(i));
        }

        System.out.println("====================");
        // 截取集合
        DoubleLinkedList<String> subList = list.subList(2, 5);
        for (int i = 0; i < subList.size(); i++) {
            System.out.println(subList.get(i));
        }

        System.out.println("====================");
        // 清空集合
        list.clear();
        for (int i = 0; i < list.size(); i++) {
            System.out.println(list.get(i));
        }
    }
}
多加点辣也没关系
关注
  • 0
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
JAVA双向链表反转实现
06-10
通过java实现的双向链表，及反转功能，可能对面试有用哦
【Java数据结构】 手写顺序表与单双向链表
m0_65563175的博客
10-09 245
线性表是一种简单的线性结构。主要操作特点是可以在插入和删除一个数据元素。除了第一个和最后一个元素，中间的每个元素只有一个和一个。线性表有两种存储方式：第一种是，第二种是。
doublelink.zip_DoubleLink java_双向链表实现
09-24
使用java语言实现双向链表，提供测试用例说明功能
Java算法实例-双向链表操作
08-22
Java算法实例-双向链表操作，封装性高，考试、学习都可使用
java手动实现双向链表LinkedList
小范的博客
01-12 803
一、LinkedList原理介绍 LinkedList是java中重要的List集合，其内部是一个双向链的数据结构。插入和删除的效率比ArrayList高,之前手动实现的ArrayList，因为插入和删除没有数组的复制工作，如果想在下标为index位置插入元素则通过从头部或者尾部开始查找，找到index原始位置的元素，则修改原始位置index元素的Node中的上一个元素，以及元素index元素前
Java数据结构 —— 手写线性结构（稀疏数组、栈、队列、链表）
小S的博客
02-24 795
当一个数组中大部分值为0,或者相同时，可以采用稀疏数组的方式来保存，从而节约存储空间，提高存储效率。Java描述的双向链表。Java描述的顺序表。
Java手写链表
qq_45464560的博客
09-28 2020
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-V73ZFeSh-1632464808641)(https://img-mid.csdnimg.cn/release/static/image/mid/ask/081087464236187.jpg “=600 #left”)]
java实现双向链表(图解以及分析)
qq_54469537的博客
10-02 1690
详细分析以图解实现双向链表
【数据结构】Java实现双向链表
qq_53869058的博客
03-20 1862
LinkedList的底层是双向链表结构，由于链表没有将元素存储在连续的空间中，元素存储在单独的节点中，然后通过引用将节点连接起来了，因此在在任意位置插入或者删除元素时，不需要搬移元素，效率比较高。
【数据结构篇】手写双向链表、单向链表（超详细）
热爱编程、热爱生活、热爱探索
08-05 2386
什么是链表？链表（Linked List）是用链式存储结构实现的线性表。链表的组成数据域引用域（数据域和引用域合称结点或元素）数据域存放数据元素自身的数据引用域存放相邻结点的地址链表的特点链表中元素的联系依靠引用域具有线性结构的特点，链表所使用的逻辑结构是线性结构具有链式存储结构的特点，所使用的物理存储结构是链式存储链表的分类单向链表：单链表是一种最简的链表，只有一个引用域1next特点：通过next可以访问到后继结点，终端结点的引用域指向null双向链表：具有两个引用域prev和next。
Java实现双向链表(两个版本)
09-02
主要介绍了Java实现双向链表(两个版本)的相关资料,需要的朋友可以参考下
Java实现双向链表
03-22
用Java定义一个双向链表，实现链表的基本操作： 初始化、获取头结点、添加新元素、删除链表元素、 获取链表元素、查找链表元素、更新链表中某个元素、 判断链表是否为空、求链表元素个数、输出链表元素、清空链表。
Java手写双向链表
weixin_45986454的博客
09-20 387
标题：Java手写双向链表 1.声明链表的节点样式： class IntSNode{ public int info; public IntSNode prev; public IntSNode next; public IntSNode(int info) { this(info,null,null); } public IntSNode(int info,IntSNode prev,IntSNode next) { this.info=info; this.prev=prev;
一步步带你用Java实现双向链表（超详细）
热门推荐
you do ,you win
04-21 1万+
文章目录什么是双向链表属性及方法节点Nodesize数据插入头插法 addFirst(T value)尾插法 addLast(T value)插入到指定下标位置add(int index)数据删除(返回被删除节点存储的值)删除头结点 removeFirst删除尾结点 removeLast删除指定下标节点remove（int index）获取指定下标位置节点的数据 getData（int index）获取链表长度遍历输出print()详细遍历输出清空链表实现细节 上一节说到了单链表,这一节我们来手写一个双向链
Java 手写双向链表
weixin_41914010的博客
04-14 793
Java 手写双向链表 DoubleLinkedList.java package com.muxiaofei.veryday.entity; /** * 双链表 * * @param <T> */ public class DoubleLinkedList<T> { //链表大小 public int size; // 头节点（先初始化一下） Node<T> head = new Node<>(); //
【Java】手打双向链表
qq_53478650的博客
11-07 133
【代码】【Java】手打双向链表。
数据结构之手写单链表(通过Node节点实现)(Java)
一切随缘的博客
07-20 514
代码】数据结构之手写单链表（通过Node节点实现）（Java）
【Java】初学者成神路之手写单链表
qq_53964276的博客
03-04 308
小白学习Java的第7天，手写单链表单链表中的节点：节点是单向链表中基本的单元 每一个节点Node都有两个属性： 一个属性：是存储的数据 另一个属性：是下一个节点的内存地址
Day25-Java基础之常用类1
最新发布
m0_46053885的博客
04-27 1100
同时我们发现Math类中的方法都是静态的，因此在使用的时候我们可以直接通过类名去调用。对于计算机而言，其实是没有数据类型的概念的，都是0101010101，数据类型是编程语言自己规定的，所以在实际存储的时候，先把具体的数字变成二进制，每32个bit为一组，存储在数组中。比较内存地址值一般情况下是没有意义的，我们希望比较的是对象的属性，如果两个对象的属性相同，我们认为就是同一个对象；如果我们的数据是一个浮点类型的数据，有的时候计算机并不会将这个数据完全转换成一个二进制数据，而是将这个将其转换成一个无限的。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值