二叉树的遍历算法（先序、中序、后序遍历）

💖The Begin💖点点关注，收藏不迷路💖

1、实现思想

1. 先序遍历（Pre-order Traversal）：

   • 从根节点开始，按照根节点-左子树-右子树的顺序递归遍历每个节点。
   • 实现思路：递归地对当前节点进行处理，先将当前节点的值加入结果列表，然后递归处理左子树和右子树。

2. 中序遍历（In-order Traversal）：

   • 从根节点开始，按照左子树-根节点-右子树的顺序递归遍历每个节点。
   • 实现思路：递归地对当前节点进行处理，在递归调用之前处理左子树，然后将当前节点的值加入结果列表，在递归调用之后处理右子树。

3. 后序遍历（Post-order Traversal）：

   • 从根节点开始，按照左子树-右子树-根节点的顺序递归遍历每个节点。
   • 实现思路：递归地对当前节点进行处理，在递归调用之前处理左子树，然后处理右子树，在最后将当前节点的值加入结果列表。

2、代码实现

package csdn;
import java.util.ArrayList;  // 导入 ArrayList 类，用于存储遍历结果
import java.util.List;       // 导入 List 接口，用于存储遍历结果

public class TreeNode {      // 定义 TreeNode 类
    int val;                 // 定义整型变量 val，用于存储节点的值
    TreeNode left;           // 定义左子节点
    TreeNode right;          // 定义右子节点

    TreeNode(int x) {        // 构造方法，初始化节点的值
        val = x;             // 将传入的参数 x 赋值给 val
    }

    // 用递归的方法进行先序遍历
    public void qianxuDigui(TreeNode treeNode, List<Integer> resultList) {  // 先序遍历方法，参数为当前节点和存储结果的列表
        if (treeNode != null) {                    // 如果当前节点不为空
            resultList.add(treeNode.val);          // 将当前节点的值添加到结果列表中（先访问根节点）
            qianxuDigui(treeNode.left, resultList);   // 递归遍历左子树
            qianxuDigui(treeNode.right, resultList);  // 递归遍历右子树
        }
    }

    // 用递归的方法进行中序遍历
    public void zhongxuDigui(TreeNode treeNode, List<Integer> resultList) {  // 中序遍历方法，参数为当前节点和存储结果的列表
        if (treeNode != null) {                     // 如果当前节点不为空
            zhongxuDigui(treeNode.left, resultList);  // 递归遍历左子树
            resultList.add(treeNode.val);           // 将当前节点的值添加到结果列表中（访问根节点）
            zhongxuDigui(treeNode.right, resultList); // 递归遍历右子树
        }
    }

    // 用递归的方法进行后序遍历
    public void houxuDigui(TreeNode treeNode, List<Integer> resultList) {  // 后序遍历方法，参数为当前节点和存储结果的列表
        if (treeNode != null) {                     // 如果当前节点不为空
            houxuDigui(treeNode.left, resultList);   // 递归遍历左子树
            houxuDigui(treeNode.right, resultList);  // 递归遍历右子树
            resultList.add(treeNode.val);           // 将当前节点的值添加到结果列表中（最后访问根节点）
        }
    }

    public static void main(String[] args) {       // 主方法
        // 构造一个二叉树示例
        TreeNode root = new TreeNode(1);           // 创建根节点，值为 1
        root.left = new TreeNode(2);               // 创建左子节点，值为 2
        root.right = new TreeNode(3);              // 创建右子节点，值为 3
        root.left.left = new TreeNode(4);          // 创建左子节点的左子节点，值为 4
        root.left.right = new TreeNode(5);         // 创建左子节点的右子节点，值为 5

        // 分别进行三种遍历
        List<Integer> resultList = new ArrayList<>();   // 创建用于存储遍历结果的列表
        TreeNode treeNode = new TreeNode(0);             // 创建 TreeNode 实例，用于调用遍历方法
        treeNode.qianxuDigui(root, resultList);          // 调用先序遍历方法
        System.out.println("先序遍历结果：" + resultList); // 打印先序遍历结果

        resultList.clear();                               // 清空结果列表
        treeNode.zhongxuDigui(root, resultList);          // 调用中序遍历方法
        System.out.println("中序遍历结果：" + resultList); // 打印中序遍历结果

        resultList.clear();                               // 清空结果列表
        treeNode.houxuDigui(root, resultList);            // 调用后序遍历方法
        System.out.println("后序遍历结果：" + resultList); // 打印后序遍历结果
    }
}

1. 先序遍历（Pre-order Traversal）：

   • 实现步骤：
     1. 从根节点开始，如果节点为空，则返回。
     2. 访问当前节点，并将其值添加到结果列表中。
     3. 递归地对左子树进行先序遍历。
     4. 递归地对右子树进行先序遍历。
   • 实现思想：递归地对树的每个节点进行处理，先处理当前节点，然后依次处理左子树和右子树。

2. 中序遍历（In-order Traversal）：

   • 实现步骤：
     1. 从根节点开始，如果节点为空，则返回。
     2. 递归地对左子树进行中序遍历。
     3. 访问当前节点，并将其值添加到结果列表中。
     4. 递归地对右子树进行中序遍历。
   • 实现思想：递归地对树的每个节点进行处理，在左子树处理完毕后处理当前节点，然后处理右子树。

3. 后序遍历（Post-order Traversal）：

   • 实现步骤：
     1. 从根节点开始，如果节点为空，则返回。
     2. 递归地对左子树进行后序遍历。
     3. 递归地对右子树进行后序遍历。
     4. 访问当前节点，并将其值添加到结果列表中。
   • 实现思想：递归地对树的每个节点进行处理，在处理完左右子树后再处理当前节点，然后将当前节点的值添加到结果列表中。

💖The End💖点点关注，收藏不迷路💖