Minimum Depth of Binary Tree

Description:

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.

代码:

#include <iostream>
#include <vector>
#include <stack>
#include <algorithm>
#include <queue>

#define Elementype int

using namespace std;

int index = 0;


typedef struct TreeNode //树结点
{
    Elementype  val;
    TreeNode *left;
    TreeNode *right;
    TreeNode(Elementype x) : val(x), left(nullptr), right(nullptr) {}
} *Tree;

//使用先序遍历创建创建二叉树
void MakeBinaryTree(Tree &T, Elementype value[])
{
    Elementype  c = value[index++];
    if (c == '#')
        T = nullptr;
    else
    {
        T = new TreeNode(c);
        MakeBinaryTree(T->left, value);
        MakeBinaryTree(T->right, value);
    }

}


//递归
int minDepth(Tree root, bool hasBrother)
{
    if (!root)
        return hasBrother ? INT_MAX : 0;
    return 1 + min(minDepth(root->left, root->right != nullptr), minDepth(root->right, root->left != nullptr));
}

//迭代，广度优先遍历
int minDepthBFS(Tree root)
{
    if (!root)
        return 0;
    int depth = 1;
    queue<Tree> que;
    queue<Tree> que2;  //存储下一层结点
    que.push(root);
    while (!que.empty())
    {
        Tree p = que.front();
        que.pop();
        if (p->left && p->right)
        {
            que2.push(p->left);
            que2.push(p->right);

        }
        else
        {
            return depth;
        }

        if (que.empty() && !que2.empty())
        {
            swap(que, que2);
            depth++;
        }
    }
    return depth;
}

//先序遍历
void preOrderTraversal(Tree root)
{
    stack<Tree> sk;
    Tree p = root;
    if (p)
        sk.push(p);
    while (!sk.empty())
    {
        p = sk.top();
        cout << p->val<<" ";
        sk.pop();

        if (p->right)
            sk.push(p->right);

        if (p->left)
            sk.push(p->left);
    }
}

int main()
{
    Tree root = nullptr;        //根结点
    Elementype data[11] = { 3, 9, '#', '#', 20, 15, '#', '#', 7, '#', '#' };
    MakeBinaryTree(root, data);

    cout << "先序遍历： ";
    preOrderTraversal(root);
    cout << endl;


    cout << "最小深度，递归：" << minDepth(root, false) << endl;
    cout << "最小深度，迭代：" << minDepthBFS(root) << endl;

    system("pause");
    return 0;
}

测试：