leetcode 102.二叉树的层序遍历（binary tree level order traversal）C语言

1.description

https://leetcode-cn.com/problems/binary-tree-level-order-traversal/description/

给你一个二叉树，请你返回其按 层序遍历 得到的节点值。 （即逐层地，从左到右访问所有节点）。

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

返回其层次遍历结果：

[
⁠ [3],
⁠ [9,20],
⁠ [15,7]
]

2.solution

#define REALLOC_STEP 10

#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** levelOrder(struct TreeNode* root, int* returnSize, int** returnColumnSizes){
    if(root == NULL){
        *returnSize = 0;
        return NULL;
    }

    int **ans = (int**)malloc(sizeof(int*)*REALLOC_STEP);
    *returnColumnSizes = (int*)malloc(sizeof(int)*REALLOC_STEP);
    memset(*returnColumnSizes, 0, sizeof(int)*REALLOC_STEP);

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

    // 根节点先入队
    enqueue(queue, (void *)root);

    int level = 0;
    // pop一个节点，输出其值，将左节点和右节点push，不断循环至队空
    while(!queue_is_empty(queue)){
        if(level != 0 && level % REALLOC_STEP == 0){
            ans = (int**)realloc(ans, sizeof(int*)*(level+REALLOC_STEP));
            *returnColumnSizes = (int*)realloc(*returnColumnSizes, sizeof(int)*(level+REALLOC_STEP));
            for(int i=level; i<level+REALLOC_STEP; ++i){
                (*returnColumnSizes)[i] = 0;
            }
        }

        ans[level] = (int*)malloc(sizeof(int)*REALLOC_STEP);
        int levelid = 0;
        int size = queue->size;
        (*returnColumnSizes)[level] = size;
        while(size--){
            dequeue(queue, (void *)&node);

            if(levelid != 0 && levelid % REALLOC_STEP == 0){
                ans[level] = (int*)realloc(ans[level], sizeof(int)*(levelid+REALLOC_STEP));
            }

            ans[level][levelid++] = node->val;

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

    *returnSize = level;

    free(queue);

    return ans;
}