Leetcode刷题116. 填充每个节点的下一个右侧节点指针

给定一个 完美二叉树 ，其所有叶子节点都在同一层，每个父节点都有两个子节点。二叉树定义如下：

struct Node {
  int val;
  Node *left;
  Node *right;
  Node *next;
}
填充它的每个 next 指针，让这个指针指向其下一个右侧节点。如果找不到下一个右侧节点，则将 next 指针设置为 NULL。

初始状态下，所有 next 指针都被设置为 NULL。

进阶：

你只能使用常量级额外空间。
使用递归解题也符合要求，本题中递归程序占用的栈空间不算做额外的空间复杂度。
 

示例：

输入：root = [1,2,3,4,5,6,7]
输出：[1,#,2,3,#,4,5,6,7,#]
解释：给定二叉树如图 A 所示，你的函数应该填充它的每个 next 指针，以指向其下一个右侧节点，如图 B 所示。序列化的输出按层序遍历排列，同一层节点由 next 指针连接，'#' 标志着每一层的结束。

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/populating-next-right-pointers-in-each-node
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

感谢大神王尼玛和数据结构和算法的详细解法，传送门动画演示+三种实现 116. 填充每个节点的下一个右侧节点指针、BFS和递归共4种方式解决（最后3种击败了100%的用户）。

class Solution {
        public Node connect(Node root) {
//            return connectI(root);
//            return connectII(root);
//            return connectIII(root);
            return connectIIII(root);
        }

        //方法四：基于方法三优化
        //将每一行看成一个链表，遍历当前层的时候，将下一层的节点连接
        //时间复杂度O(N)，空间复杂度O(1)
        private Node connectIIII(Node root) {
            if (root == null) {
                return null;
            }
            Node cur = root;
            while (cur != null) {
                //定义dummy节点方便将下一层的节点连接
                Node dummy = new Node(0);
                //prev访问下一层的前一个节点
                Node prev = dummy;
                //遍历当前层的链表，因为是完美二叉树，如果有左子节点一定有右子节点
                while (cur != null && cur.left != null) {
                    //让prev节点指向当前节点的左子节点
                    prev.next = cur.left;
                    //更新prev节点
                    prev = prev.next;
                    //prev节点指向当前节点的右子节点
                    prev.next = cur.right;
                    prev = prev.next;
                    //继续访问这一层的下一节点
                    cur = cur.next;
                }
                //将下一层连接成链表后，赋值给cur继续循环
                cur = dummy.next;
            }
            return root;
        }


        //方法三：BFS遍历
        //定义prev节点指向每一行中上一次遍历的节点
        //遍历每一行的时候，将每一行的节点连接
        private Node connectIII(Node root) {
            if (root == null) {
                return null;
            }
            Queue<Node> queue = new LinkedList<>();
            queue.add(root);
            while (!queue.isEmpty()) {
                //每一层的节点数量
                int levelCount = queue.size();
                Node prev = null;
                for (int i = 0; i < levelCount; i++) {
                    Node node = queue.poll();
                    //prev为null说明是这一行的第一个节点
                    //否则，就让前一个节点指向当前节点
                    if (prev != null) {
                        prev.next = node;
                    }
                    //更新prev为当前节点
                    prev = node;
                    if (node.left != null) {
                        queue.add(node.left);
                    }
                    if (node.right != null) {
                        queue.add(node.right);
                    }
                }
            }
            return root;
        }

        //方法二：DFS递归
        //时间复杂度O(N)，空间复杂度O(N)
        private Node connectII(Node root) {
            dfs(root, null);
            return root;
        }

        private void dfs(Node cur, Node next) {
            if (cur == null) {
                return;
            }
            //连接两个节点
            cur.next = next;
            //每个cur左子树的next,就是cur的右子树
		    //每个cur右子树的next,就是cur.next的左子树
            dfs(cur.left, cur.right);
            dfs(cur.right, cur.next == null ? null : cur.next.left);
        }

        //方法一：递归
        //先分别将左右子树的左节点指向右节点，再将左子树的右节点指向右子树的左节点
        //时间复杂度O(N)，空间复杂度O(N)
        private Node connectI(Node root) {
            if (root == null) {
                return null;
            }
            connectNode(root.left, root.right);
            return root;
        }

        private void connectNode(Node node1, Node node2) {
            if (node1 == null || node2 == null) {
                return;
            }
            //将两个节点连接
            node1.next = node2;
            //连接相同父节点的两个子节点
            connectNode(node1.left, node1.right);
            connectNode(node2.left, node2.right);
            //连接跨越父节点的两个子节点
            connectNode(node1.right, node2.left);
        }
    }
}