树形结构根据子节点ID查找所有父节点ID

在树形结构或层级结构中，经常需要实现根据子节点ID查找所有父节点ID的功能。这通常涉及到递归或迭代遍历树结构，直到找到根节点为止。下面是一个简单的Java开发教程，介绍如何实现这个功能。

一、定义树节点

首先，我们需要定义一个树节点的类，它通常包含节点的ID、父节点ID以及子节点列表。

import java.util.ArrayList;  
import java.util.List;  
  
public class TreeNode {  
    private String id;  
    private String parentId;  
    private List<TreeNode> children;  
  
    public TreeNode(String id, String parentId) {  
        this.id = id;  
        this.parentId = parentId;  
        this.children = new ArrayList<>();  
    }  
  
    public String getId() {  
        return id;  
    }  
  
    public String getParentId() {  
        return parentId;  
    }  
  
    public List<TreeNode> getChildren() {  
        return children;  
    }  
  
    public void addChild(TreeNode child) {  
        children.add(child);  
    }  
}

二、构建树形结构

接下来，我们需要构建树形结构。这通常是通过读取数据库或配置文件中的数据来完成的。为了简化教程，这里我们手动创建一个简单的树形结构。

public class TreeBuilder {  
    public static TreeNode buildTree() {  
        // 创建根节点  
        TreeNode root = new TreeNode("1", null);  
  
        // 创建子节点  
        TreeNode child1 = new TreeNode("2", "1");  
        TreeNode child2 = new TreeNode("3", "1");  
        TreeNode grandChild = new TreeNode("4", "2");  
  
        // 构建树形结构  
        root.addChild(child1);  
        root.addChild(child2);  
        child1.addChild(grandChild);  
  
        return root;  
    }  
}

三、实现查找父节点ID的功能

现在，我们可以实现根据子节点ID查找所有父节点ID的功能。这可以通过递归遍历树形结构来实现。

import java.util.ArrayList;  
import java.util.List;  
  
public class ParentFinder {  
    public static List<String> findParentIds(TreeNode root, String childId) {  
        List<String> parentIds = new ArrayList<>();  
        findParentIdsRecursive(root, childId, parentIds);  
        return parentIds;  
    }  
  
    private static void findParentIdsRecursive(TreeNode node, String childId, List<String> parentIds) {  
        if (node == null) {  
            return;  
        }  
  
        for (TreeNode child : node.getChildren()) {  
            if (child.getId().equals(childId)) {  
                parentIds.add(node.getId());  
                if (node.getParentId() != null) {  
                    parentIds.add(node.getParentId()); // 添加当前节点的父节点ID  
                    findParentIdsRecursive(findParentNode(node.getParentId(), root), childId, parentIds); // 递归查找更上层的父节点  
                }  
                break;  
            } else {  
                findParentIdsRecursive(child, childId, parentIds); // 继续递归查找子节点  
            }  
        }  
    }  
  
    private static TreeNode findParentNode(String parentId, TreeNode root) {  
        if (root == null || root.getId().equals(parentId)) {  
            return root;  
        }  
        for (TreeNode child : root.getChildren()) {  
            TreeNode parent = findParentNode(parentId, child);  
            if (parent != null) {  
                return parent;  
            }  
        }  
        return null;  
    }  
}

四、测试功能

最后，我们可以编写一个简单的测试类来验证功能是否正确。

public class Main {  
    public static void main(String[] args) {  
        TreeNode root = TreeBuilder.buildTree();  
        List<String> parentIds = ParentFinder.findParentIds(root, "4");  
        System.out.println("父节点ID列表: " + parentIds); // 输出: [2, 1]  
    }  
}

这个教程展示了如何根据子节点ID查找所有父节点ID的基本思路。在实际应用中，你可能需要根据具体的业务需求和数据结构进行调整和优化。