Question

我想写一个linq扩展（或自定义词典，排序列表或任何最佳解决方案），这将允许我为一个集合添加一个值，其键是“下一个可用的”。

例如：

int CreatedKey = IncrementDictionary.AddNext(myCustomer);

如果当前存在的键如下：

然后它将myCustomer添加到字典中，键为5，它将返回该键。

您怎么看？

Answer 1

public static int AddNext(this Dictionary<int, string> dict)
{
    int min = dict.Keys.Min();
    int max = dict.Keys.Max();

    return Enumerable.Range(min, max-min).Except(dict.Keys).First();   
}

将其用作

int result = new Dictionary<int, string>(){ {1, "a"}, {2, "a"}, 
                                            {8, "a"}, {4, "a"}, 
                                                      {3, "a"}}.AddNext();

此处result为5。

Answer 2

您可以使用SortedList扩展方法添加到下一个自动检索的密钥。

假设数据结构是任何对象，使用数字键

以下是SortedList的ExtensionMethod

public static class SortedListExtensions
{
    ///Add item to sortedList (numeric key) to next available key item, and return key
    public static int AddNext<T>(this SortedList<int, T> sortedList, T item)
    {
        int key = 1; // Make it 0 to start from Zero based index
        int count = sortedList.Count;

        int counter=0;
        do
        {
            if (count == 0) break;
            int nextKeyInList = sortedList.Keys[counter++];

            if (key != nextKeyInList) break;

            key = nextKeyInList +1;

            if (count == 1 || counter == count  ) break;


            if (key != sortedList.Keys[counter])
                break;

        } while (true);

        sortedList.Add(key, item);
        return key;
    }

}

可以像以下一样使用

  SortedList<int, string> x = new SortedList<int, string>();

        x.Add(4, "BCD");
        x.Add(6, "BCD");

        x.AddNext("a");
        x.AddNext("b");
        x.AddNext("c");
        x.AddNext("d");
        x.AddNext("e");

        foreach (var item in x)
            Console.WriteLine(item.Key + " " + item.Value);

输出

您可以使用Dictionary或任何其他数据结构。在这种情况下，将需要双循环。在SortedList的情况下，在搜索键时保存一个循环。使用BinarySearch算法，SortedList.Add函数在内部使用此循环。

二进制搜索比循环所有元素（对于更大尺寸的数据）更快。

Answer 3

这是我的解决方案比第一个短，但你可以从中得到一个想法。

        Dictionary<int, string> x = new Dictionary<int, string>();
        x.Add(1, "a");
        x.Add(2, "a");
        x.Add(3, "a");
        x.Add(4, "a");
        x.Add(8, "a");
        Console.WriteLine((x.Keys.Where(k => !x.Keys.Contains(k + 1)).Min() + 1).ToString());

Answer 4

你在寻找这样的东西（它显然只能包含1000个元素）吗？可以有许多其他解决方案，但很难说出你想要做什么。无论如何，这可能是一个起点。

public class IncrementDictionary : Dictionary<int, object>
{
    private bool[] usedKeys = new bool[1000];

    public new void Add(int key, object value)
    {
        base.Add(key, value);
        usedKeys[key] = true;
    }

    public new void Clear()
    {
        base.Clear();
        usedKeys = new bool[1000];
    }

    public new object this[int key] 
    {
        get
        {
            return base[key];
        }
        set
        {
            base[key] = value;
            usedKeys[key] = true;
        }
    }

    public new bool Remove(int key)
    {
        usedKeys[key] = false;
        return base.Remove(key);
    }

    public int AddNext(object anObj)
    {
        int newKey = -1;
        for (int i = 1; i < 1000; i++)
            if (!usedKeys[i])
            {
                newKey = i;
                break;
            }
        if (newKey > 0)
            this.Add(newKey, anObj);
        return newKey;
    }
}

Answer 5

嗯......这是一个老问题，但我想回答。

Nikhil Agrawal的代码可能会有所改进，因为如果你有一个空集合，你必须指定你的最小值。所以代码变成了：

 public static int FirstFree(Dictionary<int, Guid> dict, int minumum)
    {
        int min = dict.Count == 0
            ? minumum                       //use passed minimum if needed
            : dict.Keys.Min();              //use real minimum
        int max = dict.Count > 1
            ? dict.Keys.Max() + 2           //two steps away from maximum, avoids exceptions
            : min + 2;                      //emulate data presence
        return Enumerable.Range(min, max).Except(dict.Keys).First();
    }

但是如果您在定义的范围内工作，您还应该知道是否有空间来存储值。这可以是这样的：

public static int? FirstFree(Dictionary<int, Guid> dict, int min, int max)
    {
        if (max <= min)
            throw new Exception($"Specified range is invalid (must be max > min)");
        if (max - min + 1 == dict.Count)
            //no space left
            return null;
        return Enumerable.Range(min, max).Except(dict.Keys).First();
    }

如果你不喜欢nullable-int，你可以检查结果是否是最低允许值。显然，如果你指定min = int.MinValue它不起作用，我知道，但在这种情况下，问题是这个方法创建的巨大集合！

public static int FirstFree(Dictionary<int, Guid> dict, int min, int max)
    {
        if (max <= min)
            throw new Exception($"Specified range is invalid (must be max > min)");
        if (max - min + 1 == dict.Count)
            //no space left
            return int.MinValue;
        return Enumerable.Range(min, max).Except(dict.Keys).First();
    }

在字典或相关集合中查找“下一个可用”键

5 个答案: