最牛逼的Bit算法合集

基于Bit置换算法的延伸算法

1. Bit置换算法

​ Bit置换算法是这一系列算法中最为简单的一种，理解该算法可以帮助我们更好的理解接下来的其它算法。
​ 算法的伪码如下表示：

    T = ((A >> N) ⊕ B) & MASK;
    B = B ⊕ T;
    A = A ⊕ (T << N);

​ MASK为B的掩码（将B需要交换的位置1，其他位置0），交换B^MASK位与A的（MASK << N)位。

​ 设要交换B的m位与A的n+m位（从右边数起），则将MASK第m位置1，其他位置0，N = n。

• (A >> N): 将A的n+m位与B的m位对齐;
• ((A >> N) ⊕ B): 判断A的n+m位与B的m位是否相等，相等为0，不相等为1;
• T = ((A >> N) ⊕ B) & MASK: 若A的n+m位与B的m位相等，T = 0，下面的两步保持A和B不动，若不相等，T = MASK;
• A的n+m位与B的m位相等的话下面两步相当于跳过，否则：
• B = B ⊕ T：B的m位置反；
• A = A ⊕ (T << N)： A的n+m位置反。

C++代码：

void swap(uint8_t &a, uint8_t &b, int n, uint8_t mask) {
    uint8_t t = ((a >> n) ^ b) & mask;
    b = b ^ t;
    a = a ^ (t << n);
}

注意该算法有以下特点：

• 通过对MASK的设置，该算法可以一次对A和B的多位同时进行交换，当然间隔相差为N固定。

• 可以调整移位的方向来简单地适应需要交换的位的位置关系。

• 可以稍加修改成为交换同一bit序列中不同位置的bit：

 	T = ((A >> N) ⊕ A) & MASK;
    A = A ⊕ (T << N) ⊕ T;

2. 一些重要的掩码

在介绍其他的算法之前，我们先介绍一些重要的掩码表示：

mask1 = 0x55555555
mask2 = 0x33333333
mask3 = 0x0f0f0f0f
mask4 = 0x00ff00ff
mask5 = 0x0000ffff

这些是32位的掩码表示，将其从16进制表示的形式转为二进制表示的形式可以很容易的发现其规律:

mask1 = 01010101010101010101010101010101
mask2 = 00110011001100110011001100110011
mask3 = 00001111000011110000111100001111
mask4 = 00000000111111110000000011111111
mask5 = 00000000000000001111111111111111

也可以按照需要设置8位，16位，64位甚至128位的掩码。

总之：

m j = ( { 0 } 2 j { 1 } 2 j ) m_{j} = (\{0\}^{2^j} \{1\}^{2^j}) mj​=({0}2j{1}2j)

在后面的算法中，我们将常需要这些掩码，以递归的思想对bit进行操作。

3. Bit逆序算法

uint32_t reverse_bit(uint32_t c) {
    c = (c & ~mask1) >> 1 | (c & mask1) << 1;
    c = (c & ~mask2) >> 2 | (c & mask2) << 2;
    c = (c & ~mask3) >> 4 | (c & mask3) << 4;
    c = (c & ~mask4) >> 8 | (c & mask4) << 8;
    c = (c & ~mask5) >> 16 | (c & mask5) << 16;
    return c;
}

该算法先每2bit分组进行对换，然后4bit分组从中间进行对换，8bit分组进行对换。。。从而达到整个bit序列的逆序。

4. 汉明重量

uint32_t hamming_weight(uint32_t x) {
    x = (x & mask1) + ((x & ~mask1) >> 1);
    x = (x & mask2) + ((x & ~mask2) >> 2);
    x = (x & mask3) + ((x & ~mask3) >> 4);
    x = (x & mask4) + ((x & ~mask4) >> 8);
    x = (x & mask5) + ((x & ~mask5) >> 16);
    return x;
}

x的二进制可以按每2个bit为一组进行分组，各组的十进制表示的就是该组的汉明重量。然后按照每位分组相加，其十进制表示即为该组的汉明重量。直至加至32位分组，得到x的汉明重量。

有对以上算法的改进算法可达到更少的操作符和更快的运算速度，算法如下：

const uint32_t mask01 = 0x01010101;
uint32_t hamming_weight_fast(uint32_t x) {
    x -= (x >> 1) & mask1;
    x = (x & mask2) + ((x >> 2) & mask2);
    x = (x + (x >> 4)) & mask3;
    return (x * mask01) >> 24;
}

对于2bit的分组，x -= (x >> 1) & mask1可以达到和x = (x & mask1) + ((x & ~mask1) >> 1)相同的功能。对于2bit的分组减去第一位的值，可得如下：

	11	10	01	00
x -= (x >> 1) & mask1	10	01	01	00

x = (x + (x >> 4)) & mask3可以达到x = (x & mask3) + ((x & ~mask3) >> 4)的功能，

x * mask01起到了 x + (x<<8) + (x<<16) + (x<<24) + ...的作用。

将(x * mask01) >> 24可得到所有8bit分组的十进制之和。

为了防止进位带来的影响，该算法使用了4种不同的方式达到了和上述算法相同的功能，对于64位或更长的bit序列，需要修改返回值的移位大小。

5. 矩阵转置

//32 * 32的矩阵按bit原地转置
uint32_t mask[5] = {0x55555555,0x33333333,0x0f0f0f0f,0x00ff00ff,0x0000ffff};
int k;
int l;
uint32_t temp;
void transpose(uint32_t *A) {
    for (int j = 0; j < 5; ++j) {
        k = 1 << j;
        for (int i = 0; i < 16; ++i) {
            l = 2 * i - (i % k);
            temp = (A[l] & ~mask[j]) | ((A[l + k] & ~mask[j]) >> k);
            A[l + k] = (A[l + k] & mask[j]) | ((A[l] & mask[j]) << k);
            A[l] = temp;
        }
        printf("\n");
    }
}

示例中我们使用32* 32的矩阵按bit转置，矩阵uint32_t A[32]，我们沿矩阵对角线转置。

算法的核心部分（即对角线对换），使用了一次进行多位的bit交换算法。

//对角线对换
temp = (A[l] & ~mask[j]) | ((A[l + k] & ~mask[j]) >> k);
A[l + k] = (A[l + k] & mask[j]) | ((A[l] & mask[j]) << k);
A[l] = temp;

代码对l行和l + k行中的元素进行对换，保持l行和l + k行的按mask掩码的位后进行交错补成完整的行，达到如下图的效果：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-qi0ArZ3E-1623845320070)(矩阵转置.png)]

橘色部分保持不动，蓝色部分进行对换。其中蓝色和橘色的长度取决于掩码。

通过这种方法，实际上也是采用了递归的方式将矩阵一一进行转置。

位后进行交错补成完整的行，达到如下图的效果：

[外链图片转存中…(img-qi0ArZ3E-1623845320070)]

橘色部分保持不动，蓝色部分进行对换。其中蓝色和橘色的长度取决于掩码。

通过这种方法，实际上也是采用了递归的方式将矩阵一一进行转置。

其中计算L行和L+K行时L和K的数量关系的确定l = 2 * i - (i % k)值得注意。