Leetcode: 104. 二叉树的最大深度

给定一个二叉树，找出其最大深度。

二叉树的深度为根节点到最远叶子节点的最长路径上的节点数。

说明: 叶子节点是指没有子节点的节点。

示例：
给定二叉树 [3,9,20,null,null,15,7]，

    3
   / \
  9  20
    /  \
   15   7

返回它的最大深度 3 。

1. DFS 递归:

int maxDepth(struct TreeNode* root){

    if(!root)
    {
        return 0;
    }
    
    int a = maxDepth(root->left);
    int b = maxDepth(root->right);
    return  (a > b) ? (1+a) : (1 +b);
}

2. BFS迭代：

int maxDepth(struct TreeNode* root){

    struct TreeNode *queue[10000];
    int head = 0;
    int tail= 0;
    int size = 0;
    int ret = 0;
    if(root)
    {
        queue[tail++] = root;
        ++size;
        //++ret;
    }
    while(size > 0)
    {
        ++ret;
        int newsize = size;
        size = 0;
        while(newsize > 0)
        {
            struct TreeNode *node = queue[head++];
            --newsize;

            if(node->left)
            {
                queue[tail++] = node->left;
                ++size;
            }
            if(node->right)
            {
                queue[tail++] = node->right;
                ++size;
            }

        }
    }
    
    return ret;
}

3. DFS迭代：

struct myTreeNode
{
    struct TreeNode *p;
    int level;
};

struct myTreeNode g_pool[10000];
int g_pool_idx;

int maxDepth(struct TreeNode* root){
    g_pool_idx = 0;

    struct myTreeNode *g_stack[10000];
    int top = 0;
    int size = 0;

    int ret = 0;
    
    if(root)
    {
        g_stack[top] = &g_pool[g_pool_idx++];
        g_stack[top]->p = root;
        g_stack[top]->level = 1;
        ++top;
        ++size;
        ret = 1;
    }

    while(size > 0)
    {
        struct myTreeNode *node = g_stack[--top];
        --size;
        if(node->p->left)
        {
            g_stack[top] = &g_pool[g_pool_idx++];
            g_stack[top]->p = node->p->left;
            g_stack[top]->level = node->level + 1;
            ++top;
            ++size;

            if( ret < node->level + 1)
            {
                ret = node->level + 1;
            }
        }

        if(node->p->right)
        {
            g_stack[top] = &g_pool[g_pool_idx++];
            g_stack[top]->p = node->p->right;
            g_stack[top]->level = node->level + 1;
            ++top;
            ++size;

            if(ret < node->level + 1)
            {
                ret = node->level + 1;
            }
        }     

    }
      return ret;
}