单选题

1. 通讯卫星在通信网络系统中主要起到（）的作用。

   {{ select(1) }}

• 信息过滤
• 信号中继
• 避免攻击
• 数据加密

2. 小杨想编写一个判断任意输入的整数N是否为素数的程序，下面哪个方法不合适？（ ）

   {{ select(2) }}

• 埃氏筛法
• 线性筛法
• 二分答案
• 枚举法

3. 内排序有不同的类别，下面哪种排序算法和冒泡排序是同一类？（ ）

   {{ select(3) }}

• 希尔排序
• 快速排序
• 堆排序
• 插入排序

4. 关于Python类和对象的说法，错误的是（ ）。

   {{ select(4) }}

• 在Python中，一切皆对象，即便是字面量如整数5等也是对象
• 在Python中，可以自定义新的类，并实例化为新的对象
• 在Python中，内置函数和自定义函数，都是类或者对象
• 在Python中，不可仅在自定义函数中嵌套定义新的函数

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

   class Point:
       def __init__(self,X,Y):
           self.x = X
           self.y = Y
   class Rect:
       def __init__(self,lefttop_Point,rightbottom_Point):
           self.left_top = lefttop_Point
           self.right_bottom = rightbottom_Point
       def __contains__(self,xy):
           if self.left_top.x <= xy.x <= self.right_bottom.x \
           and self.right_bottom.y <= xy.y <= self.left_top.y:
               return True
           return False
   
   rectA = Rect(Point(10,10),Point(20,5))
   print(Point(15,8) in rectA)
   

   {{ select(5) }}

• 第17行代码执行后将报错，因为Rect类没有定义in运算符
• 第16行代码将Point对象作为参数，将导致错误
• in是成员运算符，不适用于Rect类
• 由于Rect类定义了__contains__魔术方法，因此第17行代码能正确执行

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

   class newClass(object):
       objCounter = 0
       def __init__(self):
           newClass.objCounter += 1
   
   classA = newClass()
   classB = newClass()
   print(newClass.objCounter)
   print(classA.objCounter)
   

   {{ select(6) }}

• 第8行代码错误，第9行正确
• 第9行代码错误，第8行代码正确
• 第8、9两行代码都正确
• 第4行代码可修改为objCounter += 1

7. 有关下面Python代码的说法，错误的是（ ）。

   class bifTreeNode:
       def __init__(self, val=None, left=None, right=None):
           self.val = val
           self.left = left
           self.right = right
   
   class bifree(object):
       def __init__(self, root=None):
           self.root = root
   

   {{ select(7) }}

• 上列Python代码适用于构造各种二叉树
• 代码Root = bifree(bifreeNode(5))构造二叉树的根节点
• 代码Root = bifree()可以构造空二叉树，此时Root对象的root属性值为None
• 代码Root = bifree(bifreeNode()可以构造空二叉树，此时Root对象的root属性为Node

8. 基于上述的定义，有关下面Python代码的说法错误的是（ ）。

   def Search(root, val):
       if root is None:
           return None
       if root.val == val:
           return root
       else:
           rtn = search(root.left, val)
           if rtn != None:
               return rtn
           return search(root.right, val)
   

   {{ select(8) }}

• 代码中 Search() 函数如果查找到查找值的节点，则返回该节点的对象
• 代码中 Search() 函数先搜索左子树，如果搜索不到指定值，则搜索右子树
• 代码中 Search() 函数采用递归方式实现二叉树节点的搜索
• 代码中 Search() 函数采用动态规划方法实现二叉树节点的搜索

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

   class Node:
       def __init__(self, Val, Prv=None, Nxt = None)
           self.Value = Val
           self.Prev = Prv
           self.Next = Nxt
   
   firstNode = Node(10)
   firstNode.Next = Node(100, firstNode)
   firstNode.Next.Next = Node(111, firstNode.Next)
   

   {{ select(9) }}

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

10. 对 hello world 使用霍夫曼编码 (Huffman Coding)，最少 bit (比特) 为（ ）。

    {{ select(10) }}

• 4
• 32
• 64
• 88

11. 下面的 fiboA() 和 fiboB() 两个函数分别实现斐波那契数列、该数列第1、第2项值为1，其余各项分别为前两项之和。下面有关说法错误的是（ ）。

    def fiboa(N):
        if N == 0:
            return 1
        if N == 1:
            return 1
        return fiboa(N - 1) + fiboa(N - 2)
    
    def fibos(N):
        dp = [-1] * (N + 1)
        dp[0] = 1
        dp[1] = 1
        for i in range(2, N + 1):
            dp[i] = dp[i - 1] + dp[i - 2]
        return dp[N]
    

    {{ select(11) }}

• fiboa() 采用递归方式实现斐波那契数列
• fibos() 采用动态规划算法实现斐波那契数列
• 当N值较大时，fiboa() 存在大量重复计算
• 由于fiboa() 代码较短，其执行效率较高

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

    def getDepth(root):
        if root is None:
            return 0
        left_depth = getDepth(root.left)
        right_depth = getDepth(root.right)
        if left_depth < right_depth:
            return right_depth + 1
        else:
            return left_depth + 1
    

    {{ select(12) }}

• 该代码可用于求解二叉树的深度
• 代码中函数getDepth()的参数root表示根节点，非根节点不可以作为参数
• 代码中函数getDepth()采用了递归方法
• 代码中函数getDepth()可用于求解各种形式的二叉树深度，要求该二叉树节点至少有left和right属性

13. 下面有关树的存储，错误的是（ ）。

    {{ select(13) }}

• 完全二叉树可以用list存储
• 一般二叉树都可以用list存储，空子树位置可以用None表示
• 清二叉树可以用list存储
• 树数据结构，都可以用list存储

14. 下面有关Python中in运算符的时间复杂度的说法，错误的是（ ）。

    {{ select(14) }}

• 当in运算符作用于dict时，其时间复杂度为O(1)
• 当in运算符作用于set时，其时间复杂度为O(1)
• 当in运算符作用于list时，其时间复杂度为O(N)
• 当in运算符作用于str时，其时间复杂度为O(N)

15. 下面有关bool()函数的说法，正确的是（ ）。

    {{ select(15) }}

• 如果自定义类中没有定义魔术方法__bool__( )，将不能对该类的对象使用bool()函数
• 如果自定义类中没有定义魔术方法__bool__( )，将查找有无魔术方法__len__( )函数，如果有__len__( )则按__len__( )的值进行处理。如果该值为0则返回False，否则True，如果没有__len__( )，则返回值为True
• bool()函数如果没有参数，返回值为 True
• 表达式bool(int)的值为False

判断题

1. 小杨想写一个程序来算出正整数N有多少个因数，经过思考他写出了一个重复没有超过N/2次的循环就能够算出来了。（ ）

   {{ select(16) }}

• 对
• 错

2. 同样的整数序列分别保存在单链表和双向链中，这两种链表上的简单冒泡排序的复杂度相同。（ ）

   {{ select(17) }}

• 对
• 错

3. 在面向对象中，方法（Event）在Python的class中表现为class内定义的函数。（ ）

   {{ select(18) }}

• 对
• 错

4. 在下面的Python代码被执行将根错，因为newClass没有__init__()魔术方法。（ ）

   class newClass:
       pass
   
   myNewClass = newClass()
   

   {{ select(19) }}

• 对
• 错

5. 如果某个Python对象（object）支持下标运算符（方括号运算符），则该对象在所对应class中定义了名为__getitem__的魔术方法。（ ）

   {{ select(20) }}

• 对
• 错

6. 深度优先搜索（DFS、Depth First Search的简写）属于图算法，其过程是对每一个可能的分支路径深入到不能再深入为止，而且每个节点只能访问一次。（ ）

   {{ select(21) }}

• 对
• 错

7. 哈夫曼编码（Huffman Coding）具有唯一性，因此有确定的压缩率。（ ）

   {{ select(22) }}

• 对
• 错

8. Python虽然不支持指针和引用语法，但变量的本质是数据的引用（reference），因此可以实现各种C/C++数据结构。在下面的Python代码中，由于删除了变量a，因此a所对应的数据也随之删除，故第4行代码被执行时，将根错。（ ）

   a, b = [1,2,3], [3,4,5]
   c = [a, b]
   del a
   print(c)
   

   {{ select(23) }}

• 对
• 错

9. 二叉搜索树查找的平均时间复杂度为(O(\log N))。（ ）

   {{ select(24) }}

• 对
• 错

10. 二叉搜索树可以是空树（没有任何节点）或者单节点树（只有一个节点），或者多节点。如果是多节点，则左节点的值小于父节点的值，右节点的值大于父节点的值，由此推理，右节点的值都大于根节点的值，左节点的值都小于根节点的值。（ ）

    {{ select(25) }}

• 对
• 错