面试100题：7.判断两个链表是否相交
题目：
给出俩个单向链表的头指针，比如h1，h2，判断这俩个链表是否相交。
为了简化问题，我们假设俩个链表均不带环。
分析：
之前一直没有搞清楚的问题，今天看了如下链接才终于有了清晰的认识，一个字就是笨，俩字很笨，三字非常笨。
参考：http://blog.163.com/bbluesnow@126/blog/static/27784545201251051156817/。特此感谢！！！
先要搞清楚如下几个问题，就能看透此题的真面目，才能体会到此题居然可以挖掘的这么深。
1)判断一个单链表是否有环
在一个单链表上判断有没有环的首选方法就是采用快慢步长法。分别令两个指针p和q分别指向头节点，p指针每次前
进一步，q指针每次前进两步。如果最终p和q指针能够指向同一个节点，则说明有环。
证明：
假设p和q的速度分别为v1和v2，如果存在环，我们假设指针p和q第一次进入环时，他们相对于环中第一个节点
的偏移地址分别为a和b（偏移地址即为节点数）。
这样判断链表是否有环就转化为p和q指针的值是否存在相等的时候，也就是他们相对于环的首节点的偏移量是
一样的。设环的节点个数为n，程序可能循环了m次。
这样就会有如下等式：(a+m*v1)mod(n)=(b+m*v2)mod(n)
假设p指针mod(n)的最大整数位k1，q指针mod(n)的最大整数位k2，则(a+m*v1)-k1*n= (b+m*v2)-k2*n，整理后得
m=|((k2-k1)*n+a-b)/(v2-v1)| , v2>v1。
时间复杂度分析：
假设甩尾（在环外）长度为len1（结点个数），环内长度为 len2，链表总长度为n，则n=len1+len2 。当p步
长为1，q步长为2时，p指针到达环入口需要len1时间，p到达入口后，q处于哪里不确定，但是肯定在环内，此
时p和q开始追赶，q最长需要len2时间就能追上p（p和q都指向环入口），最短需要1步就能追上p（p指向环入口，
q指向环入口的前一个节点）。事实上，每经过一步，q和p的距离就拉近一步，因此，经过q和p的距离步就可以
追上p。因此总时间复杂度为O(n)，n为链表的总长度。
// 1) 判断一个单链表是否有环
template<typename T>
bool checkCircle(T* head)
{
if (NULL == head)
return false;
T* low = head;
T* fast = head;
while (low->next != NULL && (fast->next != NULL) && (fast->next)->next != NULL)
{
low = low->next;
fast = (fast->next)->next;
if (low == fast)
{
return true;
}
}
return false;
}
2)判断一个环的入口点位置
证明：
链表形状类似数字6。假设环外长度（节点数）为a，环内长度为b，则总长度（链表总节点数）为a+b。起始节
点编号，从0开始。假设第i步访问的节点为S(i)，i=0,1,2...n。当i<a时，S(i)=i;当i>=a时，S(i)=a+(i-a)%b。
分析追赶过程：
p和q指针分别从头节点以v1和v2速度前进，经过x步后碰撞，则有：S(x)=S(2x)。由于环的周期性存在
如下等式：2x=tb+x，得x=tb。碰撞时，必须发生在环内，所以有x>=a。
入口点为从起点走a步，即S(a)。S(a)=S(tb+a)=S(x+a)
结论：从碰撞点x前进a步即为环的入口点。
假设分别从起点和x点同时前进，第一个碰撞点就是环的入口点。
时间复杂度分析：
假设甩尾（在环外）长度为len1（结点个数），环内长度为 len2 。则时间复杂度为“环是否存在的时间复杂度”+O（len1）。
// 2) 查找环的入口
template<typename T>
T* findLoopPort(T* head)
{
// 判断是否有环，五环返回NULL
if (!checkCircle(head))
return NULL;
T* low = head;
T* fast = head;
// low按照步长1增加，fast按照步长2增加，找到碰撞点
while (1)
{
low = low->next;
fast = fast->next->next;
if (low == fast)
break;
}
// 分别从头结点和碰撞节点开始按照步长1增加，遍历链表，第一个节点相同的点是环入口点
low = head;
while (low != fast)
{
low = low->next;
fast = fast->next;
}
return low;
}
3) 环的长度
从碰撞点开始，两个指针p和q，q以一步步长前进，q以两步步长前进，到下次碰撞所经过的操作次数即是环的长度。这很好理解，比如两个运动员A和B从起点开始跑步，A的速度是B的两倍，当A跑玩一圈的时候，B刚好跑完两圈，A和B又同时在起点上。此时A跑的长度即相当于环的长度。
时间复杂度分析：
假设甩尾（在环外）长度为len1（结点个数），环内长度为 len2 ，则时间复杂度为“环是否存在的时间复杂度”+O(len2)。
// 3) 计算环的长度
template<typename T>
int getLoopLength(T* head)
{
if (!checkCircle(head))
return 0;
T* low = head;
T* fast = head;
int length = 0;
// low按照步长1增加，fast按照步长2增加，找到碰撞点,然后接着循环直到下一次碰撞，
// 计算两次碰撞之间的循环次数即为长度
while (1)
{
low = low->next;
fast = fast->next->next;
if (low == fast)
break;
}
while(1)
{
low = low->next;
fast = fast->next->next;
length++;
if (low == fast)
break;
}
return length;
}
4)除环之外的链表长度
// 4) 计算有环链表的尾长度
template<typename T>
int getTailLength(T* head)
{
T* port = findLoopPort(head);
int length = 0;
T* temp = head;
while (temp != port)
{
length++;
temp = temp->next;
}
return length;
}
5)判断两个（无环）单链表是否相交
法一：
将链表A的尾节点的next指针指向链表B的头结点，从而构造了一个新链表。问题转化为求这个新链表是否有环的问题。时间复杂度：为环是否存在的时间复杂度，即O（length(A)+length(B)），使用了两个额外指针。
法二：
两个链表相交，则从相交的节点起，其后的所有的节点都是都是两个链表共有的。因此，如果它们相交，则最后一个节点一定是共有的。因此，判断两链表相交的方法是：遍历第一个链表，记住最后一个节点。然后遍历第二个链表，到最后一个节点时和第一个链表的最后一个节点做比较，如果相同，则相交。
时间复杂度：O（length(A)+length(B)），但是只用了一个额外指针存储最后一个节点。
// 若都无环，b1==b2==0,尾节点必然相同，是Y字形
if (!b1)
{
while (head1->next != NULL) // 原来的代码head1 != NULL，此处改为head1->next != NULL。因为head1和head2遍历到最后都为NULL的时候必然相等，这样就会造成判断错误
{
head1 = head1->next;
}
while (head2->next != NULL) // 原来的代码head2 != NULL，此处改为head2->next != NULL。因为head1和head2遍历到最后都为NULL的时候必然相等，这样就会造成判断错误
{
head2 = head2->next;
}
if (head1 == head2)
{
return true;
}
}
6) 如两个（无环）单链表相交，求相交的第一个节点
将链表A的尾节点的next指针指向链表B的头结点，从而构造了一个环。问题转化为求这个环的入口问题。
时间复杂度：求环入口的时间复杂度。
// 若都无环，b1==b2==0,尾节点必然相同，是Y字形
if (!b1)
{
T* node1 = head1;
T* node2 = head2;
while (node1->next != NULL)// 原来的代码node1 != NULL，此处改为node1->next != NULL。因为node1和node2遍历到最后都为NULL的时候必然相等，这样就会造成判断错误
{
node1 = node1->next;
}
while (node2->next != NULL)// 原来的代码node2 != NULL，此处改为node2->next != NULL。因为node1和node2遍历到最后都为NULL的时候必然相等，这样就会造成判断错误
{
node2 = node2->next;
}
if (node1 == node2)
{
// 相交，把第一个链表的尾节点指向第二个链表
node1->next = head2;
junctionNode = findLoopPort(head1);
return true;
}
}
7) 判断两个（有环）单链表是否相交
分别判断两个链表A、B是否有环。
如果仅有一个有环，则A、B不可能相交。如果相交，则该环必定是A、B共享。
如果两个都有环，则求出A的环入口，判断其是否在B链表上，如果在，则说明A、B相交。
时间复杂度："环入口问题的时间复杂度"+O(length(B))。
见8)
8) 如两个（有环）单链表相交，求相交的第一个节点
分别计算出两个链表A、B的长度LA和LB（环的长度和环到入口点长度之和就是链表长度），参照上面问题3)。
如果LA>LB，则链表A指针先走LA-LB，链表B指针再开始走，则两个指针相遇的位置就是相交的第一个节点。
如果LB>LA，则链表B指针先走LB-LA，链表A指针再开始走，则两个指针相遇的位置就是相交的第一个节点。
时间复杂度：O(max(LA,LB))
// 若有环，则找出链表1的环入口，看是否在链表2上
if (b1)
{
int length1 = getLoopLength(head1) + getTailLength(head1);
int length2 = getLoopLength(head2) + getTailLength(head2);
int len = length2;
T* port = findLoopPort(head1);
if (port != NULL)
{
T* temp = head2;
while (port != temp && (len--) >= 0)
temp = temp->next;
if (port == temp)
{
// 若长度相等，同步寻找相同的节点
if (length1 == length2)
{
while (head1 != head2)
{
head1 = head1->next;
head2 = head2->next;
}
junctionNode = head1;
}
// 若长度不等，长的先剪掉长度差，然后再同步递增
else if (length1 > length2)
{
int step = length1 - length2;
while (step--)
{
head1 = head1->next;
}
while (head1 != head2)
{
head1 = head1->next;
head2 = head2->next;
}
junctionNode = head1;
}
else
{
int step = length2 - length1;
while (step--)
{
head2 = head2->next;
}
while (head1 != head2)
{
head1 = head1->next;
head2 = head2->next;
}
junctionNode = head1;
}
return true;
}
else
{
return false;
}
}
}
完整代码：
/*Title: 7.判断俩个链表是否相交
Date: 2012-11-12*/
#include <iostream>
#include <string>
#include <list>
using namespace std;
// 1) 判断一个单链表是否有环
template<typename T>
bool checkCircle(T* head)
{
if (NULL == head)
return false;
T* low = head;
T* fast = head;
while (low->next != NULL && (fast->next != NULL) && (fast->next)->next != NULL)
{
low = low->next;
fast = (fast->next)->next;
if (low == fast)
{
return true;
}
}
return false;
}
// 2) 查找环的入口
template<typename T>
T* findLoopPort(T* head)
{
// 判断是否有环，五环返回NULL
if (!checkCircle(head))
return NULL;
T* low = head;
T* fast = head;
// low按照步长1增加，fast按照步长2增加，找到碰撞点
while (1)
{
low = low->next;
fast = fast->next->next;
if (low == fast)
break;
}
// 分别从头结点和碰撞节点开始按照步长1增加，遍历链表，第一个节点相同的点是环入口点
low = head;
while (low != fast)
{
low = low->next;
fast = fast->next;
}
return low;
}
// 3) 计算环的长度
template<typename T>
int getLoopLength(T* head)
{
if (!checkCircle(head))
return 0;
T* low = head;
T* fast = head;
int length = 0;
// low按照步长1增加，fast按照步长2增加，找到碰撞点,然后接着循环直到下一次碰撞，
// 计算两次碰撞之间的循环次数即为长度
while (1)
{
low = low->next;
fast = fast->next->next;
if (low == fast)
break;
}
while(1)
{
low = low->next;
fast = fast->next->next;
length++;
if (low == fast)
break;
}
return length;
}
// 4) 计算有环链表的尾长度
template<typename T>
int getTailLength(T* head)
{
T* port = findLoopPort(head);
int length = 0;
T* temp = head;
while (temp != port)
{
length++;
temp = temp->next;
}
return length;
}
// 5) 判断两个链表是否相交
template<typename T>
bool isListJunction(T* head1, T* head2)
{
if (NULL == head1 || NULL == head2)
{
return false;
}
// 如果头结点相同，代表相同的链表，肯定是相交
if (head1 == head2)
{
return true;
}
// 检测是否有环
bool b1 = checkCircle(head1);
bool b2 = checkCircle(head2);
// 若相交，则两个链表要么都无环，要么都有环
if (b1 != b2)
{
return false;
}
// 若都无环，b1==b2==0,尾节点必然相同，是Y字形
if (!b1)
{
while (head1->next != NULL)
{
head1 = head1->next;
}
while (head2->next != NULL)
{
head2 = head2->next;
}
if (head1 == head2)
{
return true;
}
}
// 若有环，则找出链表1的环入口，看是否在链表2上
if (b1)
{
T* port = findLoopPort(head1);
if (port != NULL)
{
T* temp = head2;
int length2 = getLoopLength(head2) + getTailLength(head2);
while (port != temp && (length2--) >= 0)
temp = temp->next;
if (port == temp)
return true;
else
return false;
}
}
return false;
}
// 6) 判断两个链表是否相交，并输出相交节点
template<typename T>
bool isListJunction(T* head1, T* head2, T *&junctionNode)
{
if (NULL == head1 || NULL == head2)
{
return false;
}
// 如果头结点相同，代表相同的链表，肯定是相交
if (head1 == head2)
{
junctionNode = head1;
return true;
}
// 检测是否有环
bool b1 = checkCircle(head1);
bool b2 = checkCircle(head2);
// 若相交，则两个链表要么都无环，要么都有环
if (b1 != b2)
{
return false;
}
// 若都无环，b1==b2==0,尾节点必然相同，是Y字形
if (!b1)
{
T* node1 = head1;
T* node2 = head2;
while (node1->next != NULL)
{
node1 = node1->next;
}
while (node2->next != NULL)
{
node2 = node2->next;
}
if (node1 == node2)
{
// 相交，把第一个链表的尾节点指向第二个链表
node1->next = head2;
junctionNode = findLoopPort(head1);
return true;
}
}
// 若有环，则找出链表1的环入口，看是否在链表2上
if (b1)
{
int length1 = getLoopLength(head1) + getTailLength(head1);
int length2 = getLoopLength(head2) + getTailLength(head2);
int len = length2;
T* port = findLoopPort(head1);
if (port != NULL)
{
T* temp = head2;
while (port != temp && (len--) >= 0)
temp = temp->next;
if (port == temp)
{
// 若长度相等，同步寻找相同的节点
if (length1 == length2)
{
while (head1 != head2)
{
head1 = head1->next;
head2 = head2->next;
}
junctionNode = head1;
}
// 若长度不等，长的先剪掉长度差，然后再同步递增
else if (length1 > length2)
{
int step = length1 - length2;
while (step--)
{
head1 = head1->next;
}
while (head1 != head2)
{
head1 = head1->next;
head2 = head2->next;
}
junctionNode = head1;
}
else
{
int step = length2 - length1;
while (step--)
{
head2 = head2->next;
}
while (head1 != head2)
{
head1 = head1->next;
head2 = head2->next;
}
junctionNode = head1;
}
return true;
}
else
{
return false;
}
}
}
return false;
}
template <typename T>
struct listNode
{
T val;
listNode *pre;
listNode *next;
listNode()
{
pre = NULL;
next = NULL;
}
listNode(T value)
{
val = value;
pre = NULL;
next = NULL;
}
};
int main(int argc,char** argv)
{
string first = "my is";
string second = "your";
string three = "is";
string four = "king";
string five = "name";
string first2 = "speak";
string second2 = "what";
list<string> firstlist;
firstlist.push_back(first);
firstlist.push_back(second);
firstlist.push_back(three);
firstlist.push_back(four);
firstlist.push_back(five);
list<string> secondlist;
secondlist.push_back(first2);
secondlist.push_back(second2);
secondlist.push_back(four);
secondlist.push_back(five);
// 链表1，无环
listNode<string> *head1 = new listNode<string>(first);
listNode<string> *pnode2 = new listNode<string>(second);
head1->next = pnode2;
listNode<string> *pnode3 = new listNode<string>(three);
pnode2->next = pnode3;
listNode<string> *pnode4 = new listNode<string>(four);
pnode3->next = pnode4;
listNode<string> *pnode5 = new listNode<string>(five);
pnode4->next = pnode5;
// 链表2，无环
listNode<string> *head2 = new listNode<string>(first2);
listNode<string> *pnode22 = new listNode<string>(second2);
head2->next = pnode22;
pnode22->next = pnode4;
pnode4->next = pnode5;
// 链表1、2相交
bool bJunction = isListJunction(head1,head2);
std::cout<< bJunction<<std::endl;
std::cout<< checkCircle(head1)<<endl;
std::cout<< checkCircle(head2)<<endl;
string first3 = "1";
string second3 = "2";
string three3 = "3";
string four3 = "4";
string five3 = "5";
string six3 = "6";
string seven3 = "7";
// 链表3，有环
listNode<string> *head3 = new listNode<string>(first3);
listNode<string> *pnode32 = new listNode<string>(second3);
head3->next = pnode32;
listNode<string> *pnode33 = new listNode<string>(three3);
pnode32->next = pnode33;
listNode<string> *pnode34 = new listNode<string>(four3);
pnode33->next = pnode34;
listNode<string> *pnode35 = new listNode<string>(five3);
pnode34->next = pnode35;
listNode<string> *pnode36 = new listNode<string>(six3);
pnode35->next = pnode36;
pnode36->next = pnode33;
cout<<findLoopPort(head3)->val<<endl;
cout<<getLoopLength(head3)<<endl;
// 链表4，有环
listNode<string> *head4 = new listNode<string>(seven3);
head4->next = pnode32;
cout<<isListJunction(head3,head4)<<endl;
cout<< "the length of list3 : "<<getLoopLength(head3) + getTailLength(head3)<<endl;
cout<< "the length of list4 : "<<getLoopLength(head4) + getTailLength(head3)<<endl;
listNode<string> *junctionNode = new listNode<string>;
cout<<isListJunction(head3,head4,junctionNode)<<endl;
cout<<"list3 与 list4的交点： "<<junctionNode->val<<endl;
system("pause");
return 0;
}