java递归查询树形结构

// 定义树节点类
class TreeNode {
    int id;
    int parentId;
    String name;
    List<TreeNode> children;

    public TreeNode(int id, int parentId, String name) {
        this.id = id;
        this.parentId = parentId;
        this.name = name;
        this.children = new ArrayList<>();
    }

    // 添加子节点的方法
    public void addChild(TreeNode child) {
        this.children.add(child);
    }
}

public class TreeService {

    // 递归查询树形结构的方法
    public static List<TreeNode> buildTree(List<TreeNode> nodes, int rootId) {
        List<TreeNode> tree = new ArrayList<>();
        for (TreeNode node : nodes) {
            if (node.parentId == rootId) {
                // 找到根节点，递归构建子树
                TreeNode rootNode = findNodeById(nodes, node.id);
                buildChildren(nodes, rootNode);
                tree.add(rootNode);
            }
        }
        return tree;
    }

    // 构建子树的递归方法
    private static void buildChildren(List<TreeNode> nodes, TreeNode parent) {
        for (TreeNode node : nodes) {
            if (node.parentId == parent.id) {
                // 找到子节点，递归构建其子树
                TreeNode childNode = findNodeById(nodes, node.id);
                parent.addChild(childNode);
                buildChildren(nodes, childNode);
            }
        }
    }

    // 根据ID查找节点
    private static TreeNode findNodeById(List<TreeNode> nodes, int id) {
        for (TreeNode node : nodes) {
            if (node.id == id) {
                return node;
            }
        }
        return null;
    }

    // 示例数据
    public static void main(String[] args) {
        List<TreeNode> nodes = Arrays.asList(
            new TreeNode(1, 0, "Root"),
            new TreeNode(2, 1, "Child 1"),
            new TreeNode(3, 1, "Child 2"),
            new TreeNode(4, 2, "Grandchild 1"),
            new TreeNode(5, 2, "Grandchild 2")
        );

        List<TreeNode> tree = buildTree(nodes, 0);
        printTree(tree, 0);
    }

    // 打印树形结构
    private static void printTree(List<TreeNode> nodes, int level) {
        for (TreeNode node : nodes) {
            System.out.println(" ".repeat(level * 4) + node.name);
            printTree(node.children, level + 1);
        }
    }
}

解释说明：

1. TreeNode 类：定义了树的节点，包含 id、parentId、name 和 children 属性。每个节点可以有多个子节点。
2. buildTree 方法：递归地构建树形结构。它从给定的节点列表中找到根节点，并调用 buildChildren 方法来递归地构建子树。
3. buildChildren 方法：递归地为每个父节点添加子节点，并继续为这些子节点构建它们的子树。
4. findNodeById 方法：根据 ID 查找节点。
5. main 方法：创建一个示例节点列表，并调用 buildTree 方法来构建树形结构，最后打印出树形结构。

通过这种方式，你可以递归地查询和构建树形结构。