【二叉树 左右视图】可用BFS

leetcode199
给定一棵二叉树，想象自己站在它的右侧，按照从顶部到底部的顺序，返回从右侧所能看到的节点值。
右视图
遇到一层就添加一个Int，若深度没变则更新res(index)

class Solution {
    List<Integer> res = new ArrayList<>();
    public List<Integer> rightSideView(TreeNode root) {
       if(root == null)
       return null;
       dfs(root,0);
       return res;
    }
    public void dfs(TreeNode root,int depth){
        if(root == null)
        return;
       if(depth >= res.size())
       res.add(new Integer(1));    // res.add(root.val);
       res.set(depth,root.val);    // depth++; 
       depth++;                    // dfs(root.right,depth);
       dfs(root.left,depth);       // dfs(root.left,depth);
       dfs(root.right,depth);
    }
}

左视图
遇到新一层，就添加改节点值

class Solution {
    List<Integer> res = new ArrayList<>();
    public List<Integer> rightSideView(TreeNode root) {
       if(root == null)
       return null;
       dfs(root,0);
       return res;
    }
    public void dfs(TreeNode root,int depth){
        if(root == null)
        return;
       if(depth >= res.size())
       res.add(root.val);
       depth++;
       dfs(root.left,depth);
       dfs(root.right,depth);
    }
}

填充每一结点的右侧结点指针

通用解法

public Node connect(Node root) {
		if(root == null)
        return null;
        Queue<Node> queue = new LinkedList<>();
        queue.add(root);
        while(!queue.isEmpty()){
            //前一个结点
            Node pre= null;
            //每层数量
            int size = queue.size();
            for(int i = 0;i < size;i++){
                //获取当前结点
                Node node = queue.poll();
                //若前一结点不为空，则连接
                if(pre != null)
                pre.next = node;
                //前一结点移动到当前结点
                pre = node;
                if(node.left != null)
                queue.add(node.left);
                if(node.right != null)
                queue.add(node.right);
            }
        }
        return root;
	}

完美二叉树

class Solution {
	public Node connect(Node root) {
		dfs(root);
		return root;
	}
	void dfs(Node root) {
		if(root==null) {
			return;
		}
		Node left = root.left;
		Node right = root.right;
		//配合动画演示理解这段，以root为起点，将整个纵深这段串联起来
		while(left!=null) {
			left.next = right;
			left = left.right;
			right = right.left;
		}
		//递归的调用左右节点，完成同样的纵深串联
		dfs(root.left);
		dfs(root.right);
	}
}

class Solution {
    public Node connect(Node root) {
        if(root == null)
        return null;
        connectTwo(root.left,root.right);
        return root;
    }
    public void connectTwo (Node node1,Node node2){
        if(node1 == null || node2 == null)
        return;
        node1.next = node2;

        connectTwo(node1.left,node1.right);
        connectTwo(node2.left,node2.right);
        connectTwo(node1.right,node2.left);
    }
}

普通二叉树

class Solution {
    List<Node> res = new ArrayList<>();
	public Node connect(Node root) {
		if(root == null)
        return null;
        dfs(root,0);
        return res.get(0);
	}
    public void dfs(Node root,int depth){
        if(root == null)
        return;
        //遇到新一层则添加新的node
        if(depth >= res.size())
        res.add(new Node(0));
        //获得该层已有的节点，指针连接当前节点
        res.get(depth).next = root;
        //将该层的节点换为当前节点
        res.set(depth,root);
        depth++;
        dfs(root.left,depth);
        dfs(root.right,depth);
    }
	
}