Question

我正在寻找一种更好的方法来排序以下类型的数据。以下适用于较小的数据集（在某些系统上，其他9000上的2000）但在处理较大的数据集时会导致堆栈溢出

保存数据的结构如下所示

NSFontAttributeName

以下是需要将数据分类到单个对象中的示例，其中int指示其深度。子级别可能比示例数据中显示的三级更深入

public class AttributeItem
{
    public string AttributeType { get; set; }
    public string Title { get; set; }
    public string Value { get; set; }
    public int ObjectID { get; set; }
    public bool CanModify { get; set; }
    public bool CanDelete { get; set; }
    public bool? IsParent { get; set; }
    public int SortID { get; set; }
    public int? ParentSortID { get; set; }
    public bool Deleted { get; set; }
}

public class AttributeItemNode
{
    public AttributeItem Item {get;set;}
    public int Depth {get;set;}

    public AttributeItemNode(AttributeItem item , int Depth)
    {
        this.Item = item ;
        this.Depth = Depth;
    }
}

预期输出如下（我已从对象中删除了无关数据以帮助提高可读性）

var items = new List<AttributeItem>();
items.Add(new AttributeItem{Title ="Parent1", ObjectID=1,SortID =1, IsParent= true, ParentSortID = Int32.MinValue});

items.Add(new AttributeItem{Title ="FooChild", ObjectID=2,SortID =2, IsParent= false, ParentSortID = 1});

items.Add(new AttributeItem{Title ="Parent2", ObjectID=4,SortID =4, IsParent= true, ParentSortID = Int32.MinValue});

items.Add(new AttributeItem{ Title ="Parent2Child1", ObjectID=5,SortID =5, IsParent= false, ParentSortID = 4});

items.Add(new AttributeItem{Title ="Parent2Child2", ObjectID=7,SortID =7, IsParent= false, ParentSortID = 4});

items.Add(new AttributeItem{Title ="Parent2Child2Child1", ObjectID=6,SortID =6, IsParent= false, ParentSortID = 5});

这是实际的排序代码

Depth = 0 Title ="Parent1"
Depth = 1 Title ="FooChild" 
Depth = 0 Title ="Parent2"
Depth = 1 Title ="Parent2Child1" 
Depth = 2 Title ="Parent2Child2Child1"
Depth = 1 Title ="Parent2Child2"

Answer 1

使用递归可以有效地解决问题。它可以分为两部分 - 创建树结构并使用迭代pre-order Depth First Traversal展平树，对每个级别进行排序。

对于第一部分，我们可以使用LINQ ToLookup方法在O（N）时间内通过ParentSortID创建快速查找结构。

对于第二部分，按照DRY原则，我将使用我对How to flatten tree via LINQ?的回答中的通用方法，通过创建一个重载，允许从项目和深度投影到自定义结果（如你可以看到我已经有了）：

public static class TreeUtils
{
    public static IEnumerable<TResult> Expand<T, TResult>(
        this IEnumerable<T> source, Func<T, IEnumerable<T>> elementSelector, Func<T, int, TResult> resultSelector)
    {
        var stack = new Stack<IEnumerator<T>>();
        var e = source.GetEnumerator();
        try
        {
            while (true)
            {
                while (e.MoveNext())
                {
                    var item = e.Current;
                    yield return resultSelector(item, stack.Count);
                    var elements = elementSelector(item);
                    if (elements == null) continue;
                    stack.Push(e);
                    e = elements.GetEnumerator();
                }
                if (stack.Count == 0) break;
                e.Dispose();
                e = stack.Pop();
            }
        }
        finally
        {
            e.Dispose();
            while (stack.Count != 0) stack.Pop().Dispose();
        }
    }
}

以下是相关方法的实现：

public static IList<AttributeItemNode> SortAttributeItems(IList<AttributeItem> list)
{
    var childrenMap = list.ToLookup(e => e.ParentSortID ?? int.MinValue);
    return childrenMap[int.MinValue].OrderBy(item => item.SortID)
        .Expand(parent => childrenMap[parent.SortID].OrderBy(item => item.SortID),
            (item, depth) => new AttributeItemNode(item, depth))
        .ToList();
}

Answer 2

您有什么理由不能按照父指针来计算深度？

如果您将Dictionary<int,AttributeItem> map与SortId作为关键字，现在可以使用AttributeItem item并执行以下操作：

int depth = 0;
var current = item;
while (!current.IsParent)
{ 
   depth++;
   current = map[current.ParentSortId;
}

如果您使用了许多Nuget软件包中的一个用于树或图形，您可以对数据执行此操作以及许多其他图形操作，包括检查它是否有效且不包含循环。

最好不要以两种方式表示相同的信息：您有IsParent，但ParentSortId上也有标记值。如果这些不同意怎么办？等。

Answer 3

public class AttributeItemNode : IComparable<AttributeNode> {

    public int CompareTo(AttributeItemNode other) {
        // compare the Ids in appropriate order
    }
}

public class NodeCollection {
    protected List<AttributeItemNode> nodes;

    public void AddNode() { }

    public void Sort() { 
       nodes.Sort();
       this.CalcDepth();
    }

    protected void CalcDepth {
        foreach (var node in nodes)
          if (node.IsParent) { node.Depth = 0; break; }

          //use the various Ids that are now in sorted order
          // and calculate the item's Depth.
    }
}

AttributeItem已经拥有了排序所需的一切。使用IsParent（可能？），SortId和ParentSortId来实施上述CompareTo()。

仅在排序后测量深度，这避免了递归的需要。

然后：

myNodeCollection.Sort()

List.Sort() .NET智能地决定使用哪种排序算法。

处理较大的数据集时，排序算法会导致堆栈溢出吗？

3 个答案: