Java算法体系学习（六）链表的相关面试题（复制链表、找中点、快慢指针、寻找有环链表的入环节点、求两个链表的交点、回文链表）

最新推荐文章于 2024-07-29 18:00:00 发布
最新推荐文章于 2024-07-29 18:00:00 发布
阅读量400 收藏
点赞数
分类专栏： Java算法体系学习 文章标签： 链表 java 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45071560/article/details/122362419
版权

文章目录

五、链表的面试题

  • 对于笔试，不用在意空间复杂度，一切为了时间复杂度
  • 对于笔试，时间复杂度放在第一位，一定找到空间最优的方法
  • 笔试技巧：
    1. 使用容器，哈希表、集合、优先队列、栈、队列
    2. 快慢指针
  • 笔试求稳，面试求骚

1、快慢指针

1.1 给定一个链表头节点，找到链表的中点位置

  • 如果节点个数为奇数，则返回中间的节点

  • 如果为偶数，返回中间的前一个位置和后一个位置（两个方法）

  • 思想：准备两个指针，一个slow，一个fast。slow每次走一步，fast一次走两步，当fast走到链表尾部的时候，slow刚好走在链表中间，但是要注意边界判断

package list;

public class LinkedListMid {

    /**
     * 返回链表的中间节点，如果总节点数为偶数，则返回中间位置的后一个位置节点
     * @param head
     * @param <T>
     * @return
     */
    public static  <T>  Node<T> getListMidAfter(Node<T> head){
        if (head == null || head.next == null){
            return head;
        }

        Node<T> slow = head;
        Node<T> fast = head;

        //fast.next != null时候进入循环不会发生空指针问题
        while (fast != null && fast.next != null){
            //慢指针先走，这样快指针到末尾时候，如果节点总数为偶数则慢指针刚好在中间偏后的一个位置
            slow = slow.next;
            fast = fast.next.next;
        }
        return slow;
    }


    /**
     * 返回链表的中间节点，如果总节点数为偶数，则返回中间位置的前一个一个位置节点
     * @param head
     * @param <T>
     * @return
     */
    public static  <T>  Node<T> getListMidPre(Node<T> head){
        if (head == null || head.next == null){
            return head;
        }

        Node<T> slow = head;
        Node<T> fast = head;

        //fast.next != null时候进入循环不会发生空指针问题
        while (fast != null && fast.next != null){
            //快指针先走，加一次判断，如果快指针到末尾时候，则慢指针不需要走了，直接跳出，如果节点总数为偶数则慢指针刚好在中间偏前的一个位置
            fast = fast.next.next;
            if(fast == null){
                break;
            }
            slow = slow.next;

        }
        return slow;
    }
    

}

1.2 给定一个链表的头结点，判断是否为回文结构

  • 笔试时候，直接用栈结构，所有节点入栈然后逆序弹出与原链表对比。时间复杂度O(N)，空间复杂度O(N)
  • 面试技巧：
    1. 找到链表的中点，然后把后半部分翻转
    2. 依次遍历两个链表相应位置，判断是否相同
    3. 最后要把链表还原
package list;

import java.time.Period;
import java.util.Stack;

public class IsPalindromeList {
    /**
     * 判断链表是否为回文结构，用栈实现，时间空间复杂度都为O(N)
     * @param head
     * @param <T>
     * @return
     */
    public static <T> boolean isPalindromeListByStack(Node<T> head){
        if(head == null || head.next == null){
            return true;
        }

        Stack<Node<T>> stack = new Stack<>();
        Node<T> cur = head;
        while (cur != null){
            stack.push(cur);
            cur = cur.next;
        }

        while (head != null){
            if (!head.value.equals(stack.pop().value)){
                return false;
            }
            head = head.next;
        }
        return true;
    }


    /**
     *  判断链表是否为回文结构，用逆序链表实现，时间复杂度O(N),空间复杂度为O(1)
     * @param head
     * @param <T>
     * @return
     */
    public static <T> boolean isPalindromeListByMe(Node<T> head){
        if(head == null || head.next == null){
            return true;
        }

        //找出链表中点位置的节点，偶数时候找较后位置的一个节点
        Node<T> slow = head;
        Node<T> fast = head;
        while (fast != null && fast.next != null){
            slow = slow.next;
            fast = fast.next.next;
        }

        //翻转后半部分链表
        Node<T> pre = null;
        Node<T> next = null;
        while (slow != null){
            next = slow.next;
            slow.next = pre;
            pre = slow;
            slow = next;
        }

        //开始比较两个回文结构
        boolean isPalindrome = true;
        Node<T> leftHead = head;
        Node<T> rightHead = pre;
        while (rightHead != null){
            if(!leftHead.value.equals(rightHead.value)){
                isPalindrome = false;
                break;
            }
            rightHead = rightHead.next;
            leftHead = leftHead.next;
        }

        //还原链表
        Node<T> before = null;
        while (pre != null){
            next = pre.next;
            pre.next = before;
            before = pre;
            pre = next;
        }
        return isPalindrome;
    }
    
    
    //打印链表数据的静态方法，方便查看链表是否被还原
    public static <T> void print(Node<T> head){
        while (head != null){
            System.out.print(head.value + "   ->  ");
            head = head.next;
        }
        System.out.println();
    }

//    public static void main(String[] args) {
//        Node<Integer> node1 = new Node<>(1);
//        node1.next = new Node<>(2);
//        node1.next.next = new Node<>(3);
//        node1.next.next.next = new Node<>(2);
//        node1.next.next.next.next = new Node<>(1);
//        print(node1);
//        System.out.println(isPalindromeListByStack(node1));
//        print(node1);
//        System.out.println(isPalindromeListByMe(node1));
//        print(node1);
//    }

}

2、链表复制问题

  • 给定一个链表，每个节点除了有指向下一个节点的指针之外，还带有一个随机指针指向链表的随机一个节点，请完成链表的复制（建立一条新的链表）
  • 两种方法：
    • 方法一： 用一个map，先遍历一遍链表，key存储当前链表节点，value存储值相同的新节点（新创建的节点），next和random指针置空。再遍历一遍链表，根据key的next和random指针找到对应key的value进行赋值。第一遍不能赋值next和random指针，因为表中还没有放进去相应位置的节点。
    • 方法二： 在原始链表上为每个节点后面插入一个copy节点，与前面的值相同。再次遍历链表，根据原始节点的random找到next为copy节点的random赋值，最后将两个链表拆分即可。
package list;

import java.util.HashMap;
import java.util.HashSet;

public class LinkedListRandomCopy {
    public static class RandomNode{
        public int value;
        public RandomNode next;
        public RandomNode random;

        public RandomNode(int value){
            this.value = value;
            next = null;
            random = null;
        }
    }

    /**
     * 用hash表完成链表复制
     * @param head
     * @return
     */
    public static RandomNode copyByHashMap(RandomNode head){
        if(head == null){
            return null;
        }

        HashMap<RandomNode, RandomNode> map = new HashMap<>();
        RandomNode cur = head;

        //第一遍将节点放入map
        while (cur != null){
            map.put(cur,new RandomNode(cur.value));
            cur = cur.next;
        }

        cur = head;
        while (cur != null){
            map.get(cur).next = map.get(cur.next);
            map.get(cur).random = map.get(cur.random);
            cur = cur.next;
        }

        return map.get(head);
    }

    /**
     * 用有限个变量完成链表复制
     * @param head
     * @return
     */
    public static RandomNode copyLinkedListByMe(RandomNode head){
        if(head == null){
            return null;
        }

        RandomNode cur = head;
        RandomNode next = null;
        //给每个节点后面加一个复制节点
        while (cur != null){
            next = cur.next;
            cur.next = new RandomNode(cur.value);
            cur.next.next = next;
            cur = next;
        }


        //再次遍历链表，为random指针赋值
        cur = head;
        while (cur != null){
            cur.next.random = cur.random.next;
            cur = cur.next.next;
        }

        //分离链表
        cur = head;
        RandomNode copyHead = head.next;
        RandomNode copyCur = copyHead;
        while (true){
            cur.next = copyCur.next;
            if(copyCur.next == null){
                break;
            }
            cur = cur.next;
            copyCur.next = cur.next;
            copyCur = copyCur.next;
        }

        return copyHead;
    }


    //生成制定个数的随机链表
    public static RandomNode getRandomNode(int num){
        if(num < 0){
            return null;
        }

        HashMap<Integer, RandomNode> map = new HashMap<>();
        RandomNode head = new RandomNode((int) (Math.random() * 100));
        map.put(0,head);
        RandomNode cur = head;
        for (int i = 1;i < num;i++){
            cur.next = new RandomNode((int) (Math.random() * 100));
            cur = cur.next;
            map.put(i,cur);
        }

        cur = head;
        while (cur != null){
            cur.random = map.get((int) (Math.random() * num));
            cur = cur.next;
        }
        return head;
    }

    //打印链表元素，方便测试
    public static void print(RandomNode head){
        while (head != null){
            System.out.print(head.value + " ->  ");
            head = head.next;
        }
        System.out.println();
    }


    public static void main(String[] args) {
        RandomNode head = getRandomNode(10);
        print(head);
        RandomNode copyOne = copyByHashMap(head);
        print(copyOne);
        print(head);

        RandomNode copyTwo = copyLinkedListByMe(head);
        print(copyTwo);
        print(head);

    }

}

3、判断两个有环或者无环链表是否相交，如果有就返回第一个相交节点，如果没有则返回null

1. 先判断一个链表是否有环，如果有环就返回第一个入环节点，如果没有就返回null

  • 生成快慢两个指针，快指针一次两步，慢指针一次一步，如果没有环，则快指针一定会走到链表末尾，这时直接返回空即可。
  • 如果链表有环，那么快慢指针一定会在环上某个节点相遇。因为快慢指针一旦入环，都会在环上循环，而快指针每次比慢指针快一步，那么最多经过N（环上节点的个数）步必定追上慢指针。
  • 当有环并且快慢指针相遇时，让快指针回到链表头结点，并且每次只有一步，当再次相遇时就是入环节点。
    public static class Node {
        public int value;
        public Node next;

        public Node() {
        }

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

    /**
     * 判断链表是否有环，有返回第一个入环节点，没有返回null
     * @param head  头结点
     * @return  第一个入环节点
     */
    public static Node getLoopNode(Node head){
        if(head == null || head.next == null || head.next.next == null){
            return null;
        }

        Node slow = head.next;
        Node fast = head.next.next;

        //如果没有环就返回null，不会在继续执行。如果有环则继续向下执行
        while (slow != fast){
            if(fast.next == null || fast.next.next == null){
                return null;
            }
            fast = fast.next.next;
            slow = slow.next;
        }

        //fast来到头结点，每次也走一步，这样相遇时返回就是入环节点
        fast = head;
        while (fast != slow){
            fast = fast.next;
            slow = slow.next;
        }

        return slow;
    }

2、判断两个无环链表是否相交

  • 给定两个无环链表的头结点（链表是否有环可以用上面判断），如果两个链表相交则返回相交节点，没有则返回null
  • 思路：
    1. 遍历两个链表，分别记录两个链表的长度，并记录两个链表的尾结点
    2. 如果两个链表最后一个节点相等（指的是内存地址，直接==），则必定相交，继续下一步
    3. 让长链表先走（n1 - n2）步（n1为长链表的长度），然后两个链表一起走，直到遇见相等的节点
    /**
     * 判断两个无环链表是否相交，是返回第一个相交节点，否则返回null
     * @param head1
     * @param head2
     * @return
     */
    public static Node noLoop(Node head1, Node head2){
        if(head1 == null || head2 == null){
            return null;
        }

        Node cur1 = head1;
        Node cur2 = head2;

        int n1 = 0,n2 = 0;
        while (cur1.next != null){
            n1++;
            cur1 = cur1.next;
        }

        while (cur2.next != null){
            n2++;
            cur2 = cur2.next;
        }

        if(cur1 != cur2){
            return null;
        }

        //让cur1来到长链表的头结点，cur2来到短链表的头节点
        int diff = n1 - n2;
        cur1 = diff >= 0 ? head1 : head2;
        cur2 = cur1 == head1 ? head2 : head1;

        //长链表先走diff步
         diff = Math.abs(diff);
        while (diff-- > 0){
            cur1 = cur1.next;
        }

        //两个链表开始一起走，直到遇见相交节点
        while (cur1 != cur2){
            cur1 = cur1.next;
            cur2 = cur2.next;
        }

        return cur1;
    }

3. 判断两个有环链表是否相交

  • 判断两个有环链表是否相交

    1. 都有环但不相交

    2. 未入环之前相交

    3. 在环上相交

      3.1 入环处交于一点

      3.2 在环上不同点相交

  /**
     * 判断两个有环链表是否相交，若相交则返回第一个相交节点
     * 1.   都有环但不相交
     * 2.   未入环之前相交
     * 3.   在环上相交
     *     3.1  入环处交于一点
     *     3.2 在环上不同点相交
     * @param head1 第一个链表头结点
     * @param head2 第二个链表头结点
     * @param loop1 第一个链表入环节点
     * @param loop2 第二个链表入环节点
     * @return
     */
    public static Node bothLoop(Node head1,Node head2,Node loop1,Node loop2){
        //如果入环节点相同
        //在入环节点相交
        //在未入环处相交
        if(loop1 == loop2){
            Node cur1 = head1;
            Node cur2 = head2;

            //找出每个链表（不包括环的长度）
            int n1 = 0;
            int n2 = 0;
            while (cur1 != loop1){
                n1++;
                cur1 = cur1.next;
            }
            while (cur2 != loop2){
                n2++;
                cur2 = cur2.next;
            }

            //让cur1来到长链表的头结点，cur2来到短链表的头节点
            int diff = n1 - n2;
            cur1 = diff >= 0 ? head1 : head2;
            cur2 = cur1 == head1 ? head2 : head1;

            //长链表先走diff步
             diff = Math.abs(diff);
            while (diff-- > 0){
                cur1 = cur1.next;
            }

            //两个链表开始一起走，直到遇见相交节点
            while (cur1 != cur2){
                cur1 = cur1.next;
                cur2 = cur2.next;
            }
            return cur1;
        }else {
            //两种情况，不相交或者在环上相交
            //如果第一个链表把环走一圈没有遇到loop2.则说明不相交
            //如果相交，返回loop1或loop2中的任意一个
            Node cur1 = loop1.next;
            while (cur1 != loop1){
                if(cur1 == loop2){
                    return loop2;
                }
                cur1 = cur1.next;
            }
            return null;
        }

4、整合

    public static Node getIntersectNode(Node head1,Node head2){
        if(head1 == null || head2 == null){
            return null;
        }

        //1. 先判断两个链表是否有环
        Node loop1 = getLoopNode(head1);
        Node loop2 = getLoopNode(head2);

        //2.两个链表都有环
        if(loop1 != null && loop2 != null){
            return bothLoop(head1,head2,loop1,loop2);
        }

        //3.两个链表都无环
        if(loop1 == null && loop2 == null){
            return noLoop(head1,head2);
        }
        
        //4.其中一个有环，一个无环。这种情况下不可能相交（如果相交，则必定会有环）
        return null;
    }
冷奴lengnu
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java算法判断链表有没有闭环_【算法问题】如何判断链表有环
weixin_31785421的博客
02-28 827
如何判断链表有环摘自漫画算法：题目：有一个单向链表，链表中有可能出现“环”，就像下图这样，那么如何用程序来判断该链表是否为有环链表呢？方法1首先从头节点开始，以此遍历单链表中的每一个节点。每遍历一个新节点，就从头检查新节点之前的所有节点，用新节点和此节点之前所有节点依次做比较。如果发现新节点和之前的某个节点相同，则说明该节点被遍历过两次，链表有环。如果之前的所有节点中不存在与新节点相同的节点，就继...
面试题快慢链表和快慢指针
08-30
快慢链表和快慢指针是一种常见的数据结构和算法设计模式，广泛应用于各种面试题中，例如腾讯的一道面试题：如何快速找到位置长度单链表的中间节点？本文将详细介绍快慢链表和快慢指针的原理、实现和应用。 快慢链表...
Java面试题（八）链表常见算法题
岁月不饶人，我亦未曾饶过岁月
12-27 1068
链表常见算法
Java数据结构与算法——链表面试题
baijaiyu的博客
09-13 1338
本文为链表相关面试题，每道题均附讲解及对应连接。 一：反转一个单链表。 链接：206. 反转链表 - 力扣（LeetCode）https://leetcode.cn/problems/reverse-linked-list/description/ 1.题目：给你单链表的头节点 head ，请你反转链表，并返回反转后的链表。2. 2.解题 我的思路是：从第二个结点开始，依次将后一个结点的指向改变为指向前一个结点。如果直接改变指向，那么就无法找到下一个结点了，所.....
天下三分明月夜，独有快慢指针法（链表面试题篇1）
mgzdwm的博客
03-30 1028
1. 寻找链表的中间结点 2. 判断链表是否带环 3. 返回链表倒数第k个节点
【算法面试必刷Java版六】判断链表是否有环
莫安逸无风雪
09-05 3036
判断给定的链表中是否有环。如果有环则返回true，否则返回false。
面试题 02.08. 环路检测-快慢指针+如何找到环的入口？（证明）Java
junewgl
04-17 1397
判断是否有环+环的入口+证明
【数据结构与算法】2、链表（简单模拟 Java 中的 LinkedList 集合，反转链表面试题）
m0_54189068的博客
06-24 712
简单实现 Java 中的 LinkedList 集合；反转一个链表 Leetcode 题；判断一个链表是否有环 Leetcode题
面试热点题：环形链表及环形链表寻找环入口结点问题
DEXTERFUTIAN的博客
03-04 1686
问题：给你一个链表的头节点 head ，判断链表中是否有环。如果链表中有某个节点，可以通过连续跟踪 next 指针再次到达，则链表中存在环。为了表示给定链表中的环，评测系统内部使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。注意：pos 不作为参数进行传递。仅仅是为了标识链表的实际情况。如果链表中存在环 ，则返回 true。否则，返回 false。来源：力扣（LeetCode）思路一：暴力解法。
【Java】利用双指针解决十道经典的链表面试题（图文详解）
Superkom666的博客
09-21 932
有以下几道经典的题目 1.删除链表中等于给定值 val 的所有节点 2.反转一个单链表 3.给定一个带有头结点 head 的非空单链表，返回链表的中间结点 4.输入一个链表，输出该链表中倒数第k个结点 5.将两个有序链表合并为一个新的有序链表并返回 6.以给定值x为基准将链表分割成两部分 7.链表的回文结构 8.输入两个链表，找出它们的第一个公共结点 9.给定一个链表，判断链表中是否有环 10.给定一个链表，返回链表开始入环的第一节点
Java面试题-实现复杂链表的复制代码分享
08-29
主要介绍了Java面试题-实现复杂链表的复制代码分享，小编觉得还是挺不错的，具有参考价值，需要的朋友可以了解下。
java基础面试题复杂链表的复制
11-12
java基础面试题复杂链表的复制本资源系百度网盘分享地址
java基础面试题删除链表中重复的节点
11-13
java基础面试题删除链表中重复的节点本资源系百度网盘分享地址
使用hutool工具判断字符串是否全部是字母(包括大小写)，java判断字符串是否全部是字母(包括大小写)
qq_43700885的博客
07-29 245
1.导入hutool的maven依赖。2.复制一下代码执行。
golang 接口
m0_70982551的博客
07-24 988
接口定义了一组方法，这些方法没有具体的实现。接口类型的变量可以存储任何实现了这些方法的类型的值。// 更多方法...在Go语言中，接口值是指存储了实现某个接口的具体类型值的变量。接口值由两部分组成：1.动态类型：这是接口值当前存储的实际类型。2.动态值：这是实际存储的值，该值必须实现了接口中定义的所有方法。
java判断邮箱地址是否正确，使用hutool工具判断邮箱地址是否正确
qq_43700885的博客
07-29 94
1.导入hutool的maven依赖。2.直接复制一下代码运行。
Swagger使用Map接受参数时，页面如何显示具体参数及说
a1058926697的博客
07-26 528
后端使用Map接受参数，要求在swagger页面上显示具体的参数名称、类型及说明。当Map接受参数数量少时，可以使用Swagger自带的注解。自定义注解 @ApiGlobalModel。编写处理注解对应的插件。
26.jdk源码阅读之ConcurrentLinkedQueue
最新发布
前端、移动端、后端源码级底层原理分享
07-29 579
ConcurrentLinkedQueue 是 Java 中提供的一个基于无界非阻塞算法的线程安全队列。它是一个适用于高并发环境的队列实现，基于链表结构。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值