常用位运算总结

一.位运算符：

逻辑运算符：

1. &：位‘与’；
2. ^：位‘异或’
3. ｜：位‘或’
4. ～：位‘非’，取反

移位运算符：
1. <<:左移
2. >>:右移

逻辑运算符都是移（bit）为单位。

二.

（1）‘～’非，取反
位取反的操作符为“~”，0变成1，1变成0，需要注意的是，位取反运算并不会改变操作数的值，它只是再内存中进行的。如果想要改变需要重新赋值。

#include<stdio.h>
int main(void) {
	unsigned char a = 15; //0000 1111
 	unsigned char a1 = ~a; //1111 0000
 	unsigned char a2 = ~a1;//0000 1111
 	printf("%d,%d,%d", a, a1, a2);
}
//输出为15，240，15

（2）位与运算&：
位与运算符的操作符为&，1 & 1 = 1，1 & 0 = 0， 0 & 1 = 0，0 & 0 = 0

#include<stdio.h>
int main(void) {
	unsigned char a1 = 3;  // 0000 0011
 	unsigned char a2 = 240; // 1111 0000
 	unsigned char a3 = 255; //1111 1111
	printf("%d,%d", a1 & a2, a1 & a3);
	return 0;
}
//输出为0，3

（3）位或｜运算
位或运算的操作符为｜，将对两个操作数的每一位进行或运算，位“或”运算的准则如下：
1 ｜ 1 = 1， 1 ｜ 0 = 1， 0 ｜ 1 = 1， 0 ｜ 0 = 0

#include<stdio.h>
int main(void) {
	unsigned char a = 169;  //1010 1001
 	unsigned char a1 = 240; //1111 0000
	printf("%d", a | a1);
	return 0;
}
//输出为249

（4）位异或^
位异或运算的操作符为^，将对两个操作数的每一位进行异或运算。运算准则为：
1 ^ 1 = 0, 1 ^ 0 = 0, 0 ^ 1 = 0, 0 ^ 0 = 0(相同为0，不同为1)

#include<stdio.h>
int main(void) {
	unsigned char a1 = 169;  //1010 1001
 	unsigned char a2 = 15; //0000 1111
	printf("%d", a1 ^ a2);
	return 0;
}
//输出为166

（5）左移‘<<’和右移’>>’

#include<stdio.h>
int main(void) {
	unsigned char a = 1; // 0000 0001
	printf("%d,", a << 1); // 0000 0010	
	printf("%d,", a << 3); // 0000 1000
	printf("%d", a); //0000 0001左移运算符不改变原来的值
	return 0;
}
//输出结果：2,8,1

例题：
一、
题目：力扣191.位1的个数
编写一个函数，输入是一个无符号整数（以二进制串的形式），返回其二进制表达式中数字位数为 ‘1’ 的个数（也被称为汉明重量）。

提示：

请注意，在某些语言（如 Java）中，没有无符号整数类型。在这种情况下，输入和输出都将被指定为有符号整数类型，并且不应影响您的实现，因为无论整数是有符号的还是无符号的，其内部的二进制表示形式都是相同的。
在 Java 中，编译器使用二进制补码记法来表示有符号整数。因此，在上面的 示例 3 中，输入表示有符号整数 -3。

示例 1：

输入：00000000000000000000000000001011
输出：3
解释：输入的二进制串 00000000000000000000000000001011 中，共有三位为 ‘1’。
示例 2：

输入：00000000000000000000000010000000
输出：1
解释：输入的二进制串 00000000000000000000000010000000 中，共有一位为 ‘1’。
示例 3：

输入：11111111111111111111111111111101
输出：31
解释：输入的二进制串 11111111111111111111111111111101 中，共有 31 位为 ‘1’。

提示：

输入必须是长度为 32 的 二进制串 。

进阶：

如果多次调用这个函数，你将如何优化你的算法？

思考：用无符号数1结合for循环，利用按位与运算符和左移运算符遍历n二进制码的每一位，用cnt记录n二进制码中1的个数，出循环后返回cnt的值即可。

代码：

int hammingWeight(uint32_t n) {
    int cnt = 0, i;
    unsigned int a = 1;
    for (i = 0; i < 32; i++) {
        if (n & (a << i)) { //按位与运算符&只有 1 & 1 时才等于1，其余情况都为0，用左移运算符<<每次循环都让a的二进制码左移i位，最多左移31位就可以判断n的二进制码中的每一位是否为1
            ++cnt; //如果n这个位上的二进制码为1就会进循环，在这个地方++cnt
        }
    }
    return cnt;
}

二、
题目：力扣231.2的幂
给定一个整数，编写一个函数来判断它是否是 2 的幂次方。

示例 1:

输入: 1
输出: true
解释: 20 = 1
示例 2:

输入: 16
输出: true
解释: 24 = 16
示例 3:

输入: 218
输出: false

思考：在代码开头将n <= 0这些特殊情况返回false，定义int x = 1,因为如果n是2的幂次方的话n的二进制码中只会有一个1，用i建立for循环，结合按位与运算符跑遍n的从最小位开始的31个位的二进制码，并用cnt记录这31个位上1的个数，出循环后，如果cnt == 1返回true，如果cnt != 1返回false。

代码：

bool isPowerOfTwo(int n){
    if (n <= 0) {
        return false;
    }
    int i, x = 1, cnt = 0;
    for (i = 0; i < 31; ++i) {
        if (n & (x << i)) {
            ++cnt;
        }
    }
    if (cnt == 1) {
        return true;
    } else {
        return false;
    }
}

三、
题目：力扣29.两数相除
给定两个整数，被除数 dividend 和除数 divisor。将两数相除，要求不使用乘法、除法和 mod 运算符。

返回被除数 dividend 除以除数 divisor 得到的商。

整数除法的结果应当截去（truncate）其小数部分，例如：truncate(8.345) = 8 以及 truncate(-2.7335) = -2

示例 1:

输入: dividend = 10, divisor = 3
输出: 3
解释: 10/3 = truncate(3.33333…) = truncate(3) = 3
示例 2:

输入: dividend = 7, divisor = -3
输出: -2
解释: 7/-3 = truncate(-2.33333…) = -2

提示：

被除数和除数均为 32 位有符号整数。
除数不为 0。
假设我们的环境只能存储 32 位有符号整数，其数值范围是 [−231, 231 − 1]。本题中，如果除法结果溢出，则返回 231 − 1。

思考：（位运算法）按除数移位次数从大到小试探，并且不断更新被除数，直到被除数小于除数为止，按题目条件返回相应的结果即可。

代码：

int divide(int dividend, int divisor){
    long long div = divisor, did = dividend; // 除数，被除数全部转换为64位数据，避免溢出 
    long long quo = 0;   //商 
    int  sign = 0;

    //正负号处理，全部转换为无符号数进行移位运算 
if ( did < 0 ) { 
sign = !sign; 
did = -did;
}
if ( div < 0 ) { 
sign = !sign; 
div = -div; 
}

    //除法主体
for ( int i = 31; (i >= 0)  &&  (did >= div); i--) { //按移位次数从大到小试探加一个条件，提前终止32次循环
        if (did >= (div << i) ) { //最接近被除数且比被除数小的移位次数
            quo += ((long long)1 << i);  //更新结果将计算出来的一个子项加到商上
            did -= (div << i); //更新被除数 
        }
    }
    quo = (sign == 1)  ?  -quo  :  quo; //获得最终结果(即为正还是为负)
    return  ( quo < -2147483648 || quo > 2147483647 )  ?  2147483647 : quo; //结果溢出判断并返回相应的值
}