精华内容
下载资源
问答
  • JAVA 递归与反递归
    2020-12-04 15:28:46

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

    import org.apache.commons.lang3.StringUtils;

    import com.alibaba.fastjson.JSON;
    import com.alibaba.fastjson.JSONArray;
    import com.yj.lf.domain.AjaxResult;

    /***
     * 递归树形结构工具类
     */
    public class TreeUtil {

        public static TreeSelectVo treeVo = new TreeSelectVo();

        public static List<String> ids = new ArrayList<String>();

        public static Map<String, List<TreeSelectVo>> pathMap = new HashMap<String, List<TreeSelectVo>>();// 记录所有从根节点到叶子结点的路径

        // 过滤一下数据
        public static AjaxResult filter(AjaxResult res, String type) {
            List<TreeSelectVo> list = new ArrayList<TreeSelectVo>();
            if (HttpStatus.SUCCESS == res.getCode()) {
                list = (List<TreeSelectVo>) JSONArray.parseArray(JSON.toJSONString(res.get("data")), TreeSelectVo.class);
                return AjaxResult.success(list);
            }
            return res;
        }

        // 递归计算父类别下子类别集合
        public static List<String> recursive(List<TreeSelectVo> tree) {
            List<String> list = new ArrayList<String>();
            for (TreeSelectVo treeSelectVo : tree) {
                list.add(treeSelectVo.getId());
                if (treeSelectVo.getChildren().size() > 0) {
                    list.addAll(recursive(treeSelectVo.getChildren()));
                }
            }
            return list;
        }

        // 递归计算父类别特定子类需要全局变量跳出递归
        public static TreeSelectVo find(List<TreeSelectVo> tree, String id) {
            treeVo = new TreeSelectVo();// 初始化全局变量
            return findDetail(tree, id);
        }

        // 递归计算父类别特定子类
        public static TreeSelectVo findDetail(List<TreeSelectVo> tree, String id) {
            for (TreeSelectVo treeSelectVo : tree) {
                if (id.equals(treeSelectVo.getId())) {
                    treeVo = treeSelectVo;
                } else if (treeSelectVo.getChildren().size() > 0) {
                    findDetail(treeSelectVo.getChildren(), id);
                }
            }
            return treeVo;
        }

        // 递归计算父类用-分隔-代表路径
        public static String getParentNames(List<TreeSelectVo> tree, String id) {
            return String.join("-", findParentNames(tree, id));
        }

        // 递归计算父类名称集合
        public static List<String> findParentNames(List<TreeSelectVo> tree, String id) {
            ids = new ArrayList<String>();// 初始化全局变量
            return findParentName(tree, id);
        }

        // 递归子类递归父类NAME集合
        public static List<String> findParentName(List<TreeSelectVo> tree, String id) {
            TreeSelectVo vo = find(tree, id);
            if (StringUtils.isNotEmpty(vo.getParentId())) {
                ids.add(vo.getLabel());
                findParentName(tree, vo.getParentId());
            } else {
                ids.add(vo.getLabel());
            }
            Collections.reverse(ids);
            return ids;
        }

        // 递归计算父类ID集合
        public static List<String> findParentIds(List<TreeSelectVo> tree, String id) {
            ids = new ArrayList<String>();// 初始化全局变量
            return findParentId(tree, id);
        }

        // 子类反向递归父类ID集合
        public static List<String> findParentId(List<TreeSelectVo> tree, String id) {
            TreeSelectVo vo = find(tree, id);
            if (StringUtils.isNotEmpty(vo.getParentId())) {
                ids.add(vo.getId());
                findParentId(tree, vo.getParentId());
            } else {
                ids.add(vo.getId());
            }
            Collections.reverse(ids);
            return ids;
        }

    }
     

    更多相关内容
  • 1. 递归查询树tree结构有两种做法:第一种,递归查询数据库结构,第二种,一次性将数据库表中的所有数据查出来,然后再... 反向递归(逆向递归)查询树tree结构根据关键字过滤数据大家有么有遇到过这个问题:我想要...

    1. 递归查询树tree结构有两种做法:

    第一种,递归查询数据库结构,

    第二种,一次性将数据库表中的所有数据查出来,然后再递归查出来的list集合,

    第一种做法适合数据量较少的tree结构,因为要一直查询数据库数据量大时速度回相对较慢,所以数据量大时建议使用第二种方法,如图1所示是一个常见的树tree结构

    图1

    0818b9ca8b590ca3270a3433284dd417.png

    2. 反向递归(逆向递归)查询树tree结构根据关键字过滤数据

    大家有么有遇到过这个问题:我想要根据关键字过滤查询出相关数据和它的上级结构,得到图1所示结果,可往往不知道怎么做,查不出上级结构总是得到图3类似的结构,要解决这个比较常见的问题就要用到反向递归的算法,网上我那个网搜不到类似的解决方案,本人一时兴趣来了,做了一套递归和反递归的解决方案,简单易懂,大家可以相互交流一下

    图2

    0818b9ca8b590ca3270a3433284dd417.png

    0818b9ca8b590ca3270a3433284dd417.png

    图3

    0818b9ca8b590ca3270a3433284dd417.png

    0818b9ca8b590ca3270a3433284dd417.png

    3.示例代码

    /**

    * 说明方法描述:将list转为树tree结构

    *

    * @param allRrecords

    * @return

    * @time 2016年5月10日 下午6:00:35

    * @author yangdong

    */

    public List useListRecordToTree(List allRrecords) {

    List listParentRecord = new ArrayList();

    List listNotParentRecord = new ArrayList();

    // 第一步:遍历allRrecords保存所有数据的uuid用于判断是不是根节点

    Map mapAllUuid = new HashMap();

    Map allRecordMap = new HashMap();

    for (Record record : allRrecords) {

    mapAllUuid.put(record.getStr("uuid"), record.getStr("uuid"));

    allRecordMap.put(record.getStr("uuid"), record);

    }

    // 第二步:遍历allRrecords找出所有的根节点和非根节点

    if (allRrecords != null && allRrecords.size() > 0) {

    for (Record record : allRrecords) {

    if (StringUtil.isBlank(record.getStr("parent_uuid"))

    || !mapAllUuid.containsKey(record.getStr("parent_uuid"))) {

    listParentRecord.add(record);

    } else {

    listNotParentRecord.add(record);

    }

    }

    }

    // 第三步: 递归获取所有子节点

    if (listParentRecord.size() > 0) {

    for (Record record : listParentRecord) {

    // 添加所有子级

    record.set("childs", this.getTreeChildRecord(listNotParentRecord, record.getStr("uuid")));

    }

    }

    return listParentRecord;

    }

    /**

    * 说明方法描述:使list转换为树并根据关键字和节点名称过滤

    *

    * @param allRecords 所有节点

    * @param keywords 要过滤的关键字

    * @param filterFields 要过滤的字段

    * @return

    * @time 2016年5月19日 下午3:27:32

    * @author yangdong

    */

    public List useListRecordToTreeByKeywords(List allRecords, String keywords, String... filterFields) {

    List listRecord = new ArrayList();

    Map allRecordMap = new HashMap();

    for (Record record : allRecords) {

    allRecordMap.put(record.getStr("uuid"), record);

    }

    // 遍历allRrecords找出所有的nodeName和关键字keywords相关的数据

    if (allRecords != null && allRecords.size() > 0) {

    if (filterFields.length > 1) {

    for (Record record : allRecords) {

    for (String field : filterFields) {

    // 比较

    if (record.getStr(field).toLowerCase().indexOf(keywords.toLowerCase()) != -1) {

    listRecord.add(record);

    }

    }

    }

    } else {

    for (Record record : allRecords) {

    // 比较

    if (record.getStr(filterFields[0]).toLowerCase().indexOf(keywords.toLowerCase()) != -1) {

    listRecord.add(record);

    }

    }

    }

    }

    // 查找过滤出来的节点和他们的父节点

    listRecord = this.getSelfAndTheirParentRecord(listRecord, new ArrayList(),

    new HashMap(), allRecordMap);

    // 将过滤出来的数据变成树tree结构

    listRecord = this.useListRecordToTree(listRecord);

    return listRecord;

    }

    /**

    * 说明方法描述:递归查询子节点

    *

    * @param childList 子节点

    * @param parentUuid 父节点id

    * @return

    * @time 2016年5月10日 下午3:29:35

    * @author yangdong

    */

    private List getTreeChildRecord(List childList, String parentUuid) {

    List listParentRecord = new ArrayList();

    List listNotParentRecord = new ArrayList();

    // 遍历tmpList,找出所有的根节点和非根节点

    if (childList != null && childList.size() > 0) {

    for (Record record : childList) {

    // 对比找出父节点

    if (StringUtil.equals(record.getStr("parent_uuid"), parentUuid)) {

    listParentRecord.add(record);

    } else {

    listNotParentRecord.add(record);

    }

    }

    }

    // 查询子节点

    if (listParentRecord.size() > 0) {

    for (Record record : listParentRecord) {

    // 递归查询子节点

    record.set("childs", getTreeChildRecord(listNotParentRecord, record.getStr("uuid")));

    }

    }

    return listParentRecord;

    }

    /**

    * 说明方法描述:递归找出本节点和他们的父节点

    *

    * @param parentList 根据关键字过滤出来的相关节点的父节点

    * @param resultList 返回的过滤出来的节点

    * @param filterRecordMap 已经过滤出来的节点

    * @param allRecordMap 所有节点

    * @return

    * @time 2016年5月19日 上午9:53:56

    * @author yangdong

    */

    private List getSelfAndTheirParentRecord(List parentList, List resultList,

    Map filterRecordMap,

    Map allRecordMap) {

    // 当父节点为null或者节点数量为0时返回结果,退出递归

    if (parentList == null || parentList.size() == 0) {

    return resultList;

    }

    // 重新创建父节点集合

    List listParentRecord = new ArrayList();

    // 遍历已经过滤出来的节点

    for (Record record : parentList) {

    String uuid = record.getStr("uuid");

    String parent_uuid = record.getStr("parent_uuid");

    // 如果已经过滤出来的节点不存在则添加到list中

    if (!filterRecordMap.containsKey(uuid)) {

    listParentRecord.add(record);// 添加到父节点中

    filterRecordMap.put(uuid, record);// 添加到已过滤的map中

    allRecordMap.remove(uuid);// 移除集合中相应的元素

    resultList.add(record);// 添加到结果集中

    }

    // 找出本节点的父节点并添加到listParentRecord父节点集合中,并移除集合中相应的元素

    if (StringUtil.isNotBlank(parent_uuid)) {

    Record parentRecord = allRecordMap.get(parent_uuid);

    if (parentRecord != null) {

    listParentRecord.add(parentRecord);

    allRecordMap.remove(parent_uuid);

    }

    }

    }

    // 递归调用

    getSelfAndTheirParentRecord(listParentRecord, resultList, filterRecordMap, allRecordMap);

    return resultList;

    }

    //示例

    /**

    * 说明方法描述:递归查询所有权限

    *

    * @param keyword

    * @param is_deleted

    * @return

    * @time 2016年5月10日 下午3:47:50

    * @author yangdong

    */

    public List getRecordByKeywordRecursive(String keyword, String is_deleted) {

    // 第一步:查询所有的数据

    StringBuffer sql = new StringBuffer(

    " select pa.uuid,pa.parent_uuid,pa.author_code,pa.author_name,pa.is_menu,pa.sort_number,pa.is_enable,pa.menu_icon ");

    sql.append("  from s_author pa");

    List params = new ArrayList();

    sql.append(" where  pa.is_deleted=? ");

    params.add(is_deleted);

    sql.append(" order by pa.sort_number asc ");

    List allRrecords = Db.use(AppConst.DB_DATASOURCE_MAIN).find(sql.toString(), ParamUtil.listToArray(params));

    //第二步:将list变为树tree结构

    if (StringUtil.isNotBlank(keyword)) {

    return super.useListRecordToTreeByKeywords(allRrecords, keyword, "author_name");

    } else {

    return super.useListRecordToTree(allRrecords);

    }

    }

    ----------------------------------------------------------------------------------------------------------------------------------------

    如果您认为本教程质量不错,读后觉得收获很大,预期工资能蹭蹭蹭的往上涨,那么不妨小额赞助我一下,让我有动力继续写出高质量的教程。 ----------------------------------------------------------------------------------------------------------------------------------------

    0818b9ca8b590ca3270a3433284dd417.png    

    0818b9ca8b590ca3270a3433284dd417.png

    展开全文
  • java递归和反向递归

    2021-02-12 21:46:58
    } } } // 第三步: 递归获取所有子节点 if (listParentRecord.size() > 0) { for (Record record : listParentRecord) { // 添加所有子级 record.set("childs", this.getTreeChildRecord...

    /**

    * 说明方法描述:将list转为树tree结构

    *

    * @param allRrecords

    * @return

    * @time 2016年5月10日 下午6:00:35

    * @author yangdong

    */

    public List useListRecordToTree(List allRrecords) {

    List listParentRecord = new ArrayList();

    List listNotParentRecord = new ArrayList();

    // 第一步:遍历allRrecords保存所有数据的uuid用于判断是不是根节点

    Map mapAllUuid = new HashMap();

    Map allRecordMap = new HashMap();

    for (Record record : allRrecords) {

    mapAllUuid.put(record.getStr("uuid"), record.getStr("uuid"));

    allRecordMap.put(record.getStr("uuid"), record);

    }

    // 第二步:遍历allRrecords找出所有的根节点和非根节点

    if (allRrecords != null && allRrecords.size() > 0) {

    for (Record record : allRrecords) {

    if (StringUtil.isBlank(record.getStr("parent_uuid"))

    || !mapAllUuid.containsKey(record.getStr("parent_uuid"))) {

    listParentRecord.add(record);

    } else {

    listNotParentRecord.add(record);

    }

    }

    }

    // 第三步: 递归获取所有子节点

    if (listParentRecord.size() > 0) {

    for (Record record : listParentRecord) {

    // 添加所有子级

    record.set("childs", this.getTreeChildRecord(listNotParentRecord, record.getStr("uuid")));

    }

    }

    return listParentRecord;

    }

    /**

    * 说明方法描述:使list转换为树并根据关键字和节点名称过滤

    *

    * @param allRecords 所有节点

    * @param keywords 要过滤的关键字

    * @param filterFields 要过滤的字段

    * @return

    * @time 2016年5月19日 下午3:27:32

    * @author yangdong

    */

    public List useListRecordToTreeByKeywords(List allRecords, String keywords, String... filterFields) {

    List listRecord = new ArrayList();

    Map allRecordMap = new HashMap();

    for (Record record : allRecords) {

    allRecordMap.put(record.getStr("uuid"), record);

    }

    // 遍历allRrecords找出所有的nodeName和关键字keywords相关的数据

    if (allRecords != null && allRecords.size() > 0) {

    if (filterFields.length > 1) {

    for (Record record : allRecords) {

    for (String field : filterFields) {

    // 比较

    if (record.getStr(field).toLowerCase().indexOf(keywords.toLowerCase()) != -1) {

    listRecord.add(record);

    }

    }

    }

    } else {

    for (Record record : allRecords) {

    // 比较

    if (record.getStr(filterFields[0]).toLowerCase().indexOf(keywords.toLowerCase()) != -1) {

    listRecord.add(record);

    }

    }

    }

    }

    // 查找过滤出来的节点和他们的父节点

    listRecord = this.getSelfAndTheirParentRecord(listRecord, new ArrayList(),

    new HashMap(), allRecordMap);

    // 将过滤出来的数据变成树tree结构

    listRecord = this.useListRecordToTree(listRecord);

    return listRecord;

    }

    /**

    * 说明方法描述:递归查询子节点

    *

    * @param childList 子节点

    * @param parentUuid 父节点id

    * @return

    * @time 2016年5月10日 下午3:29:35

    * @author yangdong

    */

    private List getTreeChildRecord(List childList, String parentUuid) {

    List listParentRecord = new ArrayList();

    List listNotParentRecord = new ArrayList();

    // 遍历tmpList,找出所有的根节点和非根节点

    if (childList != null && childList.size() > 0) {

    for (Record record : childList) {

    // 对比找出父节点

    if (StringUtil.equals(record.getStr("parent_uuid"), parentUuid)) {

    listParentRecord.add(record);

    } else {

    listNotParentRecord.add(record);

    }

    }

    }

    // 查询子节点

    if (listParentRecord.size() > 0) {

    for (Record record : listParentRecord) {

    // 递归查询子节点

    record.set("childs", getTreeChildRecord(listNotParentRecord, record.getStr("uuid")));

    }

    }

    return listParentRecord;

    }

    /**

    * 说明方法描述:递归找出本节点和他们的父节点

    *

    * @param parentList 根据关键字过滤出来的相关节点的父节点

    * @param resultList 返回的过滤出来的节点

    * @param filterRecordMap 已经过滤出来的节点

    * @param allRecordMap 所有节点

    * @return

    * @time 2016年5月19日 上午9:53:56

    * @author yangdong

    */

    private List getSelfAndTheirParentRecord(List parentList, List resultList,

    Map filterRecordMap,

    Map allRecordMap) {

    // 当父节点为null或者节点数量为0时返回结果,退出递归

    if (parentList == null || parentList.size() == 0) {

    return resultList;

    }

    // 重新创建父节点集合

    List listParentRecord = new ArrayList();

    // 遍历已经过滤出来的节点

    for (Record record : parentList) {

    String uuid = record.getStr("uuid");

    String parent_uuid = record.getStr("parent_uuid");

    // 如果已经过滤出来的节点不存在则添加到list中

    if (!filterRecordMap.containsKey(uuid)) {

    listParentRecord.add(record);// 添加到父节点中

    filterRecordMap.put(uuid, record);// 添加到已过滤的map中

    allRecordMap.remove(uuid);// 移除集合中相应的元素

    resultList.add(record);// 添加到结果集中

    }

    // 找出本节点的父节点并添加到listParentRecord父节点集合中,并移除集合中相应的元素

    if (StringUtil.isNotBlank(parent_uuid)) {

    Record parentRecord = allRecordMap.get(parent_uuid);

    if (parentRecord != null) {

    listParentRecord.add(parentRecord);

    allRecordMap.remove(parent_uuid);

    }

    }

    }

    // 递归调用

    getSelfAndTheirParentRecord(listParentRecord, resultList, filterRecordMap, allRecordMap);

    return resultList;

    }

    展开全文
  • 查询子级菜单递归查询具体实现方法1(JAVA8):  public void getTreeCategory() { //查询所有的分类 List&lt;VipGoodsCategory&gt; vipGoodsCategoryList = vipGoodsCategoryService....

    查询子级菜单递归查询具体实现方法1(JAVA8): 

       public void getTreeCategory() {
            //查询所有的分类
            List<VipGoodsCategory> vipGoodsCategoryList = vipGoodsCategoryService.listGoodsCategory();
            //查询顶级分类
            List<VipGoodsCategory> top = vipGoodsCategoryList.stream().filter(x -> StringUtils.isEmpty(x.getParentId()) || x.getParentId().equals("-1")).collect(Collectors.toList());
            //parentId作为key,子级作为value组成的map
            Map<String, List<VipGoodsCategory>> allMap = vipGoodsCategoryList.stream().collect(Collectors.groupingBy(VipGoodsCategory::getParentId));
            //递归查询
            List<VipGoodsCategory> list = this.treeCategoryData(top, allMap);
            for (VipGoodsCategory category : list) {
                System.out.println(category.getAuId()+","+category.getCategoryName()+","+category.getParentId()+","+category.getChildren().get(0).getCategoryName());
            }
        }
    
        public List<VipGoodsCategory> treeCategoryData(List<VipGoodsCategory> top, Map<String, List<VipGoodsCategory>> allMap) {
            //遍历
            top.forEach(category -> {
                List<VipGoodsCategory> temp = allMap.get(category.getAuId());
                if (temp != null && !temp.isEmpty()) {
                    category.setChildren(temp);
                    treeCategoryData(category.getChildren(), allMap);
                } else {
                    category.setChildren(new ArrayList<>());
                }
            });
            return top;
        }

    查询子级菜单递归查询具体实现方法2: 

    import java.util.ArrayList;
    import java.util.HashMap;
    import java.util.List;
    import java.util.Map;
    
    import com.lhm.value.TreeJson;
    
    public class RecursiveTreeMap {
    	
    	public static List<TreeJson> getTreeMap(List<TreeJson> treeList) {
    		List<TreeJson> parentTreeList = new ArrayList<TreeJson>();
    		List<TreeJson> childrenTreeList = new ArrayList<TreeJson>();
    		Map<String, String> allIdMap = new HashMap<String, String>();
    		if (treeList == null || treeList.size() == 0) {
    			return parentTreeList;
    		}
    		for (TreeJson tree : treeList){
    			allIdMap.put(tree.getId(), tree.getId());
    		}
    		//遍历找出所有的根节点和非根节点
    		for (TreeJson tree : treeList) {
    			if ("-1".equals(tree.getParentid()) || !allIdMap.containsKey(tree.getParentid())){
    				parentTreeList.add(tree);
    			}else{
    				childrenTreeList.add(tree);
    			}
    		}
    		//递归获取所有子节点
    		if (parentTreeList != null && parentTreeList.size() > 0) {
    			for (TreeJson tree : parentTreeList) {
    				//添加所有子级
    				List<TreeJson> children = getChildrenTreeList(childrenTreeList, tree.getId());
    				tree.setChildren(children);
    			}
    		}
    		return parentTreeList;
    	}
    	
    	//递归查询子节点
    	public static List<TreeJson> getChildrenTreeList(List<TreeJson> childrenList, String parentId) {
    		List<TreeJson> parentTreeList = new ArrayList<TreeJson>();
    		List<TreeJson> childrenTreeList = new ArrayList<TreeJson>();
    		if (childrenList == null || childrenList.size() == 0) {
    			return parentTreeList;
    		}
    		//找出所有的根节点和非根节点
    		for (TreeJson tree : childrenList) {
    			if (parentId.equals(tree.getParentid())) {
    				parentTreeList.add(tree);
    			} else {
    				childrenTreeList.add(tree);
    			}
    		}
    		//查询子节点
    		if (parentTreeList != null && parentTreeList.size() > 0) {
    			for (TreeJson tree : parentTreeList) {
    				//递归查询子节点
    				List<TreeJson> children = getChildrenTreeList(childrenTreeList, tree.getId());
    				tree.setChildren(children);
    			}
    		}
    		return parentTreeList;
    	}
    
    }
    

     查询父级菜单递归查询具体实现方法:

    import java.util.ArrayList;
    import java.util.HashMap;
    import java.util.List;
    import java.util.Map;
    
    import com.lhm.value.TreeJson;
    
    public class RecursiveParentTree {
    	
        public static List<TreeJson> getParentTree(List<TreeJson> treeList) {
        	List<TreeJson> parentTreeList = new ArrayList<TreeJson>();
    		List<TreeJson> childrenTreeList = new ArrayList<TreeJson>();
    		Map<String, String> parentIdMap = new HashMap<String, String>();
    		if (treeList == null || treeList.size() == 0) {
    			return childrenTreeList;
    		}
    		for (TreeJson tree : treeList){
    			parentIdMap.put(tree.getParentid(), tree.getParentid());
    		}
    		//遍历找出所有的根节点和非根节点
    		for (TreeJson tree : treeList) {
    			if ("-1".equals(tree.getParentid()) || parentIdMap.containsKey(tree.getId())) {
    				parentTreeList.add(tree);
    			}else {
    				childrenTreeList.add(tree);
    			}
    		}
    		//递归获取所有父节点
    		if (childrenTreeList != null && childrenTreeList.size() > 0) {
    			for (TreeJson tree : childrenTreeList) {
    				//添加所有父级
    				List<TreeJson> parents = getParentTreeList(parentTreeList, tree.getParentid());
    				tree.setParents(parents);
    			}
    		}
    		return childrenTreeList;
        }
        
    	//递归查询父节点
    	private static List<TreeJson> getParentTreeList(List<TreeJson> parents, String id) {
    		List<TreeJson> parentTreeList = new ArrayList<TreeJson>();
    		List<TreeJson> childrenTreeList = new ArrayList<TreeJson>();
    		if (parents == null || parents.size() == 0) {
    			return childrenTreeList;
    		}
    		//找出所有的根节点和非根节点
    		for (TreeJson tree : parents) {
    			if (id.equals(tree.getId())) {
    				childrenTreeList.add(tree);
    			} else {
    				parentTreeList.add(tree);
    			}
    		}
    		//查询父节点
    		if (childrenTreeList != null && childrenTreeList.size() > 0) {
    			for (TreeJson tree : childrenTreeList) {
    				//递归查询父节点
    				List<TreeJson> parentList = getParentTreeList(parentTreeList, tree.getParentid());
    				tree.setParents(parentList);
    			}
    		}
    		return childrenTreeList;
    	}
    
    }

    TreeJson实体类

    import java.util.ArrayList;
    import java.util.List;
    
    public class TreeJson {
    	private String id;
    	private String text;
    	private String parentid;
    	private String url;
    	private String iconcls;
    	private List<TreeJson> children = new ArrayList<TreeJson>();
    	private List<TreeJson> parents = new ArrayList<TreeJson>();
    	public String getId() {
    		return id;
    	}
    	public void setId(String id) {
    		this.id = id;
    	}
    	public String getText() {
    		return text;
    	}
    	public void setText(String text) {
    		this.text = text;
    	}
    	public String getParentid() {
    		return parentid;
    	}
    	public void setParentid(String parentid) {
    		this.parentid = parentid;
    	}
    	public String getUrl() {
    		return url;
    	}
    	public void setUrl(String url) {
    		this.url = url;
    	}
    	public String getIconcls() {
    		return iconcls;
    	}
    	public void setIconcls(String iconcls) {
    		this.iconcls = iconcls;
    	}
    	public List<TreeJson> getChildren() {
    		return children;
    	}
    	public void setChildren(List<TreeJson> children) {
    		this.children = children;
    	}
    	public List<TreeJson> getParents() {
    		return parents;
    	}
    	public void setParents(List<TreeJson> parents) {
    		this.parents = parents;
    	}
    
    }
    

    花了一点时间整理出来, 有任何问题欢迎指导?

     

    展开全文
  • 无限级树正向查找、反向查找例子【递归实现】 无限级树正向查找、反向查找例子【递归实现】 无限级树正向查找、反向查找例子【递归实现】
  • 原文:java递归与反向递归(逆向递归)查询树tree结构根据关键字过滤数据 转载于:https://www.cnblogs.com/wangwangfei/p/6928213.html
  • } } /** * 向上递归查询所有父节点(每一层的父节点只有一个) * @param sxyBranchVOSub * @param branchVOSetSub * @return */ private Set buildTreeUp(SxyBranchVO sxyBranchVOSub, Set branchVOSetSub) { // ...
  • java链表反转:反向实现递归(leetcode206) 文章目录java链表反转:反向实现递归(leetcode206)前言一、题目中文二、代码实现1.完整代码2.代码详解总结 前言 对于链表翻转使用递归方法分为顺序翻转和逆向翻转,...
  • java树形结构递归查询

    2018-09-04 17:24:08
    //最大递归次数不超过Constants.CATEGORY_MAX_LEVEL-level次,防止坏数据死循环 if(remainRecursionCount ){ return categoryTreeDTO; } String categoryCode = categoryTreeDTO.getCategoryCode(); Integer ...
  • java递归实现输入字符串反向输出

    千次阅读 2015-06-19 16:52:42
     package test; public class ReverseString {  public static void main(String[] args) {  reverseString("abcde");  } ... public static void reverseString(String str) { ... if
  • 一个简单的小例子递归实现list按照index排序的树
  • 部门树形结构算法 — Java递归实现 将查询到的部门列表数据,进行父子节点树形结构排序 该功能适用需要树形结构的,不仅仅是部门树 步骤: 查询数据库,获得所有的部门列表 调用下面的实现方法 一、数据库结构...
  • import java.util.ArrayList;import java.util.Iterator;import java.util.List;/*** 获取子节点*/public class NodeUtil {private List returnList = new ArrayList();/*** 根据父节点的ID获取所有子节点* @param ...
  • java递归与反向递归

    2017-11-01 10:08:10
    反向递归(逆向递归)查询树tree结构根据关键字过滤数据 大家有么有遇到过这个问题:我想要根据关键字过滤查询出相关数据和它的上级结构,得到图1所示结果,可往往不知道怎么做,查不出上级结构总是得到图3类似的...
  • 大家好,今天我们来看看树形结构的递归取数,说实话,这个呢,我其实也不太明白其中的原理,也就是我也不会灵活运用,之所以写下来,嘿嘿,是为了希望那行和我一样不会这个的,或者不懂这个递归的,可以有所帮助,...
  • 对于递归来说,我只了解它的概念,没有具体使用过,近期也是尝试着用递归写了一下冒泡排序和大家分享,希望能帮助大家了解递归递归是什么?通俗的讲:在方法内部调用自己花了几分钟整出来的,下面是递归冒泡排序的...
  • 一、概述List遍历是我们经常会使用到的一个功能,很多时候我们也会用到反向遍历,在用到反向遍历时我们常用的方法是通过for循环或者是对List反向排序来完成相应的操作,像下面代码这样:方法1:for(int i = list.size...
  • 对于面试大厂的朋友,一些建议 阿里 阿里面试官一般都是P7/P8岗,对标到普通互联网公司相当于就是技术专家那种类型!他们对于没有经验的毕业...高扩展、高可用问题,这些你也应该准备好,10%问基础,像spring原理、Java
  • 业务要求: 1.前台给定末级分类id,要求根据当前末级分类id递归方向查询分类名称如: 2.java后台代码: controller层: ...// 根据商品ID查询单个的商品对象 ...//根据指定末级分类id反向递归查询
  • java 递归函数

    2021-02-12 16:08:27
    一、递归函数,通俗的说就是函数本身自己调用自己...如:n!=n(n-1)!你定义函数f(n)=nf(n-1)而f(n-1)又是这个定义的函数。。这就是递归二、为什么要用递归递归的目的是简化程序设计,使程序易读三、递归的弊端:尽管...
  • JAVA递归生成tree树

    千次阅读 2015-06-01 09:37:46
    关于类别树的多级是一个刚接触ajax和多级类别很头痛的问题,针对那种商品种类繁多,级别层次多更是麻烦的问题,去年刚学asp.net,实验室的同学曾经这样做过,递归sql,现在看了惊心动魄 虽然实现了类别多级的问题这样...
  • 题目:输入一个字符串,要求将该字符串反向输出 ... * 递归方法反向输出字符串 * @author tyrantForever * */ public class Project1 { public static void main(String[] args) { String testStri...
  • 我已经尝试了各种递归函数的方法,但只有在深度为2时才设法获得正确的结果 . 我找到了这个函数,但它似乎返回键的名称而不是值: function find_parent($array, $needle, $parent = null) { foreach ($array as $key...
  • Java递归的深入理解

    2021-03-11 13:31:49
    今天爱站技术频道的小编将给您带来这篇对Java递归的深入理解,一个过程或函数在其定义或说明中有直接或间接调用自身的一种方法,它通常把一个大型复杂的问题层层转化为一个与原问题相似的规模较小的问题来求解,需要...
  • 参数映射指的是对于java 数据类型和jdbc数据类型之间的转换:这里有包括两个过程:查询阶段,我们要将java类型的数据,转换成jdbc类型的数据,通过 preparedStatement.setXXX()来设值;另一个就是对resultset查询...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 15,669
精华内容 6,267
关键字:

java反向递归

java 订阅
友情链接: Dijkstra2008.rar