树的高度

树的高度：

1.深度优先遍历（递归）

  先遍历左子节点，再遍历右子节点

   时间复杂度：每个叶子节点被访问到一次，O（N）

 空间复杂度：当是不平衡树的时候，如果所有的节点都是左子节点，递归将会被调用 N 次（树的高度），空间复杂度O(n)

                      但在最好的情况下（树是完全平衡的），树的高度将是log(N)。因此，在这种情况下的空间复杂度将是O(log(N))

2.广度优先遍历

     一层一层的遍历节点，当遍历到最后一个节点的时候，循环结束,每遍历一层，深度参数加1

    采用队列结构，先入先出，队列里面存储当前的父节点

时间复杂度：o（n）

空间复杂度： o(n)

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
    public int maxDepth(TreeNode root) {
        if (root==null) return 0;
        /*
            深度优先遍历
        */
        
        /*
        int l=maxDepth(root.left);
        int r=maxDepth(root.right);
        return 1+(l>r?l:r);
        */
        /*
            广度优先遍历，利用队列数据结构，先入先出，一层一层遍历树，直到叶子节点的最后一个，记录遍历的层数
        */
        LinkedList<TreeNode> queue =new LinkedList<>();
        int rootnum=1;
        int sonnum=0;
        queue.add(root);
        int lever=0;
        while(!queue.isEmpty()){
            //先取出要遍历的父节点
            TreeNode parent=queue.poll();
            rootnum--;
            //计算子节点的数目
            if(parent.left!=null){
                queue.add(parent.left);
                sonnum++;
            }
            if(parent.right!=null){
                queue.add(parent.right);
                sonnum++;
            }
            //遍历切换到下一层
            if(rootnum==0){
                rootnum=sonnum;
                sonnum=0;
                lever++;
            }
            
        }
        return lever;
    }
}