力扣102题、107题（二叉树、层次遍历、较难）

102.给你一个二叉树，请你返回其按 层序遍历 得到的节点值。 （即逐层地，从左到右访问所有节点）。

1. 本来这是一个比较简单的题目，只需要通过一个队列就能到完成层次遍历了，但是题目非要你返回一个二维数组，同时还要记录层数跟每一层有多少个元素，这就是难点所在了。

这里需要用到另一个关于内存分配的函数realloc，用于调整返回的数组的大小。

realloc函数：

根据评论区题解写出以下代码，该题处理空间的分配的做法还是很有必要学习一下的。

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     struct TreeNode *left;
 *     struct TreeNode *right;
 * };
 */



int** levelOrder(struct TreeNode* root, int* returnSize, int** returnColumnSizes){
    int **res = NULL; //用于存储返回结果
    int *columnSize = NULL; //用于存储每一层有多少个节点
    struct TreeNode **queue = malloc(sizeof(struct TreeNode*) * 2000);                 
    struct TreeNode *pNode = NULL;
    int front = 0, rear = 0, pre_rear;
    *returnSize = 0; //用于记录层
    int i = 0; //用于记录每一层有多少个节点

    if (!root) {
        return NULL;
    }
    //入队根节点，队头指针跟队尾指针同时指向根节点
    queue[rear] = root;   

    //不断处理队列中的元素                                 
    while (front <= rear) {                                     
        pre_rear = rear;                                        
        //给res数组增加一个元素，即二叉树增加一层
        res = realloc(res, (*returnSize + 1)*sizeof(int *));           
        //res增加的元素指向一个整型数组，用于存放这一层的节点
        res[*returnSize] = malloc((pre_rear - front + 1) * sizeof(int));
        //遍历每一层的节点并将它们的孩子节点入队
        while(front <= pre_rear) {       
            //出队一个元素并记录它的值                      
            pNode = queue[front++];                             
            res[(*returnSize)][i++] = pNode->val;               
            //将出队的节点的孩子节点入队           
            if (pNode->left)                                    
                queue[++rear] = pNode->left;
            if (pNode->right)
                queue[++rear] = pNode->right;
        }
        columnSize = realloc(columnSize, (*returnSize + 1)*sizeof(int));  
        columnSize[(*returnSize)++] = i;
        i = 0;
    }
    *returnColumnSizes = columnSize;                          
    return res;                                             
}

---

107.给定一个二叉树，返回其节点值自底向上的层序遍历。 （即按从叶子节点所在层到根节点所在的层，逐层从左向右遍历）

1. 107题跟102题的做法是一样的，只不过最后再把结果反转一下就可以了。反转的代码也不难，由于结果数组是一个指针数组，把指针数组反转一下，同时把记录层数的数组也反转一下就行了。

/**
 * 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** levelOrderBottom(struct TreeNode* root, int* returnSize, int** returnColumnSizes){
    int **res = NULL;
    int *columnSizes = NULL;
    struct TreeNode* queue[2000];
    int front = 0, rear = 0, pre_rear;
    *returnSize = 0;
    int i = 0;
    struct TreeNode* p;

    if (!root) 
        return NULL;

    queue[rear] = root;
    while (front <= rear) {
        pre_rear = rear;
        res = realloc(res, (*returnSize + 1) * sizeof(int *));
        res[*returnSize] = malloc((pre_rear - front + 1) * sizeof(int));
        while (front <= pre_rear) {
            p = queue[front++];
            res[*returnSize][i++] = p->val;
            if (p->left != NULL)
                queue[++rear] = p->left;
            if (p->right != NULL) 
                queue[++rear] = p->right;  
        }
        columnSizes = realloc(columnSizes, (*returnSize + 1) * sizeof(int));
        columnSizes[(*returnSize)++] = i;
        i = 0;
    }
    int m = 0, n = *returnSize - 1;
    int *temp1;
    int temp2;
    while (m < n) {
        temp1 = res[m];
        res[m] = res[n];
        res[n] = temp1;

        temp2 = columnSizes[m];
        columnSizes[m] = columnSizes[n];
        columnSizes[n] = temp2;

        m++, n--;
    }
    *returnColumnSizes = columnSizes;

    return res;
}