二叉树非递归遍历

前提

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;
    }
}

// 构造二叉树
TreeNode node = new TreeNode(5);
node.right = new TreeNode(3);
TreeNode left = node.left = new TreeNode(1);
left.left = new TreeNode(2);
left.right = new TreeNode(4);

前序

    private static List<Integer> preorderTraversal(TreeNode head) {
        List<Integer> res = new ArrayList<>();
        if (head == null) {
            return res;
        }
        
        Stack<TreeNode> stack = new Stack<>();
        stack.push(head);
        while (!stack.isEmpty()) {
            TreeNode top = stack.pop();
            res.add(top.val);
            if (top.right != null) {
                stack.push(top.right);
            }
            if (top.left != null) {
                stack.push(top.left);
            }
        }
        System.out.println(res);
        return res;
    }

后序

private static List<Integer> postorderTraversal(TreeNode root) {

        List<Integer> res = new LinkedList<>();
        if (root == null) {
            return res;
        }
        Stack<TreeNode> stack = new Stack<>();
        stack.push(root);
        while (!stack.isEmpty()) {
            TreeNode top = stack.pop();
            res.add(0, top.val);
            if (top.left != null) {
                stack.push(top.left);
            }
            if (top.right != null) {
                stack.push(top.right);
            }
        }
        System.out.println(res);
        return res;
    }

中序

private static List<Integer>  inorderTraversal(TreeNode root) {
        List<Integer> res = new ArrayList<>();
        if (root == null) {
            return res;
        }
        Stack<TreeNode> stack = new Stack<>();

        while (root != null || !stack.isEmpty()) {
            if (root != null) {
                stack.push(root);
                root = root.left;
                continue;
            }
            TreeNode top = stack.pop();
            res.add(top.val);
            root = top.right;
        }
        System.out.println(res);
        return res;
    }

 附录

递归代码

public static List<Integer> res = new ArrayList<>();
private static List<Integer> preorderTraversalRecur(TreeNode head) {
  if (head == null) {
    return res;
  }
  // 这里放其他位置，就是前序/中序/后序遍历  
  res.add(head.val);
  preorderTraversalRecur(head.left);
  preorderTraversalRecur(head.right);
  return res;
}