minimum-depth-of-binary-tree

利用二叉树的递归版的深搜可解

class Solution {
public:
    int DFS(TreeNode* root){
        if(root==nullptr)
            return 0;
        if(root->left==nullptr&&root->right==nullptr)
            return 1;
        if(root->left==nullptr&&root->right)
            return DFS(root->right)+1;
        if(root->left&&root->right==nullptr)
            return DFS(root->left)+1;
        int leftlen=DFS(root->left);
        int rightlen=DFS(root->right);
        return (leftlen>rightlen)?rightlen+1:leftlen+1;
    }
    int run(TreeNode *root) {
        int res=DFS(root);
        return res;
    }
};

然后非递归版本的深搜需要借助队列来实现：

class Solution {
public:
    int run(TreeNode *root) {
        if(root==nullptr)
            return 0;
        if(root->left==nullptr&&root->right==nullptr)
            return 1;
        queue<TreeNode*> q;
        q.push(root);
        int level=1;//记录当前高度
        int next=1;//记录下一次BFS需要遍历多少节点
        TreeNode* temp;
        while(q.size()!=0)
        {
            //一次while循环意味着一次BFS
            int tempnext=0;//每层遍历初始化next
            for(int i=0;i<next;i++)
            {
                temp=q.front();
                q.pop();
                if(temp->left==nullptr&&temp->right==nullptr)
                    return level;//找到的第一个没有左右子节点的即输出高度
                if(temp->left){q.push(temp->left);tempnext+=1;}
                if(temp->right){q.push(temp->right);tempnext+=1;}
                
            }
            next=tempnext;//将BFS后得到下一次循环需要遍历的节点数量进行更新
            level+=1;
        }
        return 0;
    }
};