关于位运算、位图的一些用法

目录

1、打印一个整型的32位二进制

2、在hashmap中用到 num % 2^n   <==>  num & (2^n-1) 

3、位运算实现加减乘除

4、异或实现两个数交换

5、提取一个整数（int型）最右边的1（如 011010100--->000000100）

---

 

 

---

1、打印一个整型的32位二进制

public void print(int num){
	for (int i = 31; i >= 0 ; i--) {
		System.out.print( ( num & (1<<i) ) == 0 ? 0 : 1 );
	}
}

2、在hashmap中用到 num % 2^n   <==>  num & (2^n-1) 

举例说明：127% 64  

127: 0000 0000 0111 1111

64 :  0000 0000 0100 0000

127对64取模结果肯定为0~63，也就是取127的第0位到第5位：0000 0000 0011 1111，而 127 & 63 恰好是取127的第0位到第5位。

127: 0000 0000 0111 1111

63 :  0000 0000 0011 1111

所以这两种写法是等价的，但是与运算的速度要快很多。

3、位运算实现加减乘除

public class Solution{

	public static int add(int a, int b) {
		int sum = a;
		while (b != 0) {
			sum = a ^ b;
			b = (a & b) << 1;
			a = sum;
		}
		return sum;
	}
    //complement是补码，相当于绝对值，但是无法对Integer.MIN_VALUE求绝对值
	public static int complement(int n) {
		return add(~n, 1);
	}

	public static int minus(int a, int b) {
		return add(a, complement(b));
	}

	public static int multiply(int a, int b) {
		int res = 0;
		while (b != 0) {
			if ((b & 1) != 0) {
				res = add(res, a);
			}
			a <<= 1;
			b >>>= 1;
		}
		return res;
	}

	public static boolean isNegetive(int n) {
		return n < 0;
	}

	public static int div(int a, int b) {
		int x = isNegetive(a) ? complement(a) : a;
		int y = isNegetive(b) ? complement(b) : b;
		int res = 0;
        //因为x已经保证为正数，符号位为0，所以右移30位就够了
		for (int i = 30; i >= 0; i = minus(i, 1)) {
			if ((x >> i) >= y) {
				res |= (1 << i);
				x = minus(x, y << i);
			}
		}
		return isNegetive(a) != isNegetive(b) ? complement(res) : res;
	}

	public static int divide(int a, int b) {
		if (a == Integer.MIN_VALUE && b == Integer.MIN_VALUE) {
			return 1;
		} else if (b == Integer.MIN_VALUE) {
			return 0;
		} else if (a == Integer.MIN_VALUE) {
			if (b == negNum(1)) {
				return Integer.MAX_VALUE;
            //后面会解释
			} else {
				int c = div(add(a, 1), b);
				return add(c, div(minus(a, multiply(c, b)), b));
			}
		} else {
			return div(a, b);
		}
	}

}

对于加法：二进制加法等价于 无进位相加 + 进位，无进位相加就是异或（^），进位就是与（&）举例说明用二进制运算代替加法

 

减法可以用加法实现；

乘法实现：

 

根据以上过程可以写出如下代码

public static int multi(int a, int b) {
    int res = 0;
    while (b != 0) {
        if ((b & 1) != 0) {
            res = add(res, a);
        }
        a <<= 1;
        //如果b有符号位1，则>>运算不会使循环退出
        b >>>= 1;
    }
    return res;
}

除法最为麻烦

else if (a == Integer.MIN_VALUE) {
	if (b == negNum(1)) {
        return Integer.MAX_VALUE;
	} else {
		int c = div(add(a, 1), b);
		return add(c, div(minus(a, multiply(c, b)), b));
	}
} 

如果a=Integer.MIN_VALUE，我们是无法对其求绝对值的，所以要多做一些步骤：

还是举例子，假设int的范围是~10到9，我要求-10/2可以按照以下步骤来求

1 ：-10 +1 =-9

2： -9 / 2 = -4；

3：2 * (-4) = -8；

4：-10 - (-8) = -2

5：-2 / 2 = -1；

6：-4 + (-1) = -5;

4、异或实现两个数交换

a = a ^ b;

b = a ^ b;

b = a ^ b;

5、提取一个整数（int型）最右边的1（如 011010100--->000000100）

a：0110 1010 0

~a+1 ：1001 0110 0

a & (~a + 1) =a & (-a)  = 0000 0010 0

由这个结论可以完成下面这题：

一个数组中有两种数出现了奇数次，其它数都出现了偶数次，找到并返回这两个数。

思路：如果能按照某种划分方法能够将这两个数分开，根据LeetCode136可以找出这两个数。举例： 

[6,10,6,6,4,4,12,12,12,12,3,3]，如果将数组中所有数异或，可以得到res = 6^10 = 12, 我们只能得到12，无法得到具体两个数。我们可以根据数组中的数的某一位是否为1将这个数组分为两种数。上面已经有了方法提取一个数的最右边的1，所以这个数组的数按照第2位是否为1分为两种数，一种为第2位为1的，还有一种就是第2位为0的。(这里为什么是按照第二位的是否为1来划分？因为res（6^10）表示为二进制：1100，异或结果中有1的位表示参与异或的两个数该位不一样，所以按照res第二位可以将整个数组划分为2种数，而且6和10分到不同的组，这样能用上LeetCode136的结论)这个数组被分为 ：[6,10,6,6,4,4,12,12,12,12,3,3]. 而res = 6^10, 在将第二位为1的全部异或起来得到 res1；则两个数分别为 a = res1，b = res ^ res1;

public class Main {
    public static void main(String[] args) {
        int[] a = {6,10,6,6,4,4,12,12,12,12,3,3};
        int[] res = solve(a);
        System.out.println(Arrays.toString(res));
    }

    //数组中只有两个数出现奇数次，其他都出现偶数次，找出这两个数
    public static int[] solve(int[] nums){
        int a = 0;
        for (int num : nums){
            a ^= num;
        }
        int b = 0;
        for (int num : nums){
            b ^= (num & (a & (-a))) == 0 ? 0 : num;
        }
        return new int[]{b,a^b};
    }
}

扩展：一个数组nums中只有一种数出现K次，其他的数都出现了M次，M>1,K<M，找到出现K次的数。你能让算法的空间复杂度达到O(1)吗？

public static int onlyKTimes(int[] nums, int K, int M) {
    int[] T = new int[32];
    for (int num : nums) {
        for (int i = 0; i < 32; i++) {
            if (((num >> i) & 1) != 0) {
                T[i]++;
            }
        }

    }
    int ans = 0;
    for (int i = 0; i < 32; i++) {
        if(T[i] % M != 0)
            ans |= (1<<i);
    }
    return ans;
}

解释：一个int型是32位的，遍历数组nums，把数组nums中每个数看成32位二进制，如果某一位是1，则将这个1统计到T数组中，如数组nums中有3个10，10的第二位和第四位是1，那么T数组为[0,0，......，0，3，0，3，0]。数组T的第i为意思是，原数组nums中第i位是1的元素的个数。这样一来，T[i]/M如果不等于0，则说明出现K次的数在第i个位置上是1（K<M）。