常见的位运算

常见的位运算（转）

位操作符

  • & 与运算 两个位都是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 

  • ^ 异或运算，两个位相同则为0，不同则为1，如

      1 0 0 1 1 
    ^  1 1 0 0 1 
    ----------------------------- 
      0 1 0 1 0 

  • ~ 取反运算，0则变为1，1则变为0，如

    ~   1 0 0 1 1 
    ----------------------------- 
       0 1 1 0 0 

  • << 左移运算，向左进行移位操作，高位丢弃，低位补0，如

  1.  
    int a = 8;
  2.  
    a << 3;
  3.  
    移位前：0000 0000 0000 0000 0000 0000 0000 1000
  4.  
    移位后：0000 0000 0000 0000 0000 0000 0100 0000

  • >> 右移运算，向右进行移位操作，对无符号数，高位补0，对于有符号数，高位补符号位，如

  1.  
    unsigned int a = 8;
  2.  
    a >> 3;
  3.  
    移位前：0000 0000 0000 0000 0000 0000 0000 1000
  4.  
    移位后：0000 0000 0000 0000 0000 0000 0000 0001
  5.  
    int a = -8;
  6.  
    a >> 3;
  7.  
    移位前：1111 1111 1111 1111 1111 1111 1111 1000
  8.  
    移位前：1111 1111 1111 1111 1111 1111 1111 1111

常见位运算问题

1. 位操作实现乘除法

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

  1.  
    int a = 2;
  2.  
     
  3.  
    a >> 1; ---> 1
  4.  
     
  5.  
    a << 1; ---> 4

2. 位操作交货两数

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

  1.  
    //普通操作
  2.  
    void swap(int &a, int &b) {
  3.  
      a = a + b;
  4.  
      b = a - b;
  5.  
      a = a - b;
  6.  
    }
  7.  
    //位与操作
  8.  
    void swap(int &a, int &b) {
  9.  
      a ^= b;
  10.  
      b ^= a;
  11.  
      a ^= b;
  12.  
    }

位与操作解释： 第一步：a ^= b ---> a = (a^b); 
第二步：b ^= a ---> b = b^(a^b) ---> b = (b^b)^a = a 
第三步：a ^= b ---> a = (a^b)^a = (a^a)^b = b 

3. 位操作判断奇偶数

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

  1.  
    if(0 == (a & 1)) {
  2.  
     
  3.  
     //偶数
  4.  
     
  5.  
    }

4. 位操作交换符号

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

  1.  
    int reversal(int a) {
  2.  
     
  3.  
      return ~a + 1;
  4.  
     
  5.  
    }

整数取反加1，正好变成其对应的负数(补码表示)；负数取反加一，则变为其原码，即正数

5. 位操作求绝对值

  • 整数的绝对值是其本身，负数的绝对值正好可以对其进行取反加一求得，即我们首先判断其符号位（整数右移31位得到0，负数右移31位得到-1,即0xffffffff），然后根据符号进行相应的操作

  1.  
    int abs(int a) {
  2.  
     
  3.  
      int i = a >> 31;
  4.  
     
  5.  
      return i == 0 ? a : (~a + 1);
  6.  
     
  7.  
    }

上面的操作可以进行优化，可以将i == 0的条件判断语句去掉。我们都知道符号位i只有两种情况，即i = 0为正，i = -1为负。对于任何数与0异或都会保持不变，与-1即0xffffffff进行异或就相当于对此数进行取反,因此可以将上面三目元算符转换为((a^i)-i)，即整数时a与0异或得到本身，再减去0，负数时与0xffffffff异或将a进行取反，然后在加上1，即减去i(i =-1)

  1.  
    int abs2(int a) {
  2.  
     
  3.  
      int i = a >> 31;
  4.  
     
  5.  
      return ((a^i) - i);
  6.  
     
  7.  
    }

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

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

  1.  
    原数：   10000110 11011000
  2.  
     
  3.  
    奇数位右移一位： 0 10000010 1000100
  4.  
     
  5.  
    偶数位左移一位：0000100 01010000 0
  6.  
     
  7.  
    两数相或得到： 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)
    因此整个操作为：

  1.  
    unsigned short a = 34520;
  2.  
     
  3.  
    a = ((a & 0xAAAA) >> 1) | ((a & 0x5555) << 1);
  4.  
     
  5.  
    a = ((a & 0xCCCC) >> 2) | ((a & 0x3333) << 2);
  6.  
     
  7.  
    a = ((a & 0xF0F0) >> 4) | ((a & 0x0F0F) << 4);
  8.  
     
  9.  
    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，则我们可以通过下面方法去统计：

  1.  
    count = 0  
  2.  
     
  3.  
    while(a){  
  4.  
     
  5.  
      a = a & (a - 1);  
  6.  
     
  7.  
      count++;  
  8.  
     
  9.  
    }  

 

9.取绝对值

return ((x>>30)|1)*x.

10.求平均值

return (x&y) + ((x^y)>>1). 

原文链接：https://blog.csdn.net/weixin_41318405/article/details/83753462

posted @ 2020-08-28 10:49  萧海~  阅读(424)  评论(0)  编辑  收藏  举报
← → ↓ ↑