Given a binary tree, the node returns its bottom-up value hierarchy traversal. (Ie, by physical layer to the layer from the leaf nodes of the root node, layer by layer traversal from left to right)
For example:
given binary tree [3,9,20, null, null, 15,7 ],
3
/ \
9 20
/ \
15 7
Returns to its bottom-up hierarchy traversal is:
[
[15,7],
[9,20],
[3]
]
/**
* 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().
*/
void DFS(struct TreeNode* root,int* returnSize,int** returnColumnSizes,int target_size,int ***ret)
{
if(!root)return;
if(*returnSize<target_size)
{
*returnColumnSizes=(int *)realloc(*returnColumnSizes,sizeof(int )*target_size);
memmove((*returnColumnSizes)+1,*returnColumnSizes,sizeof(int)*(* returnSize));
(*returnColumnSizes)[0]=0;
*ret=(int **)realloc(*ret,sizeof(int *)*target_size);
memmove((*ret)+1,*ret,sizeof(int*)*(* returnSize));
(* ret)[0]=NULL;
(* returnSize)++;
}
(*returnColumnSizes)[(* returnSize)-target_size]++;
(* ret)[(* returnSize)-target_size]=(int *)realloc((* ret)[(* returnSize)-target_size],sizeof(int)*(*returnColumnSizes)[(* returnSize)-target_size]);
(* ret)[(* returnSize)-target_size][(*returnColumnSizes)[(* returnSize)-target_size]-1]=root->val;
DFS(root->left,returnSize,returnColumnSizes,target_size+1,ret);
DFS(root->right,returnSize,returnColumnSizes,target_size+1,ret);
}
int** levelOrderBottom(struct TreeNode* root, int* returnSize, int** returnColumnSizes){
int **ret=NULL;
* returnSize=0;
* returnColumnSizes=NULL;
DFS(root,returnSize,returnColumnSizes,1,&ret);
return ret;
}
When execution: 20 ms, beat the 57.35% of all users in C submission
Memory consumption: 17.7 MB, defeated 12.12% of all users in C submission