代码随想录算法训练营打卡day04-2|面试题0207 链表相交

面试题 02.07. 链表相交

本题没有视频讲解，大家注意 数值相同，不代表指针相同。

题目链接/文章讲解：代码随想录

面试题0207 链表相交

题目描述

给你两个单链表的头节点 headA 和 headB ，请你找出并返回两个单链表相交的起始节点，返回节点。如果两个链表没有交点，返回 null 。

图示两个链表在节点 c1 开始相交：

注意：根据题目要求，相交节点是地址相同、值相同的同一个节点，并不是第一个值相同的节点。

题目数据 保证 整个链式结构中不存在环。

注意，函数返回结果后，链表必须 保持其原始结构 。

示例：相交节点是值为8的节点，不是1的节点。

题解

思路

步骤：

1、遍历两个列表，分别得出长度m ,n。

2、两个指针分别从两个链表表头开始，长的链表指针先走|m-n|步，此时两个链表剩下长度相等。

3、两个指针同时向前走，如果指针相同，说明此处为相交点，返回该节点即可；如果走到链表尾都没有相同，说明没有相交点，返回null

代码

java版本

注意相交节点是地址相同、值相同的同一个节点，并不是第一个值相同的节点，所以 while(a != b) 而不是while(a.val != b.val)

        
/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) {
 *         val = x;
 *         next = null;
 *     }
 * }
 */
public class Solution {
    public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
        ListNode a = headA;
        ListNode b = headB;
        int m=0, n=0, k = 0;
        //分别计算两个链表的长度
        while(a != null){
            a = a.next;
            m = m + 1;
        }

        while(b != null ){
            b = b.next;
            n = n + 1;
        }

        a = headA;
        b = headB;

        //让长的链表指针先走|m-n|步
        if (m >= n){
            k = m - n;
            while( k > 0 ){
                a = a.next;
                k--;
            }
        }else if(m < n){
            k = n - m;
            while( k > 0 ){
                b = b.next;
                k--;
            }
        }
        while(a != b){ //注意这里是比较指针(节点地址)是否相等，不是节点值是否相等
            a = a.next;
            b = b.next;
        }
        return a; //如果a不为null，说明有交点，为null说明走到了链表最后没有交点
    }
}

复杂度分析：

时间复杂度：O(n + m)

空间复杂度：O(1)

python版本

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, x):
#         self.val = x
#         self.next = None

class Solution:
    def getIntersectionNode(self, headA: ListNode, headB: ListNode) -> ListNode:
        a = headA
        b = headB
        m,n,k = 0, 0, 0

        while a != None:
            a = a.next
            m += 1
        while b != None:
            b = b.next
            n += 1
        
        a = headA
        b = headB
            
        if m >= n :
            k = m - n
            while k > 0:
                a = a.next
                k -= 1
        else:
            k = n - m
            while k > 0:
                b = b.next
                k -= 1

        while a != b:
            a = a.next
            b = b.next

        return a