leetcode-链表-160.相交链表

编写一个程序，找到两个单链表相交的起始节点。

如下面的两个链表：

在节点 c1 开始相交。

// 用stack缓存两个链表中的数据，再从尾到头的判断
// 时间复杂度 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) {
        stack<ListNode *> s1, s2;
        
        while(headA != nullptr)
        {
            s1.push(headA);               
            headA = headA->next;
        }
    
        while(headB != nullptr)
        {
            s2.push(headB);
            headB = headB->next;
        }
    
        
        ListNode * lastequal = nullptr;
        while(!s1.empty() && !s2.empty())
        {
            if (s1.top() == s2.top())
            {
                lastequal = s1.top();
            }
            else
            {
                break;
            }
            
            s1.pop();
            s2.pop();
        }
        
        return lastequal;
    }
};

// 哈希表方法：将链表A所有节点的存到哈希表里，遍历链表B的同时跟表内的节点比较
// 时间复杂度 O(m+n) 空间复杂度 O(n)

/*双指针： 时间复杂度 O(m+n) 空间复杂度 O(1)
 * 1. 创建两个指针 pApA 和 pBpB，分别初始化为链表 A 和 B 的头结点。然后让它们向后逐结点遍历。
 * 2. 当 pApA 到达链表的尾部时，将它重定位到链表 B 的头结点 (你没看错，就是链表 B); 类似的，当 pBpB 到达链    表的尾部时，将它重定位到链表 A 的头结点。
 * 3. 若在某一时刻 pApA 和 pBpB 相遇，则 pApA/pBpB 为相交结点。
 * 4. 想弄清楚为什么这样可行, 可以考虑以下两个链表: A={1,3,5,7,9,11} 和 B={2,4,9,11}，相交于结点 9。 由于 B.length (=4) < A.length (=6)，pBpB 比 pApA 少经过 22 个结点，会先到达尾部。将 pBpB 重定向到 A 的头结点，pApA 重定向到 B 的头结点后，pBpB 要比 pApA 多走 2 个结点。因此，它们会同时到达交点。
 * 5. 如果两个链表存在相交，它们末尾的结点必然相同。因此当 pApA/pBpB 到达链表结尾时，记录下链表 A/B 对应的元素。若最后元素不相同，则两个链表不相交。
 */
 
/**
 * 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) {
        ListNode * a = headA;
        ListNode * b = headB;
        
        while(a != b)
        {
            a = (a == nullptr)? headB : a->next;
            b = (b == nullptr)? headA : b->next;
        }
        
        return a;
    }
};