C# 从平面列表创建有向图

我想创建一个图表。我的要求是：

我有用于调度的共享资源

 1,2,3,4,5,7,8,9 

每一个都可以组合起来创建节点

所以我可以有这样的节点：

 [1,3],[2],[5,7,6,9] //[...] means that is one node (and can be complex)
                     //[...] is one job which have assigned multiple resources

基本上我需要的是安排依赖于共享资源的作业。所有这些都是同时发生的，这就是为什么我需要这个树能够在作业上迭代，在几个线程中运行自由作业（f.e 8线程），等待作业完成并运行其依赖的作业

因此，我实现了一个从平面列表创建图形的算法。这些平面列表如下所示：

    var nodes = new List<IDependencyJobNode>()
    {
        new DependandJobNode(new DependandJob(new List<int> { 1 }, ()=>{})),
        new DependandJobNode(new DependandJob(new List<int> { 2 }, ()=>{})),
        new DependandJobNode(new DependandJob(new List<int> { 1, 5, 4, 8 }, ()=>{})),
        new DependandJobNode(new DependandJob(new List<int> { 2, 3, 7, 9 }, ()=>{})),
        new DependandJobNode(new DependandJob(new List<int> { 8, 2 }, ()=>{})),
        new DependandJobNode(new DependandJob(new List<int> { 5, 7 }, ()=>{})),
        new DependandJobNode(new DependandJob(new List<int> { 5, 8 }, ()=>{})),
    }; 

节点[5,8]将遍历2次，一次从[1]开始，第二次从[2]开始，这给了我四个父节点（不需要复制父节点）

这是我的实现

public class TreeBuilder
{
    private IEnumerable<IDependencyJobNode> jobs;
    public int Depth { get; private set; }
    private int currentLevel;

    public IDependencyJobNode Root{ get; private set; }

    public TreeBuilder(IEnumerable<IDependencyJobNode> jobs)
    {
        this.jobs = jobs;
        this.Depth = 0;
    }

    public void Create(IDependencyJobNode root)
    {

        var depths = new List<int> ();
        for (int i = 0; i < jobs.Count(); ++i) {
            depths.Add(Insert(root, jobs.ElementAt (i), Depth + 1));
        }

        this.Depth = depths.Max ();

        this.Root = root;
    }

    public int Insert(IDependencyJobNode root, IDependencyJobNode job, int depth){
        var insertAsChild = true;
        for(int i = 0; i < root.Childs.Count(); ++i){
            var rootElement = root.Childs.ElementAt (i);
            if (HasCommonGpio (rootElement, job)) {
                depth = Insert (rootElement, job, depth + 1);
                insertAsChild = false;
            }
        }
        if (insertAsChild == true) {
            job.Parents.Add(root);
            root.AddChild (job);
        }
        return depth;
    }

    private static bool HasCommonGpio(IDependencyJobNode root, IDependencyJobNode job)
    {
        for(int i = 0; i < root.Job.UsedGpio.Count (); ++i){
            for (int j = 0; j < job.Job.UsedGpio.Count (); ++j) {
                if (root.Job.UsedGpio.ElementAt (i) == job.Job.UsedGpio.ElementAt (j)) {
                    return true;
                }
            }
        }
        return HasCommonGpio (root.Childs, job);
    }

    private static bool HasCommonGpio(IEnumerable<IDependencyJobNode> roots, IDependencyJobNode job)
    {
        if (roots == null || !roots.Any ()) {
            return false;
        }
        foreach (var root in roots) {
            if (HasCommonGpio (root, job)) {
                return true;
            }
        }
        return false;
    }
}

公共类树生成器
{
私人就业；
公共int深度{get；私有集；}
私家级；
public IDependencyJobNode根{get；private set；}
公共树生成器（IEnumerable作业）
{
这个.工作=工作；
这个。深度=0；
}
public void Create（IDependencyJobNode根目录）
{
var深度=新列表（）；
对于（int i=0；i

我无法处理这个问题，有没有通用的算法来实现这样的图，并处理这样复杂的情况？我不知道如何让它工作，也许有人会分享一些想法

public class TreeBuilder
{
    private IEnumerable<IDependencyJobNode> jobs;
    public int Depth { get; private set; }
    private int currentLevel;

    public IDependencyJobNode Root{ get; private set; }

    public TreeBuilder(IEnumerable<IDependencyJobNode> jobs)
    {
        this.jobs = jobs;
        this.Depth = 0;
    }

    public void Create(IDependencyJobNode root)
    {

        var depths = new List<int> ();
        for (int i = 0; i < jobs.Count(); ++i) {
            depths.Add(Insert(root, jobs.ElementAt (i), Depth + 1));
        }

        this.Depth = depths.Max ();

        this.Root = root;
    }

    public int Insert(IDependencyJobNode root, IDependencyJobNode job, int depth){
        var insertAsChild = true;
        for(int i = 0; i < root.Childs.Count(); ++i){
            var rootElement = root.Childs.ElementAt (i);
            if (HasCommonGpio (rootElement, job)) {
                depth = Insert (rootElement, job, depth + 1);
                insertAsChild = false;
            }
        }
        if (insertAsChild == true) {
            job.Parents.Add(root);
            root.AddChild (job);
        }
        return depth;
    }

    private static bool HasCommonGpio(IDependencyJobNode root, IDependencyJobNode job)
    {
        for(int i = 0; i < root.Job.UsedGpio.Count (); ++i){
            for (int j = 0; j < job.Job.UsedGpio.Count (); ++j) {
                if (root.Job.UsedGpio.ElementAt (i) == job.Job.UsedGpio.ElementAt (j)) {
                    return true;
                }
            }
        }
        return HasCommonGpio (root.Childs, job);
    }

    private static bool HasCommonGpio(IEnumerable<IDependencyJobNode> roots, IDependencyJobNode job)
    {
        if (roots == null || !roots.Any ()) {
            return false;
        }
        foreach (var root in roots) {
            if (HasCommonGpio (root, job)) {
                return true;
            }
        }
        return false;
    }
}