Maxium depth of BT 104

public int maxDepth(TreeNode root) {
        if (root == null) return 0;
        return Math.max(maxDepth(root.left), maxDepth(root.right)) + 1;

        List<TreeNode> q = new ArrayList<>();
        TreeNode current = root;
        int level = 0;
        q.add(root);
        while (!q.isEmpty()) {
            int siz = q.size();
            while (siz-- > 0) {
                current = q.remove(0);
                if (current.left != null) { q.add(current.left); } 
                if (current.right != null) { q.add(current.right); }
            }
            level++;
        }
        return level;

        if (root == null) return 0;
        Stack<TreeNode> treeq = new Stack<>();
        Stack<Integer> levelq = new Stack<>();
        treeq.push(root); levelq.push(1);
        int maxLevel = 0;
        while (!treeq.isEmpty()) {
            TreeNode curNode = treeq.pop();
            Integer curLevel = levelq.pop();
            maxLevel = Math.max(maxLevel, curLevel);
            if (curNode.left != null) {
                treeq.push(curNode.left);
                levelq.push(curLevel + 1);
            }
            if (curNode.right != null) {
                treeq.push(curNode.right);
                levelq.push(curLevel + 1);
            }
        }
        return maxLevel;
}

Min depth of BT 111

public int minDepth(TreeNode root) {
        if (root == null) return 0;
        int left = minDepth(root.left), right = minDepth(root.right);
        return (left == 0 || right == 0) ? left + right + 1 : Math.min(left, right) + 1; 
        //left=0-->left null, then minDepth(right) + 1; otherwise minDepth(left) + 1; otherwise min of left/right + 1.

        if (root == null) return 0;
        Queue<TreeNode> nodeq = new LinkedList<>();
        Queue<Integer> levelq = new LinkedList<>();
        nodeq.offer(root); levelq.offer(1);
        while (!nodeq.isEmpty()) {
            TreeNode curNode = nodeq.poll();
            Integer curLevel = levelq.poll();
            if (curNode.left == null && curNode.right == null) return curLevel;
            if (curNode.left != null) {
                nodeq.offer(curNode.left);
                levelq.offer(curLevel + 1);
            }
            if (curNode.right != null) {
                nodeq.offer(curNode.right);
                levelq.offer(curLevel + 1);
            }
        }
        return -1;
}

Invert Binary Tree 226

     4                        4
   /   \                    /   \
  2     7                  7     2
 / \   / \     /\         / \    / \
1   3 6   9              9   6  3   1
public TreeNode invertTree(TreeNode root) {
        if (root == null) return root;
        TreeNode tmp = root.left;
        root.left = invertTree(root.right);
        root.right = invertTree(tmp);
        return root;
    }