剑指offer:两个链表的第一个公共节点(python)

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

题目位置
代码位置

题目：
输入两个链表，找出它们的第一个公共节点。

A:          a1 → a2
                   ↘
                     c1 → c2 → c3
                   ↗            
B:     b1 → b2 → b3

分析：
如果两个链表有公共节点，那么公共节点出现在两个链表的尾部。如Example1和Example 2。如果我们从两个链表的尾部开始往前比较，最后一个相同的节点就是我们要找的节点。

方法一：

我们可以利用两个辅助栈，先将链表放入栈中，接着比较两个栈顶节点是否相同。如果相同，则把栈顶节点弹出，接着比较下一个栈顶节点，直到找到最后一个相同节点。

class Solution(object):
    def getIntersectionNode(self, headA, headB):
        """
        :type head1, head1: ListNode
        :rtype: ListNode
        """
        stackA = []
        stackB = []
        while headA:
            stackA.append(headA)
            headA = headA.next
        while headB:
            stackB.append(headB)
            headB = headB.next
        temp = None
        while stackA and stackB:
            a = stackA.pop()
            b = stackB.pop()
            if a != b:
                return temp
            else:
                temp = a
        return temp

方法二：

我们首先遍历两个链表得到它们的长度。通过比较可以知道，哪个链表长，以及长链表比短链表多几个节点。第二次遍历的时候，在长链表上先走这多的几步，接着同时遍历两个链表，找到第一个相同的节点就是它们的第一个公共节点。

class Solution(object):
    def getIntersectionNode(self, headA, headB):
        """
        :type head1, head1: ListNode
        :rtype: ListNode
        """
        lenA = lenB = 0      
        ahead = headA
        bhead = headB         
        while ahead:
            ahead = ahead.next
            lenA += 1       
        while bhead:
            bhead = bhead.next
            lenB += 1
        if lenA > lenB:
            long = headA
            short = headB
        else:
            long = headB
            short = headA            
        len = abs(lenA-lenB)       
        for i in range(len):     
            long = long.next       
        while long != None and short != None and short != long:
            long = long.next
            short = short.next          
        return long

方法三：

第一次遍历时，如果两者的非公共元素的个数正好相等，那么一定能找到相同元素；如果非公共元素个数不等，那么在一次遍历之后，两者的指针的差距就是非公共元素的个数差。这样翻转之后，指针的差距正好弥补了非公共元素的差，这样，第二次遍历要么一定相遇，要么两者没有公共元素，返回None。

如下图例子：
长链B有6个节点,短链A有5个节点，红色指针指向A链的头，蓝色指针指向B链的头，一起向后遍历。红指针无路可走时，就转头B链，蓝指针无路可走，就转头A链，然后继续向后，相遇时，即真爱节点。

class Solution(object):
    def getIntersectionNode(self, headA, headB):
        """
        :type head1, head1: ListNode
        :rtype: ListNode
        """
        if headA is None or headB is None:
            return None
        pa = headA
        pb = headB
        while pa is not pb:
            pa = headB if pa is None else pa.next
            pb = headA if pb is None else pb.next
        return pa