链表操作 两个链表间的相交性问题

本文参考：

　　http://blog.csdn.net/g_brightboy/article/details/6824834

　　http://blog.csdn.net/huangxy10/article/details/8014233

　　在此致谢。

• 问题：

　　给定两个链表，判断它们是否相交。

注意：

　　如果两个链表相交的话，则公用相交点开始往后的所有节点。【因为节点的next指针只有一个！】

解答：

　　1)首先来看最直观的方法，也就是一次判断链表A中的节点是否在链表B中出现。

　　时间复杂度：O(n²)

　　空间复杂度：O(1)

　　

bool List::isIntersect(Node* listA,Node* listB){
    for(Node* headA = listA; headA != NULL ; headA =  headA->next){
        for(Node* headB = listB; headB != NULL; headB = headB->next){
            if(headA == headB)
                return true;
        }
    }   
    return false;                                                                                                      
}

　　

　　2)在方法(1)中，链表A中节点每次都需要匹配链表B中每个节点，这个匹配动作的时间复杂度为O(n)。考虑使用Hash来存储链表B，这样可将匹配动作的时间复杂度降低为O(1)。

　　时间复杂度：O(n)

　　空间复杂度：O(n)

bool isIntersect(Node* listA,Node* listB){
    unordered_map<Node*,bool> hashTable;

    for(Node* tmp = listA; tmp != NULL; tmp=tmp->next)
    {
        hashTable.insert(pair<Node*,bool>(tmp,true));
    }

    for(Node* tmp = listB; tmp != NULL; tmp=tmp->next)
    {
        unordered_map<Node*,bool>::iterator iter = hashTable.find(tmp);
        if(iter!=hashTable.end() && iter->second)
            return true;
    }

    return false;
}

　　

　　3)考虑当两个链表相交时，自相交点之后的所有节点都一样。因此，当两个链表的尾节点一样时就是相交的。

　　时间复杂度：O(n)

　　空间复杂度：O(1)

bool isIntersect(Node* listA,Node* listB)
{
    if(listA==NULL || listB==NULL)
        return false;

    Node* tailA = listA;
    while(tailA->next != NULL)
        tailA = tailA->next;
    
    Node* tailB = listB;
    while(tailB->next != NULL)
        tailB = tailB->next;

    return (tailA == tailB);
}

 
　　4)思考之前处理的 “判断链表是否有环”的问题。 当链表A与链表B相交时，将链表A的首尾相连，则链表B中出现环。

　　时间复杂度：O(n)

　　空间复杂度：O(1)

　　

bool hasCycle(Node* listB)
{
    if(listB==NULL)
        return false;

    Node* fast = listB->next;
    Node* slow = listB;

    while(fast!=NULL && fast->next!=NULL)
    {
        fast = fast->next->next;
        slow = slow->next;

        if(fast == slow)
            return true;
    }
    return false;
}

bool isIntersect(Node* listA,Node* listB)
{
    if(listA == NULL || listB == NULL)
        return false;

    Node* tailA = listA;
    while(tailA->next != NULL)
        tailA = tailA->next;

    tailA->next = listA;

    return hasCycle(listB);     

}

　　5)More ?

• 问题

　　求两个相交链表的第一个交点

　　

　　解答：

　　1)将链表A收尾相连，之后“寻找有环链表的首个环节点”

　　

Node* find_cycle_begin(Node* list)
{
    Node* fast = list->next;
    Node* slow = list;

    while(fast != NULL && fast->next !=NULL)
    {
        fast = fast->next->next;
        slow = slow->next;

        if(fast == slow)
            break;
    }

    fast = fast->next;
    slow = list;

    while(fast != slow)
    {
        fast = fast->next;
        slow = slow->next;
    }

    return fast;
}

Node*  isIntersect(Node* listA,Node* listB)
{
    if(listA == NULL)
        return (new Node(-1));

    Node* tail = listA; 
    while(tail->next != NULL)
        tail = tail->next;

    tail->next = listA;

    return find_cycle_begin(listB);    
}

　　

　　2)依次比较

　　　　可用加速操作：

　　　　　　　　[1].假设链表A的长度lenA大于链表B的lenBa。在第一个交点的位置一定在链表的后lenB的内。可以不用判断前lenA - lenB个节点。

　　　　　　　　[2].将链表A的节点存储在hash表中,一次检查链表B中的节点。

　　　　　　　　[3].使用两个指针来分别遍历两个队列，当指针到达尾部时，将指针切换到另一个队列的头部，在两个指针都切换后，如果两个队列存在相交，则

　　　　在指针在此到达尾部前会相遇。

　　　　　　　　原因：这种控制，可以使得两个指针移动相同的距离。