leetcode[107]:Binary Tree Level Order Traversal II

最新推荐文章于 2020-01-03 13:57:10 发布

hahubaba

最新推荐文章于 2020-01-03 13:57:10 发布

阅读量219

点赞数

分类专栏： leetcode 文章标签： binary tree

本文链接：https://blog.csdn.net/hahubaba/article/details/46968003

版权

leetcode 专栏收录该内容

86 篇文章 0 订阅

订阅专栏

Binary Tree Level Order Traversal II
Given a binary tree, return the bottom-up level order traversal of its nodes’ values. (ie, from left to right, level by level from leaf to root).

For example:
Given binary tree {3,9,20,#,#,15,7},

return its bottom-up level order traversal as:

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

    int i, j;

    i=j=1;

    if(!root) return 0;
    if(root->left) i += maxDepth(root->left);
    if(root->right) j += maxDepth(root->right);

    if( i > j ) return i;

    return j;

}

int** levelOrderBottom(struct TreeNode* root, int** columnSizes, int* returnSize) {

    int res[1000][1000];
    int size[1000];
    struct TreeNode stack[10000];
    int i,ress,j,k,l,ll;
    int **result;

    l=maxDepth(root);

    if(!root) return NULL;
    result= (int**)malloc(sizeof(int*)*l);
    *columnSizes = (int*)malloc(sizeof(int*)*l);
    *returnSize = l;
    i=j=k=0;
    stack[0] = *root;
    size[l-1]=1;
    ll=1;
    ress=1;
    while(ll!=0)
    {
        ll=0;
        printf("%d",l-i-1);
        result[l-i-1] = (int*)malloc(sizeof(int*)*size[l-i-1]);

        for(j=0;j<size[l-i-1];j++)
        {
            result[l-i-1][j]=stack[k+j].val;

            if(stack[k+j].left) {ll++;stack[ress++]=*stack[k+j].left; }
            if(stack[k+j].right) {ll++;stack[ress++]=*stack[k+j].right;}
        }
        k += j;
        (*columnSizes)[l-i-1]=size[l-i-1];
        i++;
        size[l-i-1]=ll;
    }
     return result;

}