Javascript 按嵌套的依赖数组元素对数组进行分组

我有一个数组存储任务信息。每个任务也有一个它所依赖的任务ID数组

输入

let inputArr = [
    {
        id: 1,
        dependOnTasks: [2, 3]
    },
    {
        id: 2,
        dependOnTasks: [3]
    },
    {
        id: 3,
        dependOnTasks: []
    },
    {
        id: 4,
        dependOnTasks: [5]
    },
    {
        id: 5,
        dependOnTasks: []
    },
    {
        id: 6,
        dependOnTasks: [5]
    }
]

[
    [
        {
            id: 1,
            dependOnTasks: [2, 3]
        },
        {
            id: 2,
            dependOnTasks: [3]
        },
        {
            id: 3,
            dependOnTasks: []
        }
    ],
    [
        {
            id: 4,
            dependOnTasks: [5]
        },
        {
            id: 5,
            dependOnTasks: []
        },
        {
            id: 6,
            dependOnTasks: [5]
        }
    ]
]

预期的输出是将所有依赖的任务分组到一个数组中，以显示在UI中

输出

let inputArr = [
    {
        id: 1,
        dependOnTasks: [2, 3]
    },
    {
        id: 2,
        dependOnTasks: [3]
    },
    {
        id: 3,
        dependOnTasks: []
    },
    {
        id: 4,
        dependOnTasks: [5]
    },
    {
        id: 5,
        dependOnTasks: []
    },
    {
        id: 6,
        dependOnTasks: [5]
    }
]

[
    [
        {
            id: 1,
            dependOnTasks: [2, 3]
        },
        {
            id: 2,
            dependOnTasks: [3]
        },
        {
            id: 3,
            dependOnTasks: []
        }
    ],
    [
        {
            id: 4,
            dependOnTasks: [5]
        },
        {
            id: 5,
            dependOnTasks: []
        },
        {
            id: 6,
            dependOnTasks: [5]
        }
    ]
]

我已经做了一个函数来做它，但似乎我的想法是错误的硬编码它。希望有人能帮助我用纯JavaScript/TypeScript或下划线正确归档，因为我们已经在项目中使用了

---

---

注意：如果您不关心同一组中任务的顺序，TaskId将是类似“5878465507b36e1f9c4c46fe”的随机字符串。使用

union和find

实现

不相交集

可能是一种选择

Util数据结构：

function UnionFind(n) {
  this.parent = [...Array(n+1).keys()]
}

UnionFind.prototype.find = function(x) {
  if (this.parent[x] === x) {
    return x
  }
  const ret = this.find(this.parent[x])
  this.parent[x] = ret
  return ret
}

UnionFind.prototype.union = function(x, y) {
  let x_rep = this.find(x)
  let y_rep = this.find(y)
  if (x_rep !== y_rep) {
    this.parent[x_rep] = y_rep
  }
}

哑数据源：

let inputArr = [
    {
        id: 1,
        dependOnTasks: [2, 3]
    },
    {
        id: 2,
        dependOnTasks: [3]
    },
    {
        id: 3,
        dependOnTasks: []
    },
    {
        id: 4,
        dependOnTasks: [5]
    },
    {
        id: 5,
        dependOnTasks: []
    },
    {
        id: 6,
        dependOnTasks: [5]
    }
]

驱动程序：

let len = inputArr.length
let uf = new UnionFind(len)

// iterate through all tasks to group them
inputArr.forEach(entry => {
  entry.dependOnTasks.forEach(depsId => {
    uf.union(entry.id, depsId)
  })
})

// reiterate to retrieve each task's group and group them using a hash table
let groups = {}
inputArr.forEach(entry => {
  const groupId = uf.find(entry.id)
  if (!groups.hasOwnProperty(groupId)) {
    groups[groupId] = [entry]
    return
  }
  groups[groupId].push(entry)
})

let result = Object.keys(groups).map(groupId => groups[groupId])
console.log(JSON.stringify(result, null, 2))

---

注意：如果在你的情况下ID为随机字符串，只需将<代码> >父/代码>为哈希映射，如果你关心顺序（因为有依赖树），请考虑使用<代码>拓扑排序。

< P>解决方案很简单，

初始化空组列表

对于每个任务，查找组列表中是否有id为或id为任何从属任务的组

如果没有，请添加具有任务id和从属任务的新组

var输入=[
{id:1，dependentasks:[2,3]}，
{id:2，dependentasks:[3]}，
{id:3，dependentasks:[]}，
{id:4，dependentasks:[5]}，
{id:5，dependentasks:[]}，
{id:6，dependentasks:[5]}
];
var组=[]；
对于（变量i=0；i'）；
document.write（组[1].ids+'
'）；
函数findGroup（组、任务）{
对于（变量i=0；i}

您可以尝试使用我的代码

var-inputArr=[
{
id:1，
依赖任务：[2,3]
},
{
id:2，
依赖任务：[3]
},
{
id:3，
依赖任务：[]
},
{
id:4，
依赖任务：[5]
},
{
id:5，
依赖任务：[]
},
{
id:6，
依赖任务：[5]
}
]
//生成矩阵图
var-map={}；
对于（变量i=0；i=0；
})[0]
如果（！组）{
组=[键]；
组任务。推送（组）；
}
for（映射中的var dependKey[键]）{
if（group.indexOf（dependKey）=-1）{
分组推送（dependKey）；
}
}
}
var result=groupTasks.map（函数（组）{
var任务=[]；
group.forEach（函数（id）{
var task=inputArr.filter（函数（e）{returne e.id==id}）[0]；
任务。推送（任务）；
});
返回任务；
})
log（JSON.stringify（result，null，4））如果任务3依赖于任务4，那么预期输出是什么？或者任务5依赖于任务1？如果任务3依赖于任务4，我们可以得出结论，所有任务都相互依赖。因此，结果将是一组6个任务。如果任务5依赖于任务1，则相同。这对你来说够清楚吗？如果还有任何查询，请告诉我。ID是这样的吗（1表示第一个对象，2表示第二个对象，依此类推？或者它们是随机数？它将是随机字符串，如“5878465507b36e1f9c4c46fe”。谢谢Xele，我现在正在检查它。根据我的数据，它似乎有点错误。稍后我将用这些数据更新问题。