102. Binary Tree Level Order Traversal
Given the root of a binary tree, return the level order traversal of its nodes' values. (i.e., from left to right, level by level).
Example 1:
Input: root = [3,9,20,null,null,15,7]
Output: [[3],[9,20],[15,7]]
Example 2:
Input: root = [1]
Output: [[1]]
Example 3:
Input: root = []
Output: []
Constraints:
- The number of nodes in the tree is in the range [0, 2000].
- -1000 <= Node.val <= 1000
From: LeetCode
Link: 102. Binary Tree Level Order Traversal
Solution:
Ideas:
- Create a queue to hold the nodes of the tree.
- Enqueue the root node to the queue.
- While the queue is not empty:
- Calculate the number of nodes at the current level.
- Allocate memory for these nodes.
- For each node at the current level:
- Dequeue the node from the queue.
- Add the node's value to the result.
- Enqueue the node's left child (if it exists).
- Enqueue the node's right child (if it exists).
- Return the result.
Code:
c
/**
* Definition for a binary tree node.
* struct TreeNode {
* int val;
* struct TreeNode *left;
* struct TreeNode *right;
* };
*/
/**
* 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) {
if (!root) {
*returnSize = 0;
return NULL;
}
// Create a queue for BFS
struct TreeNode** queue = malloc(2000 * sizeof(struct TreeNode*));
int front = 0, rear = 0;
// Enqueue root
queue[rear++] = root;
int** result = malloc(2000 * sizeof(int*));
*returnColumnSizes = malloc(2000 * sizeof(int));
*returnSize = 0;
while (front < rear) {
// Number of nodes at current level
int levelSize = rear - front;
(*returnColumnSizes)[*returnSize] = levelSize;
// Allocate memory for nodes of this level
result[*returnSize] = malloc(levelSize * sizeof(int));
for (int i = 0; i < levelSize; i++) {
// Dequeue node
struct TreeNode* current = queue[front++];
// Add node's value to result
result[*returnSize][i] = current->val;
// Enqueue left child
if (current->left) {
queue[rear++] = current->left;
}
// Enqueue right child
if (current->right) {
queue[rear++] = current->right;
}
}
(*returnSize)++;
}
free(queue);
return result;
}