3.6 判断两个链表是否相交

判断两个链表是否相交，若相交则求其交点（指第一个相交的点）。

思路1，利用计数法： 遍历链表1，将其节点的内存地址存入map或者hashmap内。然后遍历链表2，并查询map或者hashmap，判断链表2节点是否在里面。若存在，则两者相交，且交于此节点。此方法时间复杂度是O(Length(List1)+Length(List2))且需要O(Length(List1))的空间存储hashmap。如下面代码的isCross_method1

 

思路2， 计数法优化： 我们知道，若两链表相交，则交点之后的链表均为两链表所共有。因此，若两者相交，则两者最后的节点一定相同。 所以只需要比较两链表最后的节点即可。此方法虽然时间复杂度也为O(Length(List1)+Length(List2))，但只需要O(1)个空间存储最后一个节点就可以。至于求交点，则需要直到两链表的长度（假设Length1>Length2），链表1先走Length1-Length2步，再同时开始走，直到节点相同的点，就是交点。然后如下面代码的isCross_method2

 

思路3， 人为构造环：将链表1的尾节点指向链表2的头节点。问题变为，判断此新链表是否有环，并求环入口点。相关问题可参照这里解决。

需要注意的是判断结束后要将两链表分开。

全部代码如下：

#include "stdafx.h"
#include <iostream>
#include <hash_map>

using namespace std;

const int LONG_LENGTH = 13;
const int SHORT_LENGTH = 4;

typedef struct node{
    int value;
    struct node *next;
}node;

//构造两相交链表，相较于第crossNum个节点。另外为了方便测试, isCross控制两链表是否相交
bool createCrossLink(node *list1,node *list2,int crossNum,bool isCross){
    
    if(crossNum<0 || crossNum>=LONG_LENGTH) return false;

    node *temp,*last,*longList,*shortList;
    longList = list1;
    shortList = list2;
    //last = (node *)malloc(sizeof(node)); last可以不需要分配内存

    for(int i=LONG_LENGTH-1;i>=0;i--){
        node *lp = (node *)malloc(sizeof(node));
        lp->value = i;
        lp->next = longList->next;
        longList->next = lp;
        if(i==crossNum){
            temp = lp;            //temp是交点
        }
    }

    for(int i=SHORT_LENGTH-1;i>=1;i--){
        node *sp = (node *)malloc(sizeof(node));
        sp->value = i*100;
        sp->next = shortList->next;
        shortList->next = sp;
        if(i==SHORT_LENGTH-1){
            last = sp;           //last是链表2最后一个节点
        }
    }

    if(isCross) last->next = temp;
    return true;
}

//遍历链表
void traverse(node *p){
    node * ptr = p;
    while(ptr!=NULL){
        cout<<ptr->value;
        if(ptr->next!=NULL) cout<<" -> ";
        ptr = ptr->next;
    }
    cout<<endl;
}

//思路1，利用hash_map
bool isCross_method1(node *l1,node *l2){

    if(l1==NULL || l2==NULL) return false;

    node *firstPtr,*secondPtr;
    firstPtr = l1;
    secondPtr = l2;

    hash_map<node *,int> ptrMap;
    hash_map<node *,int>::iterator it;

    while(firstPtr!=NULL){
        ptrMap.insert(pair<node *,int>(firstPtr,firstPtr->value));
        firstPtr = firstPtr->next;
    }
    
    for(it=ptrMap.begin();it!=ptrMap.end();it++){
        cout<<(*it).first<<" => "<<(*it).second<<endl;
    }

    while(secondPtr!=NULL){
        if(ptrMap.find(secondPtr)!=ptrMap.end()){
            cout<<"Crossing at: "<<secondPtr<<endl;
            return true;
        }
        secondPtr = secondPtr->next;
    }

    return false;
}

//思路2
bool isCross_method2(node *l1,node *l2){
    
    if(l1==NULL || l2==NULL) return false;

    node *firstPtr,*secondPtr,*first,*second;
    firstPtr = l1;
    secondPtr = l2;
    int firLen = 0;
    int secLen = 0;

    while(firstPtr!=NULL){
        if(firstPtr->next==NULL) first=firstPtr;
        firstPtr=firstPtr->next;
        firLen++;
    }
    while(secondPtr!=NULL){
        if(secondPtr->next==NULL) second=secondPtr;
        secondPtr=secondPtr->next;
        secLen++;
    }

    if(first==second){  //判断尾节点是否相等
        firstPtr = l1;  //要将指针重新指向两节点的头节点，再开始找交点！
        secondPtr = l2;
        if(firLen>secLen){
            for(int i=0;i<firLen-secLen;i++){
                firstPtr = firstPtr->next;
            }
        }else{
            for(int i=0;i<secLen-firLen;i++){
                secondPtr = secondPtr->next;
            }
        }

        while(firstPtr!=secondPtr){
            firstPtr=firstPtr->next;
            secondPtr = secondPtr->next;
        }

        cout<<"Crossing at: "<<firstPtr<<":"<<firstPtr->value<<" , "<<secondPtr<<":"<<secondPtr->value<<endl;
        return true;
    }else 
        return false;
}

int _tmain(int argc, _TCHAR* argv[])
{
    node *longHead = (node *)malloc(sizeof(node));
    node *shortHead = (node *)malloc(sizeof(node));
    longHead->next = NULL;
    shortHead->next = NULL;

    if(createCrossLink(longHead,shortHead,6,true)){
        traverse(longHead->next);
        traverse(shortHead->next);

        cout<<isCross_method1(longHead->next,shortHead->next)<<endl;;
        cout<<endl;
        cout<<isCross_method2(longHead->next,shortHead->next)<<endl;;
    }

    return 0;
}

以上均假设两链表无环，如不知两者是否有环，则需要分步骤解决：

1. 若两者均无环，按上述思路解决

2. 若一个有环，一个无环，则两者不相交（因为不可能无环链表与有环链表相交，这样无环链表也会变有环）

3. 若两者皆有环，则可求出链表1的入口节点是否在链表2的环中，若在则相交。相交时环必为两者共有。

环相关问题，请参考这里

参考：

http://blog.csdn.net/liuxialong/article/details/6556096