剑指offer——面试题37：两个链表的第一个公共结点

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

【方法一、利用栈】

代码：

/*
struct ListNode {
	int val;
	struct ListNode *next;
	ListNode(int x) :
			val(x), next(NULL) {
	}
};*/
class Solution {
public:
    ListNode* FindFirstCommonNode( ListNode* pHead1, ListNode* pHead2) {
      if(pHead1 == NULL || pHead2 == NULL)
          return NULL;
        stack<ListNode*>s1;
        stack<ListNode*>s2;
        ListNode* pNode = pHead1;
        ListNode* qNode = pHead2;
        
        ListNode* gonggongNode = NULL;
        
        while(pNode != NULL)
        {
            s1.push(pNode);
            pNode = pNode->next;
        }
        while(qNode != NULL)
        {
            s2.push(qNode);
            qNode = qNode->next;
        }
        while(!s1.empty() && !s2.empty()&& s1.top()->val == s2.top()->val)
        {
            gonggongNode = s1.top();  // 保存最后一个相等的的结点。
            s1.pop();
            s2.pop();
        }
        return gonggongNode;
    }
};

分析：刚看到这一题，很自然地想到了用栈，用栈挺好写的。第一次编译，显示段错误，可能是堆栈溢出。然后又修改了一下程序，发现 gonggongNode 的位置放错了。本来不是放在循环体内部的，这会导致一个问题，当不断地从栈顶弹出元素时，弹到第一个公共结点时，s1.top() 和s2.top() 是相等的，但是此时又会弹出一次。所以，每次循环，都让 gonggongNode 指向栈顶元素。这样的话，退出循环的时候，gonggongNode 保存的就是第一个公共结点了。

这样做的时间复杂度为 O（m+n）。但是要额外申请两个栈的空间。

【方法二】

暴力方法，直接上代码， 

/*
struct ListNode {
    int val;
    struct ListNode *next;
    ListNode(int x) :
            val(x), next(NULL) {
    }
};*/
class Solution {
public:
    ListNode* FindFirstCommonNode( ListNode* pHead1, ListNode* pHead2) {
        ListNode* p1 = pHead1;
        ListNode* p2 = pHead2;
        while(p1 != p2)
        {
            p1 = (!(p1) ? pHead2 : p1->next);
            p2 = (!(p2) ? pHead1 : p2->next);
        }
        return p1;
    }
};

分析：这样做，很容易想到，但是时间复杂度太高，为 O（m*n）不足以打动面试官啊。

【方法三】我看到有人采用 Hashmap 的方法，也很好。

【方法四】：《剑指offer》上提供的方法。

       从链表结点的定义我们可以看出，这两个链表是单链表。如果两个单链表有公共结点，那么这两个链表从某一结点开始，它们的 next 都指向了同一结点。由于单链表的每一个结点都只有一个 next ，因此，从第一个公共结点开始，之后它们所有的结点都是重合的，不可能再出现分叉。所以，两个有公共结点而部分重合的链表，拓扑形状看起来应该是一个 Y，而不是像 X。

      

代码：

unsigned int GetListLength(ListNode* pHead);
class Solution {
public:
    ListNode* FindFirstCommonNode( ListNode* pHead1, ListNode* pHead2) {
        unsigned int nlength1 = GetListLength(pHead1);
        unsigned int nlength2 = GetListLength(pHead2);
        int lengthDif = nlength1 - nlength2;
        
        ListNode* pListNodeLong = pHead1;
        ListNode* pListNodeShort = pHead2;
        
        if(nlength1 < nlength2)
        {
            ListNode* pListNodeLong = pHead2;
            ListNode* pListNodeShort = pHead1;
            lengthDif = nlength2 - nlength1;
        }
        for(int i =0;i < lengthDif;++i)
        {
            pListNodeLong = pListNodeLong->next;
        }
        while(pListNodeLong != NULL && pListNodeShort != NULL && pListNodeLong != pListNodeShort)
        {
            pListNodeLong = pListNodeLong->next;
            pListNodeShort = pListNodeShort->next;
        }
        ListNode* CommonNode = pListNodeLong;
        return CommonNode;
    }
};
    
unsigned int GetListLength(ListNode* pHead)
{
    unsigned int length = 0;
    if(pHead == NULL)
        return NULL;
    ListNode* pNode = pHead;
    while(pNode != NULL)
    {
        ++ length;
        pNode = pNode->next;
    }
    return length;
}