Java 递归实现树状数据查询：父子表结构遍历

Java 递归实现树状数据查询：父子表结构遍历

本文将介绍如何使用 Java 递归方法实现树状数据的查询和构建，以父子表为例，演示如何先查询所有父级节点，再递归查询子节点，构建树状数据结构。

数据结构

假设我们有一个父子表，包含以下字段：

• id: 节点 ID
• name: 节点名称
• code: 节点代码
• pid: 父节点 ID
• child: 子节点列表

实现步骤

1. 定义节点类

   首先定义一个 TreeNode 类，表示树的节点，包含 id、name、code、pid 和 child 属性。

   import java.util.ArrayList;
   import java.util.HashMap;
   import java.util.List;
   import java.util.Map;
   
   public class TreeNode {
       private int id;
       private String name;
       private String code;
       private int pid;
       private List<TreeNode> child;
   
       public TreeNode(int id, String name, String code, int pid) {
           this.id = id;
           this.name = name;
           this.code = code;
           this.pid = pid;
           this.child = new ArrayList<>();
       }
   
       public void addChild(TreeNode node) {
           this.child.add(node);
       }
   
       // getter 方法...
   }
   

2. 递归查询父级节点

   定义 queryParentNodes 方法，使用递归方法查询所有父级节点。

   // 递归查询所有父级节点
   public static List<TreeNode> queryParentNodes(List<TreeNode> nodes) {
       List<TreeNode> parents = new ArrayList<>();
       Map<Integer, TreeNode> nodeMap = new HashMap<>();
   
       // 将节点列表转换为以id为key的映射关系
       for (TreeNode node : nodes) {
           nodeMap.put(node.getId(), node);
       }
   
       // 遍历节点列表，找到所有根节点（pid为0的节点）
       for (TreeNode node : nodes) {
           if (node.getPid() == 0) {
               parents.add(node);
           } else {
               // 将非根节点添加到对应的父节点的child列表中
               TreeNode parent = nodeMap.get(node.getPid());
               parent.addChild(node);
           }
       }
   
       return parents;
   }
   

3. 递归查询子节点

   定义 queryChildNodes 方法，使用递归方法查询所有子节点。

   // 递归查询子节点
   public static void queryChildNodes(TreeNode node) {
       List<TreeNode> childNodes = node.getChild();
   
       for (TreeNode childNode : childNodes) {
           queryChildNodes(childNode);
       }
   }
   

4. 主函数测试

   在主函数中，创建测试数据，调用 queryParentNodes 方法查询所有父级节点，并使用 queryChildNodes 方法递归查询所有子节点。

   public static void main(String[] args) {
       // 假设有以下父子关系数据
       List<TreeNode> nodes = new ArrayList<>();
       nodes.add(new TreeNode(1, 'Parent1', 'P1', 0));
       nodes.add(new TreeNode(2, 'Child1', 'C1', 1));
       nodes.add(new TreeNode(3, 'Child2', 'C2', 1));
       nodes.add(new TreeNode(4, 'Parent2', 'P2', 0));
       nodes.add(new TreeNode(5, 'Child3', 'C3', 4));
   
       // 查询所有父级节点
       List<TreeNode> parents = TreeNode.queryParentNodes(nodes);
   
       // 输出所有父级节点
       for (TreeNode parent : parents) {
           System.out.println(parent.getName());
           TreeNode.queryChildNodes(parent);
           // 输出所有子节点
           for (TreeNode child : parent.getChild()) {
               System.out.println('--' + child.getName());
           }
       }
   }
   

输出结果

Parent1
--Child1
--Child2
Parent2
--Child3

总结

本文通过一个简单的父子表结构的例子，展示了如何使用 Java 递归方法实现树状数据的查询和构建。递归方法能够有效地遍历树形结构，并构建树状数据结构，适用于需要对父子关系数据进行查询和处理的场景。

注意：

• 本文代码示例仅供参考，实际应用中需要根据具体需求进行修改。
• 递归方法在处理大量数据时可能会导致栈溢出，需要谨慎使用。
• 可以使用非递归方法来代替递归方法，例如使用栈或队列来实现。