leetcode

题目：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.

这道题容易联想到求二叉树最大深度的题目，一开始以为只要把那个题目稍微改改就行了，其实有个小陷阱在里面，在下面的个人思路中我会提及。

个人思路：

1、类似求二叉树的深度的算法，采用递归的方式，一个二叉树的最小深度是左子树深度和右子树深度的较小者加1

2、这里要注意加几个判断条件，一个节点为叶子节点，则返回深度1；一个节点若仅有一个左孩子或者右孩子，则应该返回孩子节点的深度加1，而不应该直接计算左右子树的深度，选取较小者加1，假如该节点仅有左孩子，则右节点为空，返回0，这样便会选取右边这条路径，但其实这个右节点根本不存在，就会有问题（读读题目就明白了）；一个节点有两个孩子节点，则是按照左右深度较小者加1的思路。

代码：

#include <stddef.h>
#include <iostream>

using namespace std;

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;
        }

        if (!root->left && !root->right)
        {
            return 1;
        }

        if (root->left && !root->right)
        {
            return minDepth(root->left) + 1;
        }

        if (root->right && !root->left)
        {
            return minDepth(root->right) + 1;
        }

        int leftMinDepth = minDepth(root->left);
        int rightMinDepth = minDepth(root->right);

        return leftMinDepth < rightMinDepth ? leftMinDepth + 1 : rightMinDepth + 1;
    }
};

int main()
{
    TreeNode *root = new TreeNode(3);
    root->left = new TreeNode(9);
    //root->right = new TreeNode(20);
    //root->right->left = new TreeNode(15);
    //root->right->right = new TreeNode(7);

    Solution s;
    int depth = s.minDepth(root);

    cout << depth << endl;

    system("pause");

    return 0;
}

上面的思路是DFS的方式，在网上还发现了BFS的算法，由于是按层次遍历，只有在某一层发现了叶子节点，则该树的最小深度就是该层次的深度

个人实践了一下，代码：

#include <stddef.h>
#include <iostream>
#include <queue>

using namespace std;

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;
        }

        if (!root->left && !root->right)
        {
            return 1;
        }

        if (root->left && !root->right)
        {
            return minDepth(root->left) + 1;
        }

        if (root->right && !root->left)
        {
            return minDepth(root->right) + 1;
        }

        int leftMinDepth = minDepth(root->left);
        int rightMinDepth = minDepth(root->right);

        return leftMinDepth < rightMinDepth ? leftMinDepth + 1 : rightMinDepth + 1;
        */

        if (!root)
        {
            return 0;
        }

        queue<TreeNode *> level, level_bak;
        int level_num = 1;
        level.push(root);

        while (!level.empty())
        {
            TreeNode *currentNode = level.front();
            level.pop();
            level_bak.push(currentNode);
            if (!currentNode->left && !currentNode->right)
            {
                break;
            }
            if (level.empty())
            {
                ++level_num;
                while (!level_bak.empty())
                {
                    currentNode = level_bak.front();
                    level_bak.pop();
                    if (currentNode->left)
                    {
                        level.push(currentNode->left);
                    }
                    if (currentNode->right)
                    {
                        level.push(currentNode->right);
                    }
                }
            }
        }

        return level_num;
    }
};

int main()
{
    TreeNode *root = new TreeNode(3);
    root->left = new TreeNode(9);
    //root->right = new TreeNode(20);
    //root->right->left = new TreeNode(15);
    //root->right->right = new TreeNode(7);

    Solution s;
    int depth = s.minDepth(root);

    cout << depth << endl;

    system("pause");

    return 0;
}