如何通过递归找父节点或子节点详解_递归找到子节点-优快云博客

本文链接：https://blog.youkuaiyun.com/TreeShu321/article/details/121890877

本文介绍了如何使用递归查询在数据库中查找父节点和子节点。通过创建一个关系表`limit_mesh`存储节点关系，并提供了Java代码实现递归查找父节点和子节点的方法。示例中展示了查询`inst`的父节点和`cust`的子节点的过程，查询结果以图表形式展示。完整代码可在链接中获取。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

前言：如何通过递归去查询父节点或子节点，相信大家在平常肯定会遇到这样的需求，这一章我们就好好研究下如何用递归去找。

一、递归找父节点或子节点

1、根据下图我如何去找下图inst的父节点：inst->crlim->cust->custTotal

2、根据下图我如何去找下图cust的子节点：cust->crlim->inst、cash、instCash

二、创建一张表关系表保存上面的关系

带着上面的疑问，我们首先先创建一张关系表，把这些关系都存到表中。

CREATE TABLE `limit_mesh` (
  `id` int NOT NULL AUTO_INCREMENT,
  `parent_node` varchar(255) COLLATE utf8mb4_bin DEFAULT NULL,
  `child_node` varchar(255) COLLATE utf8mb4_bin DEFAULT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=9 DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_bin;

INSERT INTO `limit_mesh`(`id`, `parent_node`, `child_node`) VALUES (1, 'crilm', 'inst');
INSERT INTO `limit_mesh`(`id`, `parent_node`, `child_node`) VALUES (2, 'crilm', 'cash');
INSERT INTO `limit_mesh`(`id`, `parent_node`, `child_node`) VALUES (3, 'crilm', 'instCash');
INSERT INTO `limit_mesh`(`id`, `parent_node`, `child_node`) VALUES (4, 'cust', 'crilm');
INSERT INTO `limit_mesh`(`id`, `parent_node`, `child_node`) VALUES (5, 'custTotal', 'cust');
INSERT INTO `limit_mesh`(`id`, `parent_node`, `child_node`) VALUES (6, 'cust', 'splmt');
INSERT INTO `limit_mesh`(`id`, `parent_node`, `child_node`) VALUES (7, 'splmt', 'byj');
INSERT INTO `limit_mesh`(`id`, `parent_node`, `child_node`) VALUES (8, 'splmt', 'ygj');

三、递归查询父节点或子节点核心代码

其他代码这里就不详细来写了，只写我们递归的核心代码。

递归查询父节点核心代码

    /**
     * 递归找父节点
     * @param nodeNo
     * @return
     */
    public List<String> getLimitMeshParentList(String nodeNo) {
        List<String> parentList = new ArrayList<>();
        List<LimitMesh> limitMeshList = limitMeshService.getLimitMeshList();
        getParentNodeNo(limitMeshList,nodeNo,parentList);
        return parentList;
    }

    private List<String> getParentNodeNo(List<LimitMesh> limitMeshList,String nodeNo,List<String> parentList) {
        if (!parentList.contains(nodeNo)) {
            parentList.add(nodeNo);
        }
        List<String> parentRecursionList = getParentRecursionList(nodeNo,limitMeshList);
        if (CollectionUtils.isNotEmpty(parentRecursionList)) {
            if (!parentList.containsAll(parentRecursionList)) {
                parentList.addAll(parentRecursionList);
            }
            for (String str:parentRecursionList) {
                List<String> parentNodeNoList = getParentNodeNo(limitMeshList, str, parentList);
                if (!parentList.containsAll(parentNodeNoList)) {
                    parentList.addAll(parentNodeNoList);
                }
            }
        }
        return parentList;
    }

    private List<String> getParentRecursionList(String nodeNo, List<LimitMesh> limitMeshList) {
        return limitMeshList.stream().filter(limitMesh -> limitMesh.getChildNode().equals(nodeNo)).
                map(limitMesh -> limitMesh.getParentNode()).collect(Collectors.toList());
    }

递归查询子节点核心代码

     /**
     * 递归找子节点
     * @param nodeNo
     * @return
     */
    public List<String> getLimitMeshChildList(String nodeNo) {
        List<String> childList = new ArrayList<>();
        List<LimitMesh> limitMeshList = limitMeshService.getLimitMeshList();
        getChildNodeNo(limitMeshList,nodeNo,childList);
        return childList;
    }

    private List<String> getChildNodeNo(List<LimitMesh> limitMeshList, String nodeNo, List<String> childList) {
        if (!childList.contains(nodeNo)) {
            childList.add(nodeNo);
        }
        List<String> childRecursionList = getChildRecursionList(nodeNo,limitMeshList);
        if (CollectionUtils.isNotEmpty(childRecursionList)) {
            if (!childList.containsAll(childRecursionList)) {
                childList.addAll(childRecursionList);
            }
            for (String str:childRecursionList) {
                List<String> childNodeNoList = getChildNodeNo(limitMeshList, str, childList);
                if (!childList.containsAll(childNodeNoList)) {
                    childList.addAll(childNodeNoList);
                }
            }
        }
        return childList;
    }

    private List<String> getChildRecursionList(String nodeNo, List<LimitMesh> limitMeshList) {
        return limitMeshList.stream().filter(limitMesh -> limitMesh.getParentNode().equals(nodeNo)).
                map(limitMesh -> limitMesh.getChildNode()).collect(Collectors.toList());
    }