深度优先遍历(DFS)和广度优先遍历(BFS)的应用

深度优先遍历：DFS，原则就是沿着一条路径一直找到最深的那个节点，当没有子节点的时候，返回上一级节点，寻找其另外的子节点，继续向下遍历，没有就向上返回一级，直到所有的节点都被遍历到，每个节点只能访问一次。

广度优先遍历：BFS，原则就是对每一层的节点依次访问，一层访问结束后，进入下一层，直到最后一个节点，同样每个节点都只访问一次
对于下面的二叉树：

深度优先搜索的遍历顺序：1-2-3-4-5-6-7-8-9
广度优先搜索的遍历顺序：1-2-6-2-3-7-5-8-9

广度优先搜索应用：层序遍历、最短路径等
深度优先搜索应用：先序遍历，中序遍历，后序遍历
二叉树的前序遍历

public List<Integer> preorderTraversal(TreeNode root) {
        List<Integer> list = new LinkedList<>();
        if(root != null) {
            list.add(root.val);
            List<Integer> listLeft = preorderTraversal(root.left);
            list.addAll(listLeft);
            List<Integer> listRight = preorderTraversal(root.right);       
            list.addAll(listRight);
        }
        return list;
    }

广度优先搜索应用：
二叉树的层序遍历

class Solution {
    
    public List<List<Integer>> levelOrder(TreeNode root) {
        List<List<Integer>> list = new ArrayList<List<Integer>>();
        if (root == null) {
            return list;
        }
        Queue<TreeNode> queue = new ArrayDeque<>();
        if (root != null) { //如果根节点不为空，加入队列
            queue.add(root);
        }
        while (!queue.isEmpty()) { //当队列不为空
            int n = queue.size(); //
            List<Integer> level = new ArrayList<>(); //记录每一层的结点
            for (int i = 0; i < n; i++) { 
                TreeNode node = queue.poll();//从队列中取出结点
                level.add(node.val);
                if (node.left != null) { 
                    queue.add(node.left); //将下一层的结点加入队列
                }
                if (node.right != null) {
                    queue.add(node.right); 
                }
            }
            list.add(level);
        }
        return list;  
    }
}

同样，可以利用广度优先遍历来求二叉树的最大高度，与层序遍历大致相同，每遍历一层高度加一

求二叉树的最大深度：

class Solution {
    public int maxDepth(TreeNode root) {
        if(root == null) {
            return 0;
        }
        int ret = 0;
        Queue<TreeNode> queue = new ArrayDeque<>();
        if(root != null) {
            queue.offer(root);
        }
        while (!queue.isEmpty()) {
            int n = queue.size();
            TreeNode node = new TreeNode();
            for (int i = 0; i < n;i++) {
                node = queue.poll(); //取出
                if (node.left != null) {
                    queue.offer(node.left);
                }
                if(node.right != null) {
                    queue.offer(node.right);
                }
            }
            ret++;
        }
        return ret;

    }
}