剑指offer-两个链表的第一个公共结点

两个链表的第一个公共结点

输入两个链表，找出它们的第一个公共结点。

分析关键点：

这是一道微软的面试题。微软非常喜欢与链表相关的题目，因此在微软的面试题中，链表出现的概率非常高。如果两个单向链表有公共的节点，也就是说两个链表从某一个节点开始，它们的m_pNext都指向同一个节点。但由于是单向链表的节点，每个节点只有一个m_pNext,因此从第一个公共节点开始，之后它们所有的节点都是重合的，不可能出现分叉。

看到这个题目，第一反应就是蛮力法：在第一链表上顺序遍历每个结点。每遍历一个结点的时候，在第二个链表上顺序遍历每个结点。如果此时两个链表上的结点是一样的，说明此时两个链表重合，于是找到了它们的公共结点。如果第一个链表的长度为m，第二个链表的长度为n，显然，该方法的时间复杂度为O(mn)。

• 暴力算法

package com.genge.offer;

/**
 * Created by Genge on 2016-07-02.
 */
public class FindFirstCommonNode {
    public ListNode FindFirstCommonNode(ListNode pHead1, ListNode pHead2) {
        ListNode p = pHead1, q = pHead2;
        if (p == null || q == null) {
            return null;
        }
        while (p != null) {
            while (q != null) {
                if (p.val == q.val) {
                    return p;
                }
                q = q.next;
            }
            p = p.next;
            q = pHead2;
        }
        return null;
    }
}
class ListNode {
    int val;
    ListNode next = null;

    ListNode(int val) {
        this.val = val;
    }
}

• 长度法

1. 如何判断两个单向链表有没有公共结点？前面已经提到，如果两个链表有一个公共结点，那么该公共结点之后的所有结点都是重合的。那么，它们的最后一个结点必然是重合的。因此，我们判断两个链表是不是有重合的部分，只要分别遍历两个链表到最后一个结点。如果两个尾结点是一样的，说明它们重合；否则两个链表没有公共的结点。
2. 在上面的思路中，顺序遍历两个链表到尾结点的时候，我们不能保证在两个链表上同时到达尾结点。这是因为两个链表长度不一定一样。但我们假设一个链表比另一个长l个结点，我们先在长的链表上遍历l个结点，之后再同步遍历两个链表，这个时候我们就能保证两个链表同时到达尾节点了。由于两个链表从第一个公共结点开始到链表的尾结点，这一部分是重合的。因此，它们肯定也是同时到达第一公共结点的。于是在遍历中，第一个相同的结点就是第一个公共的结点。
3. 在这个思路中，我们先要分别遍历两个链表得到它们的长度，并求出两个链表的长度之差。在长的链表上先遍历若干次之后，再同步遍历两个链表，直到找到相同的结点，或者一直到链表结束。此时，如果第一个链表的长度为m，第二个链表的长度为n，该方法的时间复杂度为O(m+n)。

/*
找出2个链表的长度，然后让长的先走两个链表的长度差，然后再一起走
（因为2个链表用公共的尾部）
*/
class Solution {
public:
    ListNode* FindFirstCommonNode( ListNode *pHead1, ListNode *pHead2) {
        int len1 = findListLenth(pHead1);
        int len2 = findListLenth(pHead2);
        if(len1 > len2){
            pHead1 = walkStep(pHead1,len1 - len2);
        }else{
            pHead2 = walkStep(pHead2,len2 - len1);
        }
        while(pHead1 != NULL){
            if(pHead1 == pHead2) return pHead1;
            pHead1 = pHead1->next;
            pHead2 = pHead2->next;
        }
        return NULL;
    }

    int findListLenth(ListNode *pHead1){
        if(pHead1 == NULL) return 0;
        int sum = 1;
        while(pHead1 = pHead1->next) sum++;
        return sum;
    }

    ListNode* walkStep(ListNode *pHead1, int step){
        while(step--){
            pHead1 = pHead1->next;
        }
        return pHead1;
    }
};

• 最简便的方式（值得推荐）

用两个指针扫描”两个链表“，如果某个指针先为空，那么让他指向另外一个链表的头，继续遍历，此时如果再次遇到反转（另外一个指针为空，指向另外一个头节点），此时应该是相等的公共节点。其实这种方式是利用了两个链表一定存在公共节点（公共的链表表尾）

class Solution {
public:
    ListNode* FindFirstCommonNode( ListNode *pHead1, ListNode *pHead2) {
        ListNode *p1 = pHead1;
        ListNode *p2 = pHead2;
        while(p1!=p2){
            p1 = (p1==NULL ? pHead2 : p1->next);
            p2 = (p2==NULL ? pHead1 : p2->next);
        }
        return p1;
    }
};

如果不懂所描述的，那么自己随便举例两个链表，按照上述算法走一遍，应该就明白了，光是看算法还是有点懵逼。。。