任何进制都没有他的本身：因为他们是从0开始的
10进制:
0 1 2 3 4 5 6 7 8 9 10 11
2进制:
0 1 10 11 100 101 110 111 1000
8进制：
0 1 2 3 4 5 6 7 10 11 12 13 14 15 16 17 20
16进制：
0 1 2 3 4 5 6 7 8 9 A B C D E F
10 11 12 13 14 15 16 17 18 19 1A
1B 1C 1D 1E 1F 20 21 22 23 24 25（1）10进制转R进制（任意进制的意思）：采用除R取余法
如果转成10进制，就除以10
如果转成2进制，就除以2
易错点：从后往前读
（2）R进制转10进制：按权展开
所谓权就是：主要看R进制，R进制如果是10进制，那么权就是10的多少次方，如果R进制是2进制，那么权就是2的多少次方。（记得从低位开始）
注意：任何进制的0次方都是1
简便方法：2进制转10进制
例子：1010 转成10进制
1 0 1 0
8 4 2 1
将有1 的地方对应的数加起来 得到：8+2=10
假设是6位2进制数：101010
1 0 1 0 1 0
32 16 8 4 2 1
对应的1加起来：32+8+2=42
1、将定义1-F的16进制对于的数组记忆下来
#include<bits/stdc++.h>
using namespace std;
string t[16]={"0000","0001","0010","0011","0100","0101","0110","0111","1000","1001","1010","1011","1100","1101","1110","1111"};
int main(){string s,r;cin>>s;int x;for(int i=0;i<s.size();i++){if(isdigit(s[i])){x=s[i]-'0';}else{x=s[i]-'A'+10;}r=r+t[x];}while(r[0]=='0'){r.erase(0,1);}if(r==""){cout<<0;}else{cout<<r;}
}
将以下的二进制数转换为八进制数：
将以下的二进制数转换为十六进制数：
将以下的八进制数转换为二进制数：
将以下的十六进制数转换为二进制数：
提示：
注意：对于二进制、八进制和十六进制的转换，可能存在多种不同的表示方法（例如前置零），但这些答案都是基于标准的转换方法得到的。
祝你学习愉快！
思路：任何进制的转换函数
1、定义一个数组
2、采用while获取获取值不为0
3、取出对应进制的余数
4、计数
5、得到对应进制的商
#include<bits/stdc++.h>
using namespace std;bool huiwen(int n,int d){bool r=true;int k=0;int a[1000]={0};while(n!=0){a[k]=n%d;k++;n=n/d;}for(int i=0;i<k/2;i++){if(a[i]!=a[k-i-1]){r=false;break;}}return r;
}
int main(){int a[110],n;cin>>n;for(int i=0;i<n;i++){cin>>a[i];if(huiwen(a[i],10)==false&&(huiwen(a[i],16)==true)||(huiwen(a[i],2)==true)){cout<<a[i]<<endl;}} return 0;
}
int类型数值范围：2 * 10的9次方（大概可以表示10位数）
long long 数值范围：9 * 10的18次方（大概可以表示的是19位数）
为什么要使用高精度运算？
因为运算数字已经超出了标准类型所能承载的最大限度，所以只能用高精度运算进行计算，同样的高精度运算也叫做大整数运算
高精度运算步骤：
高精度加法运算：
1、两个字符串读入，三个数组
2、将字符串翻转，逆序传入数组
3、遍历数组，进行加法运算
4、遍历数组，处理进位
5、处理前导0
6、倒序输出
#include <iostream>
#include <string>
#include <algorithm>
using namespace std;
//1、定义两个字符串，用于输入高精度整数
string s1,s2;
//2、三个数组
const int MAX_SIZE = 250;//定义常数
int a1[MAX_SIZE],a2[MAX_SIZE],a3[MAX_SIZE];
int main()
{cin>>s1>>s2;//4、存入数组 for(int i=0; i<s1.size(); i++){a1[i] = s1[s1.size()-i-1] - '0';}for(int i=0; i<s2.size(); i++){a2[i] = s2[s2.size()-i-1] - '0';}//5、相加 int carry = 0;for(int i=0; i<MAX_SIZE; i++){a3[i] = a1[i] + a2[i];}for(int i=0; i<MAX_SIZE; i++){if(a3[i] >= 10){carry = a3[i] / 10;a3[i] = a3[i] % 10;a3[i+1] += carry; }}//6、去掉前导0int len = MAX_SIZE-1;while(a3[len] == 0 && len>0){len--;} //输出 for(int i=len; i>=0; i--) {cout<<a3[i];}return 0;
} 1、输入两个字符串
2、判断结果是正数还是负数（(1)先比较长度 (2)长度相等比较字典码大小）
3、倒叙存入数组（字符转数字）
4、定义一个len=s1.size()-1(默认s1字符串是最大的)
5、遍历长度为len的数组，进行加减运算（（1）先判断是否要进位（2）在进行加减）
6、先判断是否要输出负号以及去掉前导0
7、倒叙输出
#include<bits/stdc++.h>
using namespace std;
string s1,s2;
const int MAX_SIZE = 250;
int a[MAX_SIZE],b[MAX_SIZE],c[MAX_SIZE];
int len,p;
char f='+';
int main(){//1、输入字符串 cin>>s1>>s2;//2、判断结果是正数还是负数//(1)先比较长度 (2)长度相等比较字典码大小 if(s1.size()<s2.size()||(s1.size()==s2.size()&&s1<s2)){f='-';//swap可以交换数组 字符串 字符 整形 swap(s1,s2);}for(int i=0;i<s1.size();i++){a[i]=s1[s1.size()-i-1]-'0';}for(int i=0;i<s2.size();i++){b[i]=s2[s2.size()-i-1]-'0';}len=s1.size()-1;//先判断需不需要进位//再进行加减 for(int i=0;i<=len;i++){if(a[i]<b[i]){a[i+1]=a[i+1]-1;a[i]=a[i]+10;}c[i]=a[i]-b[i];}if(f=='-') cout<<f;//去掉前导0 while(c[len] == 0 && len>0){len--;} for(int i=len;i>=0;i--){cout<<c[i];}return 0;
}
#include<bits/stdc++.h>
using namespace std;
const int MAX_SIZE=250;
string s;
int b;
int a[MAX_SIZE];
int main(){ios::sync_with_stdio(false);cin.tie(0);cout.tie(0);cin>>s>>b;for(int i=0;i<s.size();i++){a[i]=s[s.size()-i-1]-'0';}for(int i=0;i<s.size();i++){a[i]=a[i]*b;}for(int i=0;i<s.size()+4;i++){if(a[i]>=10){a[i+1]=a[i+1]+a[i]/10;a[i]=a[i]%10;}}int len=MAX_SIZE;while(a[len]==0&&len>0){len--;}for(int i=len;i>=0;i--){cout<<a[i];}return 0;
}
高精度乘高精度步骤：
（1）输入两个字符串
（2）倒序存入数组
（3）利用（i+j）进行错位相加，并且判断进位
（4）去掉前导0,len长度为两个字符串相加的长度-1，必须要大于0，因为要保证有一个数，如果len=0那么就会被减成-1，访问数组就会越界
（5）倒序输出
#include<bits/stdc++.h>
using namespace std;
string s1,s2;
int a[250],b[250],c[500];
int len;
int main(){ios::sync_with_stdio(false);cin.tie(0);cout.tie(0);cin>>s1>>s2;for(int i=0;i<s1.size();i++){a[i]=s1[s1.size()-i-1]-'0';}for(int i=0;i<s1.size();i++){b[i]=s2[s2.size()-i-1]-'0';}for(int i=0;i<s1.size();i++){for(int j=0;j<s2.size();j++){c[i+j]=c[i+j]+a[i]*b[j];if(c[i+j]>9){c[i+j+1]=c[i+j+1]+c[i+j]/10;c[i+j]=c[i+j]%10;}}}len=s1.size()+s2.size()-1;while(c[len]==0&&len>0){len--;}for(int i=len;i>=0;i--){cout<<c[i];}return 0;
}
#include<bits/stdc++.h>
using namespace std;
int a[110]={1};
int main(){int n,sum=0,k=1;cin>>n;for(int i=0;i<n;i++){for(int j=0;j<k;j++){a[j]*=2;}for(int z=0;z<n;z++){if(a[z]>=10){a[z+1]+=a[z]/10;a[z]%=10;}}if(a[k]!=0){k++;}} for(int i=k-1;i>=0;i--){cout<<a[i];}return 0;
}
#include<bits/stdc++.h>
using namespace std;
int a[1000]={1},r[1000];
int main(){int n,sum=0,k1=1,k2=0;cin>>n;int len=0;for(int i=0;i<n;i++){for(int j=0;j<k1;j++){a[j]*=2;}for(int z=0;z<n;z++){if(a[z]>=10){a[z+1]+=a[z]/10;a[z]%=10;}}if(a[k1]!=0){k1++;}len=max(k1,len);for(int j=0;j<len;j++){r[j]+=a[j];if(r[j]>=10){r[j+1]+=r[j]/10;r[j]%=10;} }if(r[len]!=0){len++;}
}for(int i=len-1;i>=0;i-- ){cout<<r[i];}return 0;
}
什么是递推？
递推算法是一种用若干步可重复运算来描述复杂问题的方法，递推法是一种重要的数学方法，也是编程中解决问题的一个重要方法。
斐波那契数列求第n项的值:
(1)第一项、第二项的值都为1
(2)A(n) = A(n-1) + A(n-2)
1、采用递归的方法
缺点：随着n的值越来越大，重复求解的项会越来越多，这颗树就会越来越大，因此很耗费时间。
#include <iostream>
using namespace std;
//递归
int num(int n)
{int r;if(n==1 || n==2){//递归的结束条件 r = 1; }else{r = num(n-1) + num(n-2);}}
int main()
{int n;//求第几项cin>>n;cout<<num(n)<<endl; return 0;}
2、记忆数组
#include <iostream>
using namespace std;
long long a[60],n;
int main()
{cin>>n;a[1] = 1;a[2] = 1;for(int i = 3; i<=n; i++){a[i] = a[i-1] + a[i-2];}cout<<a[n]<<endl;return 0;
}
#include <iostream>
using namespace std;
int main()
{int x;//最后剩余的数量x = 1;for(int i=2; i<=10; i++){x = (x+1) * 2;} cout<<x;return 0;
}
第一种方法：双重for循环
#include <iostream>
using namespace std;
int main()
{int n,sum=0;cin>>n;for(int i=1; i<=n; i++){for(int j=1; j<=i; j++){sum += j;}} cout<<sum;return 0;
}
第二种方法：递推公式
A(n)= A(n-1) + n;
（1）定义一个二维数组
（2）输入的时候内层循环是小于i的（因为是三角形）
（3）外层循环从第n-1行开始，内层循环从1开始到i
（4）选取相邻两条线找值最大
（下标是a[x+1][y],a[x+1][y+1]）
（5）输出是a[1][1]
#include <iostream>
using namespace std;
int a[110][110];
int n;
int main()
{cin>>n;for(int i=1; i<=n; i++){for(int j=1; j<=i;j++){cin>>a[i][j];}}for(int i=n-1; i>=1; i--){for(int j=1; j<=i;j++){a[i][j] += max(a[i+1][j],a[i+1][j+1]);}} cout<<a[1][1];return 0;
}
#include <iostream>
using namespace std;
string he(string s1,string s2)
{string r;int a[1000]={0};int b[1000]={0};int c[1000]={0};for(int i=0;i<s1.size();i++){a[i]=s1[s1.size()-i-1]-'0';}for(int i=0;i<s2.size();i++){b[i]=s2[s2.size()-i-1]-'0';}int len=max(s1.size(),s2.size());for(int i=0;i<len;i++){c[i]+=a[i]+b[i];if(c[i]>=10){c[i+1] = c[i+1] + c[i] / 10;c[i] = c[i] % 10; }}if(c[len]!=0){len++;}for(int i=len-1;i>=0;i--){r=r+(char)(c[i]+'0');}return r;
}
string cheng(string s)
{string r;int len=s.size();int a[1000]={0};for(int i=0;i<s.size();i++){a[i]=s[s.size()-i-1]-'0';}for(int i=0;i<len;i++){a[i]*=2;}for(int i=0;i<s.size();i++){if(a[i]>=10){a[i+1]+=a[i]/10;a[i]%=10;}if(a[len]!=0){len++;}}for(int i=len-1;i>=0;i--){r=r+to_string(a[i]);}return r;
}
int main()
{string x,y,z;int i,n;cin>>n;x="1";y="2";if(n==1){cout<<x;}else if(n==2){cout<<y;}else{for(int i=3;i<=n;i++){z=he(cheng(y),x);x=y;y=z;}}cout<<z;return 0;
}
#include <bits/stdc++.h>
using namespace std;
int n;int fun(int i) {if (i <= n) {return i + fun(i + 1);} else {return 0;}
}int main() {cin >> n;cout << fun(1);
}
#include <bits/stdc++.h>
using namespace std;
int fun(int n,int c){if (n!=1){if (n%2==0){return fun(n/2,1+c);}else{return fun(n*3+1,1+c); }}else{return c;}
}
int main(){int n;cin>>n;cout<<fun(n,0);
}
#include <bits/stdc++.h>
using namespace std;
int a[11][11];void fun(int start, int len, int x) {int i, j;if (len > 0) {for (j = start; j <= start + len - 1; j++) {a[start][j] = x;x++;}for (i = start + 1; i <= start + len - 1; i++) {a[i][start + len - 1] = x;x++;}for (j = start + len - 2; j >= start; j--) {a[start + len - 1][j] = x;x++;}for (i = start + len - 2; i >= start + 1; i--) {a[i][start] = x;x++;}fun(start + 1, len - 2, x);}}int main() {int n;cin >> n ;fun(1, n, 1);for (int i = 1; i <= n; i++) {for (int j = 1; j <= n; j++) {cout << setw(3) << a[i][j];}cout << endl;}return 0;
}
第一种写法：分方向
#include <bits/stdc++.h>
using namespace std;
int a[11][11];
int n, m;void fun(int x, int y, int k) {a[x][y] = k;if (y + 1 <= m && a[x][y + 1] == 0)fun(x, y + 1, k + 1);if (x + 1 <= n && a[x + 1][y] == 0)fun(x + 1, y, k + 1);if (y - 1 >= 1 && a[x][y - 1] == 0)fun(x, y - 1, k + 1);if (x - 1 >= 1 && a[x - 1][y] == 0)fun(x - 1, y, k + 1);
}int main() {cin >> n >> m;fun(1, 1, 1);for (int i = 1; i <= n; i++) {for (int j = 1; j <= m; j++) {cout << setw(3) << a[i][j];}cout << endl;}}
第二种写法是方向数组
1.定义字符数组/整数数组（看输入数据类型决定）
2.定义fx[4],fy[4],tx(下一个方向的x),ty(下一个方向的y)
3.根据题目要求的方向进行方向数组赋值，左右为y,上下为x，右y+1,左y-1，下x+1,上x-1;
4.开始写递归函数
（1）进来先赋值/标记
（2）遍历四个方向
（3）判断边界一般是tx、ty、数组的初始值/标记数组的初始值
（4）fun(tx,ty,k+1)递归下一个点
#include <bits/stdc++.h>
using namespace std;
int n, m, tx, ty;
int a[11][11];
int fx[4] = {0, 1, 0, -1};
int fy[4] = {1, 0, -1, 0};
void fun(int x, int y, int k) {a[x][y] = k;for (int i = 0; i < 4; i++) {tx = x + fx[i];ty = y + fy[i];if (tx <= n && tx >= 1 && ty <= m && ty >= 1 && a[tx][ty] == 0) {fun(tx, ty, k + 1);}}
}
int main() {cin >> n >> m;fun(1, 1, 1);for (int i = 1; i <= n; i++) {for (int j = 1; j <= m; j++) {cout << setw(3) << a[i][j];}cout << endl;}return 0;
}
#include <bits/stdc++.h>
using namespace std;
int n, ha, la, hb, lb, tx, ty;
int fx[4] = {1, -1, 0, 0};
int fy[4] = {0, 0, 1, -1};
int a[110][110];void dfs(int x, int y) {a[x][y] = 1;for (int i = 0; i < 4; i++) {tx = x + fx[i];ty = y + fy[i];if (tx >= 1 && tx <= n && ty >= 1 && ty <= n && a[tx][ty] == 0) {if (tx == hb && ty == lb) {cout << "YES";exit(0);}dfs(tx, ty);}}
}int main() {cin >> n;for (int i = 1; i <= n; i++) {for (int j = 1; j <= n; j++) {cin >> a[i][j];}}cin >> ha >> la >> hb >> lb;if(a[ha][la]==1||a[hb][lb]==1){cout<<"NO";return 0;}else{dfs(ha, la);} cout << "NO";return 0;
}
DFS一般步骤：
1、进来先给数组赋值
2、开始遍历四个方向
3、判断在是否在可实行范围内
4、在可实行范围内调用递归
涉及知识点：
最大最小值头文件：
#include<climits>
#include <limits.h>
INT_MAX： 表示int类型的最大值；
INT_MIN： 表示int类型的最小值；
详细可看文档：C/C++之最值limits.h(climits)和limits头文件
#include <iostream>
#include <climits>//最大值最小值头文件
using namespace std;
char a[50][50];
int d[50][50];
int fx[4] = {1,0,-1,0};
int fy[4] = {0,1,0,-1};void dfs(int x,int y,int step)
{//1、进来先将数组赋值d[x][y] = step; //2、开始遍历四个方向 int tx,ty;for(int i=0; i<4; i++){tx = x + fx[i];ty = y + fy[i];//判断是否在这个范围if(a[tx][ty] == '.' && step+1<d[tx][ty]){dfs(tx,ty,step+1);} } }
int main()
{int r,c;cin>>r>>c;for(int i=1; i<=r; i++){for(int j=1;j<=c; j++){cin>>a[i][j];d[i][j] = INT_MAX;}}//深度搜索 dfs(1,1,1); cout<<d[c][r];return 0;
} 方向数组如何规定方向：
左、上、右、下
首先数组一般是：d[x][y]（看成一个二维数组）
证明：
x决定的是上下方向(行方向)，下走为1，上走为-1左、上、右、下
fx 0 -1 0 1
y决定的是左右方向（列方向），右走为1，左走为-1左、上、右、下
fy -1 0 1 0主要思路：
1、定义两个数组一个用于存储地图，一个用于存储走过的路径
2、dfs对于本题的一般步骤：
（1）标记数组走过的路径并且记录该路径的值
（2）判断是否到达终点
（3）循环遍历四个方向，在循环里面判断下一个位置是否是可实行范围
（4）在可实行范围里面递归寻找下一个点
#include<iostream>
using namespace std;
char a[30][30];//输入地图
int r[410][3];
int n;
//左、上、右、下
int fx[4] = {0,-1,0,1};
int fy[4] = {-1,0,1,0};
void print(int k)
{for(int i=1; i<=k; i++){cout<<"("<<r[i][1]<<","<<r[i][2]<<")";if(i != k){cout<<"->";}}exit(0);
}void dfs(int x,int y,int k)
{int tx,ty;//标记or赋值 r[k][1] = x;r[k][2] = y;//将走过的的路径标记为1a[x][y] = '1'; if(x==n && y==n){print(k);}for(int i=0;i<4;i++){tx = x + fx[i];ty = y + fy[i];if(a[tx][ty] == '0'){dfs(tx,ty,k+1);}}}
int main()
{cin>>n;for(int i=1; i<=n; i++){for(int j=1; j<=n; j++){cin>>a[i][j];}}dfs(1,1,1);return 0;
}
重点：记得搜索到终点return可以节约时间。
#include <iostream>
using namespace std;
int n,m;
int d[20][3];
int c = 0 ;//计数
//方向数组
void print(int k)
{c++;cout<<c<<":";for(int i=1; i<k; i++){cout<<d[i][1]<<","<<d[i][2]<<"->";}cout<<n<<","<<m<<endl;
}
int fx[2] = {1,0};
int fy[2] = {0,1};
void dfs(int x,int y, int k)
{//1、先记录路线d[k][1] = x;d[k][2] = y;//2、判断是否到达终点 if(x == n && y == m){print(k);return ; //到终点停止递归 }int tx,ty;for(int i=0; i<2; i++){tx = x + fx[i];ty = y + fy[i]; if(tx>=1 && tx<=n && ty>=1 && ty<=m){dfs(tx,ty,k+1);}} }
int main()
{cin>>n>>m;dfs(1,1,1);return 0;
}
回溯是搜索算法中的一种控制策略。它的基本思想是:为了求得问题的解，先选择一种可能情况向前探索，在探索过程中，一旦发现原来的选择是错误的，就退回一步重新选择，继续向前搜索，如此反复进行，直至得到解或证明无解。
如迷宫问题:进入迷宫后，先随意选择一个前进方向，一步步向前试探前进,如果碰到死胡同，说明前进方向已无路可走，这时，首先看其它方向是否还有路可走，如果有路可走，则沿该方向再向前试探:如果已无路可走，则返回一步，再看其它方向是否还有路可走:如果有路可走，则沿该方向再向前试探。按此原则不断搜索回溯再搜索，直到找到新的出路或从原路返回入口处无解为止
#include <iostream>
using namespace std;
int n;
bool b[10][10];//默认为false
int r[30][3];
int temp;//计数
//方向数组
//右、下、左、上
int fx[4] = {0,1,0,-1};
int fy[4] = {1,0,-1,0};void print(int k)
{temp++;cout<<temp<<":";for(int i=1; i<k; i++){cout<<r[i][1]<<","<<r[i][2]<<"->";}cout<<n<<","<<n<<endl;
} void dfs(int x,int y,int k)
{//1、进来先标记路线 r[k][1] = x;r[k][2] = y;//2、判断到达终点就返回if(x==n && y==n){print(k);return ;} //3、遍历四个方向 int tx,ty;for(int i=0; i<4; i++){tx = x + fx[i];ty = y + fy[i];if(tx>=1&& tx <=n && ty >=1 && ty<=n && b[tx][ty] == false){b[tx][ty] = true;dfs(tx,ty,k+1);b[tx][ty] = false;}}
}
int main()
{cin>>n;b[1][1] = true;dfs(1,1,1); return 0;
}
此类全排列类型题目：
1、需要带有标记数组选过的路径
2、遍历所有可能的选项
3、标记已经走过的路径
4、判断是否到达最终路径，若无到达则继续递归
5、递归结束要回到初始状态
#include <iostream>
using namespace std;int n;
int a[10];
bool r[10];
void print(int k)
{for(int i=1; i<=k; i++){cout<<a[i]<<" ";}cout<<endl;
}
void fun(int k)
{//1、遍历所有可能的结果for(int i=1; i<=n; i++){if(r[i] == false){//2、赋值 a[k] = i;//3、标记选过的数r[i] = true;//4、判断范围是否到达 if(k == n){print(k);}else{fun(k+1);}//5、递归结束需要回到之前状态r[i] = false;}}
}
int main()
{cin>>n;fun(1);return 0;
}
此题知识点：
判断素数代码需要记忆（）：
bool Sushu(int n)
{if(n<2) return false;for(int i=2; i * i <= n; i++){if(n % i==0){return false;}}return true;
}
#include <iostream>
using namespace std;
int n,temp;
bool b[20];
int a[30];
void print(int k)
{temp++;cout<<temp<<":";for(int i=1; i<=k; i++){cout<<a[i];if(i!=k){cout<<" ";}else{cout<<endl;}}
}bool Sushu(int n)
{if(n<2) return false;for(int i=2; i*i <= n; i++){if(n % i==0){return false;}}return true;
}
void fun(int k)
{for(int i=1; i<=n; i++){if(b[i] == false && (k==1 || Sushu(i+a[k-1]) == true))//难点判断范围{b[i] = true;a[k] = i;if(k==n && Sushu(a[k] + a[1])){print(k);//这里不能用return;会直接结束掉全部程序} else{fun(k+1);}b[i] = false;}}
}
int main()
{cin>>n;fun(1);cout<<"total:"<<temp;return 0;}
#include <iostream>
using namespace std;
int a[110][110];//存储矩阵
int q[10110][3];//存储队列(遍历过的点)
//右、下、左、上
int fx[4]={0,1,0,-1};
int fy[4]={1,0,-1,0};
int tx,ty;//表示访问的下一个点的坐标
int k = 1;//表示计数
//head表示头指针 tail表示尾指针
int n,m,head = 1,tail = 1;
int main()
{cin>>n>>m;//进来先标记为 1a[1][1] = k;//标记遍历数组的横纵坐标q[1][1] = 1;q[1][2] = 1;//当head<=tail时，说明队列还有点没有尝试标记过四个方向 while(head<=tail){for(int i=0; i<4; i++){for(int j=0; j<4;j++){tx = q[head][1] + fx[i];ty = q[head][2] + fy[i];//如果新点在矩阵内，且新点没有访问过if(tx>=1 && tx<=n && ty>=1 && ty<=m && a[tx][ty]==0){//存入点 尾指针++tail++;q[tail][1] = tx;q[tail][2] = ty;a[tx][ty] = ++k; }}}//使得标记过四个方向的点出队列 head++;} for(int i=1; i<=n; i++){for(int j=1; j<=n; j++){cout<<a[i][j]<<" "; }cout<<endl;}return 0;
}
#include <bits/stdc++.h>
using namespace std;
int a[1010][1010];
bool f[1010][1010];
int q[10000100][3];
int fx[4] = {0,0,1,-1};
int fy[4] = {1,-1,0,0};
int head = 1,tail = 1,tx,ty;//标记头尾指针为1
int main()
{//1、输入数组 ios::sync_with_stdio(0);cin.tie(0);cout.tie(0);int n,m,p1,p2;cin>>n>>m>>p1>>p2;for(int i=1; i<=n; i++){for(int j=1; j<=m; j++){cin>>a[i][j]; }}//2、第一个点入队列 q[1][1] = p1;q[1][2] = p2;f[p1][p2] = true;//3、while循环头指针小于尾指针 while(head<=tail){//4、遍历四个方向 for(int i=0; i < 4; i++){tx = q[head][1] + fx[i];ty = q[head][2] + fy[i];//5、如果新点可达并且没有出边界if(tx>=1&&tx<=n&&ty>=1&&ty<=m&&f[tx][ty] == false && a[tx][ty] <= a[p1][p2]) {//6、进来先标记和入队列 f[tx][ty] = true;tail++;q[tail][1] = tx;q[tail][2] = ty; }}head++;}cout<<tail;//走过多少点 return 0;}
1442 - 走出迷宫的最短路径
#include <bits/stdc++.h>
using namespace std;
int a[150][150];
int q[40000][3];
int fx[4] = {1,-1,0,0};
int fy[4] = {0,0,1,-1};
int tx,ty,head = 1,tail = 1;
void print(int k)
{if (q[k][3] != 0 ){print(q[k][3]);}cout<<"("<<q[k][1]<<","<<q[k][2]<<")";if(k != tail){cout<<"->";}
}
int main()
{ios::sync_with_stdio(0);cin.tie(0);cout.tie(0);int n,m,s1,s2,e1,e2;cin>>n>>m;for(int i=1; i<=n; i++){for(int j=1; j<=m; j++){cin>>a[i][j];}}cin>>s1>>s2>>e1>>e2;q[1][1] = s1;q[1][2] = s2;q[1][3] = 0;//没有前驱点while(head<= tail) {for(int i=0; i<4; i++){tx = q[head][1] + fx[i];ty = q[head][2] + fy[i];if(tx>=1&&tx<=n&&ty>=1&&ty<=m&&a[tx][ty]==0){a[tx][ty] = 1;tail++;q[tail][1] = tx;q[tail][2] = ty;q[tail][3] = head;if(tx==e1 && ty==e2){print(tail);return 0;}}}head++;}cout<<"no way";return 0;
}
#include<bits/stdc++.h>
using namespace std;
char a[200][200];
int q[40000][3];
int tx,ty,head=1,tail=1;
int fx[8] = {-1,-2,-2,-1,1,2,2,1};
int fy[8] = {-2,-1,1,2,2,1,-1,-2};
int main()
{int n,m,s1,s2,e1,e2;cin>>m>>n;for(int i=1; i<=n; i++){for(int j=1; j<=m; j++){cin>>a[i][j];if(a[i][j]=='K'){s1=i;s2=j;}if(a[i][j]=='H'){e1=i;e2=j;}}}//起始点进入队列 q[1][1] = s1;q[1][2] = s2;q[1][3] = 0;while(head<=tail){//遍历8个方向 for(int i=0; i<8; i++){tx = fx[i] + q[head][1];ty = fy[i] + q[head][2];if(a[tx][ty]=='.'||a[tx][ty]=='H'){a[tx][ty] = '*';tail++;q[tail][1] = tx;q[tail][2] = ty;q[tail][3] = q[head][3]+1;if(tx==e1&&ty==e2){cout<<q[tail][3];return 0; } }}head++;}return 0;}
分治:将一个规模为 N 的问题分解为 个规模较小的子问题，这些子问题相互独立且与原问题性质相同。
求出子问题的解，就可得到原问题的解。即一种分目标完成程序算法。二分查找步骤：
1、定义一个初始位置 r(需要赋初始值)，left,right，mid
2、while循环条件固定位left<=right
3、先判断中点是不是目标值，如果是就break；
4、在判断是在左边，左边将mid-1赋值给right
5、在判断是在右边，右边将mid+1值赋给left
6、注意重点：
(1)left = mid+1 左加
(1)right = mid-1 右减
分查找（Binary Search）是一种在有序数组中查找特定元素的高效算法。在讨论二分查找的最佳结果时，我们通常是在讨论其最佳时间复杂度，即在最理想的情况下，算法需要比较的次数。
在最佳情况下，二分查找的时间复杂度是 O(1)，这发生在要查找的元素正好是数组的中间元素时。也就是说，在最佳情况下，你只需要进行一次比较就能找到目标元素。
二分查找算法的最坏情况时间复杂度是 O(log n)，其中 “n” 是数组中的元素数量。这种情况发生在所查找的元素位于数组的一端或根本不存在于数组中。
以下是一个简单的代码实例：
#include <iostream>
using namespace std;int main() {int n;cout << "输入一个正整数: ";cin >> n; // 用户输入一个数// 这个 for 循环每次以 2 的幂进行迭代for (int i = 1; i < n; i *= 2) {// 每次循环，i 都翻一番cout << "当前 i 的值是: " << i << endl;}return 0;
}如果您想了解对于不同的 2 的幂，循环的迭代次数是多少，下面是几个示例：1. 如果 `n` 等于 2，即 (2^1)，那么循环只需迭代 1 次，因为 `i` 初始值为 1，循环第一次迭代就变成了 2，满足了条件。2. 如果 `n` 等于 4，即 (2^2)，那么循环需要迭代 2 次。第一次迭代 `i` 变为 2，第二次迭代 `i` 变为 4。3. 如果 `n` 等于 8，即 (2^3)，那么循环需要迭代 3 次。`i` 的值将先后变为 2、4 和 8。4. 如果 `n` 等于 16，即 (2^4)，那么循环需要迭代 4 次。`i` 的值将先后变为 2、4、8 和 16。5. 如果 `n` 等于 32，即 (2^5)，循环需要迭代 5 次。`i` 的值将先后变为 2、4、8、16 和 32。依此类推，如果 `n` 是 (2^x)，那么循环就需要迭代 `x` 次。这是因为每次迭代都会使 `i` 翻倍，所以 `i` 会以 2 的幂次增长：(2^1, 2^2, 2^3, ldots, 2^x)。总之，当 `n` 是 2 的幂时，循环的迭代次数正好是 `n` 的以 2 为底的对数，即 (log_2(n))。如果 `n` 不是 2 的幂，循环的迭代次数将是大于 (log_2(n)) 的最小整数。相关公式展示：log一般将底数2。
开区间写法
#include <iostream>
using namespace std;
int a[1000000];
int main()
{int n,x,mid,left,right,r; cin>>n;for(int i=0; i<n; i++){cin>>a[i];}cin>>x;left = 0;right = n-1;r = -1;//给一个初始位置while(left<=right){mid = (left+right) / 2;if(a[mid] == x){r = mid;break;}else if(x<a[mid]){right = mid - 1;}else if(x>a[mid]){left = mid + 1;}} //本身是从零开始的 cout<<(r==-1 ? -1 : r+1)<<endl;return 0;
}
#include<bits/stdc++.h>
using namespace std;
int main(){ios::sync_with_stdio(false);cin.tie(0);cout.tie(0);int n,x;cin>>n;int a[n+5];for(int i=1;i<=n;i++){cin>>a[i];}cin>>x;int l=1,r=n+1;while(l<r){int mid=(l+r)/2;if(x<a[mid]) r=mid;else if(x>a[mid]) l=mid+1;else{cout<<mid;return 0;}}cout<<-1;return 0;
}
递归解法：
#include <bits/stdc++.h>
using namespace std;int n, a[1000000], x;int fun(int left, int right)
{if (left > right) return -1;int mid = (left + right) / 2;if (x == a[mid]){return mid + 1;}else if (x < a[mid]){return fun(left, mid - 1);}else if (x > a[mid]){return fun(mid + 1, right);}}int main()
{cin >> n;for (int i = 0; i < n; i++){cin >> a[i];}cin >> x;cout << fun(0, n - 1) << endl;return 0;
}
#include<bits/stdc++.h>
using namespace std;
int a[100005],b[100005];
int f(int n,int m,int x){int l=0,r=n-1;while(l<=r){int mid=l+r>>1;if(a[mid]<x) l=mid+1;else if(a[mid]>x) r=mid-1;else return 1;}return 0;
}
int main(){ios::sync_with_stdio(false);cin.tie(0);cout.tie(0);int n,m;cin>>n>>m;for(int i=0;i<n;i++) cin>>a[i];for(int i=0;i<m;i++) cin>>b[i];sort(a,a+n);sort(b,b+m);for(int i=0;i<m;i++){if(f(n,m,b[i])) cout<<b[i]<<" ";}return 0;
}
本题的快排思想：
1、左右指针赋值
2、基准值赋值
3、第一次划分子区间
4、寻找不符合的左、右区域
5、将两边不符合的值进行交换
6、交换后需要下标增加和减少
7、调用递归重新将左右子区域划分
这是一个经典的快速排序（Quick Sort）算法的实现。快速排序的平均时间复杂度为O(n log n)，但最坏情况下时间复杂度为O(n^2)。 在你的代码中，快速排序递归调用的方式可能导致最坏情况的发生，因此最坏情况下时间复杂度为O(n^2)。
快速排序的时间复杂度的平均和最坏情况取决于选择的基准元素以及数据的分布情况。在最好情况下，每次选择的基准元素都能将数组均匀地分成两部分，此时时间复杂度接近O(n log n)。
#include <bits/stdc++.h>
using namespace std;int n, a[100000];void quick(int left, int right)
{if (left >= right) return; // 增加的基本情况检查，避免不必要的递归调用int i = left, j = right;//中轴值有可能是会被改变的，所以需要用额外的单独变量进行记忆下来int pivot = a[(left + right) / 2]; // 保存中间值while (i <= j){while (a[i] < pivot) i++;while (a[j] > pivot) j--;if (i <= j){swap(a[i], a[j]);i++;j--;}}if (left < j) quick(left, j);if (i < right) quick(i, right);
}int main()
{cin >> n;for (int i = 0; i < n; i++){cin >> a[i];}quick(0, n - 1);for (int i = 0; i < n; i++){cout << a[i] << " ";}return 0;
}冒泡排序思路：
（1）外层循环-每轮要排的次数
（2）内层循环-循环到下标为几的数
（3）外层循环排n个数则要循环n-1轮
（4）内层循环不需要访问到最后的下标 下标应该是n-i-1
#include <iostream>
using namespace std;
int a[1000],n;
int main()
{cin>>n;for(int i=0; i < n; i++){cin>>a[i];}for(int i=1; i<=n-1; i++)//轮次{for(int j=0; j<=n-i-1;j++){//内层循环下标从0开始遍历到n-i-1//下标从1开始遍历到n-i if(a[j] > a[j+1]){swap(a[j],a[j+1]);}}}for(int i=0; i<n; i++){cout<<a[i]<<" ";}return 0;}
#include <iostream>
using namespace std;
int a[1000],n;
int main()
{cin>>n;for(int i=1; i <= n; i++){cin>>a[i];}for(int i=1; i<=n-1; i++)//轮次{for(int j=0; j<=n-i;j++){//内层循环下标从0开始遍历到n-i-1//下标从1开始遍历到n-i if(a[j] > a[j+1]){swap(a[j],a[j+1]);}}}for(int i=1; i<=n; i++){cout<<a[i]<<" ";}return 0;}
#include<iostream> //包含输入输出头文件
#include<cmath>
using namespace std; //指定名字空间
int main()
{ //主函数int a[100]; //定义数组，大小100int N; //元素的实际个数int i = 0, j = 0; //循环变量，并进行初始化cin >> N; //输入元素个数//-------输入数据-----------for (i = 0; i<N; i++) //输入N个元素cin >> a[i]; //循环体只有一行//-------排序---------------for (i = 0; i<N - 1; i++) { //控制n-1趟冒泡for (j = 0; j<N - 1 - i; j++){if (a[j]>a[j + 1]) { //比较相邻的两个元素swap(a[j],a[j+1]); }}}//--------输出----------for (i = 0; i<N; i++) { //使用循环，输出N个元素cout << a[i] << " "; //输出a[i], 后加空格，不换行}cout << endl; //所有元素输出完之后才换行return 0; //函数返回
}
#include <iostream>
using namespace std;
int a[1000],n;
bool f;
int main()
{cin>>n;for(int i=0; i < n; i++){cin>>a[i];}for(int i=1; i<=n-1; i++)//轮次{f = false;//假设没有产生过交换 for(int j=0; j<=n-i-1;j++){if(a[j] > a[j+1]){swap(a[j],a[j+1]);f = true;//产生交换则为true }}if(f==false)//本轮没有产生过交换 {break;//则退出循环 }}for(int i=0; i<n; i++){cout<<a[i]<<" ";}return 0;}
选择排序思想：
（1）外层循环比较n-1轮
（2）内层循环找出最大的数的下标不是它本轮最后一个数的下标n-i
（3）交换a[ma] , a[n-i]
#include <iostream>
using namespace std;
int a[1000],n,ma;
int main()
{cin>>n;for(int i=0; i<n; i++){cin>>a[i];}for(int i=1; i<=n-1; i++){//假设每轮的最大值下标都是0ma = 0;for(int j=1; j<=n-i; j++){if(a[j]>a[ma]){ma = j;}}//如果第i轮最大数下标不是本轮的最后一个数（n-i） if(ma != n-i){swap(a[ma],a[n-i]);} }for(int i=0; i<n; i++) {cout<<a[i]<<" ";}return 0;
}
18.4 桶排序
桶排序也叫箱排序工作的原理是:统计每个元素出现的个数，然后利用桶的下标已经有序的原理，按照每个数出现的次数循环输出。
因此，桶排序要求数组元素数值必须是小范围内的数!
什么情况下不适合用桶排序?
如果数据量不大，但数据中有一个数特别大，则不适合用桶排序!
2,5,3,3,8,9,1,2,7,6,100000
#include<iostream>
using namespace std;
int a[1010],n,x;
int main()
{cin>>n;for(int i=0; i<n; i++){cin>>x;a[x]++;}//桶排序数值尽量在1-1000范围内 for(int i=1;i<=1000; i++){for(int j=1;j<=a[i]; j++){cout<<i<<" ";}}return 0;
}
插入排序将数组分成前后 2 块， 前一块: 有序区间;后一块: 无序区间;排序思想:从无序区间中选择一个数字，插入到有序区间中。有序区间扩大一位，无序区间减少一位。直到有序区间覆盖整个数组。
无序区间:i到 n-1
有序区间:0到i-1
#include <iostream>
using namespace std;
int a[10010],n,i,j,t;
int main()
{cin>>n;for(int i=0; i<n; i++){cin>>a[i];}//循环无序区（a[0]默认在有序区）for(i=1;i<n; i++){//将a[i]插入到有序区间//循环有序区，寻找a[i]应该插入的下标for(j=0; j<i; j++){//找到第一个比要插入的数大的数//其位置就是插入的位置if(a[j]>=a[i]){break;} } if(j != i){t = a[i];//现将啊a[i]存储起来//将a[i]插入到下标为j的位置//先将元素后移动for(int k = i-1; k>=j; k--){a[k+1] = a[k];} }a[j] = t; } for(i=0; i<n; i++){cout<<a[i]<<" "; }return 0;
}
方法一：dfs
#include <bits/stdc++.h>
using namespace std;
int a[110][110];
int ma;
int n;
void dfs(int x,int y, int sum)
{ma = max(ma,sum);if(x+1<=n){dfs(x+1,y,sum+a[x+1][y]);dfs(x+1,y+1,sum+a[x+1][y+1]);}
}
int main()
{cin>>n;for(int i=1; i<=n; i++){for(int j=1; j<=i; j++){cin>>a[i][j];}} dfs(1,1,a[1][1]);cout<<ma<<endl;return 0;}
方法二：递推求解
动态规划一般步骤：
1、存储数据的数组
2、一个标注动态规划过程值的数组
3、寻找状态转移方程
#include <bits/stdc++.h>
using namespace std;
int a[110][110];
int d[110][110];
int ma;
int n;
void dfs(int x,int y, int sum)
{ma = max(ma,sum);if(x+1<=n){dfs(x+1,y,sum+a[x+1][y]);dfs(x+1,y+1,sum+a[x+1][y+1]);}
}//递推求解
void fun1(void){for(int j=1; j<=n; j++){d[n][j] = a[n][j];}for(int i=n-1; i>=1; i--){for(int j=1; j<=i; j++){d[i][j] = a[i][j]+max(d[i+1][j],d[i+1][j+1]);}}
}
int main()
{cin>>n;for(int i=1; i<=n; i++){for(int j=1; j<=i; j++){cin>>a[i][j];}} fun1();cout<<d[1][1];return 0;}
方法三：记忆化搜索
#include <bits/stdc++.h>
using namespace std;
int a[110][110];
int d[110][110];
int ma;
int n;
//1、深度优先搜索
void dfs(int x,int y, int sum)
{ma = max(ma,sum);if(x+1<=n){dfs(x+1,y,sum+a[x+1][y]);dfs(x+1,y+1,sum+a[x+1][y+1]);}
}//2、递推求解
void fun1(void){for(int j=1; j<=n; j++){d[n][j] = a[n][j];}for(int i=n-1; i>=1; i--){for(int j=1; j<=i; j++){d[i][j] = a[i][j]+max(d[i+1][j],d[i+1][j+1]);}}
}//4、记忆化搜索
int fun3(int x,int y){if(x==n){return a[x][y];}else{if(d[x][y] != -1) return d[x][y];else{d[x][y] = a[x][y] + max(fun3(x+1,y),fun3(x+1,y+1));return d[x][y];}}
}
int main()
{cin>>n;memset(d,-1,sizeof(d)); for(int i=1; i<=n; i++){for(int j=1; j<=i; j++){cin>>a[i][j];}} cout<<fun3(1,1);return 0;}
#include <bits/stdc++.h>
using namespace std;
int a[110];
int dp[110];
int main()
{int n,ma=0;cin>>n;for(int i=1; i<=n; i++){cin>>a[i];}dp[1] = a[1];for(int i=2; i<=n; i++){dp[i] = max(dp[i-1]+a[i] , a[i]);ma = max(ma,dp[i]);}cout<<ma;return 0;}
1、定义两个数组 一个输入数组 一个dp数组
2、外层循环遍历dp数组，dp[i]始终默认为1
3、内层循环遍历到i-1，如果本位值大于前面的值则使用状态转移方程
4、状态转移方程dp[j]+1(上一位的加一)+本位的dp[i]比较（因为这里重复了多次的存储dp[i]）
#include <bits/stdc++.h>
using namespace std;
int a[10010],ma;
int dp[10010];int main()
{int n;cin>>n;for(int i=1; i<=n; i++){cin>>a[i]; } for(int i=1; i<=n; i++){dp[i] = 1;for(int j=1; j<i; j++){if(a[i]>a[j]){dp[i] = max(dp[j]+1,dp[i]);}}ma = max(dp[i],ma);}cout<<ma;return 0;
}
#include <iostream>
using namespace std;
int a[100100],s=0,n,x;
int dp[100100];
int main()
{//解题步骤//1、划分方向//2、确定状态转移方程//3、寻找边界cin>>n>>x; a[1] = x;dp[1] = a[1];s = dp[1];for(int i=2; i<=n; i++){a[i] = (379 * a[i-1] + 131 ) % 997;dp[i] = max(dp[i-1],a[i]);s += dp[i];}cout<<s;return 0;}
#include <iostream>
using namespace std;
int a[110],s=0,n,x;
int dp[110];
int main()
{cin>>n;for(int i=1; i<=n;i++){cin>>a[i];}//2、交代边界的值dp[1] = a[1];dp[2] = max(a[1],a[2]);//因为这里最低的取数是两个for(int i=3; i<=n;i++){dp[i] = max(dp[i-1],dp[i-2]+a[i]);}cout<<dp[n];return 0;}
#include <iostream>
using namespace std;
int a[110],s=0,n,x,ans;
int dpa[110];
int dpb[110];
int main()
{cin>>n;for(int i=1; i<=n;i++){cin>>a[i];}for(int i=1;i<=n; i++){dpa[i] = 1;for(int j=1; j<i; j++){if(a[j]<a[i]){dpa[i] = max(dpa[i],dpa[j]+1);}}}for(int i=n; i>=1; i--){dpb[i] = 1;for(int j=n; j>i;j--){if(a[j]<a[i]){dpb[i] = max(dpb[i],dpb[j]+1);}}}for(int i=1;i<=n;i++){ans=max(ans,dpa[i]+dpb[i]-1);}cout<<n-ans;return 0;}
STL核心库的基本概念
vector定义的四种方法：
(1)vector <类型> 名字
vector <int> d;(2)vector <int> d(默认初始大小);
vector <int> d(10);(3)vector <int> d(n,t);
n为默认长度
t为默认初始值
vector <int> d(10,10);(4)vector <int> d[begin,end);
int a[] = {10,20,30,40,50};
//数组名是数组的首地址
vector <int> d(a,a+sizeof(a)/sizeof(int));vector <类型> 名字
vector <int> d;#include <bits/stdc++.h>
#include <vector>
using namespace std;void print(vector <int> v)
{for(int i=0; i<v.size(); i++){cout<<v[i]<<" ";}
}
int main()
{//vector 的定义vector <int> v;//size()：返回vector实际存储多少个元素//cout<<v.size(); //常见错误：定义一个空vector//然后给vector赋值//v[0] = 1; v[1] = 2; v.push_back(10);v.push_back(20);v.push_back(30);print(v);return 0;
}
#include <bits/stdc++.h>
#include <vector>
using namespace std;void print(vector <int> v)
{for(int i=0; i<v.size(); i++){cout<<v[i]<<" ";}
}
int main()
{vector<int> v;v.push_back(10);v.push_back(20);v.push_back(30);//insert(位置，元素)：位置必须要提供位置指针//向vector中下标为1的位置插入用元素100v.insert(v.begin()+1,100); print(v);return 0;
}
#include <bits/stdc++.h>
#include <vector>
using namespace std;void print(vector <int> v)
{for(int i=0; i<v.size(); i++){cout<<v[i]<<" ";}
}
int main()
{vector<int> v;v.push_back(10);v.push_back(20);v.push_back(30);//insert(位置，元素)：位置必须要提供位置指针//向vector中下标为1的位置插入用元素100//v.insert(v.begin()+1,100); //向vector中下标为1的位置插入5个100v.insert(v.begin()+1,5,100); print(v);return 0;
}
#include <bits/stdc++.h>
#include <vector>
using namespace std;void print(vector <int> v)
{for(int i=0; i<v.size(); i++){cout<<v[i]<<" ";}
}
int main()
{vector<int> v;v.push_back(10);v.push_back(20);v.push_back(30);//insert(位置，元素)：位置必须要提供位置指针//向vector中下标为1的位置插入用元素100//v.insert(v.begin()+1,100); //向vector中下标为1的位置插入5个100//v.insert(v.begin()+1,5,100); vector<int> v2;v2.push_back(100);v2.push_back(200);v.insert(v.begin(),v2.begin(),v2.end());print(v);return 0;
}
#include <bits/stdc++.h>
#include <vector>
using namespace std;void print(vector <int> v)
{for(int i=0; i<v.size(); i++){cout<<v[i]<<" ";}
}
int main()
{vector<int> v;v.push_back(10);v.push_back(20);v.push_back(30);vector<int> v2;v2.push_back(100);v2.push_back(200);v.insert(v.begin(),v2.begin(),v2.end());v.erase(v.begin(),v.begin()+2); print(v);return 0;
}
#include <bits/stdc++.h>
#include <vector>
using namespace std;void print(vector <int> v)
{for(int i=0; i<v.size(); i++){cout<<v[i]<<" ";}
}
int main()
{vector<int> v;v.push_back(10);v.push_back(20);v.push_back(30);cout<<"第一个元素："<<v.front()<<endl;cout<<"最后一个元素："<<v.back()<<endl;print(v);return 0;
}
#include <bits/stdc++.h>
using namespace std;void print(vector <int> v)
{for(int i=0; i<v.size(); i++){cout<<v[i]<<" ";}cout<<endl;
}
int main()
{vector<int> v1;v1.push_back(10);v1.push_back(20);v1.push_back(30);vector<int> v2;v2.push_back(1000);v2.push_back(2000);v2.push_back(3000);swap(v1,v2);print(v1);print(v2);return 0;
}
#include <bits/stdc++.h>
using namespace std;void print(vector <int> v)
{for(int i=0; i<v.size(); i++){cout<<v[i]<<" ";}cout<<endl;
}
int main()
{vector<int> v1;v1.push_back(10);v1.push_back(20);v1.push_back(30);reverse(v1.begin(),v1.end());print(v1);return 0;
}
#include <bits/stdc++.h>
using namespace std;void print(vector <int> v)
{for(int i=0; i<v.size(); i++){cout<<v[i]<<" ";}cout<<endl;
}
int main()
{vector<int> v1;v1.push_back(10);v1.push_back(20);v1.push_back(30);reverse(v1.begin(),v1.end());print(v1);v1.resize(20);print(v1);return 0;
}
#include <bits/stdc++.h>
using namespace std;void print(vector <int> v)
{for(int i=0; i<v.size(); i++){cout<<v[i]<<" ";}cout<<endl;
}
int main()
{vector<int> v1;v1.push_back(10);v1.push_back(20);v1.push_back(30);reverse(v1.begin(),v1.end());print(v1);v1.resize(2);print(v1);v1.resize(3);print(v1);return 0;
}
初始化二维 vector:vector<vector<int>> v(20);
这创建了一个包含 20 个元素的二维 vector，其中每个元素都是一个空的 vector<int>。
访问内层 vector:当你使用 v[i] 时，你实际上访问的是这个二维 vector 的第 i 个元素。由于二维 vector 已经被初始化，所以这个操作是安全的。
向内层 vector 添加元素:使用 .push_back(i+j) 向第 i 个内层 vector 添加元素。在每次循环中，这个内层 vector 会根据需要增长，因为 vector 是动态数组，它可以根据添加的元素数量自动调整大小。
#include <bits/stdc++.h>
using namespace std;int main()
{//cin cout加速代码 ios::sync_with_stdio(0);cin.tie(0);cout.tie(0);//定义二维的vector 因为>>表示右移运算符 vector<vector <int> > v(20);for(int i=0; i<5; i++){for(int j=0; j<5; j++){v[i].push_back(i+j); }} for(int i=0; i<5;i++){for(int j=0; j<5; j++){cout<<v[i][j]<<" ";}cout<<endl;}return 0;
}
定义一个空的二维vector在进行动态增加
#include <iostream>
#include <vector>
using namespace std;int main() {vector<vector<int>> v; // 定义一个空的二维vector// 动态地填充5x5的二维vectorfor (int i = 0; i < 5; i++) {vector<int> row; // 创建一个新行for (int j = 0; j < 5; j++) {row.push_back(i + j); // 向这个新行添加元素}v.push_back(row); // 将新行添加到二维vector中}// 打印二维vector的内容for (int i = 0; i < 5; i++) {for (int j = 0; j < 5; j++) {cout << v[i][j] << " ";}cout << endl;}return 0;
}直接使用vector定义一个二维的vector，竖着输入
在 C++ 中，vector<vector<int>> 是一个二维向量。它可以被视为一个表格，其中每行是一个向量（即一个一维数组）。
初始化: vector<vector<int>> v(n, vector<int>(m));这行代码初始化了一个 n x m 的二维向量，其中每个元素默认为 0。这相当于创建了一个具有 n 行和 m 列的表格。
int n = 5; // 行数
int m = 5; // 列数
vector<vector<int>> v(n, vector<int>(m));
int temp = 0;
for(int i = 0; i < m; ++i) {for(int j = 0; j < n; ++j) {v[j][i] = ++temp;}
}
指针复习：
#include <bits/stdc++.h>
using namespace std;int main()
{//cin cout加速代码 ios::sync_with_stdio(0);cin.tie(0);cout.tie(0);char s[] = "hello";char *p = s;for(p=s; *p != ' '; *p++){cout<<*p<<" ";}return 0;
}
使用正向迭代器遍历vector
#include <bits/stdc++.h>
using namespace std;int main()
{ios::sync_with_stdio(0);cin.tie(0);cout.tie(0);int a[] = {10,20,30,40};vector<int> v(a,a+4);for(vector<int>::iterator it = v.begin(); it != v.end(); it++){cout<<*it<<" ";}cout<<endl;return 0;}
利用反向迭代器遍历vector
#include <bits/stdc++.h>
#include <vector>
using namespace std;int main()
{ios::sync_with_stdio(0);cin.tie(0);cout.tie(0);int a[] = {10,20,30,40};vector<int> v(a,a+4);for(vector<int>::reverse_iterator rit = v.rbegin(); rit != v.rend(); rit++){cout<<*rit<<" ";}return 0;}
#include <iostream>
#include <list>
using namespace std;
void print(list <int> l)
{list <int>::iterator it;for(it=l.begin();it!&#d();it++){cout<<*it<<" ";}cout<<endl;
}
int main()
{int a[]={10,20,30};list <int> l(a,a+3);print(l);l.insert(l.begin(),15);print(l);return 0;
}
#include <iostream>
#include <list>
using namespace std;
void print(list <int> l)
{list <int>::iterator it;for(it=l.begin();it!&#d();it++){cout<<*it<<" ";}cout<<endl;
}
int main()
{int a[]={10,20,30};list <int> l(a,a+3);print(l);l.insert(l.begin(),15);print(l);list <int>::iterator it=l.begin();cout<<"请输入要插入的位置和元素的值：";int x,y;cin>>x>>y;for(int i=0;i<x;i++){it++;}l.insert(it,y);print(l);return 0;
}
#include <iostream>
#include <list>
using namespace std;
void print(list <int> l)
{list <int>::iterator it;for(it=l.begin();it!&#d();it++){cout<<*it<<" ";}cout<<endl;
}
int main()
{int a[]={10,20,30};list <int> l(a,a+3);print(l);l.insert(l.begin(),15);print(l);list <int>::iterator it=l.begin();cout<<"请输入要插入的位置和元素的值：";int x,y;cin>>x>>y;for(int i=0;i<x;i++){it++;}l.insert(it,y);print(l);l.remove(30);print(l); return 0;
}
#include <iostream>
#include <list>
using namespace std;
void print(list <int> l)
{list <int>::iterator it;for(it=l.begin();it!&#d();it++){cout<<*it<<" ";}cout<<endl;
}
int main()
{int a[]={70,50,100,90,80,20,40,10,30,60};list <int> l(a,a+10); print(l);
// l.insert(l.begin(),15);
// print(l);
// list <int>::iterator it=l.begin();
// cout<<"请输入要插入的位置和元素的值：";
// int x,y;
// cin>>x>>y;
// for(int i=0;i<x;i++)
// {
// it++;
// }
// l.insert(it,y);
// print(l);
// l.remove(30);
// print(l); l.sort();print(l);return 0;
}
#include <iostream>
#include <list>
using namespace std;
bool lll(int a,int b)
{return a>b;
}
void print(list <int> l)
{list <int>::iterator it;for(it=l.begin();it!&#d();it++){cout<<*it<<" ";}cout<<endl;
}
int main()
{int a[]={70,50,100,90,80,20,40,10,30,60};list <int> l(a,a+10); print(l);
// l.insert(l.begin(),15);
// print(l);
// list <int>::iterator it=l.begin();
// cout<<"请输入要插入的位置和元素的值：";
// int x,y;
// cin>>x>>y;
// for(int i=0;i<x;i++)
// {
// it++;
// }
// l.insert(it,y);
// print(l);
// l.remove(30);
// print(l); l.sort(lll);print(l);return 0;
}
/*自定义一个函数，名称非固定。*参数的顺序可以看成list中的参数顺序*/
bool compare(int a,int b){return a>b;
}/*在使用list.sprt()时传入函数名*/
int main(){list<int> lst;lst.sort(compare);
}#include <iostream>
#include <set>
using namespace std;
void print(set <int> l)
{set <int>::iterator it;for(it=l.begin();it!&#d();it++){cout<<*it<<" ";}cout<<endl;
}
int main()
{int a[]={70,50,10,90,80,20,40,10,30,60};set <int> l(a,a+10); print(l);return 0;
}
#include <iostream>
#include <set>
using namespace std;
void print(set <int> l)
{set <int>::iterator it;for(it=l.begin();it!&#d();it++){cout<<*it<<" ";}cout<<endl;
}
int main()
{int a[]={70,50,10,90,80,20,40,10,30,60};set <int> r(a,a+10); print(r);set <int>::iterator it;it=r.find(300);if(it!&#d()){cout<<*it<<"存在";}else{cout<<"不存在";}cout<<endl;print(r);return 0;
}
#include <iostream>
#include <set>
#include <bits/stdc++.h>
using namespace std;
void print(set<int,greater<int> > l)
{set <int>::iterator it;for(it=l.begin();it!&#d();it++){cout<<*it<<" ";}cout<<endl;
}
int main()
{int a[]={70,100,80,90,10,40,30,20,50};set<int,greater<int> > s(a,a+9);s.insert(60);print(s);return 0;
}#include <iostream>
#include <set>
#include <bits/stdc++.h>
using namespace std;
void print(set<int,greater<int> > l)
{set <int>::iterator it;for(it=l.begin();it!&#d();it++){cout<<*it<<" ";}cout<<endl;
}
int main()
{int a[]={70,100,80,90,10,40,30,20,50};set<int,greater<int> > s(a,a+9);s.insert(60);print(s);return 0;
}
选择题
1、正整数的原码和补码是否相同？
A. 是
B. 否
C. 只在特定情况下相同
D. 无法确定
2、在8位二进制表示中，数-5的补码是多少？
A. 11111011
B. 00000101
C. 10000101
D. 11111010
3、反码用于解决哪个数的表示问题？
A. 正整数
B. 负整数
C. 小数
D. 实数
4、在补码编码中，最高位（符号位）为1通常表示什么？
A. 正数
B. 负数
C. 零
D. 上述都不是
5、在8位二进制表示中，数7的反码是多少？
A. 00000111
B. 11111000
C. 11111001
D. 00000110
6、在补码表示中，-0和+0是否有不同的表示？
A. 有
B. 没有
C. 只在特定情况下不同
D. 无法确定
7、补码表示法的主要优点是什么？
A. 简化了加法运算
B. 提供了统一的表示方式
C. 减少存储空间
D. A和B都是
8、哪一种编码方式可以直接用于加法运算？
A. 原码
B. 反码
C. 补码
D. 上述都不是
9、在补码表示中，一个数和它的补数相加的结果是什么？
A. 0
B. 1
C. 该数的两倍
D. 无法确定
10、在8位二进制补码表示中，-128的表示是什么？
A. 10000000
B. 01111111
C. 11111111
D. 00000000
11、对于8位二进制数，以下哪个是-1的补码表示？
A. 11111111
B. 01111111
C. 10000001
D. 11111110
12、在反码表示中，正数和负数的最高位分别是什么？
A. 0和1
B. 1和0
C. 都是0
D. 都是1
13、为什么在计算机中使用补码而不是原码来表示负数？
A. 原码计算复杂
B. 补码可以表示更多的数
C. 补码简化了加法和减法运算
D. 原码无法表示负数
14、在计算机中，整数通常用哪种编码方式表示？
A. 原码
B. 反码
C. 补码
D. ASCII码
15、哪种编码方式中，负数的表示是其对应正数的二进制表示的每一位取反？
A. 原码
B. 反码
C. 补码
D. ASCII码
16、在8位二进制补码表示中，最大的正数是多少？
A. 01111111
B. 10000000
C. 11111111
D. 00000000
17、补码系统中，哪一个数的原码、反码、补码表示相同？
A. 0
B. -1
C. 1
D. -128
18、在反码表示中，-5的8位二进制表示是什么？
A. 11111011
B. 10000101
C. 11111010
D. 10000100
19、如果一个8位二进制数的补码是11111000，那么它的十进制值是多少？
A. -8
B. -7
C. -6
D. -5
20、在计算机中，使用补码表示有助于解决哪个问题？
A. 0的多种表示
B. 正数的表示
C. 负数的加法运算
D. 浮点数的表示
代码填空题
1、给定一个8位二进制补码11001010，其十进制表示为__________。
2、对于负整数-9，其8位二进制原码表示为__________。
3、在计算机中，整数15的8位二进制补码表示为__________。
4、若一个数的8位二进制原码为01101001，则其反码表示为__________。
5、给定一个数的8位二进制补码表示10001011，其反码表示为__________。
6、一个数的8位二进制原码是01000101，则其补码表示为__________。
7、负整数-32在8位二进制补码表示中为__________。
8、补码11111110在十进制中表示__________。
9、对于正整数+17，其8位二进制补码表示为__________。
10、若一个数的8位二进制补码为11110111，则其原码表示为__________。
选择题解析：
正整数的原码和补码是否相同？
答案: A. 是
解析: 对于正整数，其原码和补码是相同的。在原码和补码表示法中，正数的最高位（符号位）都是0，其余各位（数值位）不变。
在8位二进制表示中，数-5的补码是多少？
答案: A. 11111011
解析: 要找到-5的补码，首先确定5的二进制表示（00000101），然后对这个数取反得到反码（11111010），最后给反码加1得到补码（11111011）。
反码用于解决哪个数的表示问题？
答案: B. 负整数
解析: 反码主要用于表示负数。在反码表示法中，负数的最高位为1，其余各位是该数的绝对值的二进制表示的反码（即0变1，1变0）。
在补码编码中，最高位（符号位）为1通常表示什么？
答案: B. 负数
解析: 在补码表示法中，最高位为1通常表示该数为负数。补码用于简化二进制的加减运算，特别是负数的表示和运算。
在8位二进制表示中，数7的反码是多少？
答案: A. 00000111
解析: 正数的反码与其原码相同。因此，数7（原码为00000111）的反码也是00000111。
在补码表示中，-0和+0是否有不同的表示？
答案: B. 没有
解析: 在补码表示法中，+0和-0的表示是相同的，均为全0。这解决了原码和反码表示中0的符号歧义问题。
补码表示法的主要优点是什么？
答案: D. A和B都是
解析: 补码表示法的主要优点是它简化了加法运算，并为正数和负数提供了统一的表示方式。在补码系统中，加法和减法可以统一为加法运算。
哪一种编码方式可以直接用于加法运算？
答案: C. 补码
解析: 补码是唯一一种可以直接用于加法运算的编码方式，因为它解决了负数的表示和运算问题，使得加法和减法都可以简单地使用加法来实现。
在补码表示中，一个数和它的补数相加的结果是什么？
答案: A. 0
解析: 在补码表示中，一个数和它的补数相加的结果总是0。例如，一个数的补码加上它的原码（如果是负数的话）总是等于0。
在8位二进制补码表示中，-128的表示是什么？
答案: A. 10000000
解析: 在8位二进制补码表示中，-128是一个特殊情况，它的补码和原码相同，均为10000000。这是因为在8位二进制中，-128无法用常规的取反加一得到补码的方法表示。
对于8位二进制数，以下哪个是-1的补码表示？
答案: A. 11111111
解析: 在补码表示法中，-1的补码是所有位均为1的二进制数。这是因为1的原码是00000001，取反后得到11111110，加1得到11111111。
在反码表示中，正数和负数的最高位分别是什么？
答案: A. 0和1
解析: 在反码表示中，正数的最高位（符号位）是0，负数的最高位是1。反码表示法中，正数的反码与其原码相同，而负数的反码是其绝对值原码的每一位取反。
为什么在计算机中使用补码而不是原码来表示负数？
答案: C. 补码简化了加法和减法运算
解析: 使用补码而不是原码来表示负数是因为补码可以简化二进制的加减运算。在补码系统中，可以直接进行加法运算，而不需要根据数的符号进行不同的运算过程。
在计算机中，整数通常用哪种编码方式表示？
答案: C. 补码
解析: 计算机系统通常使用补码来表示整数，因为补码能够简化硬件设计，特别是在进行加法和减法运算时。
哪种编码方式中，负数的表示是其对应正数的二进制表示的每一位取反？
答案: B. 反码
解析: 在反码表示中，负数的表示是其对应正数的二进制表示的每一位取反（0变1，1变0），而最高位（符号位）变为1。
在8位二进制补码表示中，最大的正数是多少？
答案: A. 01111111
解析: 在8位二进制补码表示中，最大的正数是01111111，对应十进制中的127。这是因为符号位为0（表示正数），其余位全部为1。
补码系统中，哪一个数的原码、反码、补码表示相同？
答案: A C
解析: 在补码系统中，0和1是唯一一个其原码、反码、补码表示都相同的数。无论是正0还是负0，它们在原码、反码、补码中的表示都是全0。
首先，我们要找到+5的原码。在一个8位的系统中，+5的原码是：00000101
现在，为了得到-5的反码，我们需要将+5的原码中的数值位取反，但保持符号位不变。这意味着每个0变成1，每个1变成0，除了最左边的符号位。所以，-5的反码是：
11111010
因此，正确答案是 C. 11111010。
如果一个8位二进制数的补码是11111000，那么它的十进制值是多少？
答案: A. -8
解析: 11111000的补码表示负数，首先减1得到11110111，然后取反得到00001000，即十进制的8，因此原数是-8。
在计算机中，使用补码表示有助于解决哪个问题？
答案: C. 负数的加法运算
解析: 使用补码表示有助于简化负数的加法运算。在补码系统中，加法和减法可以统一为加法运算
代码填空题
当然，让我们逐个解答这些问题，并详细解释计算过程：
当然，让我详细解释如何将8位二进制补码 11001010 转换为十进制数。
检查符号位：
在二进制补码表示中，最左边的位是符号位。如果符号位为1，则表示它是一个负数。在我们的例子中，符号位是1，所以 11001010 表示一个负数。
将补码转换为原码：
11001010 减去1得到 11001001。11001001 取反（除符号位）得到 10110110。10110110 转换为十进制。我们先计算除符号位外的数值部分：0110110，转换为十进制：[ 2^5 + 2^4 + 2^2 + 2^1 ] = [ 32 + 16 + 4 + 2 ] = 54。 11001010 的十进制表示是 -54。-9的8位二进制原码表示：
整数15的8位二进制补码表示：
8位二进制原码01101001的反码表示：
1、判断给出的数是正数还是负数
如果给出的是二进制数就看最高位
为0则正 为1则负2、正数反码补码跟原码全部相同3、负数才是需要计算
符号位不变，其余位是0变1 1变0
补码是反码+1
8位二进制补码10001011的反码表示：
8位二进制原码01000101的补码表示：
在计算机中，负整数通常使用二进制补码形式表示。要将负整数 -32 转换为 8 位二进制补码，可以按照以下步骤进行：1. 找到 32 的二进制表示：首先将正数 32 转换为二进制形式。32 的二进制表示是 100000，但我们需要 8 位，所以在前面补零，变成 00100000。2. 求反：接下来将所有的位取反（0 变成 1，1 变成 0）。所以 00100000 变成 11011111。3. 加一：最后，将取反后的结果加上 1。因此，11011111 + 1 = 11100000。所以，-32 在 8 位二进制补码表示中是 11100000。为了将 8 位二进制补码 11111110 转换为十进制表示，可以按照以下步骤进行：1. 确认符号位：在补码表示中，最左边的一位是符号位。如果符号位是 1，那么这个数是负数。在这个例子中，最左边的位是 1，所以它是一个负数。2. 找到补码的原码：对于负数的补码，首先将其除了符号位之外的其他位取反（1 变成 0，0 变成 1），然后加 1。因此，11111110 取反后是 00000001，加 1 后变成 00000010。3. 将原码转换为十进制：现在我们将 00000010 转换为十进制。这个二进制数代表的是十进制的 2。4. 应用符号：由于原来的数是负数，所以我们需要在这个结果前加上负号。因此，二进制补码 11111110 在十进制中表示为 -2。要将正整数 +17 转换为 8 位二进制补码，可以按照以下步骤进行：1. 将 +17 转换为二进制：首先，将 +17 转换成二进制形式。17 的二进制是 10001。2. 补齐 8 位：由于我们需要 8 位的表示，我们在这个二进制数的前面补零，直到长度达到 8 位。所以 10001 变成 00010001。3. 对于正数，其二进制表示与二进制补码相同：因为 +17 是一个正整数，它的二进制表示就是它的二进制补码。因此，正整数 +17 的 8 位二进制补码表示为 00010001。若一个数的 8 位二进制补码为 11110111，则其原码表示可以按照以下步骤得到：1. 确认符号位：在补码表示中，最左边的一位是符号位。如果符号位是 1，那么这个数是负数。在这个例子中，最左边的位是 1，所以它是一个负数。2. 对于负数的补码，首先将除了符号位之外的其他位取反：11110111 除符号位外的取反结果是 00001000。3. 然后加 1：00001000 加 1 变成 00001001。4. 保留符号位：由于原来的数是负数，所以我们需要在这个结果前加上负号符号位。因此，这个数的原码表示为 10001001。答案: A. 00011011
解析:
将+27转换为二进制: 27 = 16 + 8 + 2 + 1 = 11011
补齐8位: 00011011
答案: A. 11110011
解析:
将13转换为二进制: 13 = 8 + 4 + 1 = 1101
补齐8位: 00001101
取反: 11110010
加1: 11110010 + 1 = 11110011
答案: A. 原码: 10100000，补码: 11000000
解析:
原码（负数）: 符号位1，其余与正数32的二进制相同: 10100000
补码: 取反: 11011111，加1: 11011111 + 1 = 11000000
答案: B. 10010100
解析:
补码: 11101100
反码（减1）: 11101011
原码（取反，除了符号位）: 10010100
答案: B. 11111001
解析:
将7转换为二进制: 7 = 4 + 2 + 1 = 111
补齐8位: 00000111
取反（反码）: 11111000
因为是-7，所以反码是11111000
答案: A. 0
解析:
任何数和它的相反数相加，结果为0。在补码表示中，一个数的相反数是它的补码的取反再加1。相加后，所有位上的数值都会抵消为0。
答案: B. -10
解析:
原码10001010表示一个负数，其绝对值是001010 = 2 + 8 = 10，所以原码表示-10。
答案: C. 11111111
解析:
-128的补码: 10000000
+1的补码: 00000001
相加: 10000000 + 00000001 = 10000001，由于溢出，最高位被忽略，结果为11111111。
答案: D. 01110001
解析:
-120的补码: 原码: 11111000, 取反: 00000111, 加1: 00001000
+15的补码: 00001111
相加: 00001000 + 00001111 = 00010111 = 01110001
答案: D. 00000000
解析:
+127原码: 01111111
-127原码: 11111111
相加: 01111111 + 11111111 = 00000000 (溢出，符号位忽略)
答案: C. 11111111
解析:
最小负数（-128）的补码: 10000000
减1操作相当于加-1: 10000000 + 11111111 = 011111111 (溢出，符号位忽略，结果是11111111)
答案: A. 00010011
解析:
十进制19转换为二进制: 00010011
答案: B. 1
解析:
补码表示中，负数的最高位（符号位）总是1。
答案: B. 11010101
解析:
由于最高位是1，表示负数，反码计算为补码减1然后取反:
减1: 10101010 - 1 = 10101001
取反: 11010101
答案: C. 10110011
解析:
十进制45转换为二进制: 00101101
取反: 11010010
加1: 11010010 + 1 = 10110011
答案: B. 00000000
解析:
+32的补码: 00100000
-32的补码: 11100000
相加: 00100000 + 11100000 = 00000000
答案: C. 10010100
解析:
由于最高位是1，表示负数，补码计算为反码加1:
反码: 11101010
加1: 11101010 + 1 = 10010100
答案: A. 00000000
解析:
-1的补码: 11111111
+1的补码: 00000001
相加: 11111111 + 00000001 = 00000000 (溢出，符号位忽略)
答案: A. -27
解析:
由于最高位是1，表示负数：
反码: 11100100
原码: 10011011 (即-27)
答案: A. -54
解析:
由于最高位是1，表示负数：
反码: 11001001
原码: 10110110 (即-54)
进制转换总结：1、R进制转10进制按权展开2、10进制转R进制短除法十进制转二进制整数部分：短除法/2小数部分：小数部分乘2取整数部分0.625 × 2 = 1.25（整数部分 1，留下小数 .25）0.25 × 2 = 0.5（整数部分 0，留下小数 .5）0.5 × 2 = 1.0（整数部分 1） 小数部分 .625 的二进制表示是 .101。十进制转八进制整数部分：短除法/16小数部分：小数部分乘8取整数部分小数部分（十进制到八进制）: 0.2 × 8 = 1.6（整数部分 1，留下小数 .6）0.6 × 8 = 4.8（整数部分 4） 小数部分 .2 的八进制表示是 .14。十进制转十六进制整数部分：短除法/16小数部分：小数部分乘16取整数部分二进制转10进制整数部分：按权展开整数部分（二进制到十进制）: - 10101 = 1*2^4 + 0*2^3 + 1*2^2 + 0*2^1 + 1*2^0 = 16 + 0 + 4 + 0 + 1 = 21二进制到十进制）: .101 = 1*2^-1 + 0*2^-2 + 1*2^-3 = 0.5 + 0 + 0.125 = 0.625参考第二题八进制转10进制整数部分（八进制到十进制）:- 73 = 7*8^1 + 3*8^0 = 56 + 3 = 59小数部分（八进制到十进制）:
- .5 = 5*8^-1 = 5/8 = 0.625八进制数 73.5 的十进制表示是 59.625。参考第五题十六进制转10进制参考第七题二进制转八进制（每三位二进制转一位八进制）整数部分：从右边开始取 ，不够的高位（左边补0）小数部分：从左边开始取，不够的低位（右边补0）11011.11整数部分：011011 = 3 3小数部分：110 = 6结果（33.6)_8二进制转十六进制（每四位二进制转一位十六进制）整数部分：从右边开始取 ，不够的高位（左边补0）小数部分：从左边开始取，不够的低位（右边补0）二进制数 110.101 转换为十六进制数是 ________。整数部分：0110 = 6小数部分：1010=10（A）记得大于等于10的需要转换成字符答案：（6.A)_16参考第八题八进制转二进制（每位8进制转3位二进制）64.5整数部分：6 = 110 4= 100小数部分：5=101110100.101十六进制转二进制（每位十六进制转4位二进制）64.5整数部分：6 = 0110 4= 0100小数部分：5=0101答案：01100100.0101选择题
1、十进制数 45.625 转换为二进制数是多少？
A. 101101.101
B. 101101.01
C. 110110.101
D. 101110.101
2、二进制数 1101.101 转换为十进制数是多少？
A. 13.625
B. 13.75
C. 12.625
D. 12.75
3、十六进制数 3A.9 转换为十进制数是多少？
A. 58.5625
B. 58.75
C. 59.5625
D. 59.75
4、八进制数 127.4 转换为十进制数是多少？
A. 87.5
B. 88.5
C. 87.75
D. 88.75
5、十进制数 101.2 转换为八进制数是多少？
A. 145.16
B. 145.14
C. 146.14
D. 146.16
6、二进制数 1010.11 转换为十六进制数是多少？
A. A.C
B. A.3
C. B.6
D. B.3
7、十六进制数 F.4 转换为二进制数是多少？
A. 1111.01
B. 1111.0011
C. 1111.0100
D. 1111.1
8、八进制数 34.2 转换为二进制数是多少？
A. 11100.01
B. 110100.01
C. 11100.1
D. 011100.010
9、十进制数 75.375 转换为二进制数是多少？
A. 1001011.011
B. 1001011.001
C. 1001101.011
D. 1001101.001
10、十六进制数 2E.1C 转换为十进制数是多少？
A. 46.171875
B. 47.171875
C. 46.1875
D. 47.1875
填空题
1、十进制数 32.75 转换为二进制数是 ________。
2、二进制数 10101.101 转换为十进制数是 ________。
3、十六进制数 1A.3F 转换为二进制数是 ________。
4、二进制数 11100.011 转换为八进制数是 ________。
5、八进制数 73.5 转换为十进制数是 ________。
6、十进制数 58.1875 转换为十六进制数是 ________。
7、十六进制数 B.4 转换为十进制数是 ________。
8、二进制数 110.101 转换为十六进制数是 ________。
9、十进制数 99.5625 转换为八进制数是 ________。
10、八进制数 21.2 转换为二进制数是 ________。
答案: A. 101101.101
解析:
整数部分（十进制到二进制）:
- 45 ÷ 2 = 22 余 1
- 22 ÷ 2 = 11 余 0
- 11 ÷ 2 = 5 余 1
- 5 ÷ 2 = 2 余 1
- 2 ÷ 2 = 1 余 0
- 1 ÷ 2 = 0 余 1
反向排列余数，得到 45 的二进制表示为 101101。小数部分（十进制到二进制）:
- 0.625 × 2 = 1.25（整数部分 1，留下小数 .25）
- 0.25 × 2 = 0.5（整数部分 0，留下小数 .5）
- 0.5 × 2 = 1.0（整数部分 1）
小数部分 .625 的二进制表示是 .101。将整数部分和小数部分的结果合并，十进制数 45.625 的二进制表示是 101101.101。
答案: A. 13.625
解析:
整数部分（二进制到十进制）:
- 1101 = 1*2^3 + 1*2^2 + 0*2^1 + 1*2^0 = 8 + 4 + 0 + 1 = 13
小数部分（二进制到十进制）:
- .101 = 1*2^-1 + 0*2^-2 + 1*2^-3 = 1/2 + 0 + 1/8 = 0.5 + 0.125 = 0.625
二进制数 1101.101 的十进制表示是 13.625。
答案: A. 58.5625
解析:
整数部分（十六进制到十进制）:
- 3A = 3*16^1 + A*16^0 = 3*16 + 10 = 48 + 10 = 58
小数部分（十六进制到十进制）:
- .9 = 9*16^-1 = 9/16 = 0.5625
十六进制数 3A.9 的十进制表示是 58.5625。
答案: A. 87.5
解析:
整数部分（八进制到十进制）:
- 127 = 1*8^2 + 2*8^1 + 7*8^0 = 64 + 16 + 7 = 87
小数部分（八进制到十进制）:
- .4 = 4*8^-1 = 4/8 = 0.5
八进制数 127.4 的十进制表示是 87.5。
答案: B. 145.14
解析:
整数部分（十进制到八进制）:
- 101 ÷ 8 = 12 余 5
- 12 ÷ 8 = 1 余 4
- 1 ÷ 8 = 0 余 1
反向排列余数，得到 101 的八进制表示为 145。小数部分（十进制到八进制）:
- 0.2 × 8 = 1.6（整数部分 1，留下小数 .6）
- 0.6 × 8 = 4.8（整数部分 4）
小数部分 .2 的八进制表示是 .14。将整数部分和小数部分的结果合并，十进制数 101.2 的八进制表示是 145.14。
答案: A. A.C
解析:
整数部分（二进制到十六进制）:
- 1010 = 1010（二进制）= A（十六进制）
小数部分（二进制到十六进制）:
- .11 补零为 .1100
- .1100 = 1100（二进制）= C（十六进制）
二进制数 1010.11 的十六进制表示是 A.C。
答案: C. 1111.0100
解析:
整数部分（十六进制到二进制）:
- F = 1111（二进制）
小数部分（十六进制到二进制）:
- .4 = .0100（二进制）
十六进制数 F.4 的二进制表示是 1111.0100。
答案: D. 011100.010
解析:
整数部分（八进制到二进制）:
- 34 = 3*8^1 + 4*8^0 = 011（二进制）+ 100（二进制）= 011100（二进制）
小数部分（八进制到二进制）:
- .2 = .010（二进制）
八进制数 34.2 的二进制表示是 011100.010。
答案: A. 1001011.011
解析:
整数部分（十进制到二进制）:
- 75 ÷ 2 = 37 余 1
- 37 ÷ 2 = 18 余 1
- 18 ÷ 2 = 9 余 0
- 9 ÷ 2 = 4 余 1
- 4 ÷ 2 = 2 余 0
- 2 ÷ 2 = 1 余 0
- 1 ÷ 2 = 0 余 1
反向排列余数，得到 75 的二进制表示为 1001011。小数部分（十进制到二进制）:
- 0.375 × 2 = 0.75（整数部分 0，留下小数 .75）
- 0.75 × 2 = 1.5（整数部分 1，留下小数 .5）
- 0.5 × 2 = 1.0（整数部分 1）
小数部分 .375 的二进制表示是 .011。将整数部分和小数部分的结果合并，十进制数 75.375 的二进制表示是 1001011.011。
答案: A. 46.171875
解析:
整数部分（十六进制到十进制）:
- 2E = 2*16^1 + E*16^0 = 2*16 + 14 = 32 + 14 = 46
小数部分（十六进制到十进制）:
- .1C = 1*16^-1 + C*16^-2 = 1/16 + 12/256 = 0.0625 + 0.046875 = 0.109375
十六进制数 2E.1C 的十进制表示是 46.109375。
填空题：
答案: 100000.11
解析:
整数部分（十进制到二进制）:
- 32 ÷ 2 = 16 余 0
- 16 ÷ 2 = 8 余 0
- 8 ÷ 2 = 4 余 0
- 4 ÷ 2 = 2 余 0
- 2 ÷ 2 = 1 余 0
- 1 ÷ 2 = 0 余 1
反向排列余数，得到 32 的二进制表示为 100000。小数部分（十进制到二进制）:
- 0.75 × 2 = 1.5（整数部分 1，留下小数 .5）
- 0.5 × 2 = 1.0（整数部分 1）
小数部分 .75 的二进制表示是 .11。将整数部分和小数部分的结果合并，十进制数 32.75 的二进制表示是 100000.11。
答案: 21.625
解析:
整数部分（二进制到十进制）:
- 10101 = 1*2^4 + 0*2^3 + 1*2^2 + 0*2^1 + 1*2^0 = 16 + 0 + 4 + 0 + 1 = 21
小数部分（二进制到十进制）:
- .101 = 1*2^-1 + 0*2^-2 + 1*2^-3 = 0.5 + 0 + 0.125 = 0.625
二进制数 10101.101 的十进制表示是 21.625。
答案: 11010.00111111
解析:
整数部分（十六进制到二进制）:
- 1A = 1*16^1 + A*16^0 = 0001 1010 (二进制)
小数部分（十六进制到二进制）:
- .3F = 0011 (二进制) .1111 (二进制)
十六进制数 1A.3F 的二进制表示是 11010.00111111。
答案: 70.3
解析:
整数部分（二进制到八进制）:
- 11100 = 111 00 = 7 4 (八进制)
小数部分（二进制到八进制）:
- .011 = .011 (二进制) = .3 (八进制)
二进制数 11100.011 的八进制表示是 70.3。
答案: 59.625
解析:
整数部分（八进制到十进制）:
- 73 = 7*8^1 + 3*8^0 = 56 + 3 = 59
小数部分（八进制到十进制）:
- .5 = 5*8^-1 = 5/8 = 0.625
八进制数 73.5 的十进制表示是 59.625。
答案: 3A.3
解析:
整数部分（十进制到十六进制）:
- 58 ÷ 16 = 3 余 10 (即 A)
反向排列余数，得到 58 的十六进制表示为 3A。小数部分（十进制到十六进制）:
- 0.1875 × 16 = 3.0（整数部分 3）
小数部分 .1875 的十六进制表示是 .3。将整数部分和小数部分的结果合并，十进制数 58.1875 的十六进制表示是 3A.3。
答案: 11.25
解析:
整数部分（十六进制到十进制）:
- B = 11 (十进制)
小数部分（十六进制到十进制）:
- .4 = 4*16^-1 = 4/16 = 0.25
十六进制数 B.4 的十进制表示是 11.25。
答案: 6.8
解析:
整数部分（二进制到十六进制）:
- 110 = 110 (二进制) = 6 (十六进制)
小数部分（二进制到十六进制）:
- .101 补零为 .1000
- .1000 = 8 (十六进制)
二进制数 110.101 的十六进制表示是 6.8。
答案: 143.44
解析:
整数部分（十进制到八进制）:
- 99 ÷ 8 = 12 余 3
- 12 ÷ 8 = 1 余 4
- 1 ÷ 8 = 0 余 1
反向排列余数，得到 99 的八进制表示为 143。小数部分（十进制到八进制）:
- 0.5625 × 8 = 4.5（整数部分 4，留下小数 .5）
- 0.5 × 8 = 4.0（整数部分 4）
小数部分 .5625 的八进制表示是 .44。将整数部分和小数部分的结果合并，十进制数 99.5625 的八进制表示是 143.44。
答案: 10001.01
解析:
整数部分（八进制到二进制）:
- 21 = 2*8^1 + 1*8^0 = 010 001 (二进制)
小数部分（八进制到二进制）:
- .2 = .010 (二进制)
八进制数 21.2 的二进制表示是 10001.01。
1、在C++中，如果 int a = 5; int b = 3;，则 (a & b) 的结果是多少？
A. 1
B. 7
C. 0
D. 3
2、在C++中，如果 int a = 4; int b = 5;，则 (a | b) 的结果是多少？
A. 4
B. 5
C. 1
D. 9
3、在C++中，~0 的结果是多少？
A. -1
B. 0
C. 1
D. 无法确定
4、在C++中，如果 int a = 5;，则 a << 2 的结果是多少？
A. 10
B. 20
C. 15
D. 25
5、在C++中，如果 int a = 8;，则 a >> 1 的结果是多少？
A. 4
B. 8
C. 16
D. 0
6、在C++中，如果 int a = 5; int b = 3;，则 (a ^ b) 的结果是多少？
A. 6
B. 7
C. 8
D. 1
7、在C++中，执行 int a = 2; a <<= 3; 后，a的值是多少？
A. 5
B. 8
C. 6
D. 16
8、在C++中，执行 int a = 16; a >>= 2; 后，a的值是多少？
A. 4
B. 8
C. 16
D. 32
9、在C++中，如果 int a = 5;，则 ~a 的结果是多少？
A. -6
B. -5
C. 4
D. -4
10、在C++中，如果 int a = 4; int b = 5;，则 (!(a & b)) 的结果是多少？
A. True
B. False
C. 4
D. 0
填空题
1、在C++中，如果 int a = 6;，则 a & 3 的结果是 _____.
2、在C++中，如果 int a = 7; int b = 5;，则 (a | b) 的结果是 _____.
3、如果 int a = 2;，则 a << 1 的结果是 _____.
4、如果 int a = 9;，则 a >> 2 的结果是 _____.
5、在C++中，如果 int a = 5; int b = 5;，则 (a ^ b) 的结果是 _____.
6、在C++中，执行 int a = 1; a <<= 4; 后，a的值是 _____.
7、在C++中，执行 int a = 15; a >>= 1; 后，a的值是 _____.
8、在C++中，如果 int a = 8;，则 ~a 的结果是 _____.
9、在C++中，如果 int a = 3; int b = 2;，则 (!(a & b)) 的结果是 _____.
10、在C++中，如果 int a = 14; int b = 9;，则 (a & b) 的结果是 _____.
选择题解析
(a & b) 的结果是多少？
a & b 是按位与操作。5的二进制表示为0101，3的二进制表示为0011，按位与的结果是0001，即十进制中的1。(a | b) 的结果是多少？
a | b 是按位或操作。4的二进制表示为0100，5的二进制表示为0101，按位或的结果是0101，即十进制中的9。~0 的结果是多少？
~0 是按位取反操作。0的所有位都是0，取反后变成了全1，这在补码表示法中等同于-1。a << 2 的结果是多少？
a << 2 是将a的二进制表示向左移动2位。5的二进制是0101，左移两位变成10100，即十进制中的20。a >> 1 的结果是多少？
a >> 1 是将a的二进制表示向右移动1位。8的二进制是1000，右移一位变成0100，即十进制中的4。(a ^ b) 的结果是多少？
a ^ b 是按位异或操作。5的二进制表示为0101，3的二进制表示为0011，异或的结果是0110，即十进制中的6。7. 执行 a <<= 3; 后，a的值是多少？
a <<= 3 是将a的二进制表示向左移动3位。2的二进制是10，左移三位变成10000，即十进制中的16。执行 a >>= 2; 后，a的值是多少？
a >>= 2 是将a的二进制表示向右移动2位。16的二进制是10000，右移两位变成0100，即十进制中的4。~a 的结果是多少？
~a 是按位取反操作。5的二进制表示为0101，取反后变成1010，这在补码表示法中等同于-6。(!(a & b)) 的结果是多少？
a & b 是按位与操作。4的二进制是0100，5的二进制是0101，按位与的结果是0100，即非零值。! 是逻辑非操作，将非零值转换为False。填空题解析
a & 3 的结果是 _____.
a & 3 是按位与操作。6的二进制表示为0110，3的二进制表示为0011，按位与的结果是0010，即十进制中的2。(a | b) 的结果是 _____.
| b 是按位或操作。7的二进制表示为0111，5的二进制表示为0101，按位或的结果是0111`，即十进制中的7。
a << 1 的结果是 _____.
a << 1 是将a的二进制表示向左移动1位。2的二进制是10，左移一位变成100，即十进制中的4。a >> 2 的结果是 _____.
a >> 2 是将a的二进制表示向右移动2位。9的二进制是1001，右移两位变成0010，即十进制中的2。(a ^ b) 的结果是 _____.
a ^ b 是按位异或操作。5的二进制表示为0101，另一个5的二进制表示为0101，异或的结果是0000，即十进制中的0。a <<= 4; 后，a的值是 _____.
a <<= 4 是将a的二进制表示向左移动4位。1的二进制是1，左移四位变成10000，即十进制中的16。a >>= 1; 后，a的值是 _____.
a >>= 1 是将a的二进制表示向右移动1位。15的二进制是1111，右移一位变成0111，即十进制中的7。~a 的结果是 _____.
~a 是按位取反操作。8的二进制表示为1000，取反后变成0111，这在补码表示法中等同于-9。(!(a & b)) 的结果是 _____.
a & b 是按位与操作。3的二进制是0011，2的二进制是0010，按位与的结果是0010，即非零值。! 是逻辑非操作，将非零值转换为False。(a & b) 的结果是 _____.
a & b 是按位与操作。14的二进制是1110，9的二进制是1001，按位与的结果是1000，即十进制中的8。选择题
1、在C++中，如果 int a = 4; int b = 5;，则 (a ^ b ^ b) 的结果是多少？
A. 0
B. 4
C. 5
D. 9
2、在C++中，如果 int a = 7; int b = 7;，则 a & ~b 的结果是多少？
A. 0
B. 7
C. 14
D. 1
3、在C++中，-1 >> 1 的结果是多少？
A. 0
B. -1
C. 1
D. -2
4、在C++中，如果 int a = 6;，则 (a >> 1) & 1 的结果是多少？
A. 0
B. 1
C. 2
D. 3
5、在C++中，如果 int a = 5;，则 a ^ (~a) 的结果是多少？
A. -1
B. 0
C. 1
D. 10
6、在C++中，如果 unsigned int a = 1;，则 (a << 31) >> 31 的结果是多少？
A. 0
B. 1
C. 2
D. -1
7、在C++中，如果 int a = 2;，则 a | (a << 1) 的结果是多少？
A. 2
B. 3
C. 4
D. 6
8、在C++中，如果 int a = 1; int b = 2;，则 a & b 的结果是多少？
A. 0
B. 1
C. 2
D. 3
9、在C++中，如果 int a = 1;，则 ~(a << 4) 的结果是多少？
A. -16
B. -17
C. 15
D. 16
10、在C++中，如果 int a = 8;，则 a >> 3 的结果是多少？
A. 0
B. 1
C. 2
D. 3
填空题
1、在C++中，如果 int a = 3; int b = 6;，则 a ^ b 的结果是 _____.
2、在C++中，如果 int a = 5;，则 a << 3 的结果是 _____.
3、如果 int a = 9;，则 a & (a - 1) 的结果是 _____.
4、如果 int a = 15;，则 a >> 2 的结果是 _____.
5、在C++中，如果 int a = 1;，则 ~a 的结果是 _____.
6、在C++中，执行 int a = 2; a <<= 2; 后，a的值是 _____.
7、在C++中，执行 int a = 14; a >>= 1; 后，a的值是 _____.
8、在C++中，如果 unsigned int a = 1;，则 a << 31 的结果是 _____.
9、在C++中，如果 int a = 10; int b = 12;，则 (a | b) & a 的结果是 _____.
10、在C++中，如果 int a = 7;，则 (a << 1) + (a >> 1) 的结果是 _____.
选择题解析
(a ^ b ^ b) 的结果是多少？
a = 4，在二进制中表示为 0100b = 5，在二进制中表示为 0101b ^ b 操作：0101 ^ 0101。由于异或操作是相同为0，不同为1，因此这里结果为 0000a ^ (b ^ b) 操作：0100 ^ 0000。任何数与0进行异或操作结果都是该数本身，所以结果是 01000100 对应十进制中的4a & ~b 的结果是多少？
a = 7 和 b = 7，在二进制中均表示为 0111~b 是对b进行按位取反操作：0111 取反变为 1000a & ~b 操作：0111 & 1000。按位与操作中，只有同时为1的位结果才为1，这里没有位同时为1，所以结果是 00000000 对应十进制中的0-1 >> 1 的结果是多少？
-1 在二进制中的补码表示为所有位都是1，例如在32位系统中为 11111111 11111111 11111111 11111111>> 1 操作，即右移一位。对于有符号整数，右移通常是算术右移，会保留符号位。因此，-1 右移一位仍然是所有位都是1-1(a >> 1) & 1 的结果是多少？
a = 6，在二进制中表示为 0110a >> 1 操作，即右移一位：0110 右移一位变为 0011(a >> 1) & 1 操作：0011 & 0001。只有最低位同时为1，所以结果是 00010001 对应十进制中的1a ^ (~a) 的结果是多少？
a = 5，在二进制中表示为 0101~a 是对a进行按位取反操作：0101 取反变为 1010a ^ (~a) 操作：0101 ^ 1010。异或操作中，相反位的结果为1，所以这里结果是 11111111 在补码表示法中代表-1（因为补码的-1的表示是所有位为1）-1在C++中，执行 unsigned int a = 1; 后 (a << 31) >> 31 的结果是多少？
a = 1，在32位无符号整型中表示为 0000 0000 0000 0000 0000 0000 0000 0001。a << 31：这是将 a 的二进制表示左移31位。左移操作后，最高位（第32位）变成1，其余位变成0，结果是 1000 0000 0000 0000 0000 0000 0000 0000。(a << 31) >> 31：这是将上一步的结果右移31位。由于 a 是无符号整数，右移操作不会保留符号位，而是简单地在左侧插入0。因此，右移31位后，原来的最高位移动到最低位，其余位都是0，结果是 0000 0000 0000 0000 0000 0000 0000 0001。0000 0000 0000 0000 0000 0000 0000 0001，在十进制中表示为1。在C++中，如果 int a = 2;，则 a | (a << 1) 的结果是多少？
a = 2 在二进制中表示为 0000 0000 0000 0000 0000 0000 0000 0010a << 1 表示将 a 的二进制表示左移一位，结果为 0000 0000 0000 0000 0000 0000 0000 0100a | (a << 1) 表示 2 | 4，在二进制中为 0000 0000 0000 0000 0000 0000 0000 0010 | 0000 0000 0000 0000 0000 0000 0000 0100，结果为 0000 0000 0000 0000 0000 0000 0000 0110在C++中，如果 int a = 1; int b = 2;，则 a & b 的结果是多少？
a = 1 在二进制中表示为 0001，b = 2 在二进制中表示为 0010a & b 计算为 0001 & 0010，由于没有一个位在两个数字中同时为1，所以结果为 0000在C++中，如果 int a = 1;，则 ~(a << 4) 的结果是多少？
a = 1 在二进制中表示为 0000 0000 0000 0000 0000 0000 0000 0001a << 4 表示将 a 左移4位，结果为 0000 0000 0000 0000 0000 0000 0001 0000（即16）~(a << 4) 表示对上一步的结果取反，结果为 1111 1111 1111 1111 1111 1111 1110 1111，在补码表示法中，这对应于-17在C++中，如果 int a = 8;，则 a >> 3 的结果是多少？
a = 8 在二进制中表示为 0000 0000 0000 0000 0000 0000 0000 1000a >> 3 表示将 a 右移3位，结果为 0000 0000 0000 0000 0000 0000 0000 0001（即1）在C++中，如果 int a = 3; int b = 6;，则 a ^ b 的结果是 _____.
答案: 5
解析:
a ^ b = 3 ^ 6
二进制表示：3 = 011, 6 = 110
011 ^ 110 = 101 (二进制)，即 5 (十进制)
int a = 5;，则 a << 3 的结果是 _____.答案: 40
解析:
a << 3 = 5 << 3
二进制表示：5 = 101
左移三位得到 101000 (二进制)，即 40 (十进制)
int a = 9;，则 a & (a - 1) 的结果是 _____.答案: 8
解析:
a & (a - 1) = 9 & (9 - 1)
二进制表示：9 = 1001, 8 = 1000
1001 & 1000 = 1000 (二进制)，即 8 (十进制)
int a = 15;，则 a >> 2 的结果是 _____.答案: 3
解析:
a >> 2 = 15 >> 2
二进制表示：15 = 1111
右移两位得到 11 (二进制)，即 3 (十进制)
int a = 1;，则 ~a 的结果是 _____.答案: -2
解析:
~a = ~1
二进制表示：1 = 0001
按位取反得到 1110 (二进制)的补码，即 -2 (十进制)
int a = 2; a <<= 2; 后，a的值是 _____.答案: 8
解析:
a <<= 2 相当于 a = a << 2
二进制表示：2 = 10
左移两位得到 1000 (二进制)，即 8 (十进制)
int a = 14; a >>= 1; 后，a的值是 _____.答案: 7
解析:
a >>= 1 相当于 a = a >> 1
二进制表示：14 = 1110
右移一位得到 111 (二进制)，即 7 (十进制)
unsigned int a = 1;，则 a << 31 的结果是 _____.答案: 2147483648
解析:
a << 31 = 1 << 31
二进制表示：1 = 1
左移三十一位得到 10000000000000000000000000000000 (二进制)，即 2147483648 (十进制)
int a = 10; int b = 12;，则 (a | b) & a 的结果是 _____.答案: 10
解析:
a | b = 10 | 12
二进制表示：10 = 1010, 12 = 1100
1010 | 1100 = 1110 (二进制)
1110 & 1010 = 1010 (二进制)，即 10 (十进制)
int a = 7;，则 (a << 1) + (a >> 1) 的结果是 _____.答案: 13
解析:
a << 1 = 7 << 1 = 14 (二进制表示：7 = 111, 左移一位得到 1110)
a >> 1 = 7 >> 1 = 3 (二进制表示：7 = 111, 右移一位得到 11)
14 + 3 = 17
补全代码，将十进制数转换为二进制字符串。
string toBinary(int n) {string r;while (n != 0) { r = (n % 2 == 0 ? "0" : "1") + r; n = n ___ 2; }return r;
}
A. +
B. -
C. *
D. /
补全代码，输出一个int数组的所有元素。
void printArray(int arr[], int size) {for (int i = 0; i < ___; i++) {cout << arr[i] << " ";}
}
A. size+1
B. size
C. size-1
D. i++
补全代码，实现位运算中的“或”操作。
int bitwiseOr(int a, int b) {return a ___ b;
}
A. &
B. |
C. ^
D. <<
补全代码，实现位运算中的“异或”操作，这常用于不使用临时变量交换变量值。
void swap(int &a, int &b) {a = a ___ b;b = a ___ b;a = a ___ b;
}
A. |
B. &
C. ^
D. ~
补全代码，实现数组逆序。
void reverseArray(int arr[], int start, int end) {while (start < end) {int temp = arr[start];arr[start] = arr[end];arr[end] = temp;start++;end ___;}
}
A. ++
B. --
C. +=
D. =
补全代码，使用位运算实现整数乘以2。
int multiplyByTwo(int n) {return n ___ 1;
}
A. <<
B. >>
C. +
D. -
补全代码，输出补码形式的一个字节（8位）。
string toComplement(int n) {string r;for (int i = 7; i >= 0; i--) {r = ((n & (1 ___ i)) ? '1' : '0') + r;}return r;
}
A. <<
B. >>
C. +
D. -
补全代码，检查一个数是否为2的幂。
bool isPowerOfTwo(int n) {return n > 0 && (n & (n ___ 1)) == 0;
}
A. +
B. -
C. |
D. ^
补全代码，返回数组中最大元素的索引。
int maxIndex(int arr[], int size) {int maxIdx = 0;for (int i = 1; i < size; i++) {if (arr[i] > arr[maxIdx]) {maxIdx = ___;}}return maxIdx;
}
A. maxIdx
B. i
C. arr[i]
D. arr[maxIdx]
补全代码，使用位运算将一个整数的奇偶性反转（偶数变奇数，奇数变偶数）。
int toggleOddEven(int n) {return n ___ 1;
}
A. |
B. ^
C. &
D. <<
补全代码，返回数组中特定元素的个数。
int countElement(int arr[], int size, int x) {int count = 0;for (int i = 0; i < size;i++) {if (arr[i] == x) {count++;}}return ___;
}
A. count
B. i
C. size
D. x
补全代码，将一个字符数组转换为全部大写。
void toUpperCase(char arr[], int size) {for (int i = 0; i < size; i++) {if (arr[i] >= 'a' && arr[i] <= 'z') {arr[i] = arr[i] ___ 'a' + 'A';}}
}
A. +
B. -
C. *
D. /
补全代码，使用十六进制表示输出一个整数。
void printHex(int n) {cout << ___ << n;
}
A. "0x"
B. hex
C. "#"
D. std::hex
补全代码，实现数组的拷贝。
void copyArray(int src[], int dest[], int size) {for (int i = 0; i < size; i++) {dest[i] = ___;}
}
A. src[i]
B. i
C. size
D. dest[i]
补全代码，计算数组中所有元素的和。
int sumArray(int arr[], int size) {int sum = 0;for (int i = 0; i < size; i++) {sum += arr[i];}return ___;
}
A. sum
B. i
C. arr
D. size
补全代码，实现一个简单的数字过滤器。
void filterEven(int arr[], int size) {for (int i = 0; i < size; i++) {if (arr[i] % 2 == 0) {cout << arr[i] ___;}}
}
A. <<
B. >>
C. +++
D. --
补全代码，实现二进制到十进制的转换。
int binaryToDecimal(string binary) {int decimal = 0;for (int i = 0; i < binary.length(); i++) {if (binary[i] == '1') {decimal += 1 ___ (binary.length() - 1 - i);}}return decimal;
}
A. <<
B. >>
C. +
D. -
补全代码，找出数组中第一个重复的元素。
int findFirstDuplicate(int arr[], int size) {for (int i = 0; i < size; i++) {for (int j = i + 1; j < size; j++) {if (arr[i] == arr[j]) {return ___;}}}return -1; // 未找到重复元素
}
A. arr[i]
B. arr[j]
C. i
D. j
补全代码，计算数组中偶数和奇数的数量。
void countEvenOdd(int arr[], int size, int &evenCount, int &oddCount) {evenCount = oddCount = 0;for (int i = 0; i < size; i++) {if (arr[i] % 2 == 0) evenCount++;else ___;}
}
A. oddCount--
B. oddCount++
C. evenCount--
D. evenCount++
补全代码，实现字符串反转。
string reverseString(string str) {for (int i = 0; i < str.length() / 2; i++) {char temp = str[i];str[i] = str[str.length() - 1 - i];str[str.length() - 1 - i] = ___;}return str;
}
A. temp
B. str[i]
C. i
D. str.length() - 1 - i
除法（D）:
while (n != 0) { r = (n % 2 == 0 ? "0" : "1") + r; n = n ___ 2; }
在这个函数中，我们需要将十进制数n转换为二进制字符串。我们对n进行连续除以2的操作，并将余数作为二进制数字的最低位。这个过程一直持续到n变为0。所以挖空处应该填入除法运算符/，使n每次循环都除以2。
数组大小（B）:
for (int i = 0; i < ___; i++) {cout << arr[i] << " ";
}
我们需要打印数组arr的所有元素，这要求我们遍历整个数组。在C++中，数组的索引是从0开始的，因此，如果数组的大小是size，那么最后一个元素的索引是size - 1。所以，循环应该继续直到i小于size，因此空白处应该填入size。
位或（B）:
return a ___ b;
位或（OR）运算符|是用来对两个数的各个位进行逻辑或操作。如果在相应的位上，a或b的位是1，那么结果位就是1。所以空白处应填入|。
位异或（C）:
a = a ___ b;
b = a ___ b;
a = a ___ b;
异或（XOR）运算符^是用来在不使用临时变量的情况下交换两个变量的值。对于两个位，如果它们不同，结果是1；如果它们相同，结果是0。在第一步，a变成了a和b的异或；在第二步，b变成了新的a（即a ^ b）与原始的b的异或，这实际上给了我们原始的a；最后，在第三步，a（现在是a ^ b）与新的b（即原始的a）进行异或，得到原始的b。因此，空白处应填入^。
递减（B）:
end ___;
为了逆转数组，我们需要交换数组的开始和结束元素，然后向内移动指针，直到它们相遇。这要求start递增和end递减。因此，空白处应填入递减运算符--。
左移（A）:
return n ___ 1;
左移运算符<<可以用来将一个数的所有位向左移动。在这个例子中，我们要将一个数乘以2。二进制向左移动一位等价于乘以2。因此，空白处应填入左移运算符<<。
左移（A）:
r = ((n & (1 ___ i)) ? '1' : '0') + r;
这个函数意在创建一个整数的二进制字符串表示。我们从最高位到最低位检查每个位是否为1。为了得到每个位的值，我们可以将1左移i位，然后与n进行与操作。如果该位是1，这个操作的结果将不为0。因此，空白处应填入左移运算符<<。
减法（B）:
return n > 0 && (n & (n ___ 1)) == 0;
这是一个检查数是否为2的幂的函数。一个数是2的幂当且仅当它的二进制表示中只有一个1，且位于最高位。对这样的数减去1将会得到一个所有比那个1低的位都是1的数。如果我们将这两个数进行与操作，结果应该为0。因此，空白处应填入减法运算符-。
索引（B）:
if (arr[i] > arr[maxIdx]) {maxIdx = ___;
}
如果数组中的当前元素比目前记录的最大值要大，我们就更新最大值的索引。在这种情况下，我们应该将i赋值给maxIdx，因为i是当前元素的索引。所以空白处应填入i。
异或（B）:
return n ___ 1;
异或运算符^在这里用于切换整数的最后一位（最低有效位）。因为二进制中偶数的最后一位是0，奇数的最后一位是1，通过异或1，我们可以将偶数变为奇数，奇数变为偶数。因此，空白处应填入^。
计数变量（A）:
return ___;
这个函数计算数组中特定元素的数量。我们使用count变量来跟踪我们发现元素x的次数。在循环结束后，我们需要返回count。所以空白处应填入count。
减法（B）:
arr[i] = arr[i] ___ 'a' + 'A';
要将小写字母转换为大写，可以将其与'a'的ASCII值相减，然后加上'A'的ASCII值。这样就可以得到相应的大写字母。所以空白处应填入减法运算符-。
十六进制前缀（D）:
cout << ___ << n;
在C++中，std::hex是一个流操纵器，当它被插入到输出流中时，它会导致随后的整数值以十六进制格式输出。所以空白处应填入std::hex。
源数组（A）:
dest[i] = ___;
这个函数是用来将src数组中的元素拷贝到dest数组中。在每次循环中，我们应该将src数组的当前元素赋值给dest数组的对应元素。所以空白处应填入src[i]。
总和变量（A）:
return ___;
这个函数计算数组中所有元素的总和。我们使用变量sum来累加数组中的每个元素。在循环结束后，我们需要返回sum的值。所以空白处应填入sum。
输出操作符（A）:
cout << arr[i] ___;
我们需要打印出数组中的偶数元素。在C++中，<<是插入操作符，用于向输出流中插入数据。因此，空白处应填入<<。
左移（A）:
decimal += 1 ___ (binary.length() - 1 - i);
当我们从二进制字符串中的'1'字符转换为十进制时，我们需要将1左移相应的位数。位数由字符串的长度减去当前字符索引再减1决定。所以空白处应填入左移运算符<<。
数组元素（A）:
return ___;
当我们找到数组中的第一个重复元素时，我们返回该元素。因为i是该元素的索引，所以我们应该返回arr[i]。所以空白处应填入arr[i]。
奇数计数（B）:
else ___;
我们需要计算数组中偶数和奇数的数量。每当我们找到一个奇数时，我们需要增加oddCount的值。所以空白处应填入oddCount++。
临时变量（A）:
str[str.length() - 1 - i] = ___;
在字符串反转函数中，我们交换从两端开始的字符，直到达到中心点。交换过程中，我们使用临时变量temp来保存一个字符，以便我们可以将其与另一端的字符交换。因此，空白处应填入temp。
补全代码，实现将二进制字符串转换为其补码表示的整数值。
int binaryToTwosComplement(const string& bin) {int result = (bin[0] == '1') ? -1 << (bin.length() - 1) : 0;for (size_t i = 1; i < bin.length(); i++) {result |= (bin[i] - '0') << (bin.length() - 1 - i);}return ___;
}
A. result
B. ~result
C. result + 1
D. result - 1
补全代码，计算并返回一个无符号整数中设置位的数量。
int countSetBits(unsigned int n) {int count = 0;while (n) {count += n & 1;n ___ 1;}return count;
}
A. +=
B. -+
C. >>=
D. <<=
补全代码，实现反转32位无符号整数的位。
uint32_t reverseBits(uint32_t n) {uint32_t result = 0;for (int i = 0; i < 32; i++) {result |= (n & 1) << (31 - i);n ___ 1;}return result;
}
A. +=
B. -=
C. >>=
D. <<=
补全代码，找出给定数组中出现次数超过一半的元素。
int majorityElement(vector<int>& nums) {int count = 0, candidate = 0;for (int num : nums) {if (count == 0) {candidate = num;}count += (num == candidate) ? 1 : ___;}return candidate;
}
A. 1
B. -1
C. 0
D. 2
补全代码，计算给定整数的汉明距离。
int hammingDistance(int x, int y) {int xorValue = x ^ y, distance = 0;while (xorValue != 0) {distance += xorValue & 1;xorValue ___ 1;}return distance;
}
A. +=
B. -=
C. >>=
D. <<=
补全代码，使用递归函数计算斐波那契数列的第n项。
int fibonacci(int n) {if (n <= 1) return n;return fibonacci(n - 1) + fibonacci(___);
}
A. n - 2
B. n + 1
C. n * 2
D. n / 2
补全代码，检查一个整数是否为回文数。
bool isPalindrome(int x) {if (x < 0 || (x % 10 == 0 && x != 0)) return false;int revertedNumber = 0;while (x > revertedNumber) {revertedNumber = revertedNumber * 10 + x % 10;x ___ 10;}return x == revertedNumber || x == revertedNumber ___ 10;
}
A. +=
B. /=
C. -=
D. *=
补全代码，找出不使用运算符+和-的方式来加两个整数。
int getSum(int a, int b) {while (b != 0) {unsigned carry = a & b;a = a ^ b;b = carry ___ 1;}return a;
}
A. <<
B. >>
C. +++
D. ---
补全代码，返回在不排序的情况下，第k个最大元素。
int findKthLargest(vector<int>& nums, int k) {priority_queue<int, vector<int>, greater<int>> pq;for (int num : nums) {pq.push(num);if (pq.size() > k) pq.___();}p();
}
A. pop
B. push
C. emplace
D. top
补全代码，实现二分查找算法。
int binarySearch(vector<int>& nums, int target) {int left = 0, right = nums.size() - 1;while (left <= right) {int mid = left + (right - left) / 2;if (nums[mid] == target) return mid;else if (nums[mid] < target) left = mid + ___;else right = mid - ___;}return -1;
}
A. 1
B. 0
C. 2
D. mid
补全代码，判断一个整数是否为2的整数次幂。
bool isPowerOfTwo(int n) {if (n <= 0) return false;return (n & (n - ___)) == 0;
}
A. 1
B. n
C. 2
D. n - 1
补全代码，实现合并两个已排序的数组。
void mergeSortedArrays(vector<int>& nums1, int m, vector<int>& nums2, int n) {int i = m - 1, j = n - 1, k = m + n - 1;while (j >= 0) {if (i >= 0 && nums1[i] > nums2[j]) {nums1[k--] = nums1[i--];} else {nums1[k--] = nums2[j--];}}
}
A. 代码已完整，无需补全。
B. 补全 while 条件中的代码。
C. 补全 if 条件中的代码。
D. 补全 else 分支中的代码。
补全代码，实现一个简单的字符串压缩算法。
string compressString(const string& s) {string output;int count = 1;for (int i = 1; i <= s.length(); ++i) {if (i < s.length() && s[i] == s[i - 1]) {count++;} else {output += s[i - 1] + to_string(count);count = ___;}}return output.length() < s.length() ? output : s;
}
A. 1
B. 0
C. 2
D. count + 1
补全代码，使用位运算实现整数除以2的操作。
int divideByTwo(int n) {return n ___;
}
A. >> 1
B. << 1
C. ^ 1
D. | 1
补全代码，实现检测大写字母的函数。
bool isUppercase(char c) {return (c >= 'A' && c <= 'Z');
}
A. 代码已完整，无需补全。
B. 补全比较运算符。
C. 补全逻辑运算符。
D. 补全条件表达式。
补全代码，实现一个函数，用于判断一个数是否为素数。
bool isPrime(int num) {if (num <= 1) return false;for (int i = 2; i * i <= num; ++i) {if (num % i == ___) return false;}return true;
}
A. 0
B. 1
C. i
D. num
补全代码，实现一个函数，返回数组中第二大的数。
int secondLargest(vector<int>& nums) {int largest = INT_MIN, secondLargest = INT_MIN;for (int num : nums) {if (num > largest) {secondLargest = largest;largest = ___;} else if (num > secondLargest && num < largest) {secondLargest = ___;}}return secondLargest;
}
A. num
B. secondLargest
C. largest
D. INT_MIN
补全代码，实现一个函数，用于旋转数组k次。
void rotateArray(vector<int>& nums, int k) {k %= nums.size();reverse(nums.begin(), nums.begin() + nums.size() - k);reverse(nums.begin() + nums.size() - k, d());reverse(nums.begin(), d());
}
A. 代码已完整，无需补全。
B. 补全 reverse 函数中的参数。
C. 补全对 k 的处理。
D. 补全数组的旋转逻辑。
补全代码，实现一个函数，用于计算两个字符串的最长公共前缀。
string longestCommonPrefix(vector<string>& strs) {if (pty()) return "";string prefix = strs[0];for (int i = 1; i < strs.size(); ++i) {while (strs[i].find(prefix) != 0) {prefix = prefix.substr(0, prefix.length() - 1);if (pty()) return ___;}}return prefix;
}
A. "no common prefix"
B. "common"
C. "prefix"
D. ""
补全代码，实现一个函数，用于将所有零移动到数组的末尾，同时保持非零元素的相对顺序。
void moveZeroes(vector<int>& nums) {for (int lastNonZeroFoundAt = 0, cur = 0; cur < nums.size(); ++cur) {if (nums[cur] != 0) {swap(nums[lastNonZeroFoundAt++], nums[cur]);}}
}
A. 代码已完整，无需补全。
B. 补全 swap 函数中的参数。
C. 补全循环中的条件。
D. 补全非零元素的处理逻辑。
补码转换（A）:
补码是一种用于表示有符号整数的方法，最高位是符号位，正数的补码是其二进制表示，负数的补码是其绝对值的二进制表示取反再加1。在这个问题中，如果第一位是1，我们假设这是一个负数，所以我们用最高位设置为1其余位为0的数字（通过 -1 << (bin.length() - 1)）开始，并且我们通过遍历字符串的其余部分，如果位是1，将相应的位设置为1。因此，结果就是补码表示的整数值，所以答案是 A。
统计设置位（C）:
这个问题中，我们需要计算二进制中1的个数。对于每次循环，我们使用 (n & 1) 来获取最低位的值，并累加到 count 中。然后我们右移 n 以检查下一个位。这个操作是通过右移赋值操作符完成的，所以答案是 C (>>=)。
反转位（C）:
反转位涉及到将整数 n 的每一个位取出来，然后放置到其反转后的位置。(n & 1) 获取 n 的最低位，然后通过 << (31 - i) 放置到反转后的位置。每次迭代后，n 需要右移一位以检查下一个位，所以答案是 C (>>=)。
主要元素（B）:
Boyer-Moore投票算法是一种寻找数组中出现次数超过一半的元素的有效方法。我们用 candidate 来追踪可能的主要元素，并用 count 来追踪其出现次数。如果 count 降到0，我们就更换 candidate。如果遇到 candidate，count 就增加，否则就减少，所以答案是 B (-1)。
汉明距离（C）:
汉明距离是两个数字对应位不同的数量。首先，我们通过 x ^ y 得到一个包含不同位的二进制数。然后，我们通过计算这个结果中1的数量来确定汉明距离，每次计算后通过右移将下一个位移到最低位，所以答案是 C (>>=)。
斐波那契数（A）:
斐波那契数列定义为：F(n) = F(n-1) + F(n-2)，且 F(0) = 0, F(1) = 1。递归函数应该反映这个定义，所以当我们不是在处理基础案例时，我们需要调用 fibonacci(n - 1) 和 fibonacci(n - 2)，所以答案是 A (n - 2)。
回文数（B, B）:
回文数是正着和反着读都相同的数。在这个代码中，我们通过比较原始数和它的一半反转的数来检查它是否是回文。如果原数是回文，则在某一点上，反转数应该等于或大于原始数。每次迭代，我们需要除以10来获取下一个最高位，所以第一个空白处的答案是 B (/=)。对于比较操作，当原数有奇数位时，我们可能需要比较去除中间位的反转数，这通过除以10来实现，所以第二个空白处的答案也是 B (/ =)。
不使用+和-的加法（A）:
这个问题考察位操作实现加法。a & b 得到的carry是进位信息，当两个整数相加时，只有两个1位相加才会产生进位。然后a ^ b计算没有考虑进位的和。carry需要左移一位，因为进位会影响到下一位的计算。循环继续直到没有进位发生，即carry为0。因此，空白处应填入左移运算符 <<，所以答案是 A。
第k个最大元素（A）:
使用优先队列（最小堆）来解决这个问题，可以保持堆的大小为k。对于每个元素，我们将其加入堆中。如果堆的大小超过了k，我们将弹出堆顶元素，也就是最小的元素，这样堆中就保留了k个最大的元素。最后，堆顶就是第k大的元素。因此，当堆的大小超过k时，我们需要执行pop操作，答案是 A。
二分查找（A, A）:
二分查找算法中，如果中间的数不是要找的target，我们需要调整搜索范围。如果mid处的值小于target，则left应该调整为mid + 1，因为target位于右侧的子数组中。相反，如果mid处的值大于target，则right应该调整为mid - 1，因为target位于左侧的子数组中。因此，两个空白处都应填入 1，答案是 A。
2的整数次幂判断（A）:
一个数是2的整数次幂的一个重要特征是它的二进制表示中只有一个1。通过将该数与比它小的1相与，可以检查是否只有一个1位。如果是，结果应该为0。所以，如果n是2的幂，n & (n - 1)将等于0。所以答案是 A (1)。
合并两个已排序数组（A）:
代码已经完整，不需要补全。这段代码从后向前遍历两个数组，将较大的元素放在正确的位置。这是因为当我们知道最终数组的大小时，我们可以从后向前填充，这样我们就不会在需要在数组中移动任何元素。
字符串压缩（A）:
简单的字符串压缩算法会遍历字符串，连续相同的字符会被计数并压缩为一个字符和相应的计数。当遇到一个新字符时，我们将前一个字符和其计数添加到输出字符串中，并将count重置为1，因为新字符至少出现了一次。因此，每当我们开始新一轮计数时，count应重置为 1。所以答案是 A。
整数除以2（A）:
整数除以2可以通过将其所有的位右移一位来实现，这在二进制中等同于除以2。所以空白处应填入右移运算符 >> 1，答案是 A。
检测大写字母（A）:
代码片段是完整的，用于检测一个字符是否为大写字母。ASCII码表中，大写字母A到Z的范围是65到90。如果字符c落在这个范围内，表达式就会评估为真，
说明c是一个大写字母。所以不需要补全，答案是 A。
素数判断（A）:
素数是只有两个正因数（1和它本身）的数。为了判断一个数是否为素数，我们需要检查从2到它的平方根之间是否有因数。如果在这个范围内找到任何可以整除num的数，这意味着num不是素数。num % i == 0 检查i是否是num的因数。所以答案是 A。
第二大的数（A, A）:
为了找到第二大的数，我们需要维护两个变量：一个用于最大的数，另一个用于第二大的数。当我们找到一个比当前最大的数还大的新数时，我们应该更新第二大的数为之前的最大数，然后更新最大数为新数。如果我们找到一个比第二大的数大但比最大数小的数，我们应该更新第二大的数。所以在两个空白处都应填入 num，答案是 A。
旋转数组（A）:
这段代码已经是完整的。它描述了一种将数组旋转k次的方法，其中k是旋转的步数。首先，我们对整个数组进行旋转，然后旋转前面的n-k个元素，最后旋转后面的k个元素。这样可以在不使用额外数组的情况下完成旋转。所以不需要补全，答案是 A。
最长公共前缀（D）:
最长公共前缀算法比较字符串数组中的字符串，寻找共同的前缀。当strs[i].find(prefix) != 0时，说明prefix不是strs[i]的前缀，我们就移除prefix的最后一个字符。如果prefix变为空，我们就找到了最长的公共前缀，因此应返回一个空字符串。所以答案是 D。
移动零（A）:
这段代码的目的是将所有0移动到数组的末尾，同时保持非零元素的相对顺序。lastNonZeroFoundAt变量用来追踪非零元素应该放置的位置。当我们遇到非零元素时，我们使用swap函数将它和最后一个非零元素的位置交换。这个算法已经是完整的，不需要补全，答案是 A。
一、单选题（每题2分，共30分）
1、在C++中，哪一个ASCII编码值与字符’0’相对应？
A. 48
B. 65
C. 97
D. 32
2、二进制数 1110 转换为十进制数是多少？
A. 12
B. 14
C. 16
D. 18
3、C++中哪一个运算符用于取地址？
A. *
B. &
C. ->
D. %
4、在C++中，如果 int x = 5; int y = 10;，则表达式 x & y 的值是多少？
A. 0
B. 5
C. 10
D. 15
5、ASCII码中，字符’B’和字符’b’的十六进制差值是多少？
A. 0x20
B. 0x21
C. 0x19
D. 0x1A
6、十六进制数0xF转换为十进制数是多少？
A. 10
B. 12
C. 14
D. 15
7、在C++中，字符数组的正确初始化方式是什么？
A. char str[6] = {‘H’, ‘e’, ‘l’, ‘l’, ‘o’};
B. char str[] = “Hello”;
C. string str = “Hello”;
D. A和B都正确
8、补码编码方式主要用于表示什么类型的数？
A. 正整数
B. 负整数
C. 小数
D. 实数
9、在C++中，哪种数据类型用于表示单个字符？
A. int
B. char
C. string
D. bool
10、十六进制数0x100转换为二进制数是多少？
A. 10000000
B. 10000
C. 100000000
D. 1000
11、以下哪个选项表示将十进制数转换为八进制数？
A. std::hex
B. std::oct
C. std::dec
D. std::bin
12、C++中，数组int arr[5] = {1, 2, 3, 4, 5};的长度是多少？
A. 4
B. 5
C. 6
D. 7
13、C++中，关于一维数组的哪种描述是错误的？
A. 数组可以包含多种类型的数据。
B. 数组元素可以通过下标访问。
C. 数组大小在定义后不能更改。
D. 数组是连续的内存空间。
14、哪种运算符用于C++中的位运算"按位或"？
A. |
B. &
C. ^
D. ~
15、将十进制数8.75（整数与小数相加的结果）转换为二进制数是多少？
A. 1000.11
B. 1000.101
C. 1001.01
D. 1000.001
二、判断题（每题2分，共20分）
1、在C++中，字符常量’ ’代表空字符，其ASCII码值为0。（对√ / 错×）
2、二进制数1001转换为十进制数等于9。（对√ / 错×）
3、C++中，位运算符’&‘的优先级高于’=='。（对√ / 错×）
4、ASCII码中，大写字母和对应小写字母的编码值差固定为32。（对√ / 错×）
5、在C++中，如果数组定义为int arr[5];，则arr[5]是访问数组的合法表达式。（对√ / 错×）
6、任何一个整数左移一位都等于其乘以2。（对√ / 错×）
7、十六进制数表示中，A-F用于表示10-15。（对√ / 错×）
8、在C++中，字符串总是以空字符’ ’结束。（对√ / 错×）
9、ASCII码中，字符’0’的十进制编码为48。（对√ / 错×）
10、十进制数转换为二进制数时，结果的长度总是等于原数。（对√ / 错×）
单选题
ASCII编码值与字符’0’相对应：
二进制数 1110 转换为十进制数：
C++中用于取地址的运算符：
表达式 x & y 的值（x = 5, y = 10）：
ASCII码中，字符’B’和字符’b’的十六进制差值：
十六进制数0xF转换为十进制数：
C++中字符数组的正确初始化方式：
补码编码方式主要用于表示：
C++中用于表示单个字符的数据类型：
十六进制数0x100转换为二进制数：
表示将十进制数转换为八进制数的选项：
数组int arr[5]的长度：
关于一维数组的错误描述：
C++中的位运算"按位或"的运算符：
将十进制数8.75转换为二进制数：
判断题
字符，其ASCII码值确实是0。
二进制数1001转换为十进制数等于9：
位运算符’&‘的优先级高于’=='：
ASCII码中，大写字母和对应小写字母的编码值差固定为32：
如果数组定义为int arr[5];，则arr[5]是访问数组的合法表达式：
任何一个整数左移一位都等于其乘以2：
十六进制数表示中，A-F用于表示10-15：
在C++中，字符串总是以空字符’ ’结束：
ASCII码中，字符’0’的十进制编码为48：
十进制数转换为二进制数时，结果的长度总是等于原数：
本文发布于:2024-02-04 06:19:04，感谢您对本站的认可！
本文链接：https://www.4u4v.net/it/170700884853039.html
版权声明：本站内容均来自互联网，仅供演示用，请勿用于商业和其他非法用途。如果侵犯了您的权益请与我们联系，我们将在24小时内删除。
| 留言与评论（共有 0 条评论） |
