算法18：LeetCode_链表相关算法题
链表无小事，只要是涉及到链表的算法题，边界值的设定尤为重要，而且及其容易出错误。这就要求我们平时多加练习。但是，我们在面试和笔试的过程中往往会碰到链表相关的题目，所以我们在笔试的时候一般都会借助系统提供的工具类进行解答，但是在面试的过程中，面试官往往想听到的答案是和链表直接相关的解答。这就要求我们有2套不同的应答方案。
题目1：给定一个单链表的头节点head，请判断该链表是否为回文结构
package code03.链表_01; import java.util.Stack; /** * 给定一个单链表的头节点head，请判断该链表是否为回文结构 * https://leetcode.cn/problems/palindrome-linked-list/ * * 1）哈希表方法特别简单（笔试用） * 2）改原链表的方法就需要注意边界了（面试用） */ public class Palindrome_01 { static class ListNode { int val; ListNode next; ListNode() {} ListNode(int val) { this.val = val; } ListNode(int val, ListNode next) { this.val = val; this.next = next; } } //笔试用, 怎么简单怎么来，安全保险最重要 public boolean isPalindrome (ListNode head) { //Letcode 默认仅有一个节点的链表也是回文 if (head == null /*|| head.next == null*/) { return false; } //后进先出，正好和node是反着的 Stack stack = new Stack(); ListNode node = head; while (node != null) { stack.push(node); node = node.next; } boolean isPadinDrom = true; while (head != null) { if (head.val != ((ListNode) stack.pop()).val) { isPadinDrom = false; break; } head = head.next; } return isPadinDrom; } //面试用, 对链表进行操作，大体思路对即可，高端大气上档次 //这种写法节省了额外空间复杂度 Stack public boolean isPalindrome2 (ListNode header) { //Letcode 默认仅有一个节点的链表也是回文 if (header == null /*|| header.next == null*/) { return false; } ListNode fast = header; ListNode slow = header; while (fast != null && fast.next != null && fast.next.next != null) { // fast.next.next != null 判断特别重要 fast = fast.next.next; slow = slow.next; } //奇数，slow正好是中间节点。 偶数，slow是2个中间节点靠后的一个 ListNode next = slow.next; slow.next = null; ListNode reverseNode = slow; //前一个逆转的node节点、 ListNode node2 = null; //逆转回文后半部分链表节点 //假设原有链表是1->2->3->2->1 逆转后得到 1 ->2 -> 3 ->null 和 1 -> 2 ->3 -> null结构 //假设原有链表是1->2->3->3->2->1 逆转后得到 1 ->2 -> 3 ->null 和 1 -> 2 ->3 -> 3->null结构 while (next != null && reverseNode != null) { node2 = next.next; //记录下一个节点 next.next = reverseNode; //当前节点指向之前被逆转的节点 reverseNode = next; //更新被逆转的节点 next = node2; //当前节点来到下一个节点处 } //开始比较 //因为我们根据快慢指针进行切割并且第一个3作为中间节点，前一段链表是标准的结构；后一段链表存在以下2种情况 //1) 奇数，前后链表相同个数；偶数，厚一点链表多一个值。 因此以第一个链表为参考即可. 参考上一个while的备注 ListNode cur = header; boolean isPadinDrom = true; node2 = reverseNode; while (cur!= null) { if (cur.val != reverseNode.val) { isPadinDrom = false; break; } cur = cur.next; reverseNode = reverseNode.next; } /** * 如果我们不在意原有链表是否被破坏，那么以下while可以省略 * 如果我们还想要保持原有链表结构不被破坏，此处我们需要修复原有链表 * 假设原有链表是1->2->3->2->1 逆转后得到 1 ->2 -> 3 ->null 和 1 -> 2 ->3 -> null结构 * 假设原有链表是1->2->3->3->2->1 逆转后得到 1 ->2 -> 3 ->null 和 1 -> 2 ->3 -> 3->null结构 * 两个链表的最后一个节点在内存中是相同的，因此仅需要参考后一个链表进行修复即可（此处需要重点理解） */ reverseNode = null; while (node2 != null) { next = node2.next; node2.next = reverseNode; reverseNode = node2; node2 = next; } return isPadinDrom; } public static void printNode (ListNode node) { if (node == null) { System.out.println("链表不存在"); } System.out.println("当前链表的值为： " + node.val); //递归的方式逐层打印Node的子节点 if(node.next != null) { printNode(node.next); } } public static void main(String[] args) { Palindrome_01 test = new Palindrome_01(); ListNode node = new ListNode(1); node.next = new ListNode(2); node.next.next = new ListNode(3); node.next.next.next = new ListNode(2); node.next.next.next.next = new ListNode(1); //node.next.next.next.next.next = new Node(1); boolean isPadinDrom = test.isPalindrome(node); System.out.println(isPadinDrom); boolean isPadinDrom2 = test.isPalindrome2(node); System.out.println("测试原链表是否被修复"); printNode(node); System.out.println(isPadinDrom2); ListNode node2 = new ListNode(1); node2.next = new ListNode(2); node2.next.next = new ListNode(3); node2.next.next.next = new ListNode(3); node2.next.next.next.next = new ListNode(2); node2.next.next.next.next.next = new ListNode(1); //node2.next.next.next.next.next.next = new Node(1); boolean isPadinDrom3 = test.isPalindrome(node2); System.out.println(isPadinDrom3); boolean isPadinDrom4 = test.isPalindrome2(node2); System.out.println("测试原链表是否被修复"); printNode(node2); System.out.println(isPadinDrom4); } }
题目2：将单向链表按某值划分成左边小、中间相等、右边大的形式
笔试用：
package code03.链表_01; import java.lang.reflect.Array; import java.util.ArrayList; /** * 将单向链表按某值划分成左边小、中间相等、右边大的形式 * 笔试用，典型的快排 */ public class SmallEqualBig_02 { static class Node { int value; Node next; Node(int value) { this.value = value; } } public static void swap(Node[] nodeArr, int a, int b) { Node tmp = nodeArr[a]; nodeArr[a] = nodeArr[b]; nodeArr[b] = tmp; } public void partition (Node[] nodes, int left, int right) { //以最后一个值为参考值 Node pavoit = nodes[right]; int min = left; int max = right; int cur = left; while (cur < max) { if (nodes[cur].value < pavoit.value) { swap(nodes, min++, cur++); } else if (nodes[cur].value > pavoit.value) { swap(nodes, cur, --max); } else { cur++; } } swap(nodes, cur, right); } public Node sort(Node node) { if(node == null || node.next == null) { return node; } int n = 0; Node cur = node; while (cur != null) { cur = cur.next; n++; } Node[] arr = new Node[n]; cur = node; for (int i =0; i < arr.length; i++) { arr[i] = cur; cur = cur.next; } partition(arr, 0, n-1); cur = arr[0]; node = cur; for (int i =1; i < arr.length; i++) { cur.next = arr[i]; cur = cur.next; } cur.next = null; return node; } public static void printNode (Node node) { if (node == null) { System.out.println("链表不存在"); } System.out.println("当前链表的值为： " + node.value); //递归的方式逐层打印Node的子节点 if(node.next != null) { printNode(node.next); } } 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); SmallEqualBig_02 test = new SmallEqualBig_02(); System.out.println("排序前的节点"); printNode(head1); System.out.println("================="); Node n2 = test.sort(head1); printNode(n2); } }
面试用：
package code03.链表_01; //将单向链表按某值划分成左边小、中间相等、右边大的形式 public class SmallEqualBig_03 { static class Node { int value; Node next; Node(int value) { this.value = value; } } //笔试用, 不借助任何的新对象，纯粹借住现有的链表结构进行操作 public Node sort(Node node, int povit) { Node maxStart = null; Node maxEnd = null; Node minStart = null; Node minEnd = null; Node equalStart = null; Node equalEnd = null; while (node != null) { if(node.value < povit) { if (minStart == null) { minStart = node; minEnd = node; } else { minEnd.next = node; minEnd = node; } } else if(node.value > povit) { if (maxStart == null) { maxStart = node; maxEnd = node; } else { maxEnd.next = node; maxEnd = node; } } else { if (equalStart == null) { equalStart = node; equalEnd = node; } else { equalEnd.next = node; equalEnd = node; } } node = node.next; } if (minEnd != null) { if (equalStart != null) { minEnd.next = equalStart; equalEnd.next = null; } else if (maxStart != null) { minEnd.next = maxStart; maxEnd.next = null; } } if (equalEnd != null){ if (maxStart != null) { equalEnd.next = maxStart; maxEnd.next = null; } else { equalEnd.next = null; } } return minStart != null ? minStart : equalStart != null ? equalStart : maxStart; } public static void printNode (Node node) { if (node == null) { System.out.println("链表不存在"); } System.out.println("当前链表的值为： " + node.value); //递归的方式逐层打印Node的子节点 if(node.next != null) { printNode(node.next); } } 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); SmallEqualBig_03 test = new SmallEqualBig_03(); System.out.println("排序前的节点"); printNode(head1); System.out.println("================="); Node n2 = test.sort(head1, 5); printNode(n2); } }
题目3：
一种特殊的单链表节点类描述如下
class Node {
int value;
Node next;
Node rand;
Node(int val) { value = val; }
}
rand指针是单链表节点结构中新增的指针，rand可能指向链表中的任意一个节点，也可能指向null。
给定一个由Node节点类型组成的无环单链表的头节点 head，请实现一个函数完成这个链表的复制，并返回复制的新链表的头节点。
【要求】
时间复杂度O(N)，额外空间复杂度O(1)
package code03.链表_01; import java.util.HashMap; import java.util.Map; /** * 一种特殊的单链表节点类描述如下 * class Node { * int value; * Node next; * Node rand; * Node(int val) { value = val; } * } * rand指针是单链表节点结构中新增的指针，rand可能指向链表中的任意一个节点，也可能指向null。 * 给定一个由Node节点类型组成的无环单链表的头节点 head，请实现一个函数完成这个链表的复制，并返回复制的新链表的头节点。 * 【要求】 * 时间复杂度O(N)，额外空间复杂度O(1) * * 解题思路： * 1. 借助系统容器，逐个深拷贝每个指针对象，然后将拷贝的指针串成新指针返回 (笔试用) * * 2.深拷贝每个指针对象，并且串联进当前的指针当中，然后将当前链表进行切割，生成新链表并返回（面试用） */ public class DeepCopyNode_04 { static class Node { int value; Node next; Node rand; Node(int val) { value = val; } } //借助系统容器，笔试用（快准稳） public Node deepCopy1 (Node node) { //额外空间复杂度O（1）, 此处只生成了一个map对象 //而深拷贝N个指针，是题目本身就要求的事情，因此可以忽略题目要求的O（N）空间复杂度 Map<Node, Node> map = new HashMap<>(); if (node == null) { return node; } //深拷贝每个node Node cur = node; while (cur != null) { Node n = new Node(cur.value); map.put(cur, n); cur = cur.next; } //构造新链表 cur = node; while (cur != null) { map.get(cur).next = map.get(cur.next); map.get(cur).rand = map.get(cur.rand); cur = cur.next; } return (Node) map.get(node); } //纯链表实现，面试用 public Node deepCopy2 (Node node) { if (node == null) { return node; } Node cur = node; //假设链表为1-2-3 拷贝完以后就是 1-1-2-2-3-3 while (cur != null) { //深拷贝 Node n = new Node(cur.value); Node next = cur.next; cur.next = n; n.next = next; cur = next; } cur = node; Node copy = cur.next; //rand有可能是后面指向前面，所以不能提前断开，否则找不到copy后后面的指针对象的rand while (cur != null && cur.next != null) { //cur.next != null等价于copy ！= null //假设 b 是copy a的节点，那么b的rand节点肯定就在a.rand节点后面 copy.rand = cur.rand != null ? cur.rand.next : null; cur = cur.next.next; //等价于cur = copy.next copy = cur != null ? cur.next : null; } //最后分离 cur = node; copy = cur.next; Node ans = copy; while (cur != null && cur.next != null) { Node curNext = cur.next.next; Node copyNext = curNext != null ? curNext.next : null; cur.next = curNext; copy.next = copyNext; cur = curNext; copy = copyNext; } return ans; } public static void printNode (Node node) { if (node == null) { System.out.println("链表不存在"); } System.out.println("当前链表的值为： " + node.value); System.out.println("当前链表的random值为： " + (node.rand == null ? null : node.rand.value)); //递归的方式逐层打印Node的子节点 if(node.next != null) { printNode(node.next); } } 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); head1.next.next.rand = head1.next.next.next.next; head1.next.next.next.next.next.next.rand = head1; DeepCopyNode_04 test = new DeepCopyNode_04(); Node n = test.deepCopy1(head1); printNode(n); System.out.println("=================="); Node n2 = test.deepCopy2(head1); printNode(n2); } }
题目4：给你一个链表的头节点 head ，判断链表中是否有环。如果链表中有某个节点，可以通过连续跟踪 next 指针再次到达，则链表中存在环。 为了表示给定链表中的环，评测系统内部使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。注意：pos 不作为参数进行传递 。仅仅是为了标识链表的实际情况。如果链表中存在环 ，则返回 true 。 否则，返回 false 。
package code03.链表_01; /** * 给你一个链表的头节点 head ，判断链表中是否有环。 * * 如果链表中有某个节点，可以通过连续跟踪 next 指针再次到达，则链表中存在环。 * 为了表示给定链表中的环，评测系统内部使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。 * 注意：pos 不作为参数进行传递 。仅仅是为了标识链表的实际情况。 * * 如果链表中存在环 ，则返回 true 。 否则，返回 false 。 * 链接：https://leetcode.cn/problems/linked-list-cycle */ public class LoopNode_05 { static class ListNode { int value; ListNode next; ListNode(int value) { this.value = value; } } public boolean hasCycle(ListNode node) { //需要使用快慢指针 if (node == null || node.next == null || node.next.next == null) { return false; } ListNode fast = node.next.next; ListNode slow = node.next; //跳出当前循环 //1) fast == slow 循环链表 //2) fast.next 或 fast.next.next 为 null 不是循环链表 while (fast.next != null && fast.next.next != null) { if (fast == slow) { break; } fast = fast.next.next; slow = slow.next; } //无环链表 if (fast.next == null || fast.next.next == null) { return false; } return true; } }
题目5：给定一个链表的头节点 head ，返回链表开始入环的第一个节点。 如果链表无环，则返回 null。如果链表中有某个节点，可以通过连续跟踪 next 指针再次到达，则链表中存在环。为了表示给定链表中的环，评测系统内部使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。如果 pos 是 -1，则在该链表中没有环。注意：pos 不作为参数进行传递，仅仅是为了标识链表的实际情况。
package code03.链表_01; /** * 给定一个链表的头节点 head ，返回链表开始入环的第一个节点。 如果链表无环，则返回 null。 * * 如果链表中有某个节点，可以通过连续跟踪 next 指针再次到达，则链表中存在环。 * 为了表示给定链表中的环，评测系统内部使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。 * 如果 pos 是 -1，则在该链表中没有环。注意：pos 不作为参数进行传递，仅仅是为了标识链表的实际情况。 * https://leetcode.cn/problems/linked-list-cycle-ii */ public class LoopNode_05_2 { static class ListNode { int value; ListNode next; ListNode(int value) { this.value = value; } } public ListNode detectCycle(ListNode node) { //需要使用快慢指针 if (node == null || node.next == null || node.next.next == null) { return null; } ListNode fast = node.next.next; ListNode slow = node.next; //跳出当前循环 //1) fast == slow 循环链表 //2) fast.next 或 fast.next.next 为 null 不是循环链表 while (fast.next != null && fast.next.next != null) { if (fast == slow) { break; } fast = fast.next.next; slow = slow.next; } //无环链表 if (fast.next == null || fast.next.next == null) { return null; } //有环链表 fast = node; //备注1： 找出第一个相交节点，此处根据数据推导公式得出 while (fast != slow) { fast = fast.next; slow = slow.next; } //返回fast 或 slow 都对 return fast; } public static void main(String[] args) { ListNode head1 = new ListNode(7); ListNode head2 = new ListNode(9); head1.next = head2; ListNode head3 = new ListNode(1); head2.next = head3; ListNode head4 = new ListNode(8); head3.next = head4; ListNode head5 = new ListNode(5); head4.next = head5; ListNode head6 = new ListNode(6); head5.next = head6; ListNode head7 = new ListNode(5); head6.next = head7; LoopNode_05_2 loop = new LoopNode_05_2(); //测试无环 ListNode loopNode = loop.detectCycle(head1); System.out.println((loopNode != null ? loopNode.value : "null")); //测试有环 head7.next = head4; // head4作为环形链表的第一个值 ListNode loopNode2 = loop.detectCycle(head1); System.out.println("第一个入环节点的值为: " + (loopNode2 != null ? loopNode2.value : "null")); } }
此处，需要对代码中的 “备注1” 进行解释一下，为什么fast = node; while (fast != slow) { fast = fast.next; slow = slow.next;} 当 fast = slow的时候，fast或slow就是相交的第一个节点？ 不理解这一点，下面的题目无法继续进行下去
由此图，我们可知： 快指针从A点重新出现，跑了x距离。 那么慢指针就是跑 N圈额外加z一段距离，此时他们正好会在第一个相交的节点相遇。
题目6：给你两个单链表的头节点 headA 和 headB ，请你找出并返回两个单链表相交的起始节点。如果两个链表不存在相交节点，返回 null 。题目数据 保证 整个链式结构中不存在环。函数返回结果后，链表必须 保持其原始结构 。
package code03.链表_01; import java.util.HashMap; import java.util.Map; /** * 给你两个单链表的头节点 headA 和 headB ，请你找出并返回两个单链表相交的起始节点。如果两个链表不存在相交节点，返回 null 。 * 题目数据 保证 整个链式结构中不存在环。函数返回结果后，链表必须 保持其原始结构 。 * https://leetcode.cn/problems/intersection-of-two-linked-lists/ * */ public class DoubleLoopNodes_06 { static class ListNode { int value; ListNode next; ListNode(int value) { this.value = value; } } //借助java系统提供的容器 public ListNode getIntersectionNode(ListNode headA, ListNode headB) { if (headA == null || headB == null) { return null; } Map<ListNode, ListNode> map = new HashMap(); ListNode cur = headA; while (cur != null) { map.put(cur, cur); cur = cur.next; } cur = headB; while (cur != null) { if (map.containsKey(cur)) { return map.get(cur); } cur = cur.next; } return null; } //纯链表实现 public ListNode getIntersectionNode2(ListNode headA, ListNode headB) { if (headA == null || headB == null) { return null; } ListNode cur = headA; int n = 0; while (cur != null) { n++; cur = cur.next; } cur = headB; while (cur != null) { n--; cur = cur.next; } ListNode lNode = n > 0 ? headA : headB; //长链表 ListNode sNode = lNode == headA ? headB : headA; //短链表 n = Math.abs(n); while (n > 0) { lNode = lNode.next; n--; } //此刻，长链表剩下的节点和短链表剩下的节点个数相同 while (lNode != sNode) { lNode = lNode.next; sNode = sNode.next; if(lNode == null || sNode == null) { return null; } } return lNode; } public static void main(String[] args) { //链表1 ListNode node1 = new ListNode(4); ListNode node2 = new ListNode(1); //链表2 ListNode node3 = new ListNode(5); ListNode node4 = new ListNode(6); ListNode node5 = new ListNode(2); //相交节点 ListNode node6 = new ListNode(8); ListNode node7 = new ListNode(7); ListNode node8 = new ListNode(3); node1.next = node2; node2.next = node6; node6.next = node7; node7.next = node8; node3.next = node4; node4.next = node5; node5.next = node6; DoubleLoopNodes_06 test = new DoubleLoopNodes_06(); ListNode n1 = test.getIntersectionNode(node1, node3); System.out.println("相交节点的值为 ：" + (n1 != null ? n1.value : null)); ListNode n2 = test.getIntersectionNode2(node1, node3); System.out.println("相交节点的值为 ：" + (n2 != null ? n2.value : null)); } }
说了这么多，终极大boss终于要登场了。
题目7：给定两个可能有环也可能无环的单链表，头节点head1和head2。请实现一个函数，如果两个链表相交，请返回相交的 第一个节点。如果不相交，返回null
【要求】
如果两个链表长度之和为N，时间复杂度请达到O(N)，额外空间复杂度 请达到O(1)
解题思路：根据排除所得，要么两条链表无环相交，要么有环相交，只存在这两种情况
package code03.链表_01; /** * 给定两个可能有环也可能无环的单链表，头节点head1和head2。请实现一个函数，如果两个链表相交，请返回相交的 第一个节点。如果不相交，返回null * 【要求】 * 如果两个链表长度之和为N，时间复杂度请达到O(N)，额外空间复杂度 请达到O(1)。 * * 解题思路：根据排除所得，要么两条链表无环相交，要么有环相交，只存在这两种情况 */ public class DoubleLoopNodes_06_2 { static class ListNode { int value; ListNode next; ListNode(int value) { this.value = value; } } //获取单链表相交的第一个节点，不想交则返回null public ListNode getLoopNode(ListNode node) { //需要使用快慢指针 if (node == null || node.next == null || node.next.next == null) { return null; } ListNode fast = node.next.next; ListNode slow = node.next; //跳出当前循环 //1) fast == slow 循环链表 //2) fast.next 或 fast.next.next 为 null 不是循环链表 while (fast.next != null && fast.next.next != null) { if (fast == slow) { break; } fast = fast.next.next; slow = slow.next; } //无环链表 if (fast.next == null || fast.next.next == null) { return null; } //有环链表 fast = node; //备注1： 找出第一个相交节点，此处根据数据推导公式得出 while (fast != slow) { fast = fast.next; slow = slow.next; } //返回fast 或 slow 都对 return fast; } //两个都没有循环链表的相交节点 public ListNode bothNoCycleNodes(ListNode headA, ListNode headB) { if (headA == null || headB == null) { return null; } ListNode cur = headA; int n = 0; while (cur != null) { n++; cur = cur.next; } cur = headB; while (cur != null) { n--; cur = cur.next; } ListNode lNode = n > 0 ? headA : headB; //长链表 ListNode sNode = lNode == headA ? headB : headA; //短链表 n = Math.abs(n); while (n > 0) { lNode = lNode.next; n--; } //此刻，长链表剩下的节点和短链表剩下的节点个数相同 while (lNode != sNode) { lNode = lNode.next; sNode = sNode.next; if(lNode == null || sNode == null) { return null; } } return lNode; } public ListNode bothCycleNodes(ListNode headA, ListNode loopA, ListNode headB, ListNode loopB) { //2种情况： 环外相交，正好第一个相交节点相交。 这种情况可以视为2个无环链表相交 if (loopA == loopB) { int n = 0; ListNode cur = headA; while (cur != loopA) { n++; cur = cur.next; } cur = headB; while (cur != loopB) { n--; cur = cur.next; } ListNode lNode = n > 0 ? headA : headB; //长链表 ListNode sNode = lNode == headA ? headB : headA; //短链表 n = Math.abs(n); while (n > 0) { lNode = lNode.next; n--; } //此刻，长链表剩下的节点和短链表剩下的节点个数相同 while (lNode != sNode) { lNode = lNode.next; sNode = sNode.next; } return lNode; } else { //环内相交 ListNode cur1 = loopA.next; while (cur1 != loopA) { //如果跑一圈都没找到相交节点，则无相交节点 if (cur1 == loopB) { //中途找到了相交节点 return loopB; //返回loopA 或 loopB 都行。 环内相交，说不清谁是第一个 } cur1 = cur1.next; } return null; } } public ListNode getIntersectionNode (ListNode node1, ListNode node2) { if (node1 == null || node2 == null) { return null; } ListNode loopNode1 = getLoopNode(node1); ListNode loopNode2 = getLoopNode(node2); ListNode ansNode = null; if (loopNode1 == null && loopNode2 == null) { //两个都没有环的节点 ansNode = bothNoCycleNodes(node1, node2); } else if (loopNode1 != null && loopNode2 != null) { //两个环形链表相交 ansNode = bothCycleNodes(node1,loopNode1, node2,loopNode2); } return ansNode; } public static void main(String[] args) { System.out.println("================测试2个无环聊表相交==========================="); //链表1 ListNode node1 = new ListNode(4); ListNode node2 = new ListNode(1); //链表2 ListNode node3 = new ListNode(5); ListNode node4 = new ListNode(6); ListNode node5 = new ListNode(2); //相交节点 ListNode node6 = new ListNode(8); ListNode node7 = new ListNode(7); ListNode node8 = new ListNode(3); node1.next = node2; node2.next = node6; node6.next = node7; node7.next = node8; node3.next = node4; node4.next = node5; DoubleLoopNodes_06_2 test = new DoubleLoopNodes_06_2(); //不相交 ListNode m1 = test.getIntersectionNode(node1, node3); System.out.println("无环 不相交 ：" + (m1 != null ? m1.value : null)); //相交 node5.next = node6; ListNode m2 = test.getIntersectionNode(node1, node3); System.out.println("无环 相交节点的值为 ：" + (m2 != null ? m2.value : null)); System.out.println("================测试2个环形链表 环外 相交==========================="); //链表1 ListNode n1 = new ListNode(4); ListNode n2 = new ListNode(1); //链表2 ListNode n3 = new ListNode(5); ListNode n4 = new ListNode(6); ListNode n5 = new ListNode(2); //相交节点 ListNode n6 = new ListNode(8); ListNode n7 = new ListNode(7); ListNode n8 = new ListNode(3); n1.next = n2; n2.next = n3; n3.next = n4; n4.next = n2; n5.next = n6; n6.next = n7; n7.next = n8; n8.next = n6; ListNode m3 = test.getIntersectionNode(n1, n5); System.out.println("有环 不相交 ：" + (m3 != null ? m3.value : null)); //不相交 n1.next = n2; n2.next = n3; n3.next = n4; n4.next = n5; n5.next = n3; n6.next = n7; n7.next = n8; n8.next = n3; ListNode m4 = test.getIntersectionNode(n1, n6); System.out.println("有环 第一个相交点相交 ：" + (m4 != null ? m4.value : null)); //n3对应的值是5 n1.next = n2; n2.next = n3; n3.next = n4; n4.next = n5; n5.next = n3; n6.next = n7; n7.next = n8; n8.next = n2; ListNode m5 = test.getIntersectionNode(n1, n6); System.out.println("有环 环外相交 ：" + (m5 != null ? m5.value : null)); //n2对应的值是1 System.out.println("================测试2个环形链表 环内 相交==========================="); n6.next = n7; n7.next = n8; n8.next = n4; ListNode m6 = test.getIntersectionNode(n1, n6); System.out.println("有环 环外相交 ：" + (m6 != null ? m6.value : null)); //n2对应的值是1 n4对应6 } }
