单链表有环无环相交问题

已于 2023-02-24 09:41:10 修改
阅读量186 收藏
点赞数
分类专栏： 算法 文章标签： 链表 数据结构 算法
于 2023-02-21 08:42:45 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_37900506/article/details/129135391
版权

题目描述：
给定两个有环也可能无环的单链表，头节点head1 和head2
请实现一个函数，如果两个链表相交，请返回相交的第一个节点， 如果不相交，返回null即可。
要求:
如果链表1的长度为N，链表2的长度为M，时间复杂度请达到 O(N+M)，额外空间复杂度请达到O(1)

思路
1、先判断两个链表有环，或者无环，有环则返回入环节点，否则为null
定理查找
若链表有两个指针，慢指针，一次跳1个节点，快指针一次跳2个节点，若链表成环。那么快节点一定会跟慢节点相遇。 相遇后，快节点回到头部，然后1个1个节点的走，直至和慢节点相遇，那么这时候相遇的节点就是要找的循环开始节点

代码实现

  public static Node getLoopNode(Node head) {
    // 小于2个节点的链表不可能组成环形
    if(head == null || head.next == null || head.next.next == null) {
      return null;
    }
    // 慢节点，一次跳1个节点
    Node n1 = head.next;
    // 快节点，一次跳2个节点
    Node n2 = head.next.next;
    // 定理：若链表成环，那么快节点一定会跟慢节点相遇
    while(n1 != n2) {
      if(n2.next == null || n2.next.next == null) {
        return null;
      }
      n2 = n2.next.next;
      n1 = n1.next;
    }
    // 相遇后，快节点回到头部，然后1个1个节点的走，直至和n1相遇
    // 那么这时候相遇的节点就是要找的循环开始节点
    n2 = head;
    while(n1 != n2) {
      n2 = n2.next;
      n1 = n1.next;
    }
    return n1;
  }

额外空间法-哈希表
若没有空间复杂度要求的话，这里的有无环判断，可以通过哈希表判断。链表开始从头遍历至末尾，先查表，若无则把Node放进表里，以Node为key，Node为值放入哈希表中。若从表中查到节点，那么第一个查到的节点就是入环节点。
算法实现

  public static Node getLoopNode2(Node head) {
    HashMap<Node, Node> map = new HashMap<Node, Node>();
    while(head != null) {
      if (map.get(head) != null ) {
        return head;
      }else {
        map.put(head, head);
      }
      head = head.next;
    }
    return null;
  }

2、分析两个链表列表有环，无环的情况
2.1、1个链表有环，1个链表无环
结论：永远不可能相交

2.2、两个链表都无环
若相交，那么必然如图所示
在这里插入图片描述

两个无环链表相交情况
那么，针对以上结构，我们可以这样处理 1、判断哪个链表更长，把长链表从头节点开始一直指向下一个节点，直至与短链表长度一直 2、长短链表长度相等后，各种开始指向下一个节点，同时判断当前两个指针指向的节点是否相等，期间第一个相等的节点，即为第一个相交的节点。若遍历到结尾都不相等，则两个链表没有相交的节点。
算法实现

  public static Node noLoop1(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;
    }
    // n>0说明head1较长
    // 以下步骤是cur1指向较长的链表，cur2指向较短的链表
    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;
  }

若没有空间复杂度要求，我们可以使用HashMap来存储其中一个链表，另外一个链表遍历比较，实现如下：

  public static Node noLoop2(Node head1, Node head2) {
    HashMap<Node, Node> map = new HashMap<Node, Node>();
    while(head1 != null) {
      map.put(head1, head1);
      head1 = head1.next;
    }
    while(head2 != null) {
      if (map.get(head2) != null) {
        return head2;
      }
      head2 = head2.next;
    }
    return null;
  }

2.3、两个链表都有环
若两个链表有环且相交，只可能出现两种情况。
情况1
在这里插入图片描述

两个有环链表相遇情况1
如图所示，第一个相交结点必然不是环结点，而是入环前的节点。那么我们可以抹去成环部分，就可以转为两个无环链表的相交的问题了

情况2
在这里插入图片描述

两个有环链表相遇情况2
如图所示，若是情况2，那么只需遍历L1的loop1，直至回到loop1，期间若与loop2相遇，那么两个链表的第一个相遇节点就是loop1或loop2。否则不相交

  public static Node bothLoop(Node head1, Node loop1, Node head2, Node loop2) {
    Node cur1 = null;
    Node cur2 = null;
    // 这时候两个链表构成的形状是 >-O
    // 这时候可以忽略环，转换为求两个无环链表的相交问题
    if (loop1 == loop2) {
      // 情况1
      cur1 = head1;
      cur2 = head2;
      int n = 0;
      // 只遍历到loop1
      while(cur1.next != loop1) {
        n++;
        cur1 = cur1.next;
      }
      // 只遍历到loop2
      while(cur2.next != 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 {
      //  情况2
      cur1 = loop1.next;
      while(cur1 != loop1) {
        if(cur1 == loop2) {
          return loop1;
        }
        cur1 = cur1.next;
      }
      return null;
    }
  }

完整代码

  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 noLoop1(head1, head2);
    }
    if (loop1 != null && loop2 != null) {
      return bothLoop(head1, loop1, head2, loop2);
    }
    // 一个链表有环，一个链表无环，是不可能相交的
    return null;
  }

  /// 处理两个链表无环的情况
  /// 先把两个链表中，较长的链表走到跟较短的链表一样长
  /// 最后两个链表一起走，第一相遇的节点，就是第一个相交节点
  public static Node noLoop1(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;
    }
    // n>0说明head1较长
    // 以下步骤是cur1指向较长的链表，cur2指向较短的链表
    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) {
      // 情况1
      cur1 = head1;
      cur2 = head2;
      int n = 0;
      // 只遍历到loop1
      while(cur1.next != loop1) {
        n++;
        cur1 = cur1.next;
      }
      // 只遍历到loop2
      while(cur2.next != 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 {
      // 情况2
      cur1 = loop1.next;
      while(cur1 != loop1) {
        if(cur1 == loop2) {
          return loop1;
        }
        cur1 = cur1.next;
      }
      return null;
    }
  }

  /// 获得环形链表的循环开始的节点
  public static Node getLoopNode(Node head) {
    // 小于2个节点的链表不可能组成环形
    if(head == null || head.next == null || head.next.next == null) {
      return null;
    }
    // 慢节点，一次跳1个节点
    Node n1 = head.next;
    // 快节点，一次跳2个节点
    Node n2 = head.next.next;
    // 定理：若链表成环，那么快节点一定会跟慢节点相遇
    while(n1 != n2) {
      if(n2.next == null || n2.next.next == null) {
        return null;
      }
      n2 = n2.next.next;
      n1 = n1.next;
    }
    // 相遇后，快节点回到头部，然后1个1个节点的走，直至和n1相遇
    // 那么这时候相遇的节点就是要找的循环开始节点
    n2 = head;
    while(n1 != n2) {
      n2 = n2.next;
      n1 = n1.next;
    }
    return n1;
  }
ayu_programer
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值