Java中的链表

最新推荐文章于 2024-05-05 22:29:45 发布
最新推荐文章于 2024-05-05 22:29:45 发布
阅读量3.3k 收藏 31
点赞数 26
分类专栏： 数据结构和算法 文章标签： 链表 java 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_52758364/article/details/128251025
版权

文章目录

前言

上一节中，我们讲过了Java中的ArrayList，当在ArrayList任意位置插入或者删除元素时，就需要将后序元素整体往前或者往后搬移，时间复杂度为O(n)，效率比较低，因此ArrayList不适合做任意位置插入和删除比较多的场景。因此：java集合中又引入了LinkedList，即链表结构。

一、链表

1.1 链表的概念及结构

链表是一种物理存储结构上非连续存储结构，数据元素的逻辑顺序是通过链表中的引用链接次序来实现的。类似于火车一样。
在这里插入图片描述

注意：

  1. 链式结构在逻辑上是连续的，但是在物理上不一定连续
  2. 现实中的结点一般都是在堆上申请出来的
  3. 从堆上申请的空间，是按照一定的策略来分配的，两次申请的空间可能连续，也可能不连续

实际中，链表的结构多种多样，一下情况组合起来就有8种链表结构：

  1. 单向或者双向
    在这里插入图片描述

  2. 带头或者不带头
    在这里插入图片描述

  3. 循环或者非循环
    在这里插入图片描述

虽然有这么多的链表结构，但是我们重点讲解两种：

  • 无头单向非循环链表：结构简单，一般不会单独用来存储数据。实际中更多是作为其他数据结构的子结构，如哈希桶、图的邻接表等等。
  • 无头双向链表：在java集合框架中LinkedList底层实现就是无头双向循环链表。

1.2 链表的实现

SingleLinkedList类

// 1、无头单向非循环链表实现
public class SingleLinkedList {

    class Node {
        public int val;
        public Node next;

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

    public Node head;

    public void createLinkList() {
        Node node1 = new Node(12);
        Node node2 = new Node(45);
        Node node3 = new Node(88);
        Node node4 = new Node(92);
        node1.next = node2;
        node2.next = node3;
        node3.next = node4;
        head = node1;
    }

    //打印链表
    public void display() {
        Node cur = head;
        while (cur != null) {
            System.out.print(cur.val + " ");
            cur = cur.next;
        }
        System.out.println();
    }

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

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

    //头插法
    public void addFirst(int data) {
        Node node = new Node(data);
        node.next = head;
        head = node;
    }

    //尾插法
    public void addLast(int data) {
        Node node = new Node(data);

        if (head == null) {
            head = node;
        }

        Node cur = head;
        while (cur.next != null) {
            cur = cur.next;
        }
        cur.next = node;
    }

    //任意位置插入,第一个数据节点为0号下标
    public void addIndex(int index, int data) throws ListIndexOutofException {
        if (index < 0 || index > size()) {
            throw new ListIndexOutofException("index位置不合法");
        }
        if (index == 0) {
            addFirst(data);
        }
        if (index == size()) {
            addLast(data);
        }

        int count = 0;
        Node cur = head;
        while (count != index - 1) {
            cur = cur.next;
            count++;
        }

        Node node = new Node(data);
        node.next = cur.next;
        cur.next = node;

    }



    //删除第一次出现关键字为key的节点
    public void remove(int key) {
        if(head == null) {
            return;
        }
        if(head.val == key) {
            head = head.next;
            return;
        }
        Node cur = searchprev(key);
        if(cur == null) {
            return;
        }
        Node del = cur.next; //要删除的节点
        cur.next = del.next;
    }

    /*
    查找key前一个节点
     */
    private Node searchprev(int key) {
        Node cur = head;
        while (cur.next != null) {
            if(cur.next.val == key) {
                return cur;
            }
            cur = cur.next;
        }
        return null; //没有删除的节点
    }

    //删除所有值为key的节点
    public void removeAllKey(int key) {
        if(head == null) {
            return;
        }
        Node pre = head;
        Node cur = head.next;
        while (cur != null) {
            if(cur.val==key) {
                pre.next = cur.next;
            } else {
                pre = cur;
            }
            cur = cur.next;
        }
        if(head.val==key) {
            head = head.next;
        }
    }

    public void clear() {
        head = null;
    }
}

ListIndexOutofException类

public class ListIndexOutofException extends RuntimeException {
    public ListIndexOutofException() {
    }

    public ListIndexOutofException(String message) {
        super(message);
    }
}


Test类

public class Test {
    public static void main(String[] args) {
        SingleLinkedList singleLinkedList = new SingleLinkedList();
        singleLinkedList.createLinkList();
        singleLinkedList.display();
        System.out.println(singleLinkedList.contains(12));
        System.out.println(singleLinkedList.size());

        singleLinkedList.addFirst(8); //头插
        singleLinkedList.display();

        singleLinkedList.addLast(9);//尾插
        singleLinkedList.display();

        singleLinkedList.addIndex(2,999);
        singleLinkedList.addIndex(4,999);
        singleLinkedList.display();

        singleLinkedList.remove(88);
        singleLinkedList.display();

        singleLinkedList.removeAllKey(999);
        singleLinkedList.display();
    }
}

二、链表面试题

以下是我要讲解的5个关于链表的面试题，包含OJ链接。

2.1 判定链表是否是回文

题目：链表的回文结构
在这里插入图片描述
思路： 由于链表是单向的，所以我们如果要使用双指针的思想解决该题，就需要将后半部分数据的指向进行逆置。也就是

	1——>2——>2<——1

要实现后半部分的逆置，我们需要找到链表的中间节点 。在链表的实现里，我们已经使用快慢指针找到链表的中间节点。最后我们再使用双指针，遍历链表，比较前后对称节点的值是否相等。

代码实现：

import java.util.*;

/*
public class ListNode {
    int val;
    ListNode next = null;

    ListNode(int val) {
        this.val = val;
    }
}*/
public class PalindromeList {
    public boolean chkPalindrome(ListNode head) {
        if(head == null) {
            return false;
        }
        if(head.next == null) {
            return true;
        }
        //快慢指针找中间节点
        ListNode fast = head;
        ListNode slow = head;
        while(fast != null && fast.next != null) {
            fast = fast.next.next;
            slow = slow.next;
        }
        //翻转后半部分的指向
        ListNode cur = slow.next;
        while(cur != null) {
            ListNode curNext = cur.next;
            cur.next = slow;
            slow = cur;
            cur = curNext;
        }

        while(slow != head) {
            if(slow.val != head.val) {
                return false;
            }
            //下面这个if语句是用来判断链表长度为偶数的情况的
            if(head.next == slow) {
                return true;
            }
            slow = slow.next;
            head = head.next;
        }
        return true;

    }
}

2.2 合并两个有序链表

题目：合并两个有序链表
在这里插入图片描述
思路： 要返回一个新的升序链表，那么我们需要申请一个新的头节点，然后通过遍历两个链表，并将其值进行对比，值小的，则添加进新的头节点，并且头节点和值小的链表都往后移动，这样一直比较下去，直到一个链表比较完为止。如果最后还有一个链表不为null，那么直接添加进新的头节点。

代码实现：

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode() {}
 *     ListNode(int val) { this.val = val; }
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */
class Solution {
    public ListNode mergeTwoLists(ListNode list1, ListNode list2) {
        ListNode newHead = new ListNode(0);//申请新的头节点
        ListNode cur = newHead; //使用cur来间接使用新的头节点
        //循环的条件是两个链表都不为null
        while(list1 != null && list2 != null) {
            if(list1.val<list2.val) {
                cur.next =  list1;
                list1 = list1.next; //往后走
                cur = cur.next; //往后走
            }else {
                cur.next =  list2;
                list2 = list2.next;
                cur = cur.next;
            }
        }
        //如果哪个链表不为null，则直接添加进新的头节点
        if(list1!=null) {
            cur.next = list1;
        }
        if(list2!=null) {
            cur.next =list2;
        }
        return newHead.next; //返回新头节点的后面部分，因为newHead.val为0
    }
}

2.3 获取链表倒数第K个节点

题目：链表中倒数第K个节点
在这里插入图片描述
思路： 这道题也是一道数学题，我们仍然使用快慢指针的思想，让fast先走k-1步，然后让slow和fast一起走。知道fast.next为null。

代码实现：

/*
public class ListNode {
    int val;
    ListNode next = null;

    ListNode(int val) {
        this.val = val;
    }
}*/
public class Solution {
    public ListNode FindKthToTail(ListNode head,int k) {
    	//判断K值的合法性以及head是否为null
        if(k <= 0 || head==null) {
            return null;
        }
        ListNode fast = head;
        ListNode slow = head;
        while(k-1 != 0) {
            fast = fast.next;
            //这个if语句处理了当k值大于链表长度的情况，复杂度变低
            if(fast == null) {
                return null;
            }
            k--;
        }
        while(fast.next != null) {
            fast = fast.next;
            slow = slow.next;
        }
        return slow;
    }
}

2.4 获取链表的中间节点

题目：链表的中间节点
在这里插入图片描述
**思路：**快慢指针，让fast的速度是slow的两倍,走完之后，slow指向的节点就是中间节点。

代码实现：

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode() {}
 *     ListNode(int val) { this.val = val; }
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */
class Solution {
    public ListNode middleNode(ListNode head) {
        if(head==null) {
            return null;
        }
        ListNode fast = head;
        ListNode slow = head;
        //两个循环条件不能交换位置，不然空指针异常
        while(fast!=null && fast.next!=null) {
            fast = fast.next.next;
            slow = slow.next;
        }
        return slow;
    }
}

2.5 单链表的逆置

题目：反转链表
在这里插入图片描述

思路： 使用头插法将后面的节点一个一个插在前面。

代码实现：

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode() {}
 *     ListNode(int val) { this.val = val; }
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */
class Solution {
    public ListNode reverseList(ListNode head) {
        if(head==null) {
            return null;
        }
        if(head.next==null) {
            return head;
        }
        ListNode cur = head.next; 
        head.next = null; //修改为null
        
        while(cur!=null) {
            ListNode curNext = cur.next; //一定要保存cur.next，因为cur在改变
            cur.next = head;  //修改cur的指向，指向原本的头节点
            head = cur; //改变头节点，cur成为新的头节点
            cur = curNext; //改变cur
        }
        return head;

    }
}

总结

以上就是今天要讲的内容，本文仅仅简单介绍了链表的使用以及几个面试题，链表在Java数据结构中非常重要，学习时要多与数学结合起来，多画图，多思考！

没点哈数
关注
  • 26
    点赞
  • 踩
  • 31
    收藏
    觉得还不错? 一键收藏
  • 16
    评论
专栏目录
java 中链表的定义与使用方法
08-31
Java 中链表的定义与使用方法 Java 中链表的定义与使用方法是 Java 语言中一种常用的数据结构，链表是一种动态分配内存的数据结构，链表的每个元素都是一个独立的对象，每个元素都包含一个数据域和一个指针域，指针...
数据结构——链表(java)
薯条和番茄酱的博客
01-03 4215
链表是一种物理存储结构上非连续存储结构，数据元素的逻辑顺序是通过链表中的引用链接次序实现的。
JAVA——链表
qq_69133469的博客
04-23 2万+
一、链表概念及结构 链表：链表是一种物理存储结构上非连续存储结构，数据元素的逻辑顺序是通过链表中的引用链接次序实现的。如下图：（通俗的说：就是由一个个节点组成，这些节点逻辑上连续，物理上不连续） 类比火车： singleLinkedList ——火车车次（一整个火车or哪趟火车） Node——车厢，具体储存元素的类，每个单链表的节点就是Node的一个对象 Node.head ；——当前链表的头节点（只要知道头节点就可以此访问链表中的所有节点） int size ；——当前链表的长度（节点个.
2024年Java最新Java算法基础 - 单链表详解（文末有配套视频）(2)，2024Java面试题知识点总结
最新发布
2401_83977696的博客
05-05 1001
由于篇幅有限，这里就不一一罗列了，20道常见面试题（含答案）+21条MySQL性能调优经验小编已整理成Word文档或PDF文档还有更多面试复习笔记分享如下本文已被CODING开源项目：【一线大厂Java面试题解析+核心总结学习笔记+最新讲解视频+实战项目源码】收录需要这份系统化的资料的朋友，可以点击这里获取CustNode类里面维护一个顾客的属性，为了方便起见，就直接用public了，反正我们自己用用的，无所谓。步骤 3 排队打饭。
【Java】链表LinkedList
qq_61635026的博客
07-06 9434
链表（Linked List）是一种常见的数据结构，用于存储和组织数据。它由一系列节点（Node）组成，每个节点包含两个主要部分：数据域（Data）和指针域（Pointer）。 数据域存储节点所需的数据或信息，可以是任意类型的数据，如整数、字符、对象等。指针域则指向链表中的下一个节点，将节点连接起来形成链表结构。 链表中的节点并不一定按照物理上的连续位置存储，而是通过指针域相互连接。这使得链表能够灵活地插入、删除和修改节点，而无需像数组那样进行元素的移动。
Java数据结构篇之链表
MasterJundarj的博客
09-23 2919
/头插法//尾插法//任意位置插入,第一个数据节点为0号下标//查找是否包含关键字key是否在单链表当中//删除第一次出现关键字为key的节点//删除所有值为key的节点//得到单链表的长度int size();@Override@Override【解释】
Java链表入门(超详细)
qq_57735833的博客
07-25 1万+
说起链表,可以说是让刚接触数据结构的同学非常懵逼的那么什么是链表呢??链表（Linkedlist）是一种常见的基础数据结构，是一种线性表，但是并不会按线性的顺序存储数据，而是在每一个节点里存到下一个节点的指针(Pointer)。那么这是链表吗,是的,但是究竟是什么意思呢其实,链表就像是解密游戏一样,只有到达一个地点,才会有NPC给你下一个地点的地图,从而才能知道下个地点的位置所以链表也是一样,对于一个链表,一个结点除了要保存结点自身的值以外,还需要保存下一个结点的地址....
java中链表和数组的区别？ 数组和链表.pdf
04-18
Java 中链表和数组的区别 Java 中链表和数组都是数据结构，但它们有着本质的差异。在这篇文章中，我们将探讨链表和数组的区别，並探讨它们各自的特点、优缺点和应用场景。 数组 数组是一种线性结构，可以直接索引...
java中链表和数组的区别？ (1) 数组和链表.pdf
04-18
然而，由于链表没有直接的索引访问，要找到链表中的特定元素需要从头节点开始遍历，查找效率为O(n)。此外，链表不占用连续内存，可以更好地利用内存，避免了数组可能产生的内存浪费。 数组和链表的适用场景： - ...
java实现链表
09-24
链表是一种物理存储单元上非连续、非顺序的存储结构。 java代码实现单链表，插入，删除和遍历等功能。 链表能够灵活的进行插入和删除操作，时间复杂度为O（1）,链表的查找时间复杂度为O（n）。
JAVA基础-链表
lwxklts的博客
02-02 710
链表由一系列结点组成，每个结点包括两个部分：一个是存储数据元素的数据域，另一个是存储下一个结点地址的指针域。相比于线性表顺序结构，操作复杂。链表在插入的时候速度较快，可以达到O(1)的复杂度，但是查找操作较慢，需要O(n)的时间，线性表和顺序表查找操作的时间复杂度分别是O(logn)和O(1)。链表的物理存储结构是非连续存储结构，数据元素的逻辑顺序是通过链表中的引用链接的次序实现的.利用尾节点last尾插法插入结点。先查找结点比对结点值再删除。在指定结点前添加结点。
Java链表详解--通俗易懂(超详细,含源码)
热门推荐
噜噜噜噜鲁
12-05 3万+
概念 链表(linked list)：是一种物理存储结构上非连续存储结构，数据元素的逻辑顺序是通过链表中的引用链接次序实现的 。 链表由一系列结点（链表中每一个元素称为结点）组成，结点可以在运行时动态生成。每个结点包括两个部分：一个是存储数据元素的数据域，另一个是存储下一个结点地址的指针域。 相比于线性表顺序结构，操作复杂。由于不必须按顺序存储，链表在插入的时候可以达到O(1)的复杂度，比另一种线性表顺序表快得多，但是查找一个节点或者访问特定编号的节点则需要O(n)的时间，而线性表和顺序表相应的时间复杂
Java算法进阶(一):链表
Justin_Andyson的博客
04-11 932
Java算法链表的深究
Java实现链表
cainiaowangdake的博客
06-06 1285
以上就是今天要讲的内容，本文仅仅简单介绍了链表的基本知识与链表的实现，链表是数据结构的开门红，好好理解，慢慢消化，多打代码，坚持住，别放弃。
Java数据结构之链表
m0_74195366的博客
11-06 392
JAVA链表单链表
Java数据结构—链表（Linked List）
Rxq_Future的博客
04-16 458
数据结构—链表
一篇讲完Java链表（单链表、循环链表和双向链表）
qq_42592994的博客
07-31 4941
链表，是Java中的一种重要的链式数据结构。 众所周知，我们日常用手机电脑收发信息，下载视频和软件，都要进行数据的传输。这些数据都要以一种特定的数据结构来进行传输和存储，否则数据将会是一串毫无意义的0和1，无法生成我们想要的文件。一般来说有两种最常见的基本数据结构，一种是线性结构的数组，一种是链式结构的链表。
Java链表基础
qq_46638003的博客
01-07 2145
以上是对链表的基础操作,大部分都是通过遍历链表实现.
java 中链表的例子
05-23
下面是一个简单的 Java 链表示例： ```java class Node { int data; Node next; public Node(int data) { ...在 `main` 方法中，创建了一个 `LinkedList` 对象，添加了三个节点，然后展示了这个链表中的所有节点。
评论 16
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值