数据结构之哈希变形（位图）

Bitmap.h

#pragma once
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdint.h>
typedef uint64_t BitmapType;
typedef struct Bitmap
{
    BitmapType* data;
    uint64_t* capacity;
}Bitmap;
void BitmapInit(Bitmap* bm,uint64_t capacity);
void BitmapDestroy(Bitmap* bm);
void BitmapSet(Bitmap* bm,uint64_t index);
void BitmapUnSet(Bitmap* bm,uint64_t index);
void BitmapFill(Bitmap* bm,uint64_t capacity);
void BitmapClear(Bitmap* bm,uint64_t capacity);
uint64_t BitmapTest(Bitmap*bm,uint64_t index);

Bitmap.c

#include <stdio.h>
#include "Bitmap.h"
void BitmapInit(Bitmap* bm,uint64_t capacity)
{
    if(bm == NULL)
    {
        return;
    }
    bm->capacity = capacity;
    uint64_t size = capacity/(sizeof(BitmapType)*8)+1;
    bm->data = (BitmapType*)malloc(sizeof(BitmapType)*size);
    memset(bm->data,0,sizeof(BitmapType)*size);
    return;

}
void BitmapDestroy(Bitmap* bm)
{
    if(bm == NULL)
    {
        return;
    }
    bm->capacity = 0;
    free(bm->data);
    return;
}
/*uint64_t Getsize(uint64_t capacity)
{
    uint64_t size = capacity/(sizeof(BitmapType)*8);
}*/
uint64_t BitmapTest(Bitmap* bm,uint64_t index)
{
    if(bm == NULL || index >= bm->capacity)
    {
        return;
    }
    uint64_t n,offset;
    n = index/(sizeof(BitmapType)*8);
    offset = index % (sizeof(BitmapType)*8);
    uint64_t ret = bm->data[n]&(0x1ul << offset);
    return ret > 0 ? 1 : 0 ;

}
/*void GetOffset(uint64_t index,uint64_t n,uint64_t offset)
{
    *n = index/(sizeof(BitmapType)*8);
    *offset = index % (sizeof(BitmapType)*8);

}*/
void BitmapSet(Bitmap* bm,uint64_t index)
{
    if(bm == NULL || index >= bm->capacity)
    {
        return;
    }
    uint64_t n,offset;
    n = index/(sizeof(BitmapType)*8);
    offset = index % (sizeof(BitmapType)*8);
    bm->data[n] = (0x1ul << offset);
    return;
}

void BitmapUnSet(Bitmap* bm,u_int64_t index)
{
    if(bm == NULL || index >= bm->capacity)
    {
        return;
    }
    uint64_t n,offset;
    n = index/(sizeof(BitmapType)*8);
    offset = index % (sizeof(BitmapType)*8);
    bm->data[n] &= ~(0x1ul << offset);

}
void BitmapFill(Bitmap* bm,uint64_t capacity)
{
    if(bm == NULL)
    {
        return;
    }

    uint64_t size = capacity/(sizeof(BitmapType)*8)+1;
    memset(bm->data,0xff,sizeof(BitmapType)*size);
    return;
}
void BitmapClear(Bitmap* bm,uint64_t capacity)
{

    if(bm == NULL)
    {
        return;
    }

    uint64_t size = capacity/(sizeof(BitmapType)*8)+1;
    memset(bm->data,0x0,sizeof(BitmapType)*size);
}
//----------------------test.c------------------------------
#define HEADER printf("\n===============%s==============\n",__FUNCTION__)
void test_BitmapTest()
{
    HEADER;
    Bitmap bm;
    BitmapInit(&bm,100);
    BitmapSet(&bm,50);
    int ret = BitmapTest(&bm,50);
    printf("ret expected 1,actual %d\n",ret);
}
void test_BitmapUnSet()
{
    HEADER;
    Bitmap bm;
    BitmapInit(&bm,100);
    BitmapSet(&bm,50);
    int ret1 = BitmapTest(&bm,50);
    printf("ret1 expected 1,actual %d\n",ret1);
    BitmapUnSet(&bm,50);
    int ret2 = BitmapTest(&bm,50);
    printf("ret2 expected 0,actual %d\n",ret2);

}
void test_BitmapFill()
{

    HEADER;
    Bitmap bm;
    BitmapInit(&bm,100);
    BitmapFill(&bm,100);
    int ret1 = BitmapTest(&bm,50);
    printf("ret1 expected 1,actual %d\n",ret1);
    int ret2 = BitmapTest(&bm,99);
    printf("ret2 expected 1,actual %d\n",ret2);
}
void test_BitmapClear()
{

    HEADER;
    Bitmap bm;
    BitmapInit(&bm,100);
    BitmapClear(&bm,100);
    int ret1 = BitmapTest(&bm,50);
    printf("ret1 expected 0,actual %d\n",ret1);
    int ret2 = BitmapTest(&bm,99);
    printf("ret2 expected 0,actual %d\n",ret2);
}
int main()
{
    test_BitmapTest();
    test_BitmapUnSet();
    test_BitmapFill();
    test_BitmapClear();
}