leetcode 145. 二叉树的后序遍历

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

示例:

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

输出: [3,2,1]
进阶: 递归算法很简单，你可以通过迭代算法完成吗？

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/binary-tree-postorder-traversal
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
递归法实现：

/**
 * 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().
 */

struct TreeNode *postorder(struct TreeNode *root, int *res, int *returnSize)
{
    if (root == NULL)
    {
        return NULL;
    }

    postorder(root->left, res, returnSize);
    postorder(root->right, res, returnSize);
    res[(*returnSize)++] = root->val;

    return root;
}

int *postorderTraversal(struct TreeNode *root, int *returnSize) {
    int *res = malloc(sizeof(int) * 2001);
    *returnSize = 0;

    postorder(root, res, returnSize);

    return res;
}

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def postorderTraversal(self, root: TreeNode) -> List[int]:
        ans = list()
        
        def postorder(root, ans):
            if not root:
                return None
            postorder(root.left, ans)
            postorder(root.right, ans)
            ans.append(root.val)

        postorder(root, ans)

        return ans

迭代法相对于递归法需要显示得去维护一个栈：
迭代算法实现：

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def postorderTraversal(self, root: TreeNode) -> List[int]:
        if not root:
            return None

        ans = list()
        stack = list()
        prev = None
        
        while root or stack:
            while root:
                stack.append(root)
                root = root.left
            
            root = stack.pop()
            if not root.right or root.right == prev:
                ans.append(root.val)
                prev = root
                root = None
            else:
                stack.append(root)
                root = root.right
            
        return ans

/**
 * 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 *res = malloc(sizeof(int) * 2001);
    *returnSize = 0;
    if (root == NULL) {
        return res;
    }

    struct TreeNode **stk = malloc(sizeof(struct TreeNode *) * 2001);
    int top = 0;
    struct TreeNode *prev = NULL;
    while (root != NULL || top > 0)
    {
        while (root != NULL)
        {
            stk[top++] = root;
            root = root->left;
        }

        root = stk[--top];
        if (root->right == NULL || root->right == prev)
        {
            res[(*returnSize)++] = root->val;
            prev = root;
            root = NULL;
        }
        else
        {
            root = stk[top++];
            root = root->right;
        }
    }

    return res;
}