C语言-位图（BitMap）的实现与相关应用详解

位图（Bitmap）是一种高效存储和操作大量布尔型数据的数据结构，其核心思想是使用每一位来表示一种状态，通常用于需要快速查找、插入和删除的应用场景。在C语言中，位图的实现以及相关操作可以帮助开发者有效地管理和处理大规模的数据集合，本文将详细介绍位图的定义、实现原理、常用操作以及示例应用。

1. 什么是位图？

位图是一种数据结构，用于存储大量的布尔型数据（即每个数据只有两种状态：0或1）。它通过使用每一位来表示一个状态，从而节省内存空间并提高操作效率。在计算机中，最小的存储单位是字节（byte），而位图则是利用位（bit）来进行数据存储和操作。

2. 位图的基本原理

• 数据表示：位图通常使用一个整数数组来存储位数据，例如使用 uint32_t 类型的数组，每个 uint32_t 可以存储32位。
• 位操作：位图支持基本的位操作，包括设置位（置为1）、清除位（置为0）、测试位状态等，这些操作通常使用位运算来实现，如按位与（AND）、按位或（OR）、按位异或（XOR）等。
• 空间效率：相比使用字节或更大单位存储布尔型数据，位图可以显著减少内存占用，特别是在需要存储大量只有两种状态的数据时，如存在与否、出现次数等。

3. 应用场景

位图在计算机科学中有多种应用，其中包括但不限于：

• 数据压缩和存储：在压缩算法中，位图可以用来表示数据中的重复项或者模式。
• 查找和过滤：例如在数据库中，位图可以用来快速查找某些数据项的存在或者匹配。
• 图像处理：在图像处理中，位图可以用来表示像素的颜色和位置信息。
• 算法优化：一些算法和数据结构（例如布隆过滤器）使用位图来提高性能和减少空间消耗。

4. 使用C语言实现位图

下面是一个简单的示例，展示如何使用C语言实现一个基本的位图结构和相关操作

完整的实现代码示例：

#include <stdio.h>
#include <stdlib.h>
#include <stdint.h> // 包含uint32_t类型的定义

#define BITMAP_SIZE 100 // 位图大小，假设为100位

// 定义位图结构
typedef struct {
    uint32_t *bits; // 使用32位整数作为位图的单元
    uint32_t size;  // 位图的大小（以位为单位）
} Bitmap;

// 初始化位图
Bitmap* bitmap_init(uint32_t size) {
    Bitmap *bitmap = (Bitmap *)malloc(sizeof(Bitmap)); // 分配位图结构的内存空间
    if (bitmap == NULL) { // 检查内存分配是否成功
        perror("Failed to allocate memory for bitmap");
        return NULL;
    }
    
    // 计算需要多少个32位整数来表示位图
    uint32_t array_size = size / 32 + 1; // 计算所需的数组大小，每个uint32_t可以存储32位
    bitmap->bits = (uint32_t *)calloc(array_size, sizeof(uint32_t)); // 分配位图数据存储的内存空间
    if (bitmap->bits == NULL) { // 检查内存分配是否成功
        perror("Failed to allocate memory for bitmap bits");
        free(bitmap);
        return NULL;
    }
    
    bitmap->size = size; // 设置位图的大小
    return bitmap; // 返回初始化后的位图结构
}

// 设置位图中某一位的值（将其置为1）
void bitmap_set(Bitmap *bitmap, uint32_t pos) {
    if (bitmap == NULL || pos >= bitmap->size) { // 检查位图结构是否有效，以及位置是否超出范围
        return; // 如果无效，则直接返回
    }
    
    uint32_t index = pos / 32; // 计算位于数组中的索引
    uint32_t bit = pos % 32; // 计算在uint32_t中的位偏移量
    
    bitmap->bits[index] |= (1U << bit); // 将指定位置的位设置为1
}

// 清除位图中某一位的值（将其置为0）
void bitmap_clear(Bitmap *bitmap, uint32_t pos) {
    if (bitmap == NULL || pos >= bitmap->size) { // 检查位图结构是否有效，以及位置是否超出范围
        return; // 如果无效，则直接返回
    }
    
    uint32_t index = pos / 32; // 计算位于数组中的索引
    uint32_t bit = pos % 32; // 计算在uint32_t中的位偏移量
    
    bitmap->bits[index] &= ~(1U << bit); // 将指定位置的位清除为0
}

// 获取位图中某一位的值
int bitmap_get(Bitmap *bitmap, uint32_t pos) {
    if (bitmap == NULL || pos >= bitmap->size) { // 检查位图结构是否有效，以及位置是否超出范围
        return 0; // 如果无效，则返回0
    }
    
    uint32_t index = pos / 32; // 计算位于数组中的索引
    uint32_t bit = pos % 32; // 计算在uint32_t中的位偏移量
    
    return (bitmap->bits[index] & (1U << bit)) != 0; // 返回指定位置的位的值（0或1）
}

// 打印输出位图的内容
void bitmap_print(Bitmap *bitmap) {
    if (bitmap == NULL) { // 检查位图结构是否有效
        printf("Bitmap is NULL.\n");
        return;
    }
    
    printf("Bitmap contents:\n");
    for (uint32_t i = 0; i < bitmap->size; ++i) { // 遍历位图的每一位
        printf("%d ", bitmap_get(bitmap, i)); // 获取并输出当前位的值
        
        // 每输出32位换行，以便于查看
        if ((i + 1) % 32 == 0) {
            printf("\n");
        }
    }
    printf("\n");
}

// 释放位图内存
void bitmap_destroy(Bitmap *bitmap) {
    if (bitmap != NULL) { // 检查位图结构是否有效
        free(bitmap->bits); // 释放位图数据存储的内存空间
        free(bitmap); // 释放位图结构的内存空间
    }
}

int main() {
    Bitmap *bitmap = bitmap_init(BITMAP_SIZE); // 初始化一个位图
    
    // 设置一些位
    bitmap_set(bitmap, 5);
    bitmap_set(bitmap, 10);
    bitmap_set(bitmap, 100);
    
    // 打印输出位图内容
    bitmap_print(bitmap);
    
    bitmap_destroy(bitmap); // 释放位图内存
    
    return 0;
}

位图相关面试题 1：查找缺失的数字

题目描述：给定一个包含 n 个整数的数组，其中数字范围在 [1, n] 内，且数组中的数字可能有重复。找出数组中缺失的数字。

示例： 输入：[4, 3, 2, 7, 8, 2, 3, 1] 输出：[5, 6]

解题思路：

可以利用位图来解决该问题，具体步骤如下：

1. 创建一个长度为 n 的位图，初始所有位都为0。
2. 遍历数组，将每个元素对应的位设置为1。
3. 再次遍历位图，找到值为0的位，该位对应的索引即为缺失的数字。

实现代码：

#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>

// 使用位图查找缺失的数字
int* findMissingNumbers(int* nums, int numsSize, int* returnSize) {
    // 计算应有的位图大小
    int bitmapSize = numsSize + 1; // 范围是[1, n]，所以需要n+1个位置
    uint32_t* bitmap = calloc((bitmapSize + 31) / 32, sizeof(uint32_t)); // 初始化位图

    // 第一遍标记出现的数字
    for (int i = 0; i < numsSize; ++i) {
        int num = nums[i];
        int index = num - 1; // 数字num对应的位在位图中的索引
        int bit = index % 32; // 数字num对应的位在uint32_t中的偏移量
        bitmap[index / 32] |= (1u << bit); // 设置位为1
    }

    // 第二遍查找缺失的数字
    int* result = malloc(sizeof(int) * bitmapSize); // 最多有bitmapSize个缺失的数字
    int count = 0;
    for (int i = 0; i < bitmapSize; ++i) {
        int index = i;
        int bit = index % 32;
        if ((bitmap[index / 32] & (1u << bit)) == 0) {
            result[count++] = index + 1; // 找到缺失的数字
        }
    }

    // 释放内存并返回结果
    free(bitmap);
    *returnSize = count;
    return result;
}

// 测试函数
int main() {
    int nums[] = {4, 3, 2, 7, 8, 2, 3, 1};
    int size = sizeof(nums) / sizeof(nums[0]);
    int returnSize;
    int* result = findMissingNumbers(nums, size, &returnSize);

    printf("Missing numbers: ");
    for (int i = 0; i < returnSize; ++i) {
        printf("%d ", result[i]);
    }
    printf("\n");

    free(result);
    return 0;
}

面试题 2：查找第一个缺失的正整数

题目描述：给定一个未排序的整数数组，找出其中没有出现的最小的正整数。

示例： 输入：[3, 4, -1, 1] 输出：2

解题思路：

利用位图可以在O(n)时间复杂度内解决该问题，具体步骤如下：

1. 将数组中所有小于等于0的数和大于数组长度的数设为无效值。
2. 遍历数组，将有效值对应的位置设置为1。
3. 再次遍历位图，找到第一个值为0的位置，其索引即为缺失的最小正整数。

实现代码：

#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>

// 使用位图查找缺失的最小正整数
int firstMissingPositive(int* nums, int numsSize) {
    // 将无效值设为numsSize+1，即数组长度加1
    for (int i = 0; i < numsSize; ++i) {
        if (nums[i] <= 0 || nums[i] > numsSize) {
            nums[i] = numsSize + 1;
        }
    }

    // 初始化位图
    uint32_t* bitmap = calloc((numsSize + 1 + 31) / 32, sizeof(uint32_t));

    // 标记有效值
    for (int i = 0; i < numsSize; ++i) {
        int num = abs(nums[i]);
        if (num <= numsSize) {
            int index = num - 1; // 数字num对应的位在位图中的索引
            int bit = index % 32; // 数字num对应的位在uint32_t中的偏移量
            bitmap[index / 32] |= (1u << bit); // 设置位为1
        }
    }

    // 找到第一个缺失的正整数
    for (int i = 0; i < numsSize + 1; ++i) {
        int index = i;
        int bit = index % 32;
        if ((bitmap[index / 32] & (1u << bit)) == 0) {
            free(bitmap);
            return index + 1; // 返回缺失的正整数
        }
    }

    free(bitmap);
    return numsSize + 1; // 如果都存在，则返回numsSize+1
}

// 测试函数
int main() {
    int nums[] = {3, 4, -1, 1};
    int size = sizeof(nums) / sizeof(nums[0]);
    int missing = firstMissingPositive(nums, size);

    printf("First missing positive: %d\n", missing);

    return 0;
}