【刷题】求两单向链表交点（可能有环）

已于 2022-08-26 11:36:22 修改
阅读量101 收藏
点赞数
分类专栏： LeetCode 文章标签： 链表 java 数据结构
于 2022-08-26 10:19:06 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yexiguafu/article/details/126537919
版权 
//Java版．左老师给出的代码，很赞
   //package problems_2017_08_16;
   
   public class Problem_03_FindFirstIntersectNode {
   
       public static class Node {
           public int value;
           public Node next;
   
          public Node(int data) {
              this.value = data;
          }
      }
  
      public static Node getIntersectNode(Node head1, Node head2) {
          if (head1 == null || head2 == null) {
              return null;
          }
          Node loop1 = getLoopNode(head1);
          Node loop2 = getLoopNode(head2);
          if (loop1 == null && loop2 == null) {
              return noLoop(head1, head2);
          }
          if (loop1 != null && loop2 != null) {
              return bothLoop(head1, loop1, head2, loop2);
          }
          return null;
      }
  
      public static Node getLoopNode(Node head) {
          if (head == null || head.next == null || head.next.next == null) {
              return null;
          }
          Node n1 = head.next; // n1 -> slow
          Node n2 = head.next.next; // n2 -> fast
          while (n1 != n2) {
              if (n2.next == null || n2.next.next == null) {
                  return null;
              }
              n2 = n2.next.next;
              n1 = n1.next;
          }
          n2 = head; // n2 -> walk again from head
          while (n1 != n2) {
              n1 = n1.next;
              n2 = n2.next;
          }
          return n1;
      }
  
      public static Node noLoop(Node head1, Node head2) {
          if (head1 == null || head2 == null) {
              return null;
          }
          Node cur1 = head1;
          Node cur2 = head2;
          int n = 0;
          while (cur1.next != null) {
              n++;
              cur1 = cur1.next;
          }
          while (cur2.next != null) {
              n--;
              cur2 = cur2.next;
          }
          if (cur1 != cur2) {
              return null;
          }
          cur1 = n > 0 ? head1 : head2;
          cur2 = cur1 == head1 ? head2 : head1;
          n = Math.abs(n);
          while (n != 0) {
              n--;
              cur1 = cur1.next;
          }
          while (cur1 != cur2) {
              cur1 = cur1.next;
              cur2 = cur2.next;
          }
          return cur1;
      }
  
      public static Node bothLoop(Node head1, Node loop1, Node head2, Node loop2) {
          Node cur1 = null;
          Node cur2 = null;
          if (loop1 == loop2) {
              cur1 = head1;
              cur2 = head2;
              int n = 0;
              while (cur1 != loop1) {
                  n++;
                  cur1 = cur1.next;
              }
              while (cur2 != loop2) {
                  n--;
                  cur2 = cur2.next;
              }
              cur1 = n > 0 ? head1 : head2;
              cur2 = cur1 == head1 ? head2 : head1;
             n = Math.abs(n);
             while (n != 0) {
                 n--;
                 cur1 = cur1.next;
             }
             while (cur1 != cur2) {
                 cur1 = cur1.next;
                 cur2 = cur2.next;
             }
             return cur1;
         } else {
             cur1 = loop1.next;
             while (cur1 != loop1) {
                 if (cur1 == loop2) {
                     return loop1;
                 }
                 cur1 = cur1.next;
             }
             return null;
         }
     }
 
     public static void main(String[] args) {
         // 1->2->3->4->5->6->7->null
         Node head1 = new Node(1);
         head1.next = new Node(2);
         head1.next.next = new Node(3);
         head1.next.next.next = new Node(4);
         head1.next.next.next.next = new Node(5);
         head1.next.next.next.next.next = new Node(6);
         head1.next.next.next.next.next.next = new Node(7);
 
         // 0->9->8->6->7->null
         Node head2 = new Node(0);
         head2.next = new Node(9);
         head2.next.next = new Node(8);
         head2.next.next.next = head1.next.next.next.next.next; // 8->6
         System.out.println(getIntersectNode(head1, head2).value);//output:6
 
         // 1->2->3->4->5->6->7->4...
         head1 = new Node(1);
         head1.next = new Node(2);
         head1.next.next = new Node(3);
         head1.next.next.next = new Node(4);
         head1.next.next.next.next = new Node(5);
         head1.next.next.next.next.next = new Node(6);
         head1.next.next.next.next.next.next = new Node(7);
         head1.next.next.next.next.next.next.next = head1.next.next.next; // 7->4
 
         // 0->9->8->2...
         head2 = new Node(0);
         head2.next = new Node(9);
         head2.next.next = new Node(8);
         head2.next.next.next = head1.next; // 8->2
         System.out.println(getIntersectNode(head1, head2).value);//output:2
 
         // 0->9->8->6->4->5->6..
         head2 = new Node(0);
         head2.next = new Node(9);
         head2.next.next = new Node(8);
         head2.next.next.next = head1.next.next.next.next.next; // 8->6
         System.out.println(getIntersectNode(head1, head2).value);//output:4
         System.out.println(getIntersectNode(head2, head1).value);//note the order //output:6
 
     }
 
 }

然后照着程序执行流程梳理思路：

０．判断两链表是否有环（分别找环入口结点，能找到则有环，否则无环）：

若都无环，转入第１步（可能是情况1或2）；

若都有环，转入第２步（可能是情况4或5或6）；

若一个有环一个无环，直接返回NULL，因为如果他们相交，是不可能一个有环一个无环的（图中情况3）；

１．都无环的情况，退化到两个无环链表找入口点的问题（可参见＜剑指offer＞和leetcode:Intersection of Two Linked Lists）

1.0 先判断两条链表的长度；

1.1 从头节点开始走，更长的链表先走＂长度之差＂步，然后一起走，如果相遇，则为入口点（情况2）；否则无交点（情况1）

２．都有环的情况，这种情况还要细分:

2.0 先判断两链表环入口点是否相同，若相同，则为情况4，转入步骤2.1；若不同，则为情况5或6，转入2.2；

2.1 如果为上图中情况4，我们可以把两链表交点作为＂假想的尾部节点＂，然后就退化成两个无环链表找交点的问题了；

2.2 为判断两链表是否有交点，我们可以从第一个环的入口节点的下一个节点开始next，如果遇到了第二个链表环的入口节点，则返回第一个链表的入口节点（情况5：题目说找出第一个相交的节点，其实我觉得返回第二个链表的入口节点也行）；反之，若走了一圈没遇到第二个链表环的入口节点，说明两链表不相交（情况6）；

至此，程序执行结束．设计很巧妙，要熟练掌握．

另外一段代码：

//综合：链表噩梦题之一：2条链表相交问题，链表可能有环，也可能无环，求交点
    public static Node nightMireCrossNode(Node head1, Node head2){
        if (head1 == null || head2 == null) return null;

        Node loop1 = getLoopNodeFace(head1);
        Node loop2 = getLoopNodeFace(head2);

        //（1）`loop1 == null && loop2 == null` 俩都无环，求相交点
        if (loop1 == null && loop2 == null) return noLoopNodeGetCross(head1, head2);
        //（2）`if(loop1 != null && loop2 == null)`
        // 或者：`if(loop1 == null && loop2 != null)`
        // 其中一个有环，有一个无环，求相交点
        else if (loop1 != null && loop2 != null) return bothHasLoopCross(head1, head2, loop1, loop2);
        //（3）`if(loop1 != null && loop2 != null)` 俩都有环，求相交点
        else return null;//压根没有的
    }

//对于环形链表来说，**求入环节点**就是一个玄学的数学推理
    //咱不用推，直接记住以下结论：
    //
    //（1）初始化快慢指针：slow先走1步，fast先走2步；
    //（2）如果快指针，先遇到null，则根本就不可能有环，返回null
    //（3）有环的话，slow和fast一定会相遇，这第一次相遇就证明了有环，就是这么巧！！！
    //（4）怎么找到那个入环节点呢？让fast回到head，和slow同步慢走（都只走1步），第二次相遇时，这个点，就是入环节点。
    public static Node getLoopNodeFace(Node head){
        if (head == null || head.next == null) return null;
        //（1）初始化快慢指针：slow先走1步，fast先走2步；
        Node slow = head.next;
        Node fast = head.next.next;
        //（2）如果快指针，先遇到null，则根本就不可能有环，返回null
        while (slow != fast){
            if (fast.next == null || fast.next.next == null) return null;
            //（3）有环的话，slow和fast一定会相遇，这第一次相遇就证明了有环，就是这么巧！！！
            fast = fast.next.next;
            slow = slow.next;
        }
        //（4）怎么找到那个入环节点呢？
        // 让fast回到head，和slow同步慢走（都只走1步），第二次相遇时，这个点，就是入环节
        fast = head;
        while (slow != fast){
            slow = slow.next;
            fast = fast.next;//同步走
        }
        //第二次相遇，必然是入环节点
        return slow;
    }

//给你2个链表和他们的入环节点，如果都没有环，求相交点
    //（1）让cur1走head1，cur2走head2
    //（2）如果走完之后，发现，cur1 = cur2，显然就是相交的
    //如何确定相交的交点呢？
    //（3）如果长的那根链表长度为n1，短的那根链表长度为n2，因为末端都是相同的，则必然
    //n1-n2就是交点之前，head1比head2多出来的长度
    //故，让cur从新从head1走n1-n2，再让head2和head1同步走，必定同时走到交点处。
    public static Node noLoopNodeGetCross(Node head1, Node head2){
        //既然没有环，那也不会有入环节点，就不用串loo1和loop2了
        if (head1 == null || head2 == null) return null;//压根没有第二条链表

        //用n来模拟长链和断链长度的差
        int n = 0;
        //（1）让cur1走head1，cur2走head2
        Node cur1 = head1;
        Node cur2 = head2;
        while (cur1 != null) {
            n++;//计数长度
            cur1 = cur1.next;
        }
        while (cur2 != null) {
            n--;//head2走就要--，最后n就是长短只差
            cur2 = cur2.next;
        }
        //（2）如果走完之后，发现，cur1 = cur2，显然就是相交的
        if (cur1 != cur2) return null;//两个链表平行，不想交

        //否则就是相交的
        //咱需要把长链给cur1，短链给cur2
        cur1 = n >= 0 ? head1 : head2;
        cur2 = cur1 == head1 ? head2 : head1;
        //然后差值将其正数画，现在长链已经在cur1上，n必须>0
        //让长链走线n，弥补差值
        n = n < 0 ? -n : n;
        while (n != 0){
            n--;
            cur1 = cur1.next;
        }
        //然后cur1和cur2同步走
        while (cur1 != cur2){
            cur1 = cur1.next;
            cur2 = cur2.next;
        }
        //一旦相遇，就是交点。

        return cur1;
    }


//给你2个链表和他们的入环节点，如果都有环，求相交交点
    //又分为以下三种小情况：
    //1）俩的环是独立的，压根不相交；
    //2）两个相交，而且入环节点是同一个；
    //3）2个链表相交，但是入环节点不相同；
    public static Node bothHasLoopCross(Node head1, Node head2,
                                        Node loop1, Node loop2){
        //俩交于1一个点，提前交，或者直接在入环节点loop1=loop2那交
        //2）两个相交，而且入环节点是同一个；
        if (loop1 == loop2){
            //用n来模拟长链和断链长度的差
            int n = 0;
            //（1）让cur1走head1，cur2走head2
            Node cur1 = head1;
            Node cur2 = head2;
            while (cur1 != loop1) {//从null替换为loop1
                n++;//计数长度
                cur1 = cur1.next;
            }
            while (cur2 != loop1) {//从null替换为loop1
                n--;//head2走就要--，最后n就是长短只差
                cur2 = cur2.next;
            }
            //（2）如果走完之后，发现，cur1 = cur2，显然就是相交的
            if (cur1 != cur2) return null;//两个链表平行，不相交

            //否则就是相交的
            //咱需要把长链给cur1，短链给cur2
            cur1 = n >= 0 ? head1 : head2;
            cur2 = cur1 == head1 ? head2 : head1;
            //然后差值将其正数画，现在长链已经在cur1上，n必须>0
            //让长链走线n，弥补差值
            n = n < 0 ? -n : n;
            while (n != 0){
                n--;
                cur1 = cur1.next;
            }
            //然后cur1和cur2同步走
            while (cur1 != cur2){
                cur1 = cur1.next;
                cur2 = cur2.next;
            }
            //一旦相遇，就是交点。不论是交在前面，还是刚刚好交在loop1=loop2处，都是cur1
            return cur1;
        }else {
            //1）俩的环是独立的，压根不相交；
            //3）2个链表相交，但是入环节点不相同；
            //求交点怎么求呢？？？咱们可以这么看1）3）
            //设定cur1，让他们从loop1.next开始走，如果最后cur1竟然与loop2相遇，说明一定是相交的，交点也就是loop1或者loop2，随意
            //如果cur1回到loop1了，一直没有遇到loop2，说明压根不相交。
            Node cur1 = loop1.next;
            while (cur1 != loop1){
                if (cur1 == loop2) return loop2;//3）2个链表相交，但是入环节点不相同；现在找到了交点，任选其一
                cur1 = cur1.next;
            }
            //1）俩的环是独立的，压根不相交；
            return null;
        }
    }

好的参考文章
https://blog.csdn.net/weixin_46838716/article/details/124577412

叹了口丶气
关注
专栏目录
单链表的相交
z2766290841的博客
07-18 323
两个不含环的单链表的相交    相交指的是结点的地址相同，而不是结点的值相同                     ************************************************************************/ [cpp] view plain copy typedef struc
两个单链表相交问题。
qq_38314385的博客
06-15 168
两个单链表相交问题 package class_03; public class Code_14_FindFirstIntersectNode { public static class Node { public int value; public Node next; public Node(int data) { ...
两个单链表相交的一系列问题
qq_45797026的博客
09-03 179
【题目】在本题中，单链表可能有环，也可能无环。给定两个单链表的头节点head1和head2,这两个链表可能相交，也可能不相交。请实现一个函数，如果两个链表相交，请返回相交的第一个节点；如果不相交，返回null即可。要求：如果链表1的长度为N，链表2的长度为M，时间复杂度请达到O(N+M),额外空间复杂度请达到O(1)。 先查看结构是否有环，用hash_set实现，从头节点开始遍历链表，查到一个不在set中的节点就放到set中，查到一个在set中已经存在的节点，就说明该节点是第一个入环的节点，返回它，如果遇
leetcode 两个链表相交的一系列问题
qq_40647378的博客
01-14 179
public class code_14_FindFirstIntersectNode{ public static class Node{ public int value; public Node next; public Node(int data){ this.value=data; } } public static getIntersectN...
python判断单向链表是否包括环，若包含则计算环入口的节点实例分析
09-18
了解如何判断链表中是否存在环以及计算环的入口节点是数据结构和算法面试中常见的问题，这有助于理解链表的基本操作和逻辑推理。通过掌握这种方法，你可以有效地解决类似的问题，并优化对链表结构的理解。在实际应用...
单向链表类模板_单向链表类模板_fastchq_
10-03
标题"单向链表类模板_单向链表类模板_fastchq_"表明这是一个关于使用模板类实现单向链表的代码，可能由用户fastchq编写或维护。 单向链表类模板的基本结构通常包括以下几个部分： 1. **节点定义**：首先，我们需要...
C语言单向链表的表示与实现实例详解
12-31
链表中最简单的一种是单向链表，它包含两个域，一个信息域和一个指针域。这个链接指向列表中的下一个节点，而最后一个节点则指向一个空值。 如下图所示： 一个单向链表包含两个值: 当前节点的值和一个指向下一个...
C语言之单向链表详解及实例代码
12-31
单向链表（单链表）是链表的一种，其特点是链表的链接方向是单向的，对链表的访问要通过顺序读取从头部开始；链表是使用指针进行构造的列表；又称为结点列表，因为链表是由一个个结点组装起来的；其中每个结点都有...
单向链表 代码架构
12-29
单向链表的每个节点包含两部分：数据和指向下一个节点的引用。 在给定的“单向链表 代码架构”中，我们可以期待找到以下几个关键知识点： 1. **链表节点结构**：通常，链表节点由数据域（用于存储数据）和指针域...
两个链表第一个相交节点问题
Niall_的博客
03-18 361
如何判断链表是否有环？ 准备两个指针，快指针每次走两步，慢指针每次走一步。 如果两个指针某一次相遇则一定有环 如何找到入环的第一个节点？（图中的6） 当快慢指针相遇后，让快指针回到起点每次走一步，慢指针继续走。 直到两个指针相遇则为入环的第一个节点 // 找到链表第一个入环节点，如果无环，返回null public static Node getLoopNode(Node head) { if (head == null || head.next == null || head.next.next .
判断两个链表是否相交
赵智任的博客
03-30 159
/** * 判断两个链表是否相交，如果相交返回第一个相交的节点 * 注：该链表为单链表，是否无环，不确定！ * @author 小纸人 * */ public class FindFirstIntersectNode { //LinkNode public static class Node{ int value; Node next; public Node() { ...
算法 （十二）链表相关：判断两个链表是否相交，并返回交点
PizAn的博客
02-20 338
1、判断两个链表是否相交，并返回交点 1.1 简单描述 其实这是一个综合题，属于链表里面最难的了（好像面试管特别喜欢考这个），因为判断链表相交之前你需要先判断链表是否有环 1.2 思路 先判断两个链表是否有环（两种方法，辅助hashset或用快慢指针），找到入环点 两个都无环，判断相交（两种方法，辅助hashse或计算链表长度差N然后长链表先走N步，然后一起走，相遇即为交点） 两个都有环（一个有...
两条链表的公共部分
qq_57027679的博客
02-04 508
public class FindfirstIntersectNode { public static void main(String[] args) {} public static class Node { public int value; public Node next; Node(int value) { this.value = value; } } public static Node getIntersectNode(Node head1,.
有环或无环单链表的相交问题
Java和算法学习的博客
12-16 1361
文章目录一、题目描述二、思路1、找到单链表的入环节点，无环则返回null2、根据得到的链表的入环节点，再展开讨论（1）两个链表都无环（2）一个有环、一个无环（3）两个链表都有环1）各自有环但是不相交2）入环节点是同一个3）入环节点有两个三、详细参考代码1、找到单链表的入环节点2、根据得到的链表的入环节点，再展开讨论 关于求有环无环单链表相交的问题，是链表类型题目中数一数二的难题，且听一一道来。 一、题目描述 给定两个可能有环也可能无环的单链表，头节点head1和head2。 请实现一个函数，如果两个链表相交
剑指Offer-两个链表的第一个公共节点（延伸——判断链表有无环以及两链表相交问题）
Galip的博客
12-24 192
35.两个链表的第一个公共节点（延伸——判断链表有无环以及两链表相交问题） 1.如何判断一个单链表是否有环？若有环返回第一个入环节点，无环返回空。 思路一： 从头遍历链表，用HashSet存储此链表的各个节点。如果此节点出现过，则返回它，若直到遍历到null都没有重复节点，就返回null，即不存在这样的结构。 public static Node findFirstIntersectNode(...
190510打卡：两个单链表相交的一系列问题
谁D了我的BUG
05-10 112
题目描述： 在本题中，单链表可能有环，也可能无环。给定两个单链表的头节点 head1和head2，这两个链表可能相交，也可能不相交。请实现一个函数， 如果两个链表相交，请返回相交的第一个节点；如果不相交，返回null 即可。 要求：如果链表1的长度为N，链表2的长度为M，时间复杂度请达到 O(N+M)，额外空间复杂度请达到O(1)。 思路：该问题比较复杂 ...
C语言实现约瑟夫环：单向循环链表解决方案
"C语言通过单向循环链表实现约瑟夫环问题的代码示例" 在计算机科学中，约瑟夫环（Josephus Problem）是一个经典的理论问题，它涉及到一个循环列表中的元素按照特定规则被逐步移除。在这个问题中，n个人围成一个圈，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

叹了口丶气

觉得有收获就支持一下吧~

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

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

打赏作者

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

抵扣说明：

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

余额充值