听课笔记0001

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;
}