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
    }