精华内容
下载资源
问答
  • 递归查询所有下级部门树形结构反向递归获取所有ID集合
    千次阅读
    2018-07-13 15:03:25

    mysql递归搜索再之前得原创文档里已经写明了,这个网上比较多。

    直接进入正题:原创手写反递归

     package com.kb.nxccims.common.util;

    import java.util.ArrayList;
    import java.util.List;
    import com.kb.nxccims.expandmodel.UnitVO;
    /**
     * @author 叶成浪
     * @time 2018年7月12日 - 上午11:06:06
     * @email yechenglang521@163.com
     **/
    public class UnitRecursionUtils {
     private UnitRecursionUtils() {
     }
     private static List<Long> rList = null;
     private static UnitRecursionUtils unitRecursionUtils = null;
     public static List<Long> getInstance(List<UnitVO> list) {
      if (rList == null) {
       rList = new ArrayList<Long>();
      }
      synchronized (rList) {
       unitRecursionUtils = new UnitRecursionUtils();
       return unitRecursionUtils.getUnitList(list);
      }
     }
     // YCL递归查询下级单位ID
     private List<Long> getUnitList(List<UnitVO> list) {
      if (!rList.isEmpty()) {
       return rList;
      }
      for (int i = 0; i < list.size(); i++) {
       rList.add(list.get(i).getId());
       uVO(list.get(i).getuList());
      }
      return rList;
     }
     // YCL递归循环下级所有ID
     private static List<UnitVO> uVO(List<UnitVO> uvo) {
      List<UnitVO> list2 = new ArrayList<UnitVO>();
      for (int i = 0; i < uvo.size(); i++) {
       rList.add(uvo.get(i).getId());
       if (uvo.get(i).getuList().isEmpty()) {
        return null;
       } else {
        list2.addAll(uvo.get(i).getuList());
       }
      }
      if (uvo.size() <= 0) {
       return null;
      }
      return uVO(list2);
     }
    }

    原创版权,未经允许,不得转载。


    更多相关内容
  • js反向递归查找值

    千次阅读 2020-12-02 14:19:58
    现在遇到一个后台传给你一个某个位置的id值且需要你向上一层一层获取数据的值,这个时候你就需要反向递归去获取数据。 记录一次才坑经历吧 思路1 之前是想把源数据转成json字符串去查找,这样性能应该能更好,少了很...

    业务开发中tree树数据经常打交道,经常需要用到递归去操作更改数据。
    现在遇到一个后台传给你一个某个位置的id值且需要你向上一层一层获取数据的值,这个时候你就需要反向递归去获取数据。
    记录一次才坑经历吧

    思路1
    之前是想把源数据转成json字符串去查找,这样性能应该能更好,少了很多循环操作。后面发现自己正则似乎太菜了学的都还给老师了无奈只好放弃这种方法,

    思路2
    正常递归源数据数组 判断children值以及使用数组的some方法判断是否需要继续递归下去还是从头递归;
    贴代码

    	// 反递归查找
        function formTree(list, id) {
          // const st = JSON.stringify(props.treeData);
          // st.lastIndexOf(`"id":${props.deptId}`)
          list.forEach(item => {
            if (item.children && item.children.length) {// 判断是否有children子集
              if (item.children.some(row => row.id === id)) {// 判断子集里是否有想要的值来进行是否需要继续递归还是从头递归
                treeId.value.push(item.id);// 接收符合的数据id
                formTree(props.treeData, item.id) // 从头递归
              } else formTree(item.children, id) // 继续递归
              
            } else return
          })
        }
    
    
    	watchEffect(() => {
          visible.value = props.showModal;
          if (props.showModal) {// modal弹窗状态
            if (props.deptId && props.treeData) {// props.deptId源数组某一处的id  props.treeData源数组数据
              treeId.value = []; // 接收id的数组
              treeId.value.push(props.deptId);
              formTree(props.treeData, props.deptId);// 递归
            }
          }
    	})
    

    以上 treeId.value里就是想要的id值合集

    如果有更好的方法思路可以带带弟弟哦

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

    千次阅读 2017-12-21 10:57:36
    //反向递归 找到最低层的菜单一步步往上查 (先逆向递归然后再反向递归)  [HttpPost]  public ReturnNode MenuListByAdd(GetMenuListInput input)  {  /////反向递归,从最底层menu找上面所有的men

    有啥补充请大神们在下面留言:



    //反向递归   找到最低层的菜单一步步往上查    (先逆向递归然后再反向递归)


      [HttpPost]

            public ReturnNode MenuListByAdd(GetMenuListInput input)
            {
                /反向递归,从最底层menu找上面所有的menu
                var allList = dbContext.yf_menu.AsQueryable().ToList();
                string sql = "select * from  yf_menu as d where  d.Id  in(select menuid from yf_action as c where c.id in(select a.actionid from  yf_role_action as a where a.roleid = 2) GROUP BY  menuid); ";
                var bottomList = dbContext.Database.SqlQuery<yf_menu>(sql).ToList();
                List<yf_menu> newList = new List<yf_menu>();
                foreach (yf_menu node in bottomList)
                {
                    newList.Add(node);
                    newList.AddRange(GetParentMenuList(node, allList));
                }
                var list = newList.Where((x, i) => newList.FindIndex(z => z.id == x.id) == i);//数组去重


                ///************************
                string actionSql = string.Format("SELECT a.*,r.roleid from yf_action a LEFT JOIN yf_role_action r on  a.id=r.actionid and r.roleid={0}", input.roleId);
                var actionList = dbContext.Database.SqlQuery<GetMenuListActionOutput>(actionSql).ToList();
                var newlist = new List<GetMenuListOutput>();
                foreach (yf_menu menu in list)
                {
                    GetMenuListOutput newinput = new GetMenuListOutput();
                    newinput.createtime = menu.createtime;
                    newinput.id = menu.id;
                    newinput.menuname = menu.menuname;
                    newinput.menuurl = menu.menuurl;
                    newinput.note = menu.note;
                    newinput.parentid = menu.parentid;
                    newinput.actionList = actionList.Where(u => u.menuid == menu.id).OrderBy(p => p.id).ToList();
                    newlist.Add(newinput);
                }
                if (input.outDataType == 1)//树形
                {
                    GetMenuListOutput tree = initMenuTree(newlist.Where(u => u.parentid == 0).FirstOrDefault(), newlist);
                    return ReturnNode.ReturnSuccess(tree);
                }
                else if (input.outDataType == 2)//数据字典
                {
                    return ReturnNode.ReturnSuccess(newlist.ToDictionary(u => u.id));
                }
                else//数组
                {
                    return ReturnNode.ReturnSuccess(newlist);
                }

            }


    //递归找上级方法


       //递归找上级
            private List<yf_menu> GetParentMenuList(yf_menu menuNode, List<yf_menu> allList)
            {
                yf_menu parentNode = allList.Where(u => u.id == menuNode.parentid).FirstOrDefault();
                List<yf_menu> newList = new List<yf_menu>();
                newList.Add(parentNode);
                if (parentNode.parentid != 0)
                {
                    newList.AddRange(GetParentMenuList(parentNode, allList));
                }
                return newList;
            }







    ==========正向递归



     //生成树
            private GetMenuListOutput initMenuTree(GetMenuListOutput menu, List<GetMenuListOutput> list)
            {
                var chirldens = list.Where(u => u.parentid == menu.id);
                menu.childrens = new List<GetMenuListOutput>();
                foreach (var node in chirldens)
                {
                    var newnode = initMenuTree(node, list);
                    menu.childrens.Add(newnode);
                }


                return menu;
            }





    展开全文
  • 有这样的需求:知道一个值在某个数组当中,但是不确定在哪一级,想...1、数组对象,通过子节点的值反向获取其父级链条: //数组结构: var arr = [ { "children" : [ { "children" : [ { level:3, name:'银杏纲'

    有这样的需求:知道一个值在某个数组当中,但是不确定在哪一级,想把该值的父级链条找出来。

    1、数组对象

    let arr = [
            {
                "children" : [
                    {
                        "children" : [
                            {
                                level:3,
                                name:'银杏纲'
                            },
                            {
                                "children" : [
                                    {
                                        "children" : [
                                            {
                                                "children" : [
                                                    {
                                                        level:6,
                                                        name:'苏铁属'
                                                    },
                                                ],
                                                level:5,
                                                name:'苏铁科'
                                            },
                                        ],
                                        level:4,
                                        name:'苏铁目'
                                    },
                                ],
                                level:3,
                                name:'苏铁纲'
                            },
                        ],
                        level:2,
                        name:'裸子植物门'
                    },
                    {
                        "children" : [
                            {
                                "children" : [
                                    {
                                        "children" : [
                                            {
                                                "children" : [
                                                    {
                                                        level:6,
                                                        name:'蔷薇属'
                                                    },
                                                ],
                                                level:5,
                                                name:'蔷薇科'
                                            },
                                            {
                                                "children" : [
                                                    {
                                                        level:6,
                                                        name:'无尾果属'
                                                    },
                                                ],
                                                level:5,
                                                name:'蔷薇科'
                                            },
                                        ],
                                        level:4,
                                        name:'蔷薇目'
                                    },
                                ],
                                level:3,
                                name:'双子叶植物纲'
                            },
                        ],
                        level:2,
                        name:'被子植物门'
                    },
                ],
                level:1,
                name:'植物界'
            },
            {
                "children" : [
                    {
                        level:2,
                        name:'古虫动物门'
                    },
                    {
                        "children" : [
                            {
                                level:3,
                                name:'鱼纲'
                            }
                        ],
                        level:2,
                        name:'脊索动物门'
                    }
                ],
                level:1,
                name:'动物界'
            }
        ]
    

    2、通过子节点的值反向获取其父级链条:递归寻找

        function getParent(item, childrens, v){
            let arrRes = [];
            if(item.name == v){
                arrRes.unshift(item);
                return arrRes
            }
            let shangyiji;
            let recursive = (parent, children, v) => {
                for(let j = 0, length = children.length; j < length; j++){
                    let node = children[j];
                    if(node.name == v){
                        arrRes.unshift(node);
                        if(Object.is(children, childrens)){
                            arrRes.unshift(item);
                            break
                        }
                        recursive(parent, parent.children, shangyiji.name);//找到了,再从顶级的children里面开始找目标值的父级的父级
                        break;
                    } else {
                        let aa = !!node.children
                        if(!!node.children){
                            shangyiji = node;//记录上一级的节点,找到了的时候用
                            recursive(parent, node.children, v);//没找到,并且还有children,就继续往下找
                        }
                    }
                }
                return arrRes;
            };
            arrRes = recursive(item, childrens, v);
            return arrRes;
        }
    
        //测试
        let typeTree;
        for(let i = 0; i < arr.length; i++){
            typeTree=getParent(arr[i], arr[i].children, "蔷薇科")
            if(typeTree.length>0){
                break;
            }
        }
        let nameTree = []
        typeTree.forEach(iType=>{
            nameTree.push(iType.name)
        })
        console.log({typeTree,nameTree});
    

    3、控制台输出结果:

    {
        nameTree: ["植物界", "被子植物门", "双子叶植物纲", "蔷薇目", "蔷薇科"],
        typeTree: [{...}, {...}, {...}, {...}, {...}]
    }
    

    4、数据结构
    在这里插入图片描述
    [参考链接]:https://blog.csdn.net/qq_36437172/article/details/87198122

    展开全文
  • JavaScript(tree.js): var data = [{ name: 'IT互联网', child: [{ name: '编辑语言', child: [{ name: 'java' }, { name: 'c#/.net' }, { name: 'python' }, ...
  • 介绍两种常用的递归处理数据的方法 首先定义一组树形列表数据 规定:树的最后一级 member 为空的即为成员(也可添加一个 type 标识来判断是否为成员) const memberList = [{ name: '研发部', member: [{ name: ...
  • 使用递归进行处理树形数据 实现方式: <script> //原始从服务器返回的数据 const temp = [ {"id":7, "parent":0, "name":"test0"}, {"id":8, "parent":0, "name":"test1"}, {"id":9, "parent":0, "name...
  • 无限级树正向查找、反向查找例子【递归实现】 无限级树正向查找、反向查找例子【递归实现】 无限级树正向查找、反向查找例子【递归实现】
  • JS递归实现反转数组字符串

    千次阅读 2018-04-20 16:07:28
    直接先上代码,通过标题...每天一个JavaScript实例-递归实现反转数组字符串 var func = function(x,indx,str){ return indx == 0 ? str : func(x,--indx,(str +=" " + x[indx]));; } var arr = new Array("appl
  • 逆向递归JavaScript原型

    千次阅读 2021-05-03 17:28:25
    <!DOCTYPE html> <html lang="en"> <head> <meta charset="UTF-8"> <title>title</title> <script> function F1(age) { this.age = age;... F2.pro.
  • js递归函数递归思想

    2021-01-20 12:27:15
    1、递归函数就是在函数体内调用本函数; 2、递归函数的使用要注意函数终止条件避免死循环,使用递 归的时候必须有一个结束标志,否则会报内存溢出的错误 Maximum call stack size exceeded; 为什么使用递归递归是...
  • 前端的一道面试题,关于:“编写一个递归版本的 reverse(s) 函数,以将字符串s倒置。” 01、分 析 功能:字符串s倒置(倒序) 方法:递归 分析: 若将字符串"hello",实现倒置;先将每一位放到倒数第一位,然后...
  • 可进行逆层次遍历树,例如1(2(4,5),3(6,7))输出4
  • * 递归组装数据 * options 数结构 * code 最后一级的 id * parentHalfKeys 半选的父节点节点 */ recursion(options, code, parentHalfKeys) { let result = [], // 递归结果 tempArry = []; // 缓存数据 // ...
  • 递归说白了就是程序调用自身。 与递推思想相比,递归就是递推的反向过程。 递归的分析思路可以总结为4步: 1、寻找临界条件 2、寻找递推关系 3、总结递归表达式 4、改写成递归函数 ...
  • javascript实现数据结构: 树和二叉树,二叉树的遍历和基本操作 树型结构是一类非常重要的非线性结构。直观地,树型结构是以分支关系定义的层次结构。 树在计算机领域中也有着广泛的应用,例如在编译程序中,用树来...
  • In this tutorial I will talk about how you can reverse a string in JavaScript language. 在本教程中,我将讨论如何使用JavaScript语言反转字符串。 This is a very popular question i.e. asked in ...
  • 三、递归求阶乘 function factorial(n) { if (n ) { return 1 ; } else { return n * factorial(n - 1 ); } } alert(factorial( 4));   转载于:...
  • nodejs4: 递归, async await

    2020-08-04 00:19:40
    实现功能:打印wwwroot下所有的目录 ...1 递归:匿名自执行函数 const fs = require('fs'); var path = './wwwroot'; var dirArr = []; fs.readdir(path, (err, files) => { if (err) throw err; (function g
  • 如何实现对对象数组混合的递归深拷贝 方法由复杂到简单 方法一 var copy_data = deepCopy(data); data.name = 'tast' function deepCopy(data) { // 判断是数组还是对象 if (Array.isArray(data)) { var res = ...
  • JS函数定义的方式 普通的函数定义方式: function f1(x1,x2){ return x1+x2; } var x=f1(10,20); 字面量定义函数: var f2 = function(x1,x2){ return x1-x2; } var x = f2(200,100); 利用构造函数的方式: var f3...
  • 标准unix/linux下的...国内第一Kotlin 开发者社区公众号,主要分享、交流 Kotlin 编程语言、Spring Boot、Android、React.js/Node.js、函数式编程、编程思想等相关主题。 Kotlin 开发者社区
  • bootstrap样式实践jqgrid+bootstrap样式实践,报错数据加载,选中,删除等功能 需要引入的样式 bootstrap.min.css ui.jqgrid.css 需要引入的JS jquery.min.js b ...自动化运维工具ansible部署以及使用测试环境master ...
  • function f1(a){ // a值为 5,4,3,2,1,0 if(a==0){ return; } else{ f1(a-1); } console.log(a); //输出值为1,2,3,4,5 }; f1(5);...求解
  • var newTree = getNewTree(oldTree); // 递归 function getNewTree (tree) { return tree.map(function (v) { var item = { text: v.typeName, id: v.id }; ...
  • 递归超时怎么办?递归的优化之道 平时在做题的时候,我们经常都要用到递归来解题,因为递归能最快速的让计算机知道我们想让他做什么,解放了我们的思维量(但在一定程度上加重了计算机的计算量,这也是可能超时的...
  • 浅谈闭包和递归

    千次阅读 2019-10-02 15:52:53
    闭包和递归时函数中的两个比较特殊的情况,并且都被告诫人们要慎用。闭包相当于函数的返回值为另一个函数,而递归则相当于函数的参数为另一个函数。 一、闭包 概念:能够访问其他函数内部的变量的函数。也可以理解...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 9,967
精华内容 3,986
关键字:

js反向递归