leetcode 102. 二叉树的层次遍历 C语言 bfs

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

例如:
给定二叉树: [3,9,20,null,null,15,7],

    3
   / \
  9  20
      /  \
   15   7
返回其层次遍历结果：

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

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

#define ElementType struct TreeNode*
#define MAX_SIZE 10000

typedef struct {
    ElementType data[MAX_SIZE]; 
    int front; // 记录队列头元素位置
    int rear; // 记录队列尾元素位置
    int size; // 存储数据元素的个数
} Queue;

Queue* CreateQueue()
{
    Queue* queue = (Queue*)malloc(sizeof(Queue));
    queue->front = -1;
    queue->rear = -1;
    queue->size = 0;
    return queue;
}

void PushQueue(Queue* queue, ElementType item)
{
    queue->rear++;
    queue->rear %= MAX_SIZE;
    queue->size++;
    queue->data[queue->rear] = item;
}

ElementType PopQueue(Queue *queue)
{
    queue->front++;
    queue->front %= MAX_SIZE;
    queue->size--;
    return queue->data[queue->front];
}

int GetTreeDepth(struct TreeNode* root)
{
    int left;
    int right;
    if (root == NULL) {
        return 0;
    }
    left = GetTreeDepth(root->left);
    right = GetTreeDepth(root->right); 
    return left > right ? left + 1 : right + 1;
}

/**
 * Return an array of arrays of size *returnSize.
 * The sizes of the arrays are returned as *returnColumnSizes array.
 * Note: Both returned array and *columnSizes array must be malloced, assume caller calls free().
 */
int** levelOrder(struct TreeNode* root, int* returnSize, int** returnColumnSizes)
{
    Queue* queue;
    int depth;
    int size;
    // 记录当前处于二叉树的哪一层
    int curDepth = 0;
    // 记录当前处于二叉树同一层级的index
    int index;
    struct TreeNode* temp;
    if (root == NULL) {
        *returnSize = 0;
        *returnColumnSizes = (int*)malloc(sizeof(int));
        (*returnColumnSizes)[0] = 0;
        return NULL;
    }
    queue = CreateQueue();
    PushQueue(queue, root);
    depth = GetTreeDepth(root);
    *returnSize = depth;
    int** matrix = (int**)malloc(sizeof(int*) * depth);
    *returnColumnSizes = (int*)malloc(sizeof(int) * depth);
    while (queue->size != 0) {
        // 当前层二叉树的节点个数
        size = queue->size;
        (*returnColumnSizes)[curDepth] = size;
        matrix[curDepth] = (int*)malloc(sizeof(int) * size);
        index = 0;
        while (size != 0) {
            temp = PopQueue(queue);
            matrix[curDepth][index] = temp->val;
            index++;
            if (temp->left != NULL) {
                PushQueue(queue, temp->left);
            }
            if (temp->right != NULL) {
                PushQueue(queue, temp->right);
            }
            size--;
        }
        curDepth++;
    }
    return matrix;
}