【剑指offer-36】20190901/03 两个链表的第一个公共结点

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

• 考点：链表
• 时间限制：1秒
• 空间限制：32768K
• 输入两个链表，找出它们的第一个公共结点。

---

思路：

这个公共节点意思是，这个节点相同了，他们之后的所有节点都是相同的。如果没有相同的节点，那么链表将会走到尾部返回null。第一个公共点之后的next都是一样的，所以必然有公共的尾部。

这个算法的思想就是，首先我让长的先走，然后让他们齐头并进，最终找到那个相同的尾部。

代码：

/*
public class ListNode {
    int val;
    ListNode next = null;

    ListNode(int val) {
        this.val = val;
    }
}*/
public class Solution {
    public ListNode FindFirstCommonNode(ListNode pHead1, ListNode pHead2) {
         ListNode p1 = pHead1;
         ListNode p2 = pHead2;
        if (p1 == null || p2 == null) {
            return null;
        }
        
        int len1 = getLen(p1);
        int len2 = getLen(p2);
       
        // 两连表的长度差
        // 如果链表1的长度大于链表2的长度
        if (len1 > len2) {
            int len = len1 - len2;
            // 先遍历链表1，遍历的长度就是两链表的长度差
            while (len > 0) {
                p1 = p1.next;
                len--;
            }
 
        }
        // 如果链表2的长度大于链表1的长度
        else {
            int len = len2 - len1;
            // 先遍历链表1，遍历的长度就是两链表的长度差
            while (len > 0) {
                p2 = p2.next;
                len--;
            }
        }
        
        //开始齐头并进，直到找到第一个公共结点
        while(p1 != p2){
            p1 = p1.next;
            p2 = p2.next;
        }
        return p1;
    }
    private int getLen(ListNode p) {
        ListNode q = p;
        int count = 0;
        while (q != null){
            count++;
            q = q.next;
        }   
        return count;
    }
}

我的问题：

---

其他思路1：

有个思路，不需要存储链表的额外空间。也不需要提前知道链表的长度。看下面的链表例子：
0-1-2-3-4-5-null
a-b-4-5-null
代码的三元表达式语句，对于某个指针p1来说，其实就是让它跑了连接好的的链表，长度就变成一样了。
如果有公共结点，那么指针一起走到末尾的部分，也就一定会重叠。看看下面指针的路径吧。
p1： 0-1-2-3-4-5-null(此时遇到三元表达式)-a-b-4-5-null
p2: a-b-4-5-null(此时遇到三元表达式)0-1-2-3-4-5-null
因此，两个指针所要遍历的链表就长度一样了！

假定 List1长度: a+n List2 长度:b+n, 且 a<b
那么 p1 会先到链表尾部, 这时p2 走到 a+n位置,将p1换成List2头部
接着p2 再走b+n-(n+a) =b-a 步到链表尾部,这时p1也走到List2的b-a位置，还差a步就到可能的第一个公共节点。
将p2 换成 List1头部，p2走a步也到可能的第一个公共节点。如果恰好p1==p2,那么p1就是第一个公共节点。 或者p1和p2一起走n步到达列表尾部，二者没有公共节点，退出循环。 同理a>=b.
时间复杂度O(n+a+b)

/*
public class ListNode {
    int val;
    ListNode next = null;

    ListNode(int val) {
        this.val = val;
    }
}*/
public 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;
    }
}

---

其他思路2：

使用hashMap的性质。
把链表1所有的节点存储起来，然后去遍历链表2。找到的第一个相同的节点就是公共节点。

/*
public class ListNode {
    int val;
    ListNode next = null;

    ListNode(int val) {
        this.val = val;
    }
}*/
import java.util.HashMap;
public class Solution {
    public ListNode FindFirstCommonNode(ListNode pHead1, ListNode pHead2) {
         HashMap<ListNode, Integer> hashmap = new HashMap();
        ListNode p = pHead1;
        while (p != null) {
            hashmap.put(p, null);
            p = p.next;
        }
        
        ListNode q = pHead2;
        
        while (q != null) {
            if (hashmap.containsKey(q)) {
                return q;
            }
            q = q.next;
        }
        return null;

    }
}