用位图解决大量整数只出现一个，不超过两次，文件交集问题

最新推荐文章于 2023-10-22 19:27:19 发布
最新推荐文章于 2023-10-22 19:27:19 发布
阅读量378 收藏 1
点赞数
分类专栏： 数据结构 文章标签： 位图
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/HaloTrriger/article/details/79808788
版权

先略提下位图：位图是建立在哈希表的基础上进行的优化，哈希表可能用1个字节或者4个字节来表示key，如果数据太多，哈希表就会占用大量空间。为了解决这个问题，聪明的人类发明了了位图。找到key的用一个bit来存储一个数的状态，0表示不存在，1表示存在。这样查找key是只需判断对应bit是1还是0就行，解决了哈希表占用空间的问题。

例题：位图应用

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

使用位图，就是用1个bit位表示一个状态（或者表示次数），可以缓解大量数据相关问题。
100亿个整数，如果是int型的话，在32位机器下int型表示范围为-2^31~2^31-1，共2^32个数字。而100亿个数字的话，远远超出int表示范围，这就意味着有大量数据重复了，而且有些数据可能出现不止一次。但既然这个题目让我们找到只出现一次的整数，那么我们用2个bit来表示一个整数出现次数就完全O什么K了。从左向右存储表示，00表示出现0次，10表示出现1次，11表示出现不止一次。
2个bit表示一个数字，如果要存储2^32个数字的状态就需要2 ^ 32 / 8 * 2字节的空间。一个字节就可以存储4个整数的状态了。我们用数组的方式存取数据。key表示查找表示所要查找的整数，因为2个bit表示一个数字，所以key/16才是存储key的元素下标，key%16和key%16+1就是key的两个状态位。用1左移对应长度，然后比较，就可判断key是否出现一次。
代码：
BitMap.h

#pragma once

#include<stdio.h>
#include<assert.h>
#include<stdlib.h>
#include<string.h>

typedef struct BitMap
{
    size_t* _bits;
    size_t _range;
}BitMap;

void BitMapInit(BitMap* bm, size_t range);
void BitMapSet(BitMap* bm, size_t x);
void BitMapReset(BitMap* bm, size_t x);
// x存在返回0，不存在返回-1 
int BitMapTest(BitMap* bm, size_t x);
void BitMapOnceTime(BitMap*bm, size_t x);//数字出现一次

BitMpa.c

#include"BitMap.h"

void BitMapInit(BitMap* bm, size_t range)//初始化
{
    bm->_bits = (size_t*)malloc(range / 4 + 1);
    assert(bm);
    memset(bm->_bits, 0, range / 4 + 1);
}

void BitMapSet(BitMap* bm, size_t x)//置1,两个bit表示状态，00、10、11表示0次，1次，2次及以上
{
    assert(bm);

    int _index = x / 16;
    int _position = x % 16 * 2;

    if (BitMapTest(bm,x) == -1)//出现0次
    {
        bm->_bits[_index] |= (1 << _position);
    }
    else
    {
        if  (((bm->_bits[_index]) & (1 << (_position + 1))) == 0)//出现1次
            bm->_bits[_index] |= (1 << (_position + 1));
        else//出两次及以上，不变
            return;
    }
}

void BitMapReset(BitMap* bm, size_t x)//当前位置清零
{
    assert(bm);

    int _index = x / 16;
    int _position = x % 16 * 2;

    bm->_bits[_index] &=  ~(1 << _position);
    bm->_bits[_index] &= ~(1 << (_position + 1));
}

// x存在返回0，不存在返回-1 
int BitMapTest(BitMap* bm, size_t x)
{

    int _index = x / 16;
    int _position = x % 16 * 2;

    if ((((bm->_bits[_index]) & (1 << _position)) != 0)
        || (((bm->_bits[_index]) & (1 << (_position + 1))) != 0))
        return 0;
    else
        return -1;
}

void BitMapOnceTime(BitMap*bm, size_t x)//数字出现一次
{
    assert(bm);

    int _index = x / 16;
    int _position = x % 16 * 2;

    if ((((bm->_bits[_index]) & (1 << _position)) != 0)
        && (((bm->_bits[_index]) & (1 << (_position + 1))) == 0))
        printf("%u appear once.\n",x);
    else
        printf("%u isn't once.\n",x);
}

Test.c

#include"BitMap.h"

void TestAppearOnce()
{
    BitMap bt;
    BitMapInit(&bt, -1);//range是size_t型，-1存进去就是全1，表示整型最大数
    BitMapSet(&bt, 99);//只能插入非负数
    BitMapSet(&bt, 99);
    BitMapSet(&bt, 16);
    BitMapSet(&bt, 16);
    BitMapSet(&bt, 16);
    BitMapSet(&bt, 88);
    BitMapSet(&bt, 1024);
    BitMapSet(&bt, 4200000000);

    BitMapOnceTime(&bt, 99);
    BitMapOnceTime(&bt, 16);
    BitMapOnceTime(&bt, 88);
    BitMapOnceTime(&bt, 1024);
    BitMapOnceTime(&bt, 4200000000);
}


int main()
{
    TestAppearOnce();

    return 0;
}

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

100亿个int类型的数据，则数据范围在-2^31~2^21-1，2个bit表示一个数据出现的次数，只需2^32 * 2个bit就可。而2^32*2bit就是1G，因此内存使用满足题目条件。用从左向右存储，00、10、01、11分别表示0次，1次，2次，3次。类似100亿个整数查找只出现一次的整数，即可找到满足题目要求的整数。
代码
BitMapAppearNoMoreTwice.h

//1个文件有100亿个int，1G内存，设计算法找到出现次数不超过2次的所有整数
#pragma once

#include<stdio.h>
#include<assert.h>
#include<stdlib.h>
#include<string.h>

typedef struct BitMap
{
    size_t* _bits;
    size_t _range;
}BitMap;

void BitMapInit(BitMap* bm, size_t range);
void BitMapSet(BitMap* bm, size_t x);
void BitMapReset(BitMap* bm, size_t x);
void BitMapAppearNoMoreTwiceTime(BitMap*bm, size_t x);//数字出现一次
void Destory(BitMap* bt);//销毁

BitMapAppearNoMoreTwice.c

#include"BitMapAppearNoMoreTwice.h"

void BitMapInit(BitMap* bm, size_t range)//初始化
{
    bm->_bits = (size_t*)malloc(range / 4 + 1);
    assert(bm);
    memset(bm->_bits, 0, range / 4 + 1);
}

//2个bit位表示一块，标识一个数。0-2147483647块标识正数，2147483647-4294967295块标识负数
void BitMapSet(BitMap* bm, size_t x)//置1,两个bit表示状态，00、01、10、11表示0次，1次，2次、3次及以上
{
    assert(bm);

    int _index = x / 16;
    int _position = x % 16 * 2;

    if ((((bm->_bits[_index]) & (1 << _position)) == 0)
        && (((bm->_bits[_index]) & (1 << (_position + 1))) == 0))//出现0次
    {
        bm->_bits[_index] |= (1 << _position);
    }

    else if ((((bm->_bits[_index]) & (1 << _position)) != 0)
        && (((bm->_bits[_index]) & (1 << (_position + 1))) == 0))//出现1次
    {
        bm->_bits[_index] |= (1 << (_position + 1));//高位置1
        bm->_bits[_index] &= ~(1 << _position);//低位置0
    }

    else if ((((bm->_bits[_index]) & (1 << _position)) == 0)
        && (((bm->_bits[_index]) & (1 << (_position + 1))) != 0))//出现两次
    {
        bm->_bits[_index] |= (1 << _position);//低位置1
    }

    else
        return;

}

void BitMapReset(BitMap* bm, size_t x)//当前位置清零
{
    assert(bm);

    int _index = x / 16;
    int _position = x % 16 * 2;

    bm->_bits[_index] &= ~(1 << _position);
    bm->_bits[_index] &= ~(1 << (_position + 1));
}


void BitMapAppearNoMoreTwiceTime(BitMap*bm, size_t x)//数字出现不超过两次
{
    assert(bm);

    int _index = x / 16;
    int _position = x % 16 * 2;

    if ((((bm->_bits[_index]) & (1 << _position)) != 0)
        && (((bm->_bits[_index]) & (1 << (_position + 1))) != 0))
    {
        printf("%d appear more than twice.\n", x);
    }
    else
    {
        printf("%d appear no more twice.\n", x );
    }

}

void Destory(BitMap* bt)//销毁
{
    assert(bt);

    free(bt->_bits);
    bt->_bits = NULL;
    bt->_range = 0;
}

Test.c

#include"BitMapAppearNoMoreTwice.h"

void TestAppearOnce()//只能插入-2147483648到2147483647之间的数,因为这是int型范围
{
    BitMap bt;
    BitMapInit(&bt, -1);//range是size_t型，-1存进去就是全1，表示整型最大数
    BitMapSet(&bt, 99);
    BitMapSet(&bt, 99);
    BitMapSet(&bt, -16);
    BitMapSet(&bt, -16);
    BitMapSet(&bt, 88);
    BitMapSet(&bt, 88);
    BitMapSet(&bt, 88);
    BitMapSet(&bt, 1024);
    BitMapSet(&bt, 1024);
    BitMapSet(&bt, 1024);
    BitMapSet(&bt, 1024);
    BitMapSet(&bt, -2100000000);
    BitMapSet(&bt, -2100000000);

    BitMapAppearNoMoreTwiceTime(&bt, 99);
    BitMapAppearNoMoreTwiceTime(&bt, -16);
    BitMapAppearNoMoreTwiceTime(&bt, 88);
    BitMapAppearNoMoreTwiceTime(&bt, 1024);
    BitMapAppearNoMoreTwiceTime(&bt, -2100000000);

    Destory(&bt);
}


int main()
{
    TestAppearOnce();

    return 0;
}

给两个文件，分别有100亿个整数，我们只有1G内存，如何找到两个文件交集

两个文件，一个bit位就可标识整数key是否存在。2^32bit就可以表示一个文件，2个文件共需1G，满足题意。然后判断对应位置状态位是否都为1即可。
代码
BitMap.h

#pragma once

#include<stdio.h>
#include<assert.h>
#include<stdlib.h>
#include<string.h>

typedef struct BitMap
{
    size_t* _bits;
    size_t _range;
}BitMap;

void BitMapInit(BitMap* bm, size_t range);
void BitMapSet(BitMap* bm, size_t x);
void BitMapReset(BitMap* bm, size_t x);
int BitMapTest(BitMap* bm, size_t x);// x存在返回0，不存在返回-1 
void JudgeTwoBitMapSame(BitMap *bt1, BitMap *bt2);//判断两个位图相同地方
void Destory(BitMap* bt);//销毁

BitMap.c

#include"BitMap.h"

void BitMapInit(BitMap* bm, size_t range)
{
    bm->_bits = (size_t*)malloc(range / 8 + 1);
    bm->_range = range;
    assert(bm);
    memset(bm->_bits, 0, bm->_range / 8 + 1);
}

void BitMapSet(BitMap* bm, size_t x)
{
    assert(bm);

    int _index = x / 32;
    int _position = x % 32;

    bm->_bits[_index] |= (1 << _position);
}

void BitMapReset(BitMap* bm, size_t x)
{
    assert(bm);

    int _index = x / 32;
    int _position = x % 32;

    bm->_bits[_index] &= ~(1 << _position);

}

// x存在返回0，不存在返回-1 
int BitMapTest(BitMap* bm, size_t x)
{
    int _index = x / 32;
    int _position = x % 32;

    if (((bm->_bits[_index]) & (1 << (_position))) != 0)
        return 0;
    else
        return -1;
}


void JudgeTwoBitMapSame(BitMap *bt1, BitMap *bt2)//判断两个位图相同地方
{
    assert(bt1);
    assert(bt2);
    size_t i = 0;
    int _index;
    int _position;

    for (i = 0; i < bt1->_range; i++)//此处i<bit1的范围，而bt1->_range=2^32，循环会进行较长时间\
        且不能判断2^32-1位置的数,若i=2^32-1则会死循环
    {
        _index = i / 32;
        _position = i % 32;
        if (((bt1->_bits[_index] & (1<<_position)) != 0) 
            && ((bt2->_bits[_index] & (1 << _position)) != 0))
            printf("%u ", i);
    }

}

void Destory(BitMap* bt)//销毁
{
    assert(bt);

    free(bt->_bits);
    bt->_bits = NULL;
    bt->_range = 0;
}

Test.c

#include"BitMap.h"


void TestTwoBitMapSame()
{
    BitMap bt1;
    BitMap bt2;
    BitMapInit(&bt1, -1);//range是size_t型，-1存进去就是全1，表示整型最大数
    BitMapInit(&bt2, -1);

    BitMapSet(&bt1, 99);//只能插入非负数
    BitMapSet(&bt1, 666);
    BitMapSet(&bt1, 16);
    BitMapSet(&bt1, 2333);
    BitMapSet(&bt1, 11);
    BitMapSet(&bt1, 88);
    BitMapSet(&bt1, 1996);
    BitMapSet(&bt1, 1024);
    BitMapSet(&bt1, 1024);
    BitMapSet(&bt1, 4294967294);//4294967294该数是最大存储的数字，2^32-1-1,\
                                因为位图从0开始存储，空间是2^32-1,



    BitMapSet(&bt2, 100);
    BitMapSet(&bt2, 6954);
    BitMapSet(&bt2, 759);
    BitMapSet(&bt2, 2048);
    BitMapSet(&bt2, 2333);
    BitMapSet(&bt2, 16);
    BitMapSet(&bt2, 1024);
    BitMapSet(&bt2, 1996);
    BitMapSet(&bt2, 4294967294);

    JudgeTwoBitMapSame(&bt1, &bt2);
    printf("\n");

    BitMapReset(&bt2, 1996);
    JudgeTwoBitMapSame(&bt1, &bt2);
    printf("\n");

    Destory(&bt1);
    Destory(&bt2);

}

int main()
{

    TestTwoBitMapSame();
    return 0;
}
立 夏
关注
专栏目录
位图
weixin_43554618的博客
07-12 4813
位图 1.位图的概念 所谓位图，就是用每一位来存放某种状态，适用于海量数据，数据无重复的场景，通常是用来判断某个数据存不存在的。 2.位图的实现 namespace BitSet { class bitset { public: bitset(size_t n) { _bit.resize(n / 32 + 1, 0); _num = 0; } void set(size_t x) { size_t index = x / 32; size_t pos =
面试被问，一千万个整数里面快速查找某个整数，你会怎么去做？
Java知音
10-26 648
最近小林在求职面试中被询问了这么一个有趣的面试题：假设当我们需要在一千万个整数（整数的范围在1-1亿之间）里面快速查找某个整数是否存在于其中的话，如何快速查找进行判断会比较方便呢？ps:...
实现一个位图、100亿个整数找出只出现一次的整数、找出现次数不超多2次的数
Steve_Abelieve
08-05 3657
1.–实现一个位图。 位图特点： 节省空间 适合数据比较密集的情况 适合判断事件 是否 这样的问题 相关位运操作： & | ~ 代码实现：#include<iostream> #include<vector>using namespace std;// //1.【基础题】--实现一个位图。 //位图特点： 节省空间，适合数据密集的情况 class BitSet {
位图求交集
weixin_30292843的博客
04-26 201
位图求交集View Codepublicclass位图求交集{///<summary>///排序数组///</summary>///<paramname="list">排序数组</param>///<paramname="M...
集合的检索：位图法
CCPP Blog
08-15 2662
位图法是一种逻辑上很巧妙的描述集合的方法。 如集合S={2,4,1,5,12}，它用位图描述就是 0110 1100 0000 1000，两个字节即可描述S，左边是低阶位。用bitset<16>存储的话就是{[15]、[14]、...[1]、[0]}={0001000000110110}。 用位图对集合进行描述后，就很方便进行集合的运算，如交、并和差。
用位图实现整数排序
yuan_xulong的博客
04-18 147
    命题:一个顺序输入文件(比如磁带机),无序保存了一些整型值,这些值最小从1开始,最大不超过10000000,且没有重复,要求对文件中的数值进行排序,并按升序输出.     约束:可以使用的内存很小,最大不超过2M内存.     算法实现:可以使用位图来实现该排序,具体描述,假设有5个数字集合{1,2,3,5,8},可以用10位位图表示为{1,1,1,0,1,0,0,1,0,0},位图...
两个整数集合的交集 ———— 腾讯2014软件开发笔试题目
weixin_30809173的博客
07-12 190
题目： A、B两个整数集合，设计一个算法求他们的交集，尽可能的高效。 思想： 位图标示数字 1 遍历 集合A，求出 最值，效率 1.5n ，计算最大值与最小值的差为LA。对B一样求出最值的差为LB。 2 新建一块空间 M，大小为 min( LA, LB ) / 8 取整 +1 个字节 3 遍历 最值差 小的 集合 设置M的第j个比特为1（从0开始），j 为 每个 元素 与 该集合...
哈希(解决哈希冲突，封装map/set，哈希的应用{位图/布隆过滤器})
Morn_Star_Oliver的博客
07-11 601
C++哈希的内容
大数据方面问题的解决办法和技巧
Wantbebetter的博客
12-02 1614
大数据方面面试题思路与技巧大数据题目的解题技巧题目1 找到未出现的数解法：位图进阶问题解法：无符号整形词频统计数组再次进阶问题解法：二分法题目2 找到重复的URL解法：布隆过滤器 或 Hash分流 大数据题目的解题技巧 哈希函数可以把数据按照种类均匀分流 布隆过滤器用于集合的建立与查询，并可以节省大量空间 一致性哈希解决数据服务器的负载管理问题 利用并查集结构做岛问题的并行计算 位图解决某一范围上数字的出现情况，并可以节省大量空间 利用分段统计思想、并进一步节省大量空间 利用堆、外排序来做多个处理单元的结
C++位图及应用
TONGtongTONG000的博客
11-02 505
位图 位图是用一个比特位来表示一个数据是否存在这一状态的信息，1表示存在，0表示不存在。常用于海量的数据，没有重复的时候，快速判断某个数据是否存在 1个字节有8个比特位，就能表示8个数据的状态信息，有N个数据，需要N/8+1个字节。 例如，有一个整形数据集合 {1,3,7,4,12,16,19,13,22,18};其中最大数据为22，最小数据为1，首先估算需要大概多少个字节，位图中应包含min到max这个范围中所有数据的状态信息。实际需要22个比特位，需要3个字节的空间。 第二步将集合中的数据向位图中进行
【位图】位图实现，处理大数据
菜鸟成长记
08-05 3761
定义位图法就是bitmap的缩写。所谓bitmap，就是用每一位来存放某种状态，适用于大规模数据，但数据状态又不是很多的情况。通常是用来判断某个数据存不存在的。例如，要判断一千万个人的状态，每个人只有两种状态：男人，女人，可以用0，1表示。那么就可以开一个int数组，一个int有32个位，就可以表示32个人。操作的时候可以使用位操作。位图实现unsigned int bit[N];在这个数组里面，可
编程珠玑读书笔记——出现次数为多次的位图法实现
weixin_30847865的博客
03-28 51
是书上的一道问题,文件中保护至多10000000个记录, 每条记录都是一个7位整数. 你只有1mb的主存(我的编码完成所需内存会略大于1mb, 可以用多通道解决,这里暂不实现) 每个整数至多只能出现10次. 只是把位图法的存储空间变为4bit 即用4bit来表示该数的出现次数 为0则文件中无此数 以下是我自己用c实现的 编译器是vc6.0 #define BITSPE...
位图数据结构
M_jianjianjiao
09-12 440
位图 将一个数据的每一位都来表示一个数，存在为1不存在为0，一个char有8位，或int的32位，通过运算关系可以将每一个无符号整数都映射到每一位上，从而实现大量数据的存储。 笔试题：给40亿个不重复的无符号整数，没脾气郭旭。给一个无符号数，如何快速判读一个数是否在这40亿个数中。 将这40亿个数全部置入位图相应的位上，有为1，没有为0，如果要找的数对应的位上为1，代表该数存在，否则不存...
海量数据处理
HXiaoFan的博客
05-06 274
海量数据处理：是针对数据量较大，导致内存不足或十分占内存的情况而有的解决算法1 给一个超过100G大小的log file, log中存着IP地址, 设计算法找到出现次数最多的IP地址？【问题分析】（1）日志文件一般为一行一条日志，并且有一定的格式，每一条日志中含一个IP地址，我们可以看一下这个笔记的日志信息，简单有一个认识：（2）日志文件共100G，占用内存过大，可以尝试对100G的文件进行切分，...
【C++】哈希应用——海量数据面试题
最新发布
m0_70088010的博客
10-22 257
注意点：如果我们存储100亿个整数的话，在堆中需要申请大约40个G的空间，这个空间是非常大的，而我们利用位图来解决这个问题的时候，我们就只需要512MB，也就是代码中的4294967295，两个位图才只需要1个G的空间。3、由于哈希切分时使用的是同一个哈希函数，因此相同的IP地址计算出的 i i值是相同的，最终这些相同的IP地址就会进入到同一个Ai小文件当中。方法是依次读取文件中的整数的值，将其映射到一个位图中，再读取另一个文件中的所有整数，判断在不在位图中，在就是交集，不在就不是交集。
哈希面试题--海量数据
virgofarm的博客
05-28 707
哈希切割top K问题 给一个超过100G大小的log file, log中存着IP地址, 设计算法找到出现次数最多的IP地址？ 与上题条件相同，如何找到top K的IP？ （1）文件太大，100g，肯定不可能一次加载到内存进行处理，这里就必须将文件进行切割了，可是依据哪种方法进行切割呢？假设只是从前到后等份切割的话，将文件切割n份(切割的份数依据所给的内存大小)，第一份中假设IP地址为a...
海量数据面试题
swo_ows的博客
10-26 342
1、给定100亿个整数，设计算法找到只出现一次的整数； 先将100亿个整数切割到100个文件中，每个文件利用哈希表存储，找出每个文件中只出现一次的整数，再合并最后找出只出现一次的整数。 2、给两个文件，分别有100亿个整数，我们只有1G内存，如何找到两个文件交集； 和上题一样，先将两个文件都利用相同的散列函数各切割为100份，并且将两个文件的切割文件按一样的规律编号，再将相同编号的文件进行合...
数据结构::一些经典的大数据题
海绵宝宝的欧尼~ 的博客
02-22 5457
前言： 1、说明：一般解决大数据问题有两个思路： 1）先将与这道题相关的所有的数据结构进行使用一遍，如果有合适的就直接进行使用 2）如果不能直接使用，一般就要进行哈希切分，然后再使用合适的数据结构进行问题的解决 2、在这里我先来介绍一种常用于大数据问题的方法：哈希切分 1）先估算出要切分的大小 2）然后使用哈希的除留余数法进行各个数据的映射 经典题： 1、给
visual c++资源文件加载位图确出现ic两个字
03-24
这可能是因为您的位图文件格式不正确或者您的代码中存在错误。您可以检查一下您的位图文件是否是正确的格式，并且检查一下您的代码中是否存在错误。如果您需要更具体的帮助，请提供更多的细节信息，我会尽力帮助您解决问题。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值