通过时间复杂度O1C ++代码对字节中的1位进行计数

问题描述

我搜索了一种算法，该算法通过O（1）的时间复杂度来计算Byte中的个数以及我在Google中找到的内容：

// C++ implementation of the approach  
#include <bits/stdc++.h> 
using namespace std; 
  
int BitsSetTable256[256]; 
  
// Function to initialise the lookup table  
void initialize()  
{  
  
    // To initially generate the  
    // table algorithmically  
    BitsSetTable256[0] = 0;  
    for (int i = 0; i < 256; i++) 
    {  
        BitsSetTable256[i] = (i & 1) +  
        BitsSetTable256[i / 2];  
    }  
}  
  
// Function to return the count  
// of set bits in n  
int countSetBits(int n)  
{  
    return (BitsSetTable256[n & 0xff] +  
            BitsSetTable256[(n >> 8) & 0xff] +  
            BitsSetTable256[(n >> 16) & 0xff] +  
            BitsSetTable256[n >> 24]);  
}  
  
// Driver code  
int main()  
{  
    // Initialise the lookup table  
    initialize();  
    int n = 9;  
    cout << countSetBits(n); 
}

我了解我需要从256到255的数组大小（换句话说，查找表的大小）来索引从0到255，它们都是Byte代表的十进制值！

但是在函数初始化中，我不了解for循环内的术语： BitsSetTable256 [i] =（i＆1）+ BitsSetTable256 [i / 2];
我为什么要这么做？我不明白for循环中此行代码的目的是什么。

此外，在函数countSetBits中，该函数返回：

 return (BitsSetTable256[n & 0xff] +  
            BitsSetTable256[(n >> 8) & 0xff] +  
            BitsSetTable256[(n >> 16) & 0xff] +  
            BitsSetTable256[n >> 24]);

我根本不了解Im在做什么，用0xff按位执行，以及为什么Im在右移。可以请任何人给我解释一下这个概念吗？我根本不明白为什么在BitsSetTable256 [n >> 24]的countCountBits函数中我们不这样做，明智的选择是0xff吗？

我理解为什么我需要2 ^ 8大小的查找表，但是我上面提到的其他代码行却听不懂，有人可以用简单的话向我解释一下吗？计数字节数的目的是什么？

感谢很多人！

解决方法

关于问题的第一部分：

// Function to initialise the lookup table  
void initialize()  
{  
  
    // To initially generate the  
    // table algorithmically  
    BitsSetTable256[0] = 0;  
    for (int i = 0; i < 256; i++) 
    {  
        BitsSetTable256[i] = (i & 1) +  
        BitsSetTable256[i / 2];  
    }  
}

这是一种巧妙的递归。（请注意，我并不是指“递归函数”，而是更数学意义上的递归。）

种子是BitsSetTable256[0] = 0;

然后，使用i / 2的（已经存在）结果初始化每个元素，并为此添加1或0。因此，

i

0。

要获取i的最后一位的值，i & 1是通常的C / C ++位掩码技巧。

为什么BitsSetTable256[i / 2]的结果是要建立的值？ BitsSetTable256[i / 2]的结果是i的所有位数，最后一位被排除。

请注意，i / 2和i >> 1（值（或位）向右移1，从而删除了最低位/最后一位）是等效表达式（相应地为正数）。范围-排除极端情况）。

关于问题的另一部分：

    return (BitsSetTable256[n & 0xff] +  
            BitsSetTable256[(n >> 8) & 0xff] +  
            BitsSetTable256[(n >> 16) & 0xff] +  
            BitsSetTable256[n >> 24]);

n & 0xff屏蔽了高位，将低8位隔离开。
(n >> 8) & 0xff将n的值向右移8位（从而删除了8个最低位），然后再次屏蔽掉高位，从而将低8位隔离开。
(n >> 16) & 0xff将n的值向右移16位（从而删除16个最低位），然后再次屏蔽掉高位，从而将低8位隔离开。
(n >> 24) & 0xff将n的值向右移动24位（从而删除了最低的24位），这应实际上使高8位变为低8位。

假设int和unsigned在当今的通用平台上通常具有32位，则它涵盖了n的所有位。

请注意，负值的右移是实现定义的。

（我确实记得Bitwise shift operators。）

因此，负值的右移可能会用1s填充所有高位。
这可能会破坏BitsSetTable256[n >> 24]，从而导致(n >> 24) > 256
并因此BitsSetTable256[n >> 24]超出限制的访问。

更好的解决方案是：

    return (BitsSetTable256[n & 0xff] +  
            BitsSetTable256[(n >> 8) & 0xff] +  
            BitsSetTable256[(n >> 16) & 0xff] +  
            BitsSetTable256[(n >> 24) & 0xff]);

BitsSetTable256[0] = 0;
...
BitsSetTable256[i] = (i & 1) +  
     BitsSetTable256[i / 2];

上面的代码播种了查找表，其中每个索引包含用作索引的数字的1的数目，并且工作方式如下：

(i & 1)给出1为奇数，否则为0。
偶数的二进制数1等于该数字除以2的数量。
奇数将比该数字除以2多一个二进制1。

示例：

如果i==8（1000b），则(i & 1) + BitsSetTable256[i / 2]->
0 + BitsSetTable256[8 / 2] = 0 +索引4（0100b）= 0 + 1。
如果i==7（0111b），则1 + BitsSetTable256[7 / 2] = 1 + BitsSetTable256[3] = 1 +索引3（0011b）= 1 + 2。

如果您想要一些正式的数学证明，为什么要这么做，那么我不是一个合适的人，我会为此戳一个数学网站。

对于移位部分，这只是将32位值分割为4x8的常规方法，可移植而无需考虑字节序（任何其他这样做的方法都值得商question）。如果我们取消代码散布，则会得到以下信息：

BitsSetTable256[(n >>  0) & 0xFFu] +  
BitsSetTable256[(n >>  8) & 0xFFu] +  
BitsSetTable256[(n >> 16) & 0xFFu] +  
BitsSetTable256[(n >> 24) & 0xFFu] ;

每个字节移到LS字节位置，然后用& 0xFFu字节掩码屏蔽掉。

但是，在int上使用位移会产生代码异味，并可能会引起错误。为了避免定义不明确的行为，您需要将函数更改为此：

#include <stdint.h>

uint32_t countSetBits (uint32_t n);

countSetBits中的代码以int作为参数；显然假定为32位。那里的实现是通过移位和屏蔽从n中提取四个单字节。对于这四个分离的字节，将使用查找并添加每个字节的位数以产生结果。

查找表的初始化比较棘手，可以看作是动态编程的一种形式。条目将填充自变量的递增索引。第一个表达式掩盖了最低有效位并对其进行计数；第二个表达式将参数减半（也可以通过移位完成）。结果参数较小；然后正确地假定较小的参数的必要值已经在查找表中可用。

要访问查找表，请考虑以下示例：

input value (contains 5 ones):
01010000 00000010 00000100 00010000

input value,shifting is not necessary
masked with 0xff (11111111)
00000000 00000000 00000000 00010000     (contains 1 one)

input value shifted by 8
00000000 01010000 00000010 00000100
and masked with 0xff (11111111)
00000000 00000000 00000000 00000100     (contains 1 one)

input value shifted by 16
00000000 00000000 01010000 00000010
and masked with 0xff (11111111)
00000000 00000000 00000000 00000010     (contains 1 one)

input value shifted by 24,masking is not necessary
00000000 00000000 00000000 01010000     (contains 2 ones)

提取的值仅设置了最低的8位，这意味着相应的条目在查找表中可用。查找表中的条目已添加。基本思想是，可以按字节计算参数中的个数（实际上，位串中的任何分区都适用）。

bit-manipulation bit-shift c++

通过时间复杂度O1C ++代码对字节中的1位进行计数

问题描述

解决方法

相关问答