后序遍历非递归的自我理解

我们看一下递归的方法，来反推非递归的方法

1、递归方法

二叉树节点

class TreeNode {
    TreeNode left;
    TreeNode right;
    int val;
}

递归方法

class Solution {
	List<Integer> list = new ArrayList<Integer>();
    public List<Integer> postorderTraversal(TreeNode root) {
        if(root == null) return list;
        postorderTraversal(root.left);
        postorderTraversal(root.right);
        list.add(root.val);
        return list;
    }
}

2、非递归实现

我们按照递归的思路一步一步来，首先，第一个postorderTraversal(root.left);会一直递归去搜索最左边的一个，故而我们先写这一步，此时我们用一个stack去把所有找到的元素存下来，是为了后面回溯。

class Solution {
    public List<Integer> postorderTraversal(TreeNode root) {
        TreeNode cur = root;
        Stack<TreeNode> stack = new Stack<>();
        while (null != cur) {
            stack.push(cur);
            cur = cur.left;
        }
    }
}

此时我们栈里面就是1、2、4

然后我们找到最后一个左了，再看一下递归函数的主体：

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

左边到头了，转去搜索right。我们改一下函数

public List<Integer> postorderTraversal(TreeNode root) {
    TreeNode cur = root;
    Stack<TreeNode> stack = new Stack<>();  // 记录搜索路径，后面回溯
    List<Integer> result = new ArrayList<>(); // 输出元素的集合
    while (null != cur || !stack.isEmpty()) {
        if (null != cur) {
            stack.push(cur);
            cur = cur.left;
        } else {
            cur = stack.pop();
            if (null == cur.right) {
                result.add(cur.val); // 2.1发现右边没有了，则直接输出最左元素
                cur = null; // 2。2防止走到左元素的搜索
            } else {
                stack.push(cur); // 2.3最后一个左元素，有右节点，则再把它push回去
                cur = cur.right; // 2.4开始搜索最后一个左元素的右元素
            }
        }
    }
    
    return result;
}

2.1 表示我们搜索到最后一个左元素并且其没有右子元素的话，则直接输出。
2.4 此时我们把搜索元素替换为最后一个左元素的右子元素，这样右子元素就又开始新一轮的遍历。这样实际上我们的遍历就多做完了。
此时我们把最后一个左元素的右子元素遍历完，栈里面应该是1、2、4、8.
但是我们发现一个问题，这个只是一个向下搜索的过程，那么如何网上回溯呢？这就是为什么一开始用stack的原因，因为stack的pop过程就是一个回溯过程。
其实在上面1、2、4、8结果出来之后，我们就开始回溯了，此时取出8，发现8左右元素都是空，就直接输出8（最终后序遍历的第一个值）。此时stack就又变成了1、2、4。我们取出4，但是我们发现上面逻辑此时走不通了，因为4有右元素，从后序遍历的原理，我们可以这样思考，只要记录最后一个输出的元素，如果发现当前元素的右元素是最后一个输出的元素，那下就是输出的元素，就是其本身，此时4得以输出，故而我们又改代码

public List<Integer> postorderTraversal(TreeNode root) {
    TreeNode cur = root;
    TreeNode last = null;
    Stack<TreeNode> stack = new Stack<>();
    List<Integer> result = new ArrayList<>();
    while (null != cur || !stack.isEmpty()) {
        if (null != cur) {
            stack.push(cur);
            cur = cur.left;
        } else {
            cur = stack.pop();
            if (null == cur.right || cur.right == last) {
                result.add(cur.val);
                last = cur;
                cur = null; 
            } else {
                stack.push(cur); 
                cur = cur.right; 
            }
        }
    }

其他方法

 public List<Integer> postorderTraversal(TreeNode root) {
        Stack<TreeNode> stack1 = new Stack<TreeNode>();
        Stack<Integer> stack2 = new Stack<Integer>();
        stack1.push(root);
        while (!stack1.isEmpty()) {
            TreeNode node = stack1.pop();
            if (node != null) {
                stack2.push(node.val);
                stack1.push(node.left);
                stack1.push(node.right);
            }
        }
        List<Integer> results = new ArrayList<Integer>();
        while (!stack2.isEmpty()) {
            results.add(stack2.pop());
        }
        return results;
    }