# Data structure bitmap bitmap

Source: Internet
Author: User
Tags bool

give 4 billion non-repeating unsigned integers, not sequenced. Given an unsigned integer, how can you efficiently determine whether the data is present.

The direct idea is that we store these unsigned integers in memory and then make one by one comparisons with the given number.

Let's analyze that an unsigned integer is 4 bytes, 4 billion * 4 bytes, 1 billion bytes is probably 4 G, and 4 billion unsigned integers are 16G

Computer memory is generally not so big, even if there is such a large, but also to the operating system or something, the direct storage of plastic is not good to achieve;

Moreover, this comparison again, if not exist, then to compare 4 billion times, the efficiency is too low

Now, we can use bitmap---bitmap to solve this problem. That saves space and can solve this problem quickly.

the concept of bitmaps

A bitmap is a representation of the existence or absence of data using every bits of each element of an array;

0 means no, 1 indicates the advantage of having bitmaps

Bitmaps can quickly determine whether a stored keyword exists

and 4 billion integers, an integer occupies only one bit, the space occupancy rate is 31 times times less than before, it only needs about 500M. Anatomy of a bitmap Step 1 Choose a data structure that we have learned

Bitmaps need to be bits, by using the bits 0, one to indicate whether a number exists

We use vectors to store these numbers, and we can put vectors into any basic type; Step 2 to find the corresponding bits

This time we put size_t unsigned, with 32 bits. In other words, a vector of a corresponding subscript can indicate whether 32 numbers exist;

```	Vector<size_t> _v;//stores the status of each number size_t the number of
_size;//flags deposited```
Now give us a number, we divide it by 32, the quotient is the corresponding subscript, the remainder is the corresponding subscript in the number of bits;

Step 3 Consider how to place the position at 1

We know that binary or operation can be a position of 1;

The code for the position

```	Put, the position of NUM is 1
void Set (size_t num)
{//index is
used to determine which of the elements in the vector//value represents the number of points in
the element from the low to the high.
the//index is shifted to the right by 5 bits, equivalent to 32, with the shift operation High efficiency
int index = num >> 5;
int value = num%;

Use or operation, the position is 1
_v[index] |= 1 << (value-1);
_size++;
}```
Step 4 How to reset, erase a number in the bitmap

or using a bitwise operation, this time with XOR;

The same is 0, dissimilarity is 1;

```	Move out, place Num's position at 0
void Reset (size_t num)
{//index is
used to determine which of the elements in the vector//value represents the number of points in
the element from low to high.
the//index is shifted to the right by 5 bits, equivalent to 32, with the shift operation High efficiency
int index = num >> 5;
int value = num%;

Using the XOR operation, the position is 0
_v[index] ^= 1 << (value-1);
_size--;
}```
Step 5 Determine if a number exists in the bitmap

Still bit arithmetic, with, all 1 is 1, otherwise 0

```	Used to determine whether a number has been stored in a bitmap in
bool Find (size_t num)
{
int index = num >> 5;
int value = num%;

Determine if the bit is 1
return (_v[index] >> (value-1)) & 1;
}```
Source Code

```#include <vector>

//define Bitmap
class BitMap
{public
:
//Bitmap constructor
BitMap (size_t size = 1024)
: _size (0)
{
//an unsigned reshape (size_t) can have 32 bits representing 32 numbers
_v.resize (SIZE/32 + 1);
}

Put, the position of NUM is 1
void Set (size_t num)
{//index is
used to determine the number of elements
in the vector Value indicates which of the//index from the low to high number in the element is shifted to the
right by 5 bits, equivalent to 32, with the shift operation High efficiency
int index = num >> 5;
int value = num%;

Use or operation, the position is 1
_v[index] |= 1 << (value-1);
_size++;
}

Move out, where Num is located at 0
void Reset (size_t num)
{//index is
used to determine the number of elements
in the vector Value indicates which of the//index from the low to high number in the element is shifted to the
right by 5 bits, equivalent to 32, with the shift operation High efficiency
int index = num >> 5;
int value = num%;

Using the XOR operation, the position is 0
_v[index] ^= 1 << (value-1);
_size--;
}

Used to determine whether a number has been stored in a bitmap in
bool Find (size_t num)
{
int index = num >> 5;
int value = num%;

Determine if the bit is 1
return (_v[index] >> (value-1)) & 1;
}
Protected:
vector<size_t> _v;
size_t _size;
};```
Some applications of bitmaps apply 1 To sort using bitmaps

Iterate through the numbers and put them in the corresponding position on the bitmap. Then, from low to high, traverse through each bit;

The flaw is for negative numbers, to be converted to unsigned integers, the output of the time minus the minimum value can be applied 2 to determine if there are duplicates

Iterate over these numbers and place them in the bitmap if they do not exist, or the duplicate elements are found.

Related Keywords:

The content source of this page is from Internet, which doesn't represent Alibaba Cloud's opinion; products and services mentioned on that page don't have any relationship with Alibaba Cloud. If the content of the page makes you feel confusing, please write us an email, we will handle the problem within 5 days after receiving your email.

If you find any instances of plagiarism from the community, please send an email to: info-contact@alibabacloud.com and provide relevant evidence. A staff member will contact you within 5 working days.

## A Free Trial That Lets You Build Big!

Start building with 50+ products and up to 12 months usage for Elastic Compute Service

• #### Sales Support

1 on 1 presale consultation

• #### After-Sales Support

24/7 Technical Support 6 Free Tickets per Quarter Faster Response

• Alibaba Cloud offers highly flexible support services tailored to meet your exact needs.