7.牛客题解 | 两个链表的第一个公共结点02-25

题目

题目链接

题目中的信息：

两个链表含有公共节点或没有，有公共节点则返回第一公共节点指针
单链表，无循环
没有公共节点返回空

举一反三：

学习完本题的思路你可以解决如下题目：

方法一：双指针长度比较法（推荐使用）

知识点：双指针

双指针指的是在遍历对象的过程中，不是普通的使用单个指针进行访问，而是使用两个指针（特殊情况甚至可以多个），两个指针或是同方向访问两个链表、或是同方向访问一个链表（快慢指针）、或是相反方向扫描（对撞指针），从而达到我们需要的目的。

思路：

如果两个链表有公共节点，那么它们后半部分都是相同的，我们要找的也就是后半部分的第一个节点。链表前半部分不同，长度也可能不同，因此同时遍历的话不一定就会同时到达第一个公共节点。

但是，如果我们能够找到长度差：

int n = p1 - p2;

较长的链表指针先走 $n$ 步：

//假设pHead1更长
for(int i = 0; i < n; i++)
    pHead1 = pHead1.next;

然后两个指针分别走剩余的步数，就会同时到达第一个公共节点。

具体做法：

step 1：单独的遍历两个链表，得到各自的长度。
step 2：求得两链表的长度差 $n$ ，其中较长的链表的指针从头先走 $n$ 步。
step 3：两链表指针同步向后遍历，遇到第一个相同的节点就是第一个公共节点。

图示：

图片说明

Java实现代码：

public class Solution {
    //计算链表长度的函数
    public int ListLenth(ListNode pHead){  
        ListNode p = pHead;
        int n = 0;
        while(p != null){
            n++;
            p = p.next;
        }
        return n;
    }
    public ListNode FindFirstCommonNode(ListNode pHead1, ListNode pHead2) {
        int p1 = ListLenth(pHead1);  
        int p2 = ListLenth(pHead2);
        //当链表1更长时，链表1指针先走p1-p2步
        if(p1 >= p2){  
            int n = p1 - p2;
            for(int i = 0; i < n; i++){
                pHead1 = pHead1.next;
            }
            //两个链表同时移动，直到有公共节点时停下
            while((pHead1 != null) && (pHead2 != null) && (pHead1 != pHead2)){ 
                pHead1 = pHead1.next;
                pHead2 = pHead2.next;
            }
        }
        //反之，则链表2先行p2-p1步
        else{  
            int n = p2 - p1;
            for(int i = 0; i < n; i++){
                pHead2 = pHead2.next;
            }
            //两个链表同时移动，直到有公共节点时停下
            while((pHead1 != null) && (pHead2 != null) && (pHead1 != pHead2)){
                pHead1 = pHead1.next;
                pHead2 = pHead2.next;
            }
        }
        return pHead1;
    }
}

C++实现代码：

class Solution {
public:
    //计算链表长度的函数
    int ListLenth( ListNode* pHead){  
        ListNode* p = pHead;
        int n = 0;
        while(p != NULL){
            n++;
            p = p->next;
        }
        return n;
    }
    ListNode* FindFirstCommonNode( ListNode* pHead1, ListNode* pHead2) {
        int p1 = ListLenth(pHead1);  
        int p2 = ListLenth(pHead2);
        //当链表1更长时，链表1指针先走p1-p2步
        if(p1 >= p2){ 
            int n = p1 - p2;
            for(int i = 0; i < n; i++){
                pHead1 = pHead1->next;
            }
            //两个链表同时移动，直到有公共节点时停下
            while((pHead1 != NULL) && (pHead2 != NULL) && (pHead1 != pHead2)){ 
                pHead1 = pHead1->next;
                pHead2 = pHead2->next;
            }
        }
        //反之，则链表2先行p2-p1步
        else{ 
            int n = p2 - p1;
            for(int i = 0; i < n; i++){
                pHead2 = pHead2->next;
            }
            //两个链表同时移动，直到有公共节点时停下
            while((pHead1 != NULL) && (pHead2 != NULL) && (pHead1 != pHead2)){
                pHead1 = pHead1->next;
                pHead2 = pHead2->next;
            }
        }
        return pHead1;
    }
};

Python代码实现：

class Solution:
    #计算链表长度的函数
    def ListLenth(self, pHead): 
        p = pHead
        n = 0
        while p:
            n += 1
            p = p.next
        return n
    
    def FindFirstCommonNode(self , pHead1 , pHead2 ):    
        p1 = self.ListLenth(pHead1)
        p2 = self.ListLenth(pHead2)
        #当链表1更长时，链表1指针先走p1-p2步
        if p1 >= p2: 
            n = p1 - p2
            for i in range(n):
                pHead1 = pHead1.next
            #两个链表同时移动，直到有公共节点时停下
            while pHead1 and pHead2 and pHead1 != pHead2:
                pHead1 = pHead1.next
                pHead2 = pHead2.next
        #反之，则链表2先行p2-p1步
        else: 
            n = p2 - p1
            for i in range(n):
                pHead2 = pHead2.next
            #两个链表同时移动，直到有公共节点时停下
            while pHead1 and pHead2 and pHead1 != pHead2:
                pHead1 = pHead1.next
                pHead2 = pHead2.next
        return pHead1

复杂度分析：

时间复杂度： $O(n)$ ，其中n为两链表较长者的长度，虽是多次循环，但都为单循环，取最大值即为 $O(n)$
空间复杂度： $O(1)$ ，常数级指针，无额外辅助空间使用

方法二：双指针连接法（扩展思路）