位图相关代码实现

最新推荐文章于 2024-06-25 21:10:42 发布

Alsnoa

最新推荐文章于 2024-06-25 21:10:42 发布

阅读量446

点赞数

分类专栏：数据结构位图

本文链接：https://blog.csdn.net/Alsnoa/article/details/81070378

版权

数据结构同时被 2 个专栏收录

13 篇文章 0 订阅

订阅专栏

位图

1 篇文章 0 订阅

订阅专栏

bitmap.h

pragma once 

#include <stddef.h>

#include<inttypes.h>



typedef struct BitMap 

{ 

    uint64_t* data; 

    size_t capacity; // max bit 



} BitMap; 



void BitMapInit(BitMap* bm, size_t capacity); 



// 把第 index 位置为1 

void BitMapSet(BitMap* bm, size_t index); 



// 把第 index 位置为0 

void BitMapUnset(BitMap* bm, size_t index); 



// 测试 index 为是 1 , 还是 0. 如果是1, 就返回1. 否则返回0. 

int BitMapTest(BitMap* bm, size_t index); 



// 把整个位图所有的位都设为1. 

void BitMapFill(BitMap* bm); 



// 把整个位图所有的位都设为0. 

void BitMapClear(BitMap* bm); 



void BitMapDestroy(BitMap* bm);

bitmap.c

#include<stdio.h>

#include<stdlib.h>

#include"bitmap.h"



#define TEST_HEADER printf("\n=================%s===============\n", __FUNCTION__)



void BitMapInit(BitMap* bm, size_t capacity)

{



    if(bm==NULL)

    {

        return;

    }

  

    size_t tmp = capacity % 64;

    

    if(tmp==0)

    {

      bm->data=(uint64_t*)malloc( sizeof(uint64_t) * (capacity / 64)  );

      bm->capacity =capacity ;

    }

    else

    {

      bm->data=(uint64_t*)malloc( sizeof(uint64_t) * ( 1 + (capacity / 64) ) );

      bm->capacity = (1 + (capacity / 64))*64 ; 

    }





}



// 把第 index 位置为1 

void BitMapSet(BitMap* bm, size_t index)

{



    if(bm==NULL)

    {

        return;

    }

    

    if(bm->capacity<= index)

    {

        return;

    }



    size_t subscript=  index / 64;



    size_t offset = index % 64;



    // 0000 0000   0000 0000   0000 0000  0000 0000   0000 0000  0000 0000   0000 0000  0000 0001

    bm->data[subscript] |=  (uint64_t) 1 << offset;



}

//  [00000000]64  [000000000]64

// 把第 index 位置为0 

void BitMapUnset(BitMap* bm, size_t index)

{

  if(bm==NULL)

  {

      return;

  }

  if(bm->capacity <= index)

  {

    return;

  }



   uint64_t tmp=0xffffffffffffffff;

   

   size_t subscript = index/64;

   size_t offset = index % 64;



   tmp ^= (uint64_t)1<<offset;



   bm->data[subscript] &= tmp;





}



// 测试 index 为是 1 , 还是 0. 如果是1, 就返回1. 否则返回0. 



int BitMapTest(BitMap* bm, size_t index)

{

    if(bm==NULL)

    {

        return -1;

    }



    if(bm->capacity<= index)

    {

        return -2;

    }



   size_t subscript= index/64;

   size_t offset = index % 64;

    return ( 1 & (bm->data[subscript] >>offset));

   



    





}



// 把整个位图所有的位都设为1. 

void BitMapFill(BitMap* bm)

{



  if(bm==NULL)

  {

      return;

  }



  size_t i;

  size_t max= bm->capacity/64; 



  for(i=0;i<max;i++)

  {

    bm->data[i]=0xffffffffffffffff;

  }

   



}



// 把整个位图所有的位都设为0. 

void BitMapClear(BitMap* bm)

{

   if(bm==NULL)

   {

       return;

   }



  size_t i;

  size_t max= bm->capacity/64; 

  

  for(i=0;i<max;i++)

  {

    bm->data[i]=0;

  }



}



void BitMapDestroy(BitMap* bm)

{

    if(bm==NULL)

    {

        return;

    }

     

    free(bm->data);

    bm->data=NULL;



    bm->capacity=0;



}



void ShowSturct(BitMap* bm)

{

     printf("     Bit Map Sturct     \n");

     printf("data     : %10p\n",bm->data);

     printf("capacity : %10lu\n",bm->capacity);

}





void ShowBit(BitMap * bm)

{

   if(bm==NULL)

   {

       return;

   }

   printf("==================================================================================\n");

    size_t i;

    for(i=0;i< (bm->capacity/64);i++)

    {

      uint64_t tmp= bm->data[i]; 

       size_t t;

       for(t=0;t<64;t++)

       {

         if( tmp  & (uint64_t)1<<t )

         {

             printf("1 ");

         }

         else

         {

             printf("0 ");

         }

       }

      printf("\n");

    }

    printf("===========================================================================\n");

}



void TestAll()

{

    

    TEST_HEADER;

    BitMap bm;

    BitMapInit(&bm,1024);    

    ShowSturct(&bm);



    BitMapClear(&bm);

    ShowBit(&bm);



    BitMapSet(&bm, 1000); 

    BitMapSet(&bm, 1001); 

    BitMapSet(&bm, 1002); 

    BitMapSet(&bm, 1003); 

    BitMapSet(&bm, 1004); 

    BitMapSet(&bm, 1005); 

    ShowBit(&bm);



    int ret= BitMapTest(&bm,1000);



    printf("ret(1000) ----- expect 1 , actull:%d\n", ret);



   



    BitMapUnset(&bm, 1000);

    BitMapUnset(&bm, 1001);

//    BitMapUnset(&bm, 1002);

 //   BitMapUnset(&bm, 1003);

  //  BitMapUnset(&bm, 1004);

    ShowBit(&bm);

    ret=BitMapTest(&bm,1000);

    printf("ret(1000) ----- expect 0 , actull:%d\n", ret);



    BitMapFill(&bm);

    ShowBit(&bm);

    

    BitMapDestroy(&bm);

    ShowSturct(&bm);



}





int main()

{

  TestAll();

  return 0;

}