栈实现二叉树的前中后序遍历

迭代形式的前中后序遍历

前序遍历

LeetCode：前序遍历
节点入栈出栈顺序：1,2,3入栈，3出栈，2出栈，4入栈，4出栈，1出栈，5入栈，5出栈，6入栈，6出栈
前序遍历结果序列为：1 -> 2 -> 3 -> 4 -> 5 -> 6
节点入栈时将其加入到前序遍历结果序列。

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public List<Integer> preorderTraversal(TreeNode root) {
        List<Integer> ans = new ArrayList<>();
        if (root == null) {
            return ans;
        }
        Deque<TreeNode> d = new ArrayDeque<>();
        d.addLast(root);
        ans.add(root.val);
        root = root.left;
        while (!d.isEmpty() || root != null) {
            if (root == null) {
                root = d.pollLast().right;
                // System.out.println(root);
            } else {
                d.addLast(root);
                // System.out.println(1);
                ans.add(root.val);
                root = root.left;
            }
        }
        return ans;
    }
}

中序遍历

LeetCode：中序遍历
节点入栈出栈顺序：1,2,3入栈，3出栈，2出栈，4入栈，4出栈，1出栈，5入栈，5出栈，6入栈，6出栈
中序遍历的结果为：3,2,4,1,5,6
节点出栈时将其加入到中序遍历结果序列

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public List<Integer> inorderTraversal(TreeNode root) {
        List<Integer> ans = new ArrayList<>();
        if (root == null) {
            return ans;
        }
        Deque<TreeNode> d = new ArrayDeque<>();
        d.addLast(root);
        root = root.left;
        while (root != null || !d.isEmpty()) {
            if (root != null) {
                d.addLast(root);
                root = root.left;
            } else {
                root = d.pollLast();
                ans.add(root.val);
                root = root.right;
            }
        }
        return ans;
    }
}

后序遍历

LeetCode：后序遍历
后序遍历比前序遍历和后序遍历稍微特殊一点，后序遍历中每一个节点在第一次出栈并不会真正的出栈，而是往栈中压入一个标记变量（二次入栈），在访问到标记变量的时候，将它的下一个节点出栈并加入到后序遍历结果序列中。
节点入栈出栈顺序：1,2,3入栈，标记变量，3出栈，标记变量，4入栈，标记变量，4出栈，2出栈，标记变量，5入栈，标记变量，6入栈，标记变量，6出栈，5出栈，1出栈
后序遍历的结果为：3,4,2,6,5,1
节点在二次出栈时将其加入到后序遍历结果序列

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public List<Integer> postorderTraversal(TreeNode root) {
        List<Integer> ans = new ArrayList<>();
        if (root == null) {
            return ans;
        }
        Deque<TreeNode> d = new ArrayDeque<>();
        d.addLast(root);
        root = root.left;
        while (root != null || !d.isEmpty()) {
            if (root == null) {
                TreeNode r = d.peekLast();
                if (r.val == -100000) {
                    // System.out.println(d.pollLast().val);
                    d.pollLast();
                    ans.add(d.pollLast().val);
                    continue;
                }
                // System.out.println(d.size());
                d.addLast(new TreeNode(-100000));
                if (r.right != null) {
                    d.addLast(r.right);
                    root = r.right.left;
                }
            } else {
                d.addLast(root);
                root = root.left;
            }
        }
        return ans;
    }
}

实际上，前中后序遍历的本质是一样，就是要遍历完整颗树，不同的是生成结果的规则。