算法习题8：判断俩个链表是否相交

微软亚院之编程判断俩个链表 是否相交
给出俩个单向链表的头 指针，比如h 1，h2 ，判断这俩个链表是否相交。
为了简化问题，我们假设俩个链表均不带环 。

问题扩展：
1.如果链表可能有环列?

2.如果需要求出俩个链表相交的第一个节点列?

同样参考：http://bbs.csdn.net/topics/350118968

--------------------------------------------------------------

首先分析下，判断两个链表是否相交？

假设相交了，那么根据链表特性，相交以后就汇成一个链表，所以后面的节点都相同，可是从h1-->交点和h2-->交点经过的节点数不一定相同，这就使得我们判定他们什么时候相交不一定能够很快找到，除非采用时间复杂度O(len1*len2)这种强奸式的遍历！

我们继续想，既然相交以后的链表都一样了，那他们的共同特点就是，结尾一致，所以我们只要遍历到结尾即可，时间复杂度降为O(max(len1,len2))

但是，新问题又来了，如果存在环呢？这个尾就不存在了。首先要判断是否存在环。。

所以这个问题被分解为

1、链表是否存在环

2、有环和无环怎么找出是否相交

3、这个相交点在哪里（这个办法现在看了大家都是采用 哈希表和一个定理，http://www.cnblogs.com/BeyondAnyTime/archive/2012/07/06/2580026.html 这篇文章给了说明，但是那个定理我还保持怀疑态度，）

方法1：

判断有无环，可以利用slow=1步 fast =2步的指针来移动，如果fast->null 则无环，如果fast 与 slow相遇，则有环

方法2：

我这里采用逆序，就是对原序列头指针改成尾指针，尾指针变成头指针，

revert(h1);revert(h2)

如果是有环的则 revertH1 == h1 && revertH2 == h2

无环则(revertH1 != h1 && revertH2 != h2)

我还没看到有人采用逆序，所以这里就用这种方法写个代码把，不过这方法还是找不到相交点具体位置。。

//============================================================================
// Name        : JudgeIntersect.cpp
// Author      : YLF
// Version     :
// Copyright   : Your copyright notice
// Description : Hello World in C++, Ansi-style
//============================================================================

#include <iostream>
using namespace std;

struct Node{
	int value;
	Node* next;
};

Node* h1 = NULL;
Node* h2 = NULL;
Node* p1Cur = NULL;
Node* p2Cur = NULL;

Node* pIntersect = NULL;

void nextNode(Node* p1, Node* p2);
bool isIntersect(Node* revertH1,Node* revertH2,bool isLoop);
bool RevertLink(Node* &head);

int main() {

	int a[7] = {1,2,3,7,8,9,1};
	int b[8] = {3,5,7,1,7,8,9,1};
	int i=0,j=0;
	for(j=0;j<8;j++){
		Node* p2 = new Node();
		p2->value = b[j];
		p2->next = NULL;

		if(h2==NULL){
			h2 = p2;
		}else{
			p2Cur->next = p2;
		}
			p2Cur = p2;
		if(j==4)
			pIntersect = p2;
		if(j == 7)
			p2->next = pIntersect;
	}


	for(i=0;i<3;i++){
		Node* p1 = new Node();
		p1->value = a[i];
		p1->next = NULL;

		if(h1==NULL){
			h1 = p1;
		}else{
			p1Cur->next = p1;
		}
			p1Cur = p1;
	}

	p1Cur->next = pIntersect;
	pIntersect = NULL;

	//上面是先自动生成两个相交的链表

	//先逆序,这里先对h1逆序，再对h2逆序，这个顺序很重要，如果二者相交，那么会发现
	//revertH2 == h1
	Node *revertH1 = h1;
	Node *revertH2 = h2;
	RevertLink(revertH1);
	RevertLink(revertH2);
	//接下来从逆序开始判断是否相等，以及相等点在哪？
	if(revertH1 == h1 && revertH2 == h2){
		//存在环
		if(isIntersect(revertH1,revertH2,true))
			cout<<"exists loop and intersect "<<endl;
		else
			cout<<"有环，不相交";
	}
	else if(revertH1 != h1 && revertH2 != h2){
		//不存在环
		if(isIntersect(revertH1,revertH2,false))
			cout<<"not exists loop but intersect "<<endl;
		else
			cout<<"无环，不相交";
	}else
		cout<<"不相交";


	return 0;
}

bool RevertLink(Node* &head){
	if(head==NULL)
		return false;
	Node* p1 = head;
	if(p1->next == NULL)
		return true;
	Node* p2 = p1->next;
	if(p2->next == NULL){
		p1->next = NULL;
		p2->next = p1;
		head = p2;
		return true;
	}
	Node* p3 = p2->next;

	if(p1 == head)
		p1->next = NULL;
	//start revert
	while(p3){
		p2->next = p1;
		p1 = p2;
		p2 = p3->next;
		Node* temp = p2;
		p2 = p3;
		p3 = temp;
	}
	p2->next = p1;
	head = p2;
	return true;

}

bool isIntersect(Node* revertH1,Node* revertH2,bool isLoop){
	if(!isLoop){
		if(revertH2 == h1){
			return true;
		}
	}else{
		Node* p1 = revertH1;
		Node* p2 = revertH2;
		while(p1 != p2){
			p1 = p1->next;
			p2 = p2->next->next;
		}
		cout<<endl<<"int:"<<p1->value;
		return true;
	}
	return false;
}