Intersection of Two Linked List

Write aprogram to find the node at which the intersection of two singly linked listsbegins.

 Forexample, the following two linked lists:

A:          a1 → a2

                               ↘

                                   c1 → c2 → c3

                                ↗           

B:     b1 → b2 →b3

begin tointersect at node c1.

 

 Notes:

 If the twolinked lists have no intersection at all, return null.

The linkedlists must retain their original structure after the function returns.

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

Your codeshould preferably run in O(n) time and use only O(1) memory

我想到一种内存不是O(1)的解法，是利用stack。将两个链表分别放入两个不同的栈，然后再弹出，当两个栈弹出的节点不同时，前一个节点就是交叉的节点。

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode *getIntersectionNode(ListNode *headA, ListNode *headB) {
        if(!headA||!headB)
            return NULL;
        if(headA==headB)
            return headA;
        stack<ListNode*> listA,listB;
        ListNode *nodeA,*nodeB;
        nodeA=headA;
        nodeB=headB;
        while(nodeA){
            listA.push(nodeA);
            nodeA=nodeA->next;
        }
        while(nodeB){
            listB.push(nodeB);
            nodeB=nodeB->next;
        }
        nodeA=NULL;
        while((!listA.empty())&&(!listB.empty())&&(listA.top()==listB.top())){
            nodeA=listA.top();
            listA.pop();
            listB.pop();
        }
        return nodeA;
    }
};

最后一个while循环里的条件，要先判空，然后再比较两个栈顶的元素是否相等。如果判空放在后面，会因为最后top取不到元素而报错。

但是这种方法空间复杂度是O(m+n)，时间复杂度要大于O(m+n)。

看了网友的解法之后，修改代码如下

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode *getIntersectionNode(ListNode *headA, ListNode *headB) {
        if(!headA||!headB)
            return NULL;
        ListNode *nodeA=headA,*nodeB=headB;
        while(nodeA!=nodeB){
            nodeA=nodeA?nodeA->next:headB;
            nodeB=nodeB?nodeB->next:headA;
        }
        return nodeA;
    }
};

这种解法应该是最简洁的一种解法。空间复杂度是O(1)，时间复杂度是O(m+n)。