【leetcode】160. Intersection of Two Linked Lists（Python & C++）

---

160. Intersection of Two Linked Lists

题目链接

160.1 题目描述：

Write a program to find the node at which the intersection of two singly linked lists begins.

For example, the following two linked lists:

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

begin to intersect at node c1.

Notes:

If the two linked lists have no intersection at all, return null.
The linked lists must retain their original structure after the function returns.

You may assume there are no cycles anywhere in the entire linked structure.

Your code should preferably run in O(n) time and use only O(1) memory.

160.2 解题思路：

1. 思路一：利用stack。将两个链表分别压入栈。然后同时出栈，找到第一个不相等节点即可返回。如果栈顶就不相同，则直接返回空。

2. 思路二：同时遍历两个链表。遍历条件是两个节点不相等。如果在遍历过程中，有节点走到了结尾，就从头再重新走，这样，在你追我赶中，两个节点会因为相等，或者同为空，发生碰头。

3. 思路三：这里难点无非是两个链表长度不相等。跟思路二相同，不同的是，有节点到了结尾后，从头走的不是当前链表的头了，而是另一个链表的头。比如，L1的长度是5，L2的长度是6，当p1走到L1的结尾，p2才走到L2的第6个，此时，L1剩余长度0，L2剩余长度1。这样，p1马上走到L2的头，则L1剩余长度为6，L2走完最后一个节点后，再去走L1，其剩余长度也变成1+5=6，此时两个链表长度相等了，则找到相同节点指日可待。而且比思路二中快很多。

总结思路二和思路三，思路二相当于求两个链表的最小公倍数，如，5和6的最小公倍数是30，这样在30及之前就会发生第一次相同节点碰面。思路三相当于求两个链表的和，如5和6的和是11，这样在11及以前就会发生第一次相同节点碰面。所以说随着两个链表长度越来越大，思路三会更为快一点。

160.3 C++代码：

1、思路一代码（33ms）：

class Solution118 {
public:
    ListNode *getIntersectionNode(ListNode *headA, ListNode *headB) {
        if (headA == NULL || headB == NULL)
            return NULL;
        stack<ListNode*>a;
        stack < ListNode* > b;
        while (headA != NULL)   
        {
            a.push(headA);
            headA = headA->next;
        }
        while (headB != NULL)
        {
            b.push(headB);
            headB = headB->next;
        }
        ListNode *pub=NULL;
        while (!a.empty() && !b.empty())
        {
            if (a.top() != b.top())
                return pub;
            else
            {
                pub = a.top();
                a.pop();
                b.pop();
            }       
        }
        return pub;
    }
};

2、思路二代码（569ms）

class Solution118_1 {
public:
    ListNode *getIntersectionNode(ListNode *headA, ListNode *headB) {
        if (headA == NULL || headB == NULL)
            return NULL;
        ListNode *pa = headA;
        ListNode *pb = headB;
        while (pa!=pb)
        {
            pa = pa->next;
            pb = pb->next;
            if (pb == pa)
                return pa;
            if (pa == NULL)
                pa = headA;
            if (pb == NULL)
                pb = headB;
        }
        return pa;
    }
};

3、思路三代码（36ms）：

class Solution118_2 {
public:
    ListNode *getIntersectionNode(ListNode *headA, ListNode *headB) {
        if (headA == NULL || headB == NULL)
            return NULL;
        ListNode *pa = headA;
        ListNode *pb = headB;
        while (pa != pb)
        {
            pa = pa?pa->next:headB;
            pb = pb?pb->next:headA;
        }
        return pa;
    }
};

160.4 Python代码：

1、思路三代码（465ms）

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

---