C# 从字典C生成所有密钥对

我想创建一个以字典顺序存储的密钥对列表并不重要 结果应类似于在数组结构上工作的以下代码：

int[] myArray = new int[] {1,2,3,4,5,6,7,8,9};
List<Tuple<int, int>> list = new List<Tuple<int, int>>();

for (int i = 0; i < myArray.Length; i++)
    for (int j = i + 1; j < myArray.Length; j++)
        list.Add(new Tuple<int, int>(myArray[i], myArray[j]));

方法，然后运行两个嵌套循环。 也许还有其他更有效的解决方案

编辑： 最后一项任务是创建一个矩阵，我可以将每个条目与所有其他条目进行比较 字典的值在此任务中并不重要。 我想创建一个所有键组合的列表顺序并不重要

有没有更好的方法：

Dictionary<int, object> dict = new Dictionary<int, object>();
dict.Add(1, null);
dict.Add(2, null);
dict.Add(3, null);
dict.Add(4, null);
//...

int[] dictKeys = dict.Keys.ToArray();
List<Tuple<int, int>> list = new List<Tuple<int, int>>();

    for (int i = 0; i < dictKeys.Length; i++)
        for (int j = i + 1; j < dictKeys.Length; j++)
            list.Add(new Tuple<int, int>(dictKeys[i], dictKeys[j]));

也许这个Linq查询就是您想要的：

List<Tuple<int, int>> content = dict.Keys.SelectMany(x => 
            dict.Keys, (x, y) => new Tuple<int,int>(x, y)).ToList();

对于键为1、2、3的词典，它将给出9个元组：

1,1,2 1,3 2,1 2,2 2,3

---

3,1 3,2 3,3

你所拥有的几乎是产生结果的最简单的方法

尽管直接循环字典键是可能的，但您应该将它们实现为一个数组，以便通过索引轻松访问它们

不过，在使用它之前，您不必创建整个组合矩阵。您可以创建一个枚举器，在循环时创建矩阵：

public static IEnumerable<Tuple<int, int>> Combinations(IEnumerable<int> keys) {
  int[] a = keys.ToArray();
  for (int i = 0; i < a.Length; i++) {
    for (int j = i + 1; j < a.Length; j++) {
      yield return new Tuple<int, int>(a[i], a[j]);
    }
  }
}

用法：

foreach (Tuple<int, int> t in Combinations(myDictionary.Keys)) {
  // the pair of keys is t.Item1 and t.Item2
}

---

您可以使用生成笛卡尔积的方法：

然后在钥匙上使用它：

IEnumerable<int> firstKeySet = dict.Keys;
IEnumerable<int> secondKeySet = dict.Keys;
IEnumerable<KeyValuePair<int, int>> cartasian = firstKeySet
                                                .Cartesian(secondKeySet, 
                                                          (k, v) => 
                                                           new KeyValuePair<int, int>
                                                          (k, v));

---

你可以在里面找到这一点和更多信息。

我将使用以下方法：

int[] myArray = new int[] { 1, 2, 3, 4, 5, 6, 7, 8, 9 };
var query = from x in Enumerable.Range(0, myArray.Length)
            from y in Enumerable.Range(0, myArray.Length)
            select new Tuple<int, int>(x, y);

foreach (var tupel in query)
{
    Console.WriteLine(tupel);
}

---

要比较所有的组合，您不需要对它们进行双向比较，例如，当您将dict[1]与dict[2]进行比较时，您不需要将dict[2]与dict[1]进行比较。对不起，您所说的比较是什么意思？我不确定我是否听懂了。问题是如何将字典中的每一项与字典中的所有其他项进行比较。当您比较两个项目时，您不必交换它们并再次比较它们。当你有组合1，2时，你不需要组合2，1。也是笛卡尔积。也是笛卡尔积。

IEnumerable<int> firstKeySet = dict.Keys;
IEnumerable<int> secondKeySet = dict.Keys;
IEnumerable<KeyValuePair<int, int>> cartasian = firstKeySet
                                                .Cartesian(secondKeySet, 
                                                          (k, v) => 
                                                           new KeyValuePair<int, int>
                                                          (k, v));

int[] myArray = new int[] { 1, 2, 3, 4, 5, 6, 7, 8, 9 };
var query = from x in Enumerable.Range(0, myArray.Length)
            from y in Enumerable.Range(0, myArray.Length)
            select new Tuple<int, int>(x, y);

foreach (var tupel in query)
{
    Console.WriteLine(tupel);
}