C# 字典中的下一个键

Question

如何使用 key 获取 -Sorted- 字典中项目的 Enumerator ？

注意：GetEnumerator() 获取第一个元素的 Enumerator 。

但是我需要获取第一个元素的 Enumerator具有给定键的元素，以便使用 MoveNext() 访问下一个元素，例如...

编辑： 或者访问下一个元素的方法...

编辑：我更喜欢 const time 方法...

谢谢

Answer 1

var enumerator = dictionary.Keys.SkipWhile(k => k != myKey)

其中 myKey 是您要查找的密钥。如果你想对键进行排序，你可以使用 OrderBy 扩展方法。

编辑：您无法使用 Dictionary/SortedDictionary 进行常量编辑。为什么不实现你自己的二叉搜索树（就像 SortedDictionary 一样）并且你将有 O(log n) 时间查找和 O(1) 时间.next()？

Answer 2

也许这对某人有用：

public Dictionary<string, int> myDictionary = new Dictionary<string, int>();
public string myCurrentKey = "some key 5";
for (int i = 1; i <= 10; i++) {
    myDictionary.Add(string.Format("some key {0}", i), i);
}

private void MoveIndex(int dir) { // param "dir" can be 1 or -1 to move index forward or backward
    List<string> keys = new List<string>(myDictionary.Keys);
    int newIndex = keys.IndexOf(myCurrentKey) - dir;
    if (newIndex < 0) {
        newIndex = myDictionary.Count - 1;
    } else if (newIndex > myDictionary.Count - 1) {
        newIndex = 0;
    }

    myCurrentKey = keys[newIndex];
}

Debug.Log(string.Format("Current value: {0}", myDictionary[myCurrentKey])); // prints 5
MoveIndex(1);
Debug.Log(string.Format("Current value: {0}", myDictionary[myCurrentKey])); // prints 6
MoveIndex(-1);
MoveIndex(-1);
Debug.Log(string.Format("Current value: {0}", myDictionary[myCurrentKey])); // prints 4

Answer 3

您无法使用字典来做到这一点。
您可以通过索引访问来实现这一点，因此您可以使用 SortedList 而不是字典。您还可以查看 SkipWhile。

虽然你可以有一些像这样的解决方法：

Dictionary<int, int> dictionary = new Dictionary<int, int>();
foreach (KeyValuePair<int, int> pair in dictionary)
{ 
   // you can check the key you need and assume that the next one will be what you need.
}

但这当然不是最好的主意。

Answer 4

如果您安装了 Framework >=3.5，请使用 SkipWhile Janus Tondering 和卢克建议道。
对于较低的框架版本，您必须自己执行此操作（可以使用从键​​到末尾的键值对填充第二个字典）。

Answer 5

var query = yourDictionary.SkipWhile(kvp => kvp.Key != keyToFind);
foreach (var result in query)
{
    // ...
}

Answer 6

最简单的选择是使用 SortedList，然后向其中添加一个扩展方法，该方法返回一个 IEnumerable，其元素大于或等于给定键。下面的 GetElementsGreaterThanOrEqual 方法获取第一个元素的复杂度为 O(log(n))，之后的每次迭代的复杂度为 O(1)。

public static class SortedListExtension
{
    public static IEnumerable<KeyValuePair<TKey, TValue>> GetElementsGreaterThanOrEqual<TKey, TValue>(this SortedList<TKey, TValue> instance, TKey target) where TKey : IComparable<TKey>
    {
        int index = instance.BinarySearch(target);
        if (index < 0)
        {
            index = ~index;
        }
        for (int i = index; i < instance.Count; i++)
        {
            yield return new KeyValuePair<TKey, TValue>(instance.Keys[i], instance.Values[i]);
        }
    }

    public static int BinarySearch<TKey, TValue>(this SortedList<TKey, TValue> instance, TKey target) where TKey : IComparable<TKey>
    {
        int lo = 0;
        int hi = instance.Count - 1;
        while (lo <= hi)
        {
            int index = lo + ((hi - lo) >> 1);
            int compare = instance.Keys[index].CompareTo(target);
            if (compare == 0)
            {
                return index;
            }
            else
            {
                if (compare < 0)
                {
                    lo = index + 1;
                }
                else
                {
                    hi = index - 1;
                }
            }
        }
        return ~lo;
    }
}