不太理解，能解答一下吗

这仅仅是对数组的遍历去重吗，不限制编程语言，遇到的一个笔试题

1.简单的思路给你说一下,就是依次遍历出父节点对象, [7,10] 这是一组父节点对象, [2,11]这是次一级的父节点对象,依次类推

```html
<script>
            let arr = [{
                    node: 2,
                    children: [3, 9, 4]
                },
                {
                    node: 7,
                    children: [2]
                },
                {
                    node: 3,
                    children: [6]
                },
                {
                    node: 4,
                    children: [5]
                },
                {
                    node: 5,
                    children: [8]
                },
                {
                    node: 10,
                    children: [11]
                }

            ]
            let result = []
            var a = 1
            var set = setInterval(() => {
                list()
            }, 200)

            function list() {
                let arr1 = [] // node节点
                let arr2 = [] // children 节点
                let dingji = [] // 顶级父节点
                for (let i = 0; i < arr.length; i++) {
                    if (!result.includes(arr[i].node)) {
                        arr1.push(arr[i].node)
                        arr2.push(...arr[i].children)
                    }
                }
                arr1.forEach(item => {
                    if (!arr2.includes(item)) {
                        dingji.push(item)
                    }
                })
                dingji.forEach(item => {
                    let findIndex = arr.findIndex(items => items.node == item)
                    console.log(findIndex);
                    if (findIndex >= 0) {
                        arr[findIndex].children.forEach(item_two => {
                            let find_two = arr.findIndex(items => items.node == item_two)
                            if (find_two < 0) {
                                dingji.push(item_two)
                            }
                        })
                    }
                })
                result.push(...dingji)

                a++
            }
            setTimeout(() => {
                clearInterval(set)
                console.log(result);
            }, 1200)
        </script>

```

考点是遍历的算法，思路是将原数据重组成为tree结构数据，之后广度遍历tree得到node即可

let obj1 = {node: 2, children: [{node: 3}, {node: 9}, {node:4}]} 
let obj2 = {node: 7, children: [{node: 2}]}
let obj3 = {node: 3, children: [{node: 6}]}
let obj4 = {node: 4, children: [{node: 5}]}
let obj5 = {node: 5, children: [{node: 8}]}
let obj6 = {node: 10, children: [{node: 11}]}

let allObj = [obj1,obj2,obj3,obj4,obj5,obj6]
allObj.forEach((item, index) => {
    findFather(item, index)
})
// 生成树结构
let newArr = []
allObj.forEach(item => {
    if (!item.state) {
        newArr.push(item)
    }
})
// 广度遍历tree结构
let nodes = widthTree(newArr)
console.log(nodes, 'nodes') //  [7, 10, 2, 11, 3, 9, 4, 6, 5, 8] "nodes"

function findFather(arr, index) {
    // 从allObj中排除正在比较的数据
    let newAllObj = []
    allObj.forEach(item => {
        if (item.node !== arr.node) {
            newAllObj.push(item)
        }
    })

    arr.children.forEach(item => {
        let data = newAllObj.find(ite => ite.node === item.node)
        if (data) {
            data.state = 'isSon'
            item.children = data.children
        }
    })
}
// 广度遍历tree结构(百度)
function widthTree(data) {
    let stack = []
    let arr = []
    stack = data
    while (stack.length) {
      let item = stack.shift()
      let children = item.children
      arr.push(item.node)
      if (children) {
        for (let i = 0; i < children.length; i++) {
          stack.push(children[i])
        }
      }
    }
    return arr
}