a = 60 # 0011 1100
b = 13 # 0000 1101运算符
描述
示例
&
按位与运算符：参与运算的两个值,如果两个相应位都为1,则该位的结果为1,否则为0
a& b: 0000 1100
|
按位或运算符：只要对应的二个二进位有一个为1时，结果位就为1。
a|b: 0011 1101
~
按位取反运算符：对数据的每个二进制位取反,即把1变为0,把0变为1 。~x 类似于 -x-1
~a: 1100 0011
^
按位异或运算符：当两对应的二进位相异时，结果为1
a^b: 0011 0001
<<
左移动运算符：运算数的各二进位全部左移若干位，由 << 右边的数字指定了移动的位数，高位丢弃，低位补0。
a<<2: 1111 0000
>>
右移动运算符：把">>"左边的运算数的各二进位全部右移若干位，>> 右边的数字指定了移动的位数
a>>2: 0000 1111
位运算在数据结构的编程题目中也常常出现，通常位运算的算法都是时间和空间复杂度比较占优的一种解法。接下来总结几道leetcode中涉及位运算的解法题目。
题目描述：
给定一个包含 0, 1, 2, ..., n 中 n 个数的序列，找出 0 .. n 中没有出现在序列中的那个数。
示例 1:
输入: [3,0,1]
输出: 2
示例 2:
输入: [9,6,4,2,3,5,7,0,1]
输出: 8
说明:
你的算法应具有线性时间复杂度。你能否仅使用额外常数空间来实现?
大部分人首先想到的是利用散列表来对序列中每个数字进行计数，最后遍历0-n，计数为0的数即为所求。此解法时间复杂度为O(n)，空间复杂度O(n)。
那我们如何做到常数空间复杂度O(1)呢？
这里就要利用到我们的位运算了。如果一个数字出现了两次，则它们的异或^结果为0，我们可以利用这个性质，来对序列中的每个数字求一次异或，再对0-n中的数字求一次异或，则未缺失的数字都出现了两次，而缺失数字只出现了一次，出现两次的数字异或结果都为0，则最后留下的便是我们需要求得的缺失数字。
class Solution:
def missingNumber(self, nums):
"""异或运算，与本身为0。
:param nums:
:return:
"""
res = 0
for i in range(len(nums)+1):
res ^= i
for num in nums:
res ^= num
return res题目描述：
给定一个整数数组 nums，其中恰好有两个元素只出现一次，其余所有元素均出现两次。
找出只出现一次的那两个元素。
示例 :
输入: [1,2,1,3,2,5]
输出: [3,5]
注意：
结果输出的顺序并不重要，对于上面的例子， [5, 3] 也是正确答案。
你的算法应该具有线性时间复杂度。你能否仅使用常数空间复杂度来实现？
题目的难度有所上升了哈，如果我们还是对这个序列中的元素进行异或运算，那最后会得到什么呢？
假如只出现一次的两个元素是 x 和 y，由于其余元素均出现了两次，则其余元素的异或结果最后为0，最后剩下的便是 x 和 y 异或的结果了。我们知道异或运算保留的是两个数字二进制位的差异，有了这个差异我们又能做什么呢？
# 如示例中所述 [1,2,1,3,2,5]
>>> bin(3)
'0b11'
>>> bin(5)
'0b101'
>>> bin(3^5)
'0b110'我们注意到这个差异中的 1 均来至于 x 或 y，且只能来至于其中一个元素。那我们能否利用这些 1 将 x 和 y 分开呢？答案是肯定的。
分离 x 和 y只需要提取到其中一个 1 便够了。我们定义这个差异为 mask，即 mask = 3^5，那 -mask 是什么呢？——取反再+1。我们通过 mask & (-mask) 来得到 mask 最右边的 1。
>>> mask = 3^5
>>> bin(-mask)
'-0b110'
>>> bin(mask&(-mask))
'0b10'利用这个 1 将 x 和 y 分离，便得到了最终结果。
class Solution:
def singleNumber(self, nums):
"""位运算
:param nums:
:return:
"""
# 保留出现一次的两个数字的差异
mask = 0
for num in nums:
mask ^= num
# 记录最右边的1，这个1一定来至于其中一个数字，且只来至于那一个数字。我们可以根据这个1来分离这两个数字
diff = mask & (-mask)
res = 0
for num in nums:
if diff & num:
res ^= num
return [res, mask^res]题目描述：
集合 S 包含从1到 n 的整数。不幸的是，因为数据错误，导致集合里面某一个
元素复制了成了集合里面的另外一个元素的值，导致集合丢失了一个整数并且有
一个元素重复。
给定一个数组 nums 代表了集合 S 发生错误后的结果。你的任务是首先寻找到
重复出现的整数，再找到丢失的整数，将它们以数组的形式返回。
示例 1:
输入: nums = [1,2,2,4]
输出: [2,3]
注意:
给定数组的长度范围是 [2, 10000]。
给定的数组是无序的。
数组 nums 总共有 n 个元素，其中有一个元素重复。我们对1…n 的数字进行异或运算，再对 nums 中的数字进行异或运算，那结果便只剩下重复元素和丢失元素的差异了，联想到 leetcode 260，再将这两个元素分离，便得到了结果。
class Solution:
def findErrorNums(self, nums: List[int]) -> List[int]:
mask, xor0 = 0, 0
for idx, num in enumerate(nums, 1):
mask ^= idx ^ num
diff = mask & (-mask)
for idx, num in enumerate(nums, 1):
if diff & num:
xor0 ^= num
if diff & idx:
xor0 ^= idx
for num in nums:
# 即为重复数字
if num == xor0:
return [xor0, mask ^ xor0]
return [mask ^ xor0, xor0]前面几道题都是讲的异或 ^ 的算法，接下来我们看看这道题该采用什么算法呢？
题目描述：
给定一个包含 n + 1 个整数的数组 nums，其数字都在 1 到 n 之间（包括 1 和 n），
可知至少存在一个重复的整数。假设只有一个重复的整数，找出这个重复的数。
示例 1:
输入: [1,3,4,2,2]
输出: 2
示例 2:
输入: [3,1,3,4,2]
输出: 3
说明：
不能更改原数组（假设数组是只读的）。
只能使用额外的 O(1) 的空间。
时间复杂度小于 O(n2) 。
数组中只有一个重复的数字，但它可能不止重复出现一次。
我们知道1 的二进制表示为 0000 0001，若将 1 左移一位，即可得到 0000 0010，其中的数字 1 移动到了第2位；若将 1 左移两位，即可得到 0000 0100，其中的数字 1 移动到了第3位。数组 nums 中的数字都在 1 和 n 之间，若将 1 依次移动 1…n 位，则可得第 2…n+1 位置的 1。为了将每一位的 1 都保留下来，我们可以采用 | 运算。若这个位置的 1 已经被占用了，则表示这个数字为重复数字。
class Solution:
def findDuplicate(self, nums: List[int]) -> int:
flag = 0
for num in nums:
if flag & (1 << num) > 0:
return num
flag |= (1 << num)
return -1题目描述：
给定一个大小为 n 的数组，找到其中的多数元素。多数元素是指在数组中出现次数大于 ⌊ n/2 ⌋ 的元素。
你可以假设数组是非空的，并且给定的数组总是存在多数元素。
示例 1:
输入: [3,2,3]
输出: 3
示例 2:
输入: [2,2,1,1,1,2,2]
输出: 2
这道题采用位运算的前提是数组中的元素都为整数。虽然题目没有明确要求，但是位运算算法也能通过测试，所以题目默认应该是整数数组。当然，负数也是有可能的。
在 C 或者 java 语言中，整型占用32字节，而 python 中整型为动态类型，且没有最大值限制。我们这里的解法都是基于整型占用32位的前提下的。
想象数组中每个数字都是由32个位置所组成，每个位置为 0 或者 1。出现次数大于 ⌊n/2⌋ 的这个元素，每个位置出现的 0 或 1 的次数也是大于 ⌊n/2⌋ 的。由于 0 只是占位，1 才能帮助还原数字，所以我们可以统计每个位置 1 出现的次数，如果出现次数大于⌊n/2⌋，则计算到还原数字中。
class Solution:
def majorityElement(self, nums) -> int:
"""位运算 这里应该再加一个前提 数组中的元素为整数 且每个整数占用32字节
:param nums:
:return:
"""
res = 0
n = len(nums) >> 1
for i in range(32):
ones = 0
# 统计每个位置1出现的次数
for num in nums:
# 为了处理出现负数
ones += (num + 2 ** 31) >> i & 1
# 如果这个位置1出现的次数满足条件，则是目标数字
if ones > n:
res += 1 << i
return res - 2 ** 31
