LeetCode 104: Maximum Depth of Binary Tree

/**
 * 104. Maximum Depth of Binary Tree
 * 1. Time:O(n)  Space:O(h)
 * 2. Time:O(n)  Space:O(h)
 * 3. Time:O(n)  Space:O(h)
 */

// 1. Time:O(n)  Space:O(h)
class Solution {
    public int maxDepth(TreeNode root) {
        if(root==null) return 0;
        if(root.left==null && root.right==null) return 1;
        int maxLevel = Integer.MIN_VALUE;
        if(root.left!=null)
            maxLevel = Math.max(maxLevel,maxDepth(root.left));
        if(root.right!=null)
            maxLevel = Math.max(maxLevel,maxDepth(root.right));
        return maxLevel+1;
    }
}

// 2. Time:O(n)  Space:O(h)
class Solution {
    public int maxDepth(TreeNode root) {
        if(root==null) return 0;
        Stack<TreeNode> stack = new Stack<>();
        int maxLevel=Integer.MIN_VALUE,level=0;
        TreeNode last=null;
        while(root!=null ||!stack.isEmpty()){
            while(root!=null){
                stack.push(root);
                level++;
                root=root.left;
            }
            TreeNode tmp = stack.peek();
            if(tmp.right!=null && tmp.right!=last)
                root = tmp.right;
            else{
                if(tmp.left==null && tmp.right==null)
                    maxLevel = Math.max(maxLevel,level);
                last = stack.pop();
                level--;
            }
        }
        return maxLevel;
    }
}

// 3. Time:O(n)  Space:O(h)
class Solution {
    public int maxDepth(TreeNode root) {
        if(root==null) return 0;
        Queue<TreeNode> queue = new LinkedList<>();
        queue.add(root);
        int maxLevel = 0;
        while(!queue.isEmpty()){
            maxLevel++;
            int size = queue.size();
            for(int i=0;i<size;i++){
                TreeNode tmp = queue.poll();
                if(tmp.left!=null)
                    queue.add(tmp.left);
                if(tmp.right!=null)
                    queue.add(tmp.right);
            }
        }
        return maxLevel;
    }
}