在Linq中通过单链接实体列表自定义订单

Question

I'm trying to come up with an efficient solution to be able to query the entity list and order it correctly. I have created a singly linked list type structure in SQL DB schema. I am using GUID as my IDs but for simplicity, I'll use int here. I could solve this problem easily by having a SortOrder column on the DB but because of other requirements, this is how I have to implement this table.

I have a table structure that looks like the following entity model:

public class Record
{
    public int ID;
    public string Name;
    public int? ChildID;  //References the next record
}

My initial thought is to create a partial class like the following:

public partial class Record
{
    public int SortOrder
    {
        get
        {
           //query table and loop through the entire list building it from
           //the bottom and keeping count of the integer sort order and return 
           //the one specific to this record
        }
    }
}

However, this seems very inefficient to have to query the entire list every time and iterate through to find the SortOrder. Is there anything else I can leverage like a custom OrderBy function or anything? I'm trying sort by the order that would be created when iterating a building the list. For instance, the record with ChildID = null, is the last one in the list, since it does not have a child. I'll start with that record, then get the next one above it that references the previous as its ChildID and go until there is no more in the list that has a reference to ID, which should be when the list is complete and ordered correctly. No two records have the same ChildID.

If I had the following 3 records in a list,

ID = 3,  Name = "Apple",  ChildID = 6,
ID = 54, Name = "Orange", ChildID = 3,
ID = 6,  Name = "Banana", ChildID = null

Then I would expect to get Orange, Apple, Banana, in that order.

Answer 1

One way to do it would be to write a method that will return a list in sorted order. You would first find the record with ChildId == null , add it to the results list, and then continue to search for items where item.ChildId == previousItem.Id , and then insert them at the beginning of the list:

private static IEnumerable<Record> OrderRecords(IReadOnlyCollection<Record> records)
{
    // "Exit fast" checks
    if (records == null) return null;
    if (records.Count < 2) return records.ToList();

    // Get last record and add it to our results
    Record currentRecord = records.Single(r => r.ChildID == null);
    var results = new List<Record> {currentRecord};

    // Keep getting the parent reference to the previous record 
    // and insert it at the beginning of the results list
    while ((currentRecord = records.SingleOrDefault(r => 
        r.ChildID == currentRecord.ID)) != null)
    {
        results.Insert(0, currentRecord);
    }

    return results;
}

In use, this would look something like:

private static void Main()
{
    var records = new List<Record>
    {
        new Record {ID = 3, Name = "Apple", ChildID = 6},
        new Record {ID = 54, Name = "Orange", ChildID = 3},
        new Record {ID = 6, Name = "Banana", ChildID = null}
    };

    var sortedRecords = OrderRecords(records);

    Console.WriteLine(string.Join(", ", sortedRecords.Select(r => r.Name)));

    Console.Write("\nPress any key to exit...");
    Console.ReadKey();
}

Output

Answer 2

Given that the record ID order is random, and assuming that the List you are ordering is complete, or that you won't run out of memory/time if you have to scan the entire table to order the list, I think the best you can do is compute the depth for a Record and cache the results:

I am using the List as the table, but you could use the table instead if the list you want to order is incomplete:

public partial class Record {
    static Dictionary<int, int> depth = new Dictionary<int, int>();
    public int Depth(List<Record> dbTable) {
        int ans = 0;

        var working = new Queue<int>();
        var cur = this;
        do {
            if (depth.TryGetValue(cur.ID, out var curDepth)) {
                ans += curDepth;
                break;
            }
            else {
                working.Enqueue(cur.ID);
                cur = dbTable.FirstOrDefault(r => r.ChildID == cur.ID);
                if (cur != null)
                    ++ans;
            }
        } while (cur != null);

        var workAns = ans;
        while (working.Count > 0) {
            var workingID = working.Dequeue();
            depth.Add(workingID, workAns);
            --workAns;
        }

        return ans;
    }
}

Update: I re-wrote the code to use a specific queue; my first version was recursive and that was straightforward but risked overflowing the stack and my second version didn't cache the intermediate results when following the linked list which wasn't very efficient. Using a queue of the intermediate IDs ensures I only follow a particular chain depth once.

Now that you have a Depth method, sorting is easy:

var ans = work.OrderBy(w => w.Depth(work));

Answer 3

The best algorithm for this task is to prepare a fast lookup data structure (like Dictionary ) of Record by ChildID . Then the ordered result can be produced backwards starting with ChildID = null and using the record ID to find the previous record.

Since the hash lookup time complexity is O(1), the time complexity of the algorithm is linear O(N) - the fastest possible.

Here is the implementation:

static Record[] Ordered(IEnumerable<Record> records)
{
    var recordByNextId = records.ToDictionary(e => e.ChildID.Wrap());
    var result = new Record[recordByNextId.Count];
    int? nextId = null;
    for (int i = result.Length - 1; i >=0; i--)
        nextId = (result[i] = recordByNextId[nextId]).ID;
    return result;
}

The explanation of e.ChildID.Wrap() custom extension method. I wish I can use simply e.ChildID , but the BCL Dictionary class throws annoying exception for null key. To overcome that limitation in general, I use a simple wrapper struct and "fluent" helper:

public struct ValueWrapper<T> : IEquatable<ValueWrapper<T>>
{
    public readonly T Value;
    public ValueWrapper(T value) => Value = value;
    public bool Equals(ValueWrapper<T> other) => EqualityComparer<T>.Default.Equals(Value, other.Value);
    public override bool Equals(object obj) => obj is ValueWrapper<T> other && Equals(other);
    public override int GetHashCode() => EqualityComparer<T>.Default.GetHashCode(Value);
    public static implicit operator ValueWrapper<T>(T x) => new ValueWrapper<T>(x);
    public static implicit operator T(ValueWrapper<T> x) => x.Value;
}

public static class ValueWrapper
{
    public static ValueWrapper<T> Wrap<T>(this T value) => new ValueWrapper<T>(value);
}