位操作以及与位操作有关的面试题

最新推荐文章于 2022-04-03 00:49:03 发布

insistGoGo

最新推荐文章于 2022-04-03 00:49:03 发布

阅读量2.3k

点赞数

分类专栏：面试题

本文链接：https://blog.csdn.net/insistGoGo/article/details/9204125

版权

面试题专栏收录该内容

108 篇文章 1 订阅

订阅专栏

参考博客：MoreWindows

Starting....

前提：

（1）计算机中数据是按照补码存储

（2）位运算只针对整型或字符型数据，如char, short, int, long, unsigned

存储：

（1）在各种语言中，没有专门存储位的存储结构，常使用字符、整形数据存

（2）执行位操作时，应该针对整个存储结构单元操作

各种操作：

与操作

规则：全1为1

用途

（1）清零：欲对一个字节清零，通常是“与”上0x00 。

（2）判断某一个位置是否为1，就让对应位置的二进制位变成1

unsigned int Flag = 1;//判断最低位是否为1

if (n & Flag)
{
	//...
}

（3）取出一个数中的某些指定位，把对应位置为1，其他为0

举例：

或操作

规则：有1则1

用途：置 1，欲对某些位置1，只需在相应位上“或”1便可

非操作

规则：按位取反

用途：某些位置不变，其他边1或0

举例：一整数a ，想使它最低一位为0，而其它位不变。

方法：a=a& ~1

注意：用来表示最低位为0，其他位置全为1 的数应该使用对1取反。

这是因为，如果使用0xfffe，在16位机器是正确的，但是在32位机器上是不正确的。

对于16位机，0xfffe表示11111111 11111110。

对于32位机，0xfffe表示00000000 00000000 11111111 11111110。

异或操作

规则：相同为0，相反为1

思想：与1相^，使特定位翻转，与0相^，保留原值

用途

（1）使指定位翻转：使一个字节的低四位翻转，只需异或0x0f

（2）自身清零：一个整型或字符型数据“异或”自身,便清零

左移(<<)

规则 : 将二进位顺序左移,空位补0,移出位丢弃

举例：

若干说明

（1）无符号数的左移：

有效情况：在该数左移，被移出的数字中没有1时，左移1位,相当于乘2；左移n 位,则乘2n。

（2）有符号的正数：

有效情况：在该数左移，被移出的数字中没有1时且移出后的最高位仍为0时，左移1位,相当于乘2；左移n 位,则乘2n。

（3）有符号的负数：

有效情况：在该数左移，被移出的数字全为1,且移出后的最高位仍为1时，左移1位,相当于乘2；左移n 位,则乘2n。

无效情况：对于其他不满足上述两种情况的有符号数，数据左移后会产生溢出，那就不能简单地用乘2 来计算了。

举例：

应用：

（1）原数乘上2的指数幂

（2）与其他运算符结合使用

右移(>>)

规则 :

（1）右移运算相当于除2运算。在右移移出的位中不能包含1时，右移n 位，则除以2n

（2）将二进位顺序右移,左端空位补0或1,移出位丢弃

说明：执行右移操作时，尽量不针对负数进行操作

（1）右移运算的结果与操作数的符号有关

（2）右移高位补0或1 和编译环境有关系

举例：

建议

（1）只对正整数或无符号数进行位运算

（2）移位时，有符号数会带着符号移位，容易出意外

（3）不同长度的数据进行位运算时，系统将两数按照右对齐，长度短的那个左侧补0或1

一些面试题
判断奇偶

思想：根据二进制最后一位是1 还是 0可以判断奇偶

nNum & 1 = 1 : nNum为奇数
nNum & 1 = 0 : nNum为偶数

代码

#include <iostream>
#include <assert.h>
using namespace std;

void IsOddOrEven(int nNum)
{
	if (nNum & 1)
	{
		cout<<"Odd!"<<endl; 
	}
	else
	{
		cout<<"Even!"<<endl; 
	}
}

int main()
{
	int nNum = 12;
	IsOddOrEven(nNum);
	nNum = -12;
	IsOddOrEven(nNum);
	nNum = -11;
	IsOddOrEven(nNum);
	nNum = 11;
	IsOddOrEven(nNum);
	system("pause");
	return 1;
}

找到其最接近的偶数或奇数

思想：把nNum最后一位置为1 或 0

找到其最接近的奇数,最后一位强制为1：num | 1
找到其最接近的偶数，最后一位强制为0： (num | 1 )- 1

交换两数

思想：利用异或的性质 a ^ a = 0 以及异或运算符的交换律 a^b = b^a

nNumOne = nNumOne ^ nNumTwo;
nNumTwo = nNumOne ^ nNumTwo; 
nNumOne = nNumOne ^ nNumTwo;

分析：

在执行nNumOne（新数） = nNumOne（原数） ^ nNumTwo（原数）;后，

nNumTwo =nNumOne（新数） ^ nNumTwo（原数）

=nNumOne（原数） ^ nNumTwo（原数）^nNumTwo（原数）

= nNumOne（原数）

nNumOne=nNumOne（新数） ^nNumTwo（新数）

= nNumOne（原数） ^ nNumTwo （原数）^nNumOne（原数）

= nNumTwo （原数）

代码：

#include <iostream>
#include <assert.h>
using namespace std;

void Swap(int& nNumOne,int& nNumTwo)
{
	if (nNumOne != nNumTwo)
	{
		nNumOne = nNumOne ^ nNumTwo;
		nNumTwo = nNumOne ^ nNumTwo; 
		nNumOne = nNumOne ^ nNumTwo;	
	}
}
int main()
{
	int nNumOne = 12;
	int nNumTwo = 2;
	cout<<"nNumOne: "<<nNumOne<<endl;
	cout<<"nNumTwo: "<<nNumTwo<<endl;
	Swap(nNumOne,nNumTwo);
	cout<<"nNumOne: "<<nNumOne<<endl;
	cout<<"nNumTwo: "<<nNumTwo<<endl;
	system("pause");
	return 1;
}

拓展：仅仅使用加减符号，就交换两数

分析：

在执行nNumOne（新数） = nNumOne（原数） + nNumTwo（原数）;后，

nNumTwo =nNumOne（新数） - nNumTwo（原数）

=nNumOne（原数） + nNumTwo（原数）-nNumTwo（原数）

= nNumOne（原数）

nNumOne=nNumOne（新数） -nNumTwo（新数）

= nNumOne（原数） + nNumTwo （原数）-nNumOne（原数）

= nNumTwo （原数）

代码：

void Swap(int& nNumOne,int& nNumTwo)
{
	if (nNumOne != nNumTwo)
	{
		nNumOne = nNumOne + nNumTwo;
		nNumTwo = nNumOne - nNumTwo; 
		nNumOne = nNumOne - nNumTwo;	
	}
}

正负数互换

思路：取反、加1

~nNum + 1

代码：

#include <iostream>
#include <assert.h>
using namespace std;

int SymbolicExchange(int nNum)
{
	return ~nNum + 1;
}

int main()
{
	int nNum = 12;
	cout<<"nNum: "<<nNum<<endl;
	cout<<"nNum: "<<SymbolicExchange(nNum)<<endl;
	nNum = -12;
	cout<<"nNum: "<<nNum<<endl;
	cout<<"nNum: "<<SymbolicExchange(nNum)<<endl;
	system("pause");
	return 1;
}

求绝对值

思路：负数取反、加1，整数不变

nNum >> 31 = 1 : nNum是负数
nNum >> 31 = 0 : nNum是正数

代码：

#include <iostream>
#include <assert.h>
using namespace std;

int SymbolicExchange(int nNum)
{
	if (nNum >> 31)
	{
		return ~nNum + 1;
	}
	else
	{
		return nNum;
	}
	
}

int main()
{
	int nNum = 12;
	cout<<"nNum: "<<nNum<<endl;
	cout<<"nNum: "<<SymbolicExchange(nNum)<<endl;
	nNum = -12;
	cout<<"nNum: "<<nNum<<endl;
	cout<<"nNum: "<<SymbolicExchange(nNum)<<endl;
	system("pause");
	return 1;
}

是否包含所有关键字

思路：

1、使用一个整形变量判断包含哪个关键字

包含第几个关键字(x_thKeys)，则把该关键字置1
nKeysInfor = 1 << (x_thKeys - 1);

2、判断一个整形变量是否包含所有关键字

nKeysNum表示：关键字个数

判断整形变量nKeysInfor是否包含所有关键字
nFlag = ~(~0 << nKeysNum)
if (nFlag == (nKeysInfor & nFlag))

找出最低位1代表的数

说明：6（0110）最低位1代表的数是2。

我们的意图是把除了最低位的1以外的1置0。

思路：

nNum & (-nNum) 
或者
nNum & (~nNum + 1)

分析：用例子说明

假设nNum = 24 （0001 1000）

则~nNum = 1110 0111，

~nNum + 1 = 1110 1000

而 nNum = 0001 1000

则nNum & (~nNum + 1) = 0000 1000

假设nNum最低位的1的位置为Pos，也就是说，~nNum + 1 使最高位到Pos + 1与nNum中该位置的0和1是相反的，之后相与 = 0。同时使变量的Pos位置为1，0 ~ Pos - 1之间的二进制位为0。

用途：

（1）可以求出最后一个1代表的数

nNum = 24 （0001 1000）

最后一个1代表的数：8

（2）可以使一个数的最后一个1置为0。

（最后一个1的位置可以找到，之后把该位置变成0其他位置为1，在进行&就可以得到）

（3）如果循环和二进制中1的个数有关，则可以每次循环就把最低位的1置为0。

可以用（1）中的方法做

代码：

#include <iostream>
#include <assert.h>
using namespace std;

int NumOfLastBit(int nNum)
{
	assert(nNum != 0);
	return nNum & (~nNum + 1);
}

int main()
{
	int nNum = 12;//0000 1100
	cout<<"nNum: "<<nNum<<endl;
	cout<<"nNum: "<<NumOfLastBit(nNum)<<endl;
	nNum = -8; //1111 1000
	cout<<"nNum: "<<nNum<<endl;
	cout<<"nNum: "<<NumOfLastBit(nNum)<<endl;
	system("pause");
	return 1;
}

把最低位的1置0

说明：24（0001 1000）把最低位的1置0 = 16（0001 0000）

方法：

n & n - 1

分析：

假设n最低位1的位置为Pos，

则，n - 1 相当于把最低位Pos变成0，且区间（Pos-1， 0）的位置变成1

而，n在Pos位置是1，且区间（Pos-1， 0）是0，相与后，区间（Pos - 0）就为0了。

也就是说，就把对低位的1置为0了。

作用：如果循环和二进制中1的个数有关，则可以每次循环就把最低位的1置为0。

二进制中1的个数

思路：分析见点击打开链接

方法：给出两个比较笨的方法和一个常用方法

（1）只求解正数包含1的个数的方法

int OneNum(int n)
{
	int nCount = 0;
	while (n)
	{
		if ((n & 1) == 1)
		{
			nCount++;
		}
		n >>= 1;
	}
	return nCount;
}

说明，对于负数，右移1位时，高位补1，此时会导致无限循环。

（2）正负数都可以求解的方法

int OneNum(int n)
{
	int nCount = 0;
	unsigned int Flag = 1;
	while (Flag)
	{
		if (n & Flag)
		{
			nCount++;
		}
		Flag <<= 1;
	}
	return nCount;
}

说明，每次循环， Flag 只有一个位置为1，用来检测n的对应位置是够为1.

（3）常用方法

#include <iostream>
#include <assert.h>
using namespace std;

int OneNum(int nNum)
{
	int nCount = 0;
	while (nNum)
	{
		nNum &= (nNum - 1);
		nCount++; 
	}
	return nCount;
}

int main()
{
	int nNum = 12;//0000 1100
	cout<<"nNum: "<<OneNum(nNum)<<endl;//2
	nNum = -8; //11111111 11111111 11111111 11111000
	cout<<"nNum: "<<OneNum(nNum)<<endl;//29
	system("pause");
	return 1;
}

判断一个整数是不是2的整数次方

方法：等价于这个整数的二进制位中是否只有一个1.

if (n & (n - 1))
{
	//n的二进制中含有多个1
}

输入整数m和n，求需要改变多少m的二进制位，才能得到n

举例：6 : 1010, 8 : 1000 ,此时需要改变一位就可以让6变成8

方法：

（1）直接对m和n异或，得到t

（2）求异或的结果t的二进制中1的个数。

求N!的二进制表示中最低位1的位置（编程之美-2.2-不要被阶乘吓倒）

举例：6! = 720 = 1011010000, 最低位1的位置为5.

利用一个公式：

N!的二进制表示中最低位1的位置等于 N - N中1的个数 +１.

举例：N = 6 = 0110

6!最低位1的位置为6 - 2 + 1 = 5。

不用加减乘除做加法

方法：对于a+b = c

使用异或模拟：无进位的加法

使用与检测是否有进位以及进位的位置。

a = 15 （0000 1111）

b = 6 (0000 0110)

无进位加法： nEor = a ^ b = (0000 1001)

是否有进位： a & b = (0000 0110)

进位位置：（a & b）<< 1 = (0000 1100)

之后转化为无进位的结果和有进位结果相加：

无进位的结果：0000 1001 ^ 0000 1100 = 0000 0101;

是否有进位：（a & b）= (0000 1000)
进位位置：（a & b）<< 1 = (0001 0000)

。。。

根据上面的例子可以看出，每执行一次无进位加法的结果和进位异或：

（1）都相当于把一个进位加到无进位加法的结果上了。

（2）（a & b）<< 1 或者a & b中的1的个数（也就是进位个数）都会少一个。

代码：

#include <iostream>
#include <assert.h>
using namespace std;

int Add(int nLeft,int nRight)
{
	int nEor = nLeft ^ nRight; //执行无进位的相加
	int nAnd = (nLeft & nRight) << 1; //记录进位位置，顺便还可以检测是否有进位（是否有1）

	while (nAnd)/*有进位，则执行，每次可以看做进位和不进位的数相加*/
	{
		
		nLeft = nEor;
		nRight = nAnd;

		nEor = nLeft ^ nRight; 
		nAnd = (nLeft & nRight) << 1;
	}
	/*每执行一次循环，nEor会加上一个进位，nAnd中的1（进位）总是少一个，直到没有1（进位）位置*/
	return nEor;
}

int main()
{
	/*int nLeft = 15;
	int nRight = 6;*/
	int nLeft = 15;
	int nRight = 15;
	cout<<Add(nLeft,nRight)<<endl;	
	system("pause");
	return 1;
}