磊磊零基础打卡算法：day18 c++模拟哈希表来模拟散列表

5.21

哈希表

---

Hash表又称为散列表，一般由Hash函数（散列函数）与链表结构共同实现，与离散化思想类似。

一般要求：防止冲突，便于查询

模拟hash表：

• 拉链法：两个核心操作insert(),find()；

  • int h[N], e[N], ne[N], idx; //邻接表进行存储；

  • 

  • void insert(int x) {
        // c++中如果是负数 那他取模也是负的 所以 加N 再 %N 就一定是一个正数
        int k = (x % N + N) % N;
        //hash防冲突取值
        e[idx] = x;
        //赋值
        ne[idx] = h[k];
        //h[k]是一个拉链的结点，例如2下面的拉链；
        h[k] = idx++;
        //通过拉链进行延申
    }

  • bool find(int x) {
        //用上面同样的 Hash函数 讲x映射到 从 0-1e5 之间的数
        int k = (x % N + N) % N;
        for (int i = h[k]; i != -1; i = ne[i]) {
        //经典的邻链表的遍历操作；
            if (e[i] == x) {
                return true;
        //能找到
            }
        }
        return false;
    }

例题链接：https://www.acwing.com/problem/content/842/

---

• #include "cstring"
  #include "iostream"
  using namespace std;
  const int N = 100003;
  int h[N], e[N], ne[N], idx;
  void insert(int x) {
      int t = (x % N + N) % N;
      e[idx] = x;
      ne[idx] = h[k];
      h[k] = idx++;
  }
  bool find(int x) {
      int k = (x % N + N) % N;
      for (int i = h[k]; i != -1; i = ne[i]) {
          if (e[i] == x)
              return true;
      }
      return false;
  }
  int main() {
      // for (int i = 100000; i; i++) {
      //     bool flag = true;
      //     for (int j = 2; j * j < i; j++) {
      //         if (i % j == 0) {
      //             flag = false;
      //             break;
      //         }
      //     }
      //     if (flag) {
      //         cout << i;
      //         break;
      //     }
      // }
      //这里是找到N的操作，一般是取质数为hash计算的最好办法
      memset(h, -1, sizeof h);
      //将槽先清空 空指针一般用 -1 来表示
      int m;
      cin >> m;
      while (m--) {
          char op;
          int x;
          cin >> op >> x;
          if (op == 'I') {
              insert(x);
  
          } else {
              if (find(x))
                  cout << "Yes" << endl;
              else
                  cout << "No" << endl;
          }
      }
      return 0;
  }0;
  }< "No" << endl;
          }
      }
      return 0;
  }

---

• 开放寻址法(推荐）：

• 其实就是开辟两到三倍的一维数组空间大小来存放原来的数值；

• 主要方法：find(int x)找到x;两种结果

  • 如果能找到，就返回x的下标，同时也对应着query操作

  • 如果不能找到，那么返回x需要被插入的位置，对应着insert的操作；

• #include "cstring"
  #include "iostream"
  using namespace std;
  const int N = 200003, null = 0x3f3f3f3f;
  int h[N];
  int find(int x) {
      //找一个数是否存在，结果两种：一是存在的话，就返回它的位置，如果不存在，那么就需要返回它被插入的位置;
      int k = (x % N + N) % N;
      //散列原数，同时也找到x的位置
      while (h[k] != null && h[k] != x) {
          //如果k位置的元素是空要么k位置的元素就是x的位置，那么就不需要判断，直接返回k就是要找的位置
          k++;
          //如果当前位置被人家占了，就往后挪，直到N数组总长。总长都不够就从头开始
          if (k == N)
              k = 0;
      }
      return k;
  }
  int main() {
      int m;
      cin >> m;
      memset(h, 0x3f, sizeof h);
      //对所有元素初始化为null配合h[k]!=null的查找
      while (m--) {
          char op;
          int x;
          cin >> op >> x;
          int k = find(x);
          if (op == 'I')
              h[k] = x;
          //直接将k的位置给x元素就行
          else {
              if (h[k] != null)
                  //说明存在元素;
                  cout << "Yes" << endl;
              else
                  cout << "No" << endl;
          }
      }
      return 0;
  }