单链表复制早已难不到你，但若咱们再加个指针...

面试 18：复杂链表的复制（剑指 Offer 第 26 题）

在上一篇推文中，咱们留下的习题是来自《剑指 Offer》 的面试题 26：复杂链表的复制。

请实现复杂链表的复制，在复杂链表中，每一个结点除了 next 指针指向下一个结点外，还有一个 sibling 指向链表中的任意结点或者 NULL。好比下图就是一个含有 5 个结点的复杂链表。

 

image.png

提早想好测试用例

依旧是咱们熟悉的第一步，先想好咱们的测试用例：

1. 输入一个 null ，指望什么也不输出；
2. 输入一个结点，sibling 指向自身，指望打印符合题干的值；
3. 输入多个结点，部分 sibling 指向 null，指望打印符合题干的值。

思考程序逻辑

测试用例思考完毕，天然是开始思考咱们的测试逻辑了，在思考的过程当中，咱们不妨尝试和面试官进行沟通，这样能够避免咱们走很多弯路，并且也容易给面试官留下一个善于思考和沟通的好印象。

极易想到的逻辑是，咱们先复制咱们传统的单链表，而后再遍历单链表，复制 sibling 的指向。

假设链表中有个结点 A，A 的 sibling 指向结点 B，这个 B 可能在 A 前面也可能在 A 后面，因此咱们惟一的办法只有从头结点开始遍历。对于一个含有 n 个结点的链表，因为定位每一个结点的 sibling 都须要从链表头结点开始通过 O(n) 步才能找到，所以这种方法的时间复杂度是 O(n²)。

当咱们告知面试官咱们这样的思路的时候，面试官告诉咱们，他期待的并非这样的算法，这样的算法时间复杂度也过高了，但愿能有更加简单的方式。

获得了面试官的诉求，咱们再来看看咱们前面的想法时间都花在哪儿去了。

很明显，咱们上面的想法在定位 sibling 指向上面花了大量的时间，咱们能够尝试在这上面进行优化。咱们仍是分为两步：第一步仍然是先复制原始链表上的每一个结点 N 建立 N1，而后把这些建立出来的结点用 next 链接起来。同时咱们把 <N,N1> 的配对信息放在一个哈希表中。第二步是设置复制链表的 sibling 指向，若是原始链表中有 N 指向 S，那么咱们的复制链表中必然存在 N1 指向 S1 。因为有了哈希表，咱们能够用 O(1) 的时间，根据 S 找到 S1。

这样的方法下降了时间成本，咱们高兴地与面试官分享咱们的想法，却被面试官指出，这样的想法虽然把时间复杂度下降到了 O(n)，但却因为哈希表的存在，须要 O(n) 的空间，而他所指望的方法是不占用任何辅助空间的。

接下来咱们再换一下思路，不用辅助空间，咱们却要用更少的实际解决 sibling 的指向问题。

咱们前面彷佛对于指向都采用过两个指针的方法，这里彷佛能够用相似的处理方式处理。

咱们不妨利用原有链表对每一个结点 N 在后面直接在后面建立 N1，这样至关于咱们扩长原始链表长度为现有链表的 2 倍，奇数位置的结点链接起来是原始链表，偶数位置的结点链接起来就是咱们的复制链表。

开始编写代码

咱们先完成第一部分的代码。根据原始链表的每一个结点 N ，建立 N1，并把 N 的 next 指向 N1，N1 的 next 指向 N 的 next。

private static void cloneNodes(Node head) { Node node = null; while (head != null) { // 先新建结点 node = new Node(head.data); // 再把head 的 next 指向 node 的 next node.next = head.next; // 而后把 node 做为 head 的 next head.next = node; // 最后遍历条件 head = node.next; } } 

上面完成了复制结点，下面咱们须要编写 sibling 的指向复制。

咱们的思想是：当 N 执行 S，那么 N1 就应该指向 S1，即 N.next.sibling = N.sibling.next；

private static void connectNodes(Node head) { while (head != null) { if (head.sibling != null) { //若是 当前结点的 sibling 不为 null,那就把它后面的复制结点指向当前sibling指向的下一个结点 head.next.sibling = head.sibling.next; } // 遍历 head = head.next.next; } } 

最后咱们只须要拿出本来的链表（奇数）和复制的链表（偶数）便可。

private static Node reconnectList(Node head) { if (head == null) return null; // 用于存放复制链表的头结点 Node cloneHead = head.next; // 用于记录当前处理的结点 Node temp = cloneHead; // head 的 next 仍是要指向本来的 head.next // 实际上如今因为复制后，应该是 head.next.next，即cloneHead.next head.next = cloneHead.next; // 指向新的被复制结点 head = head.next; while (head != null) { // temp 表明的是复制结点 // 先进行赋值 temp.next = head.next; // 赋值结束应该给 next 指向的结点赋值 temp = temp.next; // head 的下一个结点应该指向被赋值的下一个结点 head.next = temp.next; head = temp.next; } return cloneHead; } 

合并后的最终代码就是：

public class Test18 { private static class Node { int data; Node next; Node sibling; Node(int data) { this.data = data; } } private static Node complexListNode(Node head) { if (head == null) return null; // 第一步，复制结点，并用 next 链接 cloneNodes(head); // 第二步，把 sibling 也复制起来 connectNodes(head); // 第三步，返回偶数结点，链接起来就是复制的链表 return reconnectList(head); } private static void cloneNodes(Node head) { Node node = null; while (head != null) { // 先新建结点 node = new Node(head.data); // 再把head 的 next 指向 node 的 next node.next = head.next; // 而后把 node 做为 head 的 next head.next = node; // 最后遍历条件 head = node.next; } } private static void connectNodes(Node head) { while (head != null) { if (head.sibling != null) { // 若是 当前结点的 sibling 不为 null,那就把它后面的复制结点指向当前sibling指向的下一个结点 head.next.sibling = head.sibling.next; } // 遍历 head = head.next.next; } } private static Node reconnectList(Node head) { if (head == null) return null; // 用于存放复制链表的头结点 Node cloneHead = head.next; // 用于记录当前处理的结点 Node cloneNode = cloneHead; // head 的 next 仍是要指向本来的 head.next // 实际上如今因为复制后，应该是 head.next.next，即cloneHead.next head.next = cloneHead.next; // 由于咱们第一个结点已经拆分了，因此须要指向新的被复制结点才能够开始循环 head = head.next; while (head != null) { // cloneNode 表明的是复制结点 // 先进行赋值 cloneNode.next = head.next; // 赋值结束应该给 next 指向的结点赋值 cloneNode = cloneNode.next; // head 的下一个结点应该指向被赋值的下一个结点 head.next = cloneNode.next; head = cloneNode.next; } return cloneHead; } public static void main(String[] args) { Node head1 = new Node(1); Node node2 = new Node(2); Node node3 = new Node(3); Node node4 = new Node(4); Node node5 = new Node(5); head1.next = node2; node2.next = node3; node3.next = node4; node4.next = node5; node5.next = null; head1.sibling = node4; node2.sibling = null; node3.sibling = node5; node4.sibling = node2; node5.sibling = head1; print(head1); Node root = complexListNode(head1); System.out.println(); print(head1); print(root); System.out.println(); System.out.println(isSameLink(head1, root)); } private static boolean isSameLink(Node head, Node root) { while (head != null && root != null) { if (head == root) { head = head.next; root = root.next; } else { return false; } } return head == null && root == null; } private static void print(Node head) { Node temp = head; while (head != null) { System.out.print(head.data + "->"); head = head.next; } System.out.println("null"); while (temp != null) { System.out.println(temp.data + "=>" + (temp.sibling == null ? "null" : temp.sibling.data)); temp = temp.next; } } } 

验证测试用例

写毕代码，咱们验证咱们的测试用例。

1. 输入一个 null ，也不会输出，测试经过；
2. 输入一个结点，sibling 指向自身，测试经过；
3. 输入多个结点，部分 sibling 指向 null，测试经过。

课后习题

下一次推文的习题来自于《剑指 Offer》第 29 题：数组中超过一半的数字

面试题：数组中有一个数字出现的次数超过数组长度的一半，请找出这个数字并输出。好比 {1,2,3,2,2,2,1} 中 2 的次数是 4，数组长度为 7，因此输出 2。要求不能修改输入的数组。