Java遍历二叉树（前中后序递归、非递归遍历，层序遍历）

/*二叉树前中后序遍历递归、非递归，层序遍历*/

import java.util.LinkedList;
import java.util.Queue;
import java.util.Stack;

public class TreeTraversal {

    public static void main(String[] args) {
        TreeNode node = new TreeNode(0);
        TreeNode node1 = new TreeNode(1);
        TreeNode node2 = new TreeNode(2);
        TreeNode node3 = new TreeNode(3);
        TreeNode node4 = new TreeNode(4);
        node.left = node1;
        node.right = node2;
        node1.left = node3;
        node2.right = node4;

        TreeTraversal traversal = new TreeTraversal();
        // 前序遍历
        System.out.println("前序遍历：");
        traversal.pre(node);
        System.out.println();
        traversal.pre1(node);
        System.out.println();
        // 中序遍历
        System.out.println("中序遍历：");
        traversal.post(node);
        System.out.println();
        traversal.post1(node);
        System.out.println();
        // 后序遍历
        System.out.println("后续遍历：");
        traversal.after(node);
        System.out.println();
        traversal.after1(node);
        System.out.println();
        // 层序遍历
        System.out.println("层序遍历：");
        traversal.level(node);
        System.out.println();
    }

    // 前序 递归
    private void pre(TreeNode root) {
        if (root != null) {
            System.out.print(root.val);
            pre(root.left);
            pre(root.right);
        }
    }

    // 前序 非递归
    private void pre1(TreeNode root) {
        if (root == null) {
            return;
        }
        Stack<TreeNode> stack = new Stack<>();
        stack.push(root);
        while (!stack.empty()) {
            TreeNode temp = stack.pop();
            if (temp.right != null) {
                stack.push(temp.right);
            }
            if (temp.left != null) {
                stack.push(temp.left);
            }
            System.out.print(temp.val);
        }
    }

    // 中序 递归
    private void post(TreeNode root) {
        if (root != null) {
            post(root.left);
            System.out.print(root.val);
            post(root.right);
        }
    }

    // 中序 非递归
    private void post1(TreeNode root) {
        Stack<TreeNode> stack = new Stack<>();
        TreeNode temp = root;
        while (!stack.empty() || temp != null) {
            if (temp != null) {
                stack.push(temp);
                temp = temp.left;
            } else {
                temp = stack.pop();
                System.out.print(temp.val);
                temp = temp.right;
            }
        }
    }

    // 后序 递归
    private void after(TreeNode root) {
        if (root != null) {
            after(root.left);
            after(root.right);
            System.out.print(root.val);
        }
    }

    // 后序 非递归
    private void after1(TreeNode root) {
        if (root == null) {
            return;
        }
        Stack<TreeNode> stack1 = new Stack<>();
        Stack<TreeNode> stack2 = new Stack<>();
        stack1.push(root);
        while (!stack1.empty()) {
            TreeNode temp = stack1.pop();
            stack2.push(temp);
            if (temp.left != null) {
                stack1.push(temp.left);
            }
            if (temp.right != null) {
                stack1.push(temp.right);
            }
        }
        while (!stack2.empty()) {
            TreeNode temp = stack2.pop();
            System.out.print(temp.val);
        }
    }

    // 层序
    private void level(TreeNode root) {
        if (root == null) {
            return;
        }
        Queue<TreeNode> queue = new LinkedList<>();
        queue.offer(root);
        while (!queue.isEmpty()) {
            TreeNode temp = queue.poll();
            if (temp.left != null) {
                queue.offer(temp.left);
            }
            if (temp.right != null) {
                queue.offer(temp.right);
            }
            System.out.print(temp.val);
        }
    }

}

class TreeNode {
    int val = 0;
    TreeNode left = null;
    TreeNode right = null;

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

结果：