位运算

什么是位运算:

介绍:

程序中的所有数在计算机内存中都是以二进制的形式储存的。位运算就是直接对整数在内存中的二进制位进行操作。比如，and运算本来是一个逻辑运算符，但整数与整数之间也可以进行and运算。举个例子，6的二进制是110，11的二进制是1011，那么6 and 11的结果就是2，它是二进制对应位进行逻辑运算的结果（0表示False，1表示True，空位都当0处理）

位运算概览

符号	描述	运算规则
&	与	两个位都为1时，结果才为1
^	异或	两个位相同为0，相异为1
~	取反	0变1，1变0
<<	左移	各二进位全部左移若干位，高位丢弃，低位补0
>>	右移	各二进位全部右移若干位，对无符号数，高位补0，有符号数，各编译器处理方法不一样，有的补符号位（算术右移），有的补0（逻辑右移）

“|” — 或 — 两个位都为0时，结果才为0

1.# 191.位1的个数—汉明重量

题目:

编写一个函数，输入是一个无符号整数，返回其二进制表达式中数字位数为 ‘1’ 的个数（也被称为汉明重量）。
示例1：
输入：00000000000000000000000000001011
输出：3

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

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

python:

class Solution:
    def hammingWeight(self, n: int) -> int:
        t = 0
        while n != 0:
            n = n & (n - 1)
            t += 1
        return t


if __name__ == '__main__':
    j = Solution()
    c = 11 #二进制转成十进制的数字
    a = j.hammingWeight(c)
    print(a)

• 一 解题思路:
  • 因为 a & (a-1) = 消灭n最右侧的一个1,所以消灭一个1,就加一个1,最后n为0,循环结束
• 二 应用范围—规律:
  • 比较适合 位运算n & (n-1)
• 三 什么类型:
  • 位运算—n&(n-1)
• 四 注意点:
  • 1 循环条件是n != 0
  • 2 传进去的参数是转成十进制的,要计算的二进制数字
• 五 哪种类型—解决哪种问题:
  • 位运算之1的个数

2.# 461. 汉明距离

题目:

两个整数之间的汉明距离指的是这两个数字对应二进制位不同的位置的数目。

给出两个整数 x 和 y，计算它们之间的汉明距离。

注意：
0 ≤ x, y < 2^31.

示例:

输入: x = 1, y = 4

输出: 2

解释:

1 (0 0 0 1)

4 (0 1 0 0)

python:

class Solution:
    def hammingDistance(self, x: int, y: int) -> int:
        a = x ^ y
        count = 0
        while a != 0:
            a = a & (a - 1)
            count += 1
        return count


if __name__ == '__main__':
    s = Solution()
    print(s.hammingDistance(1, 4))

• 一 解题思路:
  • 因为 a & (a-1) = 消灭n最右侧的一个1,a ^ a = 0,a ^ 0 = a ,而汉明距离就是计算两个值二进制不同位置的数目,所以循环条件就是a = a ^ b ,a != 0,最后返回计数
• 二 应用范围—规律:
  • 比较适合 汉明距离n & (n-1),x ^ y
• 三 什么类型:
  • 位运算—n&(n-1),x ^ y
• 四 注意点:
  • 1 循环条件是a != 0
• 五 哪种类型—解决哪种问题:
  • 位运算之汉明距离

3.136. 只出现一次的数字

题目:

给定一个非空整数数组，除了某个元素只出现一次以外，其余每个元素均出现两次。找出那个只出现了一次的元素。

说明：

你的算法应该具有线性时间复杂度。 你可以不使用额外空间来实现吗？

示例 1:

输入: [2,2,1]
输出: 1
示例 2:

输入: [4,1,2,1,2]
输出: 4

python:

from typing import List


class Solution:
    def singleNumber(self, nums: List[int]) -> int:
        res = 0
        for i in nums:
            res = res ^ i
        return res


if __name__ == '__main__':
    j = Solution()
    a = j.singleNumber([4,1,2,1,2])
    print(a)

• 一 解题思路:
  • 因为 a ^ a = 0 a ^ 0 = a,所以如果a的值等于 0 说明当前数字不是唯一,如果a不等于0 说明当前数字是唯一,依次判断遍历给定的数组
• 二 应用范围—规律:
  • 比较适合 a ^ a = 0 a ^ 0 = a
• 三 什么类型:
  • 位运算—a ^ a = 0 a ^ 0 = a
• 四 注意点:
  • 1 a ^ a = 0 a ^ 0 = a,不要记错
• 五 哪种类型—解决哪种问题:
  • 位运算之a ^ a = 0 a ^ 0 = a

4.477. 汉明距离总和

题目:

两个整数的 汉明距离 指的是这两个数字的二进制数对应位不同的数量。

计算一个数组中，任意两个数之间汉明距离的总和。

示例:

输入: 4, 14, 2

输出: 6

解释: 在二进制表示中，4表示为0100，14表示为1110，2表示为0010。（这样表示是为了体现后四位之间关系）
所以答案为：
HammingDistance(4, 14) + HammingDistance(4, 2) + HammingDistance(14, 2) = 2 + 2 + 2 = 6.
注意:

数组中元素的范围为从 0到 10^9。
数组的长度不超过 10^4。

python:

from typing import List


class Solution:
    def totalHammingDistance(self, nums: List[int]) -> int:
        res = 0
        for i in range(32):
            count_0 = 0
            count_1 = 0
            for j in range(len(nums)):
                if (nums[j] >> i) & 1:
                    count_1 += 1
                else:
                    count_0 += 1
            res = res + count_1 * count_0
        return res

if __name__ == '__main__':
    s = Solution()
    a = s.totalHammingDistance(
[4,14,2])
    print(a)

• 一 解题思路:
  • 这要是汉明距离的题目,稍有不同 n & 1 n的二进制最后一位是0,就是计算0的个数,n的二进制最后一位是1就是计算1的个数,例: 110 & 1 是计算0的个数 101 & 1是计算1的个数,因为一个字节等于8位,在计算机中存储是4个字节,总共32位,所以第一层循环就是32次,第二次循环就是数组的长度了,汉明距离是连个二进制位不同位置的个数,所以1的个数*0的个数,就是一次循环的汉明距离,最后把每次循环的次数加在一起,就是汉明距离的总和
• 二 应用范围—规律:
  • 比较适合 n & 1
• 三 什么类型:
  • 位运算—n & 1
• 四 注意点:
  • 1 n & 1 当n是什么就算的是谁的次数
  • 外层循环不是数组长度而是数字在计算机的存储格式32位 4字节
• 五 哪种类型—解决哪种问题:
  • 位运算之汉明距离总和