快速找到SortedDictionary中第一个未使用的密钥？

Question

If I have a SortedDictionary<int, object> , what is the fastest way to find the lowest key that is not currently being used? Obviously, we could iterate a counter i from 0-> int.MaxValue and escape if !Keys.Contains(i) , but that would be very slow unless we were lucky and the first spare key happened to be early on in the sequence of keys. Maybe even a different .NET class does this for us already?

Answer 1

So, If I understand you correctly, the keys can be anywhere from 0 to int.MaxValue . In that case, you have to find the first "hole" in the sequence of keys.

This should do the job efficiently:

public static int GetFirstUnusedKey<TValue>(SortedDictionary<int, TValue> dict)
{
    if (dict.Comparer != Comparer<int>.Default)
        throw new NotSupportedException("Unsupported comparer");

    using (var enumerator = dict.GetEnumerator())
    {
        if (!enumerator.MoveNext())
            return 0;

        var nextKeyInSequence = enumerator.Current.Key + 1;

        if (nextKeyInSequence < 1)
            throw new InvalidOperationException("The dictionary contains keys less than 0");

        if (nextKeyInSequence != 1)
            return 0;

        while (enumerator.MoveNext())
        {
            var key = enumerator.Current.Key;
            if (key > nextKeyInSequence)
                return nextKeyInSequence;

            ++nextKeyInSequence;
        }

        return nextKeyInSequence;
    }
}

I added a couple of checks to ensure the preconditions are valid.

Answer 2

Why not a binary search on the keys?

You can use ElementAt() method to identify the key value at an index. If the key value is greater than the index, then search in the left sub dictionary or choose the right and go on that way till you find the index at which you observe the first difference between index and the value at the index.

Answer 3

I'm not claiming any sort of performance trophy for this approach, but I think it goes someway towards achieving your aim:

var sd = new SortedDictionary<int, object>();

sd.Add(1, 1);
sd.Add(2, 1);
sd.Add(4, 1);
sd.Add(5, 1);

var e = Enumerable.Range(1, 5).Except(sd.Keys).First();

e = 3 in this case, as intended. I would expect that there are better solutions, though.

Answer 4

Do not search for a unused key starting at 0.

Instead iterate the used keys, starting at the lowest (they are sorted).

Either the first is >0 then 0 is your lowest unused.

or there is a gap between two keys, then lower+1 is what you searched for.