树的深度优先搜索和广度优先搜索的实现

1. 深度优先

depth first search，DFS
可以使用先序遍历来实现
递归版

//先序遍历
    public void PreOrder(BinaryTreeNode node){
        if(node!=null){
            System.out.println(node.getData()); //先访问根节点
            PreOrder(node.getLeftChild());  //先根遍历左子树
            PreOrder(node.getRightChild());  //先根遍历右子树
        }
    }

递归求树高

public int maxDepth(TreeNode root) {
        if(root == null){
            return 0;
        }
        int leftHeight = maxDepth(root.left);
        int rightHeight = maxDepth(root.right);
        return 1+Math.max(leftHeight,rightHeight);
}

非递归版（使用栈实现）

 public ArrayList<Integer> DfsTree(TreeNode root) {
        ArrayList<Integer> lists = new ArrayList<I>();
        if(root == null)
            return lists;
        Stack<TreeNode> stack = new Stack<>();
        stack.push(root);
        while(!stack.isEmpty()){
            TreeNode tree = stack.pop();
　　　　　　//先往栈中压入右节点，再压左节点，出栈就是先左节点后出右节点了(先序遍历推广)。
            if(tree.right != null)
                stack.push(tree.right);
            if(tree.left != null)
                stack.push(tree.left);
            lists.add(tree.val);
        }
        return lists;
    }

非递归求树高

// class DeepthNode{
//     TreeNode node;
//     int deepth;
//     public DeepthNode(TreeNode node, int deepth){
//         this.deepth = deepth;
//         this.node = node;
//     }
// }
public int maxDepth(TreeNode root) {
        Stack<DeepthNode> stack = new Stack<>();
        if(root == null){
            return 0;
        }
        stack.push(new DeepthNode(root, 1));
        int deep = 0;
        int currentDeep = 0;
        while(!stack.isEmpty()){
            DeepthNode deepthNode = stack.pop();
            currentDeep = deepthNode.deepth;
            if(deepthNode.node.right!=null){
                stack.push(new DeepthNode(deepthNode.node.right, deepthNode.deepth+1));
            }
            if(deepthNode.node.left!=null){
                stack.push(new DeepthNode(deepthNode.node.left, deepthNode.deepth+1));
            }
            deep = Math.max(deep, currentDeep);

        }
        return deep;
    }
}

广度优先

BFS使用队列实现
广度优先搜索基本操作是和深度优先差不多的，只不过这里是通过队列来实现的，找到一个起点A，并将A相邻的点放入队列中，这时将队首元素B取出，并将B相邻且没有访问过的点放入队列中，不断重复这个操作，直至队列清空，这个时候依次访问的顶点就是遍历的顺序。

广度优先遍历树，需要用到队列（Queue）来存储节点对象，队列的特点就是先进先出。先往队列中插入左节点，再插入右节点，队列出队就是先出左节点，再出右节点。

首先将A节点插入队列中，队列中有元素（A）;

将A节点弹出，同时将A节点的左节点B、右节点C依次插入队列，B在队首，C在队尾，（B，C），此时得到A节点；

将队首元素B弹出，并将B的左节点D、右节点E插入队列，C在队首，E在队尾（C，D，E），此时得到B节点；

再将队首元素C弹出，并将C节点的左节点F，右节点G依次插入队列，（D，E，F，G），此时得到C节点；

将D弹出，此时D没有子节点，队列中元素为（E，F，G），得到D节点；

。。。以此类推。最终的遍历结果为：A，B，C，D，E，F，G，H，I。

    public ArrayList<Integer> BfsTree(TreeNode root) {
        ArrayList<Integer> lists = new ArrayList<>();
        if(root == null)
            return lists;
        Queue<TreeNode> queue = new LinkedList<>();
        queue.offer(root);
        while(!queue.isEmpty()){
            TreeNode tree = queue.poll();
            if(tree.left != null)
                queue.offer(tree.left);
            if(tree.right != null)
                queue.offer(tree.right);
            lists.add(tree.val);
        }
        return lists;
    }

如果在广度优先搜索的时候对层级的记录有要求
使用嵌套循环结构，该方法的每一步都需要记录当前队列中全部元素数量，对应树中一个层级元素的数量。然后从队列中处理对应数量的元素。完成后，这一层级所有的节点都被访问，队列包含下一层级的全部节点。下面是对应伪代码

while (!Q.empty())
{
    size = Q.size()
    for i in range 0..size//这个for循环就是这一层的所有元素
    {
        node = Q.pop()
        if(node.left!=null){
        	Q.push(node.left)
        }
        if(node.right!=null){
        	Q.push(node.right)
        }
    }
}

看一个广度优先的题

给定一个二叉树，返回其按层次遍历的节点值（即逐层地，从左到右访问所有节点）
例如:
给定二叉树: [3,9,20,null,null,15,7]

    3
   / \
  9  20
    /  \
   15   7

返回

[
  [3],
  [9,20],
  [15,7]
]

这个和上面的层次遍历不同的地方在于要把每一层都记录在一个list中，做法是利用队列遍历二叉树，内层循环次数是每层节点数，每遍历完一层，加入list

class Solution {
    public List<List<Integer>> levelOrder(TreeNode root) {
        List<List<Integer>> result = new ArrayList();
        LinkedList<TreeNode> queue = new LinkedList();
        if(root==null){
            return result;
        }
        queue.add(root);
        while(!queue.isEmpty()){
            List<Integer> inner = new ArrayList();
            int size = queue.size();
            for(int i = 0; i<size; i++){
                TreeNode node = queue.poll();
                inner.add(node.val);
                if(node.left!=null){
                    queue.add(node.left);
                }
                if(node.right!=null){
                    queue.add(node.right);
                }
            }
            result.add(inner);
        }
        return result;
    }
}