【算法积累】二叉树的层平均值&二叉树的后序遍历（非递归）

LeetCode 637. 二叉树的层平均值

难度 简单

给定一个非空二叉树, 返回一个由每层节点平均值组成的数组。

示例

输入：
    3
   / \
  9  20
    /  \
   15   7
输出：[3, 14.5, 11]
解释：
第 0 层的平均值是 3 ,  第1层是 14.5 , 第2层是 11 。因此返回 [3, 14.5, 11] 。

提示：节点值的范围在32位有符号整数范围内。

---

解法一 深度优先搜索 (Depth First Search, DFS)
深度优先搜索的关键在于解决“当前该怎么做”和“下一步怎么做”，通常的方法就是把每一种可能都去尝试一遍，一般使用for循环来遍历。当前这一步解决后，进入下一步，即dfs(step + 1)。至于下一步的解决方法，和当前这一步的解决方法是完全相同的。深度优先搜索算法的基本模型如下：

void dfs(int step) {
    // 判断边界
    ...
    
    // 尝试每一种可能
    for (int i = 1; i <= n; i++) {
        // 继续下一步
        dfs(step + 1);
    }
    
    // 返回
    return;
}

参考资料：《啊哈！算法》，啊哈磊著，人民邮电出版社

使用深度优先搜索计算二叉树的层平均值，需要建立数组cnts和sums，cnts用于存储二叉树的每一层的结点数，sums用于存储二叉树的每一层的节点值之和。搜索过程中需要记录当前结点所在层，如果访问到的节点在第i层，则将cnts[i]的值加1，并将该节点的值加到sums[i]。
语言：C

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


/**
 * Note: The returned array must be malloced, assume caller calls free().
 */

int cntsSize, sumsSize;

/* 使用深度优先搜索算法 */
void dfs(struct TreeNode* root, int level, int* cnts, double* sums) {
    if (root == NULL) {
        return;
    }
    if (level < sumsSize) {
        sums[level] += root->val;
        cnts[level] += 1;
    } else {
        sums[sumsSize] = (double)root->val;
        sumsSize++;
        cnts[cntsSize] = 1;
        cntsSize++;
    }
    dfs(root->left, level + 1, cnts, sums);
    dfs(root->right, level + 1, cnts, sums);
}

double* averageOfLevels(struct TreeNode* root, int* returnSize) {
    cntsSize = 0;
    sumsSize = 0;
    int* cnts = (int*)malloc(sizeof(int) * 1001);
    double* sums = (double*)malloc(sizeof(double) * 1001);
    dfs(root, 0, cnts, sums);
    double* aves = (double*)malloc(sizeof(double) * 1001);
    * returnSize = sumsSize;
    for (int i = 0; i < sumsSize; i++) {
        aves[i] = sums[i] / cnts[i];
    }
    return aves;
}

时间复杂度：$O(n)$；空间复杂度：$O(n)$。

解法二 广度优先搜索 (Breadth Firth Search, BFS)
主体思想还是从根结点开始搜索，每一轮遍历同一层的全部结点，计算该层的结点数以及该层的结点值之和，然后计算该层的平均值。广度优先搜索使用队列存储待访问结点，只要确保在每一轮遍历时，队列中的结点是同一层的全部结点即可确保每一轮遍历的是同一层的全部结点。初始时，将根结点加入队列；每一轮遍历时，将队列中的结点全部取出，计算这些结点的数量以及它们的结点值之和，并计算这些结点的平均值，然后将这些结点的全部非空子结点加入队列，重复上述操作直到队列为空，遍历结束。
语言：C

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


/**
 * Note: The returned array must be malloced, assume caller calls free().
 */
double* averageOfLevels(struct TreeNode* root, int* returnSize) {
    double* aves = (double*)malloc(sizeof(double) * 1001);
    struct TreeNode** queue = (struct TreeNode*)malloc(sizeof(struct TreeNode*) * 10001);
    * returnSize = 0;
    int queueLeft = 0, queueRight = 0;
    queue[queueRight] = root;
    queueRight++;
    while (queueLeft < queueRight) {
        double s = 0;
        int cnt = queueRight - queueLeft;
        for (int i = 0; i < cnt; i++) {
            struct TreeNode* node = queue[queueLeft];
            queueLeft++;
            s += node->val;
            struct TreeNode* left = node->left;
            struct TreeNode* right = node->right;
            if (left) {
                queue[queueRight] = left;
                queueRight++;
            }
            if (right) {
                queue[queueRight] = right;
                queueRight++;
            }
        }
        aves[(* returnSize)++] = s / cnt;
    }
    return aves;
}

时间复杂度：$O(n)$；空间复杂度：$O(n)$。

LeetCode 145. 二叉树的后序遍历（非递归）

难度 中等

给定一个二叉树，返回它的后序遍历。

示例

输入: [1,null,2,3]  
   1
    \
     2
    /
   3 

输出: [3,2,1]

---

解法 迭代
语言：C

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


/**
 * Note: The returned array must be malloced, assume caller calls free().
 */
int* postorderTraversal(struct TreeNode* root, int* returnSize) {
    int* ret = (int*)malloc(sizeof(int) * 1001);
    * returnSize = 0;
    if (root == NULL) {
        return ret;
    }
    struct TreeNode** stack = (struct TreeNode*)malloc(sizeof(struct TreeNode*) * 1001);
    int top = 0;
    struct TreeNode* pre = NULL;
    while (root || top > 0) {
        while (root) {
            stack[top] = root;
            top++;
            root = root->left;
        }
        top--;
        root = stack[top];
        if (root->right == NULL || root->right == pre) {
            ret[(* returnSize)++] = root->val;
            pre = root;
            root = NULL;
        } else {
            stack[top] = root;
            top++;
            root = root->right;
        }
    }
    return ret;
}

时间复杂度：$O(n)$，空间复杂度：$O(n)$。