LC 117.填充每个节点的下一个右侧节点指针II

117. 填充每个节点的下一个右侧节点指针 II

给定一个二叉树：

struct Node {
int val;
Node *left;
Node *right;
Node *next;
}

填充它的每个 next 指针，让这个指针指向其下一个右侧节点。如果找不到下一个右侧节点，则将 next 指针设置为 NULL 。

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

示例 1：

输入：root = [1,2,3,4,5,null,7]
输出： [1,#,2,3,#,4,5,7,#]
解释： 给定二叉树如图 A 所示，你的函数应该填充它的每个 next 指针，以指向其下一个右侧节点，如图 B 所示。序列化输出按层序遍历顺序（由 next 指针连接），‘#’ 表示每层的末尾。

示例 2：

输入： root = []
输出：[]

提示：

• 树中的节点数在范围 [0, 6000] 内
• $-100\le Node.val\le 100$

进阶：

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

解法一(BFS+队列)

思路分析：

1. 该题与LC116.填充每个节点的下一个右侧节点指针类似，只是该题中的二叉树不是满二叉树，但是依然可以使用层序遍历来解决
2. 在遍历每层时，对每层结点进行连接

实现代码如下：

class Solution {
    public Node connect(Node root) {
        if (root != null) {
            Queue<Node> queue = new ArrayDeque<>();
            queue.offer(root);
            while (!queue.isEmpty()) {
                int size = queue.size();
                for (int i = 0; i < size; ++ i) {
                    Node node = queue.poll();
                    if (i == size-1)    // 如果是本层最后一个结点则next指向null
                        node.next = null;
                    else node.next = queue.peek();    // 不是本层最后一个结点 则指向下一个右侧节点
                    if (node.left != null)
                        queue.offer(node.left);
                    if (node.right != null)
                        queue.offer(node.right);
                }
            }
        }
        return root;
    }
}

提交结果如下：

解答成功:
执行耗时:2 ms,击败了28.63% 的Java用户
内存消耗:43.1 MB,击败了5.00% 的Java用户

复杂度分析：

• 时间复杂度：$O(n)$
• 空间复杂度：$O(n)$

解法二(使用已建立的next指针)

思路分析：

1. 需要处理树上的所有结点，所以无法降低时间复杂度，但是可以尝试降低空间复杂度；
2. 可以发现的是：在某层的节点建立了next指针的联系后，该层节点形成了一个链表，因此，如果先建立某一层的next指针，再去遍历这一层，就不需要使用队列了
3. 所以如果第i层已经建立next指针，即可以通过next去访问该层所有节点，同时也可以根据第i层的left和right指针获取下一层的节点
4. 所以遍历过程中按照i+1层节点建立next指针
5. 即从根节点开始，因为第0层只有一个节点，不需要处理，可以在上一层为下一层建立next指针，即位于x层时为x+1层建立next指针，完成连接后，再移至x+1层继续建立
6. 每次只需要知道每层的最左边节点，既可以遍历该层，不需要使用队列来访问，可以节省空间。

实现代码如下：

class Solution {
    Node last = null;        // 记录某层已建立next连接的最后一个节点
    Node nextStart = null;    // 记录某层的最左节点 即遍历某层的开始节点
    public Node connect(Node root) {
        if (root != null) {
            Node start = root;
            while (start != null) {
                last = null;
                nextStart = null;
                for (Node p = start; p != null; p = p.next) {
                    if (p.left != null) {    // 若该节点左子节点不为空 则连接
                        handle(p.left);
                    }
                    if (p.right != null) {    // 若该节点右子节点不为空 则连接
                        handle(p.right);
                    }
                }
                start = nextStart;    // 更新遍历某层的起始节点
            }
        }
        return root;
    }
    private void handle(Node p) {
        if (last != null) {        // 若连接的节点不是第一个节点 则直接连接
            last.next = p;
        } else {        // 若连接的节点是第一个节点 则记录
            nextStart = p;
        }
        last = p;    // 更新某层已建立next连接的最后一个节点
    }
}

提交结果如下：

解答成功:
执行耗时:0 ms,击败了100.00% 的Java用户
内存消耗:43 MB,击败了5.00% 的Java用户

复杂度分析：

• 时间复杂度：$O(n)$
• 空间复杂度：$O(1)$，使用了常量级变量