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); 
     } 
    } 
} 

Answer 1

有没有你不能使用一个很好的理由： -

// 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为此作出任何意义）

Answer 2

除了伊恩的和其他的方法，你也可以做这样的（像伊恩的，这给以往和当前，而不是目前和未来，但他们几乎是同样的事情）：

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; 
        } 
       } 
      } 
     } 
    } 

Answer 3

为什么你需要一个迭代器？ 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，会给你一个索引。

Answer 4

看起来你希望能够访问先前的值以及序列的当前值。下面是接受一个序列，并把它变成一个代表每个值与它的原来的顺序前值对的序列的简单的辅助方法：

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; 
} 

Answer 5

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

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

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