预先收集 C# 的最有效方法

Question

I have a C# Array of objects that needs to stay in order that I'm trying to filter duplicates out of (not same object refference just same attribute values). The catch is the duplicate that has to go is the first one and the oldest needs to stay.

Current algorithm (semi pseudo code renamed everything) using IEnumerable

        object[] filter(object[] array)
        {
            var set = new HashSet<Guid>();
            var filtered = new List<object>();

            for (int i = array.Length; i-- > 0;)
            {
                var item = array[i];

                if (!set.Contains(item.ID))
                {
                    set.Add(item.ID);
                    filtered = new List<object>(filtered.Prepend(item));
                }
            }

            return filtered.ToArray();
        }

I know it is currently O(n) but I am looking for a very efficient way of doing this. If possible with just arrays so I don't need to use.ToArray() and iterate again.

I could just make filtered an array of size array.length and put it in backwards ie "filtered[array.length-i] = item" but I don't want to have empty values.

Answer 1

Pushing to a stack can be thought of as adding to the start of a list, and popping from a stack can be thought of as removing an item from the start of a list.

Stack<T>.Push is a constant time operation as long as the stack has enough capacity, as the documentation says, so you can use a stack instead:

// using object[] doesn't make sense here as it doesn't have an ID property,
// so I have taken the liberty to create my interface
IHasID[] Filter(IHasID[] array)
{
    var set = new HashSet<Guid>();
    // if not many elements are expected to be filtered, giving the stack a initial capacity might be better
    var filtered = new Stack<IHasID>(/*array.Length*/);

    for (int i = array.Length; i-- > 0;)
    {
        var item = array[i];

        if (set.Add(item.ID))
        {

            filtered.Push(item);
        }
    }

    // ToArray creates an array in the pop order, O(n)
    // https://docs.microsoft.com/en-us/dotnet/api/system.collections.generic.stack-1.toarray?view=net-5.0#remarks
    return filtered.ToArray();
}

interface IHasID
{
    Guid ID { get; }
}

Answer 2

Just use LINQ and it will be single O(n) CPU, O(n) RAM passthrough iterator without any further allocations:

var result = input.Reverse().DistinctBy(x=> x.YourKey);

Sample of implementation is here - LINQ's Distinct() on a particular property

You can also do same thing like this, cause all it does is just create group iterators:

var result = input.Reverse().GroupBy(x=> x.YourKey).Select(x=> x.First());