两个单链表是否相交的一系列问题

题目

单链表可能有环，也可能无环。给定两个单链表的头结点head1和head2，折两个链表可能相交，也可能不想交。请实现一个函数，如果两个链表相交，请返回相交的第一个节点；如果不想交那么返回null。时间复杂度o(M+N)空间复杂度o(1)
存在三个问题：
1.单链表是否有环
2.两个无环单链表第一个相交的节点
3.两个有环单链表第一个相交的节点
|||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||手动分割
1.单链表是否有环
有环返回第一个有环的节点 无环返回null
思路1：
使用哈希表，先判断节点是否入表，在让其一一入表，如果出现了已经入表的情况，那么这个节点一定是第一个入环的节点
思路2：
准备一个快指针走两步一个慢指针走一步
当快指针最后走到null，那么一定不是环
如果是环的话那么快指针总会和慢指针在环内相遇，相遇之后，让快指针指向head，快指针变成慢指针，这时候两个慢指针继续向前走，两个指针相遇的地方一定是第一个入环的节点(莫名玄学。。)

	private static Node getLoopNode(Node head) {    //得到第一个入环节点
		if (head == null || head.next == null) {
			return null;
		}
		Node n1 = head.next;         //慢指针
		Node n2 = head.next.next;    //快指针
		while (n1 != n2) {
			if (n2.next == null || n2.next.next == null) {     //提前走到头
				return null;
			}
			n2 = n2.next.next;
			n1 = n1.next; 
		}                           
		n2 = head;                       //相交，快指针返回头
		while (n1 != n2) { 
			n1 = n1.next;
			n2 = n2.next;                //快指针变慢指针   两个指针继续向前走直到相交
		}		
		return n1;
	}

2.两个无环单链表第一个相交的节点

思路1：
还是使用哈希表，把head1中所有节点放到Map中，然后遍历head2，当Map中第一次出现head2中的节点的时候，那么就是相交的第一个节点，遍历玩了还没发现，那就是不相交
思路2：
先遍历head1并统计其长度和他最后一个节点，然后遍历head2统计其长度和他最后一个节点
end1 == end2 [不是值相等而是内存地址相等] 说明相交 否则一定不相交 因为这是单链表不可能存在交叉的情况
这个时候并不能确定最后这个节点是不是第一个相交的节点，计算length1和length2，让短的先走length1-length2，然后在一起走，一定能找到第一个相交的节点

	private 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;              //看谁长谁短  cur1保存长的那个的头
		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;
	}

3.一个有环单链表一个无环不可能相交，因为这是一个单链表
4.两个有环单链表第一个相交的节点
(1)各自成环 毫无关系 不相交
(2)共用一个环 先相交 然后共享一个环
(3)一个环单拉两条线
区别(1)(2)(3)
head1和head2的环相同那么就是(2)这样就等同于无环链表相交了
环不同的话区别(1)(3)两个指针向下走当一个指针都来回转圈又转回自己了，还没碰见另一个指针那么就是(1)，转圈的时候碰见了另一个指针那么就是(3)

	private static Node bothLoop(Node head1, Node loop1, Node head2, Node loop2) {   //有环链表相交问题
		Node cur1 = null;
		Node cur2 = null;
		if (loop1 == loop2) {   //共用一个环 那么这个时候就回到了noLoop的情况
			cur1 = head1;
			cur2 = head2;
			int n = 0;
			while (cur1 != null) {
				n++;
				cur1 = cur1.next;
			}
			while (cur2 != null) {
				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) {    //转圈的时候碰见了loop2 那么就是第三种情况
					return loop1;
				}
				cur1 = cur1.next;
			} 
			return null;                 //转了一圈都没碰见那么就是各自成环
		}
	}

完整的code

public class FindFirstIntersectNode {
	
	public static class Node{
		public int value;
		public Node next;
		
		public Node(int data) {
			this.value = data;
		}
	}
	
	public static Node gerInterSectNode(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;  //这个的情况就是两个中一个有环一个无环
	}

	private static Node getLoopNode(Node head) {    //得到第一个入环节点
		if (head == null || head.next == null) {
			return null;
		}
		Node n1 = head.next;         //慢指针
		Node n2 = head.next.next;    //快指针
		while (n1 != n2) {
			if (n2.next == null || n2.next.next == null) {     //提前走到头
				return null;
			}
			n2 = n2.next.next;
			n1 = n1.next; 
		}                           
		n2 = head;                       //相交，快指针返回头
		while (n1 != n2) { 
			n1 = n1.next;
			n2 = n2.next;                //快指针变慢指针
		}		
		return n1;
	}
	
	private 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;              //看谁长谁短
		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;
	}

	private static Node bothLoop(Node head1, Node loop1, Node head2, Node loop2) {   //有环链表相交问题
		Node cur1 = null;
		Node cur2 = null;
		if (loop1 == loop2) {   //公用一个环 那么这个时候就回到了noLoop的情况
			cur1 = head1;
			cur2 = head2;
			int n = 0;
			while (cur1 != null) {
				n++;
				cur1 = cur1.next;
			}
			while (cur2 != null) {
				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) {    //转圈的时候碰见了loop2 那么就是第三种情况
					return loop1;
				}
				cur1 = cur1.next;
			} 
			return null;                 //转了一圈都没碰见那么就是各自成环
		}
	}
}