705. 设计哈希集合 C语言

705. 设计哈希集合 不使用任何内建的哈希表库设计一个哈希集合（HashSet）。

实现 MyHashSet 类：

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

输入： [“MyHashSet”, “add”, “add”, “contains”, “contains”, “add”,
“contains”, “remove”, “contains”] [[], [1], [2], [1], [3], [2], [2],
[2], [2]] 输出： [null, null, null, true, false, null, true, null, false]

解释： MyHashSet myHashSet = new MyHashSet(); myHashSet.add(1); //
set = [1] myHashSet.add(2); // set = [1, 2]
myHashSet.contains(1); // 返回 True myHashSet.contains(3); // 返回 False
，（未找到） myHashSet.add(2); // set = [1, 2] myHashSet.contains(2);
// 返回 True myHashSet.remove(2); // set = [1] myHashSet.contains(2);
// 返回 False ，（已移除）

提示：

0 <= key <= 106 最多调用 104 次 add、remove 和 contains 。

解答采用的是拉链式哈希表

#define maxsize 769

typedef struct note{
    int value;
    struct note * next;
}List;


typedef struct {
     List * hash[maxsize];
} MyHashSet;

/** Initialize your data structure here. */

MyHashSet* myHashSetCreate() {
   MyHashSet* myhashset =(MyHashSet *)malloc(sizeof(MyHashSet));
    for(int i =0;i<maxsize;i++)
    {
          myhashset->hash[i]=(List *)malloc(sizeof(List));
          myhashset->hash[i]->value=i;
          myhashset->hash[i]->next =NULL;
    }
    return myhashset;

}
//插入元素到hash数组中得每一个元素得链表中，只需传入链表指针即可
void addList(List * a,int value)
{
    List * new = (List *)malloc(sizeof(List));
    List * tem = a->next;
    new ->value = value;
    new->next=tem;
   a->next= new;
}




/* 链表元素释放 */
void freeList(List *list) {
    List *cur = list;
    List *tmp = NULL;
    while (cur != NULL) {
        tmp = cur;
        cur = cur->next;
        free(tmp);
    }
}

void deletList(List *a ,int value)
{
    List * cur = a->next;
    List * past = a;
    while(cur)
    {
        if(cur->value==value)
        {
            past->next = cur->next;
            free(cur);
            return;
        }
        past=cur;
        cur=cur->next;
    }
}
 
 bool IsContain(List* a,int key)
 {
      List * temp = a->next;
      while(temp)
      {
          if(temp->value==key)
          {
              return true;
          }
          temp=temp->next;
      }
      return false;

 }
void myHashSetAdd(MyHashSet* obj, int key) {
      int a = key%maxsize;
      if(IsContain(obj->hash[a],key))
      {
          return ;
      }
      addList(obj->hash[a], key);
}

void myHashSetRemove(MyHashSet* obj, int key) {
      int a = key%maxsize;
      deletList(obj->hash[a],key);
}

/** Returns true if this set contains the specified element */
bool myHashSetContains(MyHashSet* obj, int key) {
            return IsContain(obj->hash[key%maxsize],key);
}

void myHashSetFree(MyHashSet* obj) {
     for(int i=0;i<maxsize;i++)
     {
        freeList(obj->hash[i]);
     }
     free(obj);
}

/**
 * Your MyHashSet struct will be instantiated and called as such:
 * MyHashSet* obj = myHashSetCreate();
 * myHashSetAdd(obj, key);
 
 * myHashSetRemove(obj, key);
 
 * bool param_3 = myHashSetContains(obj, key);
 
 * myHashSetFree(obj);
*/
/* 解法1                        */
/* 使用数组和链表的数据结构组合   */
/* 0   -> node0 node1 ...         */
/* 1   -> node0 ...               */
/* ...                            */
/* n-1 -> node0 node1 ...         */