为什么我们在哈希算法中还有其他的存储桶数组？

Question

I've been stepping through the implementation for a Hashset for the .net framework, I am slightly confused by the implementation of it. Here is the Contains method:

    private int[] m_buckets;
    private Slot[] m_slots;

public bool Contains(T item) {
        if (m_buckets != null) {
            int hashCode = InternalGetHashCode(item);
            // see note at "HashSet" level describing why "- 1" appears in for loop
            for (int i = m_buckets[hashCode % m_buckets.Length] - 1; i >= 0; i = m_slots[i].next) {
                if (m_slots[i].hashCode == hashCode && m_comparer.Equals(m_slots[i].value, item)) {
                    return true;
                }
            }
        }
        // either m_buckets is null or wasn't found
        return false;
    }


internal struct Slot {
        internal int hashCode;      // Lower 31 bits of hash code, -1 if unused
        internal T value;
        internal int next;          // Index of next entry, -1 if last
    }

I understand the first part, get the hash code of the item. Next a loop is started and a suitable index is generated from the hashcode. But then it uses this index to retrieve a value from an array of integers, which it then uses to check if the hashcodes of the values and the values themselves are the same. Why is this? Also, I cannot get my head around the .next property, why is it necessary to store this information?

Answer 1

Several objects may have the same value for hashCode % m_buckets.Length even if they have distinct hashCode values. Distinct objects may also have the same hashCode value (even though it is unlikely).

This is resolved by storing all the objects with the same value for hashCode % m_buckets.Length in an array, and then searching for the appropriate element in that array. The reason it compares both the hashCode value and the objects themselves is that the comparison of hashCode is faster than the comparison of the objects themselves. By doing a cheap check on the hashcodes first we can avoid doing an expensive check on the objects.

The next values are stored so that it is possible to enumerate the elements that hash to a single value.