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

目录

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

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

方法一：将所有元素按照层序遍历连接到一起，最后遍历root.right将最右边的节点的next全部置为空

代码展示：

方法二：递归，先将根节点的左子树指向右子树，然后判断根节点右边是否还有节点，如果有，将右子树指向根节点右边的左子树，再将根节点向后移动，进入递归，最后返回根节点即可

代码展示：

方法三：将二叉树的每一层都看作一个链表，在遍历当前层的时候，就将下一层连接起来，一层一层的连接下去，直到满足题意即可

代码展示：

---

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

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

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

示例 1：

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

示例 2:

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

提示：

树中节点的数量在 [0, 212 - 1] 范围内
-1000 <= node.val <= 1000

方法一：将所有元素按照层序遍历连接到一起，最后遍历root.right将最右边的节点的next全部置为空

代码展示：

/*
// Definition for a Node.
class Node {
    public int val;
    public Node left;
    public Node right;
    public Node next;

    public Node() {}
    
    public Node(int _val) {
        val = _val;
    }

    public Node(int _val, Node _left, Node _right, Node _next) {
        val = _val;
        left = _left;
        right = _right;
        next = _next;
    }
};
*/

class Solution {
    public Node connect(Node root) {
        if(root == null){
            return root;
        }
        List<Node> list = new ArrayList<>();
        Deque<Node> queue = new LinkedList<>();
        queue.offer(root);
        while(!queue.isEmpty()){
            Node x = queue.poll();
            list.add(x);
            if(x.left != null){
                queue.offer(x.left);
            }
            if(x.right != null){
                queue.offer(x.right);
            }
        }
        //遍历list
        Node fir = list.get(0);
        for(int i = 1; i < list.size(); i++){
            Node sec = list.get(i);
            fir.next = sec;
            fir = sec;
        }
        Node prev = root;
        while(prev != null){
            Node next = prev.right;
            prev.next = null;
            prev = next;
        }
        return root;
        
    }
 
}

方法二：递归，先将根节点的左子树指向右子树，然后判断根节点右边是否还有节点，如果有，将右子树指向根节点右边的左子树，再将根节点向后移动，进入递归，最后返回根节点即可

代码展示：

/*
// Definition for a Node.
class Node {
    public int val;
    public Node left;
    public Node right;
    public Node next;

    public Node() {}
    
    public Node(int _val) {
        val = _val;
    }

    public Node(int _val, Node _left, Node _right, Node _next) {
        val = _val;
        left = _left;
        right = _right;
        next = _next;
    }
};
*/

class Solution {
    public Node connect(Node root) {
        //递归
        connectHelp(root, null);
        return root;
    }
    public void connectHelp(Node root, Node next){
        if(root == null){
            return;
        }
        root.next = next;
        connectHelp(root.left,root.right);
        connectHelp(root.right,root.next == null? null:root.next.left);
    }
}

方法三：将二叉树的每一层都看作一个链表，在遍历当前层的时候，就将下一层连接起来，一层一层的连接下去，直到满足题意即可

代码展示：

/*
// Definition for a Node.
class Node {
    public int val;
    public Node left;
    public Node right;
    public Node next;

    public Node() {}
    
    public Node(int _val) {
        val = _val;
    }

    public Node(int _val, Node _left, Node _right, Node _next) {
        val = _val;
        left = _left;
        right = _right;
        next = _next;
    }
};
*/

class Solution {
    public Node connect(Node root) {
        if(root == null){
            return root;
        }
        Node cur = root;
        //cur非空说明还有节点
        while(cur != null){
            //定义一个虚拟头节点
            Node dummy = new Node(0);
            Node prev = dummy;
            //完美二叉树，所以有左子树必有右子树
            while(cur != null && cur.left != null){
                //使下一层连接起来
                prev.next = cur.left;
                prev = prev.next;
                prev.next = cur.right;
                prev = prev.next;
                //cur继续往右边走
                cur = cur.next;
            }
            //当前层连接完毕，换到下一层去
            cur = dummy.next;
        }
        return root;
    }
}