一. -1 转换成二进制数

    32位 11111111 11111111 11111111 11111111

    16位 11111111 11111111

    8位 11111111

    4位 1111


    第一步:绝对值化为你需要多少位表示的二进制

    第二步:各位取反,0变1,1变0

    第三步:最后面加1

二. 负数左移右移

操作数为正数：

    ① 负数的右移：需要保持数为负数，所以操作是对负数的二进制位左边补1。如果一直右移，最终会变成-1，即(-1)>>1是-1。

    ② 负数的左移：和整数左移一样，在负数的二进制位右边补0，一个数在左移的过程中会有正有负的情况，所以切记负数左移不          会特殊处理符号位。如果一直左移，最终会变成0。

操作数为负数：

    操作数为负数，取其补码。 4<<-2 <---> 4<<254

展开全部
1010
二进制和十进制的进位制度是相同的，只不32313133353236313431303231363533e58685e5aeb931333365666239过把逢十进一变成了逢二进一，比方说运算10的转换，我们可以先考虑10是2的几次方，结果就是2^3=8和2^4=16之间。所以它应该是一个四位的二进制数，其范围是0~15；
然后依次来决定各个位数的值，这四位数分别代表的值是2^3,2^2,2^1,2^0,很轻易就知道2^3+2^1=10。
所以最后的结果是1010。
扩展资料：
二进制是计算技术中广泛采用的一种数制。二进制数据是用0和1两个数码来表示的数。它的基数为2，进位规则是“逢二进一”，借位规则是“借一当二”。
由18世纪德国数理哲学大师莱布尼兹发现。当前的计算机系统使用的基本上是二进制系统，数据在计算机中主要是以补码的形式存储的。计算机中的二进制则是一个非常微小的开关，用“开”来表示1，“关”来表示0。
20世纪被称作第三次科技革命的重要标志之一的计算机的发明与应用，因为数字计算机只能识别和处理由‘0’.‘1’符号串组成的代码。
其运算模式正是二进制。19世纪爱尔兰逻辑学家乔治布尔对逻辑命题的思考过程转化为对符号"0''.''1''的某种代数演算，二进制是逢2进位的进位制。0、1是基本算符。因为它只使用0、1两个数字符号，非常简单方便，易于用电子方式实现。
十进制转二进制：
十进制整数转二进制数：“除以2取余，逆序排列”(除二取余法)

代码是整理得到的，自己的理解放在注释中。
#include <stdio.h>

const __uint64_t m1  = 0x5555555555555555; //binary: 0101...
const __uint64_t m2  = 0x3333333333333333; //binary: 00110011..
const __uint64_t m4  = 0x0f0f0f0f0f0f0f0f; //binary:  4 zeros,  4 ones ...
const __uint64_t m8  = 0x00ff00ff00ff00ff; //binary:  8 zeros,  8 ones ...
const __uint64_t m16 = 0x0000ffff0000ffff; //binary: 16 zeros, 16 ones ...
const __uint64_t m32 = 0x00000000ffffffff; //binary: 32 zeros, 32 ones

//计算64位整数里有多少个1
//使用分治思想，按组找到1，把组内1的个数加起来，组的个数由2,4,8,16,32，64。最终把1的个数存到了64位组。
int popcount64a(__uint64_t x)
{
    x = (x & m1 ) + ((x >>  1) & m1 ); //put count of each  2 bits into those  2 bits 
    x = (x & m2 ) + ((x >>  2) & m2 ); //put count of each  4 bits into those  4 bits 
    x = (x & m4 ) + ((x >>  4) & m4 ); //put count of each  8 bits into those  8 bits 
    x = (x & m8 ) + ((x >>  8) & m8 ); //put count of each 16 bits into those 16 bits 
    x = (x & m16) + ((x >> 16) & m16); //put count of each 32 bits into those 32 bits 
    x = (x & m32) + ((x >> 32) & m32); //put count of each 64 bits into those 64 bits 
    return x;
}

void main()
{
	__uint64_t i = 8888;//10001010111000
	int count;
	count = popcount64a(i);
	printf("%ldcount is %d", i, count);
}

int count_bit_one(int n)
{
	int count = 0;

	while (n)
	{
/*
	二进制加法进位为取反操作。
	二进制数a从右边低位开始数，
	遇到第一个1(xxx100...)是b(xxx011...)加1的结果，
	a&b(xxx000...)消除了最低位的1，计算消除次数。
*/
		++count;
		n = n & (n - 1); 
	}

	return count;
}

//对于一个字节（8bit）的变量，求其二进制表示中”1″的个数，要求算法执行效率尽可能的高
int num_a(unsigned char c) //方法a
{
	static unsigned char arr[] =
	{ 1, 2, 4, 8, 16, 32, 64, 128 };
	int ret = 0;
	for (int i = 0; i < 8; i++)
	{
		if (arr[i] & c)
		{
			ret++;
		}
	}
	return ret;
}
void num_b_pre() //使用方法a产生方法b需要的数据
{
	for (int i = 0; i < 256; i++)
	{
		if (i % 16 == 0)
		{
			printf("/n");
		}
		printf("%d, ", num_a(i));
	}
}
int num_b(unsigned char c) //查表法效率最高
{
	static unsigned char arr[] =
	{ 0, 1, 1, 2, 1, 2, 2, 3, 1, 2, 2, 3, 2, 3, 3, 4, 1, 2, 2, 3, 2, 3, 3, 4,
			2, 3, 3, 4, 3, 4, 4, 5, 1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4,
			4, 5, 2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6, 1, 2, 2, 3,
			2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5, 2, 3, 3, 4, 3, 4, 4, 5, 3, 4,
			4, 5, 4, 5, 5, 6, 2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,
			3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7, 1, 2, 2, 3, 2, 3,
			3, 4, 2, 3, 3, 4, 3, 4, 4, 5, 2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5,
			4, 5, 5, 6, 2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6, 3, 4,
			4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7, 2, 3, 3, 4, 3, 4, 4, 5,
			3, 4, 4, 5, 4, 5, 5, 6, 3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6,
			6, 7, 3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7, 4, 5, 5, 6,
			5, 6, 6, 7, 5, 6, 6, 7, 6, 7, 7, 8, };
	return arr[c];
}
//长整型的二进制表示中有多少个"1″
int numDWORD(unsigned long d)
{
	return num_b(d & 0xff) + num_b((d >> 8) & 0xff);
}
//两个长整型，二进制表示中有多少位是不同的
int diffDWORD(unsigned long a, unsigned long b)
{
	return numDWORD(a|b) - numDWORD(a&b);
}