前导0计数Integer.numberOfLeadingZeros，后缀0计数Integer.numberOfTailingzeros

前导0计数

问题

1的前导0个数为31，对应16进制数为0x0000 0001。
2的前导0个数位30，对应16进制数为0x0000 0002。

如何计算一个int型数对应二进制数前导0的位数呢？

解决思路

轮询bit位算法

开始想到的最简单的办法是从左边最高位开始，向低位轮训，一直到遇见位1。

// 轮询bit位
int numberOfLeadingZerors(int x) {
      int n = 0;

      for (int i = 31; i >= 0; i--) {
            if ( x & (1 << i) != 0) {
                  break;
            }
            else n++;
      }

      return n;
}

这样，最多需要循环32次，每个循环执行4个指令：判断、按位与、移位、递增。这样可能需要执行32 x 4条指令。

二分搜索算法

有没有更快的算法？
可以使用二分搜索技术计算前导0。这里二分搜索，没有用索引指示器，而是用到了进制数的特性，直接利用二进制数 + 移位操作，来作为0个数的判断点。比如0x0000FFFF，x <= 0x0000FFFF，意味着x至少有16个前导0。

从下面的代码可以看出，二分搜索法所需要的指令最多为20个（6个if，10个赋值4个移位）指令操作。

// 二分搜索计算前导0
int numberOfLeadingZeros(int x) {
      if (x == 0) return 32;
      int n = 0;
      if (x <= 0x0000FFFF) { n = n + 16; x = x << 16; } // 判断高16位是否为0：先通过高16位，判断该数是否位于较小的一半，如果是，说明至少会有16个0，再把该数左移16位，相当于增大模的一半
      if (x <= 0x00FFFFFF) { n = n + 8; x = x << 8; }   // 判断高8位
      if (x <= 0x0FFFFFFF) { n = n + 4; x = x << 4; } // 判断高4位
      if (x <= 0x3FFFFFFF) { n = n + 2; x = x << 2; } // 判断高2位
      if (x <= 0x7FFFFFFF) { n = n + 1; }  // 判断高1位
      return n;
}

按位与版本，二分搜索计算前导0

// 二分搜索计算前导0
int numberOfLeadingZeros(int x) {
      if (x == 0) return 32;
      int n = 0;
      if ((x & 0xFFFF0000) == 0) { n = n + 16; x = x << 16; } // 判断高16位是否为0：先通过高16位，判断该数是否位于较小的一半，如果是，说明至少会有16个0，再把该数左移16位，相当于增大模的一半
      if ((x & 0xFF000000) == 0) { n = n + 8; x = x << 8; }   // 判断高8位
      if ((x & 0xF0000000) == 0) { n = n + 4; x = x << 4; } // 判断高4位
      if ((x & 0xC0000000) == 0) { n = n + 2; x = x << 2; } // 判断高2位
      if ((x & 0x80000000) == 0) { n = n + 1; }  // 判断高1位
      return n;
}

最后一个if语句，可以改写成 : n = n + 1 - (x >> 31)
如果将n初值由0设为1，那么最后一个if语句可以改成成：n = n - (x >> 31)，其他语句保持不变。

右移位按位与版本，二分搜索计算前导0

// 二分搜索计算前导0
int numberOfLeadingZeros(int x) {
      if (x == 0) return 32;
      int n = 1;
      if ((x >> 16) == 0) { n = n + 16; x = x << 16; }
      if ((x >> 24) == 0) { n = n + 8; x = x << 8; } 
      if ((x >> 28) == 0) { n = n + 4; x = x << 4; }
      if ((x >> 30) == 0) { n = n + 2; x = x << 2; }
      n = n - (x >> 31);
      return n;
}

如果将n初值设为32，通过减法，上面的算法可以改写成：

// 二分搜索计算前导0，做减法
int numberOfLeadingZeros(int x) {
      if (x == 0) return 32;
      int n = 32;
      
      int y;
      y = x >>> 16; if (y != 0) { n -= 16; x = y; } // 验证高16位（bit31 ~ 16）是否为0，如果是，就不用从总计数n - 16；如果不是，就需要 n - 16，因为该区域之前已经算作是0 了
      y = x >>>  8; if (y != 0) { n -= 8; x = y; } // 验证bit31 ~ 8 是否为0，此时bit31 ~ 16 必为0
      y = x >>>  4; if (y != 0) { n -= 4; x = y; } // 验证bit31 ~ 4 是否为0，此时bit31 ~ 8 必为0
      y = x >>>  2; if (y != 0) { n -= 2; x = y; }  // 验证bit31 ~ 2 是否为0，此时bit31 ~ 2必为0
      y = x >>>  1; if (y != 0) return n - 2; // 验证bit31 ~ 1是否为0，当y = x >>> 1且y ≠ 0 时，说明bit1非0，也就是说n多计了bit1和bit0，需要减去
      return n - x;
}

改写成循环形式

int nunberOfLeadingZeros(int x) {
      int y;
      int n = 32;
      int c = 16;
      do {
            y = x >>> c; if ( y != 0) { n -= c; x = y; }
            c = c >> 1;
      }while( c != 0);

      return n - x;
}

应用 & JDK源码

在解析Java源码Integer.toHexString过程中， 碰到了这个函数Integer.numberOfLeadingZeros(int)，用于计算前导0的个数。
见Java源码解析：Integer.toHexString

查看其源码，

    public static int numberOfLeadingZeros(int i) {
        // HD, Figure 5-6
        if (i == 0)
            return 32;
        int n = 1;
        if (i >>> 16 == 0) { n += 16; i <<= 16; }
        if (i >>> 24 == 0) { n +=  8; i <<=  8; }
        if (i >>> 28 == 0) { n +=  4; i <<=  4; }
        if (i >>> 30 == 0) { n +=  2; i <<=  2; }
        n -= i >>> 31;
        return n;
    }

后缀0计数

二分搜索算法

同前导0计数，可以通过构造后缀0数目的掩码，写出后缀0计数的二分搜索算法。

核心思想： 如果右半部分为0，则在左半部继续查找，累计后缀0个数 + 右半部位数；否则，继续在右半部的右半部继续查找，累计后缀0个数不变。

int numberOfTailingZeros(int x) {
      if (x == 0) return 32;
      int n = 1;
      if ((x & 0x0000FFFF) == 0) { n += 16; x = x >>> 16; }
      if ((x & 0x000000FF) == 0) { n += 8； x = x >>> 8; }
      if ((x & 0x0000000F) == 0) { n += 4; x = x >>> 4; }
      if ((x & 0x00000003) == 0) { n += 2; x = x >>> 2; }
       
      /* 到这里x最多无符号右移了30位，也就是说，只有原始的2个bit位，还没有判断，不过此时作为最新x的bit1、0。
      x = x1 x0 (二进制表示形式，x0, x1 = 0, 1)
      例如，如果此时x = 0b01，那么最终后缀0的个数是 n - 1, 因为n初值是1，所以需要减去1。
      如果此时x = 0b10，那么最终后缀0的个数是 n。
      综上，后缀0个数最终值为 n - (x & 1)
      */
      return n - (x & 1); // 也可以 if (x & 0x00000001) != 0) { n = n-1; } return n;
}

应用 & JDK源码

位于Integer.java中的Integer.numberOfTrailingZeros(int)，用于计算后缀0个数，其源码：

    public static int numberOfTrailingZeros(int i) {
        // HD, Figure 5-14
        int y;
        if (i == 0) return 32;
        int n = 31;
        y = i <<16; if (y != 0) { n = n -16; i = y; }
        y = i << 8; if (y != 0) { n = n - 8; i = y; }
        y = i << 4; if (y != 0) { n = n - 4; i = y; }
        y = i << 2; if (y != 0) { n = n - 2; i = y; }
        return n - ((i << 1) >>> 31);
    }

参考

1. 《算法心得 高效算法的奥秘(第二版》