leetcode 104.二叉树的最大深度（maximum depth of binary tree）C语言

1.description

https://leetcode-cn.com/problems/maximum-depth-of-binary-tree/description/

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

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

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

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

⁠ 3
⁠ /
⁠ 9 20
⁠ /
⁠ 15 7

返回它的最大深度 3 。

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     struct TreeNode *left;
 *     struct TreeNode *right;
 * };
 */

2.solution

2.1 递归：

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

    if(root == NULL){
        return 0;
    }

    lhigh = maxDepth(root->left);
    rhigh = maxDepth(root->right);

    return (lhigh > rhigh) ? (lhigh + 1) : (rhigh + 1); 
}

2.2 BFS迭代

基于链表队列：

#define queue_is_empty(queue) (queue->head == NULL)

typedef struct list_node{
    void *val;
    struct list_node *next;
}Node;

typedef struct list_queue{
    Node *head;
    Node *tail;
    int size;
}Queue;


// 创建初始队列
Queue *queue_create(){
    Queue *queue = NULL;
    queue = (Queue*)malloc(sizeof(Queue));
    if(queue == NULL){
        return NULL;
    }

    queue->head = NULL;
    queue->tail = NULL;
    queue->size = 0;

    return queue;
}


// 入队
void enqueue(Queue *queue, void *val){
    Node *node = NULL;
    node = (Node*)malloc(sizeof(Node));
    node->val = val;
    node->next = NULL;

    if(queue_is_empty(queue)){
        queue->head = node;
    }else{
        queue->tail->next = node;
    }
    queue->tail = node;
    (queue->size)++;
}


// 出队
int dequeue(Queue *queue, void **val){
    if(queue_is_empty(queue)){
        return -1;
    }

    *val = queue->head->val;
    Node *p = queue->head;
    queue->head = p->next;

    // ***如果出队的是最后一个节点，记得把tail置为NULL
    if(queue->head == NULL){
        queue->tail = NULL;
    }

    (queue->size)--;

    free(p);
    return 0;
}

int maxDepth(struct TreeNode* root){
    if(root == NULL){
        return 0;
    }

    Queue *queue = NULL;
    struct TreeNode *node = NULL;
    queue = queue_create();

    enqueue(queue, (void*)root);

    int level = 0;
    while(!queue_is_empty(queue)){
        int levelid = 0;
        int size = queue->size;
        while(size--){
            dequeue(queue, (void*)&node);

            if(node->left){
                enqueue(queue, (void*)node->left);
            }
            if(node->right){
                enqueue(queue, (void*)node->right);
            }
        }
        level++;
    }

    free(queue);

    return level;
}

基于数组队列：

// 基于数组队列的BFS迭代法
#define MAX_LEN 10000

int maxDepth(struct TreeNode* root){
    if(root == NULL){
        return 0;
    }

    struct TreeNode *queue[MAX_LEN];
    struct TreeNode *p = NULL;
    int head = 0;
    int tail = 0;
    int num = 0;

    queue[tail++] = root;
    num++;

    int level = 0;
    while(num != 0){ // 队不空
        int size = num; // 记录当前层节点个数
        while(size--){
            // 出队
            p = queue[head];
            head++;
            num--;

            // 子节点入队
            if(p->left){
                queue[tail++] = p->left;
                num++;
            }
            if(p->right){
                queue[tail++] = p->right;
                num++;
            }
        }
        level++;
    }

    return level;
}