二叉树遍历方法详解：层序遍历、前序遍历、中序遍历和后序遍历

二叉树是计算机科学中常见的数据结构，广泛应用于各种算法和数据操作。遍历二叉树是操作二叉树的重要方法，其中层序遍历、前序遍历、中序遍历和后序遍历是四种基本的遍历方式。本文将详细讲解这四种遍历方法，并提供相应的代码示例。

二叉树节点定义

首先，我们定义一个二叉树节点类 TreeNode，用于表示二叉树中的每个节点。该类包含节点值、左子节点和右子节点的引用。

package org.example.tree;

import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;
import java.util.Queue;

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

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

    @Override
    public String toString() {
        return "" + val;
    }
}

层序遍历

层序遍历（也称为广度优先遍历）按照从上到下、从左到右的顺序访问二叉树的每一层节点。这种遍历方法使用队列来实现。

代码实现

public static List<TreeNode> levelOrder(TreeNode root){
    List<TreeNode> result = new ArrayList<>();
    if (root == null) {
        return result;
    }
    Queue<TreeNode> queue = new LinkedList<>();
    queue.add(root);
    while (!queue.isEmpty()) {
        TreeNode node = queue.poll();
        result.add(node);
        if (node.left != null) {
            queue.add(node.left);
        }
        if (node.right != null) {
            queue.offer(node.right);
        }
    }
    return result;
}

运行结果

levelOrder begin:
1
2
3
4
5
6
7

前序遍历

前序遍历的顺序是：根节点 -> 左子树 -> 右子树。这意味着我们首先访问根节点，然后递归访问左子树，最后递归访问右子树。

代码实现

public static List<TreeNode> preOrder(List<TreeNode> result, TreeNode node){
    if (result == null) {
        result = new ArrayList<>();
    }
    if (node == null) {
        return result;
    }
    result.add(node);
    if (node.left != null) {
        preOrder(result, node.left);
    }
    if (node.right != null) {
        preOrder(result, node.right);
    }
    return result;
}

运行结果

preOrder begin:
1
2
4
5
3
6
7

中序遍历

中序遍历的顺序是：左子树 -> 根节点 -> 右子树。这意味着我们首先递归访问左子树，然后访问根节点，最后递归访问右子树。

代码实现

public static List<TreeNode> inOrder(List<TreeNode> result, TreeNode node){
    if (result == null) {
        result = new ArrayList<>();
    }
    if (node.left != null) {
        inOrder(result, node.left);
    }
    result.add(node);
    if (node.right != null) {
        inOrder(result, node.right);
    }
    return result;
}

运行结果

inOrder begin:
4
2
5
1
6
3
7

后序遍历

后序遍历的顺序是：左子树 -> 右子树 -> 根节点。这意味着我们首先递归访问左子树，然后递归访问右子树，最后访问根节点。

代码实现

public static List<TreeNode> postOrder(List<TreeNode> result, TreeNode node){
    if (result == null) {
        result = new ArrayList<>();
    }
    if (node.left != null) {
        postOrder(result, node.left);
    }
    if (node.right != null) {
        postOrder(result, node.right);
    }
    result.add(node);
    return result;
}

运行结果

postOrder begin:
4
5
2
6
7
3
1

完整示例

以下是完整的代码示例，包括二叉树的构建和各种遍历方法的调用：

package org.example.tree;

import java.util.ArrayList;

public class binary_tree {
    public static void main(String[] args) {
        TreeNode n1 = new TreeNode(1);
        TreeNode n2 = new TreeNode(2);
        TreeNode n3 = new TreeNode(3);
        TreeNode n4 = new TreeNode(4);
        TreeNode n5 = new TreeNode(5);
        TreeNode n6 = new TreeNode(6);
        TreeNode n7 = new TreeNode(7);

        n1.left = n2;
        n1.right = n3;
        n2.left = n4;
        n2.right = n5;
        n3.left = n6;
        n3.right = n7;

        System.out.println("levelOrder begin:");
        TreeNode.levelOrder(n1).forEach(it -> System.out.println(it.val));
        
        System.out.println("preOrder begin:");
        TreeNode.preOrder(new ArrayList<>(), n1).forEach(it -> System.out.println(it.val));
        
        System.out.println("inOrder begin:");
        TreeNode.inOrder(new ArrayList<>(), n1).forEach(it -> System.out.println(it.val));
        
        System.out.println("postOrder begin:");
        TreeNode.postOrder(new ArrayList<>(), n1).forEach(it -> System.out.println(it.val));
    }
}

如何构建一个N层的完美二叉树？

class TreeNode {
    int value;
    TreeNode left;
    TreeNode right;

    TreeNode(int value) {
        this.value = value;
        this.left = null;
        this.right = null;
    }
}

public class FullBinaryTree {
    // 主函数，用于创建树并调用构建函数
    public static void main(String[] args) {
        int N = 3; // 指定树的层数
        TreeNode root = buildFullBinaryTree(1, N);
    }

    // 递归函数，用于构建满二叉树
    public static TreeNode buildFullBinaryTree(int currentLevel, int maxLevel) {
        if (currentLevel > maxLevel) return null;

        TreeNode node = new TreeNode(currentLevel); // 创建当前节点
        node.left = buildFullBinaryTree(currentLevel + 1, maxLevel); // 递归创建左子树
        node.right = buildFullBinaryTree(currentLevel + 1, maxLevel); // 递归创建右子树
        return node;
    }
}

解析

• 使用递归方法来构建树。
• 给定层数N，从1开始，直到N。
• 对于每个节点，创建其左右子节点，直到达到指定的层数