从零学算法160

**160.**给你两个单链表的头节点 headA 和 headB ,请你找出并返回两个单链表相交的起始节点。如果两个链表不存在相交节点,返回 null 。
示例 1:
输入:intersectVal = 8, listA = [4,1,8,4,5], listB = [5,6,1,8,4,5], skipA = 2, skipB = 3
输出:Intersected at ‘8’
解释:相交节点的值为 8 (注意,如果两个链表相交则不能为 0)。
从各自的表头开始算起,链表 A 为 [4,1,8,4,5],链表 B 为 [5,6,1,8,4,5]。
在 A 中,相交节点前有 2 个节点;在 B 中,相交节点前有 3 个节点。
请注意相交节点的值不为 1,因为在链表 A 和链表 B 之中值为 1 的节点 (A 中第二个节点和 B 中第三个节点) 是不同的节点。换句话说,它们在内存中指向两个不同的位置,而链表 A 和链表 B 中值为 8 的节点 (A 中第三个节点,B 中第四个节点) 在内存中指向相同的位置。
示例 2:
输入:intersectVal = 2, listA = [1,9,1,2,4], listB = [3,2,4], skipA = 3, skipB = 1
输出:Intersected at ‘2’
解释:相交节点的值为 2 (注意,如果两个链表相交则不能为 0)。
从各自的表头开始算起,链表 A 为 [1,9,1,2,4],链表 B 为 [3,2,4]。
在 A 中,相交节点前有 3 个节点;在 B 中,相交节点前有 1 个节点。
示例 3:
输入:intersectVal = 0, listA = [2,6,4], listB = [1,5], skipA = 3, skipB = 2
输出:null
解释:从各自的表头开始算起,链表 A 为 [2,6,4],链表 B 为 [1,5]。
由于这两个链表不相交,所以 intersectVal 必须为 0,而 skipA 和 skipB 可以是任意值。
这两个链表不相交,因此返回 null 。

  • 我的思路,遍历 A 用 hashSet 记录下来,然后遍历 B 看有没有相同的就行
  •   public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
          Set<ListNode> set = new HashSet<>();
          while(headA!=null){
              set.add(headA);
              headA=headA.next;
          }
          while(headB!=null){
              if(set.contains(headB))return headB;
              headB=headB.next;
          }
          return null;
      }
    
  • 他人题解:假设链表相交,重合部分有 c 个节点。链表 A 中非重合部分有 a 个节点,链表 B 中非重合部分有 b 个节点。那么当 A 节点遍历完自己的 a+c 个节点后如果继续遍历 B 节点,到达重合点时经过路程为 a+c+b,B 节点同理先遍历完自己再遍历 A 节点到达重合点的路程为 b+c+a。你会发现他们走的路程是一样长的。也就是说同时遍历 AB 节点,遍历完了就遍历对方,只要链表相交,最终就会在重合点相遇。
  • 假如链表不相交,也就是说 c 为 0,他们按照上面走一通也是会各自走 a+b 以及 b+a 个节点,然后到达了 null。当然如果 a=b 那直接各自遍历完自己就同时到 null 了。
  • 综上,循环结束条件可以设置为 a != b,遍历部分就是 ab 分别走完自己的路再走一遍对方的路
  •   ListNode getIntersectionNode(ListNode headA, ListNode headB) {
          ListNode A=headA,B=headB;
          while(A!=B){
              A=A!=null?A.next:headB;
              B=B!=null?B.next:headA;
          }
          return A;
      }
    

你可能感兴趣的:(算法学习,#,链表,算法)