LeetCode:Binary Tree Level Order Traversal

Given a binary tree, return the level order traversal of its nodes' values. (ie, from left to right, level by level).

For example:

Given binary tree

{3,9,20,#,#,15,7}

,

3
/ \
9  20
/  \
15   7

return its level order traversal as:

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

My Solution

最开始看到是二叉树的层次遍历，想用队列做。后来发现还要分层，所以只能用二维数组了。

想法还是很自然的，逐层生成即可。

/**
* 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 *columnSizes array.
* Note: Both returned array and *columnSizes array must be malloced, assume caller calls free().
*/

int** levelOrder(struct TreeNode* root, int** columnSizes, int* returnSize) {
if(!root)
{
*columnSizes = NULL;
*returnSize = 0;
return NULL;
}

*returnSize = maxDepth(root);   // 树的高度
// 分配内存
struct TreeNode* ** traversalNode = (struct TreeNode* **)malloc(*returnSize * sizeof(struct TreeNode* *));
int **traversalVal = (int**)malloc(*returnSize * sizeof(int*));
*columnSizes = (int*)malloc(*returnSize * sizeof(int));

// 先计算第一层（根节点）
traversalNode[0] = (struct TreeNode**)malloc(1 * sizeof(struct TreeNode*));
traversalVal[0] = (int*)malloc(1 * sizeof(int));
traversalNode[0][0] = root;
traversalVal[0][0] = root->val;
(*columnSizes)[0] = 1;
// 逐层计算
for(int height = 1; height < *returnSize; ++height)
{
// 分配内存
traversalNode[height] = (struct TreeNode**)malloc(2 * (*columnSizes)[height - 1] * sizeof(struct TreeNode*));
traversalVal[height] = (int*)malloc(2 * (*columnSizes)[height - 1] * sizeof(int));
// 根据上一层，计算当前层的节点指针与数据
int index = 0;
for(int lastIndex = 0; lastIndex < (*columnSizes)[height - 1]; ++lastIndex)
{
if(traversalNode[height - 1][lastIndex]->left)
{
traversalNode[height][index] = traversalNode[height - 1][lastIndex]->left;
traversalVal[height][index] = traversalNode[height - 1][lastIndex]->left->val;
++index;
}
if(traversalNode[height - 1][lastIndex]->right)
{
traversalNode[height][index] = traversalNode[height - 1][lastIndex]->right;
traversalVal[height][index] = traversalNode[height - 1][lastIndex]->right->val;
++index;
}
}
// 确定当前层的columnSize
(*columnSizes)[height] = index;
// 释放上一层的节点空间
free(traversalNode[height - 1]);
}
free(traversalNode);
return traversalVal;
}
int maxDepth(struct TreeNode *root)
{
if(!root)
{
return 0;
}
int leftDepth = maxDepth(root->left) + 1;
int rightDepth = maxDepth(root->right) + 1;
return leftDepth > rightDepth ? leftDepth : rightDepth;
}

难度并不大，只是指针用得比较多。二维变长数组就要两次解引用，如果元素还是指针的话，三个*看起来容易晕。

再有就是对int **columnSizes参数的使用，尤其是*和[]的优先级问题，[]是比*高的。所以先解引用再用下标的时候，一定要用括号把*括起来。如：(*columnSizes)[index]