C++ 数据结构之布隆过滤器

布隆过滤器

一、历史背景知识

布隆过滤器(Bloom Filter)是1970年由布隆提出的。它实际上是一个很长的二进制向量和一系列随机映射函数。布隆过滤器可以用于检索一个元素是否在一个集合中。它的优点是空间效率和查询时间都远超过一般的算法,缺点是有一定的误识别率和删除错误。而这个缺点是不可避免的。但是绝对不会出现识别错误的情况出现(即假反例False negatives,如果某个元素确实没有在该集合中,那么Bloom Filter 是不会报告该元素存在集合中的,所以不会漏报)

在 FBI,一个嫌疑人的名字是否已经在嫌疑名单上;在网络爬虫里,一个网址是否被访问过等等。最直接的方法就是将集合中全部的元素存在计算机中,遇到一个新 元素时,将它和集合中的元素直接比较即可。一般来讲,计算机中的集合是用哈希表(hash table)来存储的。它的好处是快速准确,缺点是费存储空间。当集合比较小时,这个问题不显著,但是当集合巨大时,哈希表存储效率低的问题就显现出来 了。

比如说,一个象 Yahoo,Hotmail 和 Gmai 那样的公众电子邮件(email)提供商,总是需要过滤来自发送垃圾邮件的人(spamer)的垃圾邮件。一个办法就是记录下那些发垃圾邮件的 email 地址。由于那些发送者不停地在注册新的地址,全世界少说也有几十亿个发垃圾邮件的地址,将他们都存起来则需要大量的网络服务器。如果用哈希表,每存储一亿 个 email 地址, 就需要 1.6GB 的内存(用哈希表实现的具体办法是将每一个 email 地址对应成一个八字节的信息指纹,然后将这些信息指纹存入哈希表,由于哈希表的存储效率一般只有 50%,因此一个 email 地址需要占用十六个字节。一亿个地址大约要 1.6GB, 即十六亿字节的内存)。因此存贮几十亿个邮件地址可能需要上百 GB 的内存。除非是超级计算机,一般服务器是无法存储的[2]。

二、布隆过滤器原理以及优缺点

如果想判断一个元素是不是在一个集合里,一般想到的是将集合中所有元素保存起来,然后通过比较确定。链表、树、散列表(哈希表,Hash table)等数据结构都是这种思想。但是随着集合中元素的增加,我们需要的存储空间越来越大。同时检索速度也会越来越慢。

Bloom Filter 是一种空间效率很高的随机数据结构,Bloom Filter 可以看做是对bit-map的扩展,它的原理是:

当一个元素被加入集合中时,通过K个hash函数将这个元素映射成一个位阵列(Bit array)中的K个点,将它们置成1. 检索时,我们只需要看这些点是不是都是1就能(大约)知道集合中有没有它:

如果这些点中有任何一个0,则被检索元素一定不在;

如果都是1,则被检索元素很可能在。

优点:

它的优点是空间效率和查询时间都远远超过一般的算法,布隆过滤器存储空间和插入\查询时间都是O(K),另外,散列函数相互之间没有关系,方便硬件并行实现,布隆过滤器不需要存储元素本身,在某些对保密要求非常严格的场合有优势。

缺点:

1、布隆过滤器的缺点和优点同样明显。误算率是其中之一。随着存入元素的增加,误算率随之增加。但是元素数量太少,则使用散列就可以了。

2、一般情况下不能从布隆过滤器中删除元素,我们很容易想到把位数组变成整数数组,每插入一个元素相应的计数器加1,这样删除元素时将计数器减掉就可以了。然而要保证安全地删除元素并非这么简单。首先我们必须保证删除的元素的确存在布隆过滤器里面,另外计数器回绕也会造成问题。

三、example

Google Chrome浏览器使用Bloom filter识别恶意链接(能用较小的存储空间表示较大的数据集合,简单想就是把 每一个URL都可以映射成bit)的多,并且误判率在万分之一以下。

C++实现

bit_set.h

#pragma once
#include<iostream>
using namespace std;
#include<vector> 

class Bitset
{
public:
  Bitset(size_t value)
  {
    _a.resize((value >> 5) + 1, 0);
  }
  bool set(size_t num)
  {
    size_t index = num>>5;
    size_t pos = num % 32;
    if (_a[index] & (1 << (31 - pos)))
    {
      return false;
    }
    else
    {
      _a[index] |= (1 << (31 - pos));
      _size++;
      return true;
    } 

  }
  bool Reset(size_t num)
  {
    size_t index = num >> 5;
    size_t pos = num % 32;
    if (Text(num))
    {
      _a[index] &= ~(1 << (31 - pos));
      _size--;
      return true;
    }
    else
    {
      return false;
    }
  }
  bool Text(size_t num)
  {
    size_t index = num >> 5;
    size_t pos = num % 32;
    return _a[index] & (1 << (31-pos));
  }
private:
  vector<int> _a;
  size_t _size;
};

Hash.h

#pragma once
template<class T> //各类哈希字符串转换函数
size_t BKDRHash(const char *str)
{
  register size_t hash = 0;
  while (size_t ch = (size_t)*str++)
  {
    hash = hash * 131 + ch;
  }
  return hash;
} 

template<class T>
size_t SDBMHash(const char *str)
{
  register size_t hash = 0;
  while (size_t ch = (size_t)*str++)
  {
    hash = 65599 * hash + ch;
  }
  return hash;
} 

template<class T>
size_t RSHash(const char * str)
{
  size_t hash = 0;
  size_t magic = 63689;
  while (size_t ch = (size_t)*str++)
  {
    hash = hash * magic + ch;
    magic *= 378551;
  }
  return hash;
} 

template<class T>
size_t APHash(const char *str)
{
  register size_t hash = 0;
  size_t ch;
  for (long i = 0; ch = (size_t)*str++; i++)
  {
    if ((i & 1) == 0)
    {
      hash ^= ((hash << 7) ^ ch ^ (hash >> 3));
    }
    else
    {
      hash ^= (~((hash << 11) ^ ch ^ (hash >> 5)));
    }
  }
  return hash;
} 

template<class T>
size_t JSHash(const char* str)
{
  if (!*str)
  {
    return 0;
  }
  size_t hash = 1315423911;
  while (size_t ch = (size_t)*str++)
  {
    hash ^= ((hash << 5) + ch + (hash >> 2));
  }
  return hash;
}

Bloom_Filter.h

#pragma once 

#include"bite_set.h"
#include"Hash.h"
#include<string> 

template<class T>
struct __HashFunk1
{
  size_t operator()(const T& key)
  {
    return BKDRHash<T>(key.c_str());
  }
}; 

template<class T>
struct __HashFunk2
{
  size_t operator()(const T& key)
  {
    return SDBMHash<T>(key.c_str());
  }
};  

template<class T>
struct __HashFunk3
{
  size_t operator()(const T& key)
  {
    return RSHash<T>(key.c_str());
  }
}; 

template<class T>
struct __HashFunk4
{
  size_t operator()(const T& key)
  {
    return APHash<T>(key.c_str());
  }
}; 

template<class T>
struct __HashFunk5
{
  size_t operator()(const T& key)
  {
    return JSHash<T>(key.c_str());
  }
}; 

template<class K = string,
class HashFunk1 = __HashFunk1<K>,
class HashFunk2 = __HashFunk2<K>,
class HashFunk3 = __HashFunk3<K>,
class HashFunk4 = __HashFunk4<K>,
class HashFunk5 = __HashFunk5<K>> 

class BoolFilter
{
public:
  BoolFilter(size_t n)
    :_a(n * 10)
    , _range(n * 10)
  {} 

  void set(const K& key)
  {
    _a.set(HashFunk1()(key) % _range);
    _a.set(HashFunk2()(key) % _range);
    _a.set(HashFunk3()(key) % _range);
    _a.set(HashFunk4()(key) % _range);
    _a.set(HashFunk5()(key) % _range);
  } 

  bool Text(const K& key)
  {
    if (!_a.Text(HashFunk1()(key)% _range))
      return false;
    if (!_a.Text(HashFunk2()(key) % _range))
      return false;
    if (!_a.Text(HashFunk3()(key) % _range))
      return false;
    if (!_a.Text(HashFunk4()(key) % _range))
      return false;
    if (!_a.Text(HashFunk5()(key) % _range))
      return false;
    return true;
  }
private:
  Bitset _a;
  size_t _range;
};
时间: 2017-06-04

C++ 数据结构实现两个栈实现一个队列

C++ 数据结构实现两个栈实现一个队列 栈为后进先出,队列为先进先出 用两个栈实现一个队列.是一个比较经典的问题. 看到这个问题,我的第一个解题思路为: 定义两个栈,s1,s2.s1作为入队列栈,s2作为出队列栈: 入队列:每次入队列的时候,将数值压入s1栈中: 出队列:出队列时,将s1中的所有数据,压进s2栈中,然后删除s2的栈顶数据,然后再将s2中的剩余数据压入s1中. 在这其中s1是一个存储空间,s2是一个辅助空间. 进一步想一下上述办法,在出队列时,每一次都要将s1倒进s2,然后删除s2

C++ 数据结构完全二叉树的判断

C++ 数据结构完全二叉树的判断 完全二叉树(Complete Binary Tree):若设二叉树的深度为h,除第h层外,其他各层(1~h-1)的节点数都达到最大个数,第h层所有的节点都连续集中在最左边,这就是完全二叉树.完全二叉树由满二叉树而引起来的.对于深度为K的,有n个节点的二叉树,当且仅当每一个节点都与深度为K的满二叉树中编号从1到n的节点一一对应时称之为完全二叉树. 注意:满二叉树一定是完全二叉树,但完全二叉树不一定是满二叉树. 完全二叉树的特点:完全二叉树的效率极高,堆是一种完全二

C++ 数据结构之水洼的数量算法

C++ 数据结构之水洼的数量算法 题目: 有一个大小为N*M的园子, 雨后起了积水. 八连通的积水被认为是连接在一起的. 请求出园子里总共有多少水洼. 使用深度优先搜索(DFS), 在某一处水洼, 从8个方向查找, 直到找到所有连通的积水. 再次指定下一个水洼, 直到没有水洼为止. 则所有的深度优先搜索的次数, 就是水洼数. 时间复杂度O(8*M*N)=O(M*N). 代码: /* * main.cpp * * Created on: 2014.7.12 *本栏目更多精彩内容:http://ww

C++ 冒泡排序数据结构、算法及改进算法

程序代码如下: 复制代码 代码如下: // BubbleSort.cpp : 定义控制台应用程序的入口点.//#include "stdafx.h"#include <cmath>#include <iostream>using namespace std;#define  MAXNUM 20template<typename T>void Swap(T& a, T& b){    int t = a;    a = b;    b

C++数据结构之实现循环顺序队列

数据结构–用C++实现循环顺序队列 队列的操作特性:先进先出 队列中元素具有相同类型 相邻元素具有前驱和后继关系 设置队头.队尾两个指针,以改进出队的时间性能 约定:队头指针front指向队头元素的前一个位置,队尾指针rear指向队尾元素 为了解决假溢出,我们将存储队列的数组头尾相接,从而产生了循环队列. 如何判断循环队列队空? 队空:front=rear 如何盘对循环队列堆满? 队满:front=rear 那么问题就来了,队空和队满的判断条件相同,为了避免队满时产生队空的判断或者相反,我们需要

C++ 数据结构链表的实现代码

C++ 链表 之前一直没怎么在意C++中的链表,但是突然一下子让自己写,就老是出错.没办法,决定好好恶补一下该方面的知识,也为今后的数据结构大下个良好的基础,于是我总结出以下几点,有些地方可能不正确,还望大家不吝赐教,旨在共同进步. 总结: 1.链表List的基本单元是节点Node,因此想要操作方便,就必须为每一步打好基础,Node的基本结构如下: class Node{ public: int data; Node *next; Node(int da=0,Node *p=NULL){ thi

C++语言数据结构 串的基本操作实例代码

C语言数据结构 串的基本操作实例代码 输出结果: 实现代码: #include<iostream> using namespace std; typedef int Status; #define Max 20 #define OK 1 #define ERROR 0 #define OVERLOE -2 typedef struct//堆分配表示串 { char *ch; int length; }HString; //====================================

C++ 数据结构 堆排序的实现

堆排序(heapsort)是一种比较快速的排序方式,它的时间复杂度为O(nlgn),并且堆排序具有空间原址性,任何时候只需要有限的空间来存储临时数据.我将用c++实现一个堆来简单分析一下. 堆排序的基本思想为: 1.升序排列,保持大堆:降序排列,保持小堆: 2.建立堆之后,将堆顶数据与堆中最后一个数据交换,堆大小减一,然后向下调整:直到堆中只剩下一个有效值: 下面我将简单分析一下: 第一步建立堆: 1.我用vector顺序表表示数组: 2.用仿函数实现大小堆随时切换,实现代码复用: 3.实现向下

C++ 数据结构线性表-数组实现

C++ 数据结构线性表-数组实现 线性表的数组实现,实现几个核心的功能,语言是C++,如果有更好的想法和意见,欢迎留言~~~ /* Author : Moyiii * 线性表的数组实现,仅作学习之用,当然如果 * 你想拿去用,随你好啦. */ #include<iostream> using namespace std; //顺序表 class SeqList { public: //构造函数,接受一个默认的列表大小 SeqList(int size = MAX_LIST_SIZE); //析

C++数据结构与算法之判断一个链表是否为回文结构的方法

本文实例讲述了C++判断一个链表是否为回文结构的方法.分享给大家供大家参考,具体如下: 题目: 给定一个链表头节点head,请判断是否为回文结构 例如: 1->2->1 true 1->2->2->1 true 1->2->3->4->2->1 false 解题思路及代码 1.找到链表中间节点,然后将链表中间节点的右边所有节点放入一个栈中. 2.然后从链表首节点和栈顶元素一一对比,不相等则return false. 算法C++代码: 链表节点结构

Python数据结构与算法之列表(链表,linked list)简单实现

Python 中的 list 并不是我们传统(计算机科学)意义上的列表,这也是其 append 操作会比 insert 操作效率高的原因.传统列表--通常也叫作链表(linked list)--通常是由一系列节点(node)来实现的,其每一个节点(尾节点除外)都持有一个指向下一个节点的引用. 其简单实现: class Node: def __init__(value, next=None): self.value = value self.next = next 接下来,我们就可使用链表的结构来

Python编程判断一个正整数是否为素数的方法

本文实例讲述了Python编程判断一个正整数是否为素数的方法.分享给大家供大家参考,具体如下: import string import math #判断是否素数的函数 def isPrime(n): if(n<2): return False; elif(n==2): return True; elif(n>2): for d in range(2,int(math.ceil(math.sqrt(n))+1)): if(n%d==0): return False; return True;

Python实现判断一个字符串是否包含子串的方法总结

本文实例总结了Python实现判断一个字符串是否包含子串的方法.分享给大家供大家参考,具体如下: 1.使用成员操作符 in >>> s='nihao,shijie' >>> t='nihao' >>> result = t in s >>> print result True 2.使用string模块的find()/rfind()方法 >>> import string >>> s='nihao,s

Python cookbook(数据结构与算法)将序列分解为单独变量的方法

本文实例讲述了Python cookbook(数据结构与算法)将序列分解为单独变量的方法.分享给大家供大家参考,具体如下: 如果对象是可迭代的(任何序列),则可以进行分解操作,包括元组.列表.字符串.文件.迭代器以及生成器,可通过简单的一个赋值操作分解为单独的变量. 唯一要求:变量的总数和序列相吻合,否则将出错: Python 2.7.11 (v2.7.11:6d1b6a68f775, Dec 5 2015, 20:32:19) [MSC v.1500 32 bit (Intel)] on wi

Python cookbook(数据结构与算法)实现查找两个字典相同点的方法

本文实例讲述了Python实现查找两个字典相同点的方法.分享给大家供大家参考,具体如下: 问题:寻找两个字典中间相同的地方(相同的键.相同的值等) 解决方案:通过keys()或者items()方法来执行常见的集合操作(比如求并集.交集和差集) >>> a={'x':1,'y':2,'z':3} >>> b={'ww':10,'x':11,'y':2} >>> a.keys()& b.keys() #键的交集 {'y', 'x'} >>

Python cookbook(数据结构与算法)将名称映射到序列元素中的方法

本文实例讲述了Python将名称映射到序列元素中的方法.分享给大家供大家参考,具体如下: 问题:希望通过名称来访问元素,减少结构中对位置的依赖性 解决方案:使用命名元组collections.namedtuple().它是一个工厂方法,返回的是python中标准元组类型的子类,提供给它一个类型名称以及相应的字段名称,它就返回一个可实例化的类,为你以定义好的字段名称传入值等. 命名元组的主要作用在于将代码同它所控制的元素位置间进行解耦 >>> from collections import

php判断一个数组是否为有序的方法

本文实例讲述了php判断一个数组是否为有序的方法.分享给大家供大家参考.具体分析如下: 这段代码的时间复杂度为O(n) <?php function JudegSortArray($array) { if ($array [0] > $array [1]) { $flag = 1; } else { $flag = 0; } $temp = $flag; $len = count ( $array ); for($i = 1; $i < $len; $i ++) { if ($flag

java判断一个文件是否为二进制文件的方法

本文实例讲述了java判断一个文件是否为二进制文件的方法.分享给大家供大家参考.具体如下: public static boolean isBinary(File file) { boolean isBinary = false; try { FileInputStream fin = new FileInputStream(file); long len = file.length(); for (int j = 0; j < (int) len; j++) { int t = fin.rea

python判断一个变量是否已经设置的方法

python判断一个变量是否已经设置的方法:可以使用locals()函数来进行判断. locals()函数会以字典类型返回当前位置的全部局部变量,具体使用方法如:['testvar' in locals().keys()]. 方法如下: 第一种方法使用内置函数locals(): locals():获取已定义对象字典 'testvar'   in   locals().keys() 第二种方法使用内置函数dir(): dir():获取已定义对象列表 'testvar'   in   dir() 第