1. 有关下面代码正确的是（ ）

   

{{ select(1) }}

• checkNum() 函数定义错误。
• 将 isEven 作为 checkNum() 参数将导致错误。
• 执行后将输出 1 。
• 运行时触发异常。

2. 在上题的归并排序算法中， mergeSort(listData, start, middle); 和 mergeSort(listData, middle+ 1, end); 涉及到的算法为（ ）

{{ select(2) }}

• 搜索算法
• 分治算法
• 贪心算法
• 递推算法

3. 归并排序算法的基本思想是（）{{ select(3) }}

• 将数组分成两个子数组，分别排序后再合并。
• 随机选择一个元素作为枢轴，将数组划分为两个部分。
• 从数组的最后一个元素开始，依次与前一个元素比较并交换位置。
• 比较相邻的两个元素，如果顺序错误就交换位置。

4. 有关下面代码的说法正确的是（）。

{{ select(4) }}

• 上述代码构成单向链表。
• 上述代码构成双向链表。
• 上述代码构成循环链表。
• 上述代码构成指针链表。

5. 贪心算法的解可能不是最优解。（ ）

{{ select(5) }}

• 正确
• 错误

6. 一般说来，冒泡排序算法优于归并排序。（ ）

   {{ select(6) }}

• 正确
• 错误

7. C++语言中的 qsort 库函数是不稳定排序。（ ） {{ select(7) }}

• 正确
• 错误

8. 下面的C++代码执行后将输出 0 5 1 6 2 3 4（ ）。

   {{ select(8) }}

• 正确
• 错误

9. 阅读下⾯的 C++代码 ，执行后其输出是( )。

   

   {{ select(9) }}

• 1->120<===>2->120
• 1->120<===>1->120
• 1->120<===>1->2->3->4->5->120
• 1->120<===>2->3->4->5->6->120

10. 下⾯的 C++用于对 lstA 排序，使得偶数在前奇数在后 ，横线处应填入( )。

    

{{ select(10) }}

• !isEven(lstA[j]) && isEven(lstA[j+1])
• isEven(lstA[j]) && !isEven(lstA[j+1])
• lstA[j] > lstA[j+1]
• lstA[j] < lstA[j+1]

11. 有关下面C++代码说法正确的是（ ）。

    

{{ select(11) }}

• 如果 x 小于 10， rc 值也不会超过 20
• foo 可能无限递归
• foo 可以求出 x 和 y 的最大公共质因子
• foo 能够求出 x 和 y 的最小公倍数

12. 下⾯的 C++代码实现对 list 的快速排序 ，有关说法 ，错误的是（ ）。

    

{{ select(12) }}

• qSort(less) + qSort(greater) + (vector<int>)pivot
• (vector<int>)pivot + (qSort(less) + qSort(greater))
• (qSort(less) + (vector<int>)pivot + qSort(greater))
• qSort(less) + pivot + qSort(greater)

13. 下面的排序算法都要处理多趟数据 ，哪种排序算法不能保证在下一趟处理时从待处理数据中选出最大或最小的数据？ ( )

    {{ select(13) }}

• 选择排序
• 快速排序
• 堆排序
• 冒泡排序

14. 归并排序的时间复杂度是 $O(N logN)$ 。( ) {{ select(14) }}

• 正确
• 错误

15. 贪心算法可以达到局部最优 ，但可能不是全局最优解 。( ) {{ select(15) }}

• 正确
• 错误

16. 插⼊排序有时比快速排序时间复杂度更低 。（ ） {{ select(16) }}

• 正确
• 错误

17. 对数组 int arr[] = {2, 6, 3, 5, 4, 8, 1, 0, 9, 10} 执行sort(arr, arr+10) ，则执行后arr 中的数据调整为 {0, 1, 2, 3, 4, 5, 6, 8,9, 10} 。（ ）{{ select(17) }}

• 正确
• 错误

18. 贪心算法的核心思想是（ ）？

{{ select(18) }}

• 在每⼀步选择中都做当前状态下的最优选择
• 在每⼀步选择中都选择局部最优解
• 在每⼀步选择中都选择全局最优解
• 以上都对

19. 下面的代码片段用于计算斐波那契数列。该代码的时间复杂度是（ ）

    

{{ select(19) }}

• 𝑂(1)
• 𝑂(𝑛)
• 𝑂($2^n$ )
• 𝑂(𝑙𝑜𝑔𝑛)

20. 归并排序的基本思想是（ ）。{{ select(20) }}

• 动态规划
• 分治
• 贪心算法
• 回溯算法

21. 在快速排序中，选择的主元素（pivot）会影响算法的（ ）。 {{ select(21) }}

• 不影响
• 时间复杂度
• 空间复杂度
• 时间复杂度和空间复杂度

22. 递归函数在调用自身时，必须满足（ ），以避免无限递归？ {{ select(22) }}

• 有终止条件
• 函数参数递减（或递增）
• 函数返回值固定
• 以上都对

23. 插入排序的时间复杂度是𝑂(N 𝑙𝑜𝑔 N) 。{{ select(23) }}

• 正确
• 错误

24. 使用贪心算法解决问题时，每一步的局部最优解一定会导致全局最优解。 {{ select(24) }}

• 正确
• 错误

25. 分治算法的核心思想是将一个大问题分解成多个相同或相似的子问题进行解决，最后合并得到原问题的解。 {{ select(25) }}

• 正确
• 错误

26. 分治算法的典型应用之⼀是归并排序，其时间复杂度为𝑂(N 𝑙𝑜𝑔 N) ​。 {{ select(26) }}

• 正确
• 错误

27. 贪心算法是一种可以应用于所有问题的通用解决方案。

{{ select(27) }}

• 正确
• 错误

28. 在C语言中，递归的实现方式通常会占用更多的栈空间，可能导致栈溢出。

{{ select(28) }}

• 正确
• 错误

29. 下面C++代码用于将输入金额换成最少币种组合方案，其实现算法是（ ）。

    

    

{{ select(29) }}

• 枚举算法
• 贪心算法
• 迭代算法
• 递归算法

30. 为了正确实现快速排序，下面横线上的代码应为（ ）。

    

    {{ select(30) }}

• while (i <= mid)
• while (i < mid)
• while (i < j)
• while (i <= j)

31. 贪心算法通过每一步选择局部最优解来获得全局最优解，但并不一定能找到最优解。（ ）

{{ select(31) }}

• 正确
• 错误

32. 归并排序和快速排序都采用递归实现，也都是不稳定排序。（ ）

    {{ select(32) }}

• 正确
• 错误

33. 插入排序有时比快速排序时间复杂度更低。（ ） {{ select(33) }}

• 正确
• 错误