递归与非递归实现二叉树的前序遍历、中序遍历、后序遍历。

二叉树图

 

定义

1. 前序遍历（Preorder Traversal）： 前序遍历的顺序是先访问根节点，然后按照先左后右的顺序访问子节点。对于上面的二叉树，前序遍历的结果是：4 -> 2 -> 1 -> 3 -> 6 -> 5 -> 7。

2. 中序遍历（Inorder Traversal）： 中序遍历的顺序是按照先左后根再右的顺序访问子节点。对于上面的二叉树，中序遍历的结果是：1 -> 2 -> 3 -> 4 -> 5 -> 6 -> 7。

3. 后序遍历（Postorder Traversal）： 后序遍历的顺序是按照先左后右再根的顺序访问子节点。对于上面的二叉树，后序遍历的结果是：1 -> 3 -> 2 -> 5 -> 7 -> 6 -> 4。

代码

public class BinaryTree {

    public static void main(String[] args) {
        int[] nums = {1, 2, 3, 4, 5, 6, 7};
        TreeNode root = TreeNode.buildTree(nums);
        System.out.print("前序遍历（递归）：");
        preorderTraversal(root);
        System.out.println();
        System.out.print("中序遍历（递归）：");
        inorderTraversal(root);
        System.out.println();
        System.out.print("后序遍历（递归）：");
        postorderTraversal(root);
        System.out.println();

        System.out.print("前序遍历（栈）：");
        preorderTraversal1(root);
        System.out.println();
        System.out.print("中序遍历（栈）：");
        inorderTraversal1(root);
        System.out.println();
        System.out.print("后序遍历（栈）：");
        postorderTraversal1(root);
        System.out.println();
    }

    //前序遍历(递归)
    public static void preorderTraversal(TreeNode root) {
        if (root == null) {
            return;
        }
        System.out.print(root.val + " "); // 访问根节点
        preorderTraversal(root.left); // 访问左子树
        preorderTraversal(root.right); // 访问右子树
    }

    // 中序遍历(递归)
    public static void inorderTraversal(TreeNode root) {
        if (root == null) {
            return;
        }
        inorderTraversal(root.left); // 访问左子树
        System.out.print(root.val + " "); // 访问根节点
        inorderTraversal(root.right); // 访问右子树
    }

    // 后序遍历(递归)
    public static void postorderTraversal(TreeNode root) {
        if (root == null) {
            return;
        }
        postorderTraversal(root.left); // 访问左子树
        postorderTraversal(root.right); // 访问右子树
        System.out.print(root.val + " "); // 访问根节点
    }


    // 前序遍历(栈)
    public static void preorderTraversal1(TreeNode root) {
        if (root == null) {
            return;
        }
        Stack<TreeNode> stack = new Stack<>();
        stack.push(root);
        while (!stack.isEmpty()) {
            TreeNode node = stack.pop();
            System.out.print(node.val + " "); // 打印当前节点的值
            if (node.right != null) {
                stack.push(node.right); // 先将右子节点入栈
            }
            if (node.left != null) {
                stack.push(node.left); // 再将左子节点入栈
            }
        }
    }

    // 中序遍历(栈)
    public static void inorderTraversal1(TreeNode root) {
        if (root == null) {
            return;
        }
        Stack<TreeNode> stack = new Stack<>();
        TreeNode node = root;
        while (node != null || !stack.isEmpty()) {
            while (node != null) {
                stack.push(node);
                node = node.left; // 先将左子节点入栈
            }
            node = stack.pop();
            System.out.print(node.val + " "); // 打印当前节点的值
            node = node.right; // 再处理右子节点
        }
    }

    // 后序遍历(栈)
    public static void postorderTraversal1(TreeNode root) {
        if (root == null) {
            return;
        }
        Stack<TreeNode> stack1 = new Stack<>();
        Stack<TreeNode> stack2 = new Stack<>();
        stack1.push(root);
        while (!stack1.isEmpty()) {
            TreeNode node = stack1.pop();
            if (node.left != null) {
                stack1.push(node.left); // 先将左子节点入栈
            }
            if (node.right != null) {
                stack1.push(node.right); // 再将右子节点入栈
            }
            stack2.push(node); // 将当前节点入栈（用于后序遍历）
        }
        while (!stack2.isEmpty()) {
            System.out.print(stack2.pop().val + " "); // 打印栈中的节点值（即后序遍历结果）
        }
    }
}

运行结果

前序遍历（递归）：4 2 1 3 6 5 7 
中序遍历（递归）：1 2 3 4 5 6 7 
后序遍历（递归）：1 3 2 5 7 6 4 
前序遍历（栈）：4 2 1 3 6 5 7 
中序遍历（栈）：1 2 3 4 5 6 7 
后序遍历（栈）：1 3 2 5 7 6 4