二分法查找第一个不为0 bit

已于 2024-05-15 16:04:41 修改
阅读量604 收藏
点赞数
分类专栏： C/C++ 文章标签： C/C++ 算法 二分法 typelist 模板
于 2019-09-15 15:24:26 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/dipengbin/article/details/100805996
版权

    很多年前，老刘在群里问个问题：如何找到数字第一个非0的bit位置。

    第一想法肯定是遍历，稍微想想肯定就会想到空间换时间的写法。

template<class T>
int traverseBitFind(T number, char maskArray[])
{
    if (number == 0)
        return -1;
        
    unsigned char* array = (unsigned char*)&number;
    int pos = 0;
    for (int i = 0; i < sizeof(T); i++)
    {
        if (array[i] == 0)
        {
            pos += 8;
            continue;
        }
        return pos + maskArray[array[i]];
    }
    return -1;
}

    当时想起《编程珠玑》里面说的查找问题使用二分法，这个也是查找问题，那么如果使用二分法的话要怎么构造，当时和老刘讲述了下逻辑，但自己却从来没有手动写代码去实现过，这次采用低位非0 bit，逻辑简单点。

template<class T, int M> class MaskInit;
template<class T, int M> class MaskInit
{
public:
    //enum { mask = (0x1 << M-1) | MaskInit<T, M-1>::mask };                                                                                                                                                                                                   
    static const T mask = ((T)0x1 << M-1) | MaskInit<T, M-1>::mask;
};
template<class T> class MaskInit<T, 1>
{
public:
    static const T mask = 0x1;
    //enum { mask = 0x1 };
};


template<class T>
class BinaryBitSearch
{
public:
    static const T MASK = MaskInit< T, sizeof(T)<<2 >::mask;
    static int cycleBitFind(T number)
    {   
        if (number == 0)
            return -1;
        
        int pos = 0;
        T mask = MASK;
        int shift = sizeof(T)<<2;
        while (shift > 0)
        {   
            T tmp = number & mask;
            if (tmp == 0)
            {   
                pos += shift;
                number >>= shift;
            }
            shift >>= 1;
            mask >>= shift;
        }
        
        return pos;
    }
};

    单纯从理论上分析，二分法时间复杂度是O(log n)， 而第一种算法是O(n)，但因为位数很小，其实只有在64位时才有优势，因为实现根据类型自动选择算法。

template<bool V> class Bool2Type
{
};

template<int V>
class Power
{
public:
    static const int value = 1 + Power<V>>1>::value;
};

template<> class Power<1>
{
public:
    static const int value = 0;
};

template<class T>
class TimeComplexity
{
public:
    static const bool value = Power<sizeof(T)*8>::value >= sizeof(T);
};

template<class T>
class BitFindWrap
{
public:
    static int bitFind(T number)
    {
        return bitFind(number, Bool2Type<TimeComplexity<T>::value>());
    }
    
private:
    static int bitFind(T number, Bool2Type<true>)
    {
        return traverseBitFind<T>(number, maskArray);
    }
    
    static int bitFind(T number, Bool2Type<false>)
    {
        return BinaryBitSearch<T>::cycleBitFind(number);
    }
};

    因为是有与或运算，所以还是希望类型为整型，当传入整数类型时能在编译时期检查出错误

typedef TYPELIST_8(unsigned long, long, unsigned int, int, unsigned short, short, unsigned char, char) INNERTYPELIST;

template<class TList,class T> struct IndexOf;
template<class T> struct IndexOf<NullType, T>
{

    enum { value = -1};
};
template<class Tail, class T>
struct IndexOf<Typelist<T, Tail>, T>
{
    enum { value = 0 };
};

template<class H, class T, class N>
struct IndexOf<Typelist<H, T>, N>
{
private:
    enum { temp = IndexOf<T,N>::value };
public:
    enum { value = temp == -1 ? -1 : 1 + IndexOf<T, N>::value };
};

template<bool> struct CompileTimeError;
template<> struct CompileTimeError<true> {};
#define STATIC_CHECK(expr) \
    { CompileTimeError<(expr) != 0 >(); }

#define INNERTYPE_CHECK(type) \
    STATIC_CHECK((IndexOf<INNERTYPELIST, type>::value != -1))

    在书中有一个检查可以携带信息版本，但试了下发现不行，所以还是采用这个版本。

    上面的选择方式会增加执行时的时间，并不理想，改用偏特化与宏来减少函数层数。

template<class T, bool Choice, bool InnerType> class BitFindClass;
template<class T>
class BitFindClass<T, false, true>
{
    ......
};
class BitFindClass<T, true, true>
{
    ......
};

#define BITFIND(Type, number) \
    BitFindClass<Type, (TimeComplexity<Type>::value), (IndexOf<INNERTYPELIST, Type>::value != -1)>::bitFind(number)

    第一版本是根据理论想象中的版本，事实上采用二分法的性能非常烂，与运算占用大量时间，后续文章是基于此版本进行优化处理，其性能在64位情况下是会优于第一个算法，但提升并不大。

参考：《C++设计新思维》

    发现在这个博客不能携带附件，就把最终代码贴在后面好了：

    utils.h

#include <sys/timeb.h>
#include <stdlib.h>
#include <stdio.h>

class NullType {};
template <class H,class T>
struct Typelist {
    typedef H Head;
    typedef T Tail;
};
//通过定义一些宏使得typelist线性化
#define TYPELIST_0() NullType  
#define TYPELIST_1(T1) Typelist<T1,TYPELIST_0()>  
#define TYPELIST_2(T1,T2) Typelist<T1,TYPELIST_1(T2)>  
#define TYPELIST_3(T1,T2,T3) Typelist<T1,TYPELIST_2(T2,T3)>  
#define TYPELIST_4(T1,T2,T3,T4) Typelist<T1,TYPELIST_3(T2,T3,T4)>  
#define TYPELIST_5(T1,T2,T3,T4,T5) Typelist<T1,TYPELIST_4(T2,T3,T4,T5)>  
#define TYPELIST_6(T1,T2,T3,T4,T5,T6) Typelist<T1,TYPELIST_5(T2,T3,T4,T5,T6)>  
#define TYPELIST_7(T1,T2,T3,T4,T5,T6,T7) Typelist<T1,TYPELIST_6(T2,T3,T4,T5,T6,T7)>  
#define TYPELIST_8(T1,T2,T3,T4,T5,T6,T7,T8) Typelist<T1,TYPELIST_7(T2,T3,T4,T5,T6,T7,T8)>  
#define TYPELIST_9(T1,T2,T3,T4,T5,T6,T7,T8,T9) Typelist<T1,TYPELIST_8(T2,T3,T4,T5,T6,T7,T8,T9)>  
#define TYPELIST_10(T1,T2,T3,T4,T5,T6,T7,T8,T9,T10) Typelist<T1,TYPELIST_9(T2,T3,T4,T5,T6,T7,T8,T9,T10)>  

typedef TYPELIST_8(unsigned long, long, unsigned int, int, unsigned short, short, unsigned char, char) INNERTYPELIST;

template<class TList,class T> struct IndexOf;
template<class T> struct IndexOf<NullType, T>
{

    enum { value = -1};
};
template<class Tail, class T>
struct IndexOf<Typelist<T, Tail>, T>
{
    enum { value = 0 };
};

template<class H, class T, class N>
struct IndexOf<Typelist<H, T>, N>
{
private:
    enum { temp = IndexOf<T,N>::value };
public:
    enum { value = temp == -1 ? -1 : 1 + IndexOf<T, N>::value };
};

//template<bool> struct CompileTimeChecker
//{
//    CompileTimeChecker(...) {}
//};
//template<> struct CompileTimeChecker<false> {};
//#define STATIC_CHECK(expr, msg) \
//    { \
//        class ERROR_##msg {}; \
//        sizeof(CompileTimeChecker<(expr)>(ERROR_##msg())); \
//    }

template<bool> struct CompileTimeError;
template<> struct CompileTimeError<true> {};
#define STATIC_CHECK(expr) \
    { CompileTimeError<(expr) != 0 >(); }

#define INNERTYPE_CHECK(type) \
    STATIC_CHECK((IndexOf<INNERTYPELIST, type>::value != -1))

template<bool V> class Bool2Type
{
};

template<int V>
class Power
{
public:
    static const int value = 1 + Power<V>>1>::value;
};

template<> class Power<1>
{
public:
    static const int value = 0;
};

static char maskArray[256];

void initTestArray(long array[])
{
    long mask = 1;
    for (int i = 0; i < 64; i++)
    {
        array[i] = mask;
        mask <<= 1;
    }
}

void initMaskArray(char maskArray[])
{
    maskArray[0] = 8;
    for (unsigned char i = 0xFF; i > 0; i--)
    {
        unsigned char mask = 0x1;
        for (int j = 0; j < 8; j++)
        {
            if ((i & mask) != 0)
            {
                maskArray[i] = j;
                break;
            }
            mask <<= 1;
        }
    }
}

long long systemtime()
{
    timeb t;
    ftime(&t);
    return t.time*1000+t.millitm;
}

version1.cpp

#include "utils.h"

template<class T>
int traverseBitFind(T number, char maskArray[])
{
    if (number == 0)
        return -1;
        
    unsigned char* array = (unsigned char*)&number;
    int pos = 0;
    for (int i = 0; i < sizeof(T); i++)
    {
        if (array[i] == 0)
        {
            pos += 8;
            continue;
        }
        return pos + maskArray[array[i]];
    }
    return -1;
}

template<class T, int M> class MaskInit;
template<class T, int M> class MaskInit
{
public:
    //enum { mask = (0x1 << M-1) | MaskInit<T, M-1>::mask };
    static const T mask = ((T)0x1 << M-1) | MaskInit<T, M-1>::mask;
};
template<class T> class MaskInit<T, 1>
{
public:
    static const T mask = 0x1;
    //enum { mask = 0x1 };
};


template<class T>
class BinaryBitSearch
{
public:
    static const T MASK = MaskInit< T, sizeof(T)<<2 >::mask;
    static int cycleBitFind(T number)
    {
        if (number == 0)
            return -1;

        int pos = 0;
        T mask = MASK;
        int shift = sizeof(T)<<2;
        while (shift > 0)
        {
            T tmp = number & mask;
            if (tmp == 0)
            {
                pos += shift;
                number >>= shift;
            }
            shift >>= 1;
            mask >>= shift;
        }
        
        return pos;
    }
};

template<class T>
class TimeComplexity
{
public:
    static const bool value = (Power<sizeof(T)*8>::value >= sizeof(T));
};

template<class T>
class BitFindWrap
{
public:
    static int bitFind(T number)
    {
        INNERTYPE_CHECK(T);
        return bitFind(number, Bool2Type<TimeComplexity<T>::value>());
    }
    
private:
    static int bitFind(T number, Bool2Type<true>)
    {
        return traverseBitFind<T>(number, maskArray);
    }
    
    static int bitFind(T number, Bool2Type<false>)
    {
        return BinaryBitSearch<T>::cycleBitFind(number);
    }
};

template<class T, bool Choice, bool InnerType> class BitFindClass;
template<class T>
class BitFindClass<T, false, true>
{
public:
    static const T MASK = MaskInit< T, sizeof(T)<<2 >::mask;
    static int bitFind(T number)
    {
        if (number == 0)
            return -1;

        int pos = 0;
        T mask = MASK;
        int shift = sizeof(T)<<2;
        while (shift > 0)
        {
            T tmp = number & mask;
            if (tmp == 0)
            {
                pos += shift;
                number >>= shift;
            }
            shift >>= 1;
            mask >>= shift;
        }
        
        return pos;
    }
};

template<class T>
class BitFindClass<T, true, true>
{
public:
    static int bitFind(T number)
    {
        if (number == 0)
            return -1;
            
        unsigned char* array = (unsigned char*)&number;
        int pos = 0;
        for (int i = 0; i < sizeof(T); i++)
        {
            if (array[i] == 0)
            {
                pos += 8;
                continue;
            }
            return pos + maskArray[array[i]];
        }
        return -1;
    }
};

#define BITFIND(Type, number) \
    BitFindClass<Type, (TimeComplexity<Type>::value), (IndexOf<INNERTYPELIST, Type>::value != -1)>::bitFind(number)

int main(int argc, char* argv[])
{
    initMaskArray(maskArray);

    long array[64];
    initTestArray(array);

    long begTime = systemtime();
    for (int i = 0; i < 1000000; i++)
        for (int j = 0; j < 64; j++)
            BitFindWrap<long>::bitFind(array[j]);
    long test1 = systemtime()-begTime;

    begTime = systemtime();
    for (int i = 0; i < 1000000; i++)
        for (int j = 0; j < 64; j++)
            traverseBitFind<long>(array[j], maskArray);
    long test2 = systemtime()-begTime;

    begTime = systemtime();
    for (int i = 0; i < 1000000; i++)
        for (int j = 0; j < 64; j++)
            BinaryBitSearch<long>::cycleBitFind(array[j]);
    long test3 = systemtime()-begTime;

    begTime = systemtime();
    for (int i = 0; i < 1000000; i++)
        for (int j = 0; j < 64; j++)
            BITFIND(long, array[j]);
    long test4 = systemtime()-begTime;

    printf("BitFindWrap:%d, traverseBitFind:%d, BinaryBitSearch:%d, BITFIND:%d\n", test1, test2, test3, test4);

    return 0;
}

dipengbin
关注
专栏目录
C++：找出一个整数的第一个非0bit
风静如云的博客
08-16 301
【代码】C++：找出一个整数的第一个非0bit。
二分法查找第一个不为0 bit 续。
dipengbin的专栏
09-15 303
这篇文章并不是讨论上一篇中的优化问题，而解决一另相关问题，在空间换时间的算法里面，有一个256长的maskArray数组，这篇文章是写如何来初使化这个数组的算法。 最初的想法极其简单： void initMaskArray(char maskArray[]) { maskArray[0] = 8; for (unsigned char i = 0xFF; i ...
find_next_zero_bit() -- 查找第一个不为0的位_儒雅
xu的blog
05-13 8793
导读： choose_address() --> find_next_zero_bit() /usr/src/linux-2.6.21.5/arch/i386/lib/bitops.cint find_next_zero_bit(const unsigned long *addr, int size, int offset)查询*addr中，从第offset位开始，第一个不为0的位的位数
如何取出一个数的第一个非零比特位？
mzx1317557721的博客
04-23 6689
取出一个数的第一个非零比特位，最简单的想法就是通过右移与1，记录右移次数，然后将1左移回去。 int first_bit(int n) { int count = 0;//计数器 while(n^1)//第一位为零 { n &gt;&gt;=1; count++; } rerutn (1&lt;&lt;count); }...
022.线性搜索并且输出数组中的第一个不为零的数字
dosdiosas_的博客
05-20 794
;扫描数组 (ArrayScan.asm) ;扫描数组寻找第一个非零数值 include irvine32.inc .data ;intArray SWORD 0,0,0,0,1,20,35,-12,66,4,0 ;intArray SWORD 1,0,0,0 ;候补测试数据 intArray SWORD 0,0,0,0 ;候补测试数据 ;intArray SWORD 0,0,0,1 ;候补测试数据 noneMsg BYTE "A non-zero val
二分法查找第一个不为0 bit version1.cpp
09-14
二分法查找第一个不为0 bit 使用代码提交
二分法查找第一个不为0 bit utils.h
09-14
二分法查找第一个不为0 bit 文章中使用代码提交
二分法查找元素位置
Irisohohoh的博客
11-08 728
题目描述（leetcode35）： 给定一个排序数组和一个目标值，在数组中找到目标值，并返回其索引。如果目标值不存在于数组中，返回它将会被按顺序插入的位置。 你可以假设数组中无重复元素。 我的代码： public int searchInsert(int[] nums, int target) { if(nums==null) return -1; if...
[算法详解] 二分查找算法及其变种(查找第一个数字/查找最后一个数字)
Be yourself.
12-09 752
前言 Although the basic idea of binary search is comparatively straightforward, the details can be surprisingly tricky… 思路很简单，细节是魔鬼 - - -Knuth 昨天做Offer37-数字在排序数组内出现的次数时候, 遇到了二分查找问题. 正好，借此机会总结一下。 前提条件: 数组是有序数组 算法思路很简单： 声明front和end两个index. 计算mid的index. 根据a
算法：二分法之查找第一个出现的目标元素下标
CKApril_java的博客
02-17 431
public class BSearch { /** * 查找第一个出现的目标元素下标 */ private static int bSearch(int[] array, int n, int value) { //array：数组、n：数组大小、value：需要查找的值 int low = 0; int high = n - 1; while (low <= high) { //防止超过栈
Delphi 如何判断数值的bit位是1还是0
09-03
判断数值的任意bit位是1还是0, 主要目的是用于学习使用delphi 的asm 未做安全测试，不放心的可以push ecx, pop ecx, 用于参数传递的寄存器貌似不需保护，delphi自己会处理好
汇编--查找第一个非0字符的五种方法
weixin_30670151的博客
12-17 328
第一种 #include <windows.h> #include <stdio.h> void main(void) { int m = 0, cout = 0; char cStr2Find[1024] = {0}; printf("请输入一段字符串"); scanf("%s", cStr2Find); ...
怎样快速判断掩码第一个为1的Bit位置
01-15 3566
                怎样快速判断掩码第一个为1的Bit位置作者：lioqio在底层软件开发过程中经常使用位掩码标识一个状态符号。举一个例子来说，比如一个U32类型的变量Use_Mask用来表示32个内存块的占用状态，变量的每一位代表一个内存块的使用状态，1b表示空闲，0b表示被占用。当应用程序需要使用一个空闲块时，只需要查询Use_Mask哪一位为1，就可以直接将给Bi
二分查找
O9A0MA的博客
05-23 309
二分查找也叫折半查找，采用此方法时，数据必须是有序的，有效的提高了查找的效率。 主要思想： I. 假设查找的数组为array[ left, right]区间考虑左闭右闭。 1.首确定数组的中间位置mid并记录下来。 2.查找过程有三种情况： a.将查找的X值与array[ mid ]比较，如果相等，则返回mid的下标查找成功。 b....
java语言高效实现二分法查找
a_yaodinghaha的博客
11-02 475
java实现二分法查找 二分法查找算法适用于已经排好序的数组。 二分法的基本思路和步骤是： 1.找到数组的起始坐标和末尾坐标并记录。 2.找到数组的中间元素坐标并记录。 3.将需要查找的元素跟中间元素进行比较，如果大于中间元素，则截取中间元素以后的所有元素作为新的数组，将中间元素设为新数组的起始元素，如果小于中间元素，则截取中间元素以前的所有元素作为新的数组，将中间元素作为新数组的末尾元素。 4.如果需要查找的元素正好等于中间元素，则查找结束，此时的中间元素为需要查找的元素。 5.重复步骤3，步骤4。 二分
内核辅助函数系列 002 --- _find_next_bit：unsigned long 整数数组中第一个 0 或 1 位
jackchan-x 的博客
04-04 473
基于4.19.55 内核源码 参数 addr1 带搜寻 0/1 位的整数数组 addr2 扩展数组 nbits 最大搜索位 start 搜索开始位 invert 反转掩码 返回值 invert 等于 0 时，返回第一个非 0 位，等于 ~0UL 时，返回整数数组中第一个 0 位 代码在 find_bit.c 中，实现如下： /* * This is a common helper functi...
输入一个十进制的正整数，从低位开始查找，找到第一个置位（1）比特的位置
T_IS_BEHINGD_T的博客
05-16 1248
今天在网上看到一个题目，输入一个十进制的正整数，从低位开始查找，找到第一个置位（1）比特的位置 按照如下规则对正整数进行置位比特的查找： 1. 当查找失败时，比如输入正整数0，返回-1 2. 当查找成功时，返回该比特的位置 例子： 比如 如入12，二进制表示是0000000000001100，则第一个置位比特为2 那我的思路是先使二进制1左移i位与原数的二进制相与，第一个为真的时候返回i值即可
51nod 1267 4个数和为0（二分法）
abns的博客
08-08 119
http://www.51nod.com/onlineJudge/questionCode.html#!problemId=1267&amp;judgeId=598042 1267 4个数和为0  基准时间限制：1 秒 空间限制：131072 KB 分值: 20 难度：3级算法题  收藏  关注 给出N个整数，你来判断一下是否能够选出4个数，他们的和为0，可以则输出"Yes"，否则输出"...
二分法查找目标数据下标
xinxinburning的博客
04-22 170
自行确定数组输入长度 二分法查找目标在数组中的下标 算法小白自写 简单易懂
java数组0.0.0.0.0.1.1.1.1.1.1.1.1.1用二分法查找第一个1
最新发布
03-30
对于给定的数组[0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]，我们可以使用二分法查找第一个1的索引。具体步骤如下： 1. 起始索引start为0，结束索引end为13。 2. 计算中间索引mid，即mid = (0 + 13) / 2 = 6。 3. ...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值