Pre-order, in-order and post-order traversal of a binary tree

1. Introduction

Binary trees have three traversal methods: pre-order, in-order and post-order. 关注根的位置，便于理解先中后.

1️⃣ Pre-order traversal [root left and right]

1. visit the root node;
2. Traverse the left subtree recursively in preorder;
3. Use preorder recursion to traverse the right subtree.

Note: The branches of each node follow the above-mentioned access order, reflecting "recursive call"

2️⃣Inorder traversal [left root right]

1. Use inorder to traverse the left subtree;
2. visit the root node;
3. Traverse the right subtree in inorder.

3️⃣Post-order traversal: [left and right roots]

1. Use post-order recursion to traverse the left subtree;
2. Use post-order recursion to traverse the right subtree;
3. Visit the root node.

public class TreeNode {
    
    
    public TreeNode left;
    public TreeNode right;
    public Integer val;

    public TreeNode(int val) {
    
    
        this.val = val;
    }
}

Second, preorder traversal

public class PreorderTraversal {
    
    
    public List<Integer> preorder(TreeNode root){
    
    
        ArrayList<Integer> res = new ArrayList<>();
        accessTree(root,res);
        return res;
    }

    private void accessTree(TreeNode root, ArrayList<Integer> res) {
    
    
        if(root==null){
    
    
            return;
        }
        res.add(root.val);
        accessTree(root.left,res);
        accessTree(root.right,res);
    }

    public List<Integer> preorder02(TreeNode root){
    
    
        ArrayList<Integer> res = new ArrayList<>();
        Deque<TreeNode> stack=new LinkedList<>();
        while(root!=null||!stack.isEmpty()){
    
    
            while(root!=null){
    
    
                res.add(root.val);
                stack.push(root);
                root=root.left;
            }
            root=stack.pop();
            root=root.right;

        }
        return res;
    }

}

3. Inorder traversal

public class InorderTraversal {
    
    

    public List<Integer> inOrder(TreeNode root) {
    
    
        ArrayList<Integer> res = new ArrayList<>();
        accessTree(root, res);
        return res;
    }

    private void accessTree(TreeNode root, ArrayList<Integer> res) {
    
    
        if (root == null) {
    
    
            return;
        }
        accessTree(root.left, res);
        res.add(root.val);
        accessTree(root.right, res);
    }

    public List<Integer> inOrder02(TreeNode root) {
    
    
        ArrayList<Integer> res = new ArrayList<>();
        Deque<TreeNode> stack = new LinkedList<>();
        while (root != null || !stack.isEmpty()) {
    
    
            while (root != null) {
    
    
                stack.push(root);
                root = root.left;
            }
            root = stack.pop();
            res.add(root.val);
            root = root.right;

        }
        return res;
    }

}

Fourth, post-order traversal

public class PostorderTraversal {
    
    
    public List<Integer> postorder(TreeNode root) {
    
    
        ArrayList<Integer> res = new ArrayList<>();
        accessTree(root, res);
        return res;
    }

    private void accessTree(TreeNode root, ArrayList<Integer> res) {
    
    
        if (root == null) {
    
    
            return;
        }
        accessTree(root.left, res);
        accessTree(root.right, res);
        res.add(root.val);
    }

    public List<Integer> postorder02(TreeNode root) {
    
    
        ArrayList<Integer> res = new ArrayList<>();
        Deque<TreeNode> stack = new LinkedList<>();
        TreeNode preAccess = null;
        while (root != null || !stack.isEmpty()) {
    
    
            while (root != null) {
    
    
                stack.push(root);
                root = root.left;
            }
            root = stack.pop();
            if (root.right == null || root.right == preAccess) {
    
    
                res.add(root.val);
                preAccess = root;
                root = null;
            } else {
    
    
                stack.push(root);
                root = root.right;
            }
        }
        return res;
    }

}

5. Test

public static void main(String[] args) {
    
    
    TreeNode root = new TreeNode(0);
    TreeNode node1 = new TreeNode(1);
    TreeNode node2 = new TreeNode(2);
    TreeNode node3 = new TreeNode(3);
    TreeNode node4 = new TreeNode(4);
    TreeNode node5 = new TreeNode(5);

    root.left = node1;
    root.right = node2;
    node1.left = node3;
    node1.right = node4;
    node2.left = node5;

	//先序遍历【中左右】[0, 1, 3, 4, 2, 5]
    PreorderTraversal preorder = new PreorderTraversal();
    List<Integer> preorderRes = preorder.preorder(root);
    System.out.println(Arrays.toString(preorderRes.toArray()));
  
    //中序遍历【左中右】[3, 1, 4, 0, 5, 2]
    InorderTraversal inorder = new InorderTraversal();
    List<Integer> inorderRes = inorder.inOrder(root);
    System.out.println(Arrays.toString(inorderRes.toArray()));

    //后序遍历【左右中】[3, 4, 1, 5, 2, 0]
    PostorderTraversal postorder = new PostorderTraversal();
    List<Integer> postorderRes = postorder.postorder(root);
    System.out.println(Arrays.toString(postorderRes.toArray()));

}