用于检测与另一个值的重复值的高效数据结构

Question

考虑我有如下三列值，

Col-A            Col-B            Values
1                2                9
3                4                9
5                6                9
1                2                8
5                6                8
3                4                7
1                2                7
5                6                10
1                2                10
1                3                10
1                4                10

因此在上面的值集中，（Col-A 和 Col-B）中的 (1,2) 具有所有值集（即 9,8,7 和 10），而其他如 3,4； 5,6 没有所有值。我只想通过上述数据获得 (1,2) 。

我想尝试使用哈希表，将 (ColA, ColB) 添加到一个单独的对象，并使用一个哈希表，其键是对象，值是列“值”。即，

Class K
{
    int a;
    int b;
}

Hashtable<K,int> numbers = new Hashtable<K,int>();

将每一行添加到哈希表中，当发现重复的键时，增加计数。最后检查计数是否等于“值”列中不同值的数量。

但我无法弄清楚如何迭代 Values 中的每个值，即 9、8、7、10。有没有更好的方法来做到这一点。

[编辑] 在Java中实现dasblinkenlight的方法后：

ArrayList<Double> list;
Hashtable<K,ArrayList<Double>> numbers = new Hashtable<K,ArrayList<Double>>();

while((line = brMyHashval.readLine()) != null)
{
    if(!(line.isEmpty()))
    {
        String[] temp;
        temp = line.split(" ");      
        eDouble = Double.parseDouble(temp[5].toString());                   
        Val key = new Val(Double.parseDouble(temp[0].toString()) ,Double.parseDouble(temp[1].toString()) );

        if(!(numbers.containsKey(key)))
        {
            list = new ArrayList<Double>();
            numbers.put(key, list);

        }
        else
        {
            list = numbers.get(key);
        }
        list.add(eDouble); 
     }
}

但是控件每次都会进入“if”循环。即使密钥相同，它也永远不会进入其他部分。在 Java 中，每个键都与一个 id 相关联。它也会检查对象“key”中的 id 或值。

迭代 1：密钥 (id=52) x=1，y =2

迭代 2：密钥 (id=53) x=3，y =4

迭代 3：密钥 (id=55) x=5，y =6

迭代 4 ：键（id = 56）x = 1，y = 2

Answer 1

您需要存储值列表而不是 int：Hashtable> 将值添加到列表而不是递增计数，如下所示：

var key = new K(a,b);
List<int> list;
if (!hashtable.ContainsKey(key)) {
    list = new List<int>();
    hashtable.Add(key, list);
} else {
    list = hashtable[key];
}
list.Add(value);