侧边栏壁纸
博主头像
soulballad博主等级

技术文章记录及总结

  • 累计撰写 169 篇文章
  • 累计创建 26 个标签
  • 累计收到 4 条评论

目 录CONTENT

文章目录

位运算的奇技淫巧

soulballad
2022-01-05 / 0 评论 / 0 点赞 / 53 阅读 / 5,374 字
温馨提示:
本文最后更新于 2022-03-17,若内容或图片失效,请留言反馈。部分素材来自网络,若不小心影响到您的利益,请联系我们删除。

& 与运算

两个位都是 1 时,结果才为 1,否则为 0

​ 1 0 0 1 1

& 1 1 0 0 1

​ 1 0 0 0 1

| 或运算

两个位都是 0 时,结果才为 0,否则为 1

​ 1 0 0 1 1

| 1 1 0 0 1

​ 1 1 0 1 1

可以用在if语句判断中(替代 || )

^异或运算

两个位相同则为 0,不同则为 1

​ 1 0 0 1 1

^ 1 1 0 0 1

​ 0 1 0 1 0

<< 左移运算

向左进行移位操作,高位丢弃,低位补 0

int a = 8;
a << 3;
移位前:0000 0000 0000 0000 0000 0000 0000 1000
移位后:0000 0000 0000 0000 0000 0000 0100 0000

>>右移运算

向右进行移位操作,对无符号数,高位补 0,对于有符号数,高位补符号位

unsigned int a = 8;
a >> 3;
移位前:0000 0000 0000 0000 0000 0000 0000 1000
移位后:0000 0000 0000 0000 0000 0000 0000 0001

int a = -8;
a >> 3;
移位前:1111 1111 1111 1111 1111 1111 1111 1000
移位前:1111 1111 1111 1111 1111 1111 1111 1111

常见位运算问题

  1. 位操作实现乘除法

    • 数 a 向右移一位,相当于将 a 除以 2;数 a 向左移一位,相当于将 a 乘以 2

      int a = 2;
      a >> 1; ---> 1  // a/2
      a << 1; ---> 4  // a*2
      
  2. 位操作交换两数

    • 位操作交换两数可以不需要第三个临时变量,虽然普通操作也可以做到,但是没有其效率高

      //不通过临时变量交换两数
      //普通操作
      void swap(int &a, int &b) {
        a = a + b;
        b = a - b;
        a = a - b;
      }
      
      //位与操作
      void swap(int &a, int &b) {
        a ^= b;
        b ^= a;
        a ^= b;
      }
      

      位与操作解释:

      第一步:a = b ---> a = (ab);

      第二步:b ^= a ---> b = b(ab) ---> b = (bb)a = a

      第三步:a ^= b ---> a = (ab)a = (aa)b = b

  3. 位操作判断奇偶数

    • 只要根据数的最后一位是 0 还是 1 来决定即可,为 0 就是偶数,为 1 就是奇数。

      if((a & 1)== 0) {
       //偶数
      }
      if((a & 1)== 1){
        //奇数
      }
      
  4. 位操作交换符号

    • 交换符号将正数变成负数,负数变成正数

      int reversal(int a) {
        return ~a + 1;
      }
      
      //整数取反加1,正好变成其对应的负数(补码表示);负数取反加一,则变为其原码,即正数
      
  5. 位操作求绝对值

    • 整数的绝对值是其本身,负数的绝对值正好可以对其进行取反加一求得,即我们首先判断其符号位(整数右移 31 位得到 0,负数右移 31 位得到 -1,即 0xffffffff),然后根据符号进行相应的操作
    int abs(int a) {
      int i = a >> 31;
      return i == 0 ? a : (~a + 1);
    }
    
    • 上面的操作可以进行优化,可以将i == 0 的条件判断语句去掉。我们都知道符号位i 只有两种情况,即 i = 0 为正,i = -1 为负。对于任何数与 0 异或都会保持不变,与-1 即 0xffffffff进行异或就相当于对此数进行取反,因此可以将上面三目元算符转换为((a^i)-i),即整数时 a 与 0 异或得到本身,再减去 0,负数时与 0xffffffff 异或将 a 进行取反,然后在加上 1,即减去 i(i =-1)
    int abs2(int a) {
      int i = a >> 31;
      return ((a^i) - i);
    }
    
  6. 位操作进行高低位交换

    • 给定一个 16 位的无符号整数,将其高 8 位与低 8 位进行交换,求出交换后的值,如:
    34520的二进制表示:
    10000110 11011000
    
    将其高8位与低8位进行交换,得到一个新的二进制数:
    11011000 10000110
    其十进制为55430
    

    从上面移位操作我们可以知道,只要将无符号数 a>>8 即可得到其高 8 位移到低 8 位,高位补 0;将 a<<8 即可将 低 8 位移到高 8 位,低 8 位补 0,然后将 a>>8 和 a<<8 进行或操作既可求得交换后的结果。

    unsigned short a = 34520;
    a = (a >> 8) | (a << 8);
    
  7. 位操作进行二进制逆序

    • 将无符号数的二进制表示进行逆序,求取逆序后的结果,如
    数34520的二进制表示:
    10000110 11011000
    
    逆序后则为:
    00011011 01100001
    它的十进制为7009
    

    在字符串逆序过程中,可以从字符串的首尾开始,依次交换两端的数据。在二进制中使用位的高低位交换会更方便进行处理,这里我们分组进行多步处理。

    • 第一步:以每 2 位为一组,组内进行高低位交换

      交换前: 10 00 01 10 11 01 10 00
      交换后: 01 00 10 01 11 10 01 00
      
    • 第二步:在上面的基础上,以每 4 位为 1 组,组内高低位进行交换

      交换前: 0100 1001 1110 0100
      交换后: 0001 0110 1011 0001
      
    • 第三步:以每 8 位为一组,组内高低位进行交换

      交换前: 00010110 10110001
      交换后: 01100001 00011011
      
    • 第四步:以每16位为一组,组内高低位进行交换

      交换前: 0110000100011011
      交换后: 0001101101100001
      

    对于上面的第一步,依次以 2 位作为一组,再进行组内高低位交换,这样处理起来比较繁琐,下面介绍另外一种方法进行处理。先分别取原数 10000110 11011000 的奇数位和偶数位,将空余位用 0 填充:

    原数:  10000110 11011000
    奇数位: 10000010 10001000
    偶数位: 00000100 01010000
    

    再将奇数位右移一位,偶数位左移一位,此时将两个数据相或即可以达到奇偶位上数据交换的效果:

    原数:  10000110 11011000
    奇数位右移一位: 0 10000010 1000100
    偶数位左移一位:0000100 01010000 0
    两数相或得到: 01001001 11100100
    

    上面的方法用位操作可以表示为:

     取a的奇数位并用 0 进行填充可以表示为:a & 0xAAAA
    
     取a的偶数为并用 0 进行填充可以表示为:a & 0x5555 因此,上面的第一步可以表示为:
     a = ((a & 0xAAAA) >> 1) | ((a & 0x5555) << 1)
     同理,可以得到其第二、三和四步为:
    
     a = ((a & 0xCCCC) >> 2) | ((a & 0x3333) << 2)
     a = ((a & 0xF0F0) >> 4) | ((a & 0x0F0F) << 4)
     a = ((a & 0xFF00) >> 8) | ((a & 0x00FF) << 8)
    
     因此整个操作为:
    
     unsigned short a = 34520;
    
     a = ((a & 0xAAAA) >> 1) | ((a & 0x5555) << 1);
     a = ((a & 0xCCCC) >> 2) | ((a & 0x3333) << 2);
     a = ((a & 0xF0F0) >> 4) | ((a & 0x0F0F) << 4);
     a = ((a & 0xFF00) >> 8) | ((a & 0x00FF) << 8);
    
  8. 位操作统计二进制中 1 的个数

    统计二进制1的个数可以分别获取每个二进制位数,然后再统计其1的个数,此方法效率比较低。这里介绍另外一种高效的方法,同样以 34520 为例,我们计算其 a &= (a-1)的结果:

    • 第一次:计算前:1000 0110 1101 1000 计算后:1000 0110 1101 0000
    • 第二次:计算前:1000 0110 1101 0000 计算后:1000 0110 1100 0000
    • 第二次:计算前:1000 0110 1100 0000 计算后:1000 0110 1000 0000 我们发现,没计算一次二进制中就少了一个 1,则我们可以通过下面方法去统计:
    count = 0  
    while(a){  
    a = a & (a - 1);  
    count++;  
    } 
    

找出没有重复的数

给你一组整型数据,这些数据中,其中有一个数只出现了一次,其他的数都出现了两次,让你来找出一个数 。

这道题可能很多人会用一个哈希表来存储,每次存储的时候,记录 某个数出现的次数,最后再遍历哈希表,看看哪个数只出现了一次。这种方法的时间复杂度为 O(n),空间复杂度也为 O(n)了。

然而我想告诉你的是,采用位运算来做,绝对高逼格!

我们刚才说过,两个相同的数异或的结果是 0,一个数和 0 异或的结果是它本身,所以我们把这一组整型全部异或一下,例如这组数据是:1, 2, 3, 4, 5, 1, 2, 3, 4。其中 5 只出现了一次,其他都出现了两次,把他们全部异或一下,结果如下:

由于异或支持交换律和结合律,所以:

1 2 3 4 5 1 2 34 = (1 1)(2 2) (3 3) (4 4)5= 00005 = 5。

也就是说,那些出现了两次的数异或之后会变成0,那个出现一次的数,和 0 异或之后就等于它本身。就问这个解法牛不牛逼?所以代码如下

m的n次方

如果让你求解 m 的 n 次方,并且不能使用系统自带的 pow 函数,你会怎么做呢?这还不简单,连续让 n 个 m 相乘就行了,代码如下:

int pow(int n){
    int tmp = 1;
    for(int i = 1; i <= n; i++) {
        tmp = tmp * m;
    }
    return tmp;
}

不过你要是这样做的话,我只能呵呵,时间复杂度为 O(n) 了,怕是小学生都会!如果让你用位运算来做,你会怎么做呢?

我举个例子吧,例如 n = 13,则 n 的二进制表示为 1101, 那么 m 的 13 次方可以拆解为:

m1101=m0001∗m0100∗m1000m1101=m0001∗m0100∗m1000。

我们可以通过 & 1和 >>1 来逐位读取 1101,为1时将该位代表的乘数累乘到最终结果。直接看代码吧,反而容易理解:

int pow(int n){
    int sum = 1;
    int tmp = m;
    while(n != 0){
        if(n & 1 == 1){
            sum *= tmp;
        }
        tmp *= tmp;
        n = n >> 1;
    }

    return sum;
}

时间复杂度近为 O(logn)O(logn),而且看起来很牛逼。

这里说一下,位运算很多情况下都是很二进制扯上关系的,所以我们要判断是否是否位运算,很多情况下都会把他们拆分成二进制,然后观察特性,或者就是利用与,或,异或的特性来观察,总之,我觉得多看一些例子,加上自己多动手,就比较容易上手了。所以呢,继续往下看,注意,先别看答案,先看看自己会不会做。

找出不大于N的最大的2的幂指数

传统的做法就是让 1 不断着乘以 2,代码如下:

int findN(int N){
    int sum = 1;
   while(true){
        if(sum * 2 > N){
            return sum;
        }
        sum = sum * 2;
   }
}

这样做的话,时间复杂度是 $O(logn)¥,那如果改成位运算,该怎么做呢?我刚才说了,如果要弄成位运算的方式,很多时候我们把某个数拆成二进制,然后看看有哪些发现。这里我举个例子吧。

例如 N = 19,那么转换成二进制就是 00010011(这里为了方便,我采用8位的二进制来表示)。那么我们要找的数就是,把二进制中最左边的 1 保留,后面的 1 全部变为 0。即我们的目标数是00010000。那么如何获得这个数呢?相应解法如下:

1、找到最左边的 1,然后把它右边的所有 0 变成 1

img

2、把得到的数值加 1,可以得到 00100000即 00011111 + 1 = 00100000。

3、把 得到的 00100000 向右移动一位,即可得到 00010000,即 00100000 >> 1 = 00010000。

那么问题来了,第一步中把最左边 1 中后面的 0 转化为 1 该怎么弄呢?我先给出代码再解释吧。下面这段代码就可以把最左边 1 中后面的 0 全部转化为 1,

n |= n >> 1;
n |= n >> 2;
n |= n >> 4;

就是通过把 n 右移并且做运算即可得到。我解释下吧,我们假设最左边的 1 处于二进制位中的第 k 位(从左往右数),那么把 n 右移一位之后,那么得到的结果中第 k+1 位也必定为 1,然后把 n 与右移后的结果做或运算,那么得到的结果中第 k 和 第 k + 1 位必定是 1;同样的道理,再次把 n 右移两位,那么得到的结果中第 k+2和第 k+3 位必定是 1,然后再次做或运算,那么就能得到第 k, k+1, k+2, k+3 都是 1,如此往复下去….

最终的代码如下

int findN(int n){
    n |= n >> 1;
    n |= n >> 2;
    n |= n >> 4;
    n |= n >> 8 // 整型一般是 32 位,上面我是假设 8 位。
    return (n + 1) >> 1;
}

这种做法的时间复杂度近似 O(1),重点是,高逼格。

不过呢,我给出的这些例子中,并不是让你们学会了这些题就 Ok,而且让你们有一个意识:很多时候,位运算是个不错的选择,至少时间效率会快很多,而且高逼格,装逼必备。所以呢,以后可以多尝试去使用位运算哦

资料补充:https://www.cnblogs.com/heyonggang/p/3311128.html

0

评论区