csdner: 帅地, 【技巧总结】位运算装逼指南_帅地一些常用的算法技巧总结-CSDN博客

总所周知，位算法的效率比较快。
位运算很多情况下都是很二进制扯上关系的，所以我们要判断是否是否位运算，很多情况下都会把他们拆分成二进制，然后观察特性，或者就是利用与，或, 非，异或, 移位的特性来观察，总之，我觉得多看一些例子，加上自己多动手，就比较容易上手了。所以呢，继续往下看

1、判断奇偶数
判断一个数是基于还是偶数，一般的做法的代码如下

if ( 1 == n % 2) 
    // n 是个奇数
}//if ( 1 == n % 2)

如果把 n 以二进制的形式展示的话，其实我们只需要判断最后一个二进制位是 1 还是 0 就行了，如果是 1 的话，代表是奇数，如果是 0 则代表是偶数，所以采用位运算的方式的话，代码如下：

if (1 == n & 1) {
    // n 是个奇数。
}//if (1 == n & 1)

如果写成 n % 2 的形式，有些编译器确实会自动帮我们优化。但是，我们自己能够采用位运算的形式写出来，当然更好了。

2、交换两个数
通常会使用一个额外来变量来辅助交换，例如，我们要交换 x 与 y 值，传统代码如下：

auto tmp = x;
x = y;
y = tmp;

这样写通俗易懂，万一不允许使用额外的辅助变量来完成交换呢？这个时候，就可以这样写，代码如下：

x ^= y   // （1）
y ^= x   // （2）
x ^= y   // （3）

两个相同的数异或之后结果会等于 0，即 n ^ n = 0。并且任何数与 0 异或等于它本身，即 n ^ 0 = n。所以，解释如下：
(异或运算支持运算的交换律和结合律)
把（1）中的 x 带入（2）中的 x，有
y = x^y = (xy)y = x(yy) = x^0 = x。 x 的值成功赋给了 y。
对于（3）,推导如下：
x = x^y = (xy)x = (xx)y = 0^y = y。

3、找出没有重复的数
给你一组整型数据，这些数据中，其中有一个数只出现了一次，其他的数都出现了两次，让你来找出只出现了一次的这个数。

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

但是如果采用位运算来做，会简便很多。

我们刚才说过，两个相同的数异或的结果是 0，一个数和 0 异或的结果是它本身，所以我们把这一组整型全部异或一下，例如这组数据是：1， 2， 3， 4， 5， 1， 2， 3， 4。其中 5 只出现了一次，其他都出现了两次，把他们全部异或一下，结果如下：
由于异或支持交换律和结合律，所以:
123451234 = （11)(22)(33)(44)5= 00005 = 5。
也就是说，那些出现了两次的数异或之后会变成0，那个出现一次的数，和 0 异或之后就等于它本身。时间复杂度为 O(n)，空间复杂度为 O(1)。所以代码如下

int find(int[] arr){
    int tmp = arr[0];
    for(int i = 1;i < arr.length; i++){
        tmp = tmp ^ arr[i];
    }
    return tmp;
}

4、m的n次方
求解 m 的 n 次方，并且不能使用系统自带的 pow 函数，通常代码如下：

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

时间复杂度近为 O(n)，但是如果用位运算做，例如 n = 13，则 n 的二进制表示为 1101, 那么 m 的 13 次方可以拆解为:

m^1101 = m^0001 * m^0100 * m^1000。

我们可以通过 & 1和 >>1 来逐位读取 1101，为1时将该位代表的乘数累乘到最终结果。时间复杂度近为 O(logn)，直接看代码吧，反而容易理解，代码如下：

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

5、找出不大于N的最大的2的幂指数
传统的做法就是让 1 不断着乘以 2，代码如下：

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

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

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

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

在这里插入图片描述
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;
}

————————————————
版权声明：本文为CSDN博主「帅地」的原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/m0_37907797/article/details/103120886