二叉树的三种遍历（递归和非递归、模板）

最新推荐文章于 2024-07-24 11:43:52 发布

原创最新推荐文章于 2024-07-24 11:43:52 发布 · 210 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#java #二叉树

本文详细讲解了如何使用递归和非递归方法实现二叉树的前序、中序、后序遍历，并展示了层次遍历的两种实现方式。通过实例代码演示了如何构造和操作二叉树，适合理解二叉树遍历算法的进阶学习。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

递归实现：

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

class TreeNode {
    int val;
    TreeNode left;
    TreeNode right;

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

public class Solution {

    private TreeNode createBinaryTree() {
        TreeNode root = new TreeNode(0);

        root.left = new TreeNode(1);
        root.left.left = new TreeNode(3);
        root.left.right = new TreeNode(4);
        root.right = new TreeNode(2);
        root.right.right = new TreeNode(5);

        return root;
    }

    public static void main(String[] args) {
        Solution test = new Solution();

        TreeNode root = test.createBinaryTree();

        test.preOrder(root);
        System.out.println("\n=============================================");
        test.midOrder(root);
        System.out.println("\n=============================================");
        test.postOrder(root);
        System.out.println("\n=============================================");
        test.levelOrder(root);
        System.out.println("\n=============================================");

    }

    // 前序遍历
    private void preOrder(TreeNode root) {
        if(root == null) return;

        System.out.print(root.val + " ");
        preOrder(root.left);
        preOrder(root.right);
    }

    // 中序遍历
    private void midOrder(TreeNode root) {
        if(root == null) return;

        midOrder(root.left);
        System.out.print(root.val + " ");
        midOrder(root.right);
    }

    // 后序遍历
    private void postOrder(TreeNode root) {
        if(root == null) return;

        postOrder(root.left);
        postOrder(root.right);
        System.out.print(root.val + " ");
    }

    // 层序遍历
    private void levelOrder(TreeNode root) {
        if(root == null) return;

        Queue<TreeNode> queue = new LinkedList<>();
        queue.offer(root);
        while(!queue.isEmpty()) {
            TreeNode t = queue.poll();
            if(t.left != null) queue.offer(t.left);
            if(t.right != null) queue.offer(t.right);

            System.out.print(t.val + " ");
        }
    }

}

输出：

非递归实现：

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

class TreeNode {
    int val;
    TreeNode left;
    TreeNode right;

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

public class Solution {

    private TreeNode createBinaryTree() {
        TreeNode root = new TreeNode(0);

        root.left = new TreeNode(1);
        root.left.left = new TreeNode(3);
        root.left.right = new TreeNode(4);
        root.right = new TreeNode(2);
        root.right.right = new TreeNode(5);

        return root;
    }

    public static void main(String[] args) {
        Solution test = new Solution();

        TreeNode root = test.createBinaryTree();

        test.preOrder(root);
        System.out.println("\n=============================================");
        test.midOrder(root);
        System.out.println("\n=============================================");
        test.postOrder(root);
        System.out.println("\n=============================================");
        test.levelOrder(root);
        System.out.println("\n=============================================");

    }

    // 前序遍历
    private void preOrder(TreeNode root) {

        Stack<TreeNode> stack = new Stack<>();
        while(!stack.isEmpty() || root != null) {
            while(root != null) {
                stack.push(root);
                System.out.print(root.val + " ");
                root = root.left;
            }

            if(!stack.isEmpty()) {
                root = stack.pop();
                root = root.right;
            }
        }
    }

    // 中序遍历
    private void midOrder(TreeNode root) {

        Stack<TreeNode> stack = new Stack<>();
        while(!stack.isEmpty() || root != null) {
            while(root != null) {
                stack.push(root);
                root = root.left;
            }

            if(!stack.isEmpty()) {
                root = stack.pop();
                System.out.print(root.val + " ");
                root = root.right;
            }
        }
    }

    // 后序遍历
    private void postOrder(TreeNode root) {

        Stack<TreeNode> stack = new Stack<>();
        Stack<Integer> ans = new Stack<>();
        while(!stack.isEmpty() || root != null) {
            while(root != null) {
                stack.push(root);
                ans.push(root.val);
                root = root.right;
            }

            if(!stack.isEmpty()) {
                root = stack.pop();
                root = root.left;
            }
        }
        
        while(!ans.isEmpty()) {
            System.out.print(ans.pop() + " ");
        }
    }

    // 层序遍历
    private void levelOrder(TreeNode root) {
        if(root == null) return;

        Queue<TreeNode> queue = new LinkedList<>();
        queue.offer(root);
        while(!queue.isEmpty()) {
            TreeNode t = queue.poll();
            if(t.left != null) queue.offer(t.left);
            if(t.right != null) queue.offer(t.right);

            System.out.print(t.val + " ");
        }
    }

}