C++中调用printf函数
C++中调用用户定义的类成员函数
C++中构造一个class或struct
C++中构造来源于同一基类的多个派生类
对假设栈S和队列Q的初始状态为空。存在e1~e6六个互不相同的数据，每个数据按照进栈S、出栈S、进队列Q、出队列Q和顺序操作，不同数据间的操作可能会交错。已知栈S中依次有数据e1、e2、e3、e4、e5 和 e6 进栈，队列 Q 依次有数据 e2、e4、e3、 e6、e5和e1出队列。则栈S的容量至少是( )个数据。
2
3
4
5
链表和数组的区别包括（ ）
数组不能排序，链表可以
链表比数组能存储更多的信息
数组大小固定，链表大小可以动态调整
以上均正确
运行以下代码片段的行为是( )。
int x = 101; int y = 201; int *p = &x; int *q = &y; p = q;
将x的值赋为201
将y的值赋为101
将q指向x的地址
将p指向y的地址
有 6 个元素，按照 6、5、4、3、2、1 的顺序进入栈 S，请问下列哪个出栈序列是非法的 ( )。
5 4 3 6 1 2
4 5 3 1 2 6
3 4 6 5 2 1
2 3 4 1 5 6
一个字符串中任意个连续的字符组成的子序列成为该字符串的子串，则字符串abcab有（ ）个互不相同的子串。
12
13
14
15
八进制数32.1对应的十进制数是（ ）
24.125
24.250
26.125
26.250
以下排序算法的常见实现中，哪个选项的说法是错误的（ ）
冒泡排序算法是稳定的
简单选择排序是稳定的
简单插入排序是稳定的
归并排序算法是稳定的
以下哪组操作能完成在双向循环链表结点 p 之后插入结点 s 的效果(其中，next 域为结 点的直接后继，prev域为结点的直接前驱):( )。
p->next->prev=s; s->prev=p; p->next=s; s->next=p->next;
p->next->prev=s; p->next=s; s->prev=p; s->next=p->next;
s->prev=p; s->next=p->next; p->next=s; p->next->prev=s;
s->next=p->next; p->next->prev=s; s->prev=p; p->next=s;
以下对数据结构的表述不恰当的一项为（ ）
图的深度优先遍历算法常使用的数据结构为栈
栈的访问原则为后进先出，队列的访问原则是先进先出
队列尝尝被用于广度优先搜索算法
栈与队列存在本质不同，无法用栈实现队列
考虑N个顶点构成的有向连通图，采用邻接矩阵的数据结构表示时，该矩阵中至少存在（ ）个非零元素
N-1
N
N+1
N²
一棵有 n 个结点的完全二叉树用数组进行存储与表示，已知根结点存储在数组的第 1 个位 置。若存储在数组第 9 个位置的结点存在兄弟结点和两个子结点，则它的兄弟结点和右子 结点的位置分别是( )。
8、18
10、18
8、19
10、19
假设字母表 {a, b, c, d, e} 在字符串出现的频率分别为 10%, 15%, 30%, 16%, 29%。若使用哈夫曼编码方式对字母进行不定长的二进制编码，字母 d 的编码长度为 ( )位。
1
2
2或3
3
对表达式a+(b-c)*d的前缀表达式为（ ），其中+-*/时运算符。
*+a-bcd
+a*-bcd
abc-d*+
abc-+d
以下对递归方法的描述中，正确的是（ ）
递归是允许使用多组参数调用函数的编程技术
递归是通过调用自身来求解问题的编程技术
递归是面向对象和数据而不是功能和逻辑的编程语言模型
递归是将某种高级语言转换为机器代码的编程技术
阅读程序(程序输入不超过数组或字符串定义的范围;判断题正确填√，错误填×;）
#include <iostream>
using namespace std;
int main()
{
unsigned short x, y;
cin>>x>>y;
x = (x | x << 2) & 0x33;
x = (x | x << 1) & 0x55
y = (y | y << 2) & 0x33;
y = (y | y << 1) & 0x55;
unsigned short z =x | y << 1;
cout << z << endl;
return 0;
}假设输入的 x、y 均是不超过 15 的自然数， 完成下面的判断题和单选题:
删去第7行与第13行的unsigned，程序行为不变（ ）
将第7行与第13行的short均改为char，程序行为不变（ ）
程序总是输出一个整数“0”（ ）
当输入为“2 2” 时，输出为“10”（ ）
当输入为“2 2”时，输出为“59” （ ）
当输入为“13 8”时，输出为（ ）
0
209
197
226
假设输入的 n、m 均是不超过 100 的正整数，完成下面的判断题和单选题:
#include <algorithm>
#include <iostream>
#include <limits>
using namespace std;
const int MAXN = 105;
const int MAXK = 105;
int h[MAXN][MAXK];
int f(int n,int m)
{
if (m==1) return n;
if (n==0) return 0;
int ret = numeric_limits<int>::max();
for (int i=1;i<=n;i++)
ret = min(ret,max(f(n-i,m),f(i-1,m-1))+1);
return ret;
}
int g(int n, int m)
{
for (int i = 1; i <= n; i++)
h[i][1] = i;
for (int j = 1; j <= m; j++)
h[0][j] = 0;
for (int i = 1; i <= n; i++) {
for (int j = 2; j <= m; j++) {
h[i][j] = numeric_limits<int>::max();
for (int k = 1; k <= i; k++)
h[i][j] = min(
h[i][j],
max(h[i - k][j], h[k - 1][j - 1]) + 1);
}
}
return h[n][m];
}
int main()
{
int n, m;
cin >> n >> m;
cout << f(n, m) << endl << g(n, m) << endl;
return 0;
}
当输入为7,3时，第19行采用来去最小值的min函数执行了449次
当m为1时，输出的第一行总为n
算法g(n,m)最为准确的时间复杂度分析结果为
𝑂(𝑛3/2𝑚)
𝑂(𝑛𝑚)
𝑂(𝑛2𝑚)
𝑂(𝑛𝑚2)
4
5
6
20
6
7
8
9
假设 int 为 32 位有符号整数类型，输入的 n 是不超过 47000 的自然数、k 是不超过 int 表示范围的自然数，完成下面的判断题和单选题:
#include <iostream>
using namespace std;
int n,k;
int solve1()
{
int l=0,r=n;
while(l<=r) {
int mid = (l+r)/2;
if(mid * mid<=n)l=mid+1;
else r = mid-1;
}
return l-1;
}
double solve2(double x)
{
if (x == 0) return x;
for (int i = 0; i < k; i++)
x = (x + n / x) / 2;
return x;
}
int main()
{
cin>>n>>k;
double ans = solve2(solve1());
cout << ans << ' ' << (ans * ans == n) << endl;
return 0;
}
1
1.414
1.5
2
1.7
1.732
1.75
2
(1)(枚举因数)从小到大打印正整数 n 的所有正因数。 试补全枚举程序。
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<int> fac;
fac.reserve((int)ceil(sqrt(n)));
int i;
for (i = 1; i * i < n; ++i) {
if () {
fac.push_back(i);
}
}
for (int k = 0; k < fac.size(); ++k) {
cout << << " ";
}
if () {
cout << << " ";
}
for (int k = fac.size() - 1; k >= 0; --k) {
cout << << " ";
}
}
n%i==0
n%i==1
n%(i-1)==0
n%(i-1)==1
n/fac[k]
fac[k]
fac[k]-1
n/(fac[k]-1)
(i-1)*(i-1)==n
(i-1)*i==n
i*i==n
i*(i-1)==n
n-i
n-i+1
i-1
i
n/fac[k]
fac[k]
fac[k]-1
n/(fac[k]-1)
（洪水填充）现有用字符标记像素颜色的8x8图像，颜色填充的操作描述
image[r][c] == prev_color
image[r][c] != prev_color
image[r][c] == new_color
image[r][c] != new_color
image[cur.r+1][cur.c] = new_color
image[cur.r][cur.c] = new_color
image[cur.r][cur.c+1] = new_color
image[cur.r][cur.c] = prev_color
Point(pt.r,pt.c)
Point(pt.r,pt.c+1)
Point(pt.r+1,pt.c)
Point(pt.r+1,pt.c+1)
prev_color=image[p,r][p.c]
new_color=image[p.r][p.c]
image[p.r][p.c]
image[p.r][p.c] = new_color
queue.push(p)
queue.push(pt)
queue.push(cur)
queue.push(Point(ROWS,COLS))