以下（ ）没有涉及Python语言的面向对象特性支持。

关于Python中面向对象的类的继承，下面说法错误的是（ ）

有6个元素，按照 6,5,4,3,2,1 的顺序进入栈S，下列（ ）的出栈序列是不能出现的（ ）。

下面代码判断队列的第一个元素是否等于 ，并删除该元素，横向上应填写（ ）。

import queue

q = queue.Queue()

a = 'a'

if ________________________________________

   q.get()

   print('元素 {} 是队列的第一个元素，并已被移除。'.format(a))

else:

   print('队列的第一个元素不是 {}.'.format(a))

假设字母表 {a,b,c,d,e} 在字符串出现的频率分别为 10%，15%，30%，16%，29%。若使用哈夫曼编码方式对字母进行二进制编码，则字符 abcdef 分别对应的一组哈夫曼编码的长度分别为（ ）。

以下Python代码实现 位的格雷码，则横线上应填写（ ）。

def generate_gray_code(n):

if n <= 0:

return []

if n == 1:

return [0, 1]

gray_code = generate_gray_code(n - 1)

————————————————————————————————————————

for x in gray_code]

return gray_code + inverted_gray_code

给定一棵二叉树，其前序遍历结果为：ABDECFG,中序遍历结果为：DEBACFG，则这棵树的正确后序遍历结果是（ ）。

一棵有 个结点的完全二叉树用数组进行存储与表示，已知根结点存储在数组的第 个位置。若存储在数组第个位置的结点存在兄弟结点和两个子结点，则它的兄弟结点和右子结点的位置分别是（ ）。

二叉树的深度定义为从根结点到叶结点的最长路径上的结点数，则以下基于二叉树的深度优先搜索实现的深度计算函数中横线上应填写（ ）。

class Node:

   def __init__(self, data):

           self.data = data

           self.left = None

           self.right = None

def max_depth(root_node):

       if root_node is None:

           return 0

   else:

           left_depth =                 max_depth(root_node.left)

           right_depth = max_depth(root_node.right)

           _______________________________________

以下基于二叉树的搜索实现的深度计算函数中横线上应填写（ ）。

class Node:

   def __init__(self, data):

           self.data = data

           self.left = None

           self.right = None

def height(root):

   if root is None:

           return 0

   else:

       left_height = height(root.left)

       right_height = height(root.right)

_________________________________

二叉搜索树中的每个结点，其左子树的所有结点值都小于该结点值，右子树的所有结点值都大于该结点值。以下代码对给定的整数数组(假设数组中没有数值相等的元素)，构造一个对应的二叉搜索树，横线上应填写（  ）:

class TreeNode:

   def __init__(self, x):

       self.val = x

       self.left = None

       self.right = None

class Solution:

   def isValidBST(self, root: TreeNode) -> bool:

       def helper(node, min_val, max_val):

           if not node:

               return True

           ————————————————————————————————————————————————

               return False

       return helper(node.left, min_val, node.val) and helper(node.right,

node.val, max_val)

       return helper(root, float('-inf'), float('inf'))

对上题中的二叉搜素树，当输入数组为时，构建二叉搜索树，并采用如下代码实现的遍历方式，得到的输出是（ ）。

def traversal(tree_node* root) :

   if (root == nullptr) {

       return

}

traversal(root->left)

print(root->val)

print(" ")

traversal(root->right)

动态规划通常用于解决（ ）。

C++、Python和JAVA等都是面向对象的编程语言。

在python中，类的静态成员变量只能被该类对象的成员函数访问。

栈和队列均可通过数组或链表来实现，其中数组实现支持随机访问、占用内存较少，但插入和删除元素效率低；链表实现的元素插入与删除效率高，但元素访问效率低、占用内存较多。

运行以下python代码，屏幕将输出“derived class”。

class BaseClass:

   def my_method(self):

       print("base class")

class DerivedClass(BaseClass):

   def my_method(self):

       print("derived class")

derived_instance = DerivedClass()

derived_instance.my_method()

如下列代码所示的基类（base）及其派生类（derived），则生成一个派生类的对象时，只调用派生类的构造函数。

class Base:

   def __init__(self):

       print("Base.__init__ called")

class Derived(Base):

   def __init__(self):

       print("Derived.__init__ called")

       super().__init__()

d = Derived()

哈夫曼编码本质上是一种贪心策略。

如果根结点的深度记为 ，则一棵恰有个叶结点的二叉树的深度最少是12 。

在非递归实现的树的广度优先搜索中，通常使用栈来辅助实现。

状态转移方程是动态规划的核心，可以通过递推方式表示问题状态的变化。

题 应用动态规划算法时，识别并存储重叠子问题的解是必须的。