Likou 705. Design hash collection hash (chain address method) bit operation to achieve hash

https://leetcode-cn.com/problems/design-hashset/

Idea 1: Unpretentious and boring chain address method, through $vector,forward\_list$ (the latter is a singly linked list).

class MyHashSet {
    
    
public:
    /** Initialize your data structure here. */
    const int num=2333;
    vector<forward_list<int>> hashTable;
    MyHashSet() {
    
    
        hashTable.resize(num);
    }
    
    void add(int key) {
    
    
        if(!contains(key))
            hashTable[key%num].push_front(key);
    }
    
    void remove(int key) {
    
    
        int idx=key%num;
        forward_list<int>::iterator it=hashTable[idx].before_begin();
        forward_list<int>::iterator nxt=hashTable[idx].begin();
        forward_list<int>::iterator ed=hashTable[idx].end();
        while(nxt!=ed&&*nxt!=key)
            it=nxt++;
        if(nxt!=ed)
            hashTable[idx].erase_after(it);
    }
    
    /** Returns true if this set contains the specified element */
    bool contains(int key) {
    
    
        int idx=key%num;
        forward_list<int>::iterator it=hashTable[idx].begin();
        forward_list<int>::iterator ed=hashTable[idx].end();
        while(it!=ed&&*it!=key)
            ++it;
        return it!=ed;
    }
};

/**
 * Your MyHashSet object will be instantiated and called as such:
 * MyHashSet* obj = new MyHashSet();
 * obj->add(key);
 * obj->remove(key);
 * bool param_3 = obj->contains(key);
 */

Idea 2: Bitwise arithmetic implements hashing. This idea is quite clever. Consider using an $unsignedlonglong$ array realizes hashing, might as well set the modulus as$base$ , then for any$key$ , we can convert it into two parts:$\lfloor key/base\rfloor$和$key\%base$ , the first part determines its subscript in the array, and the second part determines the binary representation of its value at that place (the code should be more intuitive here). Consideringull ullThe value range of$u$$l$$l$ type is$[0,2^{64}-1]$ , a$ull$ type corresponds to up to 64 values, so$base=64$ , the range of the array should be$\lfloor max\_key/base\rfloor +1$。

class MyHashSet {
    
    
public:
    /** Initialize your data structure here. */
    const int base=64;
    vector<unsigned long long> hashTable;
    MyHashSet() {
    
    
        int max=1e6,num=max/base;
        if(num*base==max)
            ++num;
        hashTable.resize(num);
    }
    
    void add(int key) {
    
    
        hashTable[key/base]|=1ull<<(key%base);
    }
    
    void remove(int key) {
    
    
        hashTable[key/base]&=~(1ull<<(key%base));
    }
    
    /** Returns true if this set contains the specified element */
    bool contains(int key) {
    
    
        return hashTable[key/base]&(1ull<<(key%base));
    }
};

/**
 * Your MyHashSet object will be instantiated and called as such:
 * MyHashSet* obj = new MyHashSet();
 * obj->add(key);
 * obj->remove(key);
 * bool param_3 = obj->contains(key);
 */