maximum-depth-of-binary-tree

Given a binary tree, find its maximum depth.

The maximum depth is the number of nodes along the longest path from the root node down to the farthest leaf node.

思路一：递归

/**
 * Definition for binary tree
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
public class Solution {
    public int maxDepth(TreeNode root) {
        if(root==null)
            return 0;
        else if(root.left==null&&root.right==null)
            return 1;
        else if(root.left==null)
            return maxDepth(root.right)+1;
        else if(root.right==null)
            return maxDepth(root.left)+1;
        return Math.max(maxDepth(root.left),maxDepth(root.right))+1;
    }
}

import java.util.*;
public class Solution {
    public int maxDepth(TreeNode root) {
        if(root==null)
            return 0;
        return Math.max(maxDepth(root.left),maxDepth(root.right))+1;
    }
}

思路二：BFS，效率高，用queue

/**
 * Definition for binary tree
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
import java.util.*;
public class Solution {
    public int maxDepth(TreeNode root) {
        if(root==null)
            return 0;
        Queue<TreeNode> queue=new LinkedList<TreeNode>();
        queue.add(root);
        int depth=0;//区别于最小depth的时候
        while(!queue.isEmpty()){
            int size=queue.size();
            for(int i=0;i<size;i++){
                TreeNode node=queue.poll();
                if(node.left!=null)
                    queue.add(node.left);
                if(node.right!=null)
                    queue.add(node.right);
            }
            depth++;
        }
        return depth;
    }
}

思路三：DFS，用栈

import java.util.*;
public class Solution {
    public int maxDepth(TreeNode root) {
        if(root==null)
            return 0;
        Stack<TreeNode> nodestack=new Stack<TreeNode>();//利用栈的后进先出
        Stack<Integer> depthstack=new Stack<>();//对应节点的深度
        nodestack.push(root);
        depthstack.push(1);
        int max=0;
        while(!nodestack.isEmpty()){
            TreeNode node=nodestack.pop();
            int temp=depthstack.pop();
            max=Math.max(temp,max);//每个节点，计算当前节点最大深度
            if(node.left!=null){//有子节点则加入，深度为当前深度加1；
                nodestack.push(node.left);
                depthstack.push(temp+1);
            }
            if(node.right!=null){
                nodestack.push(node.right);
                depthstack.push(temp+1);
            }
        }
        return max;
    }
}

最小深度和最大深度对比
利用递归时：
都可以判断
root null:return 0
else if root.leftnull &&root.rightnull :return 1;
else if root.leftnull: return max/minDepth(root.right)+1;
else if root.right==null: return max/minDepth(root.left)+1;
最后return Math.max/min(max/minDepth(root.left),max/minDepth(root.right))+1;
利用BFS：
最大深度初始depth=0，每层遍历完depth++，最后返回depth
最小深度初始depth=1，遇到左右节点都为空，则返回depth；否则depth++，最后返回depth