Java单向链表(黑马)

已于 2023-03-28 21:07:47 修改
阅读量96 收藏 1
点赞数
分类专栏： java数据结构与算法 文章标签： 链表 java 数据结构
于 2023-03-28 16:26:41 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_53184944/article/details/129818197
版权

概述

在计算机科学中，链表是数据元素的线性集合，其每个元素都指向下一个元素，元素存储上并不连续。

性能

随机访问性能

根据 index 查找，时间复杂度 O ( n ) O(n) O(n)

插入或删除性能

  • 起始位置： O ( 1 ) O(1) O(1)
  • 结束位置：如果已知 tail 尾节点是 O ( 1 ) O(1) O(1)，不知道 tail 尾节点是 O ( n ) O(n) O(n)
  • 中间位置：根据 index 查找时间 + O ( 1 ) O(1) O(1)

在这里插入图片描述

图示

头插（中间插入与尾插相差不大，大家可尝试自己画图理解）

  • 新建value为1的节点；
    在这里插入图片描述
  • 将head指向新节点
    在这里插入图片描述

遍历

  • 新建了一个指针p指向了head指向的节点不为空则向后移动（相当p = p.next）：
    在这里插入图片描述
    在这里插入图片描述
  • 直到移动到指向为null之后结束（p = p.next =null）
    删除（头部、尾部、中间删除差距不大自己可以尝试画图理解）
  • 只用将head指向head.next即可
    在这里插入图片描述
  • Java中引用不到的节点会通过gc回收机制自动回收，不会占用内存（例如1这个节点）
    在这里插入图片描述

案例

根据单向链表的定义，首先定义一个存储 value 和 next 指针的类 Node，和一个描述头部节点的引用

public class SinglyLinkedList {
    
      private Node head = null; //头指针
    
    /*
     *  节点类
     * */
   private static class Node{  //内部类（不用对外暴露内部结构）
        int value; //值
        Node next; //下一个节点指针

        public Node(int value, Node next) {
            this.value = value;
            this.next = next;
        }
    }
}
  • Node定义为内部类，是为了对外隐藏实现细节，没必要让类的使用者关心 Node 结构
  • 定义为 static 内部类，是因为 Node 不需要与 SinglyLinkedList 实例相关，多个 SinglyLinkedList实例能共用 Node 类定义。

头部添加

 public void addFirst(int value) {
       // 1. 链表为空
//        Node node = new Node(value, null);    //创建一个新节点
//        head = node;     //将head 的next指针指向这个创建的节点
//        head = new Node(value, null);  //这个时浓缩版本
        // 2. 链表非空 (既能处理非空也能处理为空)
        head =  new Node(value, head);
    }
  • new一个节点然后将head指针指向这个新结点，如果是首次添加则新节点的next指针因该为null（第一次的话haed也为null所以可以这样写代表两个情况），反之因该为head指向的地址（画图体会）
  • 这里head中存的是地址

while 遍历

//遍历
    public void loop1(Consumer<Integer> consumer) {
       Node p = head;  //初始应该指向头指针指向的节点
        while (p != null) {
           consumer.accept(p.value);
            p = p.next; //处理完当前节点之后在在指向下一个节点
        }
    }

while 遍历

 public void loop2(Consumer<Integer> consumer) {
        for (Node p = head; p != null; p = p.next ) {
            consumer.accept(p.value);
        }
    }
  • 以上两种遍历都可以把要做的事以 Consumer 函数的方式传递进来
    • Consumer 的规则是一个参数，无返回值，因此像 System.out::println 方法等都是 Consumer
    • 调用 Consumer 时，将当前节点 p.value 作为参数传递给它

迭代器遍历

 @Override
    public Iterator<Integer> iterator() {


        return new Iterator<Integer>() {
            Node p = head;
            @Override
            public boolean hasNext() { //是否有下一个元素
                return p != null;
            }

            @Override
            public Integer next() { //返回当前元素并指向，下一个元素
                int v = p.value;
                p = p.next;
                return v;
            }
        };
    }

  • hasNext 用来判断是否还有必要调用 next

  • next 做两件事

    • 返回当前节点的 value
    • 指向下一个节点

    递归遍历

  public class SinglyLinkedList implements Iterable<Integer> {
   // ...
   public void loop() {
       recursion(this.head);
   }

   private void recursion(Node curr) {
       if (curr == null) {
           return;
       }
       // 前面做些事
       recursion(curr.next);
       // 后面做些事
   }
}

尾部添加

先查找出最后的节点

 //查找最后一个节点
    private Node findLast() {
       Node p;
       if (head == null){ //空链表
       return null;
       }
       for (p = head; p.next != null; p = p.next) { //问题，如果head为null ，则p.next 报空指针了

       }
       return p;
    }

 //尾插
    public void addLast(int value) {
       Node last = findLast();
       if(last == null) {
           addFirst(value);
           return ;
       }
       last.next = new Node(value, null);

    }

查找结点（utils）

 // 查找Node 节点
    private Node findeNode(int index) {
        int i = 0;
        for(Node p = head; p != null; p = p.next, i++) {
            if(i == index) {
                return p;
            }
        }
        return null; //没有找到
    }

对外开放的查找所在索引值的value

//对外返回索引节点的值
    public int get(int index) {
        Node node = findeNode(index);
        if(node == null) {
            IllegalIndex(index);
        }
        return node.value;
    }

向索引位置加入新节点

// 向索引位置加入新节点
    public void insert(int index, int value) {
        if (index == 0) {
            addFirst(value);
            return;
        }
        Node prev = findeNode(index - 1);//找到上一个节点
        if(prev == null) IllegalIndex(index);
        //创建一个新节点，让perv指向下一个节点的next指针给到新节点，然后自己又指向这个创建的节点
        prev.next = new Node(value,prev.next);
    }

一个异常封装

 private static IllegalArgumentException IllegalIndex(int index) {
        throw new IllegalArgumentException(String.format("index [%d] 不合法%n", index)); //不合法参数
    }

全部代码：

package com.itheima.datastructure;

//单项链表

import java.util.Iterator;
import java.util.function.Consumer;

public class SinglyLinkedList implements Iterable<Integer> { //整体

    private Node head = null; //头指针

    /*
     *  节点类
     * */
   private static class Node{  //内部类（不用对外暴露内部结构）
        int value; //值
        Node next; //下一个节点指针

        public Node(int value, Node next) {
            this.value = value;
            this.next = next;
        }
    }


    //头茬
    public void addFirst(int value) {
       // 1. 链表为空
//        Node node = new Node(value, null);    //创建一个新节点
//        head = node;     //将head 的next指针指向这个创建的节点
//        head = new Node(value, null);  //这个时浓缩版本
        // 2. 链表非空 (既能处理非空也能处理为空)
        head =  new Node(value, head);
    }

    //遍历
    public void loop1(Consumer<Integer> consumer) {
       Node p = head;  //初始应该指向头指针指向的节点
        while (p != null) {
           consumer.accept(p.value);
            p = p.next; //处理完当前节点之后在在指向下一个节点
        }
    }

    public void loop2(Consumer<Integer> consumer) {
        for (Node p = head; p != null; p = p.next ) {
            consumer.accept(p.value);
        }
    }

    @Override
    public Iterator<Integer> iterator() {


        return new Iterator<Integer>() {
            Node p = head;
            @Override
            public boolean hasNext() { //是否有下一个元素
                return p != null;
            }

            @Override
            public Integer next() { //返回当前元素并指向，下一个元素
                int v = p.value;
                p = p.next;
                return v;
            }
        };
    }

    //查找最后一个节点
    private Node findLast() {
       Node p;
       if (head == null){ //空链表
       return null;
       }
       for (p = head; p.next != null; p = p.next) { //问题，如果head为null ，则p.next 报空指针了

       }
       return p;
    }
    //尾插
    public void addLast(int value) {
       Node last = findLast();
       if(last == null) {
           addFirst(value);
           return ;
       }
       last.next = new Node(value, null);

    }


    // 查找Node 节点
    private Node findeNode(int index) {
        int i = 0;
        for(Node p = head; p != null; p = p.next, i++) {
            if(i == index) {
                return p;
            }
        }
        return null; //没有找到
    }

    //对外返回索引节点的值
    public int get(int index) {
        Node node = findeNode(index);
        if(node == null) {
            IllegalIndex(index);
        }
        return node.value;
    }

    // 向索引位置加入新节点
    public void insert(int index, int value) {
        if (index == 0) {
            addFirst(value);
            return;
        }
        Node prev = findeNode(index - 1);//找到上一个节点
        if(prev == null) IllegalIndex(index);
        //创建一个新节点，让perv指向下一个节点的next指针给到新节点，然后自己又指向这个创建的节点
        prev.next = new Node(value,prev.next);
    }

    private static IllegalArgumentException IllegalIndex(int index) {
        throw new IllegalArgumentException(String.format("index [%d] 不合法%n", index)); //不合法参数
    }

    public int size() {
       int i = 0;
       for (Node p = head; p != null; p = p.next, i++) {

       }

       return i;
    }

    // 删除第一个节点
    public void removeFirst() {
       if(head == null){
           throw IllegalIndex(0);
       }
        head = head.next; //head头指针指向第二个节点 java中会自动清理内存
    }

    //根据index删除
    public void remove(int index) {
       if (index == 0) {
           removeFirst();
           return;
       }
       Node prev = findeNode(index - 1); //找到上一个节点
        if (prev == null) throw IllegalIndex(index); //没有查到节点（前一个结点差不到，那么后面也不会存在）
        Node removed = prev.next; //将要被删除的节点
        //这个问题出现在删除的节点的上一个节点是最后一个节点的情况(前一个能找到，但是待删除节点不存在)
        if (removed == null) throw IllegalIndex(index);

        prev.next = removed.next;

    }

}
Aholic 冲冲冲
关注
专栏目录
Java:实现反转一个单链表算法（附完整源码）
希望我的博客，能帮上你解决学习中工作中所遇到的问题
09-01 218
Java:实现反转一个单链表算法（附完整源码）
【算法篇】四种链表总结完毕，顺手刷了两道面试题紧张的羊
weixin_70730532的博客
06-30 925
今日目录：1：能够说出链表的存储结构和特点2：能够说出链表的几种分类及各自的存储结构3：能说出链表和数组的差异4：完成实战演练题目5：完成综合案例链表（Linked list）是一种物理存储单元上非连续、非顺序的存储结构，链表中的每一个元素称之为结点（Node），结点之间用指针（引用）连接起来，指针的指向顺序代表了结点的逻辑顺序，结点可以在运行时动态生成。每个结点包括两个部分：一个是存储数据元素的数据域，另一个是存储下一个结点地址的指针域。链表根据其结点之间的连接形式我们又可分为：单链表，双向链表，循环链表
java链表代码_Java单向链表代码。
weixin_42116713的博客
02-21 119
publicclassSingleLinkedList{publicSingleLinkDataFirstNode;publicintlength;//初始化链表，也就是首节点为空。publicvoidInitiate(){FirstNode=null;}//求链表的长度，做循环，当最...public class SingleLinkedList {public SingleLinkData F...
JAVA实现单链表【代码】
m0_63668314的博客
08-21 329
JAVA实现单链表【代码】
Java进阶：自定义单向链表
qq_52130567的博客
08-12 572
整体设计思路：1. 链表元素都是由结点构成的，这种结点有两个用处：1. 存数据 2. 存逻辑上相邻结点的指针，本次要做一个单向链表，结点只需要两个属性：1. 当前元素值 2. 后驱指针//由于元素是引用类型，所以不管是什么类型都是Object的子类型Node next;public Node(Object elem) {//本次为了凸显结点指针移动的过程，没有写全参构造}}2. 创建链表类继承List接口，属性中加入一个头结点（引导访问指针）和一个计数器（统计元素个数）......
java 单向链表类
许诗宇的博客
09-18 2581
package datastructure.linklist; public class LinkList { public class ListNode { public int val; public ListNode next; ListNode(int x) { val = x; next=null; } p...
Java实现单链表（步骤详解+源码）
GSCY
10-14 7327
Java实现单链表（步骤详解+源码） 欢迎大家提出问题，一起学习！
黑马程序员java数据结构教程源码
最新发布
01-13
链表分为单向链表、双向链表和循环链表等类型，它们在插入和删除操作上比数组更灵活。 3. **栈**：栈是一种后进先出（LIFO）的数据结构，常用于表达式求值、递归、函数调用等场景。Java中可以使用ArrayDeque或...
mysql的索引
m0_55613022的博客
05-15 139
1、索引的概述 来自于黑马教程：https://www.bilibili.com/video/BV1Kr4y1i7ru?p=69，快去看吧。草，卷起来 1、索引的介绍 索引(index）是帮助MysQL高效获取数据 的 数据结构(有序)。在数据之外，数据库系统还维护着满足特定查找算法的数据结构，这些数据结构以某种方式引用（指向）数据，这样就可以在这些数据结构上实现高级查找算法，这种数据结构就是索引。 2、索引的优缺点 2、索引的结构 MySQL的索引是在 存储 引擎层 实现的，不同的存储引擎有不同的结
集合进阶-Java入门-黑马程序员2022年新视频DAY23笔记
weixin_56633661的博客
03-13 218
集合进阶知识。包括了泛型的说明，每个集合的一些底层原理，使用的数据结构，以及不同集合对应的不同的使用场景。
Java数据结构--单链表
m0_74808313的博客
04-21 1389
我们在实现单向链表之前，先了解一下Java API中LinkedList类的方法摘要，并学会如何去创建使用链表，熟练运用其中常用的几种方法(增删差)下面为LinkedList类中的所有方法摘要看到这么多方法，是不是头都大了，但不要慌，我们只需熟练掌握其中最常用的几种方法即可，其余的只需了解。下面我们来运行一下其中最常用的几种方法(我们要实现的也是以下主要方法)addFirst(元素) 将指定元素添加到链表开头add(元素)将指定元素添加到链表结尾。
4.1.Java实现单向链表（完整代码及详细注释）
c1776167012的博客
03-14 1057
一.什么是单向链表？ 它由多个节点组成，每个 节点（用于存储数据） 通过next指针相互连接，从而构成了一个线性的表（它与数组的区别就是它可以不具空间连续性）。 在java中一般通过定义节点类和操作类的方式来实现链表 二.JAVA代码的实现： 1.定义节点： class ListNode{ private int data;//存储的数据 private ListNode next...
Java单向链表操作详解
u012501054的博客
07-06 386
/* 先定义一个Node类用来存储节点的值域和指针域 * 即当前节点中的值和后面节点的方法 * 在C中就是相当与定义一个结构体类型一个数据域和指针域的方法 */class LNode{//这个写法已经非常固定了 设置两个属性分别用set函数和get函数来得到这两个属性 private int data; private LNode next;//这个和String应该比较相似的用法，类名用来表示数...
单向链表实现(java代码)
qq_22993855的博客
09-11 497
单向链表实现以及常见的面试题收录(java代码) Java代码 package com.bingym.linkedlist; import java.util.Stack; public class SingleLinkedListByOrder { //实现单向链表功能:链表的添加add(可以按照编号index进行插入),链表内容的打印 //内部需要包含一个节点类:内部类/外部类都可以 //定义单向链表的属性 private Node head =new Node(
Java实现单链表代码
LeoneDeng的博客
09-22 2922
Java实现简练单链表代码 package 链表; import javax.print.attribute.standard.NumberOfDocuments; import static com.sun.tools.classfile.CharacterRangeTable_attribute.Entry.length; class Node{ Node next = nul...
实现一个简单的单向链表（Java代码）
m0_63036262的博客
04-13 1044
链表是什么？ 链表是一种物理存储结构上非连续存储结构，数据元素的逻辑顺序是通过链表中的引用链接次序实现的 。 链表分为单向链表和双向链表。 我们先来了解一下单向链表，它有一些什么操作呢？下面让我们一起来看一看：
java实现单链表
热门推荐
congge
03-06 4万+
链表是java数据结构中一种很基础很常见却也很重要的数据结构，JDK中许多内置jar包基于单链表实现，比如像我们熟悉的linkedList等，为什么要使用链表呢？ 我们知道java中很多集合的底层是基于数组实现的，数组有一个很重要的结构就是索引，通过索引可以快速定位数据，并对数据进行删除等操作，但问题是，我们的业务中，数组有自身的局限性，如果知道索引还好，如果不知道索引就需要一个个遍历查找，然后再...
Java实现单向链表
you do ,you win
04-20 2334
文章目录单向链表的特点主要属性及方法size节点类Node方法节点的添加节点的删除节点数据的获取链表的遍历实现细节测试 单向链表的特点 单向链表，见名知意，即单向存储的链表。由一个个节点链接而成，每个节点保存当前节点存储的数据以及下一个节点的位置（由于java中淡化了指针这个概念，此处我们可以理解为保存下一个节点）每个节点只知道后继节点是谁，而不清楚自己的上一个前驱节点（就像间谍一样，老大能找到你，但你不能去找老大） 主要属性及方法 size 代表链表中节点的数量 节点类Node 属性：T data、Nod
Java 单向链表和单向循环链表的代码实现
请叫我大师兄
08-03 5093
这个链表，以前上学的时候，学c语言，还是数据结构的时候，学过。也许也实现过吧。下面我就简单记录下这个链表的实现。 单向链表跟单向循环链表的差别就是：单向链表是有结束位的，指向null的时候，就到结尾了，但是单向循环链表，他就是一个圈，要是不设置指定位置，他是会一直转下去的，转着转着就会出现OOM异常了，也就是内存溢出啦。 单链表 先看单链表的节点对象--Node类。 这是组成链表的节点，就
Java实现单向链表：基础、优缺点与操作方法
本文主要介绍了如何使用Java实现单向链表的基本功能，包括链表的原理、优缺点以及相关的操作，如遍历、查找、清空、销毁、求长度、排序、删除节点和插入节点。 一、单向链表概念 单向链表是一种线性数据结构，其...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

Aholic 冲冲冲

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

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

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

打赏作者

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

抵扣说明：

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

余额充值