finish "117. Populating Next Right Pointers in Each Node II". Fix #117

Author: diguage

README.adoc

@@ -706,11 +706,11 @@
 |{doc_base_url}/0116-populating-next-right-pointers-in-each-node.adoc[Note]
 |Medium
 
-//|117
-//|{leetcode_base_url}/populating-next-right-pointers-in-each-node-ii/[Populating Next Right Pointers in Each Node II]
-//|{source_base_url}/_0117_PopulatingNextRightPointersInEachNodeII.java[Java]
-//|{doc_base_url}/0117-populating-next-right-pointers-in-each-node-ii.adoc[Note]
-//|Medium
+|117
+|{leetcode_base_url}/populating-next-right-pointers-in-each-node-ii/[Populating Next Right Pointers in Each Node II]
+|{source_base_url}/_0117_PopulatingNextRightPointersInEachNodeII.java[Java]
+|{doc_base_url}/0117-populating-next-right-pointers-in-each-node-ii.adoc[Note]
+|Medium
 
 |118
 |{leetcode_base_url}/pascals-triangle/[Pascal's Triangle]

docs/0116-populating-next-right-pointers-in-each-node.adoc

@@ -2,22 +2,9 @@
 
 https://leetcode.com/problems/populating-next-right-pointers-in-each-node/[LeetCode - Populating Next Right Pointers in Each Node]
 
-image::images/0116-0.png[]
-
-image::images/0116-1.jpg[]
-
-image::images/0116-2.jpg[]
-
-这道题的关键是在上层遍历中，把下层的链接关系建立起来。
-
-因为是完全二叉树。所以，如果左下节点为空则到达最后一层；向右节点为空，则到达行尾需要换行。
-
-=== 参考资料
-
-. https://leetcode-cn.com/problems/populating-next-right-pointers-in-each-node/solution/xiang-xi-tong-su-de-si-lu-fen-xi-duo-jie-fa-by--27/[详细通俗的思路分析，多解法 - 填充每个节点的下一个右侧节点指针 - 力扣（LeetCode）]
-
 You are given a *perfect binary tree* where all leaves are on the same level, and every parent has two children. The binary tree has the following definition:
 
+[source,c]
 [subs="verbatim,quotes"]
 ----
 struct Node {
@@ -32,32 +19,42 @@ Populate each next pointer to point to its next right node. If there is no next
 
 Initially, all next pointers are set to `NULL`.
 
- 
-
 *Follow up:*
 
-
 * You may only use constant extra space.
 * Recursive approach is fine, you may assume implicit stack space does not count as extra space for this problem.
 
 
- 
+
 *Example 1:*
 
-<img alt="" src="https://assets.leetcode.com/uploads/2019/02/14/116_sample.png" style="width: 640px; height: 218px;" />
+image::images/0116-0.png[]
 
 [subs="verbatim,quotes"]
 ----
 *Input:* root = [1,2,3,4,5,6,7]
 *Output:* [1,#,2,3,#,4,5,6,7,#]
-*Explanation: *Given the above perfect binary tree (Figure A), your function should populate each next pointer to point to its next right node, just like in Figure B. The serialized output is in level order as connected by the next pointers, with '#' signifying the end of each level.
+*Explanation:* Given the above perfect binary tree (Figure A), your function should populate each next pointer to point to its next right node, just like in Figure B. The serialized output is in level order as connected by the next pointers, with '#' signifying the end of each level.
 ----
 
- 
 *Constraints:*
 
-
 * The number of nodes in the given tree is less than `4096`.
 * `-1000 <= node.val <= 1000`
 
+=== 解题分析
+
+这道题和 xref:0117-populating-next-right-pointers-in-each-node-ii.adoc[117. Populating Next Right Pointers in Each Node II] 算是姊妹题。
+
+image::images/0116-1.jpg[]
+
+image::images/0116-2.jpg[]
+
+这道题的关键是在上层遍历中，把下层的链接关系建立起来。
+
+因为是完全二叉树。所以，如果左下节点为空则到达最后一层；向右节点为空，则到达行尾需要换行。
+
+=== 参考资料
+
+. https://leetcode-cn.com/problems/populating-next-right-pointers-in-each-node/solution/xiang-xi-tong-su-de-si-lu-fen-xi-duo-jie-fa-by--27/[详细通俗的思路分析，多解法 - 填充每个节点的下一个右侧节点指针 - 力扣（LeetCode）]
 

docs/0117-populating-next-right-pointers-in-each-node-ii.adoc

@@ -4,6 +4,7 @@ https://leetcode.com/problems/populating-next-right-pointers-in-each-node-ii/[Le
 
 Given a binary tree
 
+[source,c]
 [subs="verbatim,quotes"]
 ----
 struct Node {
@@ -18,32 +19,44 @@ Populate each next pointer to point to its next right node. If there is no next
 
 Initially, all next pointers are set to `NULL`.
 
- 
-
 *Follow up:*
 
-
 * You may only use constant extra space.
 * Recursive approach is fine, you may assume implicit stack space does not count as extra space for this problem.
 
-
- 
 *Example 1:*
 
-<img alt="" src="https://assets.leetcode.com/uploads/2019/02/15/117_sample.png" style="width: 640px; height: 218px;" />
+image::images/0117-1.png[]
 
 [subs="verbatim,quotes"]
 ----
 *Input:* root = [1,2,3,4,5,null,7]
 *Output:* [1,#,2,3,#,4,5,7,#]
-*Explanation: *Given the above binary tree (Figure A), your function should populate each next pointer to point to its next right node, just like in Figure B. The serialized output is in level order as connected by the next pointers, with '#' signifying the end of each level.
+*Explanation:* Given the above binary tree (Figure A), your function should populate each next pointer to point to its next right node, just like in Figure B. The serialized output is in level order as connected by the next pointers, with '#' signifying the end of each level.
 ----
 
- 
 *Constraints:*
 
-
 * The number of nodes in the given tree is less than `6000`.
 * `-100 <= node.val <= 100`
 
 
+=== 解题分析
+
+这道题和 xref:0116-populating-next-right-pointers-in-each-node.adoc[116. Populating Next Right Pointers in Each Node] 算是姊妹题。
+
+最简单的方式，使用 `Deque` 来保存每一层节点，然后建立起来"连接"。但是，很明显，这种方案不符合空间复杂度要求。
+
+基于上面这种解法，再深入思考一步，上面使用 `Deque` 就是想要保存接下来需要访问的元素，并且保存访问的前后顺序。现在 `Node` 上有 `next` 字段，可以利用这个字段，打通这条链表，遍历上一层时，打通下一次的链接结构。这里需要保存的就有两点：
+
+. 这条链表的头结点，用于下一层的遍历；
+. 这条链表的尾节点，用于添加下一个节点。
+
+image::images/0117-2.jpg[]
+
+这样，把第一种解法的代码稍作修改就可以了。
+
+=== 参考资料
+
+. https://leetcode-cn.com/problems/populating-next-right-pointers-in-each-node-ii/solution/xiang-xi-tong-su-de-si-lu-fen-xi-duo-jie-fa-by-28/[详细通俗的思路分析，多解法 - 填充每个节点的下一个右侧节点指针 II - 力扣（LeetCode）]
+. https://leetcode.wang/leetcode-117-Populating-Next-Right-Pointers-in-Each-NodeII.html[117. Populating Next Right Pointers in Each Node II · leetcode]

docs/images/0117-1.png

@@ -0,0 +1,113 @@
+package com.diguage.algorithm.leetcode;
+
+import com.diguage.algorithm.util.TreeNode;
+
+import java.util.Deque;
+import java.util.LinkedList;
+import java.util.Objects;
+
+import static com.diguage.algorithm.util.TreeNodeUtils.buildTree;
+import static java.util.Arrays.asList;
+
+/**
+ * @author D瓜哥, https://www.diguage.com/
+ * @since 2020-02-09 23:17
+ */
+public class _0117_PopulatingNextRightPointersInEachNodeII {
+
+    static class Node {
+        public int val;
+        public Node left;
+        public Node right;
+        public Node next;
+
+        public Node(int x) {
+            this.val = x;
+        }
+
+        @Override
+        public String toString() {
+            return "Node{" +
+                    "val=" + val +
+                    ", left=" + left +
+                    ", right=" + right +
+                    '}';
+        }
+    }
+
+
+    /**
+     * Runtime: 1 ms, faster than 49.14% of Java online submissions for Populating Next Right Pointers in Each Node II.
+     * Memory Usage: 41.4 MB, less than 100.00% of Java online submissions for Populating Next Right Pointers in Each Node II.
+     *
+     * Copy from: https://leetcode-cn.com/problems/populating-next-right-pointers-in-each-node-ii/solution/xiang-xi-tong-su-de-si-lu-fen-xi-duo-jie-fa-by-28/[详细通俗的思路分析，多解法 - 填充每个节点的下一个右侧节点指针 II - 力扣（LeetCode）]
+     */
+    public Node connect(Node root) {
+        Node curr = root;
+        while (Objects.nonNull(curr)) {
+            Node dummy = new Node(0);
+            Node tail = dummy;
+            while (Objects.nonNull(curr)) {
+                if (Objects.nonNull(curr.left)) {
+                    tail.next = curr.left;
+                    tail = tail.next;
+                }
+                if (Objects.nonNull(curr.right)) {
+                    tail.next = curr.right;
+                    tail = tail.next;
+                }
+                curr = curr.next;
+            }
+            curr = dummy.next;
+        }
+        return root;
+    }
+
+    /**
+     * Runtime: 1 ms, faster than 49.14% of Java online submissions for Populating Next Right Pointers in Each Node II.
+     * Memory Usage: 40.8 MB, less than 100.00% of Java online submissions for Populating Next Right Pointers in Each Node II.
+     */
+    public Node connectDeque(Node root) {
+        if (Objects.isNull(root)) {
+            return null;
+        }
+        Deque<Node> deque = new LinkedList<>();
+        deque.addLast(root);
+        Node prev = null;
+        while (!deque.isEmpty()) {
+            int size = deque.size();
+            for (int i = 0; i < size; i++) {
+                Node curr = deque.removeFirst();
+                if (Objects.nonNull(curr.left)) {
+                    deque.addLast(curr.left);
+                }
+                if (Objects.nonNull(curr.right)) {
+                    deque.addLast(curr.right);
+                }
+                if (i > 0) {
+                    prev.next = curr;
+                }
+                prev = curr;
+            }
+        }
+        return root;
+    }
+
+    public static void main(String[] args) {
+        _0117_PopulatingNextRightPointersInEachNodeII solution = new _0117_PopulatingNextRightPointersInEachNodeII();
+        TreeNode treeNode = buildTree(asList(1, 2, 3, 4, 5, null, 7));
+        Node node = convert(treeNode);
+        Node r1 = solution.connect(node);
+        System.out.println(r1);
+    }
+
+    private static Node convert(TreeNode treeNode) {
+        if (Objects.isNull(treeNode)) {
+            return null;
+        }
+        Node node = new Node(treeNode.val);
+        node.left = convert(treeNode.left);
+        node.right = convert(treeNode.right);
+        return node;
+    }
+}