链表3: 两个单链表相交的一系列问题

【题目】 在本题中，单链表可能有环，也可能无环。给定两个 单链表的头节点 head1和head2，这两个链表可能相交，也可能 不相交。请实现一个函数， 如果两个链表相交，请返回相交的 第一个节点；如果不相交，返回null 即可。 要求：如果链表1 的长度为N，链表2的长度为M，时间复杂度请达到 O(N+M)，额外 空间复杂度请达到O(1)。
思想：
1，用哈希表遍历，如果遍历到相同的则表示有环，因为链表里面存放的是内存地址，使用当两个链表指向同一个内存地址的话，那么两个单链表必定相交。
2，定义两个指针，一个慢指针，一个快指针，快指针走两步，慢指针走一步，如果有环，那么快指针和慢指针一定会相遇，相遇后快指针回到头部，变为走一步，再相遇的时候那个节点就是入环的第一个节点。
注意：两个单链表要相交的话，那么必定是两个单链表都有环或者两个单链表都没有环.

具体看代码：

public class Code_14_FindFirstIntersectNode {

	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;
	}

	public static Node getLoopNode(Node head) { //判断该单链表是否有环
		if (head == null || head.next == null || head.next.next == null) {
			return null;
		}
		Node n1 = head.next; // n1 -> slow 慢指针
		Node n2 = head.next.next; // n2 -> fast 快指针
		while (n1 != n2) {
			if (n2.next == null || n2.next.next == null) {
				return null;
			}
			n2 = n2.next.next;
			n1 = n1.next;
		}
		n2 = head; // n2 -> walk again from head 快指针回到开头开始走一步
		while (n1 != n2) {
			n1 = n1.next;
			n2 = n2.next;
		}
		return n1; //成环的那个节点
	}

	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--; //这里是n--，可以判断两个单链表谁的长度更长
			cur2 = cur2.next;
		}
		if (cur1 != cur2) {
			return null;   //两个无环的单链表相交的话，最后一个节点肯定是一样的
		}
		cur1 = n > 0 ? head1 : head2; //大于0说明head1的长度更长 
		cur2 = cur1 == head1 ? head2 : head1; //这句和上面那句的作用是把长度更长的那个单链表给cur1
		n = Math.abs(n);//返回n的绝对值
		while (n != 0) {
			n--;
			cur1 = cur1.next;
		}
		while (cur1 != cur2) { //得到相交的第一个节点
			cur1 = cur1.next;
			cur2 = cur2.next;
		}
		return cur1;
	}

	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; //loop1和loop2都是第一个节点，只是相对于那个链表而言，返回那个都可以
				}
				cur1 = cur1.next;   
			}
			return null;
		}
	}

	public static void main(String[] args) {
		// 1->2->3->4->5->6->7->null
		Node head1 = new Node(1);
		head1.next = new Node(2);
		head1.next.next = new Node(3);
		head1.next.next.next = new Node(4);
		head1.next.next.next.next = new Node(5);
		head1.next.next.next.next.next = new Node(6);
		head1.next.next.next.next.next.next = new Node(7);

		// 0->9->8->6->7->null
		Node head2 = new Node(0);
		head2.next = new Node(9);
		head2.next.next = new Node(8);
		head2.next.next.next = head1.next.next.next.next.next; // 8->6
		System.out.println(getIntersectNode(head1, head2).value);

		// 1->2->3->4->5->6->7->4...
		head1 = new Node(1);
		head1.next = new Node(2);
		head1.next.next = new Node(3);
		head1.next.next.next = new Node(4);
		head1.next.next.next.next = new Node(5);
		head1.next.next.next.next.next = new Node(6);
		head1.next.next.next.next.next.next = new Node(7);
		head1.next.next.next.next.next.next = head1.next.next.next; // 7->4

		// 0->9->8->2...
		head2 = new Node(0);
		head2.next = new Node(9);
		head2.next.next = new Node(8);
		head2.next.next.next = head1.next; // 8->2
		System.out.println(getIntersectNode(head1, head2).value);

		// 0->9->8->6->4->5->6..
		head2 = new Node(0);
		head2.next = new Node(9);
		head2.next.next = new Node(8);
		head2.next.next.next = head1.next.next.next.next.next; // 8->6
		System.out.println(getIntersectNode(head1, head2).value);

	}

}