一.哈希：

1.位图：

1.题目一：

给40亿个不重复的无符号整数，没有排过序。给一个无符号整数，如何快速判断一个数是否在这40亿个数中？

方法一：

1.排序+二分方法
2.时间复杂度：n*logn + logn
3.空间复杂度O(n)

1.40亿的不重复整数使用上面的方法需要保存在数组中。
2.40亿数有160亿字节的数据计算大概是14.9g
3.说明我们需要14.9g的内存给这个程序才可以在数组中存放足够的数据。
4.保存到数组中进行排序+二分。

方法二：

1.非常明显上面的方法是不靠谱的需要大量的内存+时间才可以找到数据。
2.题目要求只需要判断数据在不在。
3.使用哈希位图的方法1为存在0为不存在。
4.位置和值进行一一对应。

1.每一个方块是4个字节，4个字节4个字节开比较方便。
2.从第一个整形开始计数第几个位表示数值几。
3.使用除和模的方法获取当前需要存放的数据和判断数据的位置。
4.原来4个字节存一个数据现在存32个数据。
5.数据大概不到0.5个g就可以保存。

template<size_t N>
class Hashset {
public:Hashset(){//40亿无符号整数_N.resize(N/32 + 1 , 0);}//1.设置：void set(size_t n){int i = n / 32;int j = n % 32;_N[i] |= (1 << j);}//2.消除：void reset(size_t n){int i = n / 32;int j = n % 32;_N[i] &=(~(1 << j));}//3.查找！bool find(size_t n){int i = n / 32;int j = n % 32;return (1 << j) & _N[i];}private:vector<int> _N;
};

1.创建一个哈希位图使用整形开空间。
2.使用模板的特化传N是开多少个整形空间的大小。
3.使用set和reset放置数据和去除数据。
4.使用find判断数据是否存在1为存在0为不存在。
5.补充：<< 位向高位移动低位补0. >> 位向高位移动低位补0

2.题目二：

方法一：

给定100亿个整数，设计算法找到只出现一次的数。

1,题目需要记录出现的次数我们可以使用两个位图保存数据出现的次数情况。
2.00 没有出现 01出现一次 10表示出现两次 11表示出现三次和以上。
3.100亿个整数只需要开数据大小范围的位图就可以。
4.2^32范围的整数，100亿数据一定存在有一些数据重复出现的情况。

#include"Hashset.h"template<size_t N>
class Double_set {
public://1.++void set_add(size_t n){int a = _prev.find(n);int b = _next.find(n);if (b == 0 && a == 0){_next.set(n);}else if (b == 1 && a == 0){_next.reset(n);_prev.set(n);}else if (b == 0 && a == 1){_next.set(n);}}//2.判断出现一次的个数：bool pwd(size_t n){int a = _prev.find(n);int b = _next.find(n);if (a == 0 && b == 1)return true;return false;}
private:Hashset<N> _prev;Hashset<N> _next;
};

//2.100亿重复数据判断出现一次：
void exam_2()
{Double_set<40> h2;vector<size_t> arr = { 1,1,2,2,3,4,4,4,5,6,6,7,9,9,9,9,10 };for (auto& e : arr){h2.set_add(e);}for (int j = 0; j < 11; j++){if (h2.pwd(j))cout << j << "出现一次" << endl;elsecout << j << "出现次数不是一次" << endl;}
}

补充：

3.题目三：

给两个文件，分别有100亿个整数数据，我们只有1G内存我们需要找到两个文件的交集。

方法一：双位图

1,46亿多个数据，需要不到0.5个g
2.分别使用位图保存数据1表示数据在0表示数据不在。
3.两个文件分别使用位图进行保存

void exam_3()
{Hashset<-1> h1;Hashset<-1> h2;srand(time(NULL));for (size_t i=0 ; i< 42949; i++){size_t n = (rand()+i) % 42949;h1.set(n);}for (size_t i = 0; i < 42949; i++){size_t n = (rand() + i) % 42949;h2.set(n);}for (int i = 0; i < 42949; i++){int a = h1.find(i);int b = h2.find(i);if (a == 1 && b == 1)cout << i << "是两个文件的交集" << endl;}
}

1.两个文件分别放入两个set中，然后每一个位进行数据比较。
2.上面的这个操作是默认去重的，因为存放数据只存放一个。
3.如果不想要去重操作，可以set一个文件到位图中，然后使用另一个文件遍历第一个位图就可以找到重复数据的交集。

4.题目四：

位图应用变形：1个文件有100亿个int，1G内存，设计算法找到出现次数不超过2次的所有整数

1,题目需要记录出现的次数我们可以使用两个位图保存数据出现的次数情况。
2.00 没有出现 01出现一次 10表示出现两次 11表示出现三次和以上。
3.100亿个整数只需要开数据大小范围的位图就可以。
4.2^32范围的整数，100亿数据一定存在有一些数据重复出现的情况。
5.int数据的范围是 -2147483648 2147483647 int中会出现负数，负数对应不了下标位置需要int转size_t类型的数据。

template<size_t N>
class Double_set_3 {
public://1.++void set_add(size_t n){int a = _prev.find(n);int b = _next.find(n);if (b == 0 && a == 0){_next.set(n);}else if (b == 1 && a == 0){_next.reset(n);_prev.set(n);}else if (b == 0 && a == 1){_next.set(n);}}//2.判断出现一次的个数：bool pwd(size_t n){int a = _prev.find(n);int b = _next.find(n);//如果出现次数至少为三次就返回假。if (a == 1 && b == 1)return false;return true;}
private:Hashset<N> _prev;Hashset<N> _next;
};

void exam_4()
{Double_set_3<200> h1;vector<int> arr = { 1,1,2,2,2,3,3,3,4,4,5,6,6,7,7,7,7,8,8,8,8,9,10 };for (auto& e : arr){h1.set_add(e);}for (int i = 0; i < 200; i++){if (h1.pwd(i))cout << i << "出现次数不超过两次" << endl;}
}

//1.vector中存放的数据类型是int
//2.数据量和可以出现的数据访问过于悬殊导致位图基本上就是1 1 的结构
//3.作为size_t 类型是4294967295 作为int 类型是-1！

二.布隆过滤器：

1.基本概念：

一对一是处理不了字符串的问题非常容易产生了哈希冲突，需要布隆过滤器的存在！

1.普通的位图只能处理整形和无符号整形的问题根据位置确定数据值。
2.布隆过滤器=哈希+位图
3.把字符串进行转化==(不同的哈希函数)==存放在位图的多个位置，一个字符串映射多个位置。
4.开位图空间要多开一些？比如有100字符串一个字符串映射多个位，开的位图空间需要足够大。

2.基本结构：

struct HashFuncBKDR
{// BKDRsize_t operator()(const string& s){size_t hash = 0;for (auto ch : s){hash *= 131;hash += ch;}return hash;}
};struct HashFuncAP
{// APsize_t operator()(const string& s){size_t hash = 0;for (size_t i = 0; i < s.size(); i++){if ((i & 1) == 0) // żÊýλ×Ö·û{hash ^= ((hash << 7) ^ (s[i]) ^ (hash >> 3));}else              // ÆæÊýλ×Ö·û{hash ^= (~((hash << 11) ^ (s[i]) ^ (hash >> 5)));}}return hash;}
};struct HashFuncDJB
{// DJBsize_t operator()(const string& s){size_t hash = 5381;for (auto ch : s){hash = hash * 33 ^ ch;}return hash;}
};template<size_t N, class T = string,class Hash_1 = HashFuncBKDR,class Hash_2 = HashFuncAP,class Hash_3 = HashFuncDJB
>
class Blond_1 {
public://1.放置：void set(const T& x){//需要三个不同的哈希函数计算出3个不同的映射位置：size_t a = Hash_1()(x)%M;size_t b = Hash_2()(x)%M;size_t c = Hash_3()(x)%M;_h.set(a);_h.set(b);_h.set(c);}//2.判断数据存在的问题！bool test(const T& x){//1.映射的三个位置有一个为0这个数据都不存在(一定)size_t a = Hash_1()(x) % M;if (!_h.find(a))return false;size_t b = Hash_2()(x) % M;if (!_h.find(b))return false;size_t c = Hash_3()(x) % M;if (!_h.find(c))return false;//2.映射的三个位置都存在一定存在吗？(不确定的：存在误判！)return true;}private:static const size_t M = N * 10;//一个字符串会去映射多个位*10 空间大小Hashset<M> _h;//类的静态成员不在对象中开空间
};

如果我们要映射一个值到布隆过滤器中，我们需要使用多个不同的哈希函数生成多个哈希值，并对每个生成的哈希值指向的 bit 位置 1，例如针对值 “baidu” 和三个不同的哈希函数分别生成了哈希值 1、4、7，则上图转变为：

3.为什么存在误判？

void exam_1()
{Blond_1<10> b1;string s1("百度");string s2("字节");string s3("网易");b1.set(s1);b1.set(s2);b1.set(s3);vector<string> v1 = { "百度","字节","网易","腾讯"};for (auto& e : v1){if (b1.test(e))cout << e << "可能存在" << endl;elsecout << e << "一定不存在" << endl;}
}

1.我们把百度，字节，网易，每个字符串哈希映射到位图的三个位置（如下图所示）
2.当我们判断腾讯在不在的时候会出现误判：
3.腾讯不存在位图中，通过三个哈希函数可以计算到三个位置并且这三个位置都被百度，字节，网易中的一个所占有，产生了误判！(实际不产生误判！数据量较小)

4.如何减少误判？

如何选择哈希函数个数和布隆过滤器长度
很显然，过小的布隆过滤器很快所有的 bit 位均为 1，那么查询任何值都会返回“可能存在”，起不到过滤的目的了。布隆过滤器的长度会直接影响误报率，布隆过滤器越长其误报率越小。

另外，哈希函数的个数也需要权衡，个数越多则布隆过滤器 bit 位置位 1 的速度越快，且布隆过滤器的效率越低；但是如果太少的话，那我们的误报率会变高。

1.增加布隆过滤器的长度，提高长度/数据量的比值。
2.增加哈希函数的个数，但是考虑映射速度和空间大小的问题。
2-1：哈希函数越多，整个位图变1的速度越快。
2-2：哈希函数越多，整个位图空间的消耗变快。
3.哈希函数变少也会导致误报率变高。

5.布隆过滤器如何支持删除操作？

1.增加引用计数可以解决删除的问题。
2.一个位置可能被重复多次的被设置，如果没有引用记数操作那么可能一次删除就影响到其他字符串的存在。
3.增加一个位图块的大小到8bit。
4.可以使用8bit的第一个保存是否存在，剩下七个去保存引用计数的次数。

6.应用：

应用：

1.注册用户名重复的判断。
2.布隆过滤器存在哈希冲突，数据库的访问查找是确定性的。
3.如果不在布隆过滤器中就一定不是重复的用户名称。
4.在前端和数据库中加上一个布隆过滤器可以降低数据库的访问需求。
5.数据库的数据查询是基于网络的，布隆过滤器是基于本地的快速判断。

题目一：

给两个文件分别有100亿的字符串，我们只有1G内存怎么找到两个文件的交集？

精确算法(哈希切割)：

1.假设一个字符串的大小是50byte
2.100亿个字符串是多少G —>5千亿字节—>500G (1g大概为10亿字节)
3.我们只有1G内存两个文件可以考虑不平均切分为1000份！

问题：两个文件需要找交集切分出来的两块A0 和 B0 怎么保证是对应类型的字符串？
哈希切分：
1.当前是A0 和 B0 分别放在问题中去找交集。
2.如何确定A中的那些文件放在A0，B中的那些文件放在B0？
3.使用哈希函数i = HashFunc(queue)%1000;
4.i就是Ai或者Bi

特殊情况：哈希切分本质不平均切分！

存在一个Ai 或者 Bi 过大的情况？
解决方法一：进入递归的哈希切分。
解决方法二：可以在同一个位置出现的字符串，是相同的字符串或者相似字符串。考虑把这些字符串放到位图中先进行去重操作再放到setA和setB中(解决重复数据较多的情况)
解决方法三：哈希冲突多—>导致的文件过大？可以调整哈希切分函数–>进行二次切分。

近似算法(布隆过滤器)：

思路：
1.把一个文件的字符串放到布隆过滤器中。
2.遍历另一个文件，另一个文件中的字符串每一个都去判断一下在不在布隆过滤器中。
3.因为存在哈希冲突有可能有一些数据不是交集但是在布隆过滤器中出现存在这个就是哈希冲突。
4.综上所述：近似的算法。

三.海量数据处理：

1.哈希切割：

题目一：

给一个超过100G大小的log file ， log中存ip，设计算法找到出现次数最多的IP，转化为找topk ip问题。

方法一：哈希切分+map

方法二：大堆解决

1.定义一个pair<string , int> 类型的结构保存在堆中。
2.堆不会存在有重复的数据节点。
3.插入一个pair<string , int> string已经在堆中存在就++int类型的值。
4.插入一个pair<string , int> string之前没有在堆中存在就正常插入pair到堆中。
5.通过pait<string , int> 比较使用仿函数调int这个数据去比较。