java数据结构之链表

最新推荐文章于 2023-01-03 11:27:55 发布
最新推荐文章于 2023-01-03 11:27:55 发布
阅读量54 收藏
点赞数
分类专栏： 编程 文章标签： 数据结构 链表 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_34352492/article/details/120038872
版权

java数据结构之链表

目录

一、链表是什么？

list -->ArrayList 顺序表:元素处在连续的内存空间上
list -->LinkList 链表:元素处在不连续的内存空间上

二、使用链表

1.定义链表

链表由两部分组成:

1.元素
2.节点

在这里插入图片描述

2.链表的作用:

解决顺序表中的"搬运"问题,中间插入/删除的时间复杂度是O(N).

  • 顺序表插入元素 100 的过程
    在这里插入图片描述
    链表实现元素 100 的插入
    在这里插入图片描述

在这里插入图片描述
在这里插入图片描述
删除同理,顺序表也是需要搬运的
在这里插入图片描述
链表删除元素 2
在这里插入图片描述

  • 链表和顺序表的取下标操作

     1.顺序表数组,索引(index)指向数组下标,顺序表是直接封装了数组,可以直接使
 用index 来取元素。
 2.链表不是数组,无法使用 index 来直接取下标,可以使用 get / set 方法取下
 标,只不过此方法比顺序表的操作效率低。

3.单向链表和双向链表

  • 单向链表:只能通过当前节点,找到下一个节点~,无法找到上一个节点
class Node {
    int val; // 链表中要保存的元素
    Node next; // 保存指向下一个结点的引用
}
  • next == null 表示链表到达了末尾
  • 双向节点:通过当前节点,能找到下一个节点,也可以找到上一个节点
class Node {
    int val; 
    Node next; 
    Node prev;
}

4.带傀儡节点的链表和不带傀儡节点的链表

傀儡节点：不实际存储数据，占用位置

在这里插入图片描述

5.带环的链表和不带环的链表

  • 不带环的链表：最后一个元素指向null
    在这里插入图片描述

  • 带环的链表：最后一个元素不指向空，而是指向链表的某个节点
    在这里插入图片描述

总结：以上六种链表是正交的，可以随意任意组合，衍生出八种链表

在这里插入图片描述
链表的头结点：
针对单向链表，为了获取其头结点，通常使用头结点代替整个链表

6.链表遍历

package java;

//使用 Node 表示链表的节点
public class Node {
    public int val;
    public Node next = null;

    public Node(int val){
        this.val = val;
    }
    @Override
    public String toString() {
        return "[" + val + "]";
    }
}

package java;
public class Main {
    //此方法是创建出一个固定内容的链表
    //使用头结点来代指整个链表
    //方法返回头结点
    public static Node createList(){
        Node a = new Node(1);
        Node b = new Node(2);
        Node c = new Node(3);
        Node d = new Node(4);
        a.next = b;
        b.next = c;
        c.next = d;
        d.next = null;
        return a;
    }

    public static void main(String[] args) {
        Node head = createList();

        for (Node cur = head; cur != null; cur = cur.next ) {
            System.out.println(cur.val);
        }
    }
}

输出结果
在这里插入图片描述

通过遍历，找到链表的最后一个结点

        Node cur = head;
		while (cur != null && cur.next != null){  
        }
        System.out.println(cur.val);

运行结果
在这里插入图片描述

  • 为了保持代码稳健，头结点不可以为空
  • 如若不带傀儡节点的链表表示空，直接用 head = null 来表示；如若带傀儡节点的链表表示空链表，则使用 head.next = null 来表示。（带傀儡节点意味着无论如何都有一个节点）

通过遍历，找到链表的倒数第二个结点

        int N = 3;
        Node cur = head;
        for (int i = 1; i < N; i++) {
            cur = cur.next;
        }
        //此时 cur 指向的元素，就是正数第 N 个元素
        System.out.println(cur.val);

运行结果：
在这里插入图片描述

通过遍历，找到链表的第 n 个结点。（从 1 开始，链表的长度 >= n）


        int N = 3;
        Node cur = head;
        for (int i = 1; i < N; i++) {
            cur = cur.next;
        }
        //此时 cur 指向的元素，就是正数第 N 个元素
        System.out.println(cur.val);

运行结果：
在这里插入图片描述

通过遍历，计算链表中元素的个数

        //每次循环访问一个节点之后 ，计数器count++
        int count = 0;
        for (Node cur = head;cur != null;cur = cur.next) 
            count++;
        }
        System.out.println(count);

运行结果：
在这里插入图片描述

通过遍历，找到链表的倒数第二个结点

通过遍历，找到链表中是否包含某个元素。

        int toFind = 3;
        Node cur = head;
        for (; cur != null; cur = cur.next) {
            if (cur.val == toFind) {
                break;
            }
        }
            if(cur != null){
                System.out.println("找到了");
            }
            else{
                System.out.println("没找到");
        }

运行结果：
在这里插入图片描述

7.链表插入

中间插入

将100插入1和2之间
在这里插入图片描述

思路：

	step1：先获取元素1 节点的引用，假设Node one 对应 1 节点的引用
	step2：让新节点的 next 指向 2 节点（one.next）

newNode.next = one.next;

在这里插入图片描述

step3:让 one 的 next 指向新节点

one.next = newNode;

在这里插入图片描述

  • 垃圾回收
public class Main {
    public static Node creatList(){
        //此处的 a b c d 四个引用为局部变量,方法使用完就会被销毁，在其后面new的对象在垃圾回收的时候销毁
        //什么时候垃圾回收：没有任何(强)引用指向的时候
        Node a = new Node(1);
        Node b = new Node(2);
        Node c = new Node(3);
        Node d = new Node(4);
        a.next = b;
        b.next = c;
        c.next = d;
        d.next = null;
        return a; //将a中存的地址返回到 Node head 中，即 Node head 指向 元素 1
    }
    public static void main(String[] args) {
        Node head = creatList();

tips:对于带环链表是不是存在垃圾回收只剩环的情况呢？
答案是：不会的
理由:对于带环的链表，如果删除头结点指向，虽然其他节点也有引用吗，但是还是会被回收的，因为该节点对象为“不可达”，GC在分析对象能否被释放时，会对其进行可达性分析，即从一些特殊的引用开始进行搜索，例如：每个栈针中的局部变量，类的静态变量，对这些特殊的引用有一个别称-- gcroots。

链表元素的插入（不带傀儡节点）—头插入

  • 头插入需要考虑的最大问题是将会影响头结点的引用。
    在这里插入图片描述

第一步：让 newNode 的 next 指向链表的第一个节点
在这里插入图片描述

第二步：让head指向新节点
在这里插入图片描述

插入小结

对于无傀儡节点的中间插入和头插入是两种不同的思想和过程，对于开发者使用起来较为繁琐，故若引用傀儡节点，则可将头插入转换成中间插入，使得开发效率大大提高。

带傀儡节点的链表插入

  1. 中间插入

在节点 1 和 2 之间插入新节点 100
在这里插入图片描述

  • step0：准备工作
    在这里插入图片描述

  • step1：在这里插入图片描述

  • step2：在这里插入图片描述

        //先创建带傀儡节点的链表
        Node head = creatListWithDummy();
        Node newNode = new Node(100);

        //在 1 和 2 之间插入元素，需要知道前一个（prev）元素的位置
        //prev 是指向 1 的位置。prev 表示前一个元素
        Node prev = head.next;
        newNode.next = prev.next;
        prev.next = newNode;

  • 头插入

     由于是带傀儡节点，对其头插入相当于插入到 head 的后面

        Node prev = head;
        newNode.next = prev.next;
        prev.next = newNode;
  • step0：准备工作

在这里插入图片描述

  • step1：
    在这里插入图片描述
  • step2：
    在这里插入图片描述
  • tips：此处的头结点是傀儡节点，head 是一个班指向傀儡节点的引用；傀儡节点是无意义的，遍历的时候不遍历傀儡节点。

链表尾插（带头结点和不带头结点）

此处以不带头结点为例进行说明

  • step：准备工作
    在这里插入图片描述
  • step1：
    在这里插入图片描述
  • step2：
    在这里插入图片描述

空链表插入

对于空链表的插入，只需要让 head 的引用指向新的节点即可。因为空链表中无任何节点，故不存在“前一个位置”。

  • 如若采用之前常规的方法插入是无法插入的
    //空链表插入操作
    public static void insertTail(Node head, int val) {
        Node newNode = new Node(val);
        if(head == null){
            head = newNode;
            return;
        }
        Node prev = head;
        Node cur = prev;
        while (cur.next != null){
            cur = cur.next;
        }//循环结束,cur 就是最后一个节点吧
        newNode.next = prev.next;
        prev.next = newNode;
    }

    public static void main(String[] args) {
        //空链表插入操作
        Node head = null;
        insertTail(head,100);
        print(head);        
    }

运行结果
在这里插入图片描述
《原因分析》
在这里插入图片描述

  • tips1：此处主函数中的 head 和 插入函数（insertTail）中的 head 不一样。
  • tips2：插入函数回调仅仅修改插入函数内部的 head 值，返回时，并不改变主函数中的head 值。
  • 总结：故使用常规方法无法插将新元素入到空链表中。

正确做法如下：

  1. 给插入函数设置返回值
    public static Node insertTail(Node head, int val) {
        Node newNode = new Node(val);
        if(head == null){
            return newNode;   //返回 newNode
        }
        Node prev = head;
        Node cur = prev;
        while (cur.next != null){
            cur = cur.next;
        }//循环结束,cur 就是最后一个节点吧
        newNode.next = prev.next;
        prev.next = newNode;
        return head; //返回 head
    }

    public static void main(String[] args) {
        //空链表插入操作
        Node head = null;
        head = insertTail(head,100);  //接收返回值
        print(head);        
    }

运行结果：
在这里插入图片描述

8.链表删除（不带傀儡节点）

1.删除一般节点
  • step1

在这里插入图片描述

  • step2

在这里插入图片描述
时间复杂度为O(N)–按值删除

//(1)删除节点(按照值删除)
    public static void remove(Node head,int value){
        //1.先找到 value 值对应的位置
        //  还需要找到 val 的前一个位置
        Node prev = head;
        //遍历循环找到 value 的前一个位置
        while (prev != null
                && prev.next != null
                && prev.next.val != value){
            prev = prev.next;
        }
        //循环结束之后，prev 指向了待删除节点的前一个节点
        if (prev == null || prev.next == null){
            return; //没有找到值为 val 的节点
        }

        //2.删除操作,toDelete 指向要被删除的节点
        Node toDelete = prev.next;
        prev.next = toDelete.next;
    }

时间复杂度为O(N)–按位置删除

//(2)删除节点，按照位置来删除
    public static void remove(Node head,Node toDelete){
        //step1:找到 toDelete 的前一个节点的位置
        Node prev = head;
        while (prev != null && prev.next != toDelete){
            prev = prev.next;
        }
        if(prev == null){
            return; //没找到
        }
        prev.next = toDelete.next;
    }

时间复杂度为O(1)的按位置删除操作：
在这里插入图片描述

    //时间复杂度为O(1)的按位置删除操作
    public static void remove2(Node head,Node toDelete){
        Node nextNode = toDelete.next;
        toDelete.val = nextNode.val;
        toDelete.next = nextNode.next;
    }
  • tips: 该方法无法处理最后一个节点
2.一般节点按照下标删除
    //按照下标(抽象概念)删除
    public static void remove3(Node head,int index){

        if (index < 0 || index >= size(head)){
            return;
        }

        //如果 index = 0，则删除头结点(后面讲)
        if(index == 0){
            //TODO
        }

        //step1：找到待删除节点前一个位置的节点，即：index - 1
        Node prev = head;
        for (int i = 0;i < index -1;i++){
            prev = prev.next;
        }
        //循环结束之后，prev 指向了待删除节点的前一个位置

        //step2:进行删除
        Node toDelete = prev.next;
        prev.next = toDelete.next;
    }
链表删除总结
  • 链表的删除大多数情况下都需要遍历找到前一个元素的位置，故其时间复杂度是O(N)
  • 链表和顺序表的时间复杂度无法具体比较出孰优孰劣。其两者的本质区别是顺序表的存储再内存上是连续的空间；而链表的存储在内存上可以不连续。
链表删除头结点

在这里插入图片描述

链表删除总结

为了实现形参的顺利返回，对原先实现的删除函数需要设置返回值 Node。

//(1)删除节点(按照值删除) 时间复杂度为O(N)
    public static Node remove(Node head, int value){
        if(head == null){
            return null;
        }

        //删除头结点
        if (head.val == value){
            //删除的节点即为头结点
            head = head.next;
            return head;
        }

        //1.先找到 value 值对应的位置
        //  还需要找到 val 的前一个位置
        Node prev = head;
        //遍历循环找到 value 的前一个位置
        while (prev != null
                && prev.next != null
                && prev.next.val != value){
            prev = prev.next;
        }
        //循环结束之后，prev 指向了待删除节点的前一个节点
        if (prev == null || prev.next == null){
            return null; //没有找到值为 val 的节点
        }

        //2.删除操作,toDelete 指向要被删除的节点
        Node toDelete = prev.next;
        prev.next = toDelete.next;
        return head;
    }

    //(2)删除节点，按照位置来删除  时间复杂度为O(N)
    public static Node remove(Node head,Node toDelete){
        if (head == null){
            return null;
        }

        if(head == toDelete){
            //要删除的即为头结点
            head = head.next;
            return head;
        }

        //step1:找到 toDelete 的前一个节点的位置
        Node prev = head;
        while (prev != null && prev.next != toDelete){
            prev = prev.next;
        }
        if(prev == null){
            return null; //没找到
        }
        prev.next = toDelete.next;
        return head;
    }


    //时间复杂度为O(1)的按位置删除操作
    public static Node remove2(Node head,Node toDelete){
        if(head == null){
            return null;
        }
        if (head == toDelete){
            head = head.next;
            return head;
        }

        Node nextNode = toDelete.next;
        toDelete.val = nextNode.val;
        toDelete.next = nextNode.next;
        return head;
    }
    //注意：该方法无法处理最后一个节点


    public static int size(Node head){
        int size = 0;
        for (Node cur = head;cur != null;cur = cur.next){
            size++;
        }
        return size;
    }


    //按照下标(抽象概念)删除
    public static Node remove3(Node head,int index){

        if (index < 0 || index >= size(head)){
            return head;
        }

        //如果 index = 0，则删除头结点
        if(index == 0){
            head = head.next;
        }

        //step1：找到待删除节点前一个位置的节点，即：index - 1
        Node prev = head;
        for (int i = 0;i < index -1;i++){
            prev = prev.next;
        }
        //循环结束之后，prev 指向了待删除节点的前一个位置

        //step2:进行删除
        Node toDelete = prev.next;
        prev.next = toDelete.next;
        return head;
    }

主函数调用

    public static void main(String[] args) {
        Node head = creatList();
        head = remove(head,1);
        print(head);
        }
    }

运行结果：
在这里插入图片描述

9.链表删除（带傀儡节点）

1.删除原理

  • step1
    在这里插入图片描述

  • step2
    在这里插入图片描述

2.删除过程
    //带傀儡节点的删除
    public static void removeWithDummy(Node head,int val){
        //使用带傀儡节点的好处：
        // 1.避免了 head 引用修改的问题
        // 2.避免了删除头结点需要判断的问题

        //循环寻找 val 匹配的值
        Node prev = head;
        while (prev != null && prev.next != null
                && prev.next.val != val){
            prev = prev.next;
            //循环结束的两种情况:
            //1.prev 到达了链表末尾也没找到和 val 匹配的值
            //2.找到了和 prev 匹配的值

            if (prev == null && prev.next == null){
                //没找到对应节点
                return;
            }
            //找到了对应节点
            Node toDelete = prev.next;
            prev.next = toDelete.next;
            return;
        }
    }
KLear22
关注
专栏目录
Java 数据结构之链表
JavaZWT的博客
08-06 1051
前言 链表是一种物理存储单元上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。链表由一系列结点（链表中每一个元素称为结点）组成，结点可以在运行时动态生成。每个结点包括两个部分：一个是存储数据元素的数据域，另一个是存储下一个结点地址的指针域。 由于链表不必按照顺序存储，故在插入数据时可以达到O(1)的复杂度，但是查找的时候就需要遍历，时间复杂度为O(n)。 ...
标准LinkedList中“增删改查”的时间复杂度
weixin_34352492的博客
01-26 3087
标准LinkedList中“增删改查”的时间复杂度
Java数据结构之链表
qq_64580912的博客
10-27 2373
小结:1)链表是以节点的方式来存储2)每个节点包含data域, next域:指向下一个节点.3)如图:发现链表的各个节点不一定是连续存储.4)链表分带头节点的链表和没有头节点的链表，根据实际的需求来确定。
java数据结构-链表详解
m0_63526467的博客
05-04 4151
文章目录1.数据结构-链表详解1.1单链表1.1.1单链表节点的尾部添加1.1.2单链表节点的自动排序添加1.1.3单链表节点的修改1.1.4单链表节点的删除1.2单链表面试题1.2.1单链表的有效节点个数1.2.2单链表倒数第k个结点1.2.3单链表反转1.2.4单链表逆序打印1.3双向链表1.3.1双向链表介绍1.3.2双向链表增删改查1.4单向环形链表1.4.1约瑟夫（Josephu）环问题 1.数据结构-链表详解 链表可分为三类： 单链表 双向链表 循环列表 下面具体分析三个链表的应用。 1.1
Java数据结构之链表（单链表）
qq15035899256的博客
07-03 1571
回到目录… 本文是Java数据结构的链表部分，介绍了链表的实现原理，以及带头单链表的引入。快速手写单链表，之后的学习内容将持续更新！！！
数据结构——链表(java)
最新发布
薯条和番茄酱的博客
01-03 4351
链表是一种物理存储结构上非连续存储结构，数据元素的逻辑顺序是通过链表中的引用链接次序实现的。
Java数据结构之链表的基本操作
m0_43405302的博客
10-30 3142
一、链表的定义 链表是数据结构中线性结构中最为重要的数据结构，关于Java链表的定义以及数据实例化，请查看数据结构之数组和链表（Java语言描述）。 二、插入元素操作 在介绍插入元素之前，我先对数据进行进行节点实例化。首先，我们建立n1、n2和n3的三个节点，其中n1的后继节点是n2，现在我们想把n3插入其中。这样我们有三种插入方式： class ListNode{ int val; //节点值 ListNode next; //后续节点使用 ListNode(int x){val=x;} } Li
Java数据结构之链表、栈、队列、树的实现方法示例
08-26
"Java数据结构之链表、栈、队列、树的实现方法示例" 在计算机科学中，数据结构是一种组织和存储数据的方式，以便实现高效的数据存取和处理。Java数据结构中常用的数据结构有链表、栈、队列、树等，本文将详细介绍...
Java数据结构之链表(动力节点之Java学院整理)
08-30
在Java中，我们可以使用类来实现链表的数据结构。 首先，我们来看单链表的一些基本操作： 1. **insertFirst**: 在链表头部插入新节点。这个操作的时间复杂度是O(1)，因为只需要改变头节点的引用即可。 ```java ...
Java数据结构之简单链表的定义与实现方法示例
08-29
Java数据结构之简单链表的定义与实现方法示例 Java数据结构之简单链表是指一种链式存储结构，通过节点之间的链接来存储数据。这种数据结构的特点是先进后出，即最后插入的数据将被最先删除。 定义 在Java中，简单...
JAVA 数据结构链表操作循环链表
09-01
在Java编程中，数据结构是程序设计的基础，链表是一种常用的数据结构，它不依赖于数组的物理位置，而是通过节点间的引用关系进行组织。循环链表是链表的一种变体，它的特点是最后一个节点指向了链表的第一个节点，...
java数据结构自定义顺序表
weixin_34352492的博客
08-31 842
自定义顺序表 目录自定义顺序表一、包含功能二、具体实现过程0.0 自定义顺序表0.1 扩容0.2 重写toString1.插入元素1.1 尾插1.2 指定位置插入2.插入元素2.1 按照指定元素删除2.2 按照目标元素删除3.根据下标获取元素4.根据下标修改元素5.判断元素是否存在6.查找元素位置6.1 从前往后6.2 从后往前7.清空元素8.求长度9.判断是否为空10.测试函数10.1 测试增加函数10.2 测试删除函数10.3 测试获取/修改函数10.4 测试存在/元素位置函数10.5 测试清空/长度/
java数据结构之栈和队列
weixin_34352492的博客
02-05 787
java数据结构之栈和队列
IDE中编写java语言的hello world
weixin_34352492的博客
12-27 713
Java 中的第一行代码: hello world 此处我们用IDE编写java中的第一行代码-------hello world IDE的安装此处我们不做详细介绍,附上前辈的安装连接:https://www.cnblogs.com/gaobo123/articles/13304599.html 1. 首先,我们打开已经安装好的IDE,点击新建项目.JDK一般都会自动选择默认的,如果编译器没找到,可以自己手动添加. 2.接下来直接点击next. 3.项目名称和路径自定义,但是最好不要包含中文字符 4.
Java学习(4)之方法的使用
weixin_34352492的博客
01-23 689
Java学习(4)之方法的使用 文章目录Java学习(4)之方法的使用前言一、Scanner输入1.scanner.next 读到空白符结束2.scanner.nextLine 读到换行符结束3.使用 hasNext 对若干个整数求和二、猜数字游戏1.引入库2.读入数据总结 前言 提 一、Scanner输入 1.scanner.next 读到空白符结束 空白符：空格，换行\n，回车\r，制表符\t，翻页符\f，垂直制表符\v... 2.scanner.nextLine 读到换行符结束 Tip
链表OJ练习
weixin_34352492的博客
01-21 640
链表OJ练习 使用力扣练习链表的增删改查 目录链表OJ练习一、链表的删除二、反转单链表2.读入数据总结 一、链表的删除 【题目】：给你一个链表的头节点 head 和一个整数 val ，请你删除链表中所有满足 Node.val == val 的节点，并返回 新的头节点 。 【分析】: 需要判断删除节点是否为空 if(head == null){ return null; } 删除头节点 i
String类
weixin_34352492的博客
03-11 580
String类 目录String类前言一、字符串的常见操作1.字符串比较2.字符串查找3.字符串替换4.字符串拆分二、使用步骤1.引入库2.读入数据总结 前言 提示：这里可以添加本文要记录的大概内容： 例如：随着人工智能的不断发展，机器学习这门技术也越来越重要，很多人都开启了学习机器学习，本文就介绍了机器学习的基础内容。 提示：以下是本篇文章正文内容，下面案例可供参考 一、字符串的常见操作 1.字符串比较 2.字符串查找 3.字符串替换 4.字符串拆分 示例：pandas 是基于NumPy 的一
数据结构OJ练习
weixin_34352492的博客
01-25 572
java数据结构OJ练习（二）
类和对象 & String类
weixin_34352492的博客
03-03 491
类和对象 目录类和对象前言一、String类1.创建二、使用步骤1.引入库2.读入数据总结 前言 JVM的内存区域，除了堆和栈外，还有一块区方法区。方法区里面存的是一个一个“类相关的信息”。 对于属性来说，如果属性是一个实例属性，那么不在方法区，而是跟实例在一块，实例一般在堆上。 如果属性是一个类属性（被static修饰）则在方法区中。 对于方法来说，不管是加不加static，都会被放在方法区中。 引用也会在方法区中。 字符串常量池在JDK1.8之后存放在堆上，之前是在方法区。 一、String类
Java数据结构：链表定义与实现详解
本文档提供了一个关于Java中简单链表数据结构的详细教程，涵盖了链表的基本概念、工作原理以及如何在Java中实现链表。链表是一种动态数据结构，它的每个元素（节点）包含数据和一个指向下一个节点的引用。在链表中...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值