手撕双向链表LinkedList的部分常用方法

最新推荐文章于 2024-05-17 16:02:19 发布
最新推荐文章于 2024-05-17 16:02:19 发布
阅读量307 收藏
点赞数
文章标签： 双向链表 数据结构 增删查改 二分查找 节点操作
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ITsheng_ge/article/details/125709185
版权

定义节点结构

    //定义节点结构
    static class Node<E>{
        Node<E> prev;   //定义头部
        Node<E> next;   //定义尾部
        E element;      //存储数据

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

定义链表结构

    //定义双向链表结构
    Node<E> first;      //定义头结点
    Node<E> last;       //定于尾节点
    int size;           //记录双向链表中不为null的节点数
    //双向链表的无参构造方法
    public MyLinkedList01(){}

定义查找目标位置的方法，并返回节点

    //定义查找指定位置的方法，并返回目标节点
    //利用的是二分查找法
    public Node<E> node(int index){
        if (index < (size >> 1)){   //当索引小于长度的一半的时候在左边遍历
            Node<E> x = first;      //把头节点取出
            for (int i = 0; i < index; i++) {   //左半边遍历
                x = x.next;         //找出目标索引的下一个节点
            }
            return x;               //返回该节点
        }else {
            Node<E> x = last;       //把尾节点取出
            for (int i = size - 1; i > index; i--) {    //右半边遍历
                x = x.prev;     //找出目标索引的前一个节点
            }
            return x;           //返回该节点
        }
    }

定义添加头结点的方法

    //头部增加节点方法
    public void addFirst(E element){
        Node<E> f = first;  //先取出原来的头结点
        Node<E> newNode = new Node<>(null, element, f);     //新建一个节点作为新的头结点：头部置null，尾部指向原来的头结点
        first = newNode;    //把新节点定义为头结点
        if (f == null) {    //如果之前的头结点为null，那么说明新建的节点既是头结点也是尾节点
            last = newNode;
        }else {             //否则，原来的头结点的头部指向新建的头结点
            f.prev = newNode;
        }
        size++;             //节点数加1
    }

定义添加尾节点的方法

    //尾部添加方法
    public void addLast(E element){
        Node<E> l = last;   //先取出尾部节点
        Node<E> newNode = new Node<>(l, element, null);     //新建一个节点作为新的尾节点：头部为原来的尾节点，尾部为null
        last = newNode;     //把新建的节点作为尾节点
        if (l == null){     //如果原来的尾节点为空，那么新建的节点既是头结点也是尾节点
            first = newNode;
        }else {             //否则，原来尾节点的尾部指向新建的节点的头部
            l.next = newNode;
        }
        size++;     //节点数加1
    }

定义中间插入的方法

    //中间插入方法
    public void add(int index, E element){
        if (!(index >= 0 && index <= size)){    //先判断索引是否越界
            throw new RuntimeException("索引越界异常！");
        }
        if (index == size) {        //index永远小于size，如果index == size则说明链表为空，此时我们可以使用头结点添加方法
            addFirst(element);
        }else {                 //链表不为空
            Node<E> x = node(index);        //先通过索引查找找出目标节点
            Node<E> f = x.prev;             //把目标节点的前一个节点取出
            Node<E> newNode = new Node<>(f, element, x);    //新建一个节点：头部为目标节点的前一个节点，尾部为目标节点
            x.prev = newNode;           //目标节点的头部指向新建的节点
            if (f == null) {        //如果目标节点的前一个节点为空，那么新建的节点就是链表的头部节点
                first = newNode;
            }else {                 //如果目标节点的前一个节点不为空，那么目标节点的前一个节点的尾部指向新建节点的头部
                f.next = newNode;
            }
            size++;         //节点个数加1
        }
    }

定义删除头结点的方法

    //删除头结点方法
    public E removeFirst(){
        Node<E> f = first;  //先取出头结点
        if (f == null) {        //如果头结点为空，则提示链表为空
            throw new RuntimeException("链表为空，无法删除！");
        }
        E remove = first.element;   //取出要删除的数据
        Node<E> l = f.next;         //取出目标节点的下一个节点
        f.element = null;           //把要删除节点的数据清空
        f.next = null;
        first = l;                  //要删除节点的下一个节点为新的头结点
        if (l == null){             //如果要删除的下一个节点为空，则表示删除完之后的链表为空
            last = null;
        }else {                     //否则把新成为头部节点的头部置空
            l.prev = null;
        }
        size--;                     //节点个数减1
        return remove;              //返回被删除节点的数据
    }

定义删除尾节点的方法

    //删除尾节点方法
    public E removeLast(){
        Node<E> l = last;       //先取出尾节点
        if (l == null) {        //如果尾节点为空的话，说明链表为空
            throw new RuntimeException("链表为空，无法删除！");
        }
        E remove = l.element;       //先取出要删除节点的数据
        Node<E> f = l.prev;         //取出要删除节点的前一个节点
        l.prev = null;              //把要删除的节点的数据清空
        l.element = null;
        last = f;                   //把要删除的节点的前一个节点作为尾节点
      if (f == null) {              //如果要删除节点的前一个节点为空的话，那么删除节点之后链表就为空了
            first = null;
        }else {                     //不为空的话，就把要删除节点的尾部置空
            f.next = null;
        }
        size--;                     //节点个数减1
        return remove;              //返回被删除的数据
    }

定义中间删除的方法

    //中间删除方法
    public E remove(int index){
        //先判断索引是否越界
        if (!(index >= 0 && index <= size)){
            throw new RuntimeException("索引越界异常！");
        }
        Node<E> x = node(index);        //找出要删除的节点位置
        E remove = x.element;           //把要删除节点的数据取出
        Node<E> f = x.prev;             //把要删除节点的前一个节点取出
        Node<E> l = x.next;             //把要删除节点的后一个节点取出
        if (f == null){                 //如果要删除节点的前一个节点为空，那么要删除节点的后一个节点就是头结点
            first = l;
        }else {                         //不为空的话，把要删除节点的前一个节点的尾部指向要删除节点的后一个节点的头部
            f.next = l;
            x.prev = null;              //并把要删除节点的头部置空
        }
        if (l == null) {                //如果要删除节点的后一个节点为空，那么要删除节点的前一个节点就是尾节点
            last = f;
        }else {                         //不为空的话，就把要删除节点的后一个节点的头部指向要删除节点的前一个节点的尾部
            l.prev = f;
            x.next = null;              //并把要删除节点额尾部置空
        }
        x.element = null;               //把要删除节点的数据清空
        size--;                         //节点数减1
        return remove;                  //返回被删除的数据
    }

定义修改节点数据的方法

    //修改节点数据方法
    public E set(int index,E element){
        //先判断索引是否越界
        if (!(index >= 0 && index <= size)){
            throw new RuntimeException("索引越界异常！");
        }
        Node<E> x = node(index);       //找出目标节点
        E old = x.element;              //取出目标节点的数据并赋给一个变量
        x.element = element;            //把新数据插进去
        return old;                     //返回被修改的数据
    }

定义取值器方法

    //取值器
    public E get(int index){
        //先判断索引是否越界
        if (!(index >= 0 && index <= size)){
            throw new RuntimeException("索引越界异常！");
        }
        //返回目标节点的数据
        return node(index).element;
    }

定义获取节点数量方法

    //定义获取节点数量方法
    public int getSize(){
        return size;
    }

原码

public class MyLinkedList01<E> {
    //定义双向链表结构
    Node<E> first;      //定义头结点
    Node<E> last;       //定于尾节点
    int size;           //记录双向链表中不为null的节点数
    //双向链表的无参构造方法
    public MyLinkedList01(){}

    //定义节点结构
    static class Node<E>{
        Node<E> prev;   //定义头部
        Node<E> next;   //定义尾部
        E element;      //存储数据

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


    //定义查找指定位置的方法，并返回目标节点
    //利用的是二分查找法
    public Node<E> node(int index){
        if (index < (size >> 1)){   //当索引小于长度的一半的时候在左边遍历
            Node<E> x = first;      //把头节点取出
            for (int i = 0; i < index; i++) {   //左半边遍历
                x = x.next;         //找出目标索引的下一个节点
            }
            return x;               //返回该节点
        }else {
            Node<E> x = last;       //把尾节点取出
            for (int i = size - 1; i > index; i--) {    //右半边遍历
                x = x.prev;     //找出目标索引的前一个节点
            }
            return x;           //返回该节点
        }
    }

    //头部增加节点方法
    public void addFirst(E element){
        Node<E> f = first;  //先取出原来的头结点
        Node<E> newNode = new Node<>(null, element, f);     //新建一个节点作为新的头结点：头部置null，尾部指向原来的头结点
        first = newNode;    //把新节点定义为头结点
        if (f == null) {    //如果之前的头结点为null，那么说明新建的节点既是头结点也是尾节点
            last = newNode;
        }else {             //否则，原来的头结点的头部指向新建的头结点
            f.prev = newNode;
        }
        size++;             //节点数加1
    }

    //尾部添加方法
    public void addLast(E element){
        Node<E> l = last;   //先取出尾部节点
        Node<E> newNode = new Node<>(l, element, null);     //新建一个节点作为新的尾节点：头部为原来的尾节点，尾部为null
        last = newNode;     //把新建的节点作为尾节点
        if (l == null){     //如果原来的尾节点为空，那么新建的节点既是头结点也是尾节点
            first = newNode;
        }else {             //否则，原来尾节点的尾部指向新建的节点的头部
            l.next = newNode;
        }
        size++;     //节点数加1
    }

    //中间插入方法
    public void add(int index, E element){
        if (!(index >= 0 && index <= size)){    //先判断索引是否越界
            throw new RuntimeException("索引越界异常！");
        }
        if (index == size) {        //index永远小于size，如果index == size则说明链表为空，此时我们可以使用头结点添加方法
            addFirst(element);
        }else {                 //链表不为空
            Node<E> x = node(index);        //先通过索引查找找出目标节点
            Node<E> f = x.prev;             //把目标节点的前一个节点取出
            Node<E> newNode = new Node<>(f, element, x);    //新建一个节点：头部为目标节点的前一个节点，尾部为目标节点
            x.prev = newNode;           //目标节点的头部指向新建的节点
            if (f == null) {        //如果目标节点的前一个节点为空，那么新建的节点就是链表的头部节点
                first = newNode;
            }else {                 //如果目标节点的前一个节点不为空，那么目标节点的前一个节点的尾部指向新建节点的头部
                f.next = newNode;
            }
            size++;         //节点个数加1
        }
    }

    //取值器
    public E get(int index){
        //先判断索引是否越界
        if (!(index >= 0 && index <= size)){
            throw new RuntimeException("索引越界异常！");
        }
        //返回目标节点的数据
        return node(index).element;
    }

    //修改节点数据方法
    public E set(int index,E element){
        //先判断索引是否越界
        if (!(index >= 0 && index <= size)){
            throw new RuntimeException("索引越界异常！");
        }
        Node<E> x = node(index);       //找出目标节点
        E old = x.element;              //取出目标节点的数据并赋给一个变量
        x.element = element;            //把新数据插进去
        return old;                     //返回被修改的数据
    }

    //删除头结点方法
    public E removeFirst(){
        Node<E> f = first;  //先取出头结点
        if (f == null) {        //如果头结点为空，则提示链表为空
            throw new RuntimeException("链表为空，无法删除！");
        }
        E remove = first.element;   //取出要删除的数据
        Node<E> l = f.next;         //取出目标节点的下一个节点
        f.element = null;           //把要删除节点的数据清空
        f.next = null;
        first = l;                  //要删除节点的下一个节点为新的头结点
        if (l == null){             //如果要删除的下一个节点为空，则表示删除完之后的链表为空
            last = null;
        }else {                     //否则把新成为头部节点的头部置空
            l.prev = null;
        }
        size--;                     //节点个数减1
        return remove;              //返回被删除节点的数据
    }

    //删除尾节点方法
    public E removeLast(){
        Node<E> l = last;       //先取出尾节点
        if (l == null) {        //如果尾节点为空的话，说明链表为空
            throw new RuntimeException("链表为空，无法删除！");
        }
        E remove = l.element;       //先取出要删除节点的数据
        Node<E> f = l.prev;         //取出要删除节点的前一个节点
        l.prev = null;              //把要删除的节点的数据清空
        l.element = null;
        last = f;                   //把要删除的节点的前一个节点作为尾节点
      if (f == null) {              //如果要删除节点的前一个节点为空的话，那么删除节点之后链表就为空了
            first = null;
        }else {                     //不为空的话，就把要删除节点的尾部置空
            f.next = null;
        }
        size--;                     //节点个数减1
        return remove;              //返回被删除的数据
    }

    //中间删除方法
    public E remove(int index){
        //先判断索引是否越界
        if (!(index >= 0 && index <= size)){
            throw new RuntimeException("索引越界异常！");
        }
        Node<E> x = node(index);        //找出要删除的节点位置
        E remove = x.element;           //把要删除节点的数据取出
        Node<E> f = x.prev;             //把要删除节点的前一个节点取出
        Node<E> l = x.next;             //把要删除节点的后一个节点取出
        if (f == null){                 //如果要删除节点的前一个节点为空，那么要删除节点的后一个节点就是头结点
            first = l;
        }else {                         //不为空的话，把要删除节点的前一个节点的尾部指向要删除节点的后一个节点的头部
            f.next = l;
            x.prev = null;              //并把要删除节点的头部置空
        }
        if (l == null) {                //如果要删除节点的后一个节点为空，那么要删除节点的前一个节点就是尾节点
            last = f;
        }else {                         //不为空的话，就把要删除节点的后一个节点的头部指向要删除节点的前一个节点的尾部
            l.prev = f;
            x.next = null;              //并把要删除节点额尾部置空
        }
        x.element = null;               //把要删除节点的数据清空
        size--;                         //节点数减1
        return remove;                  //返回被删除的数据
    }

    //定义获取节点数量方法
    public int getSize(){
        return size;
    }
}
ITsheng_ge
关注
真金不怕火练：如何用双向链表实现LRU淘汰机制算法
yaotai8135的博客
09-22 265
无论是应届生的春招、秋招还是社招，难以避免的一关都是要面对面试官来几个手撕算法，如果你参加过几次面试，就知道链表出现的频率是极其高的。 上一篇文章主要给大家讲解了链表的一些类型，包括：单向链表、双向链表以及循环链表，同时还给出了不同链表的代码实现，做一些简单的增删改查。 那么本章将提高一点难度，为你介绍常见的链表算法，包括一些 BAT 等大厂的笔试面试题，同时最后彩蛋里将详细的介绍可以称之为链表笔...
❤️用武侠小说的形式来阅读LinkedList的源码，绝了！
沉默王二
09-03 2131
一、LinkedList 的剖白 大家好，我是 LinkedList，和 ArrayList 是同门师兄弟，但我俩练的内功却完全不同。师兄练的是动态数组，我练的是链表。 问大家一个问题，知道我为什么要练链表这门内功吗？ 举个例子来讲吧，假如你们手头要管理一推票据，可能有一张，也可能有一亿张。 该怎么办呢？ 申请一个 10G 的大数组等着？那万一票据只有 100 张呢？ 申请一个默认大小的数组，随着数据量的增大扩容？要知道扩容是需要重新复制数组的，很耗时间。 关键是，数组还有一个弊端就是，假如现在有 500
从零开始手撕一个数据结构（1）——双向链表
Yuc0114的博客
08-21 1242
前言 刚做完某厂的笔试，要求实现一个LRU算法，没有复习到LRU的我直接就凉了一半了 闲着没事把数据结构都过一遍吧，加深一下印象 作为《从零开始手撕一个数据结构》的第一篇，先从最简单的链表开始吧~ 文章目录前言一、要实现一个什么样的结构？二、实现步骤1. 核心定义1） 创建链表容器类LinkedList2）定义链表核心内部类ListNode2. 方法实现1）添加元素的add方法2）查询元素的get方法3）删除元素的remove方法4）修改元素的set方法5）返回当前链表长度的size方法总结 一、要实
【手撕算法】 双向链表
ZHAOJING1234567的博客
05-15 512
package test; import org.junit.Test; import java.util.Iterator; public class DoubleList<T> { int size; Node<T> head; Node<T> last; private static class Node<T...
【数据结构】手撕双向链表
m0_68662723的博客
11-15 861
在上一期中我们介绍了单链表，也做了一些练习题，在一些题中使用单链表会十分繁琐。因为单链表只能正着走，不能倒着走，例如：回文、逆置。本期我们将学习带头双向循环链表。
手撕数据结构之双向链表
最新发布
liu3290607528的博客
05-17 491
本文章主要讲述了双向链表的实现以及容易出错的地方，有做的不够好的欢迎大佬们进行指正！！！
三分钟带你手撕带头双向循环链表
暴躁小吕的博客
10-26 1094
我们从进入数据结构模块开始，首先学习了顺序表，顺序表其实就是数组，它需要一组连续的物理空间来存储数据，所以它的缺点很明确，但是优点就是查找起来很方便，可以根据下标直接访问，然后我们学习了单链表，单链表就弥补了顺序表必须是连续物理空间的缺点，它的特点是不需要连续的空间，每个结点通过指针来连接，但是它的缺点也很明显就是查找起来很麻烦，如果想要在指定位置插入数据，或者头插等功能不容易找到对应的位置，往往需要设置一个或多个指针来达到目的，所以我们今天来讲一下双向链表。
【手撕Java集合】Map容器概述以及常用子类HashMap、LinkedHashMap详解（附部分源码）
aaa_hao的博客
02-25 911
文章目录一、Map 集合概述1. 什么是 Map？2. Map 和 Collection 的区别3. Map 的结构体系4. Map 的基础功能5. Map 集合常用子类二、HashMap1. HashMap 的属性2. HashMap 的构造器3. put 方法4. resize 方法5. get 方法6. remove 方法三、LinkedHashMap1. LinkedHashMap 的属性2. LinkedHashMap 的构造方法3. newNode 方法4. LinkNodeLast 方法5.
手撕算法
Cm's blog
03-14 1491
算法梳理动态规划      1、最小路径和      2、最长上升子序列      3、三角形      4、找零钱      5、最大字段和     &nbsp
数据结构：手撕图解双向循环链表
海绵宝宝de派小星的博客
07-10 4435
双向循环链表的手撕实现和图解 分析对比其与单链表的差异
Java链表进阶=====手撕无头双向链表
qq_56146092的博客
01-28 899
双向链表的学习+手动分析
板鸭带你手撕C语言双向链表
sqm_C的博客
11-11 113
我们都知道双向链表有四种，分别是：双向带头循环链表，双向带头不循环链表，双向不带头循环链表，双向不带头不循环链表。这里我们就讲双向带头循环链表。为什么要讲这一种链表呢？因为双向带头循环链表在实际生活中的使用非常广泛，而且我们只需要了解这一种双向链表，其他三种双向链表我们也会很容易掌握。下图就是我们带头双向链表的逻辑结构。注意：这里的“带头”跟前面我们说的“头节点”是两个概念，实际前面的在单链表阶段称呼不严 谨，但是为了同学们更好的理解就直接称为单链表的头节点。
od面试手撕代码：实现双向链表
互关，互粉，互学。
04-19 44
在指定索引插入：遍历链表，找到指定索引位置的节点，将新节点插入到该位置。以上是实现双向链表的基本思路，通过合理的数据结构和算法实现，可以高效地对链表进行插入和删除操作。根据值删除：遍历链表，找到第一个值与给定值相等的节点，将该节点从链表中删除。显示操作：提供一个方法用于显示链表中的所有节点的数据，以便验证插入和删除操作是否正确。在头部插入：如果要在链表的头部插入节点，只需创建一个新节点，将其。类，表示链表中的节点。指向新节点，并将新节点设置为头节点即可。根据值删除链表中的节点。在链表头部插入新节点。
教你手撕链表
qq_52390903的博客
05-03 1351
链表的概念 链表是由许多相同数据类型的数据项，按照特定顺序排列而成的线性表。但链表的特性是其各个数据项在计算机内存中存储的位置是不连续且随机存放的，其优点是数据的插入或者删除都相当的方便呢，有新数据加入就向系统申请一块内存空间，而数据删除之后，就可以把这块内存空间还给系统，加入和删除都不需要移动大量的数据。缺点是在查找数据使，无法向数组那样可以随机数据，必须按序查找到该数据为止。 火车就可以看做一个链表 单向链表 一个单向链表节点由两个元素，一个是数据字段和指针多组成，指针会指向下一个节点的..
26_1集合实现类研究底层（部分）：手撕ArrayList底层源码、手撕LinkedList底层源码、手写单向链表和双向链表
gangain的博客
03-09 797
手撕实现类1.手撕ArrayList底层源码2.手撕LinkedList底层源码ArrayList 和 LinkedList的效率区别手写单向链表手写双向链表。
Lectcode手撕算法（C++）
zhangqin__的博客
08-25 403
Lectcode手撕算法 两数之和 删除数组中的重复项 移除元素 整数反转 回文数 最长公共前缀 合并两个有序链表 有效括号 lectcode-1:两数之和： 题目：https://leetcode-cn.com/problems/two-sum/ 解答： class Solution { public: vector<int> twoSum(vector<int&g...
C++实现双链表【每一步详细深入讲解，代码清晰、简单、易懂】
weixin_55755506的博客
12-04 2852
双链表节点由存储的数据、指向前一个元素的指针和指向后一个元素的指针构成，因此双联表节点的代码也很容易得到，如下： 双链表和单链表类似，也需要添加、删除和查找。 1、插入操作 插入的情况说明：插入每次都在第一个位置插入，也就是在伪头节点（不含元素）后插入。插入节点的过程：插入的代码逻辑： 2、删除操作 将目标节点的下一个节点的指针指向目标节点的前一个节点（目标节点下一个节点不存在则省略） 将目标节点的前一个节点的指针指向目标节点的下一个节点 代码逻辑： 3、查找操作 不同于单链表，双链表查找直接返回目
双向链表二分查找
packge的博客
09-11 628
双向链表二分查找
数据结构——C++中实现双链表（含完整代码）
huaimaisui的博客
07-10 2708
双链表相关代码。 1、创建双链表(-1结束) 2、遍历双链表 3、插入双链表元素 4、双链表删除元素 5、判断双链表是否为空 6、双链表的长度 7、查找双链表元素 0、退出程序 纯手打，亲测可以运行，使用自取。............
Python双向链表实例代码详解及操作方法
这些方法共同构建了一个可操作的双向链表，允许对链表进行常见的插入、删除、访问和判断是否为空等操作。在实际编程中，这个双向链表结构可以应用于各种需要频繁插入和删除元素，同时需要保持前后关系的场景，例如...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值