通用树找父节点：广度优先遍历实现方法

本文详细介绍了在通用树中查找指定节点父节点的实用方法，着重讲解了如何利用**广度优先遍历（BFS）算法**高效实现。文章从通用树节点结构的定义入手，深入剖析了BFS算法的原理，并提供了清晰易懂的**Java代码示例**。通过使用队列来管理待访问节点，BFS能够逐层探索树的节点，快速定位目标节点的父节点。同时，文章还对算法的**时间复杂度和空间复杂度**进行了分析，并总结了注意事项，帮助读者全面掌握这一核心树操作技巧，为解决实际问题提供有力支持。无论是数据结构初学者还是经验丰富的开发者，都能从中受益。

1. 通用树节点结构定义

首先，我们定义通用树的节点结构。一个通用树的节点通常包含一个键（key）用于标识，以及一个子节点列表（children），因为通用树的每个节点可以拥有任意数量的子节点。

import java.util.ArrayList;

public class Node {
    int key; // 节点键值
    ArrayList<Node> children = new ArrayList<>(); // 存储子节点的列表

    /**
     * 判断当前节点是否有子节点。
     * 虽然在查找父节点的逻辑中不直接使用，但有助于理解节点特性。
     * @return 如果有子节点返回 true，否则返回 false。
     */
    public boolean hasChildren(){
        return !children.isEmpty(); // 更简洁的判断方式
    }
}

2. 查找父节点：广度优先遍历（BFS）原理

要查找一个指定键值（token）的节点的父节点，我们可以利用广度优先遍历（Breadth-First Search, BFS）算法。BFS 是一种逐层探索树或图的算法，非常适合解决需要查找最近关系或最短路径的问题，例如查找父节点。

算法核心思想： BFS 使用队列（Queue）来管理待访问的节点。它从根节点开始，先访问当前节点的所有子节点，然后将这些子节点加入队列，再从队列中取出下一个节点进行同样的操作，直到队列为空或找到目标。

在查找父节点的场景中，当我们从队列中取出一个节点 p（作为潜在的父节点）时，我们会遍历它的所有子节点 c。如果发现某个子节点 c 的键值与我们正在寻找的 token 匹配，那么当前的 p 就是我们目标节点的父节点，我们可以立即返回 p。如果 c 不匹配，我们就将 c 加入队列，以便在后续的迭代中将其作为潜在的父节点进行检查。

3. Java 实现

下面是基于上述原理的 Java 实现代码：

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

public class TreeOperations {

    /**
     * 在通用树中查找指定键值节点的父节点。
     * 使用广度优先遍历（BFS）实现。
     *
     * @param root 树的根节点。
     * @param token 要查找的子节点的键值。
     * @return 如果找到，返回目标节点的父节点；如果未找到或目标节点是根节点（无父节点），则返回 null。
     */
    public static Node findParent(Node root, int token) {
        // 如果树为空，或者根节点为空，直接返回null
        if (root == null) {
            return null;
        }

        // 使用LinkedList作为Queue的实现
        Queue<Node> queue = new LinkedList<>();
        queue.add(root); // 将根节点加入队列，作为遍历的起点

        // 广度优先遍历
        while (!queue.isEmpty()) {
            Node currentNode = queue.poll(); // 从队列中取出当前节点，它将作为潜在的父节点

            // 遍历当前节点的所有子节点
            for (Node child : currentNode.children) {
                // 如果子节点的键值与目标token匹配
                if (child.key == token) {
                    return currentNode; // 找到了，当前节点就是目标节点的父节点
                }
                // 如果子节点不匹配，将其加入队列，以便后续作为潜在的父节点进行检查
                queue.add(child);
            }
        }

        // 遍历完所有节点仍未找到，说明目标节点不存在或其是根节点（无父节点）
        return null;
    }

    public static void main(String[] args) {
        // 构建一个示例通用树
        //       1
        //      /|\
        //     2 3 4
        //    / \   \
        //   5   6   7
        Node root = new Node();
        root.key = 1;

        Node node2 = new Node(); node2.key = 2;
        Node node3 = new Node(); node3.key = 3;
        Node node4 = new Node(); node4.key = 4;
        root.children.add(node2);
        root.children.add(node3);
        root.children.add(node4);

        Node node5 = new Node(); node5.key = 5;
        Node node6 = new Node(); node6.key = 6;
        node2.children.add(node5);
        node2.children.add(node6);

        Node node7 = new Node(); node7.key = 7;
        node4.children.add(node7);

        // 测试查找
        Node parentOf6 = findParent(root, 6);
        if (parentOf6 != null) {
            System.out.println("节点 6 的父节点是: " + parentOf6.key); // 预期输出 2
        } else {
            System.out.println("未找到节点 6 的父节点。");
        }

        Node parentOf7 = findParent(root, 7);
        if (parentOf7 != null) {
            System.out.println("节点 7 的父节点是: " + parentOf7.key); // 预期输出 4
        } else {
            System.out.println("未找到节点 7 的父节点。");
        }

        Node parentOf1 = findParent(root, 1); // 根节点无父节点
        if (parentOf1 != null) {
            System.out.println("节点 1 的父节点是: " + parentOf1.key);
        } else {
            System.out.println("未找到节点 1 的父节点（或其是根节点）。"); // 预期输出 未找到...
        }

        Node parentOf99 = findParent(root, 99); // 不存在的节点
        if (parentOf99 != null) {
            System.out.println("节点 99 的父节点是: " + parentOf99.key);
        } else {
            System.out.println("未找到节点 99 的父节点。"); // 预期输出 未找到...
        }
    }
}

4. 复杂度分析

• 时间复杂度： O(N)，其中 N 是树中节点的总数。在最坏情况下，我们需要访问树中的所有节点才能找到目标节点的父节点（例如，目标节点是最后一个被访问的叶子节点，或者目标节点不存在）。每个节点最多被访问一次（入队一次，出队一次）。
• 空间复杂度： O(W)，其中 W 是树的最大宽度（即在任何一层中节点的最大数量）。在最坏情况下，例如一个完整的二叉树，最后一层的节点数量接近 N/2，此时队列中可能存储接近 N/2 个节点。对于一个高度为 H 的完美平衡树，空间复杂度为 O(N)。在极端情况下（例如，一个只有一层，包含所有子节点的扁平树），空间复杂度也是 O(N)。

5. 注意事项与总结

• 根节点的父节点： 根节点没有父节点。如果 token 恰好是根节点的键值，findParent 函数将返回 null，这符合逻辑。
• 目标节点不存在： 如果树中不存在与 token 匹配的节点，函数也将返回 null。
• BFS的优势： 对于查找父节点这类需要遍历所有可能路径的问题，BFS 能够确保我们按层级顺序发现节点，并且在找到第一个匹配项时立即返回，效率较高。
• 递归与迭代的选择： 尽管某些树遍历问题常采用递归（如深度优先遍历DFS），但对于查找父节点这类问题，广度优先遍历（BFS）通过迭代配合队列实现，通常更为直观和高效。当 currentNode 作为潜在父节点被处理时，其 child 如果匹配 token，那么 currentNode 立刻就是其父节点，这种层级关系在 BFS 中自然体现。而直接用递归（DFS）来查找父节点会更复杂一些，可能需要额外的参数来传递父节点信息或返回一个包含父子对的结果。

通过本教程，您应该已经掌握了在通用树中利用广度优先遍历查找指定节点父节点的方法。理解

好了，本文到此结束，带大家了解了《通用树找父节点：广度优先遍历实现方法》，希望本文对你有所帮助！关注golang学习网公众号，给大家分享更多文章知识！