111. Minimum Depth of Binary Tree

成都创新互联公司是一家专业提供孟津企业网站建设,专注与成都网站制作、成都网站建设、成都h5网站建设、小程序制作等业务。10年已为孟津众多企业、政府机构等服务。创新互联专业的建站公司优惠进行中。

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.

思路：

mine思路：

1.采用后序遍历非递归方式，找到叶子节点，记录当时栈内元素的个数到容器中。

2.最后从容器中选择最小的一个输出。

代码如下：

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    int minDepth(TreeNode* root) {
        
        int iMinDepth;
        vector depths;
        stack s;
        
        TreeNode *p,*q;
        q = NULL;
        p = root;
        if(!root)
            return 0;
        while(p != NULL || s.size() > 0)
        {
            while( p != NULL)
            {
                s.push(p);
                p = p->left;
            }
            if(s.size() > 0)
            {
                p = s.top();
                 
                if( NULL == p->left && NULL == p->right)
                {
                    depths.push_back(s.size());
                }
                 
                if( (NULL == p->right || p->right == q) )
                {
                    q = p;
                    s.pop();
                    p = NULL;
                }
                else
                    p = p->right;
            }
        }
        iMinDepth = depths[0];
        for(int i = 0; i < depths.size(); i++)
        {
            if(depths[i] < iMinDepth)
            {
                iMinDepth = depths[i];
            }
        }
        return iMinDepth;
    }
};

参考其他：http://www.cnblogs.com/bakari/p/4126693.html

有两种求解的思路，一种采用DFS的思想，一种采用BFS的思想，如下代码所示：

struct TreeNode {
    int            val;
    TreeNode*    left;
    TreeNode*    right;
    TreeNode(int x): val(x), left(NULL),right(NULL) {}
};

//采用DFS的思想
int maxDepth(TreeNode *root)
{
    if (NULL == root)
        return 0;
    int l = maxDepth(root->left);
    int r = maxDepth(root->right);

    return l > r ? l + 1:r+1;
    //以上这两种方式有一种更简便的方法
    //return 1 + max(maxDepth(root->left), maxDepth(root->right));
}

//采用BFS的方法，引入队列
int maxDepth(TreeNode *root)
{
    if (NULL == root)
        return 0;
    queue  que;
    int nCount = 1;
    int nDepth = 0;// 记录队列里面每一层上的元素

    que.push(root);
    while(!que.empty()) {
        TreeNode *pTemp = que.front();
        que.pop();
        nCount --;

        if (pTemp->left)
            que.push(pTemp->left);
        if (pTemp->right)
            que.push(pTemp->right);
        
        if (nCount == 0) {
            nDepth ++;
            nCount = que.size();
        }
    }
    return nDepth;
}

2016-08-07 10:12:37

本文题目：leetCode111.MinimumDepthofBinaryTree二叉树问题
当前URL：http://azwzsj.com/article/ipphje.html