有苦有乐的算法 --- 可能有环也可能无环的两个单链表，判断这两个链表是否相交，如果相交返回相交的第一个节点

题目

可能有环也可能无环的两个单链表，判断这两个链表是否相交，如果相交返回相交的第一个节点。

解析

第一步，判断链表是有环链表还是无环链表；
如果一个单链表无环，它一定有一个指向null的尾结点；
如果一个单链表有环，用两个指针oneStep，twoStep，twoStep一次走两个节点，oneStep一次走一个节点，这两个指针必定会相遇；
此时将twoStep重新遍历，一次走一个节点，oneStep也继续一次走一个节点，二次相遇的时候，这个节点就是入环节点。

第二步，判断是否相交；
2-1：一个单链表有环，一个单链表无环，这两个单链表一定不想交；
2-2：两个单链表都无环，这两个单链表尾结点相同，则说明它们相交；这两个单链表尾结点不相同，则说明它们不相交。

找相交节点：
两个单链表在遍历时，用一个变量n记录两个单链表的长度差，单链表1遍历时++，单链表2遍历时–，如果n>0说明单链表1长，如果n<0说明单链表2长，如果n=0说明1两个单链表一样长；在重新遍历两个链表，链表长的先遍历n的绝对值个节点，然后两个链表一起前进，第一个相同节点为相交的第一个节点。

2-3：两个单链表都有环，那么有三种情况：

不想交的情况：先找到一个单链表的入环节点node；然后遍历另一个单链表，如果二次到达入环节点都没有找到node，说明这两个链表不相交；如果二次到达入环节点前都找到了node，说明这两个链表相交。

入环节点前相交的情况：上面得知链表相交，如果两个单链表的入环节点相同，则说明它们入环节点前相交；
找相交节点：
如果只看开始节点到入环节点这段链表，则装换成2-2情况。

入环节点后相交的情况：上面得知链表相交，如果两个单链表的入环节点不相同，则说明它们入环节点后相交；
找相交节点：此种情况，两个入环节点都可以说是相交的第一个节点。

代码

public static class Node {
	public int value;
	public Node next;
	public Node(int data) {
		this.value = data;
	}
}

public static Node getIntersectNode(Node head1, Node head2) {
	if (head1 == null || head2 == null) {
		return null;
	}
	Node loop1 = getLoopNode(head1);
	Node loop2 = getLoopNode(head2);
	if (loop1 == null && loop2 == null) {
		return noLoop(head1, head2);
	}
	if (loop1 != null && loop2 != null) {
		return bothLoop(head1, loop1, head2, loop2);
	}
	return null;
}

// 找到链表第一个入环节点，如果无环，返回null
public static Node getLoopNode(Node head) {
	if (head == null || head.next == null || head.next.next == null) {
		return null;
	}
	Node slow = head.next; 
	Node fast = head.next.next; 
	while (slow != fast) {
		if (fast.next == null || fast.next.next == null) {
			return null;
		}
		fast = fast.next.next;
		slow = slow.next;
	}
	// slow fast  相遇
	fast = head; // n2 -> walk again from head
	while (slow != fast) {
		slow = slow.next;
		fast = fast.next;
	}
	return slow;
}

// 如果两个链表都无环，返回第一个相交节点，如果不想交，返回null
public static Node noLoop(Node head1, Node head2) {
	if (head1 == null || head2 == null) {
		return null;
	}
	Node cur1 = head1;
	Node cur2 = head2;
	int n = 0;
	while (cur1.next != null) {
		n++;
		cur1 = cur1.next;
	}
	while (cur2.next != null) {
		n--;
		cur2 = cur2.next;
	}
	if (cur1 != cur2) {
		return null;
	}
	
	cur1 = n > 0 ? head1 : head2; 
	cur2 = cur1 == head1 ? head2 : head1; 
	n = Math.abs(n);
	while (n != 0) {
		n--;
		cur1 = cur1.next;
	}
	while (cur1 != cur2) {
		cur1 = cur1.next;
		cur2 = cur2.next;
	}
	return cur1;
}

// 两个有环链表，返回第一个相交节点，如果不想交返回null
public static Node bothLoop(Node head1, Node loop1, Node head2, Node loop2) {
	Node cur1 = null;
	Node cur2 = null;
	if (loop1 == loop2) {
		cur1 = head1;
		cur2 = head2;
		int n = 0;
		while (cur1 != loop1) {
			n++;
			cur1 = cur1.next;
		}
		while (cur2 != loop2) {
			n--;
			cur2 = cur2.next;
		}
		cur1 = n > 0 ? head1 : head2;
		cur2 = cur1 == head1 ? head2 : head1;
		n = Math.abs(n);
		while (n != 0) {
			n--;
			cur1 = cur1.next;
		}
		while (cur1 != cur2) {
			cur1 = cur1.next;
			cur2 = cur2.next;
		}
		return cur1;
	} else {
		cur1 = loop1.next;
		while (cur1 != loop1) {
			if (cur1 == loop2) {
				return loop1;
			}
			cur1 = cur1.next;
		}
		return null;
	}
}