LeetCode-Maximum Depth of Binary Tree

使用递归，很容易就可以得出结果。

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
    public int findMaxDepth(TreeNode n,int depth){
        int dl=depth,dr=depth;
        if(n.left!=null) dl=findMaxDepth(n.left,depth+1);
        if(n.right!=null) dr=findMaxDepth(n.right,depth+1);
        return Math.max(dl,dr);
    }
    public int maxDepth(TreeNode root) {
        if(root==null) return 0;
        return findMaxDepth(root,1);
    }
}

看到别人的解法里还有不使用递归，直接使用队列+循环来解决问题的，思路也很妙。

但因为使用链表队列，所以运行速度反而会比较慢。

/**
 * 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 depth=0;
        Queue<TreeNode> q=new LinkedList<>();
        q.offer(root);
        while(!q.isEmpty()){
            int len=q.size();
            for(;len>0;len--){
                TreeNode t=q.poll();
                if(t.left!=null) q.offer(t.left);
                if(t.right!=null) q.offer(t.right);
            }
            depth++;
        }
        return depth;
    }
}

使用 Go 语言重写递归模式，发现代码变长了很多 T-T

/**
 * Definition for a binary tree node.
 * type TreeNode struct {
 *     Val int
 *     Left *TreeNode
 *     Right *TreeNode
 * }
 */
func findMaxDepth(n *TreeNode,depth int) int{
    dl,dr:=depth,depth
    if n.Left!=nil{
        dl=findMaxDepth(n.Left,depth+1)
    }
    if n.Right!=nil{
        dr=findMaxDepth(n.Right,depth+1)
    }
    if dl>dr{
        return dl
    }else{
        return dr
    }
}
func maxDepth(root *TreeNode) int {
    if root==nil{
        return 0
    }
    return findMaxDepth(root,1)
}