C# 如何在列表中存储成对的数字，并且仍然能够根据第一个元素对它们进行排序和二进制搜索？

基本上，我需要能够根据第一个数字进行排序和二进制搜索，但我还需要将第二个数字与每个元素相关联

我不能做键值对，因为键不一定是唯一的。但我觉得这必须足够普遍，以保证某种内置解决方案，比如Pairs或其他什么，只是我不知道如何使它们仍然基于Pairs中的第一个int进行排序

有什么想法吗

编辑：

根据你的建议，我用我的脸做了以下几点：

public class Pair
{
    int first;
    int second;
    public Pair(int x, int y)
    {
        first = x;
        second = y;
    }
    public int CompareTo(Pair compair)
    {
        if (compair != null)
        {
            return this.first.CompareTo(compair.first);
        }
        else
            return 1;
    }
}

我真的很希望能有一行和内置的东西，如果我需要在某种面试中这样做的话，可以提高速度，但我想这是可行的。

List
List<Tuple<int,int>> 

---

然后，第一个数字不必是唯一的

创建包含2个点的类，按照所述实现

，并且在开始时，您可以创建一对类，以进行比较。但这一要求给工程带来了麻烦：

我不能做键值对，因为键不一定是 独一无二

这告诉我，对于

first

，可以有多个具有相同值的对。您可以按原样声明

对

类，然后基于该键使用

SortedDictionary

。它们将在输入时进行排序，您可以执行O（1）哈希表查找：

var input = new[]{
    new Pair(1, 1),
    new Pair(5, 2),
    new Pair(1, 2),
    new Pair(2, 1),
    new Pair(7, 4),
    new Pair(3, 1),
    new Pair(7, 2)
};

SortedDictionary<int, List<Pair>> pairs = 
    new SortedDictionary<int, List<Pair>>();

foreach(var pair in input)
{
    if (!pairs.ContainsKey(pair.First))
        pairs.Add(pair.First, new List<Pair>());

    pairs[pair.First].Add(pair);
}

这可能是我要走的路线（或多或少取决于确切的要求）。你还说：

我真的希望有一条线和内置的东西

嗯，我能想到的最接近“内置”的是使用

Tuple

和一点LINQ。为了清晰起见，我将其分为两行，但可以很容易地组合成一行：

var input = new[]{
    Tuple.Create(1, 1),
    Tuple.Create(5, 2),
    Tuple.Create(1, 2),
    Tuple.Create(2, 1),
    Tuple.Create(7, 4),
    Tuple.Create(3, 1),
    Tuple.Create(7, 2)
};

var unsortedDictionary = input
    .GroupBy(p => p.Item1)
    .ToDictionary(g => g.Key, g => g.Select(i => i));

var sortedDictionary = 
    new SortedDictionary<int, IEnumerable<Tuple<int, int>>>(unsortedDictionary);

var输入=新[]{
Tuple.Create（1，1），
Tuple.Create（5,2），
Tuple.Create（1,2），
Tuple.Create（2，1），
Tuple.Create（7,4），
Tuple.Create（3,1），
Tuple.Create（7,2）
};
var unsortedDictionary=输入
.GroupBy（p=>p.Item1）
.ToDictionary（g=>g.Key，g=>g.Select（i=>i））；
变量sortedDictionary=
新分类词典（非分类词典）；

但我不确定这是否更好。嵌套的元组有点奇怪。如果需要，元组此时会变得多余，因为字典的“键”与每个值都是重复的，因此您可以将一个“键”与一组“第二”值（每对的后半部分）关联：

var unsortedDictionary=输入
.GroupBy（p=>p.Item1）
.ToDictionary（g=>g.Key，g=>g.Select（i=>i.Item2））；
变量sortedDictionary=
新分类词典（非分类词典）；

---

至于在工作面试中使用速度设置，你可能必须小心。在这里很容易混淆类型（例如，当你只想传递

int

并且错误地声明字典和诸如此类的类型时，传递一个

IEnumerable

非常容易）

我不相信我自己会在白板上写下它而不会犯一万个错误。相关地，我所做的配对解决方案完成了我认为的工作。@NathanTempelman是的，您的解决方案有效，但二进制搜索返回任意一行。@NathanTempelman:关于第一个数字的二进制搜索，字典查找不必这样做。只需使用

.ContainsKey

方法并查找条目；它更快。否则，我们讨论的是一些非常人为的需求。

var input = new[]{
    Tuple.Create(1, 1),
    Tuple.Create(5, 2),
    Tuple.Create(1, 2),
    Tuple.Create(2, 1),
    Tuple.Create(7, 4),
    Tuple.Create(3, 1),
    Tuple.Create(7, 2)
};

var unsortedDictionary = input
    .GroupBy(p => p.Item1)
    .ToDictionary(g => g.Key, g => g.Select(i => i));

var sortedDictionary = 
    new SortedDictionary<int, IEnumerable<Tuple<int, int>>>(unsortedDictionary);

var unsortedDictionary = input
    .GroupBy(p => p.Item1)
    .ToDictionary(g => g.Key, g => g.Select(i => i.Item2));

var sortedDictionary = 
    new SortedDictionary<int, IEnumerable<int>>(unsortedDictionary);