给定两个单向链表，这两个链表有可能会有重叠，情况如下：
两个单向链表从节点5开始重合，要求给定一个空间复杂度为O(1)的算法，返回两个链表相交时的第一个节点。依据上图，也就是返回节点5.
首先我们需要做的是，确保给定的两个单向链表，他们是相交的。这个很好确定，只要从头遍历两个链表，如果他们的尾节点是一样的话，那么这两个链表就是相交的，问题是，如何尽快找到他们相交的第一个节点。
最笨的办法是，先找到尾节点，然后去掉尾节点，然后再次遍历查找新的尾节点，然后再去掉，直到两个链表没有共同的尾节点，那么最后去掉的共同尾巴节点，则是两个链表的首次相交节点。这种做法可行，但是算法复杂度是O(n^2)。有没有更好的办法呢？
假设第一个链表，从头结点到首次相交节点，所经历的距离用T1来表示，根据上图例子，T1 = 5, 也就是第一个队列从头结点0开始，需要经历节点1，2，3，4也就是总共5个节点后才能到达节点5.
我们用T3 表示队列2从头节点开始，到达首次相交节点的距离。根据上图，T3 = 3.
我们用T2表示两队列相交部分的节点数.依据上图T2 = 5.
由此队列1的长度为： T1 + T2 (1)
队列2的长度为：T3 + T2 (2)
如果我们能算出T3的数值，那么我们从队列2的头结点出发，经过T3-1步后，就能达到首次相交节点。我们如何计算T3的数值呢？
对T3的计算，需要一个小技巧.我们把队列2进行反转，得到下面情形：
如果此时我们从队列1的头结点开始进行遍历，那么从上头的节点0开始出发，会到队列2的头结点0结束。这样，在反转后，如果再次从头遍历队列1的话，得到的长度就是：
T1 + T3 + 1 (3).
根据上面三个公式，我们便可以计算出T3来。
(3) - (1) = T1 + T3 + 1 - T1 - T2 = T3 - T2 + 1
(3) - (1) + (2) = T3 - T2 + 1 + T3 + T2 = 2*T3 + 1
由此，我们可以反解出T3, 有了T3，我们便可以得到两队列首次相交节点了。
这个算法除了需要遍历两个队列外，还需要对其中一个队列进行反转，无论是遍历还是反转，其算法复杂度都是O(n), 因此总算法复杂度是O(n).
代码实现：
public class ListIntersetChecker {
private Node listHead1;
private Node listHead2;
private int firstListLen = 0; //t1 + t2
private int secondListLen = 0; // t3 + t2
private int lenAfterReverse = 0; // t1 + t3
private ListReverse listReverse = null;
public ListIntersetChecker(Node listHead1, Node listHead2) {
this.listHead1 = listHead1;
this.listHead2 = listHead2;
}
public Node getFirstIntersetNode() {
if (isTwoListInterset() == false) {
return null;
}
listReverse = new ListReverse(listHead2);
Node reverseHead = listReverse.getReverseList();
lenAfterReverse = getListLen(listHead1);
int t3 = ((lenAfterReverse - firstListLen) + secondListLen - 1) / 2;
int steps = secondListLen - t3 - 1;
while (steps > 0) {
reverseHead = reverseHead.next;
steps--;
}
return reverseHead;
}
private int getListLen(Node head) {
int len = 0;
while (head != null) {
head = head.next;
len++;
}
return len;
}
private boolean isTwoListInterset() {
Node head1 = listHead1;
Node head2 = listHead2;
while (head1.next != null || head2.next != null) {
if (head1.next != null) {
head1 = head1.next;
firstListLen++;
}
if (head2.next != null) {
head2 = head2.next;
secondListLen++;
}
}
firstListLen++;
secondListLen++;
return head1 == head2;
}
}ListIntersetCheck.java 用于实现上面描述的算法。 getFirstIntersetNode返回两重叠队列首次相交节点。isTwoListInterset 用于判断两队列是否相交。在遍历两队列时，统计两队列的长度，也就是获得 T1 + T2 以及 T3 + T2的值。
然后把队列2进行反转，反转后，再从队列1的头节点进行遍历，得到的lenAfterReverse就是 T1 + T3 + 1.
int t3 = ((lenAfterReverse - firstListLen) + secondListLen - 1) / 2;
上面语句则根据前面的推导计算出T3.
由于队列2已经反转了，所以不能从队列2的头结点去遍历，只能从队列2的尾节点开始遍历，如果头结点开始遍历需要T3步的话，那么从尾节点遍历，则需要steps = secondListLen - (T3 + 1) 步。
由此，代码从队列2反转后的头结点开始，经过steps个节点后抵达两队列首次相交时的节点。
再看看主入口代码:
public class LinkList {
public static void main(String[] args) {
ListUtility util1 = new ListUtility();
ListUtility util2 = new ListUtility();
Node list1 = util1.createList(10);
Node list2 = util2.createList(3);
Node node = util1.getNodeByIdx(5);
Node tail = util2.getNodeByIdx(2);
tail.next = node;
ListIntersetChecker intersetChecker = new ListIntersetChecker(list1, list2);
Node interset = intersetChecker.getFirstIntersetNode();
System.out.println("The first interset node is : " + interset.val);
}
}程序启动时，先构造两个队列，队列1节点从0到9，队列2从0到2，然后把队列2的尾节点的next指向队列1的编号为5的节点，于是就构造了我们例子图中的两个相交队列，然后再利用ListIntersetChecker获得两重合队列的首个相交节点。
最后程序运行结果为：
The first interset node is : 5
结果跟我们理论推导一致，也就是说，我们的说法实现是正确的。更详细的代码讲解和推导调试过程，请参看视频。
更多技术信息，包括操作系统，编译器，面试算法，机器学习，人工智能，请关照我的公众号：
