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

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

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

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

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

链接：https://leetcode-cn.com/problems/populating-next-right-pointers-in-each-node

输入：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
时间上不好
使用两个队列交替

public Node connect(Node root) {
        if(root==null) return null;
        Deque<Node> deque= new ArrayDeque<>();
        Deque<Node> temp= new ArrayDeque<>();
        deque.addLast(root);
        Node cur;
        while (!deque.isEmpty())
        {
            cur=deque.pollFirst();
            if(cur.left!=null) {
                temp.addLast(cur.left);
            }
            if(cur.right!=null) {
                temp.addLast(cur.right);
            }

            if(!deque.isEmpty())
            {
                cur.next=deque.peekFirst();
                System.out.println(cur.val+"->"+deque.peekFirst());
            }
            if(deque.isEmpty())
            {
                Deque<Node> t=deque;
                deque=temp;
                temp=t;
            }

        }

        return root;
    }

上面的稍微改进

public Node connect(Node root) {
        if(root==null)
            return null;
        ArrayDeque<Node> deque=new ArrayDeque<>();
        Node cur = null;
        int size;
        deque.addLast(root);
        while(!deque.isEmpty())
        {
            size=deque.size();
            for(int i=0;i<size-1;i++)//注意这里是i<size-1
            {
                cur=deque.pollFirst();
                if(cur.left!=null) {
                    deque.addLast(cur.left);
                    deque.addLast(cur.right);
                }
                cur.next=deque.peekFirst();
            }
            cur=deque.pollFirst();//为什么这里会有一个节点出队，因为上面的循环中每次出队节点都要与队列中队头进行连接，只有最后一个不需要
            if(cur.left!=null) {
                deque.addLast(cur.left);
                deque.addLast(cur.right);
            }
        }
        return root;
    }

这个思路是基于递归的思想，首先创建一个存储每一层最右边节点的存储空间，当每次遍历的时候只需要将每一层最右边的节点指向当前节点即可

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;
    }
}
public class seqecStack {

    Node[] note=new Node[13];
    public Node connect(Node root) {
        dfs(root,0);
        return root;
    }
    public void dfs(Node root,int dep)
    {
        if(null==root)
            return;
        if(note[dep]!=null)
        {
            note[dep].next=root;
        }
        note[dep]=root;
        dfs(root.left,dep+1);
        dfs(root.right,dep+1);
    }
    public static void main(String[] args) {

    }
}