1.
-1的补码是11111111,-128的补码是10000000
2.扩充
(1)对于有符号的数 扩充其符号位
(2)对于无符号的数,扩充0(数字是无符号的数,而不是转为无符号的数)
如下图所示
3.sizeof(int )返回值是一个无符号整形,若有这种情况 则不打印
for(int i=-4;i<sizeof(int);i++){
printf("\n");
}
因为int 于与 unsigned int 类型不一致 unsigned int 的优先级较高 -4转为unsigned的值特别大
4.
不得不说 这个题是真的牛逼 100转变为二进制位:0110 0100
200-------------------->:1100 1000 (char 类型)
它们是有符号的 所以100转为Int是 0000 0000 0110 0100
200--------->: 1111 1111 1100 1000
运算结果:——————————————————————————
0000 0000 0010 110 0--->300
同理 无符号前面补0 c=a+b c仍然是一个char类型 运算时取低位8位 c->44 a+b=300(第二空)
5. 此图我愿称之为神图
6.
转换到高的单位时应该判断自身 而不是判断单位 如:
(signed short)c------>由于c本身是有符号数 所以扩充时应变为1111 1111 1000 0000
7 转换规则
8.按位与---->二进制 只有1 1 情况才为1
1.按位与在进行计算的时候,是按照补码的顺序进行的
2.判断是否为偶数 ,学到了一个新方法 ,
原来:if(i%2==0)
现在:if((i&1)==0)==>偶数
必须加括号 因为==的优先级高于&
3.位运算有以下三个功能(或者判断是否能被某个值整除)
如能被2整除,则最后一位是0 能被4整除 最后两位是00 能被8整除 最后三位是000
if(( i & 0x07)==0)===>能被8整除
4。逻辑与是简介与,在进行计算的时候截断,而位与在进行运算的时候不截断
5,位或可以设置数值位为1
7.两种写法等价
8.异或--->相同为0 相异为1
#include <stdio.h>
#include<iostream>
#include <math.h>
using namespace std;
//判断数的二进制数中含有一的个数
int get_1_num(int x) {
int num = 0;
while (x != 0) {
x &= (x - 1);//每次和比自己小一个数的数相与 1的值少有个 直到最后一的值为0
num++;
}
return num;
}
int main() {
int x = 0x0;
int t = get_1_num(x);
cout << "x中含有的二进制个数为:" <<t<< endl;
}
2.这是第二种方法
#include <stdio.h>
#include<iostream>
#include <math.h>
using namespace std;
//判断数的二进制数中含有一的个数
//int get_1_num(int x) {
// int num = 0;
// while (x != 0) {
// x &= (x - 1);//每次和比自己小一个数的数相与 1的值少有个 直到最后一的值为0
// num++;
// }
// return num;
//}
int get_1_num(unsigned int x) {
int i = 0, num ;
num = sizeof(x) * 2;
while (num != 0) {
if (x & (0x01)) {
i++;
}
x >>= 1;
num--;
}
return i;
}
int main() {
unsigned int x = 0x0;
int t = get_1_num(x);
cout << "x中含有的二进制个数为:" <<t<< endl;
}
3.使用查表法计算x的二进制数中含有一的个数
在计算式 注意一下几个问题
1.算下来为字符 需要减‘0’
2.x&(0x01)是为了计算x的数值
3 一个字节中含有8位 8/4=2
因此 sizeof(x)*2
4.
此写法等同于
3.耶斯莫拉 今天的一点小成就
打印数的二进制位
#include<iostream>
using namespace std;
//打印一个数的二进制数
void PrintBinary(int x) {
int n = sizeof(x) * 8;
for (int i = 1; i <= n; i++) {
if (x & (0x80000000)) {
cout << "1";
}
else cout << "0";
if (i % 8 == 0) {
cout << endl;
}
if (i % 4 == 0) {
cout << " ";
}
x <<= 1;
}
}
int main() {
int x = 0x12345678;
PrintBinary(x);
}
4。异或是位运算中最重要的一个 主要有以下几个功能
1.整形的范围为21亿多
2.递归调用过程
3.用循环写斐波那契数列 还是有点不太熟悉这个算法
4.
#include<iostream>
using namespace std;
int maxArea(int* height, int heightSize) {
int** p = new int* [heightSize];
int max = 0;
for (int i = 0; i < heightSize; ++i)
{
p[i] = new int[heightSize];
for (int j = 0; j < heightSize; ++j)
{
int t = height[i] < height[j] ? height[i] : height[j];
p[i][j] = (j - i) * t;
if (p[i][j] > max) {
max = p[i][j];
}
}
}
return max;
}
int main() {
int height[] = { 1,8,6,2,5,4,8,3,7 };
const int heightSize = sizeof(height) / sizeof(height[0]);
cout << "盛水的最大容量为:" << maxArea(height, heightSize) << endl;;
}
2.其实此题的重点在于要动态开辟一个数组
int **p = new int*[m]; //m行n列型
for (i = 0; i < m; ++i) {
p[i] = new int[n];
for (j = 0; j < n; ++j)
scanf ("%d",&p[i][j]);
}
3.递归打印一个数组
void Print_ar(int* arr, int n) {
if (n <= 0) return ;
else {
Print_ar(arr, n - 1);
cout << arr[n - 1] << "\t";
}
}
4.二分查询 有一个更加清楚的认知 while循环中要有mid =(left+right)/2;
int Index(int* arr, int n, int key) {
int left = 0, right = n - 1;
while (left <= right)
{
int mid = (left + right) / 2;
if (arr[mid] == key) {
return mid;
}
else if (arr[mid] < key) left = mid + 1;
else {
right = mid - 1;
}
}
}
4.递归算法给值找下标
int index(int* arr, int n, int key) {
if (n <= 0) return -1;
if (arr[n - 1] != key) {
index(arr, n - 1, key);
}
else return n;
}
5.二分查询递归算法
//二分查找的递归算法
int index(int* arr, int key,int left,int right) {
int mid=0;
int pos = -1;
if (left <= right) {
mid = (left + right) / 2;
}
if (arr == NULL) return -1;
else if (arr[mid] == key) pos= mid;
else if(arr[mid] > key) {
pos=index(arr, key, mid + 1, right);
}
else {
pos=index(arr, key, left, mid -1);
}
return pos;
}