c# - c#中的字典迭代器

Question

我想知道在遍历字典时是否有任何方法可以存储键值对枚举器的值。我想将枚举数的键和值存储在某个变量中。解决办法是什么？我想做的是在遍历字典时引用当前键值对和字典中的下一个键值对。我不知道为什么它不起作用

解决方案可能如下所示：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Collections;
using System.Diagnostics;

namespace WellPuzzle
{

    class Solution
    {
        Hashtable h1 = new Hashtable();
        List<int> listofitemstoremove = new List<int>();

        Dictionary<int, int> d1 = new Dictionary<int, int>();

        public void falling_disks(int[] A, int[] B)
        {
            var itemstoremove = new List<int>();

            var en = d1.GetEnumerator();
            int count = 0;
            for (int i = 0; i <= A.Length - 1; i++)
            {
                d1.Add(count++, A[i]);
            }
            //for each incoming element in array
            foreach (int ele in B)
            {
               //store prev as current position of enumerator
                var prev = new KeyValuePair<int, int>();
                prev = en.Current;
                //check if it is possible to iterate to next element in dictionary
                if (en.MoveNext())
                {
                   //loop till end of dictionary
                    while (en.MoveNext())
                    {
                       //if current value of enumerator in dictionary is less than incoming                                                element and check if corroesponding key for that value is in hashtable or not
                        if (en.Current.Value <= ele && !(checkifthatvalueisfilled(en.Current.Key)))
                            continue;
                        else
                        {//if current enumerator value is greater than incoming element from array B then remove all elements from prev reference till end of dictionary
                            h1.Add(en.Current.Key, true);
                            listofitemstoremove.Add(en.Current.Key);
                        }
                        prev = en.Current;
                    }

                    if (!(h1.ContainsKey(en.Current.Key)))
                    {
                        h1.Add(en.Current.Key, true);
                        listofitemstoremove.Add(en.Current.Key);
                    }
                }
                else
                {
                    h1.Add(prev.Key, true);
                    listofitemstoremove.Add(prev.Key);
                }
                foreach (int item in listofitemstoremove)
                {
                    for (int i = item; i < d1.Count; i++)
                    {
                        d1.Remove(i++);
                    }
                }
            }

            Console.WriteLine(h1.Count);
        }






        public bool checkifthatvalueisfilled(int value)
        {
            if (h1.ContainsValue(h1.ContainsKey(value)) == true)
                return true;
            else return false;
        }
    }


    class Program
    {
        static void Main(string[] args)
        {
            int[] A = new int[] { 5, 6, 4, 3, 6, 2, 3 };
            int[] B = new int[] { 2, 3 };
            Solution s1 = new Solution();
            s1.falling_disks(A, B);
        }
    }
}

score 2 · Accepted Answer

似乎您希望能够访问序列的先前值以及当前值。这是一个简单的辅助方法，它接受一个序列并将其转换为一个对序列，该序列对表示每个值及其在原始序列中的前一个值：

public static IEnumerable<Tuple<T, T>> GroupAdjacent<T>(IEnumerable<T> source)
{
    using (var iterator = source.GetEnumerator())
    {
        if (!iterator.MoveNext())
        {
            yield break;
        }
        T previous = iterator.Current;

        while (iterator.MoveNext())
        {
            yield return Tuple.Create(previous, iterator.Current);
        }
    }
}

然后可以像这样使用它：

foreach(var pair in GroupAdjacent(dictionary))
{
    var previous = pair.Item1;
    var current = pair.Item2;
}

score 1 · Accepted Answer

您是否有充分的理由不能使用：-

// Replace TKey and TValue with the types from the dictionary
TKey previousKey;
TValue previousValue;

bool first = true;

foreach(var key in dictionary.Keys)
{
  var value = dictionary[key];

  if (!first)
  {
  ... // Do whatever you need to do with the keys and values
  }

  previousKey = key;
  previousValue = value;
  first = false;
}

（但请注意，您可能必须.OrderBy(...)这样.Keys做才能有意义）

score 0 · Accepted Answer

List<KeyValuePair<Int32, Int32>> keyValuePairsWithIterations = new List<KeyValuePair<Int32, Int32>>();

foreach(var keyvaluepair in d1)
{
   keyValuePairsWithIterations.Add(keyvaluepair);
}

现在您可以通过迭代访问您的键值对。但它看起来有点强大......我仍然不明白你需要它......

score 0 · Accepted Answer

除了 Iain 和其他人的方法之外，您也可以这样做（就像 Iain 的那样，这给出了上一个和当前而不是当前和下一个，但它们几乎是一回事）：

using System;
using System.Collections.Generic;

namespace Demo
{
    public static class Program
    {
        private static void Main(string[] args)
        {
            var d1 = new Dictionary<int, int> {{1, 1}, {2, 2}, {3, 3}, {4, 4}};
            bool isFirst = true;
            var previous = new KeyValuePair<int, int>();

            foreach (var current in d1)
            {
                if (!isFirst)
                {
                    // You have current and previous available now.
                    Console.WriteLine("Current = " + current.Value + ", previous = " + previous.Value);
                }

                previous = current;
                isFirst = false;
            }
        }
    }
}

以下是手动使用枚举器的方法：

    using System;
    using System.Collections.Generic;

    namespace Demo
    {
        public static class Program
        {
            private static void Main(string[] args)
            {
                var d1 = new Dictionary<int, int> {{1, 1}, {2, 2}, {3, 3}, {4, 4}};
                var iter = d1.GetEnumerator();

                if (iter.MoveNext())
                {
                    var previous = iter.Current;

                    while (iter.MoveNext())
                    {
                        // You have current and previous available now.
                        Console.WriteLine("Current = " + iter.Current.Value + ", previous = " + previous.Value);
                        previous = iter.Current;
                    }
                }
            }
        }
    }

score 0 · Accepted Answer

为什么需要迭代器？foreach 循环将为您执行此操作。

如果您需要当前和上一个项目，您可以在每次迭代中存储上一个项目：

Dictionary<int, int> d1 = new Dictionary<int, int>();
KeyValuePair<int, int> previous = null;
KeyValuePair<int, int> current = null;
foreach (KeyValuePair<int, int> item in d1)
{
    previous = current;
    current = item;
    // do what you need to do with previous and current
}

你也可以使用一个 SortedDictionary，它会给你一个索引。

c# - c#中的字典迭代器

5 回答 5

Related

Reference