Question

正在尝试解决有关设计HashSet的问题。

在不使用任何内置哈希表库的情况下设计HashSet。

具体来说，您的设计应包括以下两个功能：

add（value）：将值插入HashSet。
  contains（value）：返回值是否存在于HashSet中。

remove（value）：删除HashSet中的值。如果该值在HashSet中不存在，请执行   什么都没有。

示例：

MyHashSet hashSet = new MyHashSet（）; hashSet.add（1）;
  hashSet.add（2）; hashSet.contains（1）; //返回true   hashSet.contains（3）; //返回false（未找到）hashSet.add（2）;
  hashSet.contains（2）; //返回true hashSet.remove（2）;
  hashSet.contains（2）; //返回false（已删除）

注意：

所有值都将在[1，1000000]范围内。的数量   运算的范围为[1，10000]。请不要使用   内置的HashSet库。

以下代码在本地运行良好，但提交失败，提示错误

运行时错误消息：   引用绑定到类型为“ int”的未对齐地址0x736c61662c657572，需要4个字节对齐

最后执行的输入：   [“ MyHashSet”，“添加”，“删除”，“添加”，“包含”，“添加”，“删除”，“添加”，“添加”，“添加”，“添加”]   [[]，[6]，[4]，[17]，[14]，[14]，[17]，[14]，[14]，[18]，[14]]

class MyHashSet { public:
vector<vector<int>> setHash;
MyHashSet() {
    setHash.reserve(10000);
}

void add(int key) {
    int bucket = key % 10000;
    vector<int>::iterator it;
    it = find(setHash[bucket].begin(),setHash[bucket].end(),key);
    if(it == setHash[bucket].end()){
        setHash[bucket].push_back(key);
    }
}

void remove(int key) {
    int bucket = key % 10000;
    vector<int>::iterator it1;
    it1 = find(setHash[bucket].begin(),setHash[bucket].end(),key);
    if(it1 != setHash[bucket].end()){
        int index = distance(it1,setHash[bucket].begin());
        setHash[bucket].erase(setHash[bucket].begin()+index);
    }

}

/** Returns true if this set did not already contain the specified element */
bool contains(int key) {
    int bucket = key % 10000;
    vector<int>::iterator it2;
    it2 = find(setHash[bucket].begin(),setHash[bucket].end(),key);
        if(it2 != setHash[bucket].end()){
            return true;
        }

    return false;
}

};

我怀疑是由于内存问题。但是由于我仍在学习c ++的基础知识，因此无法弄清。

Answer 1

如果您的问题是如何解决实施问题，我会在评论中留意该建议。

如果您想学习C ++并以最佳方式解决问题，我将使用std::bitset。他们为您提供了定义的输入范围[1,1000000]，这使我相信他们正在寻找类似的东西。

这可能属于内置哈希表库的类别，因此here is a potential implementation。

class MyHashSet {
public:
    void add(int key) {
        flags.set(key);
    }
    void remove(int key) {
        flags.reset(key);
    }
    bool contains(int key) const {
        return flags[key];
    }
private:
    bitset<1000000+1> flags;
};

在我的平台上，这大约需要16kB（而10000个向量则需要30kB +）。它还不需要动态内存分配。

如果您认为这种偏离主题或作弊，请提供LeetCode问题的标题/编号，以便我可以使用他们的测试用例来编写您的代码草稿。我现在还在研究哈希表，因此是双赢的。

在leetcode中设计哈希集，代码会产生运行时错误

1 个答案: