【算法很美】位运算

1. 基本数据类型

1. 逻辑类型

   boolean

2. 整数类型

   byte 8位（取值范围 -2⁷~2⁷-1）

   short 16位（取值范围 -2¹⁵~2¹⁵-1）

   int 32位（取值范围 -2³¹~2³¹-1）

   long 64位（取值范围 -2⁶³~2⁶³-1）

3. 字符类型

   char 16位（无负数，取值范围 0~2 ¹⁶-1，即0~65535）

4. 浮点类型

   float 32位

   double 64位

 

2. 运算符

位运算符

1. “按位与”运算符 &

2. “按位或”运算符 |

3. “按位非”运算符 ~

4. “按位异或”运算符 ^

   

 

移位运算符

1. 左移位运算符 <<

   左面的操作元：被移位数

   右面的操作元：移位量，操作元必须是整型类型的数据

   • a<<n
     • 将a的所有位都左移n位，每左移一个位，左边的高阶位上的0或1被移出丢弃，并用0填充右边的低位
     • 不断左移位的结果是0
   • 对于byte或short型数据，a<<n的运算结果是int型精度
     • 当进行a<<2运算时，系统首先将a升级为int型数据，对于正数，在高位用0填充；负数用1填充，然后再进行移位运算
   • 在进行a<<n运算时
     • 如果a是byte、short或int型数据，系统总是先计算出n%32的结果m，然后再进行a<<m运算
     • 如果a是long型数据，系统总是先计算出n%64的结果m，然后再进行a<<m运算

2. 右移位运算符 >>

   左面的操作元：被移位数

   右面的操作元：移位量，操作元必须是整型类型的数据

   • a>>n
     • 将a的所有位都右移n位，每右移一个位，右边的低阶位被移出丢弃，并用0或1填充左边的高位，a是正数时用0填充，负数时用1填充
     • 正数不断右移位的结果是0，负数不断右移位的结果是-1
   • 对于byte或short型数据，a>>n的运算结果是int型精度
   • 在进行a>>n运算时
     • 如果a是byte、short或int型数据，系统总是先计算出n%32的结果m，然后再进行a>>m运算
     • 如果a是long型数据，系统总是先计算出n%64的结果m，然后再进行a>>m运算

 

>>：带符号右移。正数右移高位补0，负数右移高位补1。

>>>：无符号右移。无论是正数还是负数，高位通通补0。

 

3. 判断奇偶数

x & 1

• 奇数二进制最低位一定是 1
• 偶数二进制最低位一定是 0

 

4. 获取二进制位是1还是0

同样做 &运算，但是要把1移到需要知道的那个位上，运算后再反向移相同位，结果为1表示该二进制位为1，否则为0.

二进制仅含一个1的数去进行 & 运算，可以屏蔽掉 1以外的其他位的影响

 

5. 例题

例1：找出唯一成对的数

借助异或求解：1到1000这1000个数先求异或（假设数组中重复的数是k，此处k出现1次），再与1001数组求异或（k是重复数，在数组中出现2次，k ^ k = 0），因此最终结果会是 k。

import java.util.Random;

public class demo01 {
	public static void main(String[] args) {
		int N = 1001;
		
		// 1001个元素的数组
		int arr[] = new int[N];
		for(int i = 0; i < N-1;i++) {
			arr[i] = i + 1;
		}
		arr[N-1] = new Random().nextInt(N-1) + 1;
		
		// ======================================
		// 异或(不用辅助空间)
		int temp = 0;
		for(int i = 1; i < 1001;i++) {	// 1~1000异或
			temp ^= i;
		}
		for(int i = 0; i < N;i++) {		// 与数组异或
			temp ^= arr[i];
		}
		System.out.println(temp);
		System.out.println("==========");
		
		// ======================================
		// 借助辅助空间
		int[] helper = new int[N];
		for(int i = 0; i < N; i++) {
			helper[arr[i]]++;		// helper数组值用来计数，下标表示1~1000
		}
		for(int i = 0; i < N; i++) {
			if (helper[i] == 2) {
				System.out.println(i);
				break;
			}
		}
		System.out.println("==========");

		// ======================================
		// 借助辅助空间
		int sum = 0;
		for(int i = 0; i < N; i++) {
			sum += arr[i];
			sum -= i;
		}
		System.out.println(sum);
	}
}

 

例2：找出落单的数

直接对数组的数进行异或，成对的会被消去，最终留下落单的数

 

例3：二进制中1的个数

import java.util.Scanner;

public class demo02 {
	public static void main(String[] args) {
		// 输入一个整数
		Scanner sc = new Scanner(System.in);
		int N = sc.nextInt();
		System.out.println(Integer.toString(N,2));
		
		// ======================================
		// 方法一：令整数移位(int型对比32次)
		int count = 0;
		for(int i = 0; i < 32; i++) {
			if (((N >>> i) & 1) == 1)
				count++;
		}
		System.out.println(count);
		
		// ======================================
		// 方法二：比较每一位,看哪一位上是1(int型对比32次)
		count = 0;
		for(int i = 0; i < N; i++) {
			if ((N & (1 << i)) == (1 << i))
				count++;
		}
		System.out.println(count);
		
		// ======================================
		// 方法三：
		count = 0;
		while(N != 0) {
			N = ((N-1) & N);
			count++;
		}
		System.out.println(count);
	}
}

• 方法三中

  一个数 ( X - 1 ) & X 后可以消掉一个二进制形式上的 1 ，比如十进制的9，二进制为 1001， ( 9 - 1 ) = 1000，( 9 - 1 ) & 9 = 1000.

 

例4：是不是2的整数次方

若一个数是2的整数次方，说明其 二进制形式只有一个位上是1，其他位是0

 

例5：将整数的奇偶位互换

以8位为例分析：

public class demo04 {
	public static void main(String[] args) {
		int a = 6;
		int b = trans(a);
		System.out.println(a);
		System.out.println(b);
	}
	
	public static int trans(int a) {
		int odd = a & 0x55555555;	// 和0101 0101 0101...做与运算取出奇数位
		int even = a & 0xaaaaaaaa;	// 和1010 1010 1010...做与运算取出偶数位
		return (odd<<1)^(even>>1);
	}
}

 

例6：0~1间浮点实数的二进制表示

正整数转二进制：模2取余

小数转二进制：乘2取整

（计组里学的东西）

public class demo05 {
	public static void main(String[] args) {
		double num = 0.625;
		StringBuilder sb = new StringBuilder("0.");	// 长度为2了此时
		
		while(num > 0) {
			double temp = num * 2;	// 乘2取整
			if(temp >= 1) {
				sb.append("1");
				num = temp - 1;	// 减去正整数位上的1
			}else {
				sb.append("0");
				num = temp;
			}
			
			if(sb.length() > 34) {
				System.out.println("Error");
				return;
			}
		}
		
		System.out.println(sb.toString());
	}
}

 

例7：出现k次与出现1次

• 2个相同的2进制数做不进位加法，结果为0

  10个相同的10进制数做不进位加法，结果为0

  k个相同的k进制数做不进位加法，结果为0

• 任意进制互转

  Integer.toString(i, radix); 10进制转 radix 进制

  radix进制转10进制

• 不仅为加法

  对应位相加模 k

 

将数组中的数转为 k 进制，则做不进位加法后出现了 k 次的会变为 0.

public class demo06 {
	public static void main(String[] args) {
		int[] arr = {2, 2, 2, 9, 7, 7, 7, 3, 3, 3, 6, 6, 6, 0, 0, 0};
		int k = 3;
		int len = arr.length;
		
		// 将数组转为k进制数组
		char[][] kRadix = new char[len][];
		int maxLen = 0;	//记录最长的进制位
		for(int i = 0; i < len; i++) {
			// 将每个数字转为k进制，翻转，转为字符数组
			//（翻转的原因是使低位是对齐的，数的k进制转换后位数可能不同）
			kRadix[i] = new StringBuilder(Integer.toString(arr[i], k)).reverse().toString().toCharArray();
			if(kRadix[i].length > maxLen)
				maxLen = kRadix.length;
		}
		
		// 不进位加法
		int[] resArr = new int[maxLen];
		for(int i = 0; i < len; i++) {
			for (int j = 0; j < maxLen; j++) {
				if (j >= kRadix[i].length)
					resArr[j] += 0;
				else
					resArr[j] += (kRadix[i][j] - '0');
			}
		}
		
		// 从k进制转回10进制
		int res = 0;
		for(int i = 0; i < maxLen; i++) {
			res += (resArr[i] % k) * (int)(Math.pow(k, i));
		}
		System.out.println(res);
	}
}

 

关键知识点

• x ^ x = 0， x ^ 0 = x；
• k 个 k 进制进行不进位加法，结果为 0；
• 判断奇数偶数：x & 1 结果为1则为奇数，为0则为偶数；