在列表中存储整数对

Question

如何在列表中存储整数对？ 我知道我可以为它们创建一个类，例如：

class Pair  
{
    int i1,i2;
}

但是如果我这样做，我将无法使用 Contains 函数来检查给定的对是否在列表中。我怎样才能做到这一点，以便我可以轻松地将整数存储在列表中并检查一对整数是否已经存在？我无法使用表格，因为不知道会有多少对。

编辑：
忘记补充： 在我的程序中， (x, y) 和 (y, x) 对被视为平等。

编辑：
检查 Point 是否在列表中时，(x,y) 和 (y,x) 相等，但 x 和 y 不能相等交换是因为 x 和 y 表示两点之间的连接（整数是点的 id，不，我不能使用任何引用等...）。当我检查 List 是否包含连接时，它是 (x,y) 还是 (y,x) 并不重要，但稍后我会需要该信息。

Answer 1

如果您使用的是 .NET 4.0，则可以使用 Tuple 类，如

var tuple = new Tuple<int, int>(17, 42);
var otherTuple = Tuple.Create(17, 42);

和

var list = new List<Tuple<int, int>>();

请注意，如果您采用使用 Tuple 的路线，那么您将需要创建 IEqualityComparer> 的自定义实现，以反映 (x, y) 被视为等于 ( y，x）。然后，您必须将此比较器的实例传递给 List.Contains(T, IEqualityComparer) （此处 T 是 Tuple 为您服务）。

class TupleAsUnorderedPairComparer : IEqualityComparer<Tuple<TFirst, TSecond>> {
    public bool Equals(Tuple<TFirst, TSecond> x, Tuple<TFirst, TSecond> y) {
        if(Object.ReferenceEquals(x, y)) {
            return true;
        }
        if(x == null || y == null) {
            return false;
        }
        return x.Item1 == y.Item1 && x.Item2 == y.Item2 ||
               x.Item1 == y.Item2 && x.Item2 == y.Item1;
    }

    public int GetHashCode(Tuple<TFirst, TSecond> x) {
        if(x == null) {
            return 0;
        }
        return x.Item1.GetHashCode() ^ x.Item2.GetHashCode();
    }
}

否则，如果您不能或不想使用 Tuple，那么您需要为您的 Pair 实现 IEqualityComparer类或覆盖 Object.Equals 和 Object.GetHashCode。

class Pair {
    public int First { get; private set; }
    public int Second { get; private set; }
    public Pair(int first, int second) {
        this.First = first;
        this.Second = second;
    }

    public override bool Equals(object obj) {
        if(Object.ReferenceEquals(this, obj)) {
            return true;
        }
        Pair instance = obj as Pair;
        if(instance == null) {
            return false;
        }
        return this.First == instance.First && this.Second == instance.Second ||
               this.First == instance.Second && this.Second == instance.First;
    }

    public override int GetHashCode() {
        return this.First.GetHashCode() ^ this.Second.GetHashCode();
    }
}

如果

class PairEqualityComparer : IEqualityComparer<Pair> {
    // details elided 
}

您使用

list.Contains(pair);

，那么它将使用 Equals 和 GetHashCode 但如果您使用

list.Contains(pair, new PairEqualityComparer);

，那么它将使用 PairEqualityComparer.Equals 和 PairEqualityComparer.GetHashCode 。请注意，这些可能与您的Object.Equals 和Object.GetHashCode 实现不同。

最后，如果您经常进行遏制测试，那么 List 并不是您的最佳选择；您应该使用为此目的而设计的类，例如 HashSet。

Answer 2

班级是你最好的选择。如果您执意使用 Contains 方法，则必须在 Pair 类中实现 IComparable 接口。这将使您能够确定这对整数的“相等”含义。

最简单的方法是创建现有的类，然后在 List 对象上创建和扩展方法。

public static bool ContainsIntegers(this List<Pair> targetList, Pair comparer) {
    foreach(Pair pair in targetList)
    {
        if(pair.i1 == comparer.i1 && pair.i2 == comparer.i2) return true;
    }
    return false;
}

Answer 3

另一种方法是使用 List，通过将最大的数字放入高 32 位并将另一个数字放入低 32 位来填充它：

ulong MakeEntry(int i1, int i2)
{
    ulong hi = (ulong)Math.Max(i1, i2);
    ulong lo = (ulong)Math.Min(i1, i2);
    return (hi << 32) | lo;
}

List<ulong> items = new List<ulong>();

void DoSomething()
{
    // get numbers i1 and i2
    // and add to the list
    items.Add(MakeEntry(i1, i2));

    // test to see if the pair is in the list
    if (items.Contains(MakeEntry(i1, i2)))
    {
        // do whatever
    }
}

Answer 4

改为创建一个向量2 的列表。
将该列表视为一对整数。

哈基？也许吧，但实际上比上面所有的要简单得多。