java链表面试题总结（附动图详解）

最新推荐文章于 2024-04-18 10:41:23 发布
最新推荐文章于 2024-04-18 10:41:23 发布
阅读量334 收藏 2
点赞数
文章标签： java 链表 面试题
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42738587/article/details/100810127
版权

1.输出单链表中倒数第k个节点

第一种解法：定义两个变量p、q指向头结点，q先向前走k-1步，之后p、q同时向后走，直到q.next=null，此时p指向的就是倒数第k个节点。（或者p先向前走k步，之后p、q同时向后走，直到q=null）
在这里插入图片描述
代码如下（用的是描述里括号中的方法即q先向前走k步）

private int getLength() {//求此链表长度
    int length = 0;
    for (Entry<T> p = headEntry; p != null; p = p.getNext()) {
        length++;
    }
    return length;
}

public Entry<T> kCountDownEntry01(int k) {
    int length = getLength();//这里求长度只是为了防止k无效
    if (k <= 0 || k > length) {
        return null;
    }
    Entry<T> p = headEntry, q = headEntry;
    for (int i = 0; i < k; i++) {
        q = q.getNext();
    }
    while (q!= null) {
        p = p.getNext();
        q = q.getNext();
    }
    return p;

第二种解法：也是比较容易想到的解法，直接遍历求出链表长度length，引用变量从头向后走length-k步即可。

代码如下

public Entry<T> kCountDownEntry02(int k) {
    int length = getLength();
    if (k <= 0 || k > length) {
        return null;
    }
    int flag = length - k;
    Entry p = headEntry;
    for (int i = 0; i < flag; i++) {
        p = p.getNext();
    }
    return p;
}

2.单链表的逆置

此问题需要三个引用变量p、q、s（如果只有前后两个变量的话，后者next域改为前者之后，其余结点的地址将找不到），详细操作请看下方动图。
在这里插入图片描述
代码如下

public void inversion() {
    if (getLength() == 1) {
        return;
    }
    Entry<T> p = headEntry;
    Entry<T> q = p.getNext();
    Entry<T> s = q.getNext();
    while (q != null) {
        q.setNext(p);
        p = q;
        q = s;
        if (s != null) {//防止移动到链表末尾时出现空指针异常
            s = s.getNext();
        }
    }
    headEntry.setNext(null);
    headEntry = p;//更新头节点
}

3.假设两个单链表相交，输出相交节点value

定义两个变量p、q分别指向两个链表的头结点，计算出两个链表的长度，假如p指向长链表的头结点，先让p走长链表与短链表的差值步，之后p、q一起向后移动，直到p=q，此时p（或q）指向相交节点。
在这里插入图片描述
代码如下

public static <E extends Comparable<E>> void TwoLinkIntersectEntry(Link<E> link1, Link<E> link2) {
    int len1 = link1.getLength();
    int len2 = link2.getLength();
    int diff = Math.abs(len1 - len2);
    Entry<E> p = link1.headEntry;
    Entry<E> q = link2.headEntry;
    if (len1 > len2) {
        for (int i = 0; i < diff; i++) {
            p = p.getNext();
        }
    } else if (len1 < len2) {
        for (int i = 0; i < diff; i++) {
            q = q.getNext();
        }
    }
    while (p != q) {
        p = p.getNext();
        q = q.getNext();
    }
    System.out.println(p.getValue());
}

此算法验证较复杂，附测试代码

public static void main(String[] args) {
        Link<Integer> link1 = new Link<>();
        Link<Integer> link2 = new Link<>();
        link1.addTail(8);
        link1.addTail(4);
        link1.addTail(6);
        link1.addTail(5);
        link1.addTail(19);
        link1.addTail(13);
        link1.addTail(2);
        link1.addTail(0);
        Entry<Integer> meetEntry = link1.getEntry(13);//获取准备作为相交节点的节点
        link2.addHead(6);
        link2.addHead(2);
        link2.addHead(9);
        link2.addHead(0);
        Entry<Integer> preMeetEntry = link2.getEntry(6);//获取第二条链表中相交节点前一个节点
        preMeetEntry.setNext(meetEntry);//将两个节点链接起来
        System.out.print("链表1：");
        link1.show();
        System.out.print("链表2：");
        link2.show();
        System.out.print("相交节点：");
        Link.TwoLinkIntersectEntry(link1,link2);
}

测试结果
在这里插入图片描述

4.判断一个单链表是否有环

此算法用到快慢引用，即一个快引用（每次走两步）和一个慢引用（每次走一步），如果快引用和慢引用能够相遇，则说明链表有环。

代码如下

public Entry<T> haveCircle() {//返回相遇结点，为下一道题铺垫
    if (headEntry == null || headEntry.getNext() == null) {
   	return null;
    }
    Entry<T> fast = headEntry;
    Entry<T> slow = headEntry;
    while (true) {
        fast = fast.getNext().getNext();
        slow = slow.getNext();
        if (fast == slow) {
            return fast;
        } else if (fast == null || fast.getNext() == null) {//没有环
            return null;
        }
    }
}

5.如果链表有环，输出环的入口结点（续4）

设起始点到相遇点距离为L，环的长度为R，入口点到相遇点为x。如果快慢引用相遇，那么快引用一定比慢引用多走了nR，此时快引用所走的路程是慢引用所走路程的2倍，即L+nR+x=2(L+x)，解得L=nR-x=R-x+(n-1)R。

当n=1时，起始点到入口点的距离等于相遇点到入口点的距离，此时在起始点定义p，在相遇点定义q，同时向后移动，当p=q时，p（或q）指向入口结点。（若n不为1，则是由于L过长，q会走(n-1)圈+相遇点到入口点距离之后与p在入口结点相遇）
在这里插入图片描述
代码如下

public Entry<T> enterPoint() {
    Entry<T> meetPoint = haveCircle();//相遇点
    if (meetPoint == null) {
        return null;
    }
    Entry<T> p = meetPoint;
    Entry<T> q = headEntry;
    while (p != q) {
        p = p.getNext();
        q = q.getNext();
    }
    return p;
}

6.两个有序单链表合并成一个有序单链表

首先两个链表的头进行比较，小的作为新链表的头，之后再往后进行比较，小的就链在新链表头的后面，依次进行。
在这里插入图片描述
代码如下

public static <E extends Comparable<E>> void mergeOrder(LinkWithTail<E> link1, LinkWithTail<E> link2) {
    if (link1.headEntry == null && link2.headEntry == null) {
        return;
    } else if (link1.headEntry == null && link2.headEntry != null) {
        link2.show();//若链表1为空，直接打印链表2
        return;
    }else if(link1.headEntry!=null&&link2.headEntry==null){
        link1.show();//若链表2为空，直接打印链表1
        return;
    }
    Entry<E> p = link1.headEntry;
    Entry<E> q = link2.headEntry;
    Entry<E> newHeadEntry = p.getValue().compareTo(q.getValue()) > 0 ? q : p;//小的作为新链表的头
    Entry<E> newTailEntry = newHeadEntry;//标记新链表的尾节点
    if (newHeadEntry == p) {
        p = p.getNext();
    } else {
        q = q.getNext();
    }
    while (p != null && q != null) {
        if (p.getValue().compareTo(q.getValue()) < 0) {
            newTailEntry.setNext(p);
            newTailEntry = newTailEntry.getNext();
            p = p.getNext();
        } else if (p.getValue().compareTo(q.getValue()) > 0) {
            newTailEntry.setNext(q);
            newTailEntry = newTailEntry.getNext();
            q = q.getNext();
        } else {
            newTailEntry.setNext(p);
            newTailEntry.setNext(q);
            newTailEntry = newTailEntry.getNext().getNext();
        }
    }
    if (p == null) {//p（或q）为空时，直接将q（或p）链接到新链表的尾节点之后
        newTailEntry.setNext(q);
    } else {
        newTailEntry.setNext(p);
    }
    for (Entry<E> i = newHeadEntry; i != null; i = i.getNext()) {//打印
        System.out.print(i.getValue() + " ");
    }
}

7.复杂链表的拷贝

在这里插入图片描述
代码如下（附测试代码）

public class ComplexLink<T> {
    static class Node<E> {//复杂链表的节点
        private E value;
        private Node<E> next;
        private Node<E> random;

        public Node() {//head
        }

        public Node(E value) {
            this.value = value;
        }
    }

    private Node<T> head = null;

    public ComplexLink() {
        head = new Node<T>();
    }

    public void insert(T value, Node<T> random) {//头插法
        Node<T> node = new Node<>(value);
        node.random = random;
        node.next = head.next;
        head.next = node;
    }

    public void createList(T[] arr) {//创建一个复杂链表
        if (arr.length > 3) {
            Object[] node = new Object[arr.length];
            int i = 0;
            for (i = 0; i < arr.length; i++) {
                node[i] = new Node<T>(arr[i]);
            }
            insert(arr[0], (Node<T>) node[arr.length - 1]);
            insert(arr[1], (Node<T>) node[arr.length - 2]);
            insert(arr[2], (Node<T>) node[arr.length - 3]);
            for (i = 3; i < arr.length; i++) {
                insert(arr[i], null);
            }
        }
    }

    public void cloneNodes() {//把复制的节点链接在原始链表的每一对应节点后面
        Node<T> node = head;
        while (node != null) {
            Node<T> clone = new Node<>(node.value);
            clone.random = null;
            clone.next = node.next;
            node.next = clone;

            node = node.next.next;
        }
    }

    public void connectRandom() {//复制的节点的random指针指向被复制节点的random指针的下一个节点
        Node<T> node = head;
        while (node != null) {
            Node<T> clone = node.next;
            if (node.random != null) {
                clone.random = node.random.next;
            }
            node = node.next.next;
        }
    }

    public Node<T> separateLists() {//拆分为两个链表，此代码中奇数位置为复制链表
        Node<T> node = head;
        Node<T> cloneHead = node;
        Node<T> cloneNode = node.next;
        node.next = cloneNode.next;
        node = node.next;
        while (node != null) {
            cloneNode.next = node.next;
            cloneNode = cloneNode.next;
            node.next = cloneNode.next;
            node = node.next;
        }
        return cloneHead;
    }

    public Node<T> clone() {//三个步骤代码合并
        cloneNodes();
        connectRandom();
        return separateLists();
    }

    public void show() {//打印
        Node<T> p = head.next;
        while (p != null) {
            if (p.random != null) {
                System.out.println("value:  " + p.value + "  random: " + p.random.value);
            } else {
                System.out.println("value:  " + p.value + "  random: " + p.random);
            }
            p = p.next;
        }
        System.out.println();
    }

    public static void main(String[] args) {
        Integer[] arr = {1, 2, 3, 4, 5, 6};
        ComplexLink<Integer> link = new ComplexLink<>();
        link.createList(arr);
        link.clone();
        link.show();
    }
}
Jaye_L
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Java数据结构与算法——链表面试题
baijaiyu的博客
09-13 1328
本文为链表相关面试题，每道题均附讲解及对应连接。 一：反转一个单链表。 链接：206. 反转链表 - 力扣（LeetCode）https://leetcode.cn/problems/reverse-linked-list/description/ 1.题目：给你单链表的头节点 head ，请你反转链表，并返回反转后的链表。2. 2.解题 我的思路是：从第二个结点开始，依次将后一个结点的指向改变为指向前一个结点。如果直接改变指向，那么就无法找到下一个结点了，所.....
【Java 数据结构】单链表经典面试题 (动图解析)
书生-w的博客
04-16 1万+
链表几乎可以说是数据结构的重中之重，链表也是大厂面试必考的知识点，要想学好链表，最重要的就是画图解决问题，
【数据结构】《动图演示》单链表实现
最新发布
Eraser的博客
04-18 515
一般定义结构前，我们会先重命名该结构的数据类型，因为这个结构可能会存放不止一种数据，可能会存放int、float、double等等，所以为了方便我们代码后期维护，重定义后只需要改变一处就可以了。// 存放的数据类型数据域（data）和指针域（next）data：存放结点的数据部分next：存放下一个结点（结构体）的地址// 单链表结点的定义// 数据域// 指针域}SListNode;这里的意思就是重命名，把sturct SListNode 命名为SListNode。
【数据结构】动图详解单向链表
忆梦初心的博客
01-31 2245
顺序表中间及头部的插入与删除，需要对原有数据进行移动，时间复杂度为O(N),成本较高使用realloc进行增容时需要申请新空间，释放旧空间，拷贝数据，消耗较高。由于我们无法知道用户实际需要多少空间，在增容时往往可能会有大量的空间剩余。那么这些问题要如何解决呢？通过链表。 链表是一种物理存储结构上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。每当我们需要新增数据时，我们只需申请一个新结点用来保存数据，然后用指针将链表与新结点链接起来即可，并不需要进行数据拷贝。
Java数据结构之单链表（配图详解，简单易懂）
如风暖阳的博客
01-17 3983
Java数据结构之单链表（配图详解，简单易懂）
链表 java详解_链表详解——Java版
weixin_31090403的博客
02-16 1189
什么是链表？链表是一个线性结构，但是存储的数据可以是非线性的。链表由一个个子节点构成，每个节点有两个部分：数据域和指针域，数据域就是实际存储数据的，指针域可以有一个和两个，单链表就是单个指针域指向后一个节点，双链表就是节点有两个指针域，分别指向前一个和后一个节点。链表的核心：链表的核心就是指针域，通过对指针域的操作实现增加节点删除节点，所谓链表就是形象的表示出一环扣一环，这是链表的优点也是缺点，优...
java常见面试题总结
01-23
以下是对几个常见面试题的详细解答： 1. **Map在JDK1.7到JDK1.8的变化** 在JDK1.8中，HashMap的数据结构发生了显著变化。它引入了红黑树（Red-Black Tree）的概念。当链表长度超过8个节点时，链表会转换为红黑树，...
2022Java经典面试题总结(附问题和答案)
05-17
在Java编程领域，面试题常常涉及到语言基础、面向对象特性、类库使用等多个方面。以下是对给定标题和描述中提及的一些关键知识点的详细解释： 1. **面向对象封装**：封装是面向对象编程的核心原则之一，它隐藏了...
2022年Java面试题个人总结答案.docx
11-11
Java面试题个人总结答案 一、Java基础篇 1. Java类加载器 Java类加载器加载类次序依次为：JVM类加载器、扩展类加载器、系统类加载器、顾客自定义类加载器。其中，系统类加载器先加载。 2. 堆和栈的区别 栈存储...
JAVA经典面试题附答案
06-16
JAVA经典面试题附答案 JAVA基础知识点： 1. JAVA中的基本类型： JAVA中的基本类型有八种：byte、short、int、long、float、double、char、boolean。每种类型占用的字节数分别为：1、2、4、8、4、8、2、1。 2. ...
JAVA实现链表面试题
bin的主栏
07-08 5970
这篇文章主要介绍了JAVA相关实现链表的面试题，代码实现非常详细，每一个方法讲解也很到位，特别适合参加Java面试的朋友阅读。 这份笔记整理了整整一个星期，每一行代码都是自己默写完成，并测试运行成功，同时也回顾了一下《剑指offer》这本书中和链表有关的讲解，希望对笔试和面试有所帮助。 本文包含链表的以下内容： 　　1、单链表的创建和遍历 　　2、求单链表中
【完整程序】Java实现单链表+双链表操作+单向循环链表
qq_38596491的博客
03-25 255
参考自视频：《尚硅谷Java数据结构和Java算法》，并对代码进行详细解释 public class SingleLinkedListDemo { public static void main(String[] args) { //创建结点对象 HeroNode hero1 = new HeroNode(1,"宋江","及时雨"); HeroNode hero2 = new He...
链表入门指北
Time_Limit的博客
08-24 372
给出维护有序数组的场景，分析数组的局限性。引入链表。 链表是什么。 链表的存储方式。 链表的基本操作。 链表和数组的区别。 链表和数组的应用场景。 链表的解题技巧。 相爱相杀好基友——数组与链表 作为线性表的两种存储方式 —— 链表和数组，这对相爱相杀的好基友有着各自的优缺点。接下来，我们梳理一下这两种方式。 数组，所有元素都连续的存储于一段内存中，且每个元素占用的内存大小相同。这使得数组具备了通过下标快速访问数据的能力。 但连续存储的缺点也很明显，增加容量，增删元素的成本很高，时间复杂度均为 O(n)O(
数据结构之链表-动图演示
HuaZi_Myth的博客
11-12 665
链表简介 链表是很常见的数据结构，由一个个节点组成，每个节点中储存着数据和指针(地址引用)，指针负责节点间的连接。 它是一种线性表，线性表有两种存储方式：顺序存储和链式存储。链表属于链式存储，顺序由元素间的指针决定，元素在内存中非连续存放，且链表长度可以改变。数组是顺序存储的线性表，元素在内存中连续存放的，且数组创建时大小已固定。 链表可以用来实现栈和队列数据结构(栈和队列可理解为逻辑类数据...
双向链表（动图讲解）-Java数据结构和算法
qq_31747473的博客
03-08 410
单向链表基本操作 图解 文章目录前言一、双向链表的介绍：二、相关操作1. 新建双向链表的类2.删除数据(变化较大，有坑????)3. 中间添加数据4.尾部添加数据(稍微变化)5.修改数据(思路不变)6.双向链表的遍历(无变化)总结 前言       对于单向链表来说，查找的方向只能单向的，所以进行删除或插入，我们需要找到目标的前一个结点（无法实现向后查找的弊端）。       单向链表
Java实现单链表面试题
Leetp
04-07 595
Java链表面试题
链表详解（易懂）
热门推荐
SlimShadyKe的博客
04-24 6万+
链表是一系列的存储数据元素的单元通过指针串接起来形成的，因此每个单元至少有两个域，一个域用于数据元素的存储，另一个或两个域是指向其他单元的指针。这里具有一个数据域和多个指针域的存储单元通常称为节点（node）。 链表的第一个节点和最后一个节点，分别称为链表的头节点和尾节点。尾节点的特征是其 next 引用为空（null）。链表中每个节点的 next 引用都相当于一个指针，指向另一个节点，借助这些...
算法--路径总和
CodersCoder的博客
09-08 574
描述 给定一个二叉树和一个目标和，判断该树中是否存在根节点到叶子节点的路径，这条路径上所有节点值相加等于目标和。 说明: 叶子节点是指没有子节点的节点。 示例 分析 从根节点开始，使用递归，判断左节点或者右节点到叶子节点是否存在sum-root.val即可。 实现 class Solution { public boolean hasPathSum(TreeNode root, int sum) { if (root == null) { return fa
Java链表面试题详解：创建、遍历到反转
在Java面试中，链表是常见的数据结构，其灵活的操作和广泛的应用使得理解和熟练掌握链表至关重要。以下是上述内容中涉及的知识点详解： 1、单链表的创建和遍历： 单链表由一系列节点组成，每个节点包含数据和指向下...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值