tree 的递归算法

tree的数据结构：
tree = [
 {
    check: false,
    children: [
        check: false,
        children: [
          {  
             {
                check: false,
                children: [
                    {
                           check: false,
                           children: [],
                           code: "SD2016082600160",
                           disabled: false,
                            isLeaf: true,
                            label: "金泰荔湾小区",
                            name: "金泰荔湾小区",
                            open: false,
                            orgLeaf: false,
                            parentCode: "O04464422616",
                            parentName: "测试超长字段的组织",
                            projectCodeList: []   
                     }
                ],
                code: "O04464422616"
                disabled: false,
                isLeaf: false,
                label: "测试超长字段的组织",
                name: "测试超长字段的组织",
                open: false,
                orgLeaf: true,
                parentCode: "080311bbbe8642899d325742b2073805",
                projectCodeList: ["SD2016082600160"]
           },
           {
               check: false,
                children: [],
                code: "SD2016082600170",
                disabled: false,
                isLeaf: true,
                label: "高德公寓",
                name: "高德公寓",
                open: false,
                orgLeaf: false,
                parentCode: "080311bbbe8642899d325742b2073805",
                parentName: "集中管控标准版",
                projectCodeList: []
            }
          }, 
          {
                check: false,
                children: [],
                code: "p201809211",
                disabled: false,
                isLeaf: true,
                label: "集中管控测试项目",
                name: "集中管控测试项目",
                open: false,
                orgLeaf: false,
                parentCode: "fb3087611f248d93d67330b4938fff8e",
                parentName: "集中管控多项目集团",
                projectCodeList: []
           } 
        ],
        code: "080311bbbe8642899d325742b2073805",
        disabled: false,
        isLeaf: false,
        label: "集中管控标准版",
        name: "集中管控标准版",
        open: false,
        orgLeaf: false,
        parentCode: "fb3087611f248d93d67330b4938fff8e",
        projectCodeList: ["SD2016082600170"]
    ],
    code: "fb3087611f248d93d67330b4938fff8e",
    disabled: false,
    isLeaf: false,
    label: "集中管控多项目集团",
    name: "集中管控多项目集团",
    open: false,
    orgLeaf: false,
    projectCodeList: ["p201811081", "p201809211",             SD2016082600190", "SD2016082600164", "SD2016082600196",…]   
  }   
]                                                          

 

1.根据code ，寻找tree里面的选中对象

export function getActiveNode(tree,code){ tree: [{}] // 树型结构
  let node = {};
  finds(tree,code);
  function finds(tree,code) {
    for(let i=0;i<tree.length;i++){
      if(tree[i].code == code){
        node = tree[i]
      } else {
        if(tree[i].children && tree[i].children.length>0){
          finds(tree[i].children,code)
        }
      }
    }
  }
  return node;
}

 

2. 通过code筛选组织树节点，输出 [{}]

export function filterNode (tree, code) {
  if (!code) {return}
  let resultArr = []
  for (let i = 0; i < tree.length; i++) {
    let item = tree[i]
    if (item.code == code) {
      resultArr.push(item)
      return resultArr
    } else if (item.children && item.children.length) {
      resultArr = filterNode(item.children, code)
    }
  }
  return resultArr
}

 

3.有父子关系的数组转换成树形结构的数组

/**
* 该方法用于将有父子关系的数组转换成树形结构的数组
* 接收一个具有父子关系的数组作为参数
* 返回一个树形结构的数组 
*/
export function translateDataToTree (data) {
  let parents = data.filter((item,index) => {return index === data.length-1})
  //有父节点的数据
  let childrens = data.filter(value => value.parentCode)
  //定义转换方法的具体实现
  let translator = (parents, childrens) => {
    parents.forEach((parent) => {
      childrens.forEach((current, index) => {
        if (current.parentCode === parent.code) {
          //对子节点数据进行深复制，这里只支持部分类型的数据深复制，对深复制不了解的童靴可以先去了解下深复制
          let temp = JSON.parse(JSON.stringify(childrens))
          //让当前子节点从temp中移除，temp作为新的子节点数据，这里是为了让递归时，子节点的遍历次数更少，如果父子关系的层级越多，越有利
          temp.splice(index, 1)
          //让当前子节点作为唯一的父节点，去递归查找其对应的子节点
          translator([current], temp)
          //把找到子节点放入父节点的childrens属性中
          typeof parent.children !== 'undefined' ? parent.children.push(current) : parent.children = [current]
          
        }
      })
    })
  }
  //调用转换方法
  translator(parents, childrens)
  //返回最终的结果
  console.log(parents)
  return parents
}

 4. 递归获取第一个节点下面的第一个叶子节点 

// 查找一个树第一个节点的第一个叶子节点，深度遍历

getFirstNode (tree) {
        var temp = {}
        var forFn = function (arr) {
          if (arr && arr.length > 0) {
            temp = arr[0]
            if (arr[0].children) {
              forFn(arr[0].children)
            }
          }
        }
        forFn(tree)
        return temp
      }
            

5. 递归获取第一个节点下面的所有的第一个节点

// 查找一个树多个第一个节点，深度遍历
    getFirstNode (tree) {
      var temp = []
      var forFn = function (arr) {
        if (arr && arr.length > 0) {
          temp.push(arr[0])
          if (arr[0].children) {
            forFn(arr[0].children)
          }
        }
      }
      forFn(tree)
      return temp
    }