Java递归子集算法（树状结构）的逻辑和实例代码实现 @杨章隐

已于 2022-09-19 11:14:45 修改
阅读量705 收藏 2
点赞数
分类专栏： 算法 springboot2.0 文章标签： jvm
于 2022-09-05 14:33:04 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_41719650/article/details/126704637
版权

Java递归算法（树状结构）的逻辑和实例

1、应用场景：
递归算法作为一个经常使用的算法，无论在API开发还是计算文件夹都是比较常用的，
在api开发过程中我们经常遇到需要返回树状结构的json
例如权限树和部门归属等
这个时候我们就需要编写相关的递归算法

需求背景：之前的公司的权限模块一直是个空白（管理后台）

{
    "code": "200",
    "data": [
        {
            "index": "2",
            "pid": "0",
            "id": "2",
            "title": "课程",
            "icoc": ""
        },
        {
            "index": "dashboard",
            "pid": "0",
            "id": "1",
            "title": "控制台",
            "icoc": ""
        },
        {
            "subs": [
                {
                    "index": "studentList",
                    "pid": "4",
                    "id": "11",
                    "title": "学生列表",
                    "icoc": ""
                },
                {
                    "index": "studentApplyList",
                    "pid": "4",
                    "id": "12",
                    "title": "学生申请列表",
                    "icoc": ""
                }
            ],
            "index": "4",
            "pid": "0",
            "id": "4",
            "title": "学生",
            "icoc": ""
        },
        {
            "subs": [
                {
                    "index": "teacherApplyList",
                    "pid": "3",
                    "id": "13",
                    "title": "老师申请列表",
                    "icoc": ""
                },
                {
                    "index": "teacherList",
                    "pid": "3",
                    "id": "14",
                    "title": "老师列表",
                    "icoc": ""
                }
            ],
            "index": "3",
            "pid": "0",
            "id": "3",
            "title": "老师",
            "icoc": ""
        },
        {
            "subs": [
                {
                    "subs": [
                        {
                            "subs": [
                                {
                                    "subs": [
                                        {
                                            "index": "22",
                                            "pid": "20",
                                            "id": "22",
                                            "title": "增加用户一个111",
                                            "icoc": ""
                                        }
                                    ],
                                    "index": "20",
                                    "pid": "17",
                                    "id": "20",
                                    "title": "增加一个用户",
                                    "icoc": ""
                                },
                                {
                                    "index": "21",
                                    "pid": "17",
                                    "id": "21",
                                    "title": "增加两个用户",
                                    "icoc": ""
                                }
                            ],
                            "index": "17",
                            "pid": "9",
                            "id": "17",
                            "title": "增加",
                            "icoc": ""
                        },
                        {
                            "index": "18",
                            "pid": "9",
                            "id": "18",
                            "title": "删除",
                            "icoc": ""
                        },
                        {
                            "index": "19",
                            "pid": "9",
                            "id": "19",
                            "title": "修改",
                            "icoc": ""
                        }
                    ],
                    "index": "classList",
                    "pid": "5",
                    "id": "9",
                    "title": "班级列表",
                    "icoc": ""
                },
                {
                    "index": "finishList",
                    "pid": "5",
                    "id": "10",
                    "title": "完结班级",
                    "icoc": ""
                }
            ],
            "index": "5",
            "pid": "0",
            "id": "5",
            "title": "班级",
            "icoc": ""
        },
        {
            "subs": [
                {
                    "index": "collectionRecord",
                    "pid": "6",
                    "id": "7",
                    "title": "收款记录",
                    "icoc": ""
                },
                {
                    "index": "drawbackRecord",
                    "pid": "6",
                    "id": "8",
                    "title": "退款记录",
                    "icoc": ""
                }
            ],
            "index": "6",
            "pid": "0",
            "id": "6",
            "title": "财务",
            "icoc": ""
        }
    ],
    "message": "请求成功",
    "success": true,
    "token": null,
    "encrypt": false,
    "timestamp": 1545443453404
}

2、实现思路：
首先我们先找到一级集合
接下来就是循环遍历归属一级集合的子集
通过反复调用自身方法循环输出归属上级集合的下级集合

3、具体实例：

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

public class RightHelper{
    public static void main(String[] args) {
        List<Map<Object, Object>> list = new ArrayList<Map<Object, Object>>();
        Map<Object, Object> map1 = new HashMap<>();
        map1.put("name", "班级管理");
        map1.put("pid", "0");
        map1.put("id", "1");
        Map<Object, Object> map2 = new HashMap<>();
        map2.put("pid", "1");
        map2.put("id", "2");
        map2.put("name", "班级管理权限1");
        Map<Object, Object> map3 = new HashMap<>();
        map3.put("name", "班级管理权限2");
        map3.put("pid", "1");
        map3.put("id", "3");
        Map<Object, Object> map4 = new HashMap<>();
        map4.put("name", "班级管理权限1增加");
        map4.put("pid", "2");
        map4.put("id", "5");
        
        list.add(map1);
        list.add(map2);
        list.add(map3);
        list.add(map4);
        map4 = new HashMap<>();
        map4.put("name", "教师管理");
        map4.put("pid", "0");
        map4.put("id", "6");
        list.add(map4);
        System.out.println(RightHelper.test(list, 0));
        

    }
    
    
    public static List<Map<Object, Object>> test(List<Map<Object, Object>> list,int classs){
            List<Map<Object, Object>> maplist1 = new ArrayList<>();
            List<Map<Object, Object>> maplist2 = new ArrayList<>();
            for(Map<Object, Object> map :list) {
                if(map.get("pid").toString().equals(String.valueOf(classs))) {
                    maplist1.add(map);
                }else {
                    maplist2.add(map);
                }
            }
            List<Map<Object, Object>> result = new ArrayList<>();
            
            for(Map<Object, Object> map :maplist1) {
                Map<Object, Object> maps = new HashMap<>();
                map.put("subs", RightHelper.test(maplist2,Integer.parseInt(map.get("id").toString())));
                result.add(map);
            }
            return result;
    }
    
}

4、优化版本

简化掉不必要的树状结构迭代还有不必要的操作，关注树状结构本身。

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

public class RightHelper{
    public static void main(String[] args) {
        List<Map<Object, Object>> list = new ArrayList<Map<Object, Object>>();
        Map<Object, Object> map1 = new HashMap<>();
        map1.put("name", "班级管理");
        map1.put("pid", "0");
        map1.put("id", "1");
        Map<Object, Object> map2 = new HashMap<>();
        map2.put("pid", "1");
        map2.put("id", "2");
        map2.put("name", "班级管理权限1");
        Map<Object, Object> map3 = new HashMap<>();
        map3.put("name", "班级管理权限2");
        map3.put("pid", "1");
        map3.put("id", "3");
        Map<Object, Object> map4 = new HashMap<>();
        map4.put("name", "班级管理权限1增加");
        map4.put("pid", "2");
        map4.put("id", "5");
        
        list.add(map1);
        list.add(map2);
        list.add(map3);
        list.add(map4);
        map4 = new HashMap<>();
        map4.put("name", "教师管理");
        map4.put("pid", "0");
        map4.put("id", "6");
        list.add(map4);
        System.out.println(RightHelper.test(list, 0, "pid"));
        

    }
    
    
    
    /**
     * explain: 遍历递归优化
     * <p>demand: 无
     * @version:  1.0
     * @author: Zing
     * @date: 2018年12月01日
     * @param list 遍历的集合
     * @param pid 关联父集合的id(当然也按照你们公司的规定)
     * @param name 关系父集合id名
     * @return
     */
    public static List<Map<Object, Object>> test(List<Map<Object, Object>> list,int pid,String name){
            List<Map<Object, Object>> maplist1 = new ArrayList<>();
            List<Map<Object, Object>> maplist2 = new ArrayList<>();
            for(Map<Object, Object> map :list) {
                if(map.get(name).toString().equals(String.valueOf(pid))) {
                    maplist1.add(map);
                }else {
                    maplist2.add(map);
                }
            }
            List<Map<Object, Object>> result = new ArrayList<>();
            
            for(Map<Object, Object> map :maplist1) {
                Map<Object, Object> maps = new HashMap<>();
                map.put("subs", RightHelper.test(maplist2,Integer.parseInt(map.get("id").toString()),"pid"));
                result.add(map);
            }
            return result;
    }
    
}

杨章隐
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
java 递归原理_JAVA算法之递归
weixin_28725553的博客
02-16 420
Ⅰ、三角数字首先我们来看一组数字：1,3,6,10,15,21.....，在这个数列中第n项是由n-1项加n得到的，这个序列中的数字称为三角数字因为他们可以形象化地表示成一个三角形排列。如下图通过上面的图首先我们就可以想到使用循环来查找第n项的数值，下面代码就是从高度为n的列加到高度为1的列int triangle(intn){int total = 0;while(n>0){total= ...
1123581321递归算法java_经典算法设计方法
weixin_32498069的博客
02-27 779
本文转自博客园一、什么是算法算法是一系列解决问题的清晰指令，也就是说，能够对一定规范的输入，在有限时间内获得所要求的输出。算法常常含有重复的步骤和一些比较或逻辑判断。如果一个算法有缺陷，或不适合于某个问题，执行这个算法将不会解决这个问题。不同的算法可能用不同的时间、空间或效率来完成同样的任务。一个算法的优劣可以用空间复杂度与时间复杂度来衡量。算法的时间复杂度是指算法需要消耗的时间资源。一般来说，计...
用Java集合递归实现通用树Tree
11-28
不要分，要的是人气！资源很给力的！欢迎下载！
java算法实例详解_java递归算法的实例详解
weixin_39934613的博客
02-16 351
递归三要素：1、明确递归终止条件；2、给出递归终止时的处理办法；3、提取重复的逻辑，缩小问题规模。1、1+2+3+…+nimport java.util.Scanner;public class Recursion {public static void main(String[] args) {Scanner in = new Scanner(System.in);int n = in.next...
Java递归以及根据节点取子集合
最新发布
weixin_45817985的博客
07-03 178
Java递归以及根据节点取子集合
java使用递归对树结构进行操作
weixin_43983286的博客
02-22 620
【代码】java使用递归对树结构进行操作。
Java创建树形结构算法实例
dexianduo8217的博客
06-11 178
在JavaWeb的相关开发中经常会涉及到多级菜单的展示，为了方便菜单的管理需要使用数据库进行支持，本例采用相关算法讲数据库中的条形记录进行相关组装和排序讲菜单组装成树形结构。 首先是需要的JavaBean 1 2 3 import java.io.Serializable; 4 import java.util.ArrayList; 5 impor...
subset-sum:使用递归回溯实现子集和问题
06-13
使用递归回溯实现子集和问题。 作为提供实现SubsetSum类包中包含的io.gitbub.thehappybug.Algorithms 。 编译 可以使用make工具编译项目： $ make javac io/github/thehappybug/Algorithms/SubsetSum.java 跑步 ...
基于java实现的 决策树之 ID3 算法
04-25
在本案例中，我们将探讨如何用Java实现ID3算法，这是一种早期的决策树学习算法，由Ross Quinlan于1986年提出。 ID3（Iterative Dichotomiser 3）算法基于信息熵和信息增益来选择最优特征进行分裂。信息熵是度量数据...
深入Java递归实现：回溯算法的递归机制与实例深入分析
[深入Java递归实现：回溯算法的递归机制与实例深入分析](https://media.geeksforgeeks.org/wp-content/uploads/20230626174919/Recursion-Algorithm.png) # 1. 回溯算法概述与递归基础 ## 1.1 回溯算法简介 回溯...
java用递归算法删除树节点_Java删除二叉搜索树的任意元素的方法详解
weixin_42300113的博客
02-28 1016
本文实例讲述了Java删除二叉搜索树的任意元素的方法。分享给大家供大家参考，具体如下：一.删除思路分析在删除二叉搜索树的任意元素时，会有三种情况：1.1 删除只有左孩子的节点节点删除之后，将左孩子所在的二叉树取代其位置；连在原来节点父亲元素右节点的位置，比如在图中需要删除58这个节点。删除58这个节点后，如下图所示：1.2 删除只有右孩子的节点：节点删除之后，将右孩子所在的二叉树取代其位置；连在原...
子集合问题算法的设计与实现
03-04
设计和实现子集合问题，使用的编程语言是java
Java版回溯法求子集和Demo
05-30
从X｛a1,a2,a3,...,an｝集合用回溯法按照升序或降序找出和的第一个子集，可设置最大求解时间。
mysql 递归查询 树型结构 代码逻辑
02-18
mysql 递归查询 树型结构 代码逻辑
java TreeUtil菜单递归工具类
09-07
主要为大家详细介绍了java TreeUtil菜单递归工具类，文中示例代码介绍的非常详细，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
7.Java之递归原理详解（递归调用原理，递归重要规则，深度理解递归与回溯，递归与回溯的区别）
qq_46656580的博客
11-05 1693
7.1.递归调用原理 所谓递归，即不断的自己调用自己的方法，每次在调用的时候，都开辟了一个独立的空间压入栈中，开始执行这个栈空间的代码（谁在栈顶谁先执行），而当代码执行完或者有返回的时候，这个空间便会销毁（出栈），而下面的空间就会开始执行后面的代码（在栈顶了，开始执行），直到也销毁，这个步骤称之为回溯 7.2.递归重要规则 执行一个方法时，就创建一个新的受保护的独立空间（栈空间） 方法的局部变量是独立的，不会相互影响（即每次调用自己的方法开出新的空间，里面的局部变量独立） 如果方法中使用的是引用类型
Java递归实现树形结构（简洁版，复杂版）
qq_37823919的博客
03-29 507
【代码】Java递归实现树形结构（简洁版，复杂版）
【LeetCode-算法】 78.子集（Java实现）
sinat_35050808的博客
11-16 895
题目 给定一组不含重复元素的整数数组 nums，返回该数组所有可能的子集（幂集）。 **说明：**解集不能包含重复的子集。 示例: 输入: nums = [1,2,3] 输出: [ [3], [1], [2], [1,2,3], [1,3], [2,3], [1,2], [] ] 实现代码 class Solution { public List&amp;lt;List...
java set子集,Java - 递归地查找String（powerset）的所有子集
weixin_32487755的博客
02-16 193
So, I need to find all subsets of a given string recursively. What I have so far is:static ArrayList powerSet(String s){ArrayList ps = new ArrayList();ps.add(s);for(int i=0; iString temp = s.replace(C...
Matlab编程实现经典算法详解：工程实例与应用
9. **生命游戏（AlgorithmGossip:生命游戏）**：展示用MATLAB实现康威的生命游戏，理解迭代逻辑和复杂系统的自组织性。 10. **字符串核对（AlgorithmGossip:字串核对）**：涉及字符串处理算法，学习如何用MATLAB...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

杨章隐

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值