【LeetCode】111. Minimum Depth of Binary Tree (2 solutions)

Minimum Depth of Binary Tree

Given a binary tree, find its minimum depth.

The minimum depth is the number of nodes along the shortest path from the root node down to the nearest leaf node.

 

与Maximum Depth of Binary Tree对照看

解法一：深度优先遍历

借助栈进行深度优先遍历(DFS)，栈中存放的就是从根到当前节点的路径。

当遇到叶节点的时候，把当前栈中路径长度与minD比较，取较小值赋给minD。

返回minD即最小深度。

/**
 * Definition for binary tree
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    int minDepth(TreeNode *root) {
        if(!root)
            return 0;
        stack<TreeNode*> stk;
        int ret = INT_MAX;
        unordered_map<TreeNode*, bool> visited;
        stk.push(root);
        visited[root] = true;
        while(!stk.empty())
        {
            TreeNode* top = stk.top();
            if(!top->left && !top->right)
            //leaf
                ret = min(ret, (int)stk.size());
            
            if(top->left && visited[top->left] == false)
            {
                stk.push(top->left);
                visited[top->left] = true;
                continue;
            }
            if(top->right && visited[top->right] == false)
            {
                stk.push(top->right);
                visited[top->right] = true;
                continue;
            }
            
            stk.pop();
        }
        return ret;
    }
};

 

解法二：递归

注意：定义中需要到达叶节点，因此空的子节点不计算在内。

/**
 * Definition for binary tree
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    int minDepth(TreeNode *root) {
        if(!root)
            return 0;
        else if(root->left && !root->right)
            return 1+minDepth(root->left);
        else if(!root->left && root->right)
            return 1+minDepth(root->right);
        else
            return 1+min(minDepth(root->left), minDepth(root->right));
    }
};