A
、C++
中调用 printf
函数
B
、C++
中调用用户定义的类成员函数
C
、C++
中构造一个class
或struct
D
、C++
中构造来源于同一基类的多个派生类
6
个元素,按照 6、5、4、3、2、1
的顺序进入栈 S
,请问下列哪个出栈顺序是非法的( )A、5 4 3 6 1 2
B、4 5 3 1 2 6
C、3 4 6 5 2 1
D、2 3 4 1 5 6
int x=101;
int y=201;
int *p = &x;
int *q= &y;
p=q
A
、 将x
的值赋为201
B
、 将y
的值赋为101
C
、 将q
指向x
的地址
D
、将p
指向y
的地址
A
、数组不能排序,链表可以。
B
、链表比数组能存储更多的信息
C
、数组大小固定,链表大小可以动态调整
D
、以上均正确
S
和队列Q
的初始状态为空。存在 e1~e6
六个互不相同的数据,每个数据按照进栈 S、出栈 S、进队列 Q、出队列 Q
的顺序操作,不同数据间的操作可能会交错。已知栈 S
中依次有数据 el、e2、e3、e4、e5
和 e6
进栈,队列 Q
依次有数据 e2、e4、e3、e6、e5
和 el
出队列,则栈S
的容量至少是( )A、2
B、3
C、4
D、5
a+(b-c)*d
的前缀表达式为( ),其中+-*/
是运算符。A、*+a-bcd
B.+a*-bcd
`C.abc-d*+
D.abc-+d
A.1
B.2
C.2或3
D.3
1
个位置,若存储在数组第9
个位置的结点存在兄弟节点和2
个子节点,则它的兄弟节点和右子节点的位置分别为( )A.8、18
B.10、18
C.8、19
D.10、19
N
个顶点构成的有向连通图,采用邻接矩阵的数据结构表示时,该矩阵中至少存在( )个非零元素A、N-1
B、N
C、N+1
D、N2
A、图的深度优先遍历算法常使用的数据结构为栈
B、栈的访问原则为后进先出,队列的访问原则是先进先出
C、队列常常被用于广度优先搜索算法
D、栈与队列存在本质不同,无法用栈实现队列
p
之后插入节点s
的效果(其中,next
指的是节点的直接后继结点,prev
指的是节点的直接前驱结点)A.p->next->prev=s;s->prev=p;p->next=s;s->next=p->next;
B.p->next->prev=s;p->next=s;s->prev=p;s->next=p->next;
C.s->prev=p;s->next=p->next;p->next=s;p->next->prev=s;
D.s->next=p->next;p->next->prev=s;s->prev=p;p->next=s;
A、冒泡排序算法是稳定的
B、简单选择排序是稳定的
C、简单插入排序是稳定的
D、归并排序算法是稳定的
32.1
对应的十进制数是( )A.24.125
B.24.250
C.26.125
D.26. 250
abcab
有( )个互不相同的子串。A.12
B.13
C.14
D.15
A、递归是允许使用多组参数调用函数的编程技术
B、递归是通过调用自身来求解问题的编程技术
C、递归是面向对象和数据而不是功能和逻辑的编程语言模型
D、递归是将某种高级语言转换为机器代码的编程技术
1 #include <iostream>
2
3 using namespace std;
4
5 int main()
6 {
7 unsigned short x,y;
8 cin>>x>>y;
9 x=(x|x<<2) & 0x33;
10 x=(x|x<<1) & 0x55;
11 y=(y|y << 2) & 0x33;
12 y=(y|y<< 1) & 0x55;
13 unsigned short z=x | y << 1;
14 cout<<z<<endl;
15 return 0;
16 }
假设输入的 x、y 均是不超过 15
的自然数,完成下面的判断题和单选题。
7
行与第 13
行的 unsigned,程序行为不变 ( )7
行与第 13
行的 short
均改为 char
,程序行为不变 ( )A. 0 B.209 C.197 D.226
1 #include <algorithm>
2 #include <iostream>
3 #include <limits>
4
5 using namespace std;
7 const int MAXN =105;
8 const int MAXK =105;
10 int h[MAXN] [MAXK];
11
12 int f(int n,int m)
13 {
14 if (m==1) return n;
15 if(n==0) return 0;
16
17 int ret = numeric_limits<int>::max();
18 for (int i=1;i<=n;i++)
19 ret=min(ret,max(f(n-i,m),f(i-1,m-1))+1);
20 return ret;
21 }
22
23 int g(int n,int m)24 {
25 for (int i=1;i<=n;i++)
26 h[i][1] = i;
27 for (int j=1;j<=m;j++)
28 h[0][j] =0;
29
30 for (int i=1;i<=n;i++){
31 for(int j=2;j<=m;j++){
32 h[i][j] =numeric_limits<int>::max();
33 for (int k=1;k<=i;k++)
34 h[i][j] = min(
35 h[i][j],
36 max(h[i-k][j],h[k-1][j-1])+1);
37 }
38 }
39
40 return h[n][m];
41 }
42
43 int main()
44 {
45 int n,m;
46 cin>>n>>m;
47 cout<<f(n,m)<<endl<<g(n,m)<<endl;
48 return 0;
49 }
7,3
时,第 19
行采用来去最小值的 min
函数执行了 449
次 ( ) 23. 输出的两行整数总是相同的 ( ) 24. 当m
为1
时,输出的第一行总为n
( )A.O(n·/m) B.O(nm) C.0(n²m) D.0(nm²)
26. 若输入数据为“202”,输出的第一行为( )。A. 4 B.5 C.6 D.20
27. (4分)当输入为“100 100”时,输出的第一行为( ) 。A. 6 B.7 C.8 D.9
1 #include <iostream>2
3 using namespace std;
4
5 intn,k;
6
7 int solvel()
8 {
9 int 1=0,r=n;
10 while(1<=r) {
11 int mid =(1+r)/2;
12 if(mid * mid<=n)1=mid+1;
13 else r=mid-1;
14 }
15 return 1-1;
16 }
17
18 double solve2(double x)
19 {
20 if(x==0) return x;
21 for (int i=0;i<k;i++)
22 x=(x+n/x)/2;
23 return x;
24 }
25
26 int main()
27 {
28 cin>>n>>k;
29 double ans=solve2(solvel());
30 cout<< ans << ’’<< (ans*ans == n) << endl;
31 return 0;
32 }
0(logn+k)
()n
的所有因数试补全程序1 #include <bits/stdc++.h>2 using namespace std;3
4 int main() {
5 int n;
斯
6 cin >> n;
7
8 vector<int> fac;
9 fac.reserve((int )ceil(sqrt(n)));
10
11 int i;
12 for(int i=l;i*i<n;i++){
13 if(①) {
14 fac.push_back(i);
15 }
16 }
17
18 for(int k=0;k<fac.size();k++) {
19 cout << ② <<end1;
20 }
21 if(③) {
22 cout<< ④ <<endl;
23 }
24 for (int k=fac.size()-1;k>=0;--k){
25 cout<<⑤<<endl;
26 }
27 }
35.①处应填( )A.n%i==0
B.n%i==1 C.n%(i-1)==0 D.n%(i-1)==1
36.②处应填()A.n/fac[k] B.fac[k] C.fac[k]-1 D.n/(fac[k]-1)
37.③处应填( )A.(i-1)*(i-1)==n B.(i-1)*i==n C.i*i==n D.i*(i-1)==n
38.④处应填( )A.n-i B.n-i+1 C.i-1 D.i
39.⑤处应填()A.n/fac[k] B.fac[k] C.fac[k]-1 D.n/(fac[k]-1)
8x8
图像,颜色填充的操作描述如下:给定起点像素的位置和待填充的颜色,将起始像素和所有可达的像素(可达的定义:经过一次或多次的向上、下、左、右四个方向移动所能到达且终点和路径上所有像素的颜色都与起始像素颜色相同),替换为指定的颜色。试补全程序1 #include<bits/stdc++.h>
2 using namespace std;
3
4 const int ROWS=8;
5 const int COLS=8:
6
7 struct Point{
8 int r,c;
9 Point(int r,int c):r(r),c(c) {}
10 };
11
12 bool is valid(char image[ROWS][COLS],Point pt,
13 int prev_color, int new_color) {
14 int r=pt.r;
15 int c =pt.c;
16 return (0<=r && r<ROWS && 0<=c && c<COLS &&
17 ① && image[r][c]!= new_color);
18 }
19
20 void flood fill(char image[ROWS][COLS], Point cur, int new_color) {
21 queue<Point> queue;
22 queue.push(cur);
23
24 int prev_color = image[cur.r][cur.c];
25 ②;
26
27 while(!queue.empty()) {
28 Point pt = queue.front ();
29 queue.pop ();
30
31 Point points[4] = {③,Point(pt.r-1,pt.c),
32 Point(pt.r,pt.c+1),Point(pt.r,pt.c-1)};
33 for(auto p ;points) {
34 if (is_valid(image,p,prev_color,new_color)){
35 ④;
36 ⑤;
37 }
38 }
39 }
40 }
41
42 int main() {
43 char image[ROWS][COLS] = {{’g’,’g','g','g','g','g','g','g'},
44 {'g','g','g','g','g','g','r','r'},
45 {'g','r','r','g','g','r','g','g'},
46 {'g','b','b','b','b','r','g','r'},
47 {'g','g','g','b','b','r','g','r'},
48 {'g','g','g',’ b','b', 'b','b','r'},
49 {'g','g','g','g','g','b','g','g'},
50 {'g','g','g','g','g','b','b','g'}};
51
52 Point cur(4,4);
53 char new_color ='y';
54
55 flood_fill(image, cur, new_color);
56
57 for(int r=-;r<ROWS;r++){
58 for (int c=0;c<COLS;c++){
59 cout<<image[r][c]<<’’;
60 }
61 cout<<endl;
62 }
63 //输出:
64 // g g g g g g g g
65 // g g g g g g r r
66 // g r r g g r g g
67 // g y y y y r g r
68 // g g g y y r g r
69 // g g g y y y y r
70 // g g g g g y g g
71 // g g g g g y y g
72
73 return 0;
74 }
A.image[r][c] == prev_color
B.image[r][c] != prev_color
C.image[r][c] ==new color
D.image[r][c]!=new color
41.②处应填( )。
A.image[cur.r+1][cur.c]=new_color
B.image[cur.r][cur.c] =new color
C.image[cur.r][cur.c+1]=new_color
D. image[cur.r][cur.c] = prev color
42.③处应填( )。
A. Point(pt.r,pt.c)
B.Point(pt.r,pt.c+1)
C. Point(pt.r+1,pt.c)
D. Point(pt.r+l.pt.c+1)
43.④处应填 ( )。A.prev_color=image[p,r][p.c]
B.new_color=image[p.r][p.c]
C.image[p.r][p.c]
D.image[p.r][p.c]=newcolor
44.⑤处应填( )。
A. queue.push(p)
B. queue.push(pt)
C. queue.push(cur)
D.queue. push (Point(ROWS,COLS))