leetcode102

/**

 * Definition for a binary tree node.

 * struct TreeNode {

 *     int val;

 *     struct TreeNode *left;

 *     struct TreeNode *right;

 * };

 */

 

int MaxDepth(struct TreeNode *root)

{

    if (root == NULL) {

        return 0;

    }

    int left = MaxDepth(root->left);

    int right = MaxDepth(root->right);

    return ((left >= right ? left : right) + 1);

}

 

void CalNums(struct TreeNode *root, int k, int *arr)

{

    if (root == NULL) {

        return;

    }

    arr[k] += 1;

    CalNums(root->left, k + 1, arr);

    CalNums(root->right, k + 1, arr); 

}

 

void CalRes(struct TreeNode *root, int k, int **ret, int *arr)

{

    if (root == NULL) {

        return;

    }

    ret[k][arr[k]++] = root->val;

    CalRes(root->left, k + 1, ret, arr);

    CalRes(root->right, k + 1, ret, arr);

    return;

 

}

 

/**

 * 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)

{

    int depth = MaxDepth(root);

    int *arr = (int*)malloc(sizeof(int) * depth);

    memset(arr, 0, sizeof(int) * depth);

    CalNums(root, 0, arr);

    int **ret = (int **)malloc(sizeof(int *) * depth);

    int i;

    for (i = 0; i < depth; i++) {

        ret[i] = (int *)malloc(sizeof(int) * arr[i]);

        arr[i] = 0;

    }

    CalRes(root, 0, ret, arr);

    *returnSize = depth;

    *returnColumnSizes = arr;

    return ret;

}