位运算，学了忘，刷题又学，记不住，可能是没有学到精髓，继续吧！
原码/反码/补码
反码：
- 如果是正数，原码 = 反码；
- 如果是负数， 将0变为1，1变为0，符号位固定（这里的符号固定意味不能将符号位的1变为0）
补码：- 如果是正数，原码 = 反码 = 补码 ；
- 如果是负数， 对反码进行加 1 操作，符号位固定（这里的符号位固定意味着从反码变为补码时，符号位不参与进位操作，从补码变为反码时不参与借位操作）
8的源码： 0000000000000000000000000000 1000
-8的原码：1000000000000000000000000000 1000
-8的反码：11111111111111111111111111110111
-8的补码：11111111111111111111111111111000* [+3] = [00000000 00000000 00000000 000000011]原 * = [00000000 00000000 00000000 000000011]反 * = [00000000 00000000 00000000 000000011]补 * [-3] = [10000000 00000000 00000000 000000011]原 * = [11111111 11111111 11111111 111111100]反 * = [11111111 11111111 11111111 111111101]补
这样的话 1 和 -1 就如下表：
<< >>
移位运算： 逻辑运算 算术运算
- 逻辑移位：移出去的位丢弃，空缺位用"0"填充。
- 算术移位：移出去的位丢弃，空缺位用"符号位"来填充
左移： 将a的二进制整体向左移动N位，超出32位的戒掉，右边不足的用0 来补充。
int A = 12
int C = A << B // C = A * 2^B（如果不溢出）
eg：溢出
INT_MAX // 01111111 11111111 11111111 11111111(补码) = 2147483647
INT_MAX << 1 // 11111111 11111111 11111111 11111110(补码) = -2 (逻辑移位)
UINT_MAX // 11111111 11111111 11111111 11111111 = 4294967295
UINT_MAX << 1 // 11111111 11111111 11111111 11111110 = 4294967294 (逻辑移位)
右移操作
C++ 里面，右移操作和数据类型相关，无符号数是逻辑移位，有符号数是算术移位。
https://leetcode-cn.com/problems/subsets/submissions/
https://leetcode-cn.com/problems/subsets/submissions/https://leetcode-cn.com/problems/number-of-1-bits/submissions/
eg:不用加减乘除运算符计算a = b * 9(不考虑溢出)
// 1 分析： a=b*9=b*8+b
8=<<3
=b<<3 +b
// 2 测试： a=4*9=4<<3+4=32+4=36
a=4*6=4<<2+4+4=24
int plusWithBit(int num1, int num2) {
int xor_result = 0;
int and_result = 0;
while (num2) {
xor_result = num1 ^ num2; //不同为1 ，相同为0；
and_result = num1 & num2; // 1 1 1否则为0
num1 = xor_result;
num2 = and_result << 1;
}
return xor_result;
}
int getNumber(int num1) {
return plusWithBit(num1 << 3, num1);
}int A = 12
int C = A << B // C = A / 2^B
eg：
INT_MIN // 10000000 00000000 00000000 00000001(补码) = -2147483648
INT_MIN >> 1 // 11000000 00000000 00000000 00000000(补码) = -1073741824 (算术移位)
UINT_MAX // 11111111 11111111 11111111 11111111 = 4294967295
UINT_MAX >> 1 // 01111111 11111111 11111111 11111111 = 2147483647 (逻辑移位)& 都为1 才是1，1 1 =1
0 0 1 0 1 0
& 1 0 1 1 0 0
-------------------
0 0 1 0 0 0lowbit 方法
11000 ===24
最低位的1 1000=8；
n -n 每一位都取反 加1 ，24 -24
10：01010 (补码，最高位为符号位)
-10：10101(反码，正数的反码就是原码，负数的反码是符号位不变，其余位取反)
-10：10110（补码，正数的补码就是原码，负数的补码是反码+1）
n &= -n; // n中最后一位为1的位为1，其余位为0
0 1 0 1 0
& 1 0 1 1 0
----------------
0 0 0 1 0 
11000 & 01000==1
n&（-n）=lowbit; n-lowbit 去除一个1 n==0 的时候停止
| 只要有1 就是1
0 0 1 0 1 0
| 1 0 1 1 0 0
-------------------
1 0 1 1 1 0eg：消除二进制中最右侧的那个1
//二进制的数据
x=1100；
x-1=1011;
x&(x-1)=1000; // & ==1 1 1
bool cutRithtof1(int n)
{
return n > 0 && (n & (n-1)) == 0;
}~ a 按位非 1 0互换
0 0 1 0 1 0
~
-------------------
0 1 0 1 0 1^ 异或-考察最多的
不同为1 否则为0；
0 0 1 0 1 0
^ 1 0 1 1 0 0
-------------------
1 0 0 1 1 0
- 异或运算：
x ^ 0 = x ，x ^ 1 = ~x- 与运算：
x & 0 = 0，x & 1 = xa ^ b ^ b = a b ^ b = 0不用额外空间使用异或交换2个元素
异或运算的特质：
如果a ^ b = c，那么a ^ c = b与b ^ c = a同时成立，利用这一条，于是交换2个变量的值有以下方法：a = a ^ b b = a ^ b a = a ^ ba = a + b // new_a = old_a + old_b b = a - b // new_b = new_a - old_b = old_a + old_b - old_b = old_a a = a - b // new_a = new_a - new_b = old_a + old_b - old_a
eg 1
编写一个函数，输入是一个无符号整数（以二进制串的形式），返回其二进制表达式中数字位数为 '1' 的个数（也被称为汉明重量）。
输入：00000000000000000000000000001011
输出：3
解释：输入的二进制串 00000000000000000000000000001011 中，共有三位为 '1'。
示例 2：
输入：00000000000000000000000010000000
输出：1
解释：输入的二进制串 00000000000000000000000010000000 中，共有一位为 '1'。
int hammingWeight(uint32_t n)
{
int cnt=0;
for(int i=0;i<32;i++ )
{
if((n>>i)&1) // 提取最地位
{
cnt++;
}
} // 时间复制度是 32
// return cnt;
// lowbit
int count=0;
while(n){
int lowbit=n&(-n);
count++;
n-=lowbit;
} // 时间复制度是 O（logn）
// return count;
while (n != 0)
{
n = n & (n - 1);
count++;
}
return count;
}eg2：力扣
给你一个整数数组 nums ，除某个元素仅出现 一次 外，其余每个元素都恰出现 三次 。请你找出并返回那个只出现了一次的元素。
示例 1：
输入：nums = [2,2,3,2]
输出：3
int singleNumber(vector<int>& nums)
{
// 第一种方法 哈希
// unordered_map<int,int> map;
// for(int n:nums) map[n]++;
// for(const auto& [num,count]:map)
// {
// if(count==1) return num;
// }
// return -1;
// 第二 中 位运算
int ones = 0, twos = 0;
for(int num : nums){
ones = ones ^ num & ~twos;
twos = twos ^ num & ~ones;
}
return ones;
}eg3
数组中 只有一个数字出现一次，其他的都出现了两次，找出这个数
vector<int> ans;
unordered_map<int, int> freq;
for (int num: nums)
{
++freq[num];
}
for (const auto& [num, occ]: freq) {
if (occ == 1) {
ans.push_back(num);
}
}
return ans;
给你一个整数数组 nums ，除某个元素仅出现 一次 外，其余每个元素都恰出现 三次 。请你找出并返回那个只出现了一次的元素。
unordered_map<int,int> map;
for(int n:nums) map[n]++;
for(const auto& [num,count]:map)
{
if(count==1) return num;
}
return -1;eg；力扣https://leetcode-cn.com/problems/count-triplets-that-can-form-two-arrays-of-equal-xor/
eg5 ：力扣https://leetcode-cn.com/problems/number-complement/submissions/
eg：力扣https://leetcode-cn.com/problems/single-number/力扣https://leetcode-cn.com/problems/bitwise-and-of-numbers-range/
int rangeBitwiseAnd(int left, int right)
{
int ret=0;
for(int i=30;i>=0;i--)
{
int bl=(left>>i)&1;
int br=(right>>i)&1;
if(bl&&br) // 拿到的位数都为1
{
ret+=(1<<i);
}else if(!bl&&br)
{
break;
}
}
return ret;
} eg:给你一个整数数组 nums ，除某个元素仅出现 一次 外，其余每个元素都恰出现 三次 。请你找出并返回那个只出现了一次的元素。力扣https://leetcode-cn.com/problems/single-number-ii/
// 用到数位的思想， 按照位 计算
int singleNumber(vector<int>& nums)
{
int ret =0;
//按照位处理
for(int i=0;i<32;i++)
{
// 统计这一位 0，1 的数量（0 的数量其实是可以不同管的）
int cnt=0;
for(int x:nums){
int b=(x>>i)&1;//拿到为位
cnt +=b;
}
if(cnt%3)
{
ret+=(1<<i);
}
}
return ret;
}eg： 给定一个整数数组 nums，其中恰好有两个元素只出现一次，其余所有元素均出现两次。 找出只出现一次的那两个元素。你可以按 任意顺序 返回答案。力扣https://leetcode-cn.com/problems/single-number-iii/
vector<int> singleNumber(vector<int>& nums)
{
// 1 第1种 方法
// vector<int> res;
// unordered_map<int, int> freq;
// for (int num: nums)
// {
// ++freq[num];
// }
// for (const auto& [num, occ]: freq) {
// if (occ == 1) {
// res.push_back(num);
// }
// }
// return res;
//
// 第二种方法
// 1 将a b 分离开来 ,二相同的数据必须将他们放到同一组里面
vector<int> res;
// 枚举32位 找到1 的数量
int s =0;// 所有元素的异或结果
for(int n:nums)
{
s^=n;
}
// s i = 1 原序列当中，给位有 奇数个1
int pos=-1;
for(int i=0;i<32;i++)
{
if((s>>i)&1) //拿到的是1
{
pos=i;
break;
}
}
// 分组
int x=0;
int y=0;
for(int n:nums)
{
int m=(n>>pos)&1;
if(!m){
x^=n;
}else{
y^=n;
}
}
return {x,y};
}eg 给你一个整数数组 nums ，返回 nums[i] XOR nums[j] 的最大运算结果，其中 0 ≤ i ≤ j < n 。
class Solution {
public:
// 字典树
typedef struct Node
{
int son[2];
Node(){
son[0]=-1;
son[1]=-1;
}
}Node;
// int b2=1^b ====1-b;
vector<Node> nodes;
void insert(int x)
{
int id=0;
for(int i=31;i>=0;i--)
{
int b=(x>>i)&1;
if(nodes[id].son[b]==-1)
{
nodes.push_back({});
nodes[id].son[b] = nodes.size()-1;
}
id=nodes[id].son[b];
}
}
int query(int x)
{
int ret=0;
int id=0;
for(int i=31;i>=0;i--)
{
int b=(x>>i)&1;
int b2=1^b;// 1-b
if(nodes[id].son[b2]!=-1){
id=nodes[id].son[b2];
ret+=(1<<i);
}else{
id=nodes[id].son[b];
}
}
return ret;
}
int findMaximumXOR(vector<int>& nums)
{
// 从高位到地位考虑
if(nums.empty()) return 0;
nodes.push_back({});
insert(nums.back());
int ret=0;
for(int i=nums.size()-2;i>=0;i--){
int ans=query(nums[i]);
ret =max(ret,ans);
insert(nums[i]);
}
return ret;
}
};技巧4：循环队列的buffer size 为什么需要保证为2的幂？
为什么需要保证 buffer size 为2的幂？
因为通常循环队列的入队和出队操作要不断的对size进行求余， 为了提高效率，将 buffer size 扩展为2的幂，就可以使用位运算。kfifo->in % kfiifo->size 等同于 kfifo->in & (kfifo->size – 1)。
假设现在size 为16：
8 & (size - 1) = 01000 & 01111 = 01000 = 8
15 & (size -1) = 01111 & 01111 = 01111 = 15
16 & (size - 1) = 10000 & 01111 = 00000 = 0
26 & (size - 1 ) = 11010 & 01111 = 01010 = 10
所以保证size是2的幂的前提下，可以通过位运算的方式求余，在频繁操作对列的情况下可以大大提高效率。