145. 二叉树的后序遍历

深度优先搜索

class Solution {

    List list = new LinkedList();

    public List<Integer> postorderTraversal(TreeNode root) {

        if (root == null){
            return list;
        }

        postorderTraversal(root.left);
        postorderTraversal(root.right);
        list.add(root.val);

        return list;
    }
}

/**
 * 时间复杂度 O(n)
 * 空间复杂度 O(n)
 */

迭代

只需要将前序遍历里左右孩子进栈的顺序换一个，变成中右左，最后将得到的数组反转，就得到了左右中，也即后序遍历的结果

import java.util.ArrayList;
import java.util.List;
import java.util.Stack;

class Solution {

    List<Integer> list = new ArrayList<>();

    public List<Integer> postorderTraversal(TreeNode root) {

        if (root == null){
            return list;
        }

        /**
         * 迭代实现后序遍历
         * 将根节点压入栈后，开始循环（显式栈）
         * 先弹出根节点，记录值，然后依次压入左孩子和又孩子（如果存在的话），依次类推，直到栈空
         * 最后将得到的数组反转即可
         */
        Stack<TreeNode> stack = new Stack<>();

        stack.push(root);

        while (!stack.isEmpty()){

            TreeNode temp = stack.pop();
            list.add(temp.val);

            if (temp.left != null){
                stack.push(temp.left);
            }

            if (temp.right != null){
                stack.push(temp.right);
            }
        }

        Collections.reverse(list);
        
        return list;
    }
}

/**
 * 时间复杂度 O(n)
 * 空间复杂度 O(n)
 */

统一迭代写法

import java.util.ArrayList;
import java.util.List;
import java.util.Stack;

class Solution {

    List<Integer> list = new ArrayList<>();

    public List<Integer> postorderTraversal(TreeNode root) {

        if (root == null){
            return list;
        }

        Stack<Command> stack = new Stack<>();

        /**
         * 首先压入根节点，但不进行打印
         */
        stack.push(new Command(false, root));

        while (!stack.isEmpty()){

            /**
             * 每次弹出栈顶节点进行判断
             * 如果是上一轮的根节点，就打印；否则按不同顺序压入其左右孩子和本身
             */
            Command command = stack.pop();

            if (command.isPrint){
                list.add(command.node.val);
            }
            else {

                /**
                 * 后序遍历
                 * 先将根节点压入栈，再将右孩子和左孩子压入栈，让弹出的顺序变为左孩子、右孩子、根节点
                 * 其中根节点的isPrint == true
                 */
                stack.push(new Command(true, command.node));
                
                if (command.node.right != null){
                    stack.push(new Command(false, command.node.right));
                }

                if (command.node.left != null){
                    stack.push(new Command(false, command.node.left));
                }
            }
        }

        return list;
    }
}

/**
 * 为了像递归写法一样统一前中后序遍历，将压入栈的元素定义为一个Command类
 * 其中包含要处理的当前节点，还有要进行的操作
 * isPrint == true代表将当前节点的值打印出来，添加进列表，否则就遍历到其左右孩子
 */
class Command{

    Boolean isPrint;
    TreeNode node;
    Command(Boolean isPrint, TreeNode node){

        this.isPrint = isPrint;
        this.node = node;
    }
}

/**
 * 时间复杂度 O(n)
 * 空间复杂度 O(n)
 */

https://leetcode-cn.com/problems/binary-tree-postorder-traversal/