java中的二叉树遍历

---

前言

抛出几个问题
java中什么是二叉树？在java中怎么体现？怎么进行增删改查？
（最主要的遍历怎么遍历）有几种遍历方式

---

一、java中什么是二叉树：

展示：
          A
        /   \
       B     C
      / \   / \
     D   E  F  G

概念描述

二叉树

1. 每个节点最多有两个子树：在二叉树中，每个节点最多有两个子节点，通常被称为左子节点和右子节点。
2. 子树有左右之分：节点的两个子树被严格地区分为左子树和右子树，它们的顺序不能随意颠倒。
3. 树的层数可以不一致：在一个二叉树中，不同的节点处的子树高度可以不同，即树的各个部分的深度可以不一致。

二叉树的几种特殊形态包括：

1. 完全二叉树：除了最后一层外，其他各层的节点都达到了最大数目，并且最后一层的节点都连续地紧挨在左边。
2. 满二叉树：所有的层都达到了最大节点数目的二叉树，也就是说这是一个深度为k且有2^k - 1个节点的二叉树。
3. 平衡二叉树（AVL树）：任何节点的两个子树的高度最大差别为1，这样是为了防止树的高度过大，导致查询效率下降
4. 二叉搜索树（BST，Binary Search Tree）：对于每个节点来说，其左子树上的所有节点的值都小于它，而右子树上的所有节点的值都大于它，这样的性质使得二叉搜索树加快了查找的速度

二、使用步骤

1.java中怎么构建二叉树

public class TreeNode {
    int data;       // 节点数据
    TreeNode left;  // 左子节点
    TreeNode right; // 右子节点

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

2.怎么进行遍历

理论：

前序遍历（Pre-order Traversal)：
访问顺序为根节点 -> 左子树 -> 右子树。首先访问当前节点（根节点），然后递归地对左子树进行前序遍历，最后递归地对右子树进行前序遍历。

中序遍历（In-order Traversal）：
访问顺序为左子树 -> 根节点 -> 右子树。首先递归地对左子树进行中序遍历，然后访问当前节点（根节点），最后递归地对右子树进行中序遍历。

后序遍历（Post-order Traversal）：
访问顺序为左子树 -> 右子树 -> 根节点。首先递归地对左子树进行后序遍历，然后递归地对右子树进行后序遍历，最后访问当前节点（根节点）。

层序遍历（Level-order Traversal or Breadth-first Traversal）：
逐层从上到下，每一层从左到右访问所有节点。通常使用队列来实现。

理论详解：结合上文中的树结构

1、前序遍历：

访问A（根节点）
对节点B（左子树）应用前序遍历：
访问B
对节点D（左子树）应用前序遍历（访问D）
对节点E（右子树）应用前序遍历（访问E）
对节点C（右子树）应用前序遍历：
访问C
对节点F（左子树）应用前序遍历（访问F）
对节点G（右子树）应用前序遍历（访问G）
遍历结果：A, B, D, E, C, F, G

2、中序遍历：

对节点B（左子树）应用中序遍历：
对节点D（左子树）应用中序遍历（访问D）
访问B
对节点E（右子树）应用中序遍历（访问E）
访问A（根节点）
对节点C（右子树）应用中序遍历：
对节点F（左子树）应用中序遍历（访问F）
访问C
对节点G（右子树）应用中序遍历（访问G）
遍历结果：D, B, E, A, F, C, G

3、后序遍历：

对节点B（左子树）应用后序遍历：
对节点D（左子树）应用后序遍历（访问D）
对节点E（右子树）应用后序遍历（访问E）
访问B
对节点C（右子树）应用后序遍历：
对节点F（左子树）应用后序遍历（访问F）
对节点G（右子树）应用后序遍历（访问G）
访问C
访问A（根节点）
遍历结果：D, E, B, F, G, C, A

4、层序遍历：

访问第1层：A
访问第2层：B, C
访问第3层：D, E, F, G
遍历结果：A, B, C, D, E, F, G

这四种遍历方式各有其应用场景，
前序遍历：适合用来复制二叉树。
中序遍历：在二叉搜索树中会按照顺序访问节点，常用于排序任务。
后序遍历：适合用来执行先操作子节点，再操作父节点的任务，如树的删除操作。
层序遍历：能够按照树的层次结构逐层遍历，常用于寻找最短路径或进行分层次的分析。

---

上代码

第一步：定义二叉树的节点类

class TreeNode {
    public char value;
    public TreeNode left;
    public TreeNode right;

    public TreeNode(char value) {
        this.value = value;
    }
}

第二步：构建二叉树

public class BinaryTreeExample {
    // 构造树并返回根节点
    public static TreeNode buildTree() {
        TreeNode root = new TreeNode('A');
        root.left = new TreeNode('B');
        root.right = new TreeNode('C');
        root.left.left = new TreeNode('D');
        root.left.right = new TreeNode('E');
        root.right.left = new TreeNode('F');
        root.right.right = new TreeNode('G');
        return root;
    }
}

第三步：四种遍历方式

    // 前序遍历
    public static void preorderTraversal(TreeNode node) {
        if (node == null) {
            return;
        }
        System.out.print(node.value + " ");
        preorderTraversal(node.left);
        preorderTraversal(node.right);
    }
    // 中序遍历
    public static void inorderTraversal(TreeNode node) {
        if (node == null) {
            return;
        }
        inorderTraversal(node.left);
        System.out.print(node.value + " ");
        inorderTraversal(node.right);
    }

    // 后序遍历
    public static void postorderTraversal(TreeNode node) {
        if (node == null) {
            return;
        }
        postorderTraversal(node.left);
        postorderTraversal(node.right);
        System.out.print(node.value + " ");
    }

    // 层序遍历
    public static void levelOrderTraversal(TreeNode root) {
        if (root == null) {
            return;
        }

        Queue<TreeNode> queue = new LinkedList<>();
        queue.add(root);

        while (!queue.isEmpty()) {
            TreeNode node = queue.poll();
            System.out.print(node.value + " ");
            if (node.left != null) {
                queue.add(node.left);
            }
            if (node.right != null) {
                queue.add(node.right);
            }
        }
    }

第五步：Main函数执行

public class BinaryTreeExample {

    // 省略前面的定义...

    public static void main(String[] args) {
        // 构建二叉树
        TreeNode root = buildTree();

        // 执行遍历
        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("层序遍历：");
        levelOrderTraversal(root);
        System.out.println();
    }
}

描述

在BinaryTreeExample类中，我们首先实现了buildTree函数，这个函数基于TreeNode类创建节点并连接成我们所描述的特定二叉树。之后是四种不同的遍历方法。

preorderTraversal: 前序遍历函数首先访问根节点，然后递归地对左子树进行前序遍历，接着是右子树。
inorderTraversal: 中序遍历函数首先递归地对左子树进行中序遍历，然后访问根节点，最后递归地对右子树进行中序遍历。

postorderTraversal: 后序遍历函数首先递归地对左子树进行后序遍历，然后是右子树，最后访问根节点。

levelOrderTraversal: 层序遍历使用Queue（队列）来实现。首先将根节点放入队列，然后在队列不为空的情况下，不断地从队列中取出节点进行访问，并将该节点的左右子节点（如果有的话）依次放入队列。

最后，在main函数中我们构造了树并调用这些遍历方法，打印出每种遍历的结果。
当运行这个程序时，它将输出构造的二叉树按照前序、中序、后序和层序遍历的节点顺序。

3.怎么进行增删改

描述，首先不论是什么操作都得保证二叉树的结构不变：
进行增加的时候只能在子节点进行操作，或在根节点进行操作，应为要保持二叉树的完整结构
修改和删除则是要先找到修改和删除的节点，然后对齐进行操作，或者是对齐父节点和子节点进行操作，遍历是前提条件
代码在后续的文章中进行详细描述

总结

路虽远，行则将至，事虽难，作则必成