填充每个节点的下一个节点的右侧节点指针-2021/01/21

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

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 指针连接，’#’ 标志着每一层的结束。

提示：
树中节点的数量少于 4096
-1000 <= node.val <= 1000

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

解题思路：
如果单独来看的话，我们可以直接使用bfs算法进行递归，但是我们结合本题来看，他是将每层的节点都有链接起来，所以层的递归可以使用第一个节点，从第一个节点开始就可以遍历这一层的所有节点。
两种解题方案：
一、借用队列，保存下一层的节点，然后遍历。
二、借用指针，从每层的第一个节点的开始遍历。

代码：
方法一、

/*
// 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) {
        List<Node> list = new ArrayList<Node>();
        if(root!=null){         //做一个判断，当root为空是，返回值也为空
            root.next = null;
            list.add(root);     //构造第一层列表，进入广度优先遍历
            bfs(list);
        }
        return root;
    }

    public void bfs(List<Node> list){
        if(list.get(0).left==null)   //判断是否为叶子节点，如果是则返回，不是则执行递归
            return ;
        List<Node> newList = new ArrayList<Node>();
        Node node = new Node();
        for(int i=0;i<list.size();i++){      //遍历这一层的列表然后将前一个的next指向后一个节点
            node = list.get(i);
            newList.add(node.left);
            newList.add(node.right);
            node.left.next = node.right;
            if(i+1==list.size()){           //判断是否为该层的最后一个节点，如果是则指向空
                node.right.next = null;
            }else{
                node.right.next = list.get(i+1).left;
            }
        }
        bfs(newList);
    }
}

方法二、

/*
// 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){         //做一个判断，当root为空是，返回值也为空
            root.next = null;
            bfs(root);
        }
        return root;
    }

    public void bfs(Node node){
        if(node.left==null)   //判断是否为叶子节点，如果是则返回，不是则执行递归
            return ;
        Node nextNode = node.left;      //保存下一层的初始节点
        while(node.next!=null){
            node.left.next = node.right;
            node.right.next = node.next.left;
            node = node.next;
        }
        node.left.next = node.right;
        node.right.next = null;
        bfs(nextNode);          //进行下一层的遍历
    }
}

结果对比：

方法一

方法二

可以看出，两种方法都比较占内存，而方法二，执行速度快很多。