ID: 4777

客观题

难度: 9

上传者:

单选题

已知⼩写字母b的 ASCII 码为

98

，下列 C++ 代码的输出结果是

#include <iostream>
using namespace std;
int main() {
    char a = 'b' ^ 4;
    cout << a;
    return 0;
}

{{ select(1) }}

b
bbbb
f
102

已知 $a$ 为 int 类型变量， $p$ 为 int* 类型变量，下列赋值语句不符合语法的是 {{ select(2) }}

*(p + a) = *p;
*(p - a) = a;
p + a = p;
p = p + a;

下列关于 C++ 类的说法，错误的是 {{ select(3) }}

如需要使⽤基类的指针释放派⽣类对象，基类的析构函数应声明为虚析构函数。
构造派⽣类对象时，只调⽤派⽣类的构造函数，不会调⽤基类的构造函数。
基类和派⽣类分别实现了同⼀个虚函数，派⽣类对象仍能够调⽤基类的该⽅法。
如果函数形参为基类指针，调⽤时可以传⼊派⽣类指针作为实参。

下列 C++ 代码的输出是

#include <iostream>
using namespace std;
int main() {
    int arr[5] = {2, 4, 6, 8, 10};
    int * p = arr + 2;
    cout << p[3] << endl;
    return 0;
}

{{ select(4) }}

$6$
$8$
编译出错，⽆法运⾏。
不确定，可能发⽣运⾏时异常。

假定只有⼀个根节点的树的深度为 $1$ ，则⼀棵有 $N$ 个节点的完全⼆叉树，则树的深度为 {{ select(5) }}

$\lfloor{log_2(N)}\rfloor+1$
$\lfloor{log_2(N)}\rfloor$
$\lceil{log_2(N)}\rceil$
不能确定。

对于如下图的⼆叉树，说法正确的是 {{ select(6) }}

先序遍历是 ABDEC
中序遍历是 BDACE
后序遍历是 DBCEA
⼴度优先遍历是 ABCDE

图的存储和遍历算法，下⾯说法错误的是 {{ select(7) }}

图的深度优先遍历须要借助队列来完成。
图的深度优先遍历和⼴度优先遍历对有向图和⽆向图都适⽤。
使⽤邻接矩阵存储⼀个包含 $v$ 个顶点的有向图，统计其边数的时间复杂度为 $O(v^2)$ 。
同⼀个图分别使⽤出边邻接表和⼊边邻接表存储，其边结点个数相同。

⼀个连通的简单有向图，共有 $28$ 条边，则该图⾄少有几个顶点 {{ select(8) }}

$5$
$6$
$7$
$8$

以下哪个⽅案不能合理解决或缓解哈希表冲突{{ select(9) }}

在每个哈希表项处，使⽤不同的哈希函数再建⽴⼀个哈希表，管理该表项的冲突元素。
在每个哈希表项处，建⽴⼆叉排序树，管理该表项的冲突元素。
使⽤不同的哈希函数建⽴额外的哈希表，⽤来管理所有发⽣冲突的元素。
覆盖发⽣冲突的旧元素

以下关于动态规划的说法中，错误的是{{ select(10) }}

动态规划⽅法通常能够列出递推公式。
动态规划⽅法的时间复杂度通常为状态的个数。
动态规划⽅法有递推和递归两种实现形式。
对很多问题，递推实现和递归实现动态规划⽅法的时间复杂度相当。

下⾯程序的输出为

#include <iostream>
using namespace std;
int rec_fib[100];
int fib(int n) {
    if (n <= 1)
        return n;
    if (rec_fib[n] == 0)
        rec_fib[n] = fib(n - 1) + fib(n - 2);
    return rec_fib[n];
}
int main() {
    cout << fib(6) << endl;
    return 0;
}

{{ select(11) }}

8
13
64
结果是随机的。

下⾯程序的时间复杂度为

int rec_fib[MAX_N];
int fib(int n) {
    if (n <= 1)
        return n;
    if (rec_fib[n] == 0)
        rec_fib[n] = fib(n - 1) + fib(n - 2);
    return rec_fib[n];
}

{{ select(12) }}

$O(2^n)$
$O(\phi^n),\phi=\frac{\sqrt{5}-1}{2}$
$O(n^2)$
$O(n)$

下⾯ search 函数的平均时间复杂度为

int search(int n, int * p, int target) {
    int low = 0, high = n;
    while (low < high) {
        int middle = (low + high) / 2;
        if (target == p[middle]) {
            return middle;
        } else if (target > p[middle]) {
            low = middle + 1;
        } else {
            high = middle;
        }
    }
    return -1;
}

{{ select(13) }}

$O(nlogn)$
$O(n)$
$O(logn)$
$O(1)$

下⾯程序的时间复杂度为

int primes[MAXP], num = 0;
bool isPrime[MAXN] = {false};
void sieve() {
    for (int n = 2; n <= MAXN; n++) {
        if (!isPrime[n])
            primes[num++] = n;
        for (int i = 0; i < num && n * primes[i] <= MAXN; i++) {
            isPrime[n * primes[i]] = true;
            if (n % primes[i] == 0)
                break;
        }
    }
}

{{ select(14) }}

$O(n)$
$O(nlogn)$
$O(nloglogn)$
$O(n^2)$

下列选项中，哪个不可能是下图的⼴度优先遍历序列

{{ select(15) }}

1, 2, 4, 5, 3, 7, 6, 8, 9
1, 2, 5, 4, 3, 7, 8, 6, 9
1, 4, 5, 2, 7, 3, 8, 6, 9
1, 5, 4, 2, 7, 3, 8, 6, 9

判断题

C++ 语⾔中，表达式 $9 \& 12$ 的结果类型为 int，值为 $8$ 。{{ select(16) }}

对
错

C++ 语⾔中，指针变量指向的内存地址不⼀定都能够合法访问。{{ select(17) }}

对
错

对 $n$ 个元素的数组进⾏快速排序，最差情况的时间复杂度为 $O(nlogn)$ 。{{ select(18) }}

对
错

⼀般情况下，long long 类型占⽤的字节数⽐ float 类型多。{{ select(19) }}

对
错

使⽤ math.h 或 cmath 头⽂件中的函数，表达式 pow(10, 3) 的结果的值为 $1000$ 、类型为int。{{ select(20) }}

对
错

⼆叉排序树的中序遍历序列⼀定是有序的。{{ select(21) }}

对
错

⽆论哈希表采⽤何种⽅式解决冲突，只要管理的元素⾜够多，都⽆法避免冲突。{{ select(22) }}

对
错

在 C++ 语⾔中，类的构造函数和析构函数均可以声明为虚函数。 {{ select(23) }}

对
错

动态规划⽅法将原问题分解为⼀个或多个相似的⼦问题，因此必须使⽤递归实现。{{ select(24) }}

对
错

如果将城市视作顶点，公路视作边，将城际公路⽹络抽象为简单图，可以满⾜城市间的车道级导航需求。 {{ select(25) }}

对
错