一、打印两个有序链表的公共部分
【题目】
给定两个有序链表的头指针head1和head2，打印两个链表的公共部分。
【分析】
假设有如下两个有序链表
整个流程是这样的：谁小动谁，一开始1<2，所以head1来到3的位置
此时2<3，所以head2来到3的位置
head1=head2，打印3，并且head1和head2共同往下走一步
重复上述步骤，直到一个指针来到终点位置，整个流程就停止。
总结：谁小谁就往右移动，如果相等，打印该数，并共同往右移动；head1和head2只要有1个来到终点位置，整个流程就停止。
【代码实现】
public class PrintCommonPart { public static class Node { public int value; public Node next; public Node(int data) { this.value = data; } } public static void printCommonPart(Node head1, Node head2) { System.out.print("Common Part: "); while (head1 != null && head2 != null) { if (head1.value < head2.value) { head1 = head1.next; } else if (head1.value > head2.value) { head2 = head2.next; } else { System.out.print(head1.value + " "); head1 = head1.next; head2 = head2.next; } } System.out.println(); } public static void printLinkedList(Node node) { System.out.print("Linked List: "); while (node != null) { System.out.print(node.value + " "); node = node.next; } System.out.println(); } public static void main(String[] args) { Node node1 = new Node(2); node1.next = new Node(3); node1.next.next = new Node(5); node1.next.next.next = new Node(6); Node node2 = new Node(1); node2.next = new Node(2); node2.next.next = new Node(5); node2.next.next.next = new Node(7); node2.next.next.next.next = new Node(8); printLinkedList(node1); printLinkedList(node2); printCommonPart(node1, node2); } }
二、判断一个链表是否为回文结构
【题目】
给定一个链表的头节点head，请判断该链表是否为回文结构。 例如： 1->2->1，返回true。 1->2->2->1，返回true。15->6->15，返回true。 1->2->3，返回false。
【方法一】——额外空间复杂度O(N)
假设有如下链表
每遍历一个数都往栈压入相应的数
因为栈是先进后出的，所以从栈顶到栈底其实就是原来链表顺序的逆序。
然后再从头开始遍历链表，每遍历一个数，都从栈中取一个数出来比较，相当于原始顺序跟逆序依次比较，如果比到最后每一步都相等，则该链表是回文的；如果其中有任何一步不相等，就不是回文。
这个因为要准备一个栈，所以额外空间是O(N)。
public class IsPalindromeList { public static class Node { public int value; public Node next; public Node(int data) { this.value = data; } } /** * 需要N的额外空间，空间复杂度为O(N) * @param head * @return */ public static boolean isPalindrome1(Node head) { Stack<Node> stack = new Stack<>(); Node cur = head; while (cur != null) { stack.push(cur); cur = cur.next; } while (head != null) { if (head.value != stack.pop().value) { return false; } head = head.next; } return true; }
public static void printLinkedList(Node node) { System.out.print("Linked List: "); while (node != null) { System.out.print(node.value + " "); node = node.next; } System.out.println(); } public static void main(String[] args) { Node head = null; printLinkedList(head); System.out.print(isPalindrome1(head) + " | "); printLinkedList(head); System.out.println("========================="); head = new Node(1); printLinkedList(head); System.out.print(isPalindrome1(head) + " | "); printLinkedList(head); System.out.println("========================="); head = new Node(1); head.next = new Node(2); printLinkedList(head); System.out.print(isPalindrome1(head) + " | "); printLinkedList(head); System.out.println("========================="); head = new Node(1); head.next = new Node(2); head.next.next = new Node(3); printLinkedList(head); System.out.print(isPalindrome1(head) + " | "); printLinkedList(head); System.out.println("========================="); head = new Node(1); head.next = new Node(2); head.next.next = new Node(2); head.next.next.next = new Node(1); printLinkedList(head); System.out.print(isPalindrome1(head) + " | "); printLinkedList(head); System.out.println("========================="); } }
【方法二】——额外空间复杂度O(N)
设置两个指针，一个快指针（一次走2步），一个慢指针（一次走1步）。
快指针走完的时候，慢指针会来到中点的位置；慢指针来到中点位置后，将右半部分压到栈里
快指针走完的时候，慢指针来到3的位置，然后将后面的部分（2，1）压到栈里。
然后前面的部分（1，2）和栈中元素比较，如果每一步都相等，就是回文。
这个方法的实质就是：假设有一段线，从中点开始，让右半部分折回去，然后每个数再比较，如果每一步都相等，就是回文。
用这个方法的好处是：栈会少一半空间，虽然额外空间还是O(N),但实际的结果是省了一半的空间
public class IsPalindromeList { public static class Node { public int value; public Node next; public Node(int data) { this.value = data; } }/** * 需要n/2的额外空间,但是空间复杂度仍是O(N) * @param head * @return */ public static boolean isPalindrome2(Node head) { if (head == null || head.next == null) { return true; } //慢指针——指向第2个数 Node slow = head.next; //快指针——指向第1个数 Node fast = head; while (fast.next != null && fast.next.next != null) { //慢指针一次走一步 slow = slow.next; //快指针一次走两步 fast = fast.next.next; } // 上面过程结束之后,slow就是指向中点的后一位.如果是偶数个数的话,那么就是指向后半段的第一个位置 Stack<Node> stack = new Stack<>(); while (slow != null) { stack.push(slow); slow = slow.next; } while (!stack.isEmpty()) { if (head.value != stack.pop().value) { return false; } head = head.next; } return true; } public static void printLinkedList(Node node) { System.out.print("Linked List: "); while (node != null) { System.out.print(node.value + " "); node = node.next; } System.out.println(); } public static void main(String[] args) { Node head = null; printLinkedList(head); System.out.print(isPalindrome2(head) + " | "); printLinkedList(head); System.out.println("========================="); head = new Node(1); printLinkedList(head); System.out.print(isPalindrome2(head) + " | "); printLinkedList(head); System.out.println("========================="); head = new Node(1); head.next = new Node(2); printLinkedList(head); System.out.print(isPalindrome2(head) + " | "); printLinkedList(head); System.out.println("========================="); head = new Node(1); head.next = new Node(2); head.next.next = new Node(3); printLinkedList(head); System.out.print(isPalindrome2(head) + " | "); printLinkedList(head); System.out.println("========================="); head = new Node(1); head.next = new Node(2); head.next.next = new Node(2); head.next.next.next = new Node(1); printLinkedList(head); System.out.print(isPalindrome2(head) + " | "); printLinkedList(head); System.out.println("========================="); } }
【方法三】——额外空间复杂度O(1)
设置两个指针，一个快指针（一次走2步），一个慢指针（一次走1步）
快指针走完的时候，慢指针会来到中点的位置。从中点位置开始，让右半部分逆序。
然后分别从两边的1开始遍历，往中间逼近，中途有任何一个对不上，就不是回文，如果全部都能对的上，就是回文。
但是不管是不是回文，你在返回结果前，都要把后半部分调回原来的样子。
public class IsPalindromeList { public static class Node { public int value; public Node next; public Node(int data) { this.value = data; } }/** * 彻底不用额外空间 * @param head * @return */ public static boolean isPalindrome3(Node head) { if (head == null || head.next == null) { return true; } //慢指针 Node slow = head; //快指针 Node fast = head; /* 快指针一次走两步,慢指针一次走一步 当快指针走完后,慢指针来到中间位置 */ while (fast.next != null && fast.next.next != null) { slow = slow.next; fast = fast.next.next; } //右半部分的第一个元素 fast = slow.next; slow.next = null; Node n3 = null; /* 后半部分逆序 */ while (fast != null) { n3 = fast.next; fast.next = slow; slow = fast; fast = n3; } n3 = slow; fast = head; boolean res = true; //检查每一步的数是否相等 while (slow != null && fast != null) { if (slow.value != fast.value) { res = false; break; } slow = slow.next; fast = fast.next; } slow = n3.next; n3.next = null; //返回结果之前,将后半部分逆序的部分调回来 while (slow != null) { fast = slow.next; slow.next = n3; n3 = slow; slow = fast; } return res; }
public static void printLinkedList(Node node) { System.out.print("Linked List: "); while (node != null) { System.out.print(node.value + " "); node = node.next; } System.out.println(); } public static void main(String[] args) { Node head = null; printLinkedList(head); System.out.print(isPalindrome3(head) + " | "); printLinkedList(head); System.out.println("========================="); head = new Node(1); printLinkedList(head); System.out.print(isPalindrome3(head) + " | "); printLinkedList(head); System.out.println("========================="); head = new Node(1); head.next = new Node(2); printLinkedList(head); System.out.print(isPalindrome3(head) + " | "); printLinkedList(head); System.out.println("========================="); head = new Node(1); head.next = new Node(2); head.next.next = new Node(3); printLinkedList(head); System.out.print(isPalindrome3(head) + " | "); printLinkedList(head); System.out.println("========================="); head = new Node(1); head.next = new Node(2); head.next.next = new Node(2); head.next.next.next = new Node(1); printLinkedList(head); System.out.print(isPalindrome3(head) + " | "); printLinkedList(head); System.out.println("========================="); } }
三、将单向链表按某值划分成左边小、中间相等、右边大的形式
【题目】
给定一个单向链表的头节点head，节点的值类型是整型，再给定一个整 数pivot。实现一个调整链表的函数，将链表调整为左部分都是值小于 pivot的节点，中间部分都是值等于pivot的节点，右部分都是值大于 pivot的节点。除这个要求外，对调整后的节点顺序没有更多的要求。 例如：链表9->0->4->5->1，pivot=3。 调整后链表可以是1->0->4->9->5，也可以是0->1->9->5->4。总之，满 足左部分都是小于3的节点，中间部分都是等于3的节点（本例中这个部分为空），右部分都是大于3的节点即可。对某部分内部的节点顺序不做要求。
【分析】
最简单的做法：
把链表的每一个位置放在一个容器里，即生成一个Node类型的数组，然后在数组里面对Node的值进行划分：小于指定值的放左边，等于的放中间，大于的放右边。然后从容器开始重新连接这个链表，连完之后返回即可。此时的额外空间复杂度为O(N)
public class SmallerEqualBigger { public static class Node { public int value; public Node next; public Node(int data) { this.value = data; } } public static Node listPartition1(Node head, int pivot) { if (head == null) { return head; } Node cur = head; int i = 0; while (cur != null) { i++; cur = cur.next; } Node[] nodeArr = new Node[i]; i = 0; cur = head; //将原链表的每个Node节点放在数组里 for (i = 0; i != nodeArr.length; i++) { nodeArr[i] = cur; cur = cur.next; } arrPartition(nodeArr, pivot); //从数组容器里重新连接成链表结构 for (i = 1; i != nodeArr.length; i++) { nodeArr[i - 1].next = nodeArr[i]; } nodeArr[i - 1].next = null; return nodeArr[0]; } /** * 等同于荷兰国旗问题 * @param nodeArr * @param pivot */ public static void arrPartition(Node[] nodeArr, int pivot) { int small = -1; int big = nodeArr.length; int index = 0; while (index != big) { if (nodeArr[index].value < pivot) { swap(nodeArr, ++small, index++); } else if (nodeArr[index].value == pivot) { index++; } else { swap(nodeArr, --big, index); } } } public static void swap(Node[] nodeArr, int a, int b) { Node tmp = nodeArr[a]; nodeArr[a] = nodeArr[b]; nodeArr[b] = tmp; } public static void printLinkedList(Node node) { System.out.print("Linked List: "); while (node != null) { System.out.print(node.value + " "); node = node.next; } System.out.println(); } public static void main(String[] args) { Node head1 = new Node(7); head1.next = new Node(9); head1.next.next = new Node(1); head1.next.next.next = new Node(8); head1.next.next.next.next = new Node(5); head1.next.next.next.next.next = new Node(2); head1.next.next.next.next.next.next = new Node(5); printLinkedList(head1); head1 = listPartition1(head1, 4); printLinkedList(head1); } }
【进阶】—— 在原问题的要求之上再增加如下两个要求。
在左、中、右三个部分的内部也做顺序要求，要求每部分里的节点从左 到右的顺序与原链表中节点的先后次序一致。 例如：链表9->0->4->5->1，pivot=3。调整后的链表是0->1->9->4->5。 在满足原问题要求的同时，左部分节点从左到右为0、1。在原链表中也 是先出现0，后出现1；中间部分在本例中为空，不再讨论；右部分节点 从左到右为9、4、5。在原链表中也是先出现9，然后出现4，最后出现5。如果链表长度为N，时间复杂度请达到O(N)，额外空间复杂度请达到O(1)。
【分析】
假设有如下链表，按照4来划分，设置3个引用(small、equal、big)。
遍历一次链表，找到第一个小于4的节点，找到第一个等于4的节点，找到第一个大于4的节点.。
再遍历一遍链表，如果找到的是某个区域的头节点，就省略，比如说再遍历的时候找到的是7，就省略，因为这个7和big之前找到的节点是同一个(注意这里比较的是Node的内存地址，而不是Node的值)。遍历到6的时候，6>4，就往大于的区域里放，依次下去。然后再将3个区域连接起来即可
public class SmallerEqualBigger { public static class Node { public int value; public Node next; public Node(int data) { this.value = data; } }/** * 不需要额外的空间复杂度，且能达到稳定性 * @param head * @param pivot * @return */ public static Node listPartition2(Node head, int pivot) { if (head == null) { return null; } //小于部分链表的head和tail Node sH = null, sT = null; //等于部分链表的head和tail Node eH = null, eT = null; //大于部分链表的head和tail Node bH = null, bT = null; //用来保存下一个结点 Node next = null; //划分到三个不同的链表 while (head != null) { next = head.next; //为了链表拼接后,最后一个就不用再去赋值其next域为null了 head.next = null; //向small部分 分布 if (head.value < pivot) { //small部分的第一个结点 if (sH == null) { sH = head; sT = head; } else { //把head放到small最后一个 sT.next = head; //更新small部分的sT sT = head; } } else if (head.value == pivot) { if (eH == null) { eH = head; eT = head; } else { eT.next = head; eT = head; } } else { if (bH == null) { bH = head; bT = head; } else { bT.next = head; bT = next; } } head = next; } ///将三个链表合并(注意边界的判断) if (sT != null) { //合并small和equal部分 sT.next = eH; eT = eT == null ? sT : eT; } if (eT != null) { eT.next = bH; } return sH != null ? sH : eH != null ? eH : bH; }
public static void printLinkedList(Node node) { System.out.print("Linked List: "); while (node != null) { System.out.print(node.value + " "); node = node.next; } System.out.println(); } public static void main(String[] args) { Node head1 = new Node(7); head1.next = new Node(3); head1.next.next = new Node(4); head1.next.next.next = new Node(6); head1.next.next.next.next = new Node(0); head1.next.next.next.next.next = new Node(4); printLinkedList(head1); head1 = listPartition2(head1, 4); printLinkedList(head1); } }
四、复制含有随机指针节点的链表
【题目】
一种特殊的链表节点类描述如下：
public class Node { public int value; public Node next; public Node rand; public Node(int data) { this.value = data; } }
Node类中的value是节点值，next指针和正常单链表中next指针的意义一 样，都指向下一个节点，rand指针是Node类中新增的指针，这个指针可能指向链表中的任意一个节点，也可能指向null。 给定一个由Node节点类型组成的无环单链表的头节点head，请实现一个函数完成这个链表中所有结构的复制，并返回复制的新链表的头节点。
【分析】
这题的题意是，假设有下面链表，节点1的next指向2，节点2的next指向3，节点3的next指向null。另外，假设节点1的rand指针指向节点3，节点2的rand指针指向节点1，节点3的rand指针指向null。
需要做的是：复制该链表的所有结构（深度拷贝），最后返回1'节点
我们可以用HashMap来实现，具体做法是：
从节点1开始依次遍历到节点3，每遍历一个节点，就克隆出一个新的节点，并把这2个节点放在HashMap中，key是原链表节点，value是新链表节点。
怎么实现克隆呢？如果一个节点是node，克隆后的节点为newNode，可以将node节点传入newNode节点中：Node newNode=new Node(node.value)；
但是现在对于newNode来说，next指针和rand指针都是null。怎么办呢？我们可以在hash表里记一个记录，例如key就是节点1，value就是节点1’。
再次遍历原始链表，当我得到节点1的时候，在map中可以把节点1‘取出；因为节点1的next指针是指向节点2的，所以拷贝后的节点1‘的next指针也应该指向节点2’。而在map中，我们可以通过节点2找到节点2‘，所以就可以将1’的next指针指向2‘；我们还可以通过节点1的rand指针找到节点3，节点1’的rand指针也应该指向3'节点，其中3‘节点可以在map中找到。这是在遍历节点1的时候，1’的指针是怎么设置的。按照此方式设置2‘和3’的指针。
public class CopyListWithRandom { public static class Node { public int value; public Node next; public Node rand; public Node(int data) { this.value = data; } } /** * 利用HashMap,key存的是原链表的节点,value存的是该节点的克隆节点 * @param head * @return */ public static Node copyListWithRand1(Node head) { HashMap<Node, Node> map = new HashMap<>(); Node cur = head; while (cur != null) { //map的value里面是纯净的节点,开始是没有next跟rand的指向,需要自己去指定 map.put(cur, new Node(cur.value)); cur = cur.next; } Node X = head; //以下while跑完后,克隆节点之间的结构就设置完毕了 while (X != null) { // map.get(x)是x的拷贝节点x' map.get(X).next = map.get(X.next); map.get(X).rand = map.get(X.rand); X = X.next; } return map.get(head); } public static void printRandLinkedList(Node head) { Node cur = head; System.out.print("Order: "); while (cur != null) { System.out.print(cur.value + " "); cur = cur.next; } System.out.println(); cur = head; System.out.print("rand: "); while (cur != null) { System.out.print(cur.rand == null ? "- " : cur.rand.value + " "); cur = cur.next; } System.out.println(); } public static void main(String[] args) { Node head = null; Node res = null; printRandLinkedList(head); res = copyListWithRand1(head); printRandLinkedList(res); printRandLinkedList(head); System.out.println("========================="); head = new Node(1); head.next = new Node(2); head.next.next = new Node(3); head.next.next.next = new Node(4); head.next.next.next.next = new Node(5); head.next.next.next.next.next = new Node(6); head.rand = head.next.next.next.next.next; // 1 -> 6 head.next.rand = head.next.next.next.next.next; // 2 -> 6 head.next.next.rand = head.next.next.next.next; // 3 -> 5 head.next.next.next.rand = head.next.next; // 4 -> 3 head.next.next.next.next.rand = null; // 5 -> null head.next.next.next.next.next.rand = head.next.next.next; // 6 -> 4 printRandLinkedList(head); res = copyListWithRand1(head); printRandLinkedList(res); printRandLinkedList(head); System.out.println("========================="); } }
【进阶】
不使用额外的数据结构，只用有限几个变量，且在时间复杂度为 O(N)内完成原问题要实现的函数。
【分析】
不用hash表又怎么做呢？还是这个链表，但是拷贝后的节点是放在老链表的下一个，然后再和老链表的下一个相连。注意rand指针原来的位置并没变，只是在原来的节点1和节点2之间加了一个节点1‘。
这样做有什么好处呢？接下来遍历的时候，每一次遍历拿出2个节点，比如拿出节点1和节点1‘。1通过rand指针可以找到3，而3的克隆节点3’就是3的下一个节点，在这种结构中，通过3的next就可以找到3‘，然后把1’的rand指向3‘。第一种方法使用hash表的目的就是为了知道老链表和新链表的对应关系，而用这种方法也能把新老链表的对应关系留下来。按照这种思路，依次拿出节点2和节点2’，节点3和节点3‘即可实现所求。
最后再将新链表和老链表分离出来，整个过程就结束了。
public class CopyListWithRandom { public static class Node { public int value; public Node next; public Node rand; public Node(int data) { this.value = data; } }public static Node copyListWithRand2(Node head) { if (head == null) { return null; } Node cur = head; Node next = null; //复制链表 //原来的链表 : 1 -> 2 -> 3 -> 4 -> 5 -> 6 //复制的链表 : 1 -> 1' -> 2 -> 2' -> 3-> 3' -> 4 -> 4' -> 5 -> 5' -> 6 -> 6' while (cur != null) { next = cur.next; cur.next = new Node(cur.value); cur.next.next = next; cur = next; } cur = head; //curCopy相当于是一个引线 Node curCopy = null; //设置随机指向 while (cur != null) { next = cur.next.next; curCopy = cur.next; //注意curCopy的rand指向的是rand.next.因为原节点的next才是纯净的节点,这些next节点到时需要分隔出去 curCopy.rand = cur.rand != null ? cur.rand.next : null; cur = next; } //这个节点就是分隔出来的链表的头节点 Node res = head.next; cur = head; //分离 while (cur != null) { next = cur.next.next; curCopy = cur.next; //这一步是连接后面的 cur.next = next; curCopy.next = next != null ? next.next : null; cur = next; } return res; } public static void printRandLinkedList(Node head) { Node cur = head; System.out.print("Order: "); while (cur != null) { System.out.print(cur.value + " "); cur = cur.next; } System.out.println(); cur = head; System.out.print("rand: "); while (cur != null) { System.out.print(cur.rand == null ? "- " : cur.rand.value + " "); cur = cur.next; } System.out.println(); } public static void main(String[] args) { Node head = null; Node res = null; printRandLinkedList(head); res = copyListWithRand2(head); printRandLinkedList(res); printRandLinkedList(head); System.out.println("========================="); head = new Node(1); head.next = new Node(2); head.next.next = new Node(3); head.next.next.next = new Node(4); head.next.next.next.next = new Node(5); head.next.next.next.next.next = new Node(6); head.rand = head.next.next.next.next.next; // 1 -> 6 head.next.rand = head.next.next.next.next.next; // 2 -> 6 head.next.next.rand = head.next.next.next.next; // 3 -> 5 head.next.next.next.rand = head.next.next; // 4 -> 3 head.next.next.next.next.rand = null; // 5 -> null head.next.next.next.next.next.rand = head.next.next.next; // 6 -> 4 printRandLinkedList(head); res = copyListWithRand2(head); printRandLinkedList(res); printRandLinkedList(head); System.out.println("========================="); } }
五、两个单链表相交的一系列问题
【题目】
在本题中，单链表可能有环，也可能无环。给定两个单链表的头节点 head1和head2，这两个链表可能相交，也可能不相交。请实现一个函数， 如果两个链表相交，请返回相交的第一个节点；如果不相交，返回null 即可。 要求：如果链表1的长度为N，链表2的长度为M，时间复杂度请达到 O(N+M)，额外空间复杂度请达到O(1)。
【分析】
先解决一个问题：怎么判断一个链表是否有环？如果一个链表有环，返回第一个入环的节点；如果一个链表无环，返回null；
方法一：使用hash表。
在遍历过程中，把每个节点放到hashSet里（没有value，只有key），如果有环的话，就能重复回到一个节点。因为set把你遍历过的节点都放到里面去了，所以就能发现一个节点有没有遍历过。如果发现一个节点有遍历过，就是有环，并且返回第一个入环的节点；如果走到null，就是无环，返回null。注意：set里面存的不是节点的值，而是节点的内存地址。
/** * 返回链表的第一个入环节点——使用HashSet，需要额外空间 * @param head * @return */ public static Node getFirstLoopNode(Node head) { HashSet<Node> set = new HashSet<>(); while (head != null) { if (set.contains(head)) { return head; } set.add(head); head = head.next; } return null; }
方法二：不用额外空间，准备两个指针，一个快指针，一个慢指针。
快指针一次走2步，慢指针一次走1步。如果走的过程中，快指针走到了null，肯定无环；如果有环，快指针和慢指针一定会在环上相遇（相遇并不是值相等，而是内存地址是同一个）。相遇后，快指针回到开头，然后变成每次走一步；接下来，快指针和慢指针一起走，它们会在第一个入环节点处相遇，这是一个数学结论。此过程时间复杂度还是O(N).
/** * 返回链表的第一个入环节点——使用快慢指针，不需要额外空间 * @param head * @return */ 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; } //快指针和慢指针相遇后,快指针回到头部 fast = head; while (slow != fast) { slow = slow.next; fast = fast.next; } return slow; }
现在有两个链表，head1是链表1的头节点，head2是链表2的头节点，调用getLoopNode()函数后，就可以得到head1的第一个入环节点loop1， 也能得到head2整个链表中第一个入环节点loop2，如果loop1=null&&loop2=null，这就是两个无环链表的相交问题。两个无环链表的相交问题有两种可能：一种是不相交，一种是相交
假如有两个无环链表h1、h2，怎么求两条无环链表相交的第一个节点？
方法一：使用hash表
hash表遍历h1，把h1上的所有节点都加到set里去，然后在遍历h2的过程中,每遍历一个节点，都检查该节点是否存在于set中，如果存在，这个节点就是和h1相交的第一个节点。
举个例子，第一遍把左侧h1的节点全部放到set中，然后依次遍历右侧的h2节点，前两个节点set中都不存在 ，来到第三个节点时，发现在set中，所以这个节点就是第一个相交的节点。
方法二：不使用hash表
两个无环链表h1和h2。先遍历h1，因为是无环，所以能找到结尾，统计h1的长度(len1)以及找到h1最后一个节点(e1)。再遍历h2，统计h2的长度(len2)并找到h2最后一个节点(e2)，如果e1和e2不是同一个节点，那么h1和h2不可能相交，返回null。如果e1=e2，h1和h2肯定相交，那它俩第一个相交的节点是什么呢？举个例子，如果len1=100,len2=80，还是让h1和h2都从头开始遍历，但是让h1先走20步，然后和h2一起往下走，它俩一定会共同进入第一个相交的节点。
/** * 两个链表都无环 * @param head1 * @param head2 * @return 返回第一个相交的节点 */ 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; }
如果一个链表有环，另外一个链表无环，不可能相交。如果有相交，都会破坏单链表只有一个next的结构。
如果两个链表都有环，即loop1!=null，loop2!=null。形成的结构有3种：
怎么判断是哪一种结构？
如果loop1=loop2，是第二种结构。怎么求相交的第一个节点？把环里的部分忽略掉，把loop1、loop2作为终止，这时候就等同于两个无环链表的相交问题；
如果loop1!=loop2，让loop1通过next指针往下走，因为loop1是第一个入环的节点，它往下走一定能回到自己，如果它回到自己了，都没有遇到loop2，就是第一种结构；
如果loop1往下走后，中途遇到了loop2，就是第三种情况。如果中途能遇到loop2，返回loop1作为第一个相交的节点或者返回loop2作为第一个相交的节点都对，因为loop1是距离h1更近的，loop2是距离h2更近的，它们都可以叫做h1和h2两个链表第一个相交的节点。
/** * 两个链表都有环 * @param head1 * @param loop1 head1的第一个入环节点 * @param head2 * @param loop2 head2的第一个入环节点 * @return */ public static Node bothLoop(Node head1, Node loop1, Node head2, Node loop2) { Node cur1 = null; Node cur2 = null; //如果是第二种结构,把环里的部分忽略掉,把loop1、loop2作为终止,等同于两个无环链表的相交问题 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 { //如果loop1!=loop2,让loop1通过next指针往下走 cur1 = loop1.next; while (cur1 != loop1) { //如果loop1走的过程中遇到loop2,就是第三种情况 if (cur1 == loop2) { return loop1; } cur1 = cur1.next; } return null; } }
【两个链表相交系列问题的代码实现】
public class 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; } //head1的第一个入环节点 Node loop1 = getLoopNode(head1); //head2的第一个入环节点 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 void main(String[] args) { // head1链表: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); // head2链表:0->9->8->6->7->null Node head2 = new Node(0); head2.next = new Node(9); head2.next.next = new Node(8); //head2的8节点指向head1的6节点 head2.next.next.next = head1.next.next.next.next.next; //打印两个无环链表的第一个相交节点,结果为6 System.out.println(getIntersectNode(head1, head2).value); // head1链表：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); //7节点的next指向4节点,形成有环 head1.next.next.next.next.next.next = head1.next.next.next; // 0->9->8->2... head2 = new Node(0); head2.next = new Node(9); head2.next.next = new Node(8); //head2的8节点的next指针指向head1的2节点 head2.next.next.next = head1.next; //两个有环链表的相交问题(第二种结构) System.out.println(getIntersectNode(head1, head2).value); // head2链表：0->9->8->6->4->5->6.. head2 = new Node(0); head2.next = new Node(9); head2.next.next = new Node(8); //head2的8节点的next指针指向head1的6节点 head2.next.next.next = head1.next.next.next.next.next; //两个有环链表的相交问题(第三种结构),返回loop1或loop2 System.out.println(getIntersectNode(head1, head2).value); } }