Leetcode 705. 设计哈希集合（简单）

最新推荐文章于 2022-07-27 00:32:01 发布

Perrysky

最新推荐文章于 2022-07-27 00:32:01 发布

阅读量280

点赞数

分类专栏： Leetcode 刷题笔记文章标签： leetcode 数据结构 hash 单链表

本文链接：https://blog.csdn.net/Perrysky/article/details/105001881

版权

Leetcode 刷题笔记专栏收录该内容

63 篇文章 0 订阅

订阅专栏

本文介绍了如何不使用内建哈希表库设计一个哈希集合，包括插入、检查存在性和删除操作。通过使用链表解决哈希冲突，解决了LeetCode第705题。

摘要由CSDN通过智能技术生成

题目描述：

不使用任何内建的哈希表库设计一个哈希集合

具体地说，你的设计应该包含以下的功能

add(value)：向哈希集合中插入一个值。
contains(value) ：返回哈希集合中是否存在这个值。
remove(value)：将给定值从哈希集合中删除。如果哈希集合中没有这个值，什么也不做。

示例:

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 (已经被删除)

注意：

所有的值都在 [0, 1000000]的范围内。
操作的总数目在[1, 10000]范围内。
不要使用内建的哈希集合库。

思路：

使用链表存储冲突的节点。

//使用链表存储冲突的元素
//效率好低啊
typedef struct Node{
    int val;
    Node* next;
    Node(int val):val(val),next(NULL){}
}Node;

const int MaxSize = 20000; //哈希的桶数一般都大于元素个数

class MyHashSet {
public:
    /** Initialize your data structure here. */
    vector<Node*> arr; //用数组模拟桶
    MyHashSet() {
        arr = vector<Node*>(MaxSize,new Node(-1));
        /*for(int i=0; i<MaxSize; ++i){
            arr[i]->val = -1;
            arr[i]->next = NULL;
        }*/
    }
    
    void add(int key) {
        int t_val = key % MaxSize;
        Node* temp = arr[t_val];
        if(temp->val == -1){
            temp->val = key;
            return;
        }
        else{
            while(temp){
                if(temp->val == key)
                    return;//要add的元素已经存在
                if(temp->next == NULL){
                    Node* node = new Node(key);
                    temp->next = node;
                    return;
                }
                temp = temp->next;
            }
        }   
    }
    
    void remove(int key) {
        int t_val = key % MaxSize;
        Node* temp = arr[t_val];
        if(temp->val == -1)
            return;//不存在直接返回
        else{
            while(temp){
                if(temp->val == key){
                    temp->val = -1;
                    return;
                }
                temp = temp->next;
            }
        }
    }
    
    /** Returns true if this set contains the specified element */
    bool contains(int key) {
        int t_val = key % MaxSize;
        Node* temp = arr[t_val];
        while(temp){
            if(temp->val == key)
                return true;
            temp = temp->next;
        }
        return false;
    }
};

/**
 * 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);
 */

//最暴力的解法，使用足够大的hashtable这样没有冲突。实现很简单，内存空间消耗大
class MyHashSet {
public:
    /** Initialize your data structure here. */
    vector<bool> hashSet;
    MyHashSet() {
       hashSet = vector(1000001,false);
    }
    
    void add(int key) {
        hashSet[key] = true;
        return;
    }
    
    void remove(int key) {
        if(hashSet[key] == true)
            hashSet[key] = false;
        return;
    }
    
    /** Returns true if this set contains the specified element */
    bool contains(int key) {
        if(hashSet[key] == true)
            return true;
        else
            return false;
    }
};

/**
 * 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);
 */