最好理解的二叉树前中后序遍历

面试被问二叉树后序遍历，用循环实现，没有写出来，在leetcode有很多很好的实现，但是不太好理解，以下这种思路是最好理解的一种了

public class OrderTraversal {
    /**
     * 前序遍历：
     * 实现思想：
     * 1. 获取到每个节点添加到结果列表并保存到栈中
     * 2. 继续对这个节点对左子节点重复过程1，直到左子节点为空
     * 3. 这时栈中都节点都是左子树，没有保存右子树，开始进行出栈，
     * 4. 对出栈的元素的右子节点重复过程1
     */
    public List<Integer> preorderTraversal(TreeNode root) {
        List<Integer> resultList = new ArrayList<>();
        Stack<TreeNode> stack = new Stack<>();
        TreeNode temp = root;
        while (temp != null || !stack.empty()) {
            if (temp != null) {
                resultList.add(temp.val);
                stack.push(temp);
                temp = temp.left;
            } else {
                TreeNode node = stack.pop();
                temp = node.right;
            }
        }
        return resultList;
    }

    /**
     * 中序遍历
     * 实现思想：
     * 1. 获取每个节点入栈
     * 2. 继续对这个节点的左子节点重复过程1，直到左节点的为空
     * 3. 因为保存到栈中的都是左子树，没有保存右子树，对栈节点出栈
     * 4. 把出栈的节点值添加到结果列表，并她到右子树重复过程1
     */
    public List<Integer> inorderTraversal(TreeNode root) {
        Stack<TreeNode> stack = new Stack<>();
        List<Integer> resultList = new ArrayList<>();
        TreeNode curr = root;
        while (curr != null || !stack.empty()) {
            if (curr != null) {
                stack.push(curr);
                curr = curr.left;
            } else {
                curr = stack.pop();
                resultList.add(curr.val);
                curr = curr.right;
            }
        }
        return resultList;
    }

    /**
     * 后续遍历
     * 实现思想：
     * 前序遍历和后序遍历之间的关系：
     * 前序遍历顺序为：根 -> 左 -> 右
     * 后序遍历顺序为：左 -> 右 -> 根
     * 如果1： 我们将前序遍历中节点插入结果链表尾部的逻辑，修改为将节点插入结果链表的头部
     * 那么结果链表就变为了：右 -> 左 -> 根
     * 如果2： 我们将遍历的顺序由从左到右修改为从右到左，配合如果1
     * 那么结果链表就变为了：左 -> 右 -> 根
     * 这刚好是后序遍历的顺序
     * 基于这两个思路，我们想一下如何处理：
     * 修改前序遍历代码中，节点写入结果链表的代码，将插入队尾修改为插入队首
     * 修改前序遍历代码中，每次先查看左节点再查看右节点的逻辑，变为先查看右节点再查看左节点
     * 想清楚了逻辑，就可以开始编写代码了，详细代码和逻辑注释如下：
     */
    public List<Integer> postorderTraversal(TreeNode root) {
        LinkedList<Integer> resultList = new LinkedList<>();
        Stack<TreeNode> stack = new Stack<>();
        TreeNode temp = root;
        while (temp != null || !stack.empty()) {
            if (temp != null) {
                //在队首插入元素
                resultList.addFirst(temp.val);
                stack.push(temp);
                temp = temp.right;
            } else {
                TreeNode node = stack.pop();
                temp = node.left;
            }
        }
        return resultList;
    }

    public class TreeNode {
        private int val;
        private TreeNode left;
        private TreeNode right;

        public TreeNode(int val, TreeNode left, TreeNode right) {
            this.val = val;
            this.left = left;
            this.right = right;
        }
    }
    
    public static void main(String[] args) {
        OrderTraversal orderTraversal = new OrderTraversal();
        orderTraversal.test();
    }

    public void test() {
        TreeNode left = new TreeNode(1, null, null);
        TreeNode right = new TreeNode(3, null, null);
        TreeNode root = new TreeNode(2, left, right);
        preorderTraversal(root).forEach(System.out::println);
    }

}