**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.