LeetCode 111. Minimum Depth of Binary Tree

0. 版权声明

• LeetCode 系列笔记来源于 LeetCode 题库¹，在个人思考的基础之上博采众长，令鄙人受益匪浅；故今记此文，感怀于心，更多题解及代码，参见 Github²；
• 该系列笔记不以盈利为目的，仅用于个人学习、课后复习及交流讨论；
• 如有侵权，请与本人联系（[email protected]），经核实后即刻删除；
• 本文采用 署名-非商业性使用-禁止演绎 4.0 国际 (CC BY-NC-ND 4.0) 协议发布；

1. LeetCode 111

• 递归：需访问 n 个节点；
  • 时间复杂度：$O(n)$；
  • 空间复杂度：此处以递归调用的次数衡量栈的空间开销；
    • 在最好情况下，即树处于完全平衡状态，$O(log(n))$；
    • 在最坏情况下，即任一子树均处于非平衡状态，$O(n)$；
• 深度优先搜索迭代：需访问 n 个节点；
  • 时间复杂度：$O(n)$；
  • 空间复杂度：在最坏情况下，即任一子树均处于非平衡状态，$O(n)$；
• 广度优先搜索迭代：仅需访问$\frac{n}{2}$个节点；
  • 时间复杂度：$O(n)$；
  • 空间复杂度：$O(n)$；
• 备注：n 为二叉树中的节点数量；

2. 递归

• 求解流程：
  • 若某个节点为空，则以该节点为根节点的子树深度值为0；
• 若某个节点不为空，且该节点无子节点，则以该节点为根节点的子树深度值为1；
  • 若某个节点不为空，且该节点有子节点，则以该节点为根节点的子树深度值为两个子节点的较小深度值加1；

3. 深度优先搜索迭代

• 求解流程：
  • 以节点为键，以该节点的深度为值，用栈保存键值对；
  • 创建一个变量 minDepth，若当前节点无子节点，则以$min(currentDepth,minDepth)$更新该变量；
  • 若当前节点存在子节点，则将其压入堆栈，将当前深度值加1作为该子节点的深度值；
  • 不断将栈中的节点弹出，重复上述步骤，直至栈为空；

4. 广度优先搜索迭代

• 求解流程：
  • 与深度优先搜索的区别在于，使用队列保存键值对；

5. 代码

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */

// Approach 1: Recursion
class Solution {
    public int minDepth(TreeNode root) {
        if (root == null)
            return 0;
        if ((root.left == null) && (root.right == null))
            return 1;
        int minDepth = Integer.MAX_VALUE;   
        if (root.left != null)      
            minDepth = Math.min(minDepth, minDepth(root.left));
        if (root.right != null)
            minDepth = Math.min(minDepth, minDepth(root.right));
        return minDepth + 1;
    }
}

// Approach 2: Iteration, Depth-First-Search
class Solution {
    public int minDepth(TreeNode root) {
        if (root == null)
            return 0;
        Stack<st> stack = new Stack<>();
        stack.push(new st(root, 1));
        int ans = Integer.MAX_VALUE; 
        while (!stack.empty())
        {
            st temp = stack.pop();
            TreeNode node = temp.getNode();
            int depth = temp.getDepth();
            if ((node.left == null) && (node.right == null))
                ans = Math.min(ans, depth);    
            if (node.left != null)
                stack.push(new st(node.left, depth + 1));
            if (node.right != null)
                stack.push(new st(node.right, depth + 1));
        }
        return ans;
    }
}

public class st {
    private TreeNode node;
    private int depth;

    public st(TreeNode node, int depth)
    {
        this.node = node;
        this.depth = depth;
    }

    public TreeNode getNode()
    {
        return node;
    }

    public int getDepth()
    {
        return depth;
    }
}

// Approach 3: Iteration, Breadth-First-Search
class Solution {
    public int minDepth(TreeNode root) {
        if (root == null)
            return 0;
        Queue<st> queue = new LinkedList<>();       
        queue.add(new st(root, 1));
        int minDepth = 0;
        while (queue.size() != 0)
        {
            st temp = queue.poll();
            TreeNode node = temp.getNode();
            minDepth = temp.getDepth();
            if ((node.left == null) && (node.right == null))
                return minDepth;
            if (node.left != null)
                queue.add(new st(node.left, minDepth + 1));
            if (node.right != null)
                queue.add(new st(node.right, minDepth + 1));
        }
        return -1;
    }
}

public class st {
    private TreeNode node;
    private int depth;

    public st(TreeNode node, int depth)
    {
        this.node = node;
        this.depth = depth;
    }

    public TreeNode getNode()
    {
        return node;
    }

    public int getDepth()
    {
        return depth;
    }
}

References

---

1. https://leetcode-cn.com/problemset/all/. ↩︎

2. https://github.com/hqpan/LeetCode. ↩︎