颠仆流离学二叉树2 (Java篇)

二叉树作为数据结构中最为经典的树结构，在各类算法和数据处理问题中广泛应用。本文继续深入学习二叉树，介绍它的多种常见操作，如遍历、查找、插入与删除等操作，代码用 Java 来实现。我们通过代码实例，帮助你深入理解二叉树的基本操作。

一、二叉树基础回顾

首先，我们来回顾二叉树的基本结构。二叉树是一种每个节点最多有两个子节点的数据结构。常见的二叉树节点包含以下几个属性：

• value：存储节点的值。
• left：指向左子节点的指针。
• right：指向右子节点的指针。

下面是一个基本的二叉树节点类的定义：

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

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

二、二叉树的遍历

二叉树的遍历是对树中每个节点按照某种规则进行访问。常见的二叉树遍历方式有：

• 前序遍历（Preorder Traversal）：先访问根节点，然后访问左子树，最后访问右子树。
• 中序遍历（Inorder Traversal）：先访问左子树，然后访问根节点，最后访问右子树。
• 后序遍历（Postorder Traversal）：先访问左子树，然后访问右子树，最后访问根节点。
• 层次遍历（Level-order Traversal）：按层次逐层访问二叉树。

1. 前序遍历（Preorder Traversal）

public void preOrder(TreeNode node) {
    if (node == null) return;
    System.out.print(node.value + " ");
    preOrder(node.left);
    preOrder(node.right);
}

2. 中序遍历（Inorder Traversal）

public void inOrder(TreeNode node) {
    if (node == null) return;
    inOrder(node.left);
    System.out.print(node.value + " ");
    inOrder(node.right);
}

3. 后序遍历（Postorder Traversal）

public void postOrder(TreeNode node) {
    if (node == null) return;
    postOrder(node.left);
    postOrder(node.right);
    System.out.print(node.value + " ");
}

4. 层次遍历（Level-order Traversal）

层次遍历需要借助队列来完成：

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

public void levelOrder(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);
    }
}

三、二叉树的查找

在二叉树中查找节点是常见的操作，以下是查找值为 target 的节点的实现：

public TreeNode search(TreeNode root, int target) {
    if (root == null || root.value == target) {
        return root;
    }
    TreeNode leftSearch = search(root.left, target);
    if (leftSearch != null) return leftSearch;
    return search(root.right, target);
}

四、二叉树的插入

二叉树的插入操作会根据一定的规则将新节点插入到树中的某个位置。下面的例子展示了如何将一个新节点插入到树的空闲位置：

public TreeNode insert(TreeNode root, int value) {
    if (root == null) {
        return new TreeNode(value);
    }
    Queue<TreeNode> queue = new LinkedList<>();
    queue.add(root);
    
    while (!queue.isEmpty()) {
        TreeNode node = queue.poll();
        
        if (node.left == null) {
            node.left = new TreeNode(value);
            break;
        } else {
            queue.add(node.left);
        }
        
        if (node.right == null) {
            node.right = new TreeNode(value);
            break;
        } else {
            queue.add(node.right);
        }
    }
    return root;
}

五、二叉树的删除

删除二叉树中的节点稍微复杂一些，通常涉及找到要删除的节点，然后调整树的结构。以下是删除值为 key 的节点的代码：

public TreeNode delete(TreeNode root, int key) {
    if (root == null) return null;
    
    if (root.value == key && root.left == null && root.right == null) {
        return null;  // 如果是叶子节点，直接删除
    }
    
    Queue<TreeNode> queue = new LinkedList<>();
    queue.add(root);
    TreeNode keyNode = null, lastNode = null, lastNodeParent = null;
    
    // 查找 keyNode 以及最后一个节点 lastNode
    while (!queue.isEmpty()) {
        lastNodeParent = lastNode;
        lastNode = queue.poll();
        
        if (lastNode.value == key) {
            keyNode = lastNode;
        }
        
        if (lastNode.left != null) queue.add(lastNode.left);
        if (lastNode.right != null) queue.add(lastNode.right);
    }
    
    if (keyNode != null) {
        keyNode.value = lastNode.value;  // 用最后节点的值覆盖 keyNode
        if (lastNodeParent.left == lastNode) {
            lastNodeParent.left = null;
        } else {
            lastNodeParent.right = null;
        }
    }
    
    return root;
}

六、二叉树的深度

计算二叉树的深度是另一项常见的操作，深度表示从根节点到叶子节点的最长路径长度。

public int depth(TreeNode root) {
    if (root == null) return 0;
    return 1 + Math.max(depth(root.left), depth(root.right));
}

七、示例：完整二叉树操作流程

下面是一个完整的二叉树操作示例，它包括创建树、插入节点、遍历树等操作：

public class BinaryTreeDemo {
    public static void main(String[] args) {
        BinaryTreeDemo tree = new BinaryTreeDemo();
        TreeNode root = new TreeNode(1);
        root.left = new TreeNode(2);
        root.right = new TreeNode(3);
        root.left.left = new TreeNode(4);
        root.left.right = new TreeNode(5);

        // 前序遍历
        System.out.println("前序遍历：");
        tree.preOrder(root);

        // 插入新节点
        System.out.println("\n插入节点：");
        tree.insert(root, 6);
        tree.levelOrder(root);

        // 查找节点
        System.out.println("\n查找节点：");
        TreeNode searchNode = tree.search(root, 5);
        if (searchNode != null) {
            System.out.println("找到了节点：" + searchNode.value);
        }

        // 删除节点
        System.out.println("\n删除节点：");
        tree.delete(root, 3);
        tree.levelOrder(root);
    }
}

八、总结

本文介绍了二叉树的基本操作，包括遍历、查找、插入和删除等。通过这些基本操作的练习，你可以更深入地理解二叉树的结构和应用。特别是在实际项目中，二叉树是处理数据、构建索引、设计算法的基础结构之一，掌握它能够帮助你解决许多复杂的计算问题。