位运算

不用任何比较判断找出两个数中较大的数

题目

给定两个32位整数a和b，返回a和b中较大的数。
要求：不用任何比较判断

代码

#include<iostream>
#include<algorithm>

using namespace std;

int flip(int n)
{
	return n ^ 1;
}

int sign(int n)
{
	return flip((n >> 31) & 1);
}

int getMax(int a, int b)
{
	int c = a - b;
	int scA = sign(c);
	int scB = flip(scA);
	return a * scA + b * scB;
}//此方法无法避免溢出的问题

int getMax2(int a, int b)
{
	int c = a - b;
	int sa = sign(a);
	int sb = sign(b);
	int sc = sign(c);
	int difSab = sa ^ sb;
	int sameSab = flip(difSab);
	int returnA = difSab * sa + sameSab * sc;
	int returnB = flip(returnA);
	return a * returnA + b * returnB;
}

int main()
{
	int a, b;
	cin >> a >> b;
	int res = getMax(a, b);
	cout << res << endl;
	getchar();
	return 0;
}

只用位运算不用算术运算实现整数的加减乘除运算

题目

给定两个32位整数a和b，可正、可负、可0。不能使用算术运算符，分别实现a和a的加减乘除运算。
要求：如果给定的a和b执行加减乘除的某些救过本来就会导致数据的溢出，那么你实现的函数不必对这些结果负责

代码

#include<iostream>
using namespace std;

/*位加法*/
int bitAdd(int a, int b)
{
	int sum = a;
	while (b != 0)
	{
		sum = a ^ b;
		b = (a & b) << 1;
		a = sum;
	}
	return sum;
}

/*位减法*/
int negNum(int n)
{
	return bitAdd(~n, 1);
}
int bitMinus(int a, int b)
{
	return bitAdd(a, negNum(b));
}

/*位乘法*/
int bitMulti(int a, int b)
{
	int res = 0;
	while (b != 0)
	{
		if ((b & 1) != 0)
		{
			res = bitAdd(res, a);
		}
		a <<= 1;
		b >>= 1;
	}
	return res;
}

/*位除法*/
int isNeg(int n)
{
	return n < 0;
}

int bitDiv(int a, int b)
{
	int x = isNeg(a) ? negNum(a) : a;
	int y = isNeg(b) ? negNum(b) : b;
	int res = 0;
	for (int i = 31; i > -1; i = bitMinus(i, 1))
	{
		if ((x >> i) >= y)
		{
			res |= (1 << i);
			x = bitMinus(x, y << i);
		}
	}
	return isNeg(a) ^ isNeg(b) ? negNum(res) : res;
}//a little 

int main()
{
	int a, b;
	cin >> a >> b;
	int res1 = bitAdd(a, b);
	int res2 = bitMinus(a, b);
	int res3 = bitMulti(a, b);
	int res4 = bitDiv(a, b);
	cout << res1 << " " << res2 << endl;
	cout << res3 << " " << res4 << endl;
	getchar();
	return 0;
}

整数的二进制表达中有多少个1

题目

给定一个32位整数n，可为0，可为正也可为负，返回该整数二进制表达式中1的个数
按照书中的方法实现了四种方法，第四种方式思路有点模糊，有清楚的大佬可以给点指示

代码

#include<iostream>
#include<algorithm>
using namespace std;

int count1(int n)
{
	int res = 0;
	while (n != 0)
	{
		if (n & 1 != 0)
			res++;
		n >>= 1;
	}
	return res;
}

int count2(int n)
{
	int res = 0;
	while (n != 0)
	{
		n &= (n - 1);
		res++;
	}
	return res;
}

int count3(int n)
{
	int res = 0;
	while (n != 0)
	{
		n -= n & (~n + 1);
		res++;
	}
	return res;
}

int count4(int n)
{
	n = (n & 0x55555555) + ((n >> 1) & 0x55555555);  //每两个bit成一组1的数量状况
	n = (n & 0x33333333) + ((n >> 2) & 0x33333333);  //4个bit位成一组的1的数量状况
	n = (n & 0x0f0f0f0f) + ((n >> 4) & 0x0f0f0f0f);  //8个bit位成一组的1的数量状况
	n = (n & 0x00ff00ff) + ((n >> 8) & 0x00ff00ff);  //16个bit位成一组的1的数量状况
	n = (n & 0x0000ffff) + ((n >> 16) & 0x0000ffff);  //32个bit位成一组的1的数量状况
	return n;
}

int main()
{
	int num;
	cin >> num;
	int res1 = count1(num);
	int res2 = count2(num);
	int res3 = count3(num);
	int res4 = count4(num);
	cout << res1 << " " << res2 << endl;
	cout << res3 << " " << res4 << endl;
	getchar();
	return 0;
}

在其他数都出现偶数次的数组中找到出现奇数次的数

题目

给定一个整形数组arr，其中只有一个数出现了奇数次，其他的数出现了偶数次，打印这个数。
进阶：有两个数出现了奇数次，其他的数都出现了偶数次，打印这两个数。
要求：时间复杂度为O(N)，额外空间复杂度为O(1).

代码

#include<iostream>
#include<string>
#include<algorithm>
using namespace std;

int numOdd(int* arr, int len)
{
	int res = arr[0];
	for (int i = 1; i < len; i++)
		res ^= arr[i];
	return res;
}

void numOdd2(int *arr, int len)
{
	int res = arr[0];
	for (int i = 1; i < len; i++)
		res ^= arr[i];
	 int i;
	 for (i = 0; i < 32; i++)
	 {
		 if ((res >> i) & 1 != 0)
			 break;
	 }
	 int tmp = i;
	 int num1 = 0;
	 int num2 = 0;
	 for (int i = 0; i < len; i++)
	 {
		 if (((arr[i] >> tmp) & 1) == 0)  //注意条件中括号的使用，否则会出错
		 {
			 if (num1 == 0)
				 num1 = arr[i];
			 else
				 num1 ^= arr[i];
		 }
		 else
		 {
			 if (num2 == 0)
				 num2 = arr[i];
			 else
				 num2 ^= arr[i];
		 }
	 }
	 /*int* resF = new int[2];
	 resF[0] = num1;
	 resF[1] = num2;
	 return resF;*/
	 cout << to_string(num1) + " " + to_string(num2) << endl;
}
/*上面的解法稍微有点繁琐，书中给出的解法如下*/
void numOdd3(int* arr, int len)
{
	int eO = 0;
	int eOhasOne = 0;
	for (int i = 0; i < len; i++)
		eO ^= arr[i];
	int eRightOne = eO & (~eO + 1);
	for (int i = 0; i < len; i++)
	{
		if ((arr[i] & eRightOne != 0))
			eOhasOne ^= arr[i];
	}
	cout << to_string(eOhasOne) + " " + to_string(eO ^ eOhasOne) << endl;
}

int main()
{
	int len;
	cin >> len;
	int* input = new int[len];
	for (int i = 0; i < len; i++)
		cin >> input[i];
	//int res = numOdd(input, len);
	//cout << res << endl;
	numOdd3(input, len);
	numOdd2(input, len);
	getchar();
	return 0;
}

在其他数都出现k次的数组中找到只出现一次的数

题目

给定一个整型数组arr和一个大于1的整数k。已知arr中只有1个数只出现了1次，其他的数都出现了k次，请返回只出现了1次的数。
要求：时间复杂度为O(N)，额外空间复杂度为O(1)。

代码

#include<iostream>
using namespace std;

/*两个七进制数a和b,在i位上无进位相加的结果是(a(i)+b(i))%7。同理，
k进制的两个数c和d，在i位上无进位相加的结果就是(c(i)+d(i))%k。那么，
如果k个相同的k进制数进行无进位相加，相加的结果一定是每一位上都是0的k进制数。*/
int getNumFromKSysNum(int* eO, int k, int len)
{
	int res = 0;
	for (int i = len - 1; i >= 0; i--)
		res = res * k + eO[i];
	return res;
}

int* getKSysNumFromNum(int value, int k)
{
	int* res = new int[32];
	for (int i = 0; i < 32; i++)
		res[i] = 0;
	int index = 0;
	while (value != 0)
	{
		res[index++] = value % k;
		value = value / k;
	}
	return res;
}

void setExclusiveOr(int* eO, int value, int k)
{
	int* curKSysNum = getKSysNumFromNum(value, k);
	for (int i = 0; i < 32; i++)
		eO[i] = (eO[i] + curKSysNum[i]) % k;
}

int onceNum(int* arr, int k, int len)
{
	int* eO = new int[32];
	for (int i = 0; i < len; i++)
		setExclusiveOr(eO, arr[i], k);
	int res = getNumFromKSysNum(eO, k, len);
	return res;
}

int main()
{
	int len, k;
	cin >> len >> k;
	int* in = new int[len];
	for (int i = 0; i < len; i++)
		cin >> in[i];
	int res = onceNum(in, k, len);
	cout << res << endl;
	getchar();
	return 0;
}

后记

这一周前几天给笔记本换了个固态，装了个双系统，踩了各种坑，从周一装到了今天勉勉强强搞好了，希望近期能把这本书快速刷完，后面要再学一些新的内容。否则这个架势春招怕是没啥戏了感觉。后面还要准备论文，还想去实习，老师这边……哎，有好多要学的内容啊，有点乱了，还是得规划下进度，要不然太坑