【一起学数据结构与算法】Java实现双链表

已于 2022-10-01 19:37:21 修改
阅读量1.3k 收藏 27
点赞数 39
分类专栏： 一起学数据结构与算法系列 文章标签： java 链表 数据结构
于 2022-10-01 19:14:38 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_61341342/article/details/127136237
版权

目录

一、双链表的概念

双向链表也叫双链表，是链表的一种，它的每个数据结点中都有两个指针，分别指向直接后继和直接前驱。所以，从双向链表中的任意一个结点开始，都可以很方便地访问它的前驱结点和后继结点。一般我们都构造双向循环链表。

二、双链表一些方法的实现

2.1 双链表的属性

class ListNode {
    public int val;
    public ListNode prev;
    public ListNode next;

    public ListNode(int val) {
        this.val = val;
    }
}

public class MyLinkedList {

    public ListNode head;//指向双向链表的头节点
    public ListNode last;//指向的是尾巴结点
    }

2.2 打印双链表

打印双链表非常简单，只需要单独创一个结点cur来遍历链表并打印

//打印双向链表
public void display() {
        //和单链表的打印方式是一样的
        ListNode cur = this.head;
        while (cur != null) {
            System.out.print(cur.val + " ");
            cur = cur.next;
        }
        System.out.println();
    }

2.3 得到双链表的长度

单独创一个结点cur来遍历链表同时创一个count计数器来计算长度即可

//得到双链表的长度
    public int size() {
        ListNode cur = this.head;
        int count = 0;
        while (cur != null) {
            count++;
            cur = cur.next;
        }
        return count;
    }

2.4 查找是否包含关键字key是否在双链表中

单独创一个结点cur来遍历链表并且判断是否包含key

//查找是否包含关键字key是否在双链表中
    public boolean contains(int key) {
        ListNode cur = this.head;
        while (cur != null) {
            if (cur.val == key) {
                return true;
            }
            cur = cur.next;
        }
        return false;
    }

2.5 头插法

当我们想把新的结点插入到第一个结点位置处，可以先建立一个结点，然后把头结点的prev变为我们新建立结点的next值，然后将我们新建立的结点值变为null，最后将头结点指向新的插入的结点。
注意我们需要首先判断这个链表是否为空，假如为空就直接构建链表即可

//头插法
    public void addFirst(int data) {
        ListNode node = new ListNode(data);
        if (this.head == null) {
            this.head = node;
            this.last = node;
        } else {
            node.next = this.head;
            head.prev = node;
            this.head = node;
        }
    }

2.6 尾插法

尾插法顾名思义就是从结尾插入新的结点，这个和头插法过程差不多，只不过一个是改变head的位置，一个是改变last的位置。
和头插法一样，这个同样需要判断链表是否初始为空

//尾插法
    public void addLast(int data) {
        ListNode node = new ListNode(data);
        if (this.head == null) {
            this.head = node;
            this.last = node;
        } else {
            this.last.next = node;
            node.prev = this.last;
            this.last = node;
        }
    }

2.7 任意位置插入，第一个数据结点为0号下标

首先要考虑，插入的位置是头部或尾部或中间。根据具体的位置实现具体的操作。
如果是头部，直接调用头插，如果是尾部，就直接调用尾插即可。

如果是中间插的的话：

在这里插入图片描述
1.node.next = cur.prev.next;
2.cur.prev.next = node;
3.node.prev = cur.prev;
4.cur.prev = node;
在这里插入图片描述

public ListNode searchIndex(int index) {
        ListNode cur = this.head;
        while (index != 0) {
            cur = cur.next;
            index--;
        }
        return cur;
    }
    //任意位置插入，第一个数据结点为0号下标
    public void addIndex(int index, int data) {
        ListNode node = new ListNode(data);
        if (index < 0 || index >size()) {
            System.out.println("index位置不合法！");
            return;
        }
        if (index == 0) {
            addFirst(data);
            return;
        }
        if (index == size()) {
            addLast(data);
            return;
        }
        ListNode cur = searchIndex(index);
        node.next = cur.prev.next;
        cur.prev.next = node;
        node.prev = cur.prev;
        cur.prev = node;
    }

2.8 删除第一次出现为key的结点

假如是头结点的话我们还需要判断这个链表是否只有一个结点，如果是那么last指针也会为空，head指针也会为空，否则，我们只移动头指针结点就可以
当删除中间结点的时候我们可以先找到对于位置的结点cur，利用对应位置的cur.prev和cur.next确定附近两个结点，然后进行删除即可，这个删除与链表相似，只是多了一个删除头结点而已。

//删除第一次出现为key的结点
    public void remove(int key) {
        ListNode cur = this.head;

        while (cur != null) {
            if (cur.val == key) {
                if (cur == head) {
                    this.head = this.head.next;
                    if (this.head != null) {
                        this.head.prev = null;
                    } else {
                        this.last = null;
                    }
                } else {
                    cur.prev.next = cur.next;
                    if (cur.next != null) {
                        cur.next.prev = cur.prev;
                    } else {
                        this.last = this.last.prev;
                    }
                }
                return;
            }
            cur = cur.next;
        }
    }

2.9 删除所有key的值

//删除所有key的值
    public void removeAllKey(int key) {
        ListNode cur = this.head;

        while (cur != null) {
            if (cur.val == key) {
                if (cur == head) {
                    this.head = this.head.next;
                    if (this.head != null) {
                        this.head.prev = null;
                    } else {
                        this.last = null;
                    }
                } else {
                    cur.prev.next = cur.next;
                    if (cur.next != null) {
                        cur.next.prev = cur.prev;
                    } else {
                        this.last = this.last.prev;
                    }
                }
            }
            cur = cur.next;
        }
    }

2.10 清空双链表

//清空双链表
    public void clear() {
        while (this.head != null) {
            ListNode curNext = head.next;
            this.head.next = null;
            this.head.prev = null;
            this.head = curNext;
        }
        last = null;
    }

三、MyLinkedList.java


class ListNode {
    public int val;
    public ListNode prev;
    public ListNode next;

    public ListNode(int val) {
        this.val = val;
    }
}

public class MyLinkedList {

    public ListNode head;//指向双向链表的头节点
    public ListNode last;//指向的是尾巴结点


    //打印双向链表
    public void display() {
        //和单链表的打印方式是一样的
        ListNode cur = this.head;
        while (cur != null) {
            System.out.print(cur.val + " ");
            cur = cur.next;
        }
        System.out.println();
    }

    //得到双链表的长度
    public int size() {
        ListNode cur = this.head;
        int count = 0;
        while (cur != null) {
            count++;
            cur = cur.next;
        }
        return count;
    }

    //查找是否包含关键字key是否在双链表中
    public boolean contains(int key) {
        ListNode cur = this.head;
        while (cur != null) {
            if (cur.val == key) {
                return true;
            }
            cur = cur.next;
        }
        return false;
    }

    //头插法
    public void addFirst(int data) {
        ListNode node = new ListNode(data);
        if (this.head == null) {
            this.head = node;
            this.last = node;
        } else {
            node.next = this.head;
            head.prev = node;
            this.head = node;
        }
    }

    //尾插法
    public void addLast(int data) {
        ListNode node = new ListNode(data);
        if (this.head == null) {
            this.head = node;
            this.last = node;
        } else {
            this.last.next = node;
            node.prev = this.last;
            this.last = node;
        }
    }


    public ListNode searchIndex(int index) {
        ListNode cur = this.head;
        while (index != 0) {
            cur = cur.next;
            index--;
        }
        return cur;
    }
    //任意位置插入，第一个数据结点为0号下标
    public void addIndex(int index, int data) {
        ListNode node = new ListNode(data);
        if (index < 0 || index >size()) {
            System.out.println("index位置不合法！");
            return;
        }
        if (index == 0) {
            addFirst(data);
            return;
        }
        if (index == size()) {
            addLast(data);
            return;
        }
        ListNode cur = searchIndex(index);
        node.next = cur.prev.next;
        cur.prev.next = node;
        node.prev = cur.prev;
        cur.prev = node;
    }

    //删除第一次出现为key的结点
    public void remove(int key) {
        ListNode cur = this.head;

        while (cur != null) {
            if (cur.val == key) {
                if (cur == head) {
                    this.head = this.head.next;
                    if (this.head != null) {
                        this.head.prev = null;
                    } else {
                        this.last = null;
                    }
                } else {
                    cur.prev.next = cur.next;
                    if (cur.next != null) {
                        cur.next.prev = cur.prev;
                    } else {
                        this.last = this.last.prev;
                    }
                }
                return;
            }
            cur = cur.next;
        }
    }

    //删除所有key的值
    public void removeAllKey(int key) {
        ListNode cur = this.head;

        while (cur != null) {
            if (cur.val == key) {
                if (cur == head) {
                    this.head = this.head.next;
                    if (this.head != null) {
                        this.head.prev = null;
                    } else {
                        this.last = null;
                    }
                } else {
                    cur.prev.next = cur.next;
                    if (cur.next != null) {
                        cur.next.prev = cur.prev;
                    } else {
                        this.last = this.last.prev;
                    }
                }
            }
            cur = cur.next;
        }
    }

    //清空双链表
    public void clear() {
        while (this.head != null) {
            ListNode curNext = head.next;
            this.head.next = null;
            this.head.prev = null;
            this.head = curNext;
        }
        last = null;
    }
}

四、Test.java


public class Test {
    public static void main(String[] args) {
        MyLinkedList myLinkedList = new MyLinkedList();
        myLinkedList.addFirst(1);
        myLinkedList.addFirst(2);
        myLinkedList.addFirst(3);
        myLinkedList.addFirst(4);
        System.out.println(myLinkedList.size());
        myLinkedList.display();
        System.out.println(myLinkedList.contains(1));
        myLinkedList.addLast(1);
        myLinkedList.addLast(2);
        myLinkedList.addLast(3);
        myLinkedList.addLast(4);
        myLinkedList.display();
        myLinkedList.remove(1);
        myLinkedList.display();
        myLinkedList.removeAllKey(4);
        myLinkedList.display();
        myLinkedList.addIndex(0,99);
        myLinkedList.display();
        myLinkedList.clear();
        myLinkedList.display();

    }
}

五、效果展示

在这里插入图片描述

摸鱼王胖嘟嘟
关注
  • 39
    点赞
  • 踩
  • 27
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 66
    评论
专栏目录
JAVA:实现使用链表实现堆栈算法(附完整源码)
希望我的博客，能帮上你解决学习中工作中所遇到的问题
08-10 221
JAVA:实现使用链表实现堆栈算法(附完整源码)
一步步带你用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实现双链表（数据结构.小白看懂版）
m0_49410492的博客
08-02 357
Java实现双链表（数据结构.小白看懂版）
java实现双链表
hangoer的博客
08-07 720
java实现双链表 ​ 双向链表也叫双链表，是链表的一种，它的每个数据结点中都有两个指针，分别指向直接后继和直接前驱。所以，从双向链表中的任意一个结点开始，都可以很方便地访问它的前驱结点和后继结点。一般我们都构造双向循环链表。 java实现 代码结构 public class Demo1{ //测试类 } class MyLinkedList<T>{ //链表类 class Node{ //节点类 } /** *功能实现 */ } 测试类 /** 双向链表数据结构实现
Java基于链表的栈的实现
timewilltell12的博客
03-26 2021
1、什么是栈 栈(Stack)是一种线性存储结构，它具有如下特点： （1）栈中的数据元素遵守”先进后出”(First In Last Out)的原则，简称FILO结构。 （2）限定只能在栈顶进行插入和删除操作。 2、栈的基本操作 栈主要有以下几种基本操作： （1）empty(): 如果栈为空返回true，否则返回false； （2）size(): 返回栈内元素的大小； （3）push(): 向栈内压入一个成员； （4）pop(): 从栈顶弹出一个成员； 3、具体代码（我们使用链表来完成基本操作，并且使
数据结构与算法 —— Java 实现（链表）
01-21
数据结构与算法 —— Java 实现（链表）一、单链表1.1 链表的定义1.2 链表添加一个新的节点1.3 判断当前节点是否为最后一个节点 （isLast）1.4 删除下一节点 （removeNext）1.5 显示节点信息（show）1.6 插入一个...
【Java数据结构与算法】双向链表
12-21
双向链表 单向链表的缺点分析 单向链表，查找的方向只能是一个方向，而双向链表可以向前或者向后查找 单向链表不能自我删除，需要靠辅助节点，而双向链表，则可以自我删除，所以前面删除单向链表节点时，需要找到...
数据结构与算法Java实现.zip
01-15
逻辑结构：描述数据元素之间的逻辑关系，如线性结构（如数组、链表）、树形结构（如二叉树、堆、B树...学习算法与数据结构不仅有助于理解程序的内部工作原理，更能帮助开发人员编写出高效、稳定和易于维护的软件系统。
详解java数据结构与算法之双链表设计与实现
08-30
双链表是一种重要的数据结构，它在Java编程中有着广泛的应用。相较于单链表，双链表在每个节点中不仅包含指向后继节点的`next`域，还包含一个指向前驱节点的`prev`域。这样的设计使得在双链表中进行节点的查找、插入...
数据结构与算法（Java实现）.zip
01-15
逻辑结构：描述数据元素之间的逻辑关系，如线性结构（如数组、链表）、树形结构（如二叉树、堆、B树...学习算法与数据结构不仅有助于理解程序的内部工作原理，更能帮助开发人员编写出高效、稳定和易于维护的软件系统。
Java实现双向链表(两个版本)
09-02
主要介绍了Java实现双向链表(两个版本)的相关资料,需要的朋友可以参考下
双向链表（java实现）
04-09
NULL 博文链接：https://128kj.iteye.com/blog/1643350
JAVA双向链表反转实现
06-10
通过java实现的双向链表，及反转功能，可能对面试有用哦
java实现自己的单链表、双链表、Map存储
09-02
java实现自己的单链表、双链表、Map存储,java实现自己的单链表、双链表、Map存储
线性表-链式实现-双向链表
like5103613的专栏
04-03 340
双向链表也叫双链表，是链表的一种，它的每个数据结点中都有两个指针，分别指向直接后继和直接前驱。所以，从双向链表中的任意一个结点开始，都可以很方便地访问它的前驱结点和后继结点。一般我们都构造双向循环链表。 其实链表都差不多了，双向链表就是每个节点有两个指针，一个指向后一个节点，一个指向前一个节点。
Java实现双向链表
小小太空人的博客
09-25 512
不论是单链表还是双向链表，都有自己特殊的结构，由于单链表找尾节点，和找上一个节点的时间复杂度都是O(n)，在这个基础上提出了双向链表的结构，并且有专门的引用去指向尾节点。双向链表具有前驱和后继引用，即每一个节点都可以找到上一个和下一个节点，那么对于链表的一些操作就变得简单起来。对于链表的释放，由于对象是没有被引用后，才会被JVM回收。这里的每一个节点都被两个引用所引用，那么就需要切断每一个节点间的引用，然后再将head和tail置空，这样整个链表都会被JVM回收。
java实现双向循环链表（循环双链表）
初心不忘、始终方得
04-20 5543
若是不清楚链表的结构，该篇文章不适合观看，这里只做文字说明，没有链表结构的图示
数据结构_双向循环链表的java实现
叶清逸的博客
07-27 1056
这篇文章讲述的是数据结构部分的内容的java实现，如有错误或者不当之处，还望各位大神批评指正。 双向循环链表的特点 物理结构不连续逻辑结构连续 删除和添加操作方便 顺序储存随数据量的增大而增大 查询操作不方便 从任意一个节点可以访问整个链表 双向循环链表的基本操作 init:初始化顺序表 destroy：销毁数据表 clear：清空数据表中的元素 length：获取数据表长度 get...
数据结构与算法 全 数据结构与算法全 Java
最新发布
03-04
**习题** 部分提供了各种基于所学概念的实际编程练习，涵盖了LeetCode上的经典问题，如二分查找、链表操作、递归问题等，这些都是检验和巩固数据结构与算法理解的好方法。 学习数据结构与算法不仅可以提高编程能力...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

摸鱼王胖嘟嘟

你的鼓励将是我创作的最大动力

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

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

打赏作者

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

抵扣说明：

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

余额充值