【LeetCode】117 填充每个节点的下一个右侧节点指针II

1 问题

给定一个二叉树：

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 <= Node.val <= 100

进阶

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

2 解题思路

本题与【LeetCode】116. 填充每个节点的下一个右侧节点指针 唯一区别就是，该二叉树不是一个perfect binary tree。

关于二叉树类型，可以参考K神文章中的定义常见二叉树类型 ，也可参考传统教材严蔚敏和吴伟民老师编写的《数据结构（C 语言版）》。

所以运用其中的深度优先（DFS）算法失了效果。但是采用BFS还是可以的。并且可以改进下遍历过程中的指针指向，不用单独再遍历每层指针，操作其nexe指向其下一个节点。

3 代码

3.1 老式BFS

class Solution {
    public Node connect(Node root) {
        //this tree is not a perfect binary tree, which is the biggest difference in LC116
        //BFS
        if (null == root) {
            return root;
        }
        Queue<Node> q = new LinkedList<>();
        Node tmp;
        List<Node> rowList = new ArrayList<>();
        //in Queue
        q.offer(root);
        //flag of each level
        q.offer(null);
        int i = 0;
        while (!q.isEmpty()) {
            //pop
            tmp = q.poll();
            if (null != tmp) {
                rowList.add(tmp);
                //left node in Queue
                if (null != tmp.left) {
                    q.offer(tmp.left);
                }
                //right node in Queue
                if (null != tmp.right) {
                    q.offer(tmp.right);
                }
            }
            //end of this row's traversal
            else if (!rowList.isEmpty()) {
                //Populating Next Right Pointers in Each Node of this row
                for (i = 0; i < rowList.size() - 1; i++) {
                    rowList.get(i).next = rowList.get(i + 1);
                }
                rowList.get(rowList.size() - 1).next = null;
                rowList = new ArrayList<>();
                q.offer(null);
            }
        }//end of while
        return root;
    }
}

3.2 新式BFS

class Solution {
    public Node connect(Node root) {
        if (null == root) {
            return root;
        }
        Queue<Node> q = new LinkedList<>();
        Node tmp;
        //in Queue
        q.offer(root);
        //flag of each level
        q.offer(null);
        while (!q.isEmpty()) {
            tmp = q.poll();
            if (null != tmp) {
                //the next node is the node in the queue's head
                tmp.next = q.peek();
                //left node in Queue
                if (null != tmp.left) {
                    q.offer(tmp.left);
                }
                //right node in Queue
                if (null != tmp.right) {
                    q.offer(tmp.right);
                }
            }
            //the end of this level
            else if (!q.isEmpty()) {
                q.offer(null);
            }
        }
        return root;
    }
}