第二章 程序流程控制
容易
在循环中continue语句的作用是跳出当前循环。
错误
容易
在编写多层循环时，为了提高运行效率，应尽量减少内循环中不必要的计算。
正确
容易
如果仅仅是用于控制循环次数，那么使用for i in range(20)和for i in range(20, 40)的作用是等价的。
正确
容易
带有else子句的循环如果因为执行了break语句而退出的话，则会执行else子句中的代码。
错误
容易
对于带有else子句的循环语句，如果是因为循环条件表达式不成立而自然结束循环，则执行else子句中的代码。
正确
容易
在编写多层循环时，为了提高运行效率，应尽量减少内循环中不必要的计算。
正确
容易
以下关于循环控制语句描述错误的是哪一项？ （ ）。
A.Python中的for语句可以在任意序列上进行迭代访问，例如列表、字符串和元组。
B.在Python中if…elif…elif…结构中必须包含else子句。
C.在Python中没有switch-case的关键词，可以用if…elif…elif…来等价表达。
D.循环可以嵌套使用，例如一个for语句中有另一个for语句，一个while语句中有一个for语句等。
容易
for i in range(0,2): print (i) 上述程序的输出结果是： （ ）。
A.0 1 2
B.1 2
C.0 1
D.1
容易
下列程序共输出( )个值： 1. age = 23 2. start = 2 3. if age % 2 != 0: 4. start = 1 5. for x in range(start, age + 2, 2): 6. print(x)
A.10
B.16
C.12
D.14
容易
以下可以终结一个循环的执行的语句是（ ）。
A.break
B.if
C.input
D.exit
容易
下列 for 语句中，在 in 后使用不正确的是（ ）。 for var in : print（var）
A.set('str')
B.(1)
C.[1, 2, 3, 4, 5]
D.range(0, 10, 5)
容易
Python程序中假设字典d={'1':'male', '2':'female'}，如果语句中使用d[3]，则解释器将抛出（ ）错误信息。
A.NameError
B.IndexError
C.KeyError
D.TypeError
容易
Python程序中对于表达式123 + 'xyz'，解释器将抛出（ ）错误信息。
A.NameError
B.FileNotFoundError
C.SyntaxError
D.TypeError
容易
Python程序中假设列表s=[1,2,3]，如果语句中使用s[3]，则解释器将抛出（ ）错误信息。
A.NameError
B.IndexError
C.SyntaxError
D.TypeError
容易
以下for语句结构中，（ ）不能完成1~10的累加功能。
A.for i in range(10,0): total += i
B.for i in range(1,11): total += i
C.for i in range(10,0,-1): total += i
D.for i in (10,9,8,7,6,5,4,3,2,1): total += i
容易
下面if语句统计“成绩（score）优秀的男生以及不及格的男生”的人数，正确的语句为（ ）。
A.if (gender=="男" and score<60 or score>=90): n+=1
B.if (gender =="男" and score<60 and score>=90): n+=1
C.if (gender =="男" and (score<60 or score>=90)): n+=1
D.if (gender =="男" or score<60 or score>=90): n+=1
容易
用if语句表示如下分段函数： 下面不正确的程序段为（ ）。
A.if (x < 1): y = x * x - 2 * x+3 else: y = math.sqrt(x-1)
B.if (x < 1): y = x * x - 2 * x + 3 y = math.sqrt(x-1)
C.y = x * x - 2 * x+3 if (x >= 1): y = math.sqrt(x-1)
D.if (x < 1): y = x * x - 2 * x + 3 if (x >= 1): y = math.sqrt(x-1)
容易
下面程序段求两个数x和y中的大数，（ ）是不正确的。
A.maxNum= x if x>y else y
B.maxNum=math.max(x,y)
C.if (x>y): maxNum=x
D.if (y>=x): maxNum=y else: maxNum=ymaxNum=x
容易
执行下列Python语句将产生的结果是（ ）。 i = 1 if (i): print (True) else: print (False)
A.输出1
B.输出True
C.输出False
D.编译错误
容易
用if语句表示如下分段函数f(x)，下面不正确的程序是（ ）。
A.if(x>=1):f=2*x+1 f=3*x/(x-1)
B.if (x>=1): f=2*x+1 if (x<1): f=3*x/(x-1)
C.f=2*x+1 if (x<1): f=3*x/(x-1)
D.if (x<1): f=3*x/(x-1) else: f=2*x+1
容易
执行下列Python语句将产生的结果是（ ）。 x = 2; y = 2.0 if(x==y): print("Equal") else: print("Not Equal")
A.Equal
B.Not Equal
C.编译错误
D.运行时错误
容易
当用户输入abc时，下面代码的输出结果是（ ）。
try:
n = 0
n = input("请输入一个整数: ")
def pow10(n):
return n**10except:
print("程序执行错误")
A.输出：abc
B.程序没有任何输出
C.输出：0
D.输出：程序执行错误
容易
当用户输入abc时，下面代码的输出结果是（ ）。 try: n = 0 n = int(input("请输入一个整数: ")) def pow10(n): return n**10 print(pow10(n)) except: print("程序执行错误")
A.abc
B.程序没有任何输出
C.0
D.程序执行错误
容易
执行以下程序，输入la，输出结果是（ ）。 la = 'python' try: s = eval(input('请输入整数： ')) ls = s*2 print(ls) except: print('请输入整数 ')
A.la
B.请输入整数
C.pythonpython
D.python
容易
以下程序的输出结果是（ ）。 s='' try: for i in range(1, 10, 2): s.append(i) except: print('error') print(s)
A.1 3 5 7 9
B.[1, 3, 5, 7, 9]
C.4, 6, 8, 10
D.error
容易
以下关于循环结构的描述，错误的是（ ）。
A.遍历循环使用for <循环变量> in <循环结构>语句，其中循环结构不能是文件
B.使用range()函数可以指定for循环的次数
C.for i in range(5)表示循环5次，i的值是从0到4
D.用字符串做循环结构的时候，循环的次数是字符串的长度
正确
参考答案：
遍历循环使用for <循环变量> in <循环结构>语句，其中循环结构不能是文件
解析：
暂无解析
批注：
暂无评语
容易
执行以下程序，输入qp，输出结果是（ ）。 k = 0 while True: s = input('请输入q退出：') if s == 'q': k += 1 continue else: k += 2 break print(k)
+ 1.0 分
A.2
B.请输入q退出：
C.3
D.1
正确
参考答案：
2
解析：
暂无解析
批注：
暂无评语
容易
关于 Python 的分支结构，以下选项中描述错误的是（ ）。
+ 1.0 分
A.分支结构使用 if 保留字
B.Python 中 if-else 语句用来形成二分支结构
C.Python 中 if-elif-else 语句描述多分支结构
D.分支结构可以向已经执行过的语句部分跳转
正确
参考答案：
分支结构可以向已经执行过的语句部分跳转
解析：
暂无解析
批注：
暂无评语
容易
下面代码的输出结果是（ ）。 for s in "HelloWorld": if s=="W": continue print(s,end="")
+ 1.0 分
A.Hello
B.World
C.HelloWorld
D.Helloorld
正确
参考答案：
Helloorld
解析：
暂无解析
批注：
暂无评语
容易
以下选项，不属于程序流程图基本元素的是（ ）。
+ 0.0 分
A.循环框
B.连接点
C.判断框
D.起始框
错误
参考答案：
循环框
解析：
暂无解析
批注：
暂无评语
容易
关于结构化程序设计方法原则的描述，以下选项中错误的是（ ）。
+ 1.0 分
A.自顶向下
B.逐步求精
C.多态继承
D.模块化
正确
参考答案：
多态继承
解析：
继承是面向对象方法的一个重要特征，是使用已有的类定义作为基础建立新类的定义技术。继承是指能够直接获得已有的性质和特征，而不必重复定义它们。
批注：
暂无评语
容易
关于结构化程序设计所要求的基本结构，以下选项中描述错误的是（ ）。
+ 1.0 分
A.重复（循环）结构
B.选择（分支）结构
C.goto 跳转
D.顺序结构
正确
参考答案：
goto 跳转
解析：
暂无解析
批注：
暂无评语
容易
关于Python循环结构，以下选项中描述错误的是（ ）。
+ 1.0 分
A.Python通过for、while等保留字提供遍历循环和无限循环结构
B.遍历循环中的遍历结构可以是字符串、文件、组合数据类型和range()函数等
C.break用来跳出最层for或者while循环，脱离该循环后程序从循环代码后继续执行
D.每个continue语句有能力跳出当前层次的循环
正确
参考答案：
每个continue语句有能力跳出当前层次的循环
解析：
continue语句用来结束当前当次循环，即跳出循环体中下面尚未执行的语句，但不跳出当前循环。
批注：
暂无评语
容易
以下选项中，不属于结构化程序设计方法的是（ ）。
+ 1.0 分
A.自顶向下
B.逐步求精
C.模块化
D.可封装
正确
参考答案：
可封装
解析：
结构化程序设计方法的基本思想是将软件设计成相对独立、单一功能的模块组成的结构。结构化程序设计方法的4条原则是：①自顶向下；②逐步求精；③模块化；④限制使用goto语句。可封装是面向对象程序设计的特点之一。
批注：
暂无评语
容易
关于分支结构，以下选项中描述不正确的是（ ）。
+ 0.0 分
A.if语句中语句块执行与否依赖于条件判断
B.if语句中条件部分可以使用任何能够产生True和False的语句和函数
C.双分支结构有一种紧凑形式，使用保留字if和elif实现
D.多分支结构用于设置多个判断条件以及对应的多条执行路径
错误
参考答案：
双分支结构有一种紧凑形式，使用保留字if和elif实现
解析：
双分支结构有一种紧凑形式，使用保留字if和else实现。
批注：
暂无评语
容易
以下选项中，不是Python语言基本控制结构的是（ ）。
+ 0.0 分
A.顺序结构
B.程序异常
C.循环结构
D.跳转结构
错误
参考答案：
跳转结构
解析：
跳转结构不是Python语言的基本控制结构。
批注：
暂无评语
容易
下面代码的输出结果是（ ）。
for s in "HelloWorld":
if s=="W":
break
print(s,end="")
+ 1.0 分
A.Helloorld
B.Hello
C.World
D.HelloWorld
正确
参考答案：
Hello
解析：
break结束当前循环，不再判断执行循环的条件。
批注：
暂无评语
容易
下面代码的输出结果是（ ）。
vlist=list(range(5))
print(vlist)
+ 1.0 分
A.[0,1,2,3,4]
B.0 1 2 3 4
C.0,1,2,3,4,
D.0;1;2;3;4;
正确
参考答案：
[0,1,2,3,4]
解析：
暂无解析
批注：
暂无评语
容易
关于Python循环结构，以下选项中描述错误的是（ ）。
+ 1.0 分
A.Python通过for、while等保留字构建循环结构
B.遍历循环中的遍历结构可以是字符串、文件、组合数据类型和range()函数等
C.break用来结束当前当次语句，但不跳出当前的循环体
D.continue只结束本次循环
正确
参考答案：
break用来结束当前当次语句，但不跳出当前的循环体
解析：
continue用来结束当前当次语句，但不跳出当前的循环体。
批注：
暂无评语
容易
下面代码的输出结果是（ ）。
for s in "HelloWorld":
if s=="W":
continue
print(s,end="")
+ 1.0 分
A.Hello
B.World
C.HelloWorld
D.Helloorld
正确
参考答案：
Helloorld
解析：
暂无解析
批注：
暂无评语
容易
关于 Python 的分支结构，以下选项中描述错误的是（ ）。
+ 1.0 分
A.分支结构使用 if 保留字
B.Python 中 if-else 语句用来形成二分支结构
C.Python 中 if-elif-else 语句描述多分支结构
D.分支结构可以向已经执行过的语句部分跳转
正确
参考答案：
分支结构可以向已经执行过的语句部分跳转
解析：
暂无解析
批注：
暂无评语
容易
关于结构化程序设计所要求的基本结构，以下选项中描述错误的是（ ）。
+ 1.0 分
A.重复（循环）结构
B.选择（分支）结构
C.goto 跳转
D.顺序结构
正确
参考答案：
goto 跳转
解析：
暂无解析
批注：
暂无评语
容易
下面代码的输出结果是（ ）。
for i in range(10):
if i%2==0:
continue
else:print(i, end=",")
+ 1.0 分
A.2,4,6,8,
B.0,2,4,6,8,
C.0,2,4,6,8,10,
D.1,3,5,7,9,
正确
参考答案：
1,3,5,7,9,
解析：
暂无解析
批注：
暂无评语
容易
下面代码的输出结果是（ ）。
sum = 1.0for num in range(1,4):
sum+=numprint(sum)
+ 1.0 分
A.6
B.7.0
C.1.0
D.7
正确
参考答案：
7.0
解析：
暂无解析
批注：
暂无评语
容易
以下程序的输出结果是（ ）。 for i in "Summer": if i == "m": break print(i)
+ 1.0 分
A.M
B.mm
C.mmer
D.无输出
正确
参考答案：
无输出
解析：
暂无解析
批注：
暂无评语
容易
以下程序的输出结果是（ ）。 for num in range(1,4): sum *= num print(sum)
+ 1.0 分
A.6
B.7
C.7.0
D.TypeError 出错
正确
参考答案：
TypeError 出错
解析：
暂无解析
批注：
暂无评语
容易
以下关于 Python 的控制结构，错误的是（ ）。
+ 1.0 分
A.每个 if 条件后要使用冒号（：）
B.在 Python 中，没有 switch-case 语句
C.Python 中的 pass 是空语句，一般用作占位语句
D.elif 可以单独使用
正确
参考答案：
elif 可以单独使用
解析：
暂无解析
批注：
暂无评语
容易
以下语句执行后a、b、c的值是（ ）。 a = "watermelon" b = "strawberry" c = "cherry" if a > b: c = a a = b b = c
+ 1.0 分
A.watermelon strawberry cherry
B.watermelon cherry strawberry
C.strawberry cherry watermelon
D.strawberry watermelon watermelon
正确
参考答案：
strawberry watermelon watermelon
解析：
暂无解析
批注：
暂无评语
容易
结构化程序设计中，下面对goto语句使用描述正确的是（ ）。
+ 1.0 分
A.禁止使用goto语句
B.应避免滥用goto语句
C.goto语句最好用,不容易造成结构体程序混乱。
D.使用goto语句程序效率高
正确
参考答案：
应避免滥用goto语句
解析：
暂无解析
批注：
暂无评语
容易
设 x = 10、y = 20，下列语句能正确运行结束的是（ ）。
+ 1.0 分
A.max = x >y ? x : y
B.if(x>y) print(x)
C.while True: pass
D.min = x if x < y else y
正确
参考答案：
min = x if x < y else y
解析：
暂无解析
批注：
暂无评语
容易
以下代码段，不会输出“A，B，C，”的选项是（ ）。
+ 1.0 分
A.for i in range(3): print(chr(65+i),end=",")
B.for i in [0,1,2]: print(chr(65+i),end=",")
C.i = 0 while i < 3: print(chr(i+65),end= ",") i += 1 continue
D.i = 0 while i < 3: print(chr(i+65),end= ",") break i += 1
正确
参考答案：
i = 0 while i < 3: print(chr(i+65),end= ",") break i += 1
解析：
暂无解析
批注：
暂无评语
容易
以下程序的输出结果是（ ）。 for i in "the number changes": if i == 'n': break else: print( i, end= "")
+ 1.0 分
A.the umber chages
B.thenumberchanges
C.theumberchages
D.the
正确
参考答案：
the
解析：
暂无解析
批注：
暂无评语
容易
以下关于循环结构的描述，错误的是（ ）。
+ 1.0 分
A.遍历循环的循环次数由遍历结构中的元素个数来体现
B.非确定次数的循环的次数是根据条件判断来决定的
C.非确定次数的循环用 while 语句来实现，确定次数的循环用 for 语句来实现
D.遍历循环对循环的次数是不确定的
正确
参考答案：
遍历循环对循环的次数是不确定的
解析：
暂无解析
批注：
暂无评语
容易
以下关于程序控制结构描述错误的是（ ）。
+ 1.0 分
A.分支结构包括单分支结构和双分支结构
B.双分支结构组合形成多分支结构
C.程序由三种基本结构组成
D.Python中能用分支结构写出循环的算法
正确
参考答案：
Python中能用分支结构写出循环的算法
解析：
暂无解析
批注：
暂无评语
容易
以下程序的输出结果是（ ）。 for i in range(3): for s in "abcd": if s=="c": break print (s,end="")
+ 1.0 分
A.abcabcabc
B.aaabbbccc
C.aaabbb
D.ababab
正确
参考答案：
ababab
解析：
暂无解析
批注：
暂无评语
容易
以下程序的输出结果是（ ）。 t = "Python" print(t if t>="python" else "None")
+ 0.0 分
A.Python
B.python
C.t
D.None
错误
参考答案：
None
解析：
暂无解析
批注：
暂无评语
容易
以下程序的输出结果是（ ）。 for i in "CHINA": for k in range(2): print(i, end="") if i == 'N': break
+ 1.0 分
A.CCHHIINNAA
B.CCHHIIAA
C.CCHHIAA
D.CCHHIINAA
正确
参考答案：
CCHHIINAA
解析：
暂无解析
批注：
暂无评语
容易
以下关于分支和循环结构的描述，错误的是（ ）。
+ 1.0 分
A.python 的在分支和循环语句里使用例如 x<=y<=z 的表达式是合法的
B.分支结构的中的代码块是用冒号来标记的
C.while 循环如果设计不小心会出现死循环
D.双分支结构的 <表达式1> if <条件> else <表达式2> 形式，适合用来控制程序分支
正确
参考答案：
双分支结构的 <表达式1> if <条件> else <表达式2> 形式，适合用来控制程序分支
解析：
暂无解析
批注：
暂无评语
容易
以下程序的输出结果是（ ）。 a = 30 b = 1 if a >=10: a = 20 elif a>=20: a = 30 elif a>=30: b = a else: b = 0 print('a={}, b={}'.format(a,b))
+ 1.0 分
A.a=30, b=1
B.a=30, b=30
C.a=20, b=20
D.a=20, b=1
正确
参考答案：
a=20, b=1
解析：
暂无解析
批注：
暂无评语
容易
以下关于程序控制结构描述错误的是（ ）。
+ 1.0 分
A.单分支结构是用if保留字判断满足一个条件，就执行相应的处理代码
B.双分支结构是用if-else根据条件的真假，执行两种处理代码
C.多分支结构是用if-elif-else处理多种可能的情况
D.在Python的程序流程图中可以用处理框表示计算的输出结果
正确
参考答案：
在Python的程序流程图中可以用处理框表示计算的输出结果
解析：
暂无解析
批注：
暂无评语
容易
以下程序的输出结果是（ ）。 x= 10 while x: x -= 1 if not x%2: print(x,end = '') else: print(x)
+ 1.0 分
A.86420
B.975311
C.97531
D.864200
正确
参考答案：
864200
解析：
暂无解析
批注：
暂无评语
容易
下面代码的输出结果是（ ）。
for n in range(400,500):
i = n // 100
j = n // 10 % 10
k = n % 10
if n == i ** 3 + j ** 3 + k ** 3:
print(n)
+ 1.0 分
A.407
B.408
C.153
D.159
正确
参考答案：
407
解析：
暂无解析
批注：
暂无评语
容易
for或者while与else搭配使用时，关于执行else语句块描述正确的是（ ）。
+ 0.0 分
A.仅循环非正常结束后执行（以break结束）
B.循环正常结束后执行
C.总会执行
D.永不执行
错误
参考答案：
循环正常结束后执行
解析：
暂无解析
批注：
暂无评语
容易
以下程序，对于输入qa，输出结果是（ ）。 k = 0 while True: s = input('请输入 q 退出： ') if s == 'q': k += 1 continue else: k += 2 break print(k)
+ 1.0 分
A.2
B.请输入 q 退出：
C.3
D.1
正确
参考答案：
2
解析：
暂无解析
批注：
暂无评语
容易
执行以下程序，如果输入"93python22"，则输出结果是（ ）。 w = input('请输入数字和字母构成的字符串：') for x in w: if '0'<= x <= '9': continue else: w.replace(x,'') print(w)
+ 1.0 分
A.python9322
B.python
C.93python22
D.
正确
参考答案：
93python22
解析：
暂无解析
批注：
暂无评语
容易
以下关于循环结构的描述，错误的是（ ）。
+ 1.0 分
A.遍历循环使用for <循环变量 > in <循环结构 >语句，其中循环结构不能是文件
B.使用 range()函数可以指定for 循环的次数
C.for i in range(5)表示循环 5 次， i 的值是从 0 到 4
D.用字符串做循环结构的时候，循环的次数是字符串的长度
正确
参考答案：
遍历循环使用for <循环变量 > in <循环结构 >语句，其中循环结构不能是文件
解析：
暂无解析
批注：
暂无评语
第六章
容易
每个程序都具有的统一的运算模式是：D
A.顺序计算模式
B.输入输出模式
C.函数调用模式
D.IPO 模式
容易
以下关于数据维度的描述，错误的是（D ）。
A.采用列表表示一维数据，不同数据类型的元素是可以的
B.JSON 格式可以表示比二维数据还复杂的高维数据
C.二维数据可以看成是一维数据的组合形式
D.字典不可以表示二维以上的高维数据
容易
以下程序输出到文件text.csv中的结果是（B ）。 fo = open("text.csv",'w') x = [90,87,93] z = [] for y in x: z.append(str(y)) fo.write(",".join(z)) fo.close()
A.[90,87,93]
B.90,87,93
C.‘ [90,87,93] ’
D.‘ 90,87,93 ’
容易
以下关于文件的描述，错误的是（ B）。
A.二进制文件和文本文件的操作步骤都是“打开-操作-关闭”
B.open()打开文件之后，文件的内容并没有在内存中
C.open()只能打开一个已经存在的文件
D.文件读写之后，需要调用close()才能确保文件被保存在磁盘中
容易
以下关于CSV文件的描述，错误的选项是（ C）。
A.CSV文件可用于不同工具间进行数据交换
B.CSV文件格式是一种通用的，相对简单的文件格式，应用于程序之间转移表格数据。
C.CSV文件通过多种编码表示字符
D.CSV文件的每一行是一维数据，可以使用Python中的列表类型表示
容易
以下关于Python文件对象f的描述，错误的选项是（ A）。
A.f.closed文件关闭属性，当文件关闭时，值为False
B.f.writable()用于判断文件是否可写
C.f.readable()用于判断文件是否可读
D.f.seekable()判断文件是否支持随机访问
容易
关于Python文件的‘+’打开模式，以下选项正确的描述是（ B）。
A.追加写模式
B.与r/w/a/x一同使用，在原功能基础上增加同时读写功能
C.只读模式
D.覆盖写模式
容易
以下关于文件的描述错误的选项是（D ）。
A.readlines()函数读入文件内容后返回一个列表，元素划分依据是文本文件中的换行符
B.read()一次性读入文本文件的全部内容后，返回一个字符串
C.readline()函数读入文本文件的一行，返回一个字符串
D.二进制文件和文本文件都是可以用文本编辑器编辑的文件
容易
有一个文件记录了1000个人的高考成绩总分，每一行信息长度是20个字节，若想只读取最后10行的内容，不可能用到的函数是（D ）。
A.seek()
B.readline()
C.open()
D.read()
容易
以下程序输出到文件 text.csv中的结果是（ D）。 fo = open("text.csv",'w') x = [90,87,93] fo. write(",".join(str(x))) fo.close()
A.[90,87,93]
B.90,87,93
C.9,0,,, ,8,7,,, ,9,3,
D.[,9,0,,, ,8,7,,, ,9,3,]
容易
文件text.txt里的内容如下： QQ&Wechat Google & Baidu 以下程序的输出结果是（ ）。 fo = open("text.txt",'r') fo.seek(2) print(fo.read(8)) fo.close(D)
A.Wechat
B.&Wechat G
C.Wechat Go
D.&Wechat
容易
以下程序的输出结果是（D ）。 fo = open("text.txt",'w+') x,y ='this is a test','hello' fo.write('{}+{}\n'.format(x,y)) print(fo.read()) fo.close()
A.this is a test hello
B.this is a test
C.this is a test,hello.
D.this is a test+hello
容易
以下关于Python文件的描述，错误的是（ D）。
A.open函数的参数处理模式‘b’表示以二进制数据处理文件
B.open函数的参数处理模式‘+’表示可以对文件进行读和写操作
C.readline函数表示读取文件的下一行，返回一个字符串
D.open函数的参数处理模式‘a’表示追加方式打开文件，删除已有内容
容易
Python 文件读取方法read(size)的含义是（D ）。
A.从头到尾读取文件所有内容
B.从文件中读取一行数据
C.从文件中读取多行数据
D.从文件中读取指定size大小的数据,如果size为负数或者空，则读取到文件结束
容易
Python 文件只读打开模式是（ D）。
A.w 只写
B.x
C.b
D.r
容易
以下文件操作方法中，打开后能读取 CSV 格式文件的选项是（ ）。
A.fo = open("123.csv","w")
B.fo = open("123.csv","x")
C.fo = open("123.csv","a")
D.fo = open("123.csv","r")
容易
以下选项中，对文件的描述错误的是（ C）。
A.文件中可以包含任何数据内容
B.文本文件和二进制文件都是文件
C.文本文件不能用二进制文件方式读入
D.文件是一个存储在辅助存储器上的数据序列
容易
文件 book.txt 在当前程序所在目录内，其内容是一段文本：book，下面代码的输出结果是（C ）。
txt = open("book.txt", "r")print(txt.read())
txt.close()
A.book.txt
B.txt
C.book
D.以上答案都不对
容易
以下选项中不是 Python 对文件的写操作方法的是（C ）。
+ 1.0 分
A.writelines
B.write 和 seek
C.writetext
D.write
容易
文件 book.txt 在当前程序所在目录内，其内容是一段文本：book，下面代码的输出结果是（D ）。
txt = open("book.txt", "r");print(txt);
txt.close()
A.book.txt
B.txt
C.以上答案都不对
D.book
普通
在Python程序中，可以通过列表___访问命令行参数。___为Python脚本名，___为第一个参数名，___为第二个参数名。
参考答案：
第1空：sys.argv
第2空：argv[0]
第3空：argv[1]
第4空：argv[2]
Python可以使用函数_ open __打开文件。
普通
文件操作可以使用___方法关闭流，以释放资源。通常采用___语句，以保证系统自动关闭打开的流。
参考答案：
第1空：close
第2空：with
普通
打开随机文件后，可以使用实例方法___进行定位。
第1空：seek
容易
下列哪项不是Python中对文件的读取操作： （B ）。
A.read
B.readall
C.readlines
D.readline
容易
在读写文件之前，必须通过以下哪个方法创建文件对象： （ D）。
A.create
B.folder
C.File
D.open
容易
扩展库os中的方法remove()可以删除带有只读属性的文件。
错误
容易
使用内置函数open()且以”w”模式打开的文件，文件指针默认指向文件尾。
错误
容易
使用内置函数open()打开文件时，只要文件路径正确就总是可以正确打开的。
错误
容易
对文件进行读写操作之后必须显式关闭文件以确保所有内容都得到保存。
正确
容易
Python标准库os中的方法startfile()可以启动任何已关联应用程序的文件，并自动调用关联的程序。
正确
容易
Python标准库threading中的Lock、RLock、Condition、Event、Semaphore对象都可以用来实现线
正确
容易
二进制文件不能使用记事本程序打开。
错误
容易
使用普通文本编辑器软件也可以正常查看二进制文件的内容。
错误
容易
二进制文件也可以使用记事本或其他文本编辑器打开，但是一般来说无法正常查看其中的内容。
正确
容易
文件对象是可以迭代的。
正确
容易
以写模式打开的文件无法进读操作。
正确
普通
Python内置函数_ open()__用来打开或创建文件并返回文件对象。
容易
扩展库os中的方法remove()可以删除带有只读属性的文件。
错误
容易
使用内置函数open()且以”w”模式打开的文件，文件指针默认指向文件尾。
错误
容易
正则表达式元字符“\s”用来匹配任意空白字符。
正确
容易
正则表达式 元字符“\d”用来匹配任意数字字符。
正确
容易
正则表达式元字符“^”一般用来表示从字符串开始处进行匹配，用在一对方括号中的时候则表示反向匹配，不匹配方括号中的字符。
正确
容易
使用正则表达式对字符串进行分割时，可以指定多个分隔符，而字符串对象的split()方法无法做到这一点。
正确
容易
正则表达式对象的match()方法可以在字符串的指定位置开始进行指定模式的匹配。
正确
容易
已知x为非空字符串，那么表达式 ''.join(x.split()) == x 的值一定为True。
错误
容易
已知x为非空字符串，那么表达式 ','.join(x.split(',')) == x 的值一定为True。
正确
容易
正则表达式模块re的match()方法是从字符串的开始匹配特定模式，而search()方法是在整个字符串中寻找模式，这两个方法如果匹配成功则返回match对象，匹配失败则返回空值None。
正确
容易
如果需要连接大量字符串成为一个字符串，那么使用字符串对象的join()方法比运算符+具有更高的效率。
正确
容易
Python字符串方法replace()对字符串进行原地修改。
错误
容易
若 a = 'abcd' ，若想将 a 变为 'ebcd' ，则下列语句正确的是（ ）。
A.a[0] = 'e'
C.replace('a', 'e')
D.a = 'e' + a[1:]
E.a[1] = 'e'
容易
字符串函数strip()的作用是什么？ （ ）。
A.按照指定字符分割字符串为数组
B.连接两个字符串序列
C.去掉字符串两侧空格或指定字符
D.替换字符串中特定字符
容易
字符串是一个字符序列，例如，字符串s，从右侧向左第3个字符用什么索引？ （ ）。
A.s[3]
B.s[-3]
C.s[0:-3]
D.s[:-3]
容易
执行以下两条语句后，lst的结果是（ ）。 1. lst = [3, 2, 1] 2. lst.append(lst)
A.[3, 2, 1, [3, 2, 1]]
B.[3, 2, 1, […]]，其中“…”表示无穷递归
C.抛出异常
D.[3, 2, 1, lst]
在print函数的输出字符串中可以将（ ）作为参数，代表后面指定要输出的字符串。
A.%d
B.%c
C.%s
D.%t
普通
表达式 re.split('\.+', 'alpha.beta...gamma..delta') 的值为___。
['alpha', 'beta', 'gamma', 'delta']
普通
表达式 'apple.peach,banana,pear'.find('ppp') 的值为_-1__。
普通
表达式 'abcdefg'.split('d') 的值为___。
第1空：['abc', 'efg']
普通
表达式 ':'.join('1,2,3,4,5'.split(',')) 的值为___。
第1空：'1:2:3:4:5'
普通
表达式 'Hello world. I like Python.'.rfind('python') 的值为___。
第1空：-1
普通
表达式 'abcabcabc'.count('abc') 的值为___。
第1空：3
普通
表达式 'apple.peach,banana,pear'.find('p') 的值为___。
第1空：1
普通
正则表达式元字符___用来表示该符号前面的字符或子模式1次或多次出现。
第1空：+
普通
正则表达式元字符___用来表示该符号前面的字符或子模式0次或多次出现。
第1空：*
普通
表达式 'hello world, hellow every one'.replace('hello', 'hi') 的值为___。
第1空：'hi world, hiw every one'
普通
已知字符串 x = 'hello world'，那么执行语句 x.replace('hello', 'hi') 之后，x的值为___。
第1空：'hello world'
普通
假设正则表达式模块re已导入，那么表达式 re.sub('\d+', '1', 'a12345bbbb67c890d0e') 的值为___。
第1空：'a1bbbb1c1d1e'
普通
代码 print(re.match('^[a-zA-Z]+$','abcDEFG000')) 的输出结果为___。
第1空：None
普通
在设计正则表达式时，字符___紧随任何其他限定符(*、+、?、{n}、{n,}、{n,m})之后时，匹配模式是“非贪心的”，匹配搜索到的、尽可能短的字符串。
第1空：?
普通
语句 print(re.match('abc', 'defg')) 输出结果为___。
第1空：None
普通
已知 x = 'a234b123c'，并且re模块已导入，则表达式 re.split('\d+', x) 的值为___。
第1空：['a', 'b', 'c']
普通
表达式 ''.join('asdssfff'.split('sd')) 的值为___。
第1空：'assfff'
普通
表达式 ''.join(re.split('[sd]','asdssfff')) 的值为___。
第1空：'afff'
普通
假设re模块已导入，那么表达式 re.findall('(\d)\\1+', '33abcd112') 的值为___。
第1空：['3', '1']
普通
表达式 'a'.join('abc'.partition('a')) 的值为___。
第1空：'aaabc'
1 .
通过对象不能调用类方法和静态方法。
错误
2 .
在Python中可以为自定义类的对象动态增加新成员。
正确
3 .
Python类不支持多继承。
错误
4 .
Python类的构造函数是__init__()。
正确
5 .
定义类时，在一个方法前面使用@classmethod进行修饰，则该方法属于类方法。
正确
6 .
定义类时，在一个方法前面使用@staticmethod进行修饰，则该方法属于静态方法。
正确
7 .
在类定义的外部没有任何办法可以访问对象的私有成员。
错误
8 .
在Python中定义类时，如果某个成员名称前有2个下划线则表示是私有成员。
正确
9 .
定义类时实现了__eq__()方法，该类对象即可支持运算符==。
正确
10 .
定义类时实现了__pow__()方法，该类对象即可支持运算符**。
正确
11 .
定义类时如果实现了__contains__()方法，该类对象即可支持成员测试运算in。
正确
12 .
定义类时如果实现了__len__()方法，该类对象即可支持内置函数len()。
正确
13 .
在Python中定义类时实例方法的第一个参数名称不管是什么，都表示对象自身。
正确
14 .
在Python中定义类时实例方法的第一个参数名称必须是self。
错误
15 .
Python支持多继承，如果父类中有相同的方法名，而在子类中调用时没有指定父类名，则Python解释器将从左向右按顺序进行搜索。
正确
16 .
如果定义类时没有编写析构函数，Python将提供一个默认的析构函数进行必要的资源清理工作。
正确
17 .
在派生类中可以通过“基类名.方法名()”的方式来调用基类中的方法。
正确
18 .
对于Python类中的私有成员，可以通过“对象名._类名__私有成员名”的方式来访问。
正确
19 .
在面向对象程序设计中，函数和方法是完全一样的，都必须为所有参数进行传值。
错误
20 .
Python中没有严格意义上的私有成员。
正确
21 .
在Python中定义类时，运算符重载是通过重写特殊方法实现的。例如，在类中实现了__mul__()方法即可支持该类对象的**运算符。
错误
22 .
Python中一切内容都可以称为对象。
正确
23 .
定义类时所有实例方法的第一个参数用来表示对象本身，在类的外部通过对象名来调用实例方法时不需要为该参数传值。
正确
24 .
继承自threading.Thread类的派生类中不能有普通的成员方法。
错误
25 .
在Python中可以为自定义类的对象动态增加新成员。
正确
26 .
Python类不支持多继承。
错误
41 .
在派生类中可以通过“基类名.方法名()”的方式来调用基类中的方法。
正确
73 .
Python定义私有变量的方法为（ ）。
A. 使用__private 关键字
B. 使用public关键字
C. 使用__xxx__定义变量名
D. 使用__xxx定义变量名
74 .
关于面向对象的继承，以下选项中描述正确的是（ ）。
A. 继承是指一组对象所具有的相似性质
B. 继承是指类之间共享属性和操作的机制
C. 继承是指各对象之间的共同性质
D. 继承是指一个对象具有另一个对象的性质
76 .
在面向对象方法中，一个对象请求另一对象为其服务的方式是通过发送（ ）。
A. 调用语句
B. 命令
C. 口令
D. 消息
77 .
关于面向对象的程序设计，以下选项中描述错误的是（ ）。
A. 面向对象方法可重用性好
B. Python 3解释器内部采用完全面向对象的方式实现
C. 用面向对象方法开发的软件不容易理解
D. 面向对象方法与人类习惯的思维方法一致
80 .
阅读下面Python语句，请问输出结果是什么？ from copy import * d1 = {'a':[1,2], 'b':2}; d2 = deepcopy(d1); d1['a'][0]=6 sum = d1['a'][0] + d2['a'][0]; print(sum)
7
81 .
下列Python语句的程序运行结果为________。 list1=[1,2,3]; list2=[3,4,5];dict1={'1':list1, '2':list2};dict2=dict1.copy() dict1['1'][0]=15; print(dict1['1'][0] + dict2['1'][0])
30
82 .
阅读下面Python语句，请问输出结果是什么？
d1 = {'a':[1,2], 'b':2}; d2= d1.copy(); d1['a'][0]=6
sum = d1['a'][0] + d2['a'][0]; print(sum)
12
83 .
下列Python语句的程序运行结果为________。 class account: def __init__(self, id, balance): self.id = id; self.balance = balance def deposit(self, amount): self.balance += amount def withdraw(self, amount): self.balance -= amount acc1 = account('1234', 100); acc1.deposit(500) acc1.withdraw(200); print(acc1.balance)
400
84 .
Python类体中，___是一个类方法，创建对象时调用，返回当前对象的一个实例，一般无需重载该方法。___方法即构造函数（构造方法），用于执行类的实例的初始化工作。对象创建后调用，初始化当前对象的实例，无返回值。___方法即析构函数，用于实现销毁类的实例所需的操作，如释放对象占用的非托管资源。
__new__ 、__init__ 、__del__
85 .
在Python中，实例变量在类的内部通过___访问，在外部通过对象实例访问。
self
86 . 普通 （1分）
面向对象的程序设计具有三个基本特征：___、___和___。
封装、继承、多态
87 .
Python语句序列“x='123';print(isinstance(x, int))”的运行结果为___。
False
88 .
在Python中创建对象后，可以使用___运算符来调用其成员。
.
第一章
1 . 不同版本的Python不能安装到同一台计算机上。
错误
2.一般来说，Python扩展库没有通用于所有版本Python的，安装时应选择与已安装Python的版本对应的扩展库。
正确
3 . 可以使用py2exe或pyinstaller等扩展库把Python源程序打包成为exe文件，从而脱离Python环境在Windows平台上运行。
正确
4.Python程序只能在安装了Python环境的计算机上以源代码形式运行。
错误
5.使用print()函数无法将信息写入文件。
错误
11 . pip命令也支持扩展名为.whl的文件直接安装Python扩展库。
正确
12 . 在任何时刻相同的值在内存中都只保留一份。
错误
13 . Python采用的是基于值的自动内存管理方式。
正确
14 .
Python 3.x和Python 2.x唯一的区别就是：print在Python 2.x中是输出语句，而在Python 3.x中是输出函数。
错误
15 .在Windows平台上编写的Python程序无法在Unix平台运行。
错误
17 . Python是一种跨平台、开源、免费的高级动态编程语言。
正确
18 . Python 3.x完全兼容Python 2.x。
错误
19 .一般来说，Python扩展库没有通用于所有版本Python的，安装时应选择与已安装Python的版本对应的扩展库。
正确
20 .可以使用py2exe或pyinstaller等扩展库把Python源程序打包成为exe文件，从而脱离Python环境在Windows平台上运行。
正确
21 . Python程序只能在安装了Python环境的计算机上以源代码形式运行。
错误
30 . 在任何时刻相同的值在内存中都只保留一份。
错误
39 . 使用pip工具查看当前已安装Python扩展库列表的完整命令是_ pip list__。
40 . 使用pip工具升级科学计算扩展库numpy的完整命令是__ pip install --upgrade numpy_。
42 . 在IDLE交互模式中浏览上一条语句的快捷键是_ Alt+P __。
43 . Python程序文件扩展名主要有_ py __和__pyw_两种，其中后者常用于GUI程序。
44 . Python源代码程序编译后的文件扩展名为__ pyc_。
45 . Python安装扩展库常用的是_pip__工具。
64 . 容易 （1分）
算法是指（D ）。
A.数学的计算公式
B. 程序设计语言的语句序列
C. 问题的精确描述
D. 解决问题的精确步骤
65 .
下列关于程序设计语言的描述，正确的是（ B）。
A. 机器语言要通过编译才能被计算机接受
B. 早期人们使用机器语言编写计算机程序
C. 机器语言又称为高级语言
D. 现在人们普遍使用机器语言编写计算机程序
66 .
使用（B）函数接收用输入的数据。
A. accept （）
B. input （）
C. readline（）
D. login（）
67 .
Python脚本文件的扩展名为（B ）。
A. .python
B. .py
C. .pt
D. .pg
68 .
下面不属于python特性的是（C ）。
A. 简单易学
B. 开源的免费的
C. 属于低级语言
D. 高可移植性
69 .
利用pip命令查看pip常用帮助信息的选项是_-h 或者 –help__。
70 .
开发和运行Python程序一般包括_文件式__和__交互式_两种方式。
71 .
将源文件转换成机器语言一般有以下两种转换方法：_编译__和_解释_。
72 .
高级编程语言根据执行机制不同可以分成静态语言和脚本语言两类。采用编译方式执行的语言属于__静态语言_，采用解释方式执行的语言属于_脚本语言__。
73 .
高级编程语言根据执行机制不同可以分成静态语言和脚本语言两类。C、C++、C#、Java等程序设计语言属于_静态语言__，Python程序设计语言属于__脚本语言_。
74 .
编程语言分为低级语言和高级语言两类，其中，机器语言和汇编语言属于__低级语言_，Python属于_高级语言__。
75 .
结构化程序设计通常采用_自顶向下（Top-Down）__、_逐步求精（Stepwise Refinement）__的程序设计方法。
76 .
计算思维的本质是_抽象（Abstraction）__和__自动化（Automation）_。
77 .
在Python程序中导入sys模块后，可以通过列表___访问命令行参数。___表示Python脚本名；___表示第一个参数。
sys.argv 、argv[0] 、argv[1]
78 .
在Python解释器中使用___函数可以进入帮助系统；键入___命令，可以退出帮助系统。
help()或者help 、quit
79 .
Python程序打包和发布最常用的是第三方的扩展包_ PyInstaller__，它是用于将Python源程序生成直接运行的程序。
80 .
要关闭Python解释器，可以使用___命令或者快捷键___。
quit() 、Ctrl+Z
81 .
在Python内置集成开发环境IDLE中，可以使用快捷键__ F5_，运行当前打开的源代码程序。
82 .
Python注释以符号__#_开始，到行尾结束。
83 .
Python语言是一种解释型、面向_对象__的计算机程序设计语言。
84 .
用户程序编写的Python程序（避免使用依赖于系统的特性），无需修改就可以在任何支持Python的平台上运行，这是Python的__可移植性_特性。
85 .
Python 3.4以后的版本中，___库用于安装管理Python扩展包，___库用于发布Python包。
pip 、setuptools
86 .
在Python解释器中交互式执行Python代码的过程一般称之为（D ）。
A. FIFO
B. REPT
C. IPO
D. REPL
87 .
在Python解释器中同时运行多个以逗号分隔的表达式，返回结果为（B ）。
A. 列表
B. 元组
C. 逗号分隔的结果
D. 空格分隔的结果
88 .
以下程序设计语言中，C语言属于（A ）的编程语言。
A. 面向过程
B. 面向对象
C. 函数式
D. 逻辑式
89 .
以下程序设计语言中，（A ）属于脚本语言。
A. Python
B. Java
C. C++
D. C#
91 . 容易 （1分）
以下程序设计语言中，Java、C#、C++等属于（ B）的编程语言。
A. 面向过程
B. 面向对象
C. 函数式
D. 逻辑式
92 .
Python解释器环境中，用于表示上一次运算结果的特殊变量为（B ）。
A. :
B. _
C. >
D. #
93 .
（ A）是Python官方的扩展库索引，所有人都可以下载第三方库或上传自己开发的库到其中。
A. PyPI
B. PyPy
C. Pydev
D. pip
94 .
下列选项中，（A ）实现是最常用的Python版本，也称之为ClassicPython。
A. CPython
B. Jython
C. IronPython
D. PyPy
95 .
Python内置的集成开发工具是_（ D）_。
A. PythonWin
B. Pydev
C. IDE
D. IDLE
96 .
Python解释器的提示符为（C ）_。
A. >
B. >>
C. >>>
D. #
98 .
下列选项中，不属于Python特点的是（B ）。
A. 面向对象
B. 运行效率高
C. 可移植性
D. 免费和开源
99 .
用Pyinstall工具把Python源文件打包成一个独立的可执行文件，使用的参数是（D ）。
A. -d
B. -L
C. -i
D. -F
100 .
以下关于程序设计语言的描述，错误的选项是（ C）。
A. Python语言是一种脚本编程语言
B. 汇编语言是直接操作计算机硬件的编程语言
C. 程序设计语言经历了机器语言、汇编语言、脚本语言三个阶段
D. 编译和解释的区别是一次性翻译程序还是每次执行时都要翻译程序
101 .
以下不属于Python的pip工具命令的选项是（ D）。
A. show
B. install
C. download
D. get
102 .
执行后可以查看Python的版本的是（A ）。
A. import sys print(sys.version)
B. import sys print(sys.Version)
C. import system print(system.version)
D. import system print(system.Version)
103 .
关于Python语言的特点，以下选项中描述错误的是（B ）。
A. Python语言是脚本语言
B. Python语言是非开源语言
C. Python语言是跨平台语言
D. Python语言是多模型语言
105 .
以下选项中说法不正确的是（ A）。
A. 静态语言采用解释方式执行，脚本语言采用编译方式执行
B. C语言是静态语言，Python语言是脚本语言
C. 编译是将源代码转换成目标代码的过程
D. 解释是将源代码逐条转换成目标代码同时逐条运行目标代码的过程
106 .
IDLE环境的退出命令是（ A）。
A. exit()
B. esc()
C. close()
D. 回车键
107 .
以下选项中，不是Python语言特点的是（B ）。
A. 强制可读：Python语言通过强制缩进来体现语句间的逻辑关系
B. 变量声明：Python语言具有使用变量需要先定义后使用的特点
C. 平台无关：Python程序可以在任何安装了解释器的操作系统环境中执行
D. 黏性扩展：Python语言能够集成C、C++等语言编写的代码
108 .
（D ）选项是使用 PyInstaller 库对 Python 源文件打包的基本使用方法。
A. pip -h
B. pip install <拟安装库名>
C. pip download <拟下载库名>
D. pyinstaller 需要在命令行运行 :\>pyinstaller <Python源程序文件名>
111 .
以下选项不属于程序设计语言类别的是（D ）。
A. 机器语言
B. 汇编语言
C. 高级语言
D. 解释语言
#编写一个计算减法的方法，当第一个数小于第二个数时，引发“被减数不能小于减数”的异常
'''def sub(a,b):
if a<b:
raise Exception("被减数不能小于减数")
else:
return a-b
try:
sub(8,7)
except Exception as error:
print("出错了，出错的内容是".forat(error))'''
#2.定义一个函数func(filename) filename:文件的路径。函数功能：打开文件，并且返回文件内容，最后关闭，用异常来处理可能发生的错误。
'''def func(filename):
try:
file = open(filename,encoding="utf-8")
except Exception as error:
print("出错了，出错的内容是{}".format(error))
else:
print(file.read())
file.close()
func("c:/test.txt")'''
#3.编写一个函数，对用户输入的字符串进行检查，当长度大于8时，引发“字符串长度超过要求”的异常。
'''def checklen():
try:
st = input("请输入字符：")
if len(st) > 8:
raise Exception("字符串长度超过要求")
except Exception as err:
print(err)
else:
print("符合要求")
checklen()'''
#4.编写Python程序，建立一个名为”Student”的数据库，其中包含表user和course，user表中包含字段“name”、“age”、“mojor， couse
# course表中包含字段“iterature”、“math”、“Physics”，并插入几条记录，用SOLiteExpert查看结果。
'''import sqlite3
import os.path
class SQLiteDB(object):
def __init__(self, dbname):
try:
self.conn = sqlite3.connect(os.path.abspath(dbname))
except Exception as err:
print(err)
else:
self.cursor = self.conn.cursor()
def createTable(self, sql):
try:
self.cursor.execute(sql)
except Exception as err:
print(err)
def insert(self, sql, parm):
res = self.cursor.execute(sql, parm)
self.conn.commit()
def query(self, sql):
try:
self.cursor.execute(sql)
except Exception as err:
print(err)
def show(self,sql):
li = self.cursor.execute(sql)
for row in li:
print(row)
def __del__(self):
self.cursor.close()
self.conn.close()
if __name__ == '__main__':
db = SQLiteDB('D:/student.db')
sql = 'create table user( name varchar(10),age integer , major varchar(10))'
db.createTable(sql)
sql = 'create table course( Iterature integer,math integer,Physics integer)'
db.createTable(sql)
sql = "insert into user values (?,?,?)"
doc = ['张三', 20, '计算机应用技术']
db.insert(sql, doc)
sql = "insert into course values (?,?,?)"
doc = [95, 93, 98]
db.insert(sql, doc)
db.show('select * from user')
db.show('select * from course')'''
#5.编写程序，打开任意的文本文件，读出其中内容，判断该文件中某些给定关键字如“中国”出现的次数。
'''with open("C:/test.txt","r",encoding="utf-8") as f:
text = f.read()
n = text.count("中国")
print(n)'''
#6.编写程序，打开任意的文本文件，在指定的位置产生一个相同文件的副本，即实现文件的拷贝功能。
'''with open("C:/test.txt","r",encoding="utf-8") as f:
text = f.read()
with open("D:/copy.txt","w",encoding="utf-8") as f:
f.write(text)'''
#7.定义一个圆柱体类Cylinder，包含底面半径和高两个属性（数据成员）；
#包含一个可以计算圆柱体体积的方法。然后编写相关程序测试相关功能。
'''import math
class Cylinder:
def __init__(self,r,h):
self.r = r
self.h = h
def tiji(self):
return self.r*self.r*math.pi*self.h
cl = Cylinder(6,10)
print(round(cl.tiji(),2))'''
#8.定义一个学生类，包括学号、姓名和出生日期三个属性（数据成员）；包括一个用于给定
#数据成员初始值的构造函数；包含一个可计算学生年龄的方法。编写该类并对其进行测试。
'''from datetime import datetime
class Student:
def __init__(self,no,name,birthday):
self.no = no
self.name = name
self.birthday = birthday
def compute_age(self):
t1 = datetime.strptime(self.birthday,"%Y%m%d")
t2 = datetime.today()
return t2.year - t1.year
s1 = Student("1010","张三","19901220")
print(s1.compute_age())'''
#9.设计一个程序，用两个文本框输入数值数据，用列表框存放“＋、－、×、÷、幂次方、余数”。
#用户先输入两个操作数，再从列表框中选择一种运算，即可在标签中显示出计算结果。
#实现简单加减乘除程序。使用两个单行文本框输入数字，使用列表框选择运算。
'''from tkinter import *
import tkinter as tk
root = Tk()
def callbutton2():
a = float(num1.get())
b = float(num2.get())
print(lb.curselection())
k = lb.get(lb.curselection())
print(k)
if k == "加":
print(a+b)
result["text"] = str(a+b)
if k == "减":
print(a-b)
result["text"] = str(a-b)
if k == "乘":
print(a*b)
result["text"] = str(a*b)
if k == "除":
print(a/b)
result["text"] = str(a/b)
root.title("使用例子")
lab1 = Label(root,text = "请输入第一个数",width = 20)
lab1.pack()
num1 = tk.Entry(root)
num1.pack()
lab2 = Label(root,text = "请输入第二个数",width = 20)
lab2.pack()
num2 = tk.Entry(root)
num2.pack()
lb = Listbox(root)
lb.insert(END,"加")
lb.insert(END,"减")
lb.insert(END,"乘")
lb.insert(END,"除")
lb.pack()
b2 = Button(root,text = "计算",command = callbutton2,width = 20)
b2.pack()
result = Label(root,text = "结果",width = 6)
result.pack()
root.mainloop()'''
#10.创建一个数据库stuinfo，并在其中创建数据库表student，表中包含stuid(学号)、stuname（姓名）、birthday（出生日期）、sex（性别）、address（家庭地址）、rxrq（入学日期）6列，其中stuid设为主键，并添加5条记录。
#将所有记录的rxrq属性更新为2017-9-1。查询性别为“女”的所有学生的stuname和address字段值.
'''import sqlite3
con=sqlite3.connect("D:/student.db")
cur=con.cursor()
cur.execute("DROP table book")
con.execute("create table book(stuid primary key,stuname varchar(20),birthday integer(20),sex varchar(20),address varchar(20),rxrq integer(20))")
cur.execute("insert into book(stuid,stuname,birthday,sex,address,rxrq) values(1,'张一',19980301,'男','黄河路1号',20160901)")
cur.execute("insert into book(stuid,stuname,birthday,sex,address,rxrq) values(2,'张二',19980302,'女','黄河路2号',20160902)")
cur.execute("insert into book(stuid,stuname,birthday,sex,address,rxrq) values(3,'张三',19980303,'男','黄河路3号',20160903)")
cur.execute("insert into book(stuid,stuname,birthday,sex,address,rxrq) values(4,'张四',19980304,'男','黄河路4号',20160904)")
cur.execute("insert into book(stuid,stuname,birthday,sex,address,rxrq) values(5,'张五',19980305,'女','黄河路5号',20160905)")
print('记录计入完成')
cur.execute('select * from book')
values = cur.fetchall()
for row in values:
print(row)
print('记录更新完成')
cur.execute("Update book set rxrq=20170901")
cur.execute('select * from book')
values = cur.fetchall()
for row in values:
print(row)
print('性别为女的名字和地址信息为：')
cur.execute('select stuname,sex,address from book')
values = cur.fetchall()
for row in values:
if row[1]=='女':
print(row[0],row[2])
cur.close()
con.commit()
con.close()'''
#11.设计一个简单的某应用程序的用户注册窗口，填写注册姓名、性别、爱好信息，单击“提交”按钮，
#将出现消息对话框显示填写的信息。
'''from tkinter import *
from tkinter import messagebox
fields = ['姓名', '性别', '爱好']
entries = []
def fetch():
content = ""
for entry in entries:
field = entry[0]
text = entry[1].get()
m = '%s: %s' % (field, text)
content = content + m + "\n"
messagebox.showinfo("注册信息", content)
def makeform(root, fields):
global entries
for field in fields:
row = Frame(root)
lab = Label(row, width=15, text=field, anchor='w')
ent = Entry(row)
row.pack(side=TOP, fill=X, padx=5, pady=5)
lab.pack(side=LEFT)
ent.pack(side=RIGHT, expand=YES, fill=X)
entries.append((field, ent))
if __name__ == '__main__':
root = Tk()
root.title('Message')
makeform(root, fields)
b1 = Button(root, text='提交', command=fetch)
b1.pack(side=LEFT, padx=45, pady=5)
b2 = Button(root, text='退出', command=root.destroy)
b2.pack(side=RIGHT, padx=45, pady=5)
root.mainloop()'''
#12.设计表示正方体的类Cube，包括数据域lenOfEdge表示正方体棱长，构造方法创建
#私有数据域lenOfEdge（默认值为1）的正方体，定义其setLenOfEdge()方法和getLenOfEdge()方法，
#getArea()方法返回正方体表面积，getVolume()方法返回正方体体积。并编写测试程序，
#生成两个立方体对象，一个棱长为6，一个棱长为9，分别显示这两个立方体的表面积和体积。
'''class Cube:
def __init__(self,el=1):
self.len0fEdge = el
def setLenOfEdge(self,el):
self.LenOfEdge = el
def getLenOfEdge(self):
return self.LenOfEdge
def getArea(self):
return self.len0fEdge**2*6
def getVolume(self):
return self.len0fEdge**3
c1 = Cube(6)
c2 = Cube(9)
print(c1.getArea(),c1.getVolume())
print(c2.getArea(),c2.getVolume())'''
#13.设计表示一支股票的类Stock，定义表示股票名称（字符串类型）的数据域name、表示股票代码（字符串类型）
#的数据域id、表示当前股价（浮点数类型）的数据域curPrice、表示前一交易日收盘价（浮点数类型）的数据域pcPrice、
#数据域都定义为私有。定义返回股票名称的get方法、返回股票代码的get方法、获得/设置pcPrice的set和get方法、
#获得/设置curPrice的set和get方法，定义rateOfChange()方法返回当前股价相较前一日收盘价的变化率。
#实现这个类，并编写测试程序，生成一个名称为“ABC”、代码为“09001”的股票对象，其前一天收盘价为20.35，
#当前股价为20.95，输出其价格的变化率。
'''class Stock:
def __init__(self,name,id,curPrice,pcPrice):
self.__name = name
self.__id = id
self.__curPrice = curPrice
self.__pcPrice = pcPrice
def getname(self):
return self.__name
def getid(self):
return self.__id
def getcurPrice(self):
return self.__curPrice
def setcurPrice(self,cp):
self.__curPrice = cp
def getpcPrice(self):
return self.__pcPrice
def setpcPrice(self,pp):
self.__pcPrice = pp
def rateOfChange(self):
return (self.__curPrice - self.__pcPrice)/self.__pcPrice
s = Stock("ABC","09001",20.95,20.35)
print(round(s.rateOfChange()*100,2),"%")'''
#14.从键盘输入一些字符，逐个把它们写到磁盘文件上，直到输入一个 # 为止。
'''with open('D:/test.txt','w') as f:
flag = True
while flag:
s = input('请输入：')
if s.endswith('#'):
s = s[:-1]
flag = False
f.write(s+'\n')'''
#15.从键盘输入一个字符串，将小写字母全部转换成大写字母，然后输出到一个磁盘文件test中保存。
'''with open('D:/test.txt','w') as f:
s = input('请输入：').upper()
f.write(s)'''
#16.用户输入一个目录和一个文件名，搜索该目录及其子目录中是否存在该文件。
#(获取用户的文件路径，用os.walk函数搜索)
'''import os
di = input("输入目录：")
fi = input("输入文件：")
path = os.walk(di)
for root,dir,file in path:
if fi in file:
print(fi,"找到了")
break
else:
print(fi,"没找到")'''
#17.有两个磁盘文件A.txt和B.txt，各存放一行字符，请编写程序把这两个文件中的信息合并，
#并按字母顺序排列，输出到一个新文件C.txt。
'''with open('D:/copy.txt','r',encoding="utf-8") as f1, open('D:/test.txt','r') as f2, open('D:/C.txt','w') as f3:
s1 = f1.readline()
s2 = f2.readline()
s3 = s1 + s2
li = list(s3)
li.sort()
s3 = ' '.join(li)
f3.write(s3)'''
#18. 把一个数字的list从小到大排序，写入文件，从文件中读出文件内容，然后反序，再追加到文件的下一行。
'''import random
list_num = [random.randint(1,100) for i in range(1,20)]
list_num.sort()
txt = ",".join(list(map(str,list_num)))
with open("D:/test.txt","w",encoding="utf-8") as f:
f.write(txt)
with open("D:/test.txt","r+",encoding="utf-8") as f:
list_num2 = f.read().split(",")
list_num2.reverse()
txt2 = ",".join(list(list_num2))
f.write("\n")
f.write(txt2)'''
#20. 统计123.txt文件中单词的个数，文件未找到，抛出异常。
'''try:
with open("D:/copy.txt","r",encoding="utf-8") as f:
text = f.read()
li = text.split()
print(len(li))
except FileNotFoundError as err:
print(err)'''
#22.使用异常处理猜数字游戏，输入非整数，抛出异常
'''import random
n = random.randint(1,101)
while True:
try:
num = int(input("请输入数字："))
if num == n:
print("you guess correctly.")
break
elif num>n:
print("you guess is large.")
else:
print("you guess is small.")
except Exception as err:
print(err)'''
#23.有下面的类属性：姓名、年龄、成绩列表[语文，数学，英语]，其中每门课成绩的类型为整数，类的方法如下所述：
#(1)获取学生的姓名。get_name()，返回类型：str。
#(2)获取学生的年龄。get_age()，返回类型：int。
#(3)返回3门科目中最高的分数。get_course()， 返回类型：int。
#类定义好之后，可以定义两个同学测试下:
#zm = Student('zhangming',20,[69,88,100])
#返回结果：
#zhangming
#20
#100
'''class Student:
def __init__(self,name,age,score):
self.name = name
self.age = age
self.score = score
def get_name(self):
return self.name
def get_age(self):
return self.age
def get_score(self):
return max(self.score)
zm = Student('zhangming',20,[69,88,100])
print(zm.get_name())
print(zm.get_age())
print(zm.get_score())'''
#24.请定义一个交通工具(Vehicle)的类，属性：速度(speed)、体积(size)等等。
#方法：移动move()、设置速度setSpeed(int speed)、加速speedUp()、减速speedDown()等等。
#实例化一个交通工具对象，通过方法初始化speed、size的值并且打印出来。另外调用加速减速的方法对速度进行改变。
'''class Vehicle:
def __init__(self,speed,size):
self.speed = speed
self.size = size
def move(self):
print("前进")
def setSpeed(self,n):
self.speed = n
def speedUp(self):
self.speed +=10
print("hasten,speed is",self.speed)
def speedDown(self):
self.speed -= 10
print("deceleate,speed is",self.speed)
v = Vehicle(89,100)
v.speedUp()
v.speedDown()'''
#25.设计一个Person类，属性有姓名、年龄、性别，创建方法personInfo，打印这个人的信息；
#创建Student类，继承Person类，属性有学院college，班级class，重写父类PersonInfo方法，
#调用父类方法打印个人信息，将学生的学院、班级信息也打印出来。
'''class Person:
def __init__(self,name,age,gender):
self.name = name
self.age = age
self.gender = gender
def personInfo(self):
print(self.name,self.age,self.gender)
class Student(Person):
def __init__(self,name,age,gender,college,team):
Person.__init__(self,name,age,gender)
self.college = college
self.team = team
def personInfo(self):
Person.personInfo(self)
print(self.college,self.team)
s = Student("张三",23,"男","网络安全系","2021级")
s.personInfo()'''
#26.主动引发一个ValueError异常，捕获后输出“捕获ValueError.
try:
raise ValueError
except ValueError:
print("捕获ValueError")
1.面问对象万法中，继事是指( )。
A.类之间共享属性和操作的机制
B.各对象之间的共同性质
C.一组对象所具有的相似性质
D.一个对象具有另一个对象的性质
正确答案
A.类之间共享属性和操作的机制
学生答案
A.类之间共享属性和损作的机制
2.Python定义私有变量的方法为()。
A.使用_private关键字
B.使用public关键字
C.使用_xxx_定义变量名
D.使用_xoo.定义变量名 √
正确答案
D.使用_xoox定义变量名
学生答案
D.使用_xoxx定义变量名
3.关于 import 引用，以下选项中描述错误的是( )。
C.使用import turtle as t 引入 turtle库，取别名为t
+2.0分
+2.0分
4.( )模块是python标准库中最常用的模块之一。通过它可以获取命令行参数，从而实现从程序外部向程序内部传递参数的功
+2.0分
能，也可以获取程序路径和当前系统平台等信息，
A.sys √
B.platform
C.math
D.time
正确答案
A.sys
学生答案
A.sys
5.表达式‘A′+32会抛出下面哪种异常( ) +2.0分
A.TypeError V
B.SyntaxError
C.ValueError
D.AttributeError
6.以下模块用来获取目标网页文本的是?
A.requests √
B.bs4 ×
C.fake_useragent
D.pymysql
正确答案
A.requests
学生答案
B.bs4
7.以下模块用来获取html中特定标签内容的是?
A.requests ×
C.fake_useragent
Dpymysql
正确答案
B.bs4
学生答案
A.requests
1.继承自threading.Thread 类的派生类中不能有普通的成员方法。
正确
错误
正确答案
错误
学生答案
错误
2.Python 中一切内容都可以称为对急。
错误
+1.0分
+1.0分
正确答案
正确
学生答案
正确
3.在面向对象程序设计中，函数和方法是完全一样的，都必须为所有参数进行传值。
正确
错误 √
正确答案
错误
学生答案
错误
4.Python 中没有严格意义上的私有成员。
正确 √
+1.0分
5.Python类的构造函数是_init_0。
正确 √
错误 ×
正确答案
正确
学生答案
错误
6.定义类时，在一个方法前面使用@dassmethod 进行修怖，则该方法属于类方法。 +1.0分
正确 √
错误
正确答案
正确
学生答案
正确
7.定义类时，在一个方法前面使用@staticmethod进行休息，则该方法属于静态方法。
正确 √
错误
8.执行语句 from math import sin 之后，可以自接便用 sinO 幽数，例如sin(3)。
正确 √
错误
正确答案
正确
学生答案
正确
9.已知应用程序主窗口root =tkinterTk0.那么 rootresizable(False.False)的作用是设置窗口在水平和垂直两个方向都不允许+1.0分
改变大小。
正确 √
错 误
正确答案
正确
学生答案
正确
10.使用tkinter.simpledialog 模块中的askinteger) 函数弹出对话框输入整数时，如果用户单击“取消”按钮返回，那么 askinteger)函数的返回值为0。
正确
错误 √
1.在Python中创建对象后，可以使用__运算符来调用其成员。
正确答案
学生答案
2.Python 包含了数量众多的模块， 通 过 语句，可以导入模块。并使用其定义的功能。
正确答案
import
学生答案
import
3.Python 中sys模块的__属性返回一个路径列表。
正确答案
sys.path
学生答案
Path
4.Python 内置函数__用来打开或创建文件并返回文件对象。
正确答案
openO
学生答案
epen
5.已知当前文件夹中有纯英文文本文件readme.txt, 请填空完成功能把readme.txt文件中的所有内容复制到dst.txt中 ，with open(readme.txt)as src,open('dst.txt,_)as dst:dst.write(src.readO)。
正确答案
'w'
6.Python 标准库os 中用来创建文件夹的函数是__,如果要创建的文件夹已存在会报错抛出异常。
正确答案
mkdirO
学生答案
mkdir
7.带有else的异常处理结构，如果try中的代码抛出了异常，那么else中的代码将_ (会、不会?)执行。
正确答案
不会
学生答案
不会
8.在try…except…异常处理结构中， 用于尝试捕捉可能出现的异常。
正确答案
except
学生答案
except
9.Python 标准库__可以用来创建GU 应用程序。
正确答案
tkinter
学生答案
tkinter
10.tkinter应用程序的 方法用来启动消息主循环和应用程序。
正确答案
mainloop0
11.通过request模块爬取“新浪新闻国内新闻”的源码
import requests
res =requests.get(http://news.sina.com.cn/china/)
res,encoding=utf-8'# 修改编码方式为utf-8, 可以识别汉字 #输出源码
正确答案
print(res.text)
学生答案
无
12.通过BeautifulSoup4模块将网页源代码中的有效内容提取出来(请联系下文的soup)
from bs4 import BeautifulSoup
html_sample ='\
<html>\
<body>\
<h1 id="title*>Hello World</h1>\
<a href=°#"class="link'>This is link1</a>\
<a href='#link2"class="link*>This is link2</a>\
</body>\
</html>
以下关于外排序的叙述中正确的是（ ）。
A.外排序把外存文件调入内存，再利用内排序方法进行排序，所以外排序所花时间完全由采用的内排序确定
B.外排序所花时间=内排序时间+外存信息读写时间+内部归并所花时间
C.外排序并不涉及文件的读写操作
D.外排序完全可以由内排序来替代
正确答案B
外排序过程主要分为两个阶段：生成初始归并段和对初始归并段进行归并，这两个步骤中都涉及文件的读写操作。
m个初始归并进行k路平衡归并时，所需趟数（ ） 。
A.logkm
B.logkm+1
C.logk(m+1)
D.logmk
正确答案A
m个初始归并段中总共有u个记录，采用k路平衡归并，在k个记录中选取最小关键字的记录时采用逐个比较的方式进行，则总的关键字比较次数是（ ）。
A.log2m(u-1)(k-1)
B.log2m(u-1)(k-1)/ log2k
C.log2m(u-1)
D.log2m(k-1)
正确答案B
m个初始归并段中总共有u个记录，采用k路平衡归并，在k个记录中选取最小关键字的记录时采用败者树进行，则总的关键字比较次数是（ ）（用时间复杂度表示）。
A.log2m(u-1)(k-1)
B.log2m(u-1)(k-1)/ log2k
C.log2m(u-1)
D.log2m(k-1)
正确答案C
采用败者树进行k路平衡归并的外排序算法中，总的关键字比较次数与k（ ）。
A.成正比
B.成反比
C.无关
D.以上都不对
正确答案C
采用败者树进行k路平衡归并的外排序算法中，总的关键字比较次数=(u-1)log2m，其中u为归并的记录个数，m是初始归并段的个数，从而看出与k无关。
n个记录采用置换-选择算法产生m个有序段，m和n的关系是 （ ）。
A.m与n成正比
B.m与n成反比
C.m=log2n
D.以上都不对
正确答案D
如w=1时，记录序列{1,2,3,4,5}产生一个有序段，而{5,4,3,2,1}产生5个有序段，所以一般来讲，m与数据序列、内存工作区可容纳的记录个数w和n都有关，但并不是A、B、C选项所指的直接关系。
当内存工作区可容纳的记录个数w=2时，记录序列{5,4,3,2,1}采用置换-选择算法产生（ ）有序段。
A.1
B.2
C.3
D.5
正确答案C
产生的有序段是{4,5}，{2,3}，{1}，共3个有序段。
当内存工作区可容纳的记录个数w=1时，记录序列{5,4,3,2,1}采用置换-选择算法产生（ ） 有序段。
A.1
B.2
C.3
D.5
正确答案D
产生的有序段是{5}，{4}，{3}，{2}，{1}，共5个有序段。
对于采用置换-选择算法产生的归并段，以下含有3个初始归并段的组是 （ ） 有序段。
A.{5,6,10}，{7,8,2}，{9,5}
B.{3,6,12}，{1,2,3}，{5,14}
C.{5,6,10}，{7,12,15}，{2,9}
D.{7,8,12}，{1,4,6}，{9,12}
正确答案C
采用置换-选择算法产生的归并段一定是有序段，选项A错误。而前一个归并段的最后一个关键字一定大于下一个归并段的第一个关键字，选项B、D错误。
对于m个初始归并段，构建k路最佳归并树时，设u=(m-1) % (k-1)，当u≠0时，需要增加（ ）个虚段。
A.u
B.k-u
C.k-1-u
D.u-1
正确答案C
1
k阶最佳归并树是一棵 （ ）。
A.k阶平衡树
B.平衡二叉树
C.k阶哈夫曼树
D.以上都不对
正确答案C
k阶最佳归并树是一棵k阶哈夫曼树，不一定是k阶平衡树。
由m个初始归并段构建的k阶最佳归并树中，度为k的结点个数是 （ ） 。
A.(m-1)/k
B.m/k
C.(m-1)/(k-1)
D.无法确定
正确答案C
设树中结点个数为n，n0=m，n-1=knk，n=n0+nk，所以有knk=m+nk-1，则nk=(m-1)/(k-1)。
由m个初始归并段构建的k阶最佳归并树中，总共有 （ ） 个结点。
A.(mk-1)/k
B.(mk-1)/(k-1)
C.mk/(k-1)
D.无法确定
正确答案B
设树中结点个数为n，n0=m，n-1=knk，n=n0+nk，所以有knk=m+nk-1，则nk=(m-1)/(k-1)。n=n0+nk=m+(m-1)/(k-1)= (mk-1)/(k-1)。
外排序有两个基本阶段，第一阶段是、____、，第二阶段是、____ 。
生成初始归并段、对这些初始归并段采用某种归并方法，进行多遍归并
外排序的基本方法是归并排序，但在之前必须先生成___ 。
初始归并段
外排序有两个基本阶段，置换-选择排序算法用于___ 。
外排序的第一个阶段
置换-选择排序算法的作用是___。
由一个无序文件产生若干个有序子文件（初始归并段）
n个记录采用置换-选择排序，假设内存工作区可容纳的记录个数为w（n远大于w），则除最后一个初始归并段外，其他每个初始归并段的长度至少是___ 。
w
n个记录采用置换-选择排序，假设内存工作区可容纳的记录个数为w（n远大于w），产生的初始归并段的最大长度是 ___ 。
n
一组关键字T=(12,2,16,30,8,28,4,10,20,6,18)，设内存工作区可容纳4个记录，记采用置换-选择排序，则产生 ___个初始归并段。
2
一组关键字T=(12,2,16,30,8,28,4,10,20,6,18)，设内存工作区可容纳4个记录，记采用置换-选择排序，则产生的初始归并段为___ 。
{2,8,12,16,28,30}，{4,6,10,18,20}
m个初始归并段采用k路平衡归并，归并的趟数是 ____、 。
<p>log<sub>k</sub>m</p>
在败者树中，“败者”是指 ___ 。
在一次比较中，没有上升进入双亲结点的结点
采用k路归并构建的败者树中，不计冠军结点，败者树的结点总数是 ___ 。
2k-1
对于n个元素采用逐个比较方式选取最小元素，总的比较次数是、____、。对于含有n个结点（不含冠军结点）败者树，从中选取最小元素，最多的比较次数是、____、。
n-1 、log<sub>2</sub>(n+1)</p>
有8个长度为2、5、3、10、4、7、9、18的初始归并段，采用3路归并，在其最佳归并树中需增加___个虚段。
1
m=8，k=3，u=(m-1)%(k-1)=7%2=1，需增加k-1-u=1个虚段。
有8个长度为2、5、3、10、4、7、9、18的初始归并段，采用3路归并，在其最佳归并树中WPL= ___ 。
103
增加一个虚段，按长度排序后为{0,2,3,4,5,7,9,10,18}，构造的最佳归并树如图11所示，WPL=(2+3)×3+(4+5+7+9+10)×2+18×1=103。
外排序与外部设备的特性无关。
正确答案:否
外排序与外部设备的特性有关，如磁盘排序和磁带排序的方式有所不同。
内排序过程在数据量很大时就变成了外排序过程。
正确答案:否
影响外排序的时间因素主要是内存与外存交换信息的次数。
正确答案:是
外排序是把外存文件调入内存，可利用内排序方法进行排序，因此排序所花时间取决于内排序的时间。
正确答案:否
主要取决于内外存数据交换的次数。
外排序中没有关键字比较。
正确答案:否
外排序中需要关键字比较。
在外排序过程中所有记录的I/O次数必定相等。
正确答案:否
如在一次外排序过程中，记录a可能有2次I/O，而记录b可能有3次I/O。
在外排序过程中，一个记录的读入内存的次数和写到外存的次数必定相等。
正确答案:是
为了提高外排序的速度，在外排序中必须选用最快的内排序算法。
正确答案:否
外排序的第二阶段只能采用归并排序算法。
通常外排序采用多路归并排序方法，实际上也可以用其他内排序方法代替归并排序方法。
正确答案:否
设有5个初始归并段，每个归并段有20个记录，采用5路平衡归并，若不采用败者树，使用逐个比较的方法选取最小记录，则总共需要396次关键字比较。
正确答案:是
归并趟数s=log55=1，5个记录选取最小记录需比较4次，所以总共需要(100-1)×4×1=396次关键字比较。
设有5个初始归并段，每个归并段有20个记录，采用5路平衡归并，若采用败者树选取最小记录，则总共需要396次关键字比较。
正确答案:否
归并趟数s=log55=1，采用败者树时，5个记录选取最小记录需比较log25=3次，所以总共需要(100-1)×3×1=297次关键字比较。
减少初始归并段的个数，可以使外排序的时间缩短。
正确答案:是
外排序的k路平衡归并中，采用败者树时，归并效率与k无关。
正确答案:否
外排序的k路平衡归并中，采用败者树时，总的关键字比较次数与k无关。
采用多路平衡归并方法可以减少初始归并段的个数。
正确答案:否
采用多路平衡归并方法可以减少归并的趟数。
磁盘上存放375000个记录，做5路平衡归并排序，内存工作区能容纳600个记录，内排序采用直接插入排序。为把所有记录排好序，需做6趟归并排序。
正确答案:否
内排序采用直接插入排序时，可以产生375000/600=625个初始归并段，5路平衡归并排序的趟数=log5625=4。所以需做4趟归并排序。
k路平衡归并中，败者树的主要作用是减少归并的趟数。
正确答案:否
败者树的主要作用是加速从k个记录中选取最小记录，并不能减少归并的趟数。
k路平衡归并建立的败者树中没有度为1的结点。
正确答案:是
k路平衡归并建立的败者树的结点个数正好为k（不含冠军结点）。
正确答案:否
k路平衡归并建立的败者树的结点个数为2k-1（不含冠军结点）。
置换-选择排序算法的作用是由一个无序文件生成一个全部有序的文件。
正确答案:否
置换-选择排序算法的作用是由一个无序文件生成若干个有序的子文件。
正确答案:是
k路最佳归并树在外排序中的作用是产生初始归并段。
正确答案:否
k路最佳归并树一定是一棵k路平衡树。
正确答案:否
k路最佳归并树不一定是一棵k路平衡树。
简述外排序的过程。
外排序过程主要分为两个阶段：生成初始归并段和对初始归并段进行归并。生成初始归并段可以采用某种内排序实现。
假设内存大小为w（内存中每次最多可放入w个记录），要进行外排序的文件为in.dat，其中含有若干个无序记录，通过外排序方法产生一个有序文件out.dat的过程如下：
① 可以每次从外存文件in.dat中读入w个记录，采用某种内排序方法（如置换选择算法）进行排序来产生初始归并段，即产生outdat、…、outn.dat有序文件，如图11（a）所示。
② 采用多路归并方法将所有初始归并段（outdat、…、outn.dat文件）进行归并产生一个有序文件out.dat，如图11（b）所示。
什么是多路平衡归并，多路平衡归并的目的是什么？
归并过程可以用一棵归并树来表示。多路平衡归并对应的归并树中，每个结点都是平衡的，即每个结点的所有子树的高度相差不超过1。
k路平衡归并的过程是：第一趟归并将m个初始归并段归并为m/k个归并段，以后每一趟归并将l个初始归并段归并为l/k个归并段，直到最后形成一个大的归并段为止。
m个归并段采用k路平衡归并，其归并趟数s=logkm，其趟数是所有归并方案中最少的，所以多路平衡归并的目的是减少归并趟数。
什么是败者树？其主要作用是什么？用于k路归并的败者树中共有多少个结点（不含冠军结点）？
败者树是一棵有k个叶子结点的完全二叉树，从叶子结点开始，两个结点进行比较，将它们中的败者（较大者）上升到双亲结点，胜者（较小者）参加更高一层的比较。
败者树的主要作用是从k个记录中选取关键字最小的记录。
败者树中有k个叶子结点，且没有度为1的结点，即n0=k，n1=0，n2=n0-1=k-1，所以n=n0+n1+n2=2k-1。
使用败者树后，多路平衡归并的关键字比较次数与路数k无关了，因此只要内存空间允许，k越大越好，这个叙述正确吗？
虽然增大k会有效地减少归并树的高度，从而减少I/O的次数，提高外排序的速度。但并不是k越大越好，因为k增大时，相应的需要增大输入缓冲区个数。如果可供使用的内存空间不变，这样会减少每个输入缓冲区的容量，使得内、外存数据交换的次数增大，所以说当k值过大时，虽然归并趟数会减少，但读写外存的次数仍会增加。
以归并排序为例，说明内排序和外排序的不同，说明外排序如何提高操作效率？
内排序中的归并排序是在内存中进行的归并排序，所有数据都要调入内存，所需辅助空间为O(n)。外排序的归并排序是将外存中的多个有序子文件合并成一个有序子文件，将每个子文件中记录读入内存后的排序方法可采用多种内排序方法。
外排序的效率主要取决于读写外存的次数，m个初始子文件采用k路平衡归并时，其归并趟数s=logkm，s越大读写外存的次数也越大，增大k和减少m都可以减少s，从而提高外排序的效率。
采用置换-选择算法产生初始归并段时，如果内存缓冲区的长度为w（w>1），若输入的n（n>w）个关键字为递减次序，则算法的输出是什么？
若输入的关键字为递减次序，算法输出为：最后一个初始归并段的长度小于或等于m，其他各初始归并段的长度为m，全部归并段的个数为n/m。
采用置换-选择算法产生初始归并段时，如果内存缓冲区的长度为w（w>1），若输入的n（n>w）个关键字为递增次序，则算法的输出是什么？
若输入的关键字为递增次序，算法输出为：只有一个初始归并段，其长度恰好为n。
给出一组关键字T={12,2,16,30,8,28,4,10,20,6,18}，设内存工作区可容纳4个记录，写出用置换-选择方法得到的全部初始归并段。
置换选择方法得到的结果如下：
归并段1：{2,8,12,16,28,30}。
归并段2：{4,6,10,18,20}。
在一个无序文件中存放有若干个记录，其中所有记录构成的关键字序列为{41,39,28,32,22,19,11,50,13,21,1,33,37,3,52,16,4,8,72,12,32}。设缓冲区w能有容纳5个记录的容量。按置换-选择方法求初始归并段。请写出各初始归并段中选出的关键字。
置换选择方法得到的结果如下：
归并段1：{22,28,32,39,41,50}，关键字为50。
归并段2：{1,11,13,19,21,33,37,52,72}，关键字为72。
归并段3，{3,4,8,12,16,32}，关键字为32。
给出一组关键字T={10,9,8,7,6,5,4,3,2,1}，采用置换-选择方法得到的全部初始归并段。回答以下问题：
（1）若内存工作区容量w=1，给出相应的结果。
（2）若内存工作区容量w=2，给出相应的结果。
（3）若内存工作区容量w=5，给出相应的结果。
（4）若内存工作区容量w=8，给出相应的结果。
（1）w=1时共产生10个初始归并段，即为{10}、{9}、{8}、{7}、{6}、{5}、{4}、{3}、{2}、{1}。
（2）w=2时共产生5个初始归并段，即为{9,10}、{7,8}、{5,6}、{3,4}、{1,2}。
（3）w=5时共产生2个初始归并段，即为{6,7,8,9,10}、{1,2,3,4,5}。
（4）w=8时共产生2个初始归并段，即为{3,4,5,6,7,8,9,10}、{1,2}。
外排序中的“败者树”和堆有什么区别？若用败者树求k个数中的最小值，在某次比较中得到a>b，那么谁是败者？
外排序中的“败者树”和堆的区别如下：
败者树是在双亲结点中记下刚进行比较的败者（较大者），让胜者（较小者）去参加更高一层的比较。而堆可看作是一种“胜者树”，即双亲结点表示其左、右孩子中的胜者。
败者树中参加比较的n个关键字全部为叶子结点，双亲结点即为左、右孩子的败者，败者树中结点总数为2n-1，加上冠军结点总结点个数为2n。堆是由n个关键字组成的完全二叉树，每个关键字作为树中的一个结点，根结点是n个关键字中的胜者，树中结点总数为n。
若用败者树求k个数中的最小者，某次比较中得到a>b，那么a是败者。
如果某个文件经内排序得到80个初始归并段，试问：
（1）若使用多路归并执行3趟完成排序，那么应取的归并路数至少应为多少？
（2）如果操作系统要求一个程序同时可用的输入/输出文件的总数不超过15个，则按多路归并至少需要几趟可以完成排序？如果限定这个趟数，可取的最低路数是多少？
（1）设归并路数为 k，初始归并段个数 m=80，根据归并趟数计算公式S=logkm=logk80=3，则k3≥80，即k≥5。也就是说，可取的最低路数是5。
（2）设多路归并的归并路数为k，需要k个输入缓冲区和1个输出缓冲区。l个缓冲区对应1个文件，有k+1=15，因此k=14，可做14路归并。由S=logkm=log1480=2。即至少需2趟归并可完成排序。
若限定这个趟数，由S=logk80=2，有80≥k2，可取的最低路数为9。即要在2趟内完成排序，进行9路排序即可。
有m个初始归并段，在构建k路最佳归并树时为什么在有些情况下要增加若干个虚段？
k路最佳归并树是一棵k阶哈夫曼树，其中只有度为0和度为k的结点。
设树中结点个数为n，n0=m，n-1=knk，n=n0+nk，所以有knk=m+nk-1，则nk=(m-1)/(k-1)。显然nk
一定为正整数，如果m、k的初值不当，会导致nk
不为正整数，此时会出现少于k个的归并段进行k路归并，这是十分麻烦的。
为了保证每次都是k个归并段进行归并，则nk=(m-1)/(k-1)应为正整数，或者说u=(m-1) % (k-1)=0，若u≠0（不妨设m-1=x(k-1)+u，其中x为整数），需添加若干个长度为0的虚段，显然添加最少的虚段个数为k-1-u。这样添加后初始归并段为m+k-1-u个，新的nk=(m+k-1-u-1)/(k-1)= [x(k-1)+u+k-u-1]/(k-1)=x+1为正整数。
设有11个长度（即包含记录个数）不同的初始归并段，它们所包含的记录个数为{25,40,16,38,77,64,53,88,9,48,98}。试根据它们做4路平衡归并，要求：
（1）指出总的归并趟数。
（2）构造最佳归并树。
（3）根据最佳归并树计算每一趟及总的读记录数。
（1）总的归并趟数=log411=2。
（2）m=11，k=4，(m-1) % (k-1)=1≠0，需要附加k-1-(m-1) % (k-1)=2个长度为0的虚归并段，最佳归并树如图12所示。
（3）根据最佳归并树计算每一趟及总的读记录数：
第1趟的读记录数=9+16=25
第2趟的读记录数=25+25+38+40+48+53+64+77=370
第3趟的读记录数=128+88+242+98=556
总的读记录数=25+370+556+951。
设有13个初始归并段，其长度序列为{28,16,37,42,5,9,13,14,20,17,30,12,18}。试画出4路归并时的最佳归并树，并计算它的带权路径长度WPL。
这里n=13，k=4。由于(n-1) % (k-1)=0，不需加虚段。最佳归并树如图14所示。WPS=(5+9+12+13+14+16+17+18+20+28+30+37)×2+42=480。
已知有31个长度不等的初始归并段，其中8段长度为2，8段长度为3，7段长度为5，5段长度为12，3段长度为20（单位均为物理块），请为此设计一个最佳5路归并方案，并计算总的（归并所需的）读/写外存次数。
这里m=31，k=5。由于(m-1) % (k-1)=2≠0，需附加(k-1)-2=2个长度为0的虚归并段，最佳5路归并树如图15所示。
读写记录数如下：
第1趟：2×8+3×8+5×2=50
第2趟：6+10+12×5+15+19+20+5×5=155
第3趟：20+52+20+78+25=195
总共需要50+155+195=400次外存读/写。
置换选择排序得到初始归并段长（k字节数）为37、34、300、41、70、120、35和43。画出这些磁盘文件进行归并的4阶最佳归并树，算出归并总的读写字节数，每读写1字节计为1。
k=4，m=8，k-1-(m-1) % (k-1)=2，则设两个虚段。4阶最佳归并树如图16所示。
第1趟读写记录数：34+35=69
第2趟读写记录数：69+37+41+43=190
第3趟读写记录数：190+70+120+300=680
总的读写记录数=69+190+680=939，总的读写字节数为939。
对含有n个元素的顺序表采用直接插入排序方法进行排序，在最好情况下算法的时间复杂度为 （ ） 。
A.O(n)
B.O(nlog2n)
C.O(n2)
D.O([Math Processing Error]
)
正确答案A
直接插入排序在初始数据正序时性能最好，此时时间复杂度为O(n)。答案为A。
用某种排序方法对数据序列（24，88，21，48，15，27，69，35，20）进行递增排序，元素序列的变化情况如下：
①（24，88，21，48，15，27，69，35，20）
②（20，15，21，24，48，27，69，35，88）
③（15，20，21，24，35，27，48，69，88）
④（15，20，21，24，27，35，48，69，88）
则所采用的排序方法是（ ） 。
A.快速排序
B.选择排序
C.直接插入排序
D.二路归并排序
正确答案A
从元素序列的变化情况看，不可能是选择排序（因为前后没有产生全局有序区），不可能是直接插入排序（因为前后没有产生局部有序区），也不可能是二路归并排序。答案为A。
以下排序方法中，（ ）不需要进行关键字的比较。
A.快速排序
B.归并排序
C.基数排序[].堆排序
正确答案C
在各种内排序方法中基数排序不需要关键字比较。答案为C。
一个含有n个互不相同的整数的数组R[.n]，其中所有元素是递减有序的，将其看成是一棵完全二叉树，该树构成一个大根堆吗？若不是，请给一个反例，若是，请说明理由。
该数组一定构成一个大根堆。当R是递减有序时，其数组元素为k1、k2、…、kn，从中看出下标越大的元素值越小，对于任一元素ki，有ki>k2i，ki>k2i+1（i<n/2），这正好满足大根堆的特性，所以构成一个大根堆。
7
对有n个元素的排序表进行直接插入排序，在最好情况下需比较 ( )次关键字。
A.n-1
B.n+1
C.n/2
D.n(n-1)/2
正确答案A
直接插入排序中，若初始排序表正序时性能最好，仅需要n-1次关键字比较，没有元素移动。答案为A。
若数据元素序列（11，12，15，7，8，9，23，1，5）是采用下列排序方法之一得到的第二趟排序后的结果，则该排序算法只能是( )。
A.冒泡排序
B.直接插入排序
C.选择排序
D.二路归并排序
正确答案B
从第二趟排序后结果看出，先后没有全局有序区，不可能是冒泡排序和选择排序，又发现了并非两两有序，所以不是二路归并排序。答案为B。
快速排序在( )情况下最不利于发挥其长处。
A.排序的数据量太大
B.排序的数据中含有多个相同值
C.排序的数据个数为奇数
D.排序的数据已基本有序
正确答案D
当排序的数据已基本有序，快速排序的时间复杂度会变为O(n2)。答案为D。
已知排序序列为（15，5，16，2，25，8，20，9，18，12），给出采用二路归并排序方法对该序列作升序排序时的每一趟的结果。
采用二路归并排序法排序的各趟结果如图A.7所示。
简要说明为什么堆通常采用顺序结构。
堆实际上是一棵满足特定条件的完全二叉树（如大根堆中每个分支结点的值均大于等于其孩子结点的值）。堆采用顺序结构的优点如下：
① 完全二叉树非常适合采用顺序结构存储，不需要增加像二叉链结点中指针，节省空间，存储密度高。
② 采用顺序结构存储时，找一个结点的双亲、兄弟和孩子结点十分方便，可以高效地实现堆运算算法。
③ 堆常用于堆排序中，若排序表是一个顺序表，可以直接将排序表作为堆，对应的排序算法为就地算法，空间复杂度为O(1)。
以下排序方法中，( )在初始序列已基本有序的情况下，排序效率最高。
A.二路归并排序
B.快速排序
C.直接插入排序
D.堆排序
正确答案C
二路归并排序和堆排序的效率用初始序列分布无关，而在初始序列已基本有序的情况下快速排序的效率最差。答案为C。
某程序需要从10000个无序的整数中找出前10个最小的整数，在以下排序方法中最好采用( )_。
A.直接插入排序
B.冒泡排序
C.二路归并排序
D.希尔排序
正确答案B
冒泡排序只需要做10趟就可以了，其他排序方法需要全部排序。答案为B。
有n个十进制整数进行基数排序，其中最大的整数为5位，则基数排序过程中临时建立的队数个数是( )_。
A.10
B.n
C.5
D.2
正确答案A
基数排序中队列的个数仅与基数相关，这里基数为10。答案为A。
将一个从大到小的数组，用以下排序方法排序成从小到大的，_（ ）最快。
A.堆排序
B.冒泡排序
C.快速排序
D.直接插入排序
正确答案A
一个关键字序列为（12，38，35，25，74，50，63，90），按二路归并排序方法对序列进行一趟归并后的结果为（ ）_。
A.12，38，35，25，74，50，63，90
B.12，38，25，35，50，74，63，90
C.12，25，35，38，50，74，63，90
D.12，35，38，25，63，50，74，90
正确答案B
两两合并得到二路归并排序一趟后的结果。答案为B。
8
如果在一个排序算法的执行过程中，没有同一对元素被比较过两次或以上，则称该排序算法为节俭排序算法，以下算法中是节俭排序算法的有_（ ）。
A.直接插入排序
B.选择排序
C.堆排序
D.所有选项都不对
正确答案A
直接插入排序中没有同一对元素被比较过两次或以上。答案为A。
对给定的关键字序列（110，119，007，911，114，120，122）进行基数排序，则第二趟分配收集后得到的关键字序列是 （ ） 。
A.007，110，119，114，911，120，122
B.007，110，119，114，911，122，120
C.007，110，911，114，119，120，122
D.110，120，911，122，114，007，119
正确答案C
这里基数排序的第一趟排序是按照个位数字来排序的，第二趟排序是按然十位数字的大小进行排序的。答案为C。
快速排序算法通常是基于顺序表的，那么能不能对链表数据实现快速排序呢？对比说明基于顺序表实现快速排序有什么优点。
答：快速排序算法通常是基于顺序表的，当然能够基于链表实现快速排序（如采用单链表或者双链表都可以实现快速排序算法，注意能不能和适不适合是两个不同的概念），只是基于顺序表实现快速排序更加方便，其优点如下：
① 快速排序是将一个无序序列划分为两个无序序列，由于顺序表具有随机存取特性，基于顺序表时确定一个无序序列只需要指定上下界（即上下索引），可以在O(1)时间找到该无序序列中的任何元素，而链表不具有随机存取特性，当指定一个无序序列的首尾结点地址后，找其中一个结点的时间大于O(1)。
② 快速排序中需要将两个有序序列合并为一个有序序列，基于顺序表时合并过程是隐含的即直接合并，而基于链表时不能直接合并，需要用专门的代码来实现合并过程。
③ 采用链表实现快速排序时，一方面需要维护尾结点，另外划分中需要交换结点，这都会增加算法的复杂性。
时间复杂度恒为O(nlog2n)且不受数据初始状态影响的排序算法是_（ ）__。
A.二路归并排序
B.希尔排序
C.快速排序
D.选择排序
正确答案A
二路归并排序的最好、最坏和平均时间复杂度均为O(nlog2n)。答案为A。
有一种排序方法，它在最后一趟排序结束之前可能所有元素都发生位置的改变，该排序方法是（ ）__。
A.堆排序
B.冒泡排序
C.直接插入排序
D.选择排序
正确答案C
堆排序、冒泡排序和选择排序中，每一趟产生的有序区都是全局有序的。答案为C。
堆的形状是一棵_（ ）__。
A.满二叉树
B.二叉判定树
C.平衡二叉树
D.完全二叉树
正确答案D
堆的形状是一棵完全二叉树。答案为D。
有一组关键字序列（66，89，8，123，9，44，55，37，200，127，98），回答以下问题：
（1）请将其调整成初始大根堆，并画出初始大根堆的树形表示。
（2）采用堆排序实现按关键字递增排序，请画出当有一个最大的关键字已放置到最终位置时，剩余关键字构成的大根堆。
答：（1）初始大根堆如图A.21所示。
（2）当最大元素放入其最终位置后，剩余元素构成的大根堆，如图A.22所示。
若初始数据基本正序，则选用的最好的排序方法是 ( ) 。
Ⅰ.直接插入排序Ⅱ.冒泡排序Ⅲ.快速排序Ⅳ.二路归并排序
A.仅Ⅰ
B.仅Ⅰ、Ⅱ
C.仅Ⅰ、Ⅲ
D.仅Ⅱ、Ⅳ
正确答案B
当初始数据基本正序时，直接插入排序和起泡排序的时间复杂度为O(n)。答案为B。
已知待排序的n个元素可分为n/k组，每个组恰好包含k个元素，组内元素是无序的，且任一组内的各元素均分别大于前一组的所有元素和小于后一组内的所有元素，若采用基于比较的排序方法使整个数据递增排序，最好的时间复杂度为 ( ) 。
A.O(nlog2n)
B.O(nlog2k)
C.O(klog2n)
D.O(klog2k)
正确答案B
每个组内k个元素采用基于比较的排序方法排序最好时间复杂度为O(klog2k)，整个元素序列排序的最好时间复杂度为O(klog2k)×n/k=O(nlog2k)。答案为B。
设有一组关键字序列为（345，253，674，924，627，310，56），对其采用基数排序方法递增排序，需要分配和收集( ) 趟。
A.3
B.4
C.5
D.8
正确答案A
这组关键字中最长的位数是3，所以采用基数排序方法时需要进行3趟分配和收集过程。答案为A。
9
数据序列（8，9，10，4，5，6，20，1，2）只能是 ( )算法的两趟排序后的结果。
A.选择排序
B.冒泡排序
C.直接插入排序
D.堆排序
正确答案C
选择排序、冒泡排序和堆排序每一趟产生的有序区都是全局有序区，而
（8，9，10，4，5，6，20，1，2）中前后没有全局有序区。答案为C。
以下4个线性表中，最适合采用基数排序的是 ( ) 。
A.10000个实数
B.1000个由字母、数字和其他字符组成的字符串
C.1000个int类型的整数
D.10000个100以内的正整数
正确答案D
这里是要求选择最适合基数排序的数据，显然实数序列不如整数序列，含负整数的序列不如仅含正整数的序列。选项C中有可能出现负整数，所以最适合基数排序的是10000个100以内的正整数。答案为D。
以下序列不是堆的是 （ ） 。
A.（100，85，98，77，80，60，82，40，20，10，66）
B.（100，98，85，82，80，77，66，60，40，20，10）
C.（10，20，40，60，66，77，80，82，85，98，100）
D.（100，85，40，77，80，60，66，98，82，10，20）
正确答案D
画出各个序列对应的完全二叉树，再对每个分支结点逐个判断。本题答案为D。
设线性表中每个元素有两个数据项k1和k2，现对线性表按以下规则进行排序：先看数据项k1，k1值小的在前，大的在后；在k1值相同的情况下，再看k2，k2值小的在前，大的在后。满足这种要求的排序方法是（ ）。
A.先按k1值进行直接插入排序，再按k2值进行选择排序
B.先按k2值进行直接插入排序，再按k1值进行选择排序
C.先按k1值进行选择排序，再按k2值进行直接插入排序
D.先按k2值进行选择排序，再按k1值进行直接插入排序
正确答案D
从题中看出，k1数据项较k2数据项的权重，结合基数排序的情况，如在对若干两位的十进制数进行基数递增排序时，十位数较个位数权重，所以先按个位数排序，再按十位数排序，否则结果是错误的，因此应先按k2数据项排序，再按k1数据项排序。
再考虑排序算法的稳定性，选择排序是不稳定的，直接插入排序是稳定的，如果对k1数据项采用不稳定的排序方法，则可能出现相同k1值、k2值不同的元素改变相对次序，即可能出现k1值相同、k2大的在前小的在后，这显然不符合题意，所以应对最后的k1采用稳定的排序方法。综合起来应该先按k2值进行选择排序，再按k1值进行插入排序。本题答案为D。
若要在N个海量数据（超过十亿，不能一次全部放入内存）中找出最大的k个数（内存可以容纳k个数），最好采用什么数据结构和策略？请详细说明你采用的数据结构和策略，并用时间复杂度和空间复杂度来说明理由。
答：首先读入k个数，并把这k个数建成小顶堆。然后从第k+1个数d开始，每个数都与堆顶元素进行比较，如果d大于堆顶元素，则把堆顶元素的替换成d，再将其调整成为小顶堆。当所有数据都读入并比较完之后，这个小顶堆里面的所有元素就是最大的k个数。时间复杂度为O(nlog2k)，空间复杂度为O(k)。
首页
作业系统
考试系统
师资培训
课程题库
考研
问答
使用手册
第9章作业1
总分：10
得分：9
内排序方法的稳定性是指（ ）。
A.该排序算法不允许有相同关键字的元素
B.该排序算法允许有相同关键字的元素
C.平均时间为O(nlog2n)的排序方法
D.以上都不对
正确答案D
内排序方法的稳定性是指（ ）。
A.经过排序后，能使关键字相同的元素保持原顺序中的相对位置不变
B.经过排序后，能使关键字相同的元素保持原顺序中的绝对位置不变
C.排序算法的性能与被排序元素的数量关系不大
D.排序算法的性能与被排序元素的数量关系密切
正确答案A
初始数据序列中有两个相同关键字的元素，通过不稳定的排序方法排序后，（ ）。
A.这两个元素的前后位置不发生变化
B.这两个元素的前后位置一定发生变化
C.这两个元素的位置不发生变化
D.这两个元素的前后位置可能发生变化
正确答案D
以下关于排序的叙述中正确的是（ ）。
A.稳定的排序方法优于不稳定的排序方法，因为稳定的排序方法效率较高
B.对同一个顺序表使用不同的排序方法进行排序，得到的排序结果可能不同
C.排序方法都是在顺序表上实现的，在链表上无法实现排序方法
D.在顺序表上实现的排序方法在链表上也可以实现
正确答案B
稳定的排序方法的效率不一定都比不稳定的排序方法高。有些排序方法既可以上顺序表上实现，也可以在链表上实现，但不是所有的排序方法都如此。由于排序方法具有不同的稳定性，所以对同一个顺序表使用不同的排序方法进行排序，得到的排序结果可能不同。
以下不属于内排序方法的是（ ） 。
A.二路归并排序
B.拓扑排序
C.堆排序
D.直接插入排序
正确答案B
拓扑排序是一种产生拓扑序列的方法，不属内排序方法。
如果一组数据采用某种排序方法进行排序，排序后相同关键字的元素的相对位置不发生改变，称该排序方法是___ 。
稳定的
若不考虑基数排序，在排序过程中，主要进行的两种基本操作是关键字的、____、。和记录的、____、。
比较 、移动
每次从无序子表中取出一个元素，通过依次比较把它插入到有序子表的适当位置，此种排序方法称为___。
直接插入排序
对含有n个元素的数据序列进行直接插入排序（采用《教程》中的算法），在最坏情况下移动元素的个数是____，关键字比较的次数是____。
(n-1)(n+4)/2、n(n-1)/2
直接插入排序在初始数据反序时的效率最差，此时元素移动共(1+2)+(2+2)+…+(n-1+2)=(n-1)(n+4)/2次，关键字比较的次数为1+2+…+(n-1)=n(n-1)/2。
一组数据序列为…,R[i],…,R[j],…，R[i]与R[j]的关键字相同，采用某种排序方法排序后变为…,R[j],…,R[i],…，则该排序算法是稳定的。
正确答案:否
该排序算法是不稳定的。
当待排序的元素很大时，为了交换元素的位置，移动元素要占用较多的时间，这是影响算法时间复杂度的主要因素。
正确答案:否
影响算法时间复杂度的主要因素是移动元素的次数和关键字比较的次数。
内排序方法要求数据一定以顺序表方式存储。
正确答案:否
有些内排序方法也适合数据采用链表方式存储的情况。
所有内排序算法中的比较次数与初始元素序列的排列无关。
正确答案:否
排序的稳定性是指排序算法中的比较次数保持不变，且算法能够终止。
正确答案:否
简述何时使用稳定的排序算法。
如果排序数据存在相同关键字的元素，而且要求排序后不改变这些相同关键字记录的相对位置，此时需要使用稳定的排序算法。如张三的成绩是82，李四成绩也是82，而张三的记录在李四的记录的前面，要求按成绩递减排序，排好序后，张三的记录仍在李四的记录的前面，这就需要使用稳定的排序算法。
另一个用途是多关键字排序，如学生记录有姓名、数学、语文成绩和总分，要求这样排名次，先按总分，总分相同再按数学成绩。可以这样排序，先采用任一种排序方法按数学成绩递减排序，再选择一种稳定的排序方法按总分排序，后者一定用稳定的排序方法，否则会出现总分相同，数学成绩低的排到前面了。
排序方法的稳定性受什么因素影响？
在排序过程中，需要以一个较大的间隔互换元素，或把元素隔空搬运一段较大距离时，排序方法一定不稳定，它可能会把原先排在前面的元素搬到具有相同关键字值的另一个元素的后面，改变了相对位置。
证明：对于一个长度为n的线性表基于比较方法进行排序，至少需要进行nlog2n次比较。
证明：对于一个长度为n的线性表基于比较方法进行排序，元素两两比较构成的判定树可以近似看成是一棵满二叉树，其中叶子结点是某种排序结果，由于n个元素总共有n!种不同的排列，所以叶子结点个数为n!，一次排序恰好经过从根结点到某个叶子结点的路径，比较次数为树的高度，而h=log2(n!)≈nlog2n，所以至少需要进行nlog2n次比较。
给出关键字序列{4,5,1,2,8,6,7,3,10,9}采用直接插入排序时各趟的结果。
直接插入排序过程如图11所示。
直接插入排序算法在含有n个元素的初始数据正序、反序和数据全部相等时，时间复杂度各是多少？
含有n个元素的初始数据正序时，直接插入排序算法的时间复杂度为O(n)。
含有n个元素的初始数据反序时，直接插入排序算法的时间复杂度为O(n2)。
含有n个元素的初始数据全部相等时，直接插入排序算法的时间复杂度为O(n)。
下列排序方法中，（ ）在一趟结束后不一定能选出一个元素放在其最终位置上。
A.选择排序
B.冒泡排序
C.归并排序
D.堆排序
正确答案C
因为归并排序每趟并不一定产生全局有序区。
2
下列排序方法中，稳定的排序算法是（ ）。
A.希尔选择
B.快速排序
C.归并排序
D.堆排序
正确答案C
这几种排序方法中只有归并排序是稳定的，其余几种排序方法都是不稳定的。
下列排序方法中，辅助空间为O(n)的是（ ） 。
A.希尔选择
B.冒泡排序
C.堆排序
D.归并排序
正确答案D
这几种排序方法中只有归并排序的空间复杂度为O(n)，其余几种排序方法的空间复杂度为O(1)。
下列四种排序中 （ ）的空间复杂度最大。
A.直接插入排序
B.冒泡排序
C.堆排序
D.二路归并排序
正确答案D
二路归并排序的空间复杂度为O(n)。
就排序算法所用的辅助空间而言，堆排序、快速排序和归并排序的关系是（ ）。
A.堆排序 < 快速排序 < 归并排序
B.堆排序 < 归并排序 < 快速排序
C.堆排序 > 归并排序 > 快速排序
D.堆排序 > 快速排序 > 归并排序
正确答案A
归并排序的空间复杂度为O(n)，快速排序的空间复杂度为O(log2n)，堆排序的空间复杂度为O(1)。
数据序列{1,2,3,4,5,6,7,8}采用二路归并排序方法进行递增排序，经过两趟排序后的结果是___。
{1,2,3,4,5,6,7,8}
数据序列{8,7,6,5,4,3,2,1}采用二路归并排序方法进行递增排序，所需要关键字比较次数是___。
12
排序过程如下：
8，7，6，5，4，3，2，1初始数据
7，8，5，6，3，4，1，2共比较4次
5，6，7，8，1，2，3，4共比较4次
1，2，3，4，5，6，7，8 共比较4次
数据序列中有n=2k个元素，采用二路归并排序方法进行递增排序，最好情况下所需要关键字比较次数是___。
k2<sup>k-1</sup>
当数据序列正序或反序时，所需要关键字比较次数最少，每趟只需n/2=2k-1次关键字比较，共有k趟，总的关键字比较次数为k2k-1。
在快速排序、堆排序、归并排序中，___排序是稳定的。
归并排序
二路归并排序算法的空间复杂度是___。
O(n)
二路归并排序算法是稳定的。
正确答案:是
对于不同的初始数据序列，二路归并排序算法中关键字比较次数有所不同。
正确答案:是
二路归并排序算法的时间复杂度与初始数据序列的顺序无关，但关键字比较次数是相关的。
二路归并排序算法的时间复杂度与初始数据序列的顺序无关。
正确答案:是
二路归并排序算法的最好时间复杂度为O(n)。
正确答案:否
二路归并排序算法的最好时间复杂度也为O(nlog2n)。
n个元素采用二路归并排序算法，总的趟数为n。
正确答案:否
n个元素采用二路归并排序算法，总的趟数为log2n。
已知序列{15,5,16,2,25,8,20,9,18,12}，采用二路归并排序法对该序列做升序排序时的每一趟的结果。
采用二路归并排序法排序的各趟结果如图11所示。
两个各含有n个元素的有序序列归并成一个有序序列时，关键字比较次数为n～2n-1，也就是说关键字比较次数与初始序列有关。为什么通常说二路归并排序与初始序列无关呢？
二路归并排序中使用了辅助空间R1，需要先将所有归并数据移到R1中，然后再复制到R中，所以每一趟移动元素的次数2n，共需log2n趟排序，总的移动次数总是O(nlog2n)。尽管待排序的初始序列对关键字的比较有一定的影响，但不改变算法的总体时间性能，所以通常说二路归并排序与初始序列无关。
二路归并排序中每一趟排序都要开辟O(n)的辅助空间，共需log2n趟排序，为什么总的辅助空间仍为O(n)？
二路归并排序中每一趟排序都要开辟O(n)的辅助空间，但在一趟排序结束后，这些辅助空间都被释放了，所以总的辅助空间仍为O(n)。
在堆排序、快速排序和归并排序中：
（1）若只从存储空间考虑，则应首先选取哪种排序方法，其次选取哪种排序方法，最后选取哪种排序方法？
（2）若只从排序结果的稳定性考虑，则应选取哪种排序方法？
（3）若只从最坏情况下的排序时间考虑，则不应选取哪种排序方法？
（1）若只从存储空间考虑，则应首先选取堆排序（空间复杂度为O(1)），其次选取快速排序（空间复杂度为O(log2n)），最后选取归并排序（空间复杂度为O(n)）。
（2）若只从排序结果的稳定性考虑，则应选取归并排序。因为归并排序是稳定的，其他两种排序方法是不稳定的。
（3）若只从最坏情况下的排序时间考虑，则不应选取快速排序方法。因为快速排序方法最坏情况下的时间复杂度为O(n2)，其他两种排序方法在最坏情况下的时间复杂度为O(nlog2n)。
以归并算法为例，比较内排序和外排序的不同，说明外排序如何提高操作效率。
内排序中的归并排序是在内存中进行的归并排序，辅助空间为O(n)。外部归并排序是将外存中的多个有序子文件合并成一个有序子文件，将每个子文件中记录读入内存后的排序方法可采用多种内排序方法。外部排序的效率主要取决于读写外存的次数，即归并的趟数。因为归并的趟数s=logkm，其中，m是归并段个数，k是归并路数。增大k和减少m都可减少归并趟数。实际应用中通过败者树进行k（k≥3）路平衡归并和置换-选择排序减少m，来提高外部排序的效率。
以下排序方法中，（ ）不需要进行关键字的比较。
A.快速排序
B.归并排序
C.基数排序
D.堆排序
正确答案C
在本章介绍的各种排序方法中，基数排序是唯一不基于关键字比较的排序方法。
4
以下排序方法中，稳定的排序方法是（ ） 。
A.快速排序
B.堆排序
C.希尔排序
D.基数排序
正确答案D
基数排序是一种稳定的排序方法。
有n个十进制整数进行基数排序，其中最大的整数为5位，则基数排序的趟数是（ ）。
A.10
B.n
C.5
D.2
正确答案C
基数排序的趟数是最大的关键字的位数。
有n个十进制整数进行基数排序，其中最大的整数为5位，则基数排序过程中临时建立的队数个数是（ ）。
A.10
B.n
C.5
D.2
正确答案A
基数排序中建立队列个数等于进制数。
以下四个线性表中，最适合采用基数排序的是（ ）。
A.10000个实数
B.1000个由字母、数字和其他字符组成的字符串
C.1000个int类型的整数
D.10000个100以内的正整数
正确答案D
选项C中有可能出现负整数，这样不适合基数排序。
给出关键字序列{112,214,312,902,156,712,451,623,643,834}按低位到高位进行基数排序时每一趟的结果。
排序结果如图11所示。
给出关键字序列{112,214,312,902,156,712,451,623,643,834}按高位到低位进行基数排序时每一趟的结果。
排序结果如图12所示，从中看到，最终的排序结果是错误的，所以对于数值数据排序时只能是按低位到高位进行基数排序。
有n个不同的英文单词（均为小写字母），它们的长度相等，均为m。若n=50，m<5，试问采用什么排序方法时其时间复杂度最小？为什么？
采用基数排序方法最好，这里r=26，其时间复杂度为O(m(n+26m))，其他排序方法的时间复杂度最小为O(nlog2n)，当n=50，m<5时，m(n+26m)<nlog2n，所以基数排序方法最好。
问在一般情况下，直接插入排序、选择排序和冒泡排序的过程中，所需元素交换次数最少的是哪种排序方法？
对于直接插入排序，有序区分别有1、2、…、n-1个元素，平均交换一半的元素，所以平均元素交换次数=。
对于选择排序，最多只进行n-1次元素交换
对于冒泡排序，平均每趟交换一半的元素，平均排序n/2趟，所以平均元素交换次数=
。
所以元素交换次数最少的是选择排序。
在下列情况下，选择哪种内排序算法比较合适？说明理由。
（1）需要对1000个大型记录进行排序，记录本身存储在外存中，在内存中只保研了所有记录的关键字。关键字之间的比较非常快，但移动代价很大，因为一旦移动一个关键字，相应的外存中的记录也要移动，这将涉及很多磁盘块的移动。
（2）已知一个包含了5000个单词的列表已按字母顺序排好序，需要再进行一次检查，确保所有的单词已经排好序。
（3）需要将500张随机排列的图书卡片按照字母顺序排序。
（1）选择选择排序，该排序方法可以达到尽量少地移动记录，虽然比较次数达到O(n2)，但是相对外存的处理时间来说，不是关键因素。
（2）因为整个表已经基本有序，所以应该采用直接插入排序。
（3）因为是随机排列的卡片，所以选择快速排序比较合适。
基数排序主要适用于___排序的情况。
多关键字
基数排序与其他几种排序方法的区别是___。
基数排序采用分配和收集实现，不需要进行关键字的比较，而其他几种排序方法都是通过关键字的比较实现的
对数据序列{288,371,260,531,287,235,56,299,18,23}采用最低位优先的基数排序，第一趟排序后的结果是___。
{260,371,531,23,235,56,287,288,18,299}
对数据序列{288,371,260,531,287,235,56,299,18,23}采用最低位优先的基数排序，第2趟排序后的结果是___。
{18,23,531,235,56,260,371,287,288,299}
基数排序的空间复杂度是___。
O(r)（r为排序的基数）
基数排序只适用于以数字为关键字的情况，不适用以字符串为关键字的情况。
正确答案:否
基数排序与初始数据的次序无关。
正确答案:是
基数排序与初始数据中关键字的大小无关。
正确答案:否
基数排序与初始数据中关键字的位数有关，也就与关键字的大小有关。
快速排序、选择排序和堆排序都与初始序列次序无关。
正确答案:否
快速排序与初始序列次序无关。
直接插入排序、冒泡排序和选择排序在最好情况下的时间复杂度均为O(n)。
正确答案:否
直接插入排序和冒泡排序在最好情况下的时间复杂度均为O(n)。
以下稳定的排序方法是（ ）。
A.直接插入排序和快速排序
B.直接插入排序和冒泡排序
C.选择排序和归并排序
D.选择排序和冒泡排序
正确答案B
6
以下 （ ）方法在数据基本有序时效率最好。
A.快速排序
B.冒泡排序
C.堆排序
D.希尔排序
正确答案B
冒泡排序最少关键字比较的次数是（ ）。
A.0
B.n
C.n-1
D.3n(n-1)/2
正确答案C
冒泡排序最少元素移动的次数是（ ） 。
A.0
B.1
C.n
D.3n(n-1)/2
正确答案A
对一组数据(2,12,16,88,5,10)进行排序，若前三趟的结果如下：
第一趟：2,12,16,5,10,88
第二趟：2,12,5,10,16,88
第三趟：2,5,10,12,16,88
则采用的排序方法可能是 （ ） 。
A.冒泡排序
B.希尔排序
C.归并排序
D.基数排序
正确答案A
对含有n个元素的数据序列进行冒泡排序，其中关键字比较最多的次数是___。
n(n-1)/2
当数据反序时冒泡排序方法所需关键字比较次数最多，此时关键字比较次数=(n-1)+…+2+1=n(n-1)/2。
对含有n个元素的数据序列进行冒泡排序，其中关键字比较最少的次数是___。
n-1
当数据正序时冒泡排序方法所需关键字比较次数最少，只需一趟排序，此时关键字比较次数=n-1。
冒泡排序算法在最好情况下的时间复杂度是___。
O(n)
当数据正序时冒泡排序算法的时间复杂度是O(n)。
冒泡排序算法的平均时间复杂度是___。
O(n<sup>2</sup>)
对数据序列{5,1,7,9,8,6,3,4,2,10}采用冒泡排序方法进行递增排序，每趟通过交换归位关键字最小的元素，经过一趟后的排序结果是___。
{1,5,2,7,9,8,6,3,4,10}
冒泡排序在最好情况下的时间复杂度也是O(n2)。
正确答案:否
冒泡排序在最好情况下的时间复杂度为O(n)。
采用冒泡排序进行递增排序时，关键字较小的元素总是向前移动，关键字较大的元素总是向后移动。
正确答案:否
对n个元素进行冒泡排序，只有在初始元素反序时，冒泡排序移动元素的次数才会达到最大值。
正确答案:是
冒泡排序在最好情况下元素移动的次数为0。
正确答案:是
冒泡排序在初始数据正序时元素移动的次数为0。
冒泡排序中，关键字比较的次数与初始数据序列有关，而元素移动的次数与初始数据序列无关。
正确答案:否
关键字比较的次数与元素移动的次数都与初始数据序列有关。
已知序列{15,5,16,2,25,8,20,9,18,12}，给出采用冒泡排序方法对该序列做升序排序时的过程。
采用冒泡排序方法排序的过程如下：
冒泡排序在什么情况下需要进行的关键字比较次数最多，最多关键字比较次数是多少？
冒泡排序在初始数据反序时需要进行的关键字比较次数最多，此时关键字比较次数=(n-1)+(n-2)+…+1=n(n-1)/2。
冒泡排序在什么情况下需要进行的元素移动次数最少，最少元素移动次数是多少？
冒泡排序在初始数据正序时需要移动的元素次数最小，此时移动的元素次数为0。
在冒泡排序过程中，有的关键字在某趟排序中可能朝着与最终排序相反的方向移动，请举例说明之。快速排序过程中有没有这种现象出现？
在冒泡排序，有的关键字在某趟排序中可能朝着与最终排序相反的方向移动，例如，以下冒泡排序过程中关键字38便是如此：
49，38，13，27，97（初始关键字）
38，13，27，49，97（第1趟排序）
13，27，38，49，97（第2趟排序）
但在快速排序中不会出现这种情况。因为在每趟排序中，比基准元素大的都交换到其右边，而基准元素小的则交换到其左边。
已知序列{15,5,16,2,25,8,20,9,18,12}，给出采用快速排序方法对该序列做升序排序时的过程。
采用快速排序方法排序的过程如图11所示。
在排序算法中，每次从未排序的元素中通过关键字直接比较选取最小关键字的元素，加入到已排序元素的末尾，该排序方法是（ ）。
A.选择排序
B.冒泡排序
C.堆排序
D.直接插入排序
正确答案A
这是典型的选择排序方法，如果借助堆来选取最小元素就是堆排序方法。
8
对数据{84,47,25,15,21}排序，数据的排列次序在排序过程中的变化如图11所示，则采用的排序方法是 （ ）。
A.选择排序
B.快速排序
C.冒泡排序
D.直接插入排序
正确答案A
从数据排列次序的变化过程看到，每一趟都从无序区中选一个最小的元素归位。
假设排序过程中顺序表的变化情况如下：
21，25，49，25，16，8（初始状态）
8，25，49，25，16，21
8，16，49，25，25，21
8，16，21，25，25，49
8，16，21，25，25，49
8，16，21，25，25，49（最终状态）
可以断定，所采用的排序方法是（ ） 排序。
A.直接插入
B.冒泡
C.二路归并
D.选择
正确答案D
共有6个元素，即使有序也不结束，从排序过程可以断定是选择排序。
采用排序算法对n个元素进行排序，其排序趟数肯定为n-1趟的排序方法是（ ）。
A.直接插入和快速
B.冒泡和快速
C.选择和直接插入
D.选择和冒泡
正确答案C
选择和直接插入肯定要进行n-1趟排序，冒泡排序为1～n-1趟，快速排序为log2n～n-1趟。
在一般情况下，以下排序算法中元素移动次数最少的（ ） 。
A.直接插入排序
B.冒泡排序
C.选择排序
D.都一样
正确答案C
选择排序移动元素的次数为0～3(n-1)，在一般情况下，比直接插入排序和冒泡排序移动元素次数要少。
选择排序的最好、最坏和平均时间复杂度分别为、____、、、____、、、____、。
O(n<sup>2</sup>)、O(n<sup>2</sup>)、O(n<sup>2</sup>)
在直接插入排序、冒泡排序和选择排序这三种排序方法中，___是不稳定的。
选择排序
数据序列{6,9,1,4,5,2,3,8,7,10}采用选择排序进行递增排序，每趟挑选最小元素，经过3趟排序后结果是___ 。
{1,2,3,4,5,9,6,8,7,10}
对含有n个元素的数据序列进行选择排序，总的关键字比较次数是___。
n(n-1)/2
对含有n个元素的数据序列进行选择排序，最好情况下元素移动的次数是___。
0
当数据序列正序时没有元素移动。
选择排序在初始数据正序时，其时间复杂度为O(n)。
正确答案:否
选择排序中，每趟产生的有序区中所有元素在以后的排序中不再改变位置。
正确答案:是
选择排序是一种不稳定的排序方法。
正确答案:是
n个元素采用选择排序进行排序，关键字比较的次数总是n(n-1)/2。
正确答案:是
从时间性能看，堆排序总是优于选择排序。
正确答案:是
堆排序的最好、最坏和平均时间复杂度均为O(nlog2n)，而选择排序的最好、最坏和平均时间复杂度均为O(n2)。
给出数据序列{9,8,7,6,5,4,3,2,1}采用选择排序进行递增排序时各趟的结果。并指出选择排序的缺陷。
排序过程如下：
i=0：1，8，7，6，5，4，3，2，9
i=1：1，2，7，6，5，4，3，8，9
i=2：1，2，3，6，5，4，7，8，9
i=3：1，2，3，4，5，6，7，8，9
i=4：1，2，3，4，5，6，7，8，9
i=5：1，2，3，4，5，6，7，8，9
i=6：1，2，3，4，5，6，7，8，9
i=7：1，2，3，4，5，6，7，8，9
从中看出，当i=3这一趟排序结束后，数据已有序，但选择排序仍要完成余下的各趟排序，也就是说选择排序没有中途退出机制。
简述选择排序的时间性能。
选择排序的主要时间花在关键字比较上，无论初始数据序列如何排列，所需关键字比较次数均为n(n-1)/2，所以选择排序算法的时间复杂度总是O(n2)，与初始数据序列如何排列无关。
一个有n个整数的数组R[.n]，其中所有元素是有序的，将其看成是一棵完全二叉树，该树构成一个堆吗？若不是，请给一个反例，若是，请说明理由。
该数组一定构成一个堆，递增有序数组构成一个小根堆，递减有序数组构成一个大根堆。
以递增有序数组为例，假设数组元素为k1、k2、…、kn是递增有序的，从中看出下标越大的元素值也越大，对于任一元素ki，有ki<k2i，ki<k2i+1（i<n/2），这正好满足小根堆的特性，所以构成一个小根堆。
已知关键字序列为{72,87,61,23,94,16,5,58}，采用堆排序法对该序列进行递增排序，给出整个排序过程。
该序列对应的完全二叉树如图11（a）所示，调整成初始堆如图11（b）所示，用堆排序方法排序的各趟过程如图11（c）～（o）所示，排序结果为{5,16,23,58,61,72,87,94}。
请回答下列关于堆排序中堆的一些问题：
（1）堆的存储表示是顺序还是链式的？
（2）设有一个小根堆，即堆中任意结点的关键字均小于它的左孩子和右孩子的关键字。其中具有最大关键字的结点可能在什么地方？
（1）通常堆的存储表示是顺序的。因为堆排序将待排序序列看成是一棵完全二叉树，然后将其调整成一个堆。而完全二叉树特别适合于采用顺序存储结构，所以堆的存储表示采用顺序方式最合适。
（2）小根堆中具有最大关键字的结点只可能出现在叶子结点中。因为最小堆的最小关键字的结点必是根结点，而最大关键字的结点由偏序关系可知，只有叶子结点可能是最大关键字的结点。
1
外排序和内排序的主要区别是（ ）。
A.内排序速度快，而外排序速度慢
B.内排序不涉及内、外存数据交换，而外排序涉及内、外存数据交换
C.内排序所需内存小，而外排序所需内存大
D.内排序的数据量小，而外排序的数据量大
正确答案B
首页
作业系统
考试系统
师资培训
课程题库
考研
问答
使用手册
第8章作业
总分：10
得分：9
哈希查找方法一般适用于（ ）情况下的查找。
A.查找表为链表
B.查找表为有序表
C.关键字集合比地址集合大得多
D.关键字集合与地址集合之间存在对应关系
正确答案D
关键字集合与地址集合之间存在对应关系时，通过哈希函数表示这种关系，这样查找以计算哈希函数而不是比较的方式进行查找。
哈希查找的基本思想是根据（ ）来决定元素的存储地址。
A.元素的序号
B.元素个数
C.关键字值
D.非关键字属性值
正确答案C
将10个元素散列到大小为10000的哈希表中，（ ）产生冲突。
A.一定会
B.一定不会
C.仍可能会
D.以上都不对
正确答案C
无论装填因子大还是小，哈希表仍可能发生冲突。
以下关于哈希查找的叙述中错误的是（ ） 。
A.用拉链法解决冲突易引起堆积现象
B.用线性探测法解决冲突易引起堆积现象
C.哈希函数选得好可以减少冲突现象
D.哈希函数H(k)=k MOD p，p通常取小于等于表长的素数
正确答案A
用拉链法解决冲突时不存在堆积现象，只有用线性探测法解决冲突时易引起堆积现象。
在各种查找方法中，其成功和不成功情况下的平均查找长度与元素个数n无直接关系的查找方法是___。
哈希表查找
哈希表是通过、____、将某关键字的记录映射到哈希表中，当发生冲突时，选择某种、____、再找新的存放位置。
哈希函数、解决冲突的方法
哈希表中，哈希地址空间是指___。
哈希函数的取值范围
评价哈希函数好坏的标准是___。
哈希函数的取值均匀
构建哈希表的关键是、____、和、____、。
选择好的哈希函数、处理冲突的方法
哈希冲突是指同一个关键字对应多个不同的哈希地址。
正确答案:否
哈希冲突是指多个不同一个关键字对应相同的哈希地址。
哈希表中所有的哈希地址是连续的。
正确答案:是
哈希表发生冲突是由于选取的解决冲突的方法不当造成的。
正确答案:否
哈希表发生冲突是由于选取的哈希函数不合适造成的。
哈希表查找的时间性能可以达到O(1)，为什么在查找时不总是使用哈希表查找？
哈希表查找的时间性能O(1)是理想情况下的性能，在实际应用中的时间性能随数据量和数据分布情况的变化而变化，极端情况下也是O(n)的时间性能。而且采用开放定址法构造的哈希表要保证一定的空闲单元的比例，是以牺牲空间来换取时间的。
什么是哈希冲突？处理冲突的方法是什么？
在哈希表中，若某个哈希函数h对于不相等的关键字key1和key2得到相同的哈希地址（即h(key1)=h(key2)），将该现象称为冲突。
解决冲突的主要方法有开放定址法和拉链法。
为什么哈希表不支持元素之间的顺序查找？
哈希表是通过哈希地址来查找对应关键字的记录的，对哈希表来说顺序查找没有任何意义，也没有提供顺序查找机制。
在含有n个结点的二叉排序树中查找某关键字的结点时，最多进行（ ）次比较。
A.n/2
B.log2n
C.log2n+1
D.n
正确答案D
n个结点的二叉排序树的高度可能为n。
用n个关键字构造的一棵二叉排序树，其最低高度为（ ） 。
A.n/2
B.n
C.log2n
D.log2n+1
正确答案D
二叉排序树的最低高度与对应的平衡二叉树的高度相同。
用n个关键字构造的一棵二叉排序树，经过i次关键字比较成功找到的元素个数最多为（ ）。
A.i
B.2i
C.2i-1
D.2i-1
正确答案C
二叉排序树中第i层最多有2i-1个结点。
二叉排序中，最小关键字结点 （ ）。
A.没有左孩子结点
B.没有右孩子结点
C.一定没有左右孩子结点
D.一定存在左右孩子结点
正确答案A
在二叉排序中，最小关键字结点是中序序列的第一个结点，即根结点的最左下结点。
二叉排序中，最大关键字结点的 （ ） 。
A.没有左孩子结点
B.没有右孩子结点
C.一定没有左右孩子结点
D.一定存在左右孩子结点
正确答案B
在二叉排序中，最大关键字结点是中序序列的最后结点，即根结点的最右下结点。
二叉排序树的性质是指___。
左子树上所有结点的关键字均小于根结点关键字；右子树上所有结点的关键字均大于根结点的关键字
在二叉排序树中，关键字最小的结点是根结点的___。
最左下结点
在二叉排序树中，关键字最大的结点是根结点的___。
最右下结点
对二叉排序树进行___遍历，可以得到接关键字从小到大排列的结点序列。
中序
对一棵二叉排序树进行这样的遍历：遍历右子树、访问根结点、遍历左子树，则得到的遍历序列是___。
按关键字递减排列的有序序列
二叉排序树可以是一棵空树。
正确答案:是
二叉排序树是用来进行排序的。
正确答案:否
二叉排序树主要用于改进一般二叉树的查找效率。
在二叉排序树中，每个结点的关键字都比左孩子关键字大，比右孩子关键字小。
正确答案:是
二叉排序树的任意一棵子树中，关键字最小的结点必无左孩子，关键字最大的结点必无右孩子。
正确答案:是
二叉排序树的任意一棵子树也是二叉排序树。
每个结点的关键字都比左孩子关键字大，比右孩子关键字小，这样的二叉树一定是二叉排序树。
正确答案:否
对于二叉排序树，左子树上所有结点的关键字均小于根记录的关键字；右子树上所有结点的关键字均大于根记录的关键字。而不是仅仅与左、右孩子的关键字进行比较。
和折半查找相比，二叉排序树查找的优缺点各是什么？
二叉排序树的缺点是可能变得非常不平衡，从而导致查找时间退化为O(n)。优点是对于插入和删除操作效率高。
有一棵二叉排序树按先序遍历得到的序列为：(50,38,30,45,40,48,70,60,75,80)。回答以下问题：
（1）画出该二叉排序树。
（2）在等概率下，求查找成功的平均查找长度和查找不成功的平均查找长度。
（1）先序遍历得到的序列为：(50,38,30,45,40,48,70,60,75,80)，中序序列是一个有序序列，所以为：(30,38,40,45,48,50,60,70,75,80)，由先序序列和中序序列可以构造出对应的二叉树，如图1所示。
由二叉排序树的构造过程可以看出，一棵二叉排序树的先序序列即为构造该树的序列，因为在二叉排序树中插入一个结点的过程是：先和根结点比较，小于根结点时插入到左子树，大于根结点时插入到右子树，所以按照(50,38,30,45,40,48,70,60,75,80)构造一棵二叉排序树即可。
（2）ASL成功=(1×1+2×2+4×3+3×4)/10=9。
ASL不成功=(5×3+6×4)/11=55。
将二叉排序树T的先序序列中的关键字依次插入到一棵空的二叉排序树中，所得到的二叉排序树T'与T相同？为什么？
二叉排序树T'与T相同。
因为二叉排序树属于二叉树，其先序序列的第一个元素一定是二叉排序树的根，而对应先序序列的根后面所有元素分为两组：从根的后一元素开始的其值小于根的值的一组元素就是树的左子树的结点的先序序列，剩下的元素的值大于根的值，即为树的右子树的结点的先序序列。
在把先序序列的元素依次插入初始为空的二叉排序树时，第一个元素就成树的根，它后面第一组元素的值都小于根结点的值，可以递归建立根的左子树；第二组元素的值都大于根结点的值，可以递归建立根的右子树。
证明一棵非空二叉排序树的中序遍历序列是从小到大有序的。
证明：设中序遍历序列为：
R1,R2,R3,…,Ri,…,Rj,…,Rn（1）
并假设Rj＜Ri，根据二叉排序树的生成规则：Ri、Rj一定是以某一结点Rk为根的子树中的结点。不妨设在生成二叉排序树时，Ri先于Rj输入，而且Ri≥Rk（Ri＜Rk的情况类似）。这样Ri输入后一定是Rk右子树中的结点。在Rj输入时，若Rj≥Rk，则Rj也成为Rk右子树的结点，但由于Rj＜Ri，所以，Rj不可能成为Ri右子树中的结点。若Rj＜Rk，则Rj成为Rk左子树中的结点，这样按中序遍历所得序列为：
…,Rk,…,Rj,…,Ri,…（2）
或：
…,Rj,…,Rk,…,Ri,… （3）
这样，（2）、（3）两式与（1）式矛盾，所以当Rj＜Ri时命题成立。同理可以证明Rj先于Ri输入的情况。
证明如果一棵非空二叉树的中序遍历序列是从小到大有序的，则该二叉树是一棵二叉排序树。
证明：对于关键字为k的任一结点a，由中序遍历过程可知，在中序遍历序列中，它的左子树的所有结点的关键字排在k的左边，它的右子树的所有结点的关键字排在k的右边，由于中序序列是从小到大排列的，所以结点a的左子树中所有结点的关键字小于k，结点a的右子树中所有结点的关键字大于k，这满足二叉排序树的性质，所以该二叉树是一棵二叉排序树。
静态查找表和动态查找表的区别是（ ） 。
A.它们的逻辑结构相同
B.施加其上的操作不同
C.所包含的数据元素的类型不同
D.存储实现不同
正确答案B
由支持修改运算（或操作）来确定存放数据元素的表是静态查找表还是动态查找表。
查找效率低的数据结构是（ ）。
A.有序顺序表
B.二叉排序树
C.堆
D.二叉平衡树
正确答案C
堆查找的时间复杂度为O(n)，所以效率最低。
如果一个表既能较快地查找，又能适应动态变化的要求，则可采用（ ）。
A.有序表
B.线性表
C.哈希表
D.二叉平衡树
正确答案D
满足这种条件的表为树表，各选项中只有二叉平衡树是一种树表。
顺序查找法适合于存储结构为（ ）的线性表。
A.哈希存储
B.顺序存储或链式存储
C.压缩存储
D.索引存储
正确答案B
顺序查找可以从前向后或从后向前依次查找，既适合于顺序存储结构也适合于链式存储结构。
采用顺序查找方法查找长度为n的线性表时，成功查找的平均查找长度为 （ ）。
A.n
B.n/2
C.(n+1)/2
D.(n-1)/2
正确答案C
解：顺序查找时，元素ai需i次比较，成功查找的平均查找长度=(1+2+…+n)/n=(n+1)/2。
顺序查找方法适用于存储结构为、____、的线性表，而使用折半查找方法的条件是、____、。
顺序表或链表、存储结构为顺序表的有序表
顺序查找算法的时间复杂度为___。
O(n)
和顺序查找方法相比，折半查找的主要缺点是___。
只能在有序的顺序表上进行
采用顺序查找方法查找含n个元素的顺序表，最好情况下的关键字比较次数是___。
1
最好情况是第一个元素就是要找的元素。
采用顺序查找方法查找含n个元素的顺序表，若查找成功，则比较关键字的次数最多为、____、次；若查找不成功，则比较关键字的次数为、____、次。
n、n
顺序查找时，找到表尾元素需要比较n次，不成功查找总是比较n次。
对于不同的存储结构，应采用不同的查找方法。
正确答案:是
对于满足折半查找和分块查找条件的文件而言，无论该文件存放在任何介质上，均能进行顺序查找、折半查找和分块查找。
正确答案:否
在顺序存储的物理介质如磁带上，只能进行顺序查找，即便文件有序，也不能进行折半查找。
顺序查找法适用于存储结构为顺序或链式存储的线性表。
正确答案:是
顺序查找方法只能在顺序存储结构上进行。
正确答案:否
顺序查找方法也可以在链表存储结构上进行。
顺序查找方法只能从顺序表的前端向后端查找。
正确答案:否
顺序查找方法可以从顺序表的前端向后端查找，也可以从顺序表的后端向前端查找。
简述静态查找表和动态查找表的异同。
静态查找表和动态查找表都是数据存储结构，都适合数据查找，前者不便于（并不是不能）数据修改操作，如插入和删除元素，后者方便数数据修改操作。
设有5个数据do、for、if、repeat、while，它们排在一个有序表中，其查找概率分别是p1=2，p2=15，p3=1，p4=03，p5=01。而查找它们之间不存在数据的概率分别为q0=2，q1=15，q2=1，q3=03，q4=02，q5=01，如下图所示：
（1）试画出对该有序表分别采用顺序查找和折半查找时的判定树。
（2）分别计算顺序查找的查找成功和不成功的平均查找长度。
（3）分别计算折半查找的查找成功和不成功的平均查找长度。
（1）对该有序表分别采用顺序查找和折半查找时的判定树分别如图2和3所示。
（2）对于顺序查找：
ASL成功=(1p1+2p2+3p3+4p4+5p5)=97。
ASL不成功=(1q0+2q1+3q2+4q3+5q4+5q5)=07。
（3）对于折半查找：
ASL成功=(1p3+2(p1+p4)+3(p2+p5))=04。
ASL不成功=(2q0+3q1+3q2+2q3+3q4+3q5)=3。
折半查找对查找的数据有什么要求？
从存储结构来看，折半查找要求数据采用具有随机存取特性的存储结构来存储。
从数据的有序来看，折半查找要求数据是有序的。
设有100个元素的有序表，用折半查找时，不成功时最大的比较次数是 （ ） 。
A.25
B.50
C.10
D.7
正确答案D
不成功时最大的比较次数=log2(n+1)=7。答案为D。
在一棵m阶B树中删除一个关键字会引起合并，则该结点原有（ ）个关键字。
A.1
B.m/2
C.m/2-1
D.m/2+1
正确答案C
在一棵m阶B树中每个内部结点的关键字个数为m/2-1～m-1，删除一个关键字会引起合并，则该结点中关键字个数一定是最少的情况。答案为C。
哈希查找方法一般适用于（ ） 情况下的查找。
A.查找表为链表
B.查找表为有序表
C.关键字集合比地址集合大得多
D.关键字集合与地址集合之间存在着某种对应关系。
正确答案D
哈希表通过哈希函数和冲突解决函数确定存储地址的，适合关键字集合与地址集合之间存在着某种对应关系的数据集的存储与查找。答案为D。
有一棵二叉排序树按先序遍历得到的序列为（12，5，2，8，6，10，16，15，18，20）。回答以下问题：
（1）画出该二叉排序树。
（2）给出该二叉排序树的后序遍历序列。
（3）求在等概率下的查找成功和不成功情况下的平均查找长度。
（1）该二叉排序树的先序序列为(12，5，2，8，6，10，16，15，18，20)，中序序列是一个有序序列，所以为(2，5，6，8，10，12，15，16，18，20)，由先序序列和中序序列可以构造出对应的二叉树，如图A.4所示。
（2）后序遍历序列为：2，6，10，8，5，15，20，18，16，12。
（3）ASL成功=(1×1+2×2+4×3+3×4)/10=29/10。
ASL不成功=(5×3+6×4/11=39/11。
哈希表中出现的哈希冲突是指( )。
A.两个元素具有相同的序号
B.两个元素的关键字不同，而其他属性相同
C.数据元素过多
D.两个元素的关键字不同，而对应的哈希函数值相同
正确答案D
哈希冲突也称为同义词冲突，是指两个元素的关键字不同，而对应的哈希函数值相同。答案为D。
适合于折半查找的数据组织方式是( )。
A.以链表存储的线性表
B.以顺序表存储的任意线性表
C.以链表存储的有序线性表
D.以顺序表存储的有序线性表
正确答案D
折半查找的元素序列一定是有序的，并且采用具有随机存取特性的存储结构存储。答案为D。
假设一棵二叉排序树的关键字为单个字母，其后序遍历序列为ACDBFIJHGE，回答以下问题：
（1）画出该二叉排序树。（）
（2）求在等概率下的查找成功的平均查找长度。（）
（3）求在等概率下的查找不成功的平均查找长度。（）
（1）该二叉排序树的后序序列为ACDBFIJHGE，其中序序列是一个递增有序序列，所以中序序列为ABCDEFGHIJ，由后序序列和中序序列构造的二叉排序树如图A.6所示。
（2）考虑二叉排序树中的10个内部结点，累加找到某个结点需要的关键字比较次数，再除以10得到成功时的平均查找长度：
ASL成功=(1×1+2×2+4×3+2×4+1×5)/10=3。
（3）考虑二叉排序树中的11个外部结点，累加找到某个结点需要的关键字比较次数，再除以11得到不成功时的平均查找长度：
ASL不成功=(6×3+3×4+2×5)/11=64。
6
对含有n个元素的顺序表采用顺序查找方法，不成功时的比较次数是( )。
A.1
B.n
C.n-1
D.n+1
正确答案B
不成功时的比较次数总是n。答案为B。
含有20个结点的AVL树的最大高度是( )。
A.4
B.5
C.6
D.7
正确答案C
设Nh表示高度为h的平衡二叉树中含有的最少结点数，有N1=1，N2=2，Nh=Nh-1+Nh-2+1，求出N6=20。答案为C。
在一棵m阶B树中插入一个关键字会引起分裂，则该结点原有( )个关键字。
A.1
B.m
C.m-1
D.m/2
正确答案C
在一棵m阶B树中每个内部结点的关键字个数为m/2-1～m-1，插入一个关键字会引起分裂，则该结点中关键字个数一定是最多的情况。答案为C。
以下关于哈希查找的叙述中正确的是( )_。
A.哈希查找中不需要任何关键字的比较
B.采用拉链法解决冲突时，查找每个元素的时间是相同的
C.哈希表在查找成功时的平均查找长度仅仅与表长有关
D.哈希表的装填因子等于表中填入的元素个数除以哈希表的长度
正确答案D
装填因子等于表中填入的元素个数n除以哈希表的长度m。答案为D。
一棵二叉排序树的结构如图A.8所示，其中各结点的关键字依次为32～40，请标出各结点的关键字。
答：任何二叉排序树的中序序列是递增的，即该二叉排序树的中序序列为32，33，34，35，36，37，38，39，40，填入后得到如图A.11所示的二叉排序树。
一组关键字为（5，11，7，2，3，17），利用堆排序方法建立初始大根堆，给出你建立的初始大根堆对应的关键字序列。
答：（5，11，7，2，3，17）对应的完全二叉树如图A.12左图所示，调整为初始大根堆如图A.12右图所示，对应的关键字序列为（17，11，7，2，3，5）。
设有100个元素的有序顺序表，采用折半查找方法，不成功时最大的比较次数是 （ ） 。
A.25
B.50
C.10
D.7
正确答案D
不成功时最大比较次数为log2(n+1)=log2101=7。答案为D。
在任意一棵非空二叉排序树T1中，删除某结点v之后形成二叉排序树T2，再将v 插入T2形成二叉排序树T3。下列关于T1与T3的叙述中，正确的是 （ ） 。
I. 若v是T1的叶子结点，则T1与T3不同
II. 若v是T1的叶子结点，则T1与T3相同
III. 若v不是T1的叶子结点，则T1与T3不同
IV. 若v不是T1的叶子结点，则T1与T3相同
A.仅I、III
B.仅I、IV
C.仅II、III
D.仅II、IV
正确答案C
在一棵二叉排序树中删除一个结点后再将此结点插入到二叉排序树中，如果删除的结点是叶子结点，那么在插入结点后，后来的二叉排序树与删除结点之前相同。如果删除的结点不是叶子结点，那么再插入这个结点后，后来的二叉树可能发生变化，不再相同。答案为C。
输入关键字序列（16，3，7，11，9，26），给出构造一棵AVL树的步骤。
答：建立AVL树的过程如图A.17所示（图中加阴影的结点表示要调整的结点）。
二分查找和二叉排序树查找的时间性能（ ） 。
A.完全相同
B.有时不同
C.完全不同
D.数量级都是O(log2n)
正确答案B
问题规模为n时，二分查找的时间复杂度为O(log2n)，而二叉排序树查找与树高相关，介于O(log2n)～O(n)，所以二分查找和二叉排序树查找的时间性能不是完全相同，也不是完全不同，只能说有时不同。答案为B。
7
关于m阶B树说法错误的是（ ） 。
A.m阶B树是一棵平衡的m叉树
B.B树中的查找无论成功都必须找到最下层结点
C.根结点最多含有m棵子树
D.根结点至少含有2棵子树
正确答案B
B树中成功的查找会落在某个内部结点中，失败的查找会落在某个外部结点中。答案为B。
设有一组关键字{32，13，49，24，38，21，4，12}，其哈希函数为：H(key)=key % 7，采用开放地址法的线性探查法解决冲突，试在0～9的哈希地址空间中对该关键字序列构造哈希表，并求等概率下查找成功和查找失败的平均查找长度。
SL成功=(1+2+1+1+3+1+4+4)/8=17/8
ASL不成功=(3+2+1+7+6+5+4)/7=4
正确答案
答：构造哈希表的过程如表A.2所示，得到的哈希表如表A.3所示。
求等概率下查找成功和查找失败的平均查找长度如下：
ASL成功=(1+2+1+1+3+1+4+4)/8=17/8
ASL不成功=(3+2+1+7+6+5+4)/7=4
假设一棵非空二叉排序树（左子树结点的关键字小于根结点关键字，右子树结点的关键字大于根结点关键字，树中没有关键字重复的结点）采用二叉链存储，结点类型如下：
class BSTNode:#二叉排序树结点类
def __init__(self,k,d=None,l=None,r=None): #构造方法
self.key=k #存放关键字,假设关键字为int类型
self.lchild=l #存放左孩子指针
self.rchild=r #存放右孩子指针
设计一个尽可能高效的算法输出该二叉排序树中所有关键字在x，y之间（x<y，含x和y）的关键字。
解：由于二叉排序树的中序遍历序列是一个递增排序序列，所以采用中序遍历求解。设计solve(b，x，y)算法用于输出二叉排序树b中所有在x，y之间的关键字，一旦访问到大于y的结点，则返回True，在遍历结点b的左子树时，如果其返回值为True，则直接返回True，不必遍历其右子树，从而提高效率。例如如图A.23所示的一棵二叉排序树，若x=2，y=5，则中序遍历中访问到结点6时返回True，仅仅访问图中带阴影的结点。
对应的算法如下：
def solve(b,x,y):
if b==None:#空树返回False
return False
if solve(b.lchild,x,y): #处理左子树
return True
if x<=b.key<=y: #当前结点满足条件，输出其关键字
print(b.key,end=' ')
if b.key>y: #一旦找到大于y的结点，返回True
return True
return solve(b.rchild,x,y) #处理右子树
假设有k个关键字互为同义词，若用线性探测法把这k个关键字存入哈希表中，至少要进行 ( )次探测。
A.k-1
B.k
C.k+1
D.k(k+1)/2
正确答案D
最少探测的情况是，第一个同义词放在哈希表ha[d]位置，探测1次，第2个同义词放在哈希表ha[d+1]位置，探测2次，以此类推，第k个同义词放在哈希表ha[d+k-1]位置，探测k次，总的探测次数=1+2+…+k=k(k+1)/2。答案为D。
设整数序列D=（1，12，5，8，3，10，7，13，9），试完成下列各题：
（1）依次取D中各整数为关键字，构造一棵二叉排序树bt。
（2）如何依据此二叉树bt得到D的一个有序序列。
（3）画出在二叉树bt中删除12后的树结构。
答：（1）构造的二叉排序树bt如图A.27(a)所示。
（2）D的有序序列为bt的中序遍历次序，即1、3、5、7、8、9、10、12、13。
（3）为了删除结点12，找到其左子树中的最大结点10（其双亲结点为8），将该结点删除并用10代替12，删除后的结果如图A.27(b)所示。
当采用分块查找时，数据的组织方式为 ( ) 。
A.数据分成若干块，每块内数据有序
B.数据分成若干块，每块内数据不必有序，但块间必须有序，每块内最大（或最小）的关键字组成索引块
C.数据分成若干块，每块内数据有序，每块内最大（或最小）的关键字组成索引块
D.数据分成若干块，每块中的数据个数必须相同
正确答案B
分块查找的数据组织方式为：数据表+索引表，数据表分块，块间有序，块内无序。答案为B。
在任意一棵非空二叉排序树T1中，删除某结点v之后形成二叉排序树T2，再将v 插入T2形成二叉排序树T3。下列关于T1与T3的叙述中，正确的是 ( ) 。
I. 若v是T1的叶子结点，则T1与T3不同
II. 若v是T1的叶子结点，则T1与T3相同
III. 若v不是T1的叶子结点，则T1与T3不同
IV. 若v不是T1的叶子结点，则T1与T3相同
A.仅I、III
B.仅I、IV
C.仅II、III
D.仅II、IV
正确答案C
在一棵二叉排序树中删除一个结点后再将此结点插入到二叉排序树中，如果删除的结点是叶子结点，那么在插入结点后，后来的二叉排序树与删除结点之前相同。如果删除的结点不是叶子结点，那么再插入这个结点后，后来的二叉树可能发生变化，不再相同。答案为C。
采用递归方式对顺序表进行快速排序，下列关于递归次数的叙述中，正确的是 ( ) 。
A.递归次数与初始数据的排列次序无关
B.每次划分后，先处理较长的分区可以减少递归次数
C.每次划分后，先处理较短的分区可以减少递归次数
D.递归次数与每次划分后得到的分区处理顺序无关
正确答案D
快速排序将一个无序序列划分为两个无序子序列，这两个无序子序列的排序是独立的，先排序哪一个都可以。答案为D。
简述堆和二叉排序树的区别。
答：以小根堆为例，堆的特点是双亲结点的关键字必然小于等于孩子结点的关键字，而两个孩子结点的关键字没有次序规定。而二叉排序树中，每个双亲结点的关键字均大于左子树结点的关键字，每个双亲结点的关键字均小于右子树结点的关键字，也就是说，每个双亲结点的左、右孩子的关键字有次序关系。
有一个关键字集合{53，30，37，12，45，24，96}，从空树开始逐个插入关键字来创建一棵二叉排序树，若希望高度最小，则应该选择哪个序列插入 （ ） 。
A.45，24，53，12，37，96，30
B.37，24，12，30，53，45，96
C.12，24，30，37，45，53，96
D.30，24，12，37，45，96，53
正确答案B
4个选项对应的关键字序列构造的4棵二叉排序树如图A.32所示，T2是一棵高度为3的满二叉树，高度最小。答案为B。
8
关于哈希表查找的说法中正确的是（ ） 。
A.采用拉链法解决冲突时，成功查找到任何一个关键字的元素的时间都是相同的
B.采用拉链法解决冲突时，若规定插入总是在链首，则插入任何一个关键字的元素的时间总是相同的
C.采用拉链法解决冲突时容易引起堆积现象
D.以上都不对
正确答案B
若哈希地址为0～m-1，序号为i（0≤i≤m-1）的单链表中的结点个数可能有多个，这样查找到任何一个关键字的结点的时间可能不同。拉链法解决冲突时不会出现堆积现象。答案为B。
设有一组关键字（32，15，2，7，14，13），其哈希函数是H(key)=key % 7。采用开放地址法的线性探测法解决冲突，试在0～8的哈希表中对该关键字序列构造哈希表，并求成功和不成功情况下的平均查找长度。
0=H(key)
dj+1=(dj+1) % m j=0，1，…
计算各关键字存储地址的过程如下：
H(32)=32 % 7=4
H(15)=15 % 7=1
H(2)=2 % 7=2
H(7)=7 % 7=0
H(14)=14 % 7=0冲突
d0=0，d1=(d0+1)%9=1仍冲突
d1=1，d2=(d1+1)%9=2仍冲突
d2=0，d3=(d1+1)%9=3
H(13)=13 % 7=6
正确答案
答：依题意，n=6，m=9，线性探测法计算下一地址计算公式为：
d0=H(key)
dj+1=(dj+1) % m j=0，1，…
计算各关键字存储地址的过程如下：
H(32)=32 % 7=4
H(15)=15 % 7=1
H(2)=2 % 7=2
H(7)=7 % 7=0
H(14)=14 % 7=0冲突
d0=0，d1=(d0+1)%9=1仍冲突
d1=1，d2=(d1+1)%9=2仍冲突
d2=0，d3=(d1+1)%9=3
H(13)=13 % 7=6
因此，构建的哈希表如表A.5所示。
表中探测次数即为相应关键字成功查找时所需比较关键字的次数，因此：
ASL成功=(1+1+1+4+1+1)/6=5
查找不成功表示在表中未找到指定关键字的元素。对于不属于（32，15，2，7，14，13）中的任意关键字x，H(x)的取值为0～6（共7种可能的取值），采用线性探测法解决冲突时的比较次数如表A.6所示，得到：
ASL不成功=(6+5+4+3+2+1+2)/7=23/7=29
首页
作业系统
考试系统
师资培训
课程题库
考研
问答
使用手册
第7章作业
总分：10
得分：9
图的遍历是指（ ） 。
A.访问图的所有顶点
B.以某种次序访问图的所有顶点
C.从一个顶点出发访问图中所有顶点且每个顶点只能访问一次
D.从一个顶点出发访问图中所有顶点但每个顶点可以访问多次
正确答案C
图的遍历是从给定的初始点出发访问每个顶点且每个顶点仅访问一次。
以下叙述中错误的是（ ）。
A.图的遍历是从给定的初始点出发访问每个顶点且每个顶点仅访问一次
B.图的深度优先遍历适合无向图
C.图的深度优先遍历不适合有向图
D.图的深度优先遍历是一个递归过程
正确答案C
图的深度优先遍历算法既适合无向图也适合有向图的遍历。
以下（ ）方法可用于求无向图的连通分量。
A.遍历
B.拓扑排序
C.Dijkstra算法
D.Prim算法
正确答案A
从图中某个顶点出发进行遍历，可将与该顶点相连通的所有顶点全部访问，也就找到了该顶点所在的连通分量。
如果从无向图的任一顶点出发进行一次深度优先遍历即可访问所有顶点，则该图一定是（ ）。
A.完全图
B.连通图
C.有回路
D.一棵树
正确答案B
对于无向图，从其中某个顶点出发进行一次深度优先遍历能够访问所有的顶点。
采用邻接表存储的图的深度优先遍历算法类似于二叉树的 （ ）算法。
A.先序遍历
B.中序遍历
C.后序遍历
D.层次遍历
正确答案A
当图变为二叉树时，深度优先遍历过程是访问起点（类似于访问根结点），访问起点的相邻点，再访问起点的相邻点的相邻点（类似于访问左子树），…，回溯回来时再访问起点的下一个相邻点（类似于访问右子树）。
已知一无向图G=（V，E），其中V={a,b,c,d,e } E={(a,b),(a,d),(a,c),(d,c),(b,e)}，现用某一种图遍历方法从顶点a开始遍历图，得到的序列为abecd，则采用的是___遍历方法。
深度优先
该无向图如图1所示，如果从a顶点出发进行广度优先遍历，最后的一个访问顶点一定是e。abecd只能通过深度优先遍历得到。
已知一无向图G=（V，E），其中V={a,b,c,d,e } E={(a,b),(a,d),(a,c),(d,c),(b,e)}，现用某一种图遍历方法从顶点a开始遍历图，得到的序列为adbce，则采用的是___遍历方法。
广度优先
该无向图如图2所示，如果从a顶点出发进行深度优先遍历，访问a、d后只能访问c，不可能访问b。
已知一无向图G=（V，E），其中V={a,b,c,d,e } E={(a,b),(a,d),(a,c),(d,c),(b,e)}，给出一种遍历序列___，从顶点a出发既可以通过深度优先遍历也可以通过广度优先遍历方式得到。
dcbe
正确答案
adcbe
该无向图如图2所示。从a顶点出发进行一次深度优先遍历：访问a，访问a的相邻点d，访问d的相邻点c，回退到a，访问b，最后访问b的相邻点e，得到adcbe的序列。
从a顶点出发进行一次广度优先遍历：访问a，访问a的相邻点d、c、b，最后访问b的相邻点e，得到adcbe的序列。
一个有n个顶点e条边的连通图采用邻接表表示，从某个顶点v出发进行深度优先遍历DFS(G,v)，则最大的递归深度是___。
n
由于图中有n个顶点，每个顶点递归调用一次，所以最大递归深度为n。
一个有n个顶点e条边的连通图采用邻接表表示，从某个顶点v出发进行广度优先遍历BFS(G,v)，则队列中最多的顶点个数是___。
n-1
如果图中某个顶点有n-1个相邻点，这n-1个相邻点都会进队。
图的遍历就是访问图中所有顶点。
正确答案:否
图的遍历是指以某种顺序访问图中所有顶点，且每个顶点仅访问一次。
任何一个图，一旦指定源点，其深度优先遍历序列是唯一的。
正确答案:否
图的深度优先遍历序列不一定是唯一的。
图的深度优先遍历算法仅对无向图适用。
正确答案:否
图的深度优先遍历算法对无向图和有向图都适用。
有向图的遍历不可采用广度优先遍历方法。
正确答案:否
广度优先遍历算法适合于有向图和无向图。
图的深度优先遍历算法和广度优先遍历算法是两种不同的算法，所以任何图的这两种遍历序列是不可能相同的。
正确答案:否
图的两种遍历序列可能相同。
某城市道路中大部分是双向马路，有少部分是单向马路。现构建该城市道路交通网用于道路规划，包括道路查找等。问是设计成有向图还是无向图？是带权图还是不带权图？
因为城市道路中有单向马路，只能用有向边来表示，双向马路可以转换成两条有向边。另外，在道路规划中涉及马路的长度，所以该城市道路交通网应设计成带权有向图。
有一个无向连通图，对于给定的某种邻接表表示，能否通过修改深度优先遍历算法求出所有的深度优先遍历序列？
不能。对于给定的无向连通图邻接表，其表示是不唯一的，不同的邻接表，通过修改深度优先遍历算法只能求出该邻接表下所有的深度优先遍历序列，除非构建所有可能的邻接表，才可能求出所有的深度优先遍历序列。
图的遍历对无向图和有向图都适用吗？
图的遍历对无向图和有向图都适用。但如果无向图不是连通的，或有向图不是强连通的，调用一次遍历算法只能访问一个连通分量或强连通分量中的顶点，这种情况下需要多次调用遍历算法。
图的深度优先遍历类似于树的先根遍历，可归属哪一类算法？
图的深度优先遍历类似于树的先根遍历，都属于回溯算法。由于图的深度优先遍历有可能在访问某个顶点后，沿着某条路径向前搜索又回到这个顶点，所以要设置一个访问标记数组visited记录已访问过的顶点，以避免重复访问，而树的先根遍历没有这种情形出现。
在一个图中，每个顶点的前趋顶点和后继顶点数可以有（ ）。
A.1个
B.2个
C.任意多个
D.0个
正确答案C
图中顶点之间是多对多的相邻关系。
2
在一个无向图中，所有顶点的度之和等于边数的（ ）倍。
A.1/2
B.1
C.2
D.4
正确答案C
在无向图中，一条边计入两个顶点的度数。
一个有n个顶点的无向图最多有（ ）条边。
A.n
B.n(n-1)
C.n(n-1)/2
D.2n
正确答案C
当为完全无向图时边数最多。
在一个具有n个顶点的无向连通图中至少有（ ）条边。
A.n
B.n+l
C.n-1
D.n/2
正确答案C
树图是边数最少的连通图，其边数=n-1。
图中所有顶点的度之和为图中边数的___倍。
2
有n个结点的无向图最少有___条边。
0
有n个结点的无向图最多有___条边。
n(n-1)/2
含有n个顶点的无向图都连通全部顶点至少需要___条边。
n-1
若含有n个顶点e条边无向连通图满足___，则称之为树图。
e=n-1
图是一种结点之间无层次关系的线性结构。
正确答案:否
图是一种非线性结构。
一个图中的路径是指该路径上的边不重复出现。
正确答案:否
一个图中的路径是指该路径上的顶点不重复出现。
在无向图中，如果顶点i到顶点j有路径，而顶点j到顶点k没有路径，则顶点i到顶点k也没有路径。
正确答案:是
顶点i和顶点j属一个连通分量，而顶点k属另一个连通分量，所以顶点i到顶点k没有路径。
在有向图中，如果顶点i到顶点j有路径，而顶点i到顶点k没有路径，则顶点j到顶点k也没有路径。
正确答案:是
如果顶点j到顶点k有路径，则顶点i有一条通过顶点j到达顶点k的路径，与题中条件矛盾。
n个顶点的无向图至多有n(n-1)条边。
正确答案:否
n个顶点的无向图至多有n(n-1)/2条边。
对于一个具有n个顶点的连通无向图，如果它有且只有一个回路，那么该图有几条边？为什么？
该图有n条边。
因为具有n个顶点n-1条边的连通无向图是树图，它没有任何回路，但两个顶点i和j之间有路径，如果加上一条边(i,j)，则形成一个回路，如果再加上一条边，则会形成两个回路。所以这样的图恰好有n条边。
有一个如图1（a）所示的有向图，回答以下问题：
（1）给出该图的所有强连通分量。
（2）给出从顶点0到顶点的所有路径。
（1）该有向图的强连通分量如图1（b）所示，共有4个强连通分量。
（2）顶点0到顶点的所有路径如下：
0→1→4→8
0→3→7→8
0→3→1→4→8
有一个如图2（a）所示的有向图，给出其所有的强连通分量。
图中顶点0、1、2构成一个环，这个环一定是某个强连通分量的一部分，图中顶点3、4构成一个环，这个环也一定是某个强连通分量的一部分，这两个环合在一起后能不能构成一个强连通分量呢？通过判断它们能够构成一个强连通分量。另外，顶点5、6各自构成一个强连通分量。该有向图的强连通分量有3个，如图2（b）所示。
一个图有7个顶点，编号为0～6，其邻接矩阵如下：
回答以下问题：
（1）画出该有向图。
（2）求顶点0的入度和出度。
（3）求顶点2的度。
（1）该有向图如图3所示。
（2）顶点0的入度为0，出度为3。
（3）顶点2的度为5。
图G是一个非连通无向图，共有28条边，则该图至少有多少个顶点？
由于G是一个非连通无向图，在边数固定时，顶点数最少的情况是该图由两个连通子图构成，且其中之一只含一个顶点，另一个为完全图。其中只含一个顶点的子图没有边，另一个完全图的边数为n(n-1)/2，即：n(n-1)/2=28，得：n=8。所以，该图至少有1+8=9个顶点。
一个无向连通图的生成树是含有该连通图的全部顶点的（ ）。
A.极小连通子图
B.极小子图
C.极大连通子图
D.极大子图
正确答案A
n个顶点的连通图的生成树有（ ）个顶点。
A.n-1
B.n
C.n+1
D.不确定
正确答案B
生成树包含图中所有的顶点。
4
若一个具有n个顶点和e条边的无向图是一个森林（n>e），则该森林必有 （ ）棵树。
A.e
B.n
C.n-e
D.1
正确答案C
设该森林有m棵树，结点个数分别为n1、n2、…、nm，则总顶点数n=n1+n2+…+nm，第i棵树的边数=ni-1，总边数=(n1-1)+(n2-1)+…+(nm-1)=n-m=e，所以m=n-e。
如果具有n个顶点的图恰好是一个环，则它有（ ）棵生成树。
A.n-1
B.n
C.n+1
D.2n
正确答案D
如果图恰好是一个环，对于图中每个顶点，都有顺时针和逆时针方向两棵生成树，总计2n棵生成树。
n个顶点的连通图的生成树有（ ） 条边。
A.n
B.n-1
C.n+1
D.不确定
正确答案B
对n个顶点的连通图来说，它的生成树一定有___条边。
n-1
一个连通图的生成树是该图的一个___。
极小连通子图
一个具有n个顶点的无向图是一个环，则它有___棵生成树。
2n
每个顶点顺时针和逆时针方向找遍所有顶点产生两种生成树。
一个带权连通图的最小生成树是该图的___。
所有生成树中权值之和最小的生成树
一个带权连通图的最小生成树___唯一的。
不一定是
连通图的生成树包含了图中所有顶点。
正确答案:是
一个连通图的生成树是唯一的。
正确答案:否
一个连通图的生成树可能有多棵。
对n个顶点的连通图G来说，如果其中的某个子图有n个顶点、n-1条边，则该子图一定是G的生成树。
正确答案:否
这样的子图不一定是连通的。
对于无向图生成树，从同一顶点出发所得到的生成树一定是相同的。
正确答案:否
无向图的生成树可能有多棵，从同一顶点出发所得到的生成树也不一定相同。
对于无向图生成树，其深度优先生成树和广度优先生成树一定不相同。
正确答案:否
不一定，如果一个无向图的生成树唯一，从同一顶点出发构造的深度优先生成树和广度优先生成树也是相同的。
使用普里姆算法构造出如图1所示的图G的一棵最小生成树。
使用Prim算法构造最小生成树的过程如图2所示。
已知带权连通图G=（V,E）的邻接表如图3所示，请画出该图的逻辑结构，并分别以深度优先和广度优先遍历该图，写出遍历中顶点的序列，并画出该图的一棵最小生成树，其中表结点的3个域各为：
<table data-tag='from-word' border='1' ><tr><td>顶点编号
</td><td>边上所带的权
</td><td>指针
</td></tr></table>
该图G的逻辑结构如图4所示。
从顶点1出发的深度优先遍历序列为：0、1、2、3、4。
从顶点1出发的广度优先遍历序列为：0、1、2、3、4。
采用普里姆算法（从顶点0出发）或克鲁斯卡尔算法求得的最小生成树如图5所示。
给出如图6所示的图中从顶点0开始的深度优先生成树，并求出最小生成树。
从顶点0开始的深度优先遍历序列很多，每一序列都生成一棵DFS树，除去重复的，其深度优先生成树及权值之和如下：
(0,1)，(1,2)，(2,4)，(4,5)，(5,3)，权值和为10+3+15+3+10=41
(0,1)，(1,2)，(2,4)，(4,3)，(4,5)，权值和为10+3+15+11+3=42
(0,1)，(1,3)，(3,5)，(5,4)，(4,2)，权值和为10+5+10+3+15=43
(0,1)，(1,3)，(3,4)，(4,2)，(4,5)，权值和为10+5+11+15+3=44
(0,3)，(3,1)，(1,2)，(2,4)，(4,5)，权值和为20+5+3+15+3=45
(0,3)，(3,5)，(5,4)，(4,2)，(2,1)，权值和为20+10+3+15+3=51
(0,3)，(3,4)，(4,5)，(4,2)，(2,1)，权值和为20+11+3+15+3=52
(0,5)，(5,3)，(3,1)，(1,2)，(2,4)，权值和为2+10+5+3+15=35
(0,5)，(5,3)，(3,4)，(4,2)，(2,1)，权值和为2+10+11+15+3=41
(0,5)，(5,4)，(4,2)，(2,1)，(1,3)，权值和为2+3+15+3+5=28
(0,5)，(5,4)，(4,3)，(3,1)，(1,2)，权值和为2+3+11+5+3=24
其最小生成树为(0,5)，(5,4)，(4,3)，(3,1)，(1,2)。
对于如图7所示的带权无向图，给出利用普里姆算法（从顶点0开始构造）和克鲁斯卡尔算法构造出的最小生成树的结果。
利用普里姆算法从顶点0出发构造的最小生成树为：{(0,1),(0,3),(1,2),(2,5),(5,4)}。
利用克鲁斯卡尔算法构造出的最小生成树为：{(0,1),(0,3),(1,2),(5,4),(2,5)}。
已知世界6大城市为：北京（B）、纽约（N）、巴黎（P）、伦敦（L）、东京（T）、墨西哥城（M）。试在由表1给出的交通网中确定最小生成树，并说明所使用的方法及其时间复杂度。
构成的无向图如图8所示。产生的最小生成树如图9所示。使用普里姆算法的时间复杂度为O(n2)，其中n为图中顶点个数。使用克鲁斯卡尔算法的时间复杂度为O(elog2e)，其中e为图的边数。
一个含有n（n>0）个顶点的连通图采用邻接矩阵存储，则该矩阵一定是（ ）。
A.对称矩阵
B.非对称矩阵
C.稀疏矩阵
D.稠密矩阵
正确答案A
连通图是指任意两个顶点之间存在路径的无向图，其邻接矩阵一定是对称矩阵。答案为A。
设连通图有n个顶点e条边（e，n>0），若满足（ ），则图中一定有回路。
A.e≥n
B.e<n
C.e=n-1
D.2e≥n
正确答案A
一个有n个顶点e条边的无向图，若e=n-1时构成一个树图，若e<n-1则是不连通的，若e>n-1则一定存在回路。答案为A。
6
对于AOE网的关键路径，以下叙述（ ）是正确的。
A.任何一个关键活动提前完成，则整个工程一定会提前完成
B.完成整个工程的最短时间是从源点到汇点的最短路径长度
C.一个AOE网的关键路径一定是唯一的
D.任何一个活动持续时间的改变可能影响关键路径的改变
正确答案D
AOE网中的关键路径是从源点到汇点的最长路径，其长度为完成整个工程的最短时间。一个AOE网可能存在多条关键路径，若提前完成所有关键路径都包含的关键活动则整个工程一定会提前完成，但改变任何一个活动的持续时间可能影响关键路径的改变（因为此时关键路径可能发生改变）。答案为D。
对于图A.1所示的带权有向图采用Dijkstra算法求从顶点0到其他顶点的最短路径，要求给出求解过程，包括每一步的S集合、dist和path数组元素。
该图对应的邻接矩阵如下：
在求最短路径时，S（存放已经求出最短路径的顶点集），dist[]（存放最短路径长度）和path[]（存放最短路径）的变化过程如图A.3所示。最后得到的结果如下：
① 顶点0到顶点1的最短距离为5，最短路径为：0、4、1
② 顶点0到顶点2的最短距离为6，最短路径为：0、4、1、2
③ 顶点0到顶点3的最短距离为7，最短路径为：0、4、1、3
④ 顶点0到顶点4的最短距离为2，最短路径为：0、4。
下列关于图的叙述中，正确的是( )。
Ⅰ.回路是路径
Ⅱ.存储稀疏图，用邻接矩阵比邻接表更省空间
Ⅲ.若有向图中存在拓扑序列，则该图不存在回路
A.仅Ⅱ
B.仅Ⅰ、Ⅱ
C.仅Ⅲ
D.仅Ⅰ、Ⅲ
正确答案C
只有回路才是起始顶点和终止顶点相同的路径。存储稀疏图，用邻接表比邻接矩阵更省空间。若有向图中存在拓扑序列（包含全部顶点），则该图不存在回路。答案为C。
以下关于有向图的说法中，正确的是( )。
A.强连通图中任何顶点到其他所有顶点都有边
B.完全有向图一定是强连通图
C.有向图中任一顶点的入度等于出度
D.有向图边集的子集和顶点集的子集可构成原有向图的子图
正确答案B
强连通图是任何顶点到其他所有顶点都有路径而不一定有边。完全有向图中任意两个顶点之间都存在一条边，则一定是强连通图。有向图中任一顶点的入度不一定等于出度。一个有向图边集的子集和顶点集的子集不一定构成一个图。答案为B。
如果从无向图的某个顶点出发进行一次广度优先遍历即可访问所有顶点，则该图一定是( )。
A.完全图
B.连通图
C.有回路
D.一棵树
正确答案B
从无向图的某个顶点v出发进行一次广度优先遍历即可访问所有顶点，则说明v到该图的每个顶点都有路径，这样的无向图一定是连通图。答案为B。
用Dijkstra算法求一个带权有向图G中从顶点0出发的最短路径，在算法执行的某时刻，S={0，2，3，4}，下一步选取的目标顶点可能是( )。
A.顶点2
B.顶点3
C.顶点4
D.顶点7
正确答案D
Dijkstra算法执行中，一旦某个顶点v添加到S中，后面不再调整源点到v的最短路径。答案为D。
若用邻接矩阵存储有向图，矩阵中主对角线以下的元素均为零，则关于该图拓扑序列的结论是( )。
A.存在，且唯一
B.存在、且不唯一
C.存在，可能不唯一
D.无法确定存在
正确答案C
这样的有向图中只有顶点i到顶点j（i<j）可能有边，而顶点j到顶点i一定没有边，也就是说这样的有向图中一定没有回路，所以可以产生拓扑序列，但拓扑序列不一定唯一。答案为C。
对于如图A.5所示的带权连通图，给出利用普里姆算法（从顶点0开始构造）和克鲁斯卡尔算法构造出的最小生成树的结果（注意：按算法执行的顺序给出最小生成树的所有边，每条边用(i，j)表示）。
（2）若一个带权连通图有多棵最小生成树，其中恰好有两条最小边，那么这两条最小边一定出现在所有的最小生成树吗？
（3）若一个带权连通图有多棵最小生成树，其中恰好有三条最小边，那么这三条最小边一定都出现在所有的最小生成树吗？
（1）利用普里姆算法从顶点0出发构造最小生成树时，依次选择的边是(0，1)，(0，3)，(1，2)，(2，5)，(5，4)，构造的最终最小生成树为{(0，1)，(0，3)，(1，2)，(2，5)，(5，4)}。
利用克鲁斯卡尔算法构造最小生成树时，依次选择的边是(0，1)，(0，3)，(1，2)，(5，4)，(2，5)，构造的最终最小生成树为{(0，1)，(0，3)，(1，2)，(5，4)，(2，5)}。
（2）若一个带权连通图有多棵最小生成树，其中恰好有两条最小边，那么这两条最小边一定出现在所有的最小生成树中。
因为按照克鲁斯卡尔算法构造最小生成树的过程，首先选择这两条最小边一定不会出现回路。
（3）若一个带权连通图有多棵最小生成树，其中恰好有三条最小边，那么这三条最小边不一定都出现在所有的最小生成树中。
因为按照克鲁斯卡尔算法构造最小生成树的过程，首先选择其中两条最小边一定不会出现回路，但选择第三条最小边时可能出现回路。例如一个带权连通图中n=5，包含的3条最小边是(0,1):1，(1,2):1，(0,2):1，当选择前面两条最小边后再选择第3条最小边时出现了回路，这3条最小边并不能出现在任何最小生成树中。
对于不带权无向图的邻接矩阵来说，( )_。
A.第i行上、第i列上非零元素总数等于顶点i的度数
B.矩阵中的非零元素个数等于图中的边数
C.第i行上的非零元素个数和第i列的非零元素个数一定相等
D.邻接矩阵中非全零行的行数等于图中的顶点数
正确答案C
无向图的邻接矩阵是一个对称矩阵。答案为C。
有一个顶点编号为0～4的带权有向图G，现用Floyd算法求任意两个顶点之间的最短路径，在算法执行的某时刻，已考虑了0～2的顶点，现考虑顶点3，则以下叙述中正确的是( )。
A.只可能修改从顶点0～2到顶点3的最短路径
B.只可能修改从顶点3到顶点0～2的最短路径
C.只可能修改从顶点0～2到顶点4的最短路径
D.其他所有两个顶点之间的路径都可能被修改
正确答案D
在Floyd算法中，当初始化A和path数组后，迭代过程如下：
for k in range(g.n):#求Ak[i][j]
for i in range(g.n):
for j in range(g.n):
if A[i][j]>A[i][k]+A[k][j]:
A[i][j]=A[i][k]+A[k][j]
path[i][j]=path[k][j] #修改最短路径
理论上除了i=k（由于A[k][k]=0，A[k][j]>A[k][k]+A[k][j]不会成立）或者j=k（A[i][k]>A[i][k]+A[k][k]不会成立）外，其他A[i][j]都可能修改。答案为D。
7
若一个有向图中的顶点不能排成一个拓扑序列，则可断定该有向图 ( ) 。
A.是个有根有向图
B.是个强连通图
C.含有多个入度为0的顶点
D.含有顶点数目大于1的强连通分量
正确答案D
该图中存在回路，该回路构成一个强连通分量的一部分或全部。答案为D。
对于一个带权连通图G，可以采用Prim算法构造出从某个顶点v出发的最小生成树，问该最小生成树一定包含从顶点v到其他所有顶点的最短路径吗？如果回答是，请予以证明；如果回答不是，请给出反例。
答：不是。
反例是，对于如图A.13所示的带权连通图G，从顶点0出发构造的最小生成树如图A.14所示，而从顶点0到顶点的2的最短路径为02（路径长度为8），并不是最小生成树中的012（该路径长度为10）。
以下叙述中错误的是 （ ）。
A.图的遍历是从给定的初始点出发访问每个顶点且每个顶点仅访问一次
B.图的深度优先遍历适合无向图
C.图的深度优先遍历不适合有向图
D.图的深度优先遍历是一个递归过程
正确答案C
图的深度优先遍历适合无向图和有向图。答案为C。
对于有n个顶点的带权连通图，它的最小生成树是指图中任意一个 （ ） 。
A.由n-1条权值最小的边构成的子图
B.由n-l条权值之和最小的边构成的子图
C.由n个顶点构成的极大连通子图
D.由n个顶点构成的极小连通子图，且边的权值之和最小
正确答案D
最小生成树是图中所有顶点构成的极小连通子图，且边的权值之和最小。答案为D。
以下关于图拓扑排序的叙述中正确的是（ ） 。
Ⅰ.任何无环的有向图，其顶点都可以排在一个拓扑序列中。
Ⅱ.若n个顶点的有向图有唯一的拓扑序列，则其边数必为n-1。
Ⅲ.在一个有向图的拓扑序列中，若顶点a在顶点b之前，则图中必有一条边<a，b>
A.仅Ⅰ
B.仅Ⅰ、Ⅲ
C.仅Ⅱ、Ⅲ
D.Ⅰ、Ⅱ和Ⅲ
正确答案A
在一个有向图的拓扑序列中，若顶点a在顶点b之前，图中不一定有边<a，b>。答案为A。
用Dijkstra算法求一个图中单源最短路径时，图中边上的权值可以为正数，也可以为负数。该叙述正确吗？如果你认为正确，请证明；如果你认为不正确，请给出一个反例。
答：不正确。
因为Dijkstra算法是一种贪心算法，一旦求出源点v到某个顶点u的最短路径后，都是假设后面的路径更长，以后不再调整到顶点u的最短路径。若出现权值为负的边，就有可能在后面出现到顶点u的更短路径，而Dijkstra算法中不会考虑这样的路径。
如图A.16所示，求以顶点0为源点的最短路径，先选取顶点1，表示从顶点0到顶点1的最短路径长度为2，以后不再改变，然后选取顶点2，因为<2，1>的权值为负，需要修改0→1的最短路径为0→2→1，而Dijkstra算法没有这种回溯修改路径的能力，所以要求所有边上的权值必须大于0。
下面 （ ） 算法适合用于构造一个稠密图的最小生成树。
A.Dijkstra算法
B.Prim算法
C.Floyd算法
D.Kruskal算法
正确答案B
Prim算法和Kruskal算法用于构造一个带权连通图（顶点个数为n，边数为e）的最小生成树，前者的时间复杂度为O(n2)，后者的时间复杂度为O(elog2e)。答案为B。
（ ） 方法可以判断一个有向图存在回路。
A.求最小生成树
B.拓扑排序
C.求关键路径
D.求最短路径
正确答案B
可以采用深度优先遍历和拓扑排序来判断一个有向图存在回路，若一个有向图能够成功进行拓扑排序，即拓扑排序时产生所有顶点的拓扑序列，则该有向图中一定没有回路。答案为B。
已知一个不带权图G的邻接表如图A.18所示，针对该邻接表从顶点0出发进行深度优先遍历的结果是_（ ）__。
A.0，1，2，3，4
B.0，1，2，4，3
C.0，1，3，4，2
D.0，1，4，2，3
正确答案A
直接从顶点0出发进行深度优先遍历，得到的DFS序列为0，1，2，3，4。答案为A。
对于图A.19所示的带权有向图，若采用Dijkstra算法求从顶点a到其他顶点的最短路径和长度，第一条最短路径为：a→c，路径长度2，则求得的剩余最短路径依次是什么？（请按Dijkstra算法执行时产生最短路径的顺序，给出各最短路径及其长度）。
答：按Dijkstra算法执行时产生的其他最短路径如下：
第2条：a→c→f，长度为6
第3条：a→c→e，长度为10
第4条：a→c→f→d，长度为11
第5条：a→c→f→d→g，长度为14
第6条：a→b，长度为15
8
一个有向无环图G的拓扑序列为…，vi，…，vj，…，则不可能出现的情形是( ) 。
A.G中有边<vi，vj>
B.G中有一条从vi到vj的路径
C.G中没有边<vi，vj>
D.G中有一条从vj到vi的路径
正确答案D
拓扑序列为…，vi，…，vj，…，则vi到vj有边或者路径，如果存在从vj到vi的路径，则存在回路。答案为D。
假设在7个城市之间建造天然气输送网，7个城市分别用序号1～7来表示，已知两个城市之间的输气管道的费用如表A.4所示。
要求：
（1）在总费用最小的情况下设计出连通7个城市的天然气输送网。
（2）计算建造该天然气输送网的总费用是多少？
答：（1）建立的带权无向图如图A.25所示。要求在总费用最小的情况下设计出连通7个城市的天然气输送网，实际上就是构造该图的最小生成树，可以采用Prim算法和Kruskal算法。这里采用Prim算法从顶点1出发构造最小生成树的过程如图A.26所示，最小生成树中的边为(1，2)，(2，7)，(3，7)，(3，4)，(4，5)，(1，6)。
（2）累加最小生成树中所有边的费用得到总费用=6+4+9+5+10+12=46，所以总的费用为4600万元。
假设一个无向图是非连通的，采用邻接表作为存储结构，试设计一个算法，输出图中各连通分量的顶点序列。
解：采用某个遍历方法遍历非连通图，并输出各连通分量顶点序列。采用深度优先遍历的算法如下：
visited=[0]*MAXV
def DFSA(G):#非连通图的DFS
for i in range(G.n):
if visited[i]==0: #若顶点i没有访问过
print("一个连通分量顶点序列:",end=' ')
DFS(G,i)#从顶点i出发深度优先遍历
print()
def DFS(G,v): #邻接表G中从顶点v出发的深度优先遍历
print(v,end=' ') #访问顶点v
visited[v]=1#置已访问标记
for j in range(len(G.adjlist[v])): #处理顶点v的所有出边顶点j
w=G.adjlist[v][j].adjvex #取顶点v的一个相邻点w
if visited[w]==0:
DFS(G,w)#若w顶点未访问,递归访问它
说明：采用广度优先遍历亦可。
一个表示工程的AOE网中的关键路径 ( ) 。
A.必须是唯一的
B.可以有多条
C.可以没有
D.以上都不对
正确答案B
AOE网中的关键路径是源点到汇点的最长路径（至少有一条），可以有多条。答案为B。
用Prim算法求一个连通的带权图的最小生成树，在算法执行的某时刻，已选取的顶点集合U＝{1，2，3}，边的集合TE＝{(1，2)，(2，3)}，要选取下一条权值最小的边，不可能从 ( ) 组中选取。
A.{(1，4)，(3，4)，(3，5)，(2，5)}
B.{(1，5)，(2，4)，(3，5)}
C.{(1，2)，(2，3)，(3，1)}
D.{(1，4)，(3，5)，(2，5)，(3，4)}
正确答案C
采用Prim算法求最小生成树时，U={1，2，3}，V-U={4，5，…}，候选边只能是这两个顶点集之间的边。答案为C。
对于如图A.29所示的带权有向图，采用狄克斯特拉算法求出从顶点0到其他各顶点的最短路径及其长度，要求按求出最短路径的先后顺序给出结果。
答：采用狄克斯特拉算法时，按求出最短路径的先后顺序给出结果如下：
从0到1的最短路径长度为1，最短路径为0→1。
从0到3的最短路径长度为2，最短路径为0→3。
从0到2的最短路径长度为4，最短路径为0→1→2。
从0到4的最短路径长度为8，最短路径为0→1→4。
从0到5的最短路径长度为10，最短路径为0→3→5。
以下关于有向图的说法中，正确的是（ ） 。
A.强连通图是任何顶点到其他所有顶点都有边
B.完全有向图一定是强连通图
C.有向图中任一顶点的入度等于出度
D.有向图边集的子集和顶点集的子集可构成原有向图的子图
正确答案B
完全有向图中任意两个顶点之间都有一条边，一定是强连通图。答案为B。
用Dijkstra算法求一个带权有向图G中从顶点0出发的最短路径，在算法执行的某时刻，S={0，2，3，4}，下一步选取的目标顶点可能是 （ ）。
A.顶点2
B.顶点3
C.顶点4
D.顶点7
正确答案D
Dijkstra算法求出源点到某个顶点的最短路径并添加到S中后，后面不再以它作为目标顶点。答案为D。
有n个人，编号为1～n，给定m对（a，b）表示a和b是朋友，朋友的朋友也是朋友。编写一个程序求朋友圈的个数以及各个朋友圈的人数，每个朋友圈至少有两个人，朋友圈人数按递增顺序输出，其中n和m最大值不超过100。输入格式示例：
11 8#n=11，m=8
1 2#表示1和2是朋友
2 3
1 3
4 5
7 10
7 9
9 10
8 9
输出结果：
共有3个朋友圈
各朋友圈人数: [2, 3, 4]
解：采用列表G作为邻接表，G[i]（1≤i≤n）表示i的所有朋友列表，例如示例对应的G如下：
[None, [2, 3], [1, 3], [2, 1], [5], [4], None, [10, 9], [9], [7, 10, 8], [7, 9], None]
采用深度优先遍历求解，对应的程序如下：
def solve():#求解算法
global n,visited
ans=[]
for i in range(1,n+1):
if visited[i]==0:
cnt=DFS(G,i)
if cnt>1: ans.append(cnt)#人数多于1的计一个朋友圈
ans.sort()
return ans
def DFS(G,v): #邻接表G中从顶点v出发的深度优先遍历
global visited
cnt=1 #访问顶点v
visited[v]=1 #置已访问标记
if G[v]==None: return cnt#v没有朋友时返回
for j in range(len(G[v])): #处理顶点v的所有出边顶点j
w=G[v][j] #取顶点v的一个相邻点w
if visited[w]==0:
cnt+=DFS(G,w)#若w顶点未访问,递归访问它
return cnt
#主程序
n,m=map(int,input().split())#转换为整数序列
G=[None]*(n+1)
for i in range(m):
a,b=map(int,input().split())
if G[a]==None: G[a]=[]
if G[b]==None: G[b]=[]
G[a].append(b)
G[b].append(a)
visited=[0]*(n+1)
ans=solve()
print("共有%d个朋友圈" %(len(ans)))
print("各朋友圈人数:",ans)
说明：本题也可以采用广度优先遍历或者并查集求解。
首页
作业系统
考试系统
师资培训
课程题库
考研
问答
使用手册
第6章作业
总分：10
得分：9
以下关于二叉树遍历的说法中，正确的是（ ）。
A.二叉树遍历就是访问二叉树中所有的结点
B.二叉树遍历就是访问二叉树中部分结点
C.二叉树遍历就是按照某种规律访问二叉树中所有的结点，且每个结点仅访问一次
D.二叉树遍历就是随机访问二叉树中所有的结点，且每个结点仅访问一次
正确答案C
以下关于二叉树遍历的说法中，错误的是（ ）。
A.一棵二叉树中，若每个结点最多只有左孩子，没有右孩子，则先序和后序序列相同
B.一棵二叉树中，若每个结点最多只有左孩子，没有右孩子，则中序和后序序列相同
C.一棵二叉树中，若每个结点最多只有左孩子，没有右孩子，则先序和层次序列相同
D.一棵二叉树中，若每个结点最多只有右孩子，没有左孩子，则先序和中序序列相同
正确答案A
在二叉树中，先序序列为NLR，后序序列为LRN，若NLR=LRN，则需L和R均为空，所以选项A错误。
以下关于二叉树遍历的说法中，正确的是（ ）。
A.若某结点是二叉树中某个子树的中序序列的最后一个结点，则它一定是该子树先序序列的最后一个结点
B.若某结点是二叉树中某个子树的先序序列的最后一个结点，则它一定是该子树中序序列的最后一个结点
C.若一个叶子结点是二叉树中某个子树的中序序列的最后一个结点，则它一定是该子树先序序列的最后一个结点
D.若一个叶子结点是二叉树中某个子树的先序序列的最后一个结点，则它一定是该子树中序序列的最后一个结点
正确答案C
若一个叶子结点a是二叉树中某个子树T的中序序列的最后一个结点，它一定是该子树根结点的最右下结点，且它是叶子结点，则一定是该子树的先序序列的最后一个结点。
二叉树若用顺序存储结构表示，则下列4种运算中的 （ ）最容易实现。
A.先序遍历二叉树
B.中序遍历二叉树
C.层次遍历二叉树
D.根据结点的值查找其存储位置
正确答案C
在二叉树的顺序存储结构中，层次遍历只须从头到尾遍历一遍即可。
给定二叉树如图1所示。设N代表二叉树的根，L代表根结点的左子树，R代表根结点的右子树。若遍历后的结点序列为3,1,7,5,6,2,4，则其遍历方式是（ ）。
A.LRN
B.RNL
C.RLN
D.RNL
正确答案D
遍历后的结果是先右子树，再根结点，最后为左子树，即为RNL。本题答案为D。本题的其他3种遍历序列如下：
LRN（先左子树，再右子树，最后访问根结点）：4,6,7,5,2,3,1。
NRL（先访问根结点，再右子树，最后左子树）：1,3,2,5,7,6,4。
RLN（先右子树，再访问左子树，最后根结点）：3,7,6,5,4,2,1。
由二叉树的先序遍历序列和中序遍历序列，___唯一确定该二叉树。
能够
由二叉树的后序遍历序列和中序遍历序列，___唯一确定该二叉树。
能够
由二叉树的层次遍历序列和中序遍历序列，___唯一确定该二叉树。
能够
由二叉树的先序遍历序列和后序遍历序列，___唯一确定该二叉树。
不能
由二叉树某种遍历方式产生的结果是一个线性序列。
正确答案:是
非空二叉树的先序序列的最后一个结点一定是叶子结点。
正确答案:是
先序遍历过程是：根、左、右，如果一个结点是其最后一个结点，该序列后面一定没有结点了，则它一定没有左、右子树，是叶子结点。
非空二叉树的后序序列的最后一个结点一定是叶子结点。
正确答案:否
非空二叉树的后序序列的最后一个结点一定是根结点。
非空二叉树的中序序列的最后一个结点一定是叶子结点。
正确答案:否
中序序列的最后一个结点是根结点的最右下结点，不一定是叶子结点。
非空二叉树的中序序列的第一个结点一定是叶子结点。
正确答案:否
中序序列的最后一个结点是根结点的最左下结点，不一定是叶子结点。
对于以a为根结点的一棵二叉树，指出其先序遍历访问的第一个结点和最后一个结点各是什么？
先序遍历访问的第一个结点就是根结点a。
先序遍历按照根→左→右的次序遍历。对于任一个结点来说，如果有右孩子，则最后访问到该右孩子，如果没有右孩子只有左孩子，则最后访问到该左孩子，当且仅当它没有孩子时，才最后访问到该结点。由此，找先序序列最后一个访问结点的过程是：从根结点出发，不断走向其右孩子，当不再有右孩子时，若有左孩子，转向其左孩子，然后再不断走向其右孩子，依次类推，直到走到一个叶子结点，它就是先序序列最后一个访问结点。
（同答案）
对于以a为根结点的一棵二叉树，指出其中序遍历访问的第一个结点和最后一个结点各是什么？
中序遍历访问的第一个结点就是根结点a的最左下结点。
中序遍历访问的最后一个结点就是根结点a的最右下结点。
（同答案）
对于以a为根结点的一棵二叉树，指出其后序遍历访问的第一个结点和最后一个结点各是什么？
后序遍历按照左→右→根的次序遍历。对于任一个结点来说，如果有左孩子，最先遍历左子树，如果有右孩子，再遍历右子树，最后访问根结点，由此，找后序序列第一个访问结点的过程是：从根结点出发，不断走向其左孩子，当不再有左孩子时，若有右孩子，转向其右孩子，然后再不断走向其左孩子，依次类推，直到走到一个叶子结点，它就是后序序列第一个访问结点。
后序遍历访问的最后一个结点就是根结点a。
（同答案）
对于一棵非空二叉树，为什么只知道其先序序列和后序序列，还不能唯一确定该二叉树的形态？
因为二叉树的先序序列和后序序列都只确定了根结点的信息，而不能确定左、右子树的信息（左、右子树的结点个数），所以不能唯一确定该二叉树的形态。
（同答案）
若某非空二叉树的先序序列和后序序列正好相同，则该二叉树的形态是什么？
二叉树的先序序列是NLR，后序序列是LRN。要使NLR=LRN成立，则L和R均为空，所以满足条件的二叉树只有一个根结点。
（同答案）
以下关于二叉树的说法中正确的是（ ）。
A.二叉树中每个结点的度均为2
B.二叉树中至少有一个结点的度为2
C.二叉树中每个结点的度可以小于2
D.二叉树中至少有一个结点
正确答案C
二叉树可以为空，非空二叉树中每个结点的度可以小于2。
2
以下关于二叉树的说法中正确的是（ ）。
A.二叉树就是度为2的树
B.二叉树中不存在度大于2的结点
C.二叉树就是有序树
D.二叉树中每个结点的度都为2
正确答案B
二叉树可以为空，非空二叉树中每个结点的度都小于等于2。
以下关于二叉树的说法中正确的是（ ） 。
A.二叉树中度为0的结点个数等于度为2的结点个数加1
B.二叉树中结点个数必大于0
C.完全二叉树中任何结点的度为0或2
D.二叉树的度为2
正确答案A
二叉树的性质1，n0=n2+1。
按照二叉树的定义，具有3个结点的二叉树有（ ）种。
A.3
B.4
C.5
D.6
正确答案C
这样的二叉树总数为。
二叉树中所有结点的度之和等于结点数加（ ）。
A.0
B.1
C.-1
D.2
正确答案C
所有结点度之和=n-1。
一棵二叉树中不存在度___的结点。
大于2
一棵二叉树中，某结点即便只有一个孩子结点，也需要指出该孩子结点___。
左孩子还是右孩子结点
正确答案:是左孩子还是右孩子结点
一棵含有50个结点的二叉树，它的最小高度是___。
6
当为完全二叉树时高度最小，此时高度<imgstyle="max-width:70%;"src="https://cdnqingline.net/e1c197caa73a5ab7ad35abdf6dc0abba.png"/>
一棵含有50个结点的二叉树，它的最大高度是___。
50
最大高度的二叉树形态：每层只有一个结点，此时高度h=n=50。
一棵含有65个结点的高度最大的二叉树，第10层有___个结点。
1
最大高度的二叉树形态：每层只有一个结点，所以第10层的结点数=1。
n（n>2）个结点的二叉树中至少有一个度为2的结点。
正确答案:否
每一层只有一个结点的二叉树中就没有度为2的结点。
二叉树就是度为2的有序树。
正确答案:否
二叉树的子树有左、右之分，这不同于树。另外，二叉树的结点个数可以为0，而度为2的树至少有3个结点。
二叉树中每个度为2的结点的两棵子树都是有序的。
正确答案:是
二叉树的子树有左、右之分。
二叉树是一种特殊的树。
正确答案:否
二叉树和树都属于树形结构，但两者互不包含。
二叉树中每个结点至多有两个孩子结点，而一般树没有这种限制，所以二叉树是树的特殊情形。
正确答案:否
二叉树不是树的特殊情形，它们互不包含。
简述一棵度为2的有序树与一棵二叉树的区别。
两者的区别是：一棵度为2的有序树至少有3个结点，而二叉树的结点个数可以为0、一棵度为2的有序树中，度为1的结点无需区别左右，而二叉树中度为1的结点必须区别左右。
（同答案）
给出具有3个结点的不同形态的二叉树。
由n个结点构成的不同形态的二叉树个数为，这里n=3，计算出二叉树的个数为5。这些二叉树如图1所示。
（同答案）
存在这样的一棵二叉树，其结点总数为200，其中只有度为0和度为2的结点？为什么？
不存在。
这里n2=n0-1，n1=0，n=n0+n1+n2=2n0-1，所以n只能是奇数，而题中n=200为偶数，所以不存在这样的二叉树。
（同答案）
有n个结点并且高度为n的不同形态的二叉树个数是多少？
这里是求满足要求的不同形态的二叉树个数。显然，有n个结点并且高度为n的二叉树中每一层只有一个结点，除根结点外，其余每层的一个结点既可以作为其双亲结点的左孩子，也可以作为其双亲结点的右孩子，所以这样的二叉树的个数=1×2×…×2=2n-1，例如，当n=3时有22=4个这样的二叉树。
（同答案）
含有60个叶子结点的二叉树的最小高度是多少？
在该二叉树中，n0=60，n2=n0-1=59，n=n0+n1+n2=119+n1，当n1=0且为完全二叉树时高度最小，此时高度h=log2(n+1)= log2120=7。所以含有60个叶子结点的二叉树的最小高度是7。
（同答案）
设有13个权值，用它们组成一棵哈夫曼树，则该哈夫曼树共有（ ）个结点。
A.13
B.12
C.26
D.25
正确答案D
具有n个叶子结点的哈夫曼树共有2n-1个结点。
4
设有一棵哈夫曼树的结点总数为35，则该哈夫曼树共有（ ） 个叶子结点。
A.18
B.20
C.35
D.30
正确答案A
2n0-1=35，则n0=18。
若一棵度为m的哈夫曼树有n个叶子结点，则非叶子结点的个数是（ ）。
A.n-1
B.n/m-1
C.(n-1)/(m-1)
D.n/(m-1)-1
正确答案C
度为m的哈夫曼树中只有度为m和度为0的结点，结点总数N=n0+nm=n+nm，所有结点度之和=N-1=mnm，所以mnm= n+nm-1，nm=(n-1)/(m-1)，nm为整数，即nm=(n-1)/(m-1)。
哈夫曼树是___。
带权路径长度最小的二叉树
一棵哈夫曼树有32个叶子结点，则该树的总结点个数是___。
63
具有n个叶子结点的哈夫曼树共有2n-1个结点。
哈夫曼树中没有度为1的结点。
正确答案:是
哈夫曼树是带权路径长度最短的二叉树，权值越大的结点离根结点越远。
正确答案:否
哈夫曼树是带权路径长度最短的二叉树，权值越大的结点离根结点越近。
哈夫曼树中结点个数可以偶数也可以是奇数。
正确答案:否
n=2n0-1，所以n只能是奇数。
如果一棵哈夫曼树T有n0个叶子结点，那么，树T有多少个结点，要求给出求解过程。
一棵哈夫曼树中只有度为2和0的结点，没有度为1的结点，由非空二叉树的性质1可知，n0=n2+1，即n2=n0-1，则：总结点数n=n0+n2=2n0-1。
如果一棵哈夫曼树T的高度为h（h>1），问最少可以对几个字符进行编码？最多可以对几个字符进行编码？
哈夫曼树中只有度为2和0的结点，高度为h的哈夫曼树中叶子结点最少的情况况是，第1层只有一个根结点，第2～h层每层有2个结点，共计叶子结点个数为h。所以最少可以对h个字符进行编码
高度为h的哈夫曼树中叶子结点最多的情况况是构成一棵满二叉树，叶子结点集中在第h层，共计叶子结点个数为2h-1。所以最多可以对2h-1个字符进行编码。
树最适合用来表示（ ）。
A.有序数据元素
B.无序数据元素
C.元素之间具有分支层次关系的数据
D.元素之间无联系的数据
正确答案C
树的逻辑结构是层次结构。
5
现有一“遗传”关系，设x是y的父亲，则x可以把他的属性遗传给y。表示该遗传关系最适合的数据结构为（ ）。
A.数组
B.树
C.图
D.线性表
正确答案B
从遗传关系看，一个父亲可以有多个孩子，而一个孩子只能有一个父亲，这最适合用树来表示。
树是结点的有限集合，它 （ ）根结点，记为T。其余的结点分成为m（m≥0）个互不相交的集合T1、T2、…、Tm，每个集合又都是树，此时结点T称为Ti的双亲结点，Ti称为T的子树（1≤i≤m）。一个结点的子树个数为该结点的次数（或度）。
A.有0个或1个
B.有0个或多个
C.有且只有1个
D.有1个或1个以上
正确答案A
树是结点的有限集合，它有0个或1个根结点，记为T。其余的结点分成为m（m≥0）个（ ）的集合T1、T2、…、Tm，每个集合又都是树，此时结点T称为Ti的双亲结点，Ti称为T的子树（1≤i≤m）。一个结点的子树个数为该结点的次数（或度）。
A.互不相交
B.允许相交
C.允许叶结点相交
D.允许树枝结点相交
正确答案A
树是结点的有限集合，它有0个或1个根结点，记为T。其余的结点分成为m（m≥0）个互不相交的集合T1、T2、…、Tm，每个集合又都是树，此时结点T称为Ti的双亲结点，Ti称为T的子树（1≤i≤m）。一个结点的子树个数为该结点的（ ）。
A.权
B.维数
C.次数（或度）
D.序
正确答案C
树中任意结点允许有___孩子结点，除根结点外，其余结点___双亲结点。
有零个或多个、有且仅有一个
在一棵树中，A结点有3个兄弟结点，B结点是A结点的双亲结点，则B结点的度是___。
4
树中元素之间是多对多的关系。
正确答案:否
树中元素之间是一对多的关系。
树中每个结点都有唯一的前趋结点。
正确答案:否
树中除根结点外的每个结点都有唯一的前趋结点。
有一棵树的括号表示为A(B,C(E,F(G)),D)，回答下面的问题：
（1）这棵树的根结点是多少？
（2）这棵树的叶子结点是什么？
（3）结点C的度是多少？
（4）这棵树的度为多少？
（5）这棵树的深度是多少？
（6）结点C的孩子结点是哪些？
（7）结点C的双亲结点是谁？
该树对应的树形表示如图1所示，由相关定义得到本题答案为（1）A （2）B、E、G、D （3）2 （4）3 （5）4 （6）E、F （7）A。
（同答案）
若一棵度为4的树中度为2、3、4的结点个数分别为3、2、2，则该树的叶子结点的个数是多少？
结点总数n=n0+n1+n2+n3+n4，又由于除根结点外，每个结点都对应一个分支，所以总的分支数等于n-1。而度为i（0≤i≤4）的结点的分支数为i，所以有：总分支数=n-1=0×n0+1×n1+2×n2+3×n3+4×n4。综合两式得：n0=n2+2n3+3n4+1=3+2×2+3×2=14。
（同答案）
若一棵度为4的树中度为1、2、3、4的结点个数分别为4、3、2、2，则该树的总结点个数是多少？
结点总数n=n0+n1+n2+n3+n4，又由于除根结点外，每个结点都对应一个分支，所以总的分支数等于n-1。而度为i（0≤i≤4）的结点的分支数为i，所以有：总分支数=n-1=0×n0+1×n1+2×n2+3×n3+4×n4。综合两式得：n0=n2+2n3+3n4+1=3+2×2+3×2=14，则n=n0+n1+n2+n3+n4=14+4+3+2+2=25，所以该树的总结点个数是25。
（同答案）
引入线索二叉树的目的是（ ） 。
A.加快查找结点的前趋或后继结点的速度
B.为了能在二叉树中方便插入和删除
C.为了能方便找到双亲
D.使二叉树的遍历结果唯一
正确答案A
线索是前趋结点或后继结点的指针。
线索二叉树中的线索是指（ ） 。
A.左孩子
B.右孩子
C.指针
D.标识
正确答案C
线索是前趋结点或后继结点的指针。
二叉树线索化实质是将二叉链中___改为存放该结点前趋或后继结点的地址。
空指针域
一棵左右子树均不空的二叉树在先序线索化（不带头结点的线索化），后，其空指针域有___个。
1
将二叉树变为线索二叉树的过程称为线索化。
正确答案:是
简述为什么要建立线索二叉树。
二叉树遍历是常用的运算，按某种次序将二叉树中结点排成一个线性序列，如果每次寻找某个指定结点在某种顺序下的前趋和后继都重新遍历一次二叉树，将十分低效，希望只遍历一次，就把各结点的前趋和后继的信息记在树中，以后再寻找某结点的前趋和后继就很方便了，这就是线索二叉树的目的。
如图1（a）所示的二叉树B是由森林T转换而来的二叉树，那么森林T有（ ）个叶子结点。
A.4
B.5
C.6
D.7
正确答案C
将B还原为森林T，如图1（b）所示，其中有4棵树，C、D、F、G、I和J是叶子结点。
高度为h（h>0）的满二叉树对应的森林由（ ）棵树构成。
A.1
B.log2h
C.h/2
D.h
正确答案D
高度为h的满二叉树中，所有叶子结点的层次均为h，其根结点及其左下结点共有h个，所以还原成森林含有h棵树。
设森林F中有3棵树，第一、第二和第三棵树的结点个数分别为9、8和7，则与森林F对应的二叉树根结点的右子树上的结点个数是（ ）。
A.16
B.15
C.7
D.17
正确答案B
转换的二叉树中，根结点的右子树的结点由第二和第三棵树中的结点构成的，所以为8+7=15。
一棵树中两个兄弟a和b，转换成二叉树后，a、b之间的关系是___。
双亲－右孩子
一棵树中结点a的第一个孩子是结点b，转换成二叉树后，a、b之间的关系是___。
双亲－左孩子
给定一棵树T，可以找到唯一的一棵二叉树B与之对应。
正确答案:是
根据树到二叉树的转换规则可以得到这一结论。
给定一棵树T，将其转换成二叉树B后，它们的结点个数相同。
正确答案:是
根据树到二叉树的转换规则可以得到这一结论。
画出如图1（a）所示的树对应的二叉树。
对应的二叉树如图1（b）所示。
画出如图2（a）所示的二叉树还原成的森林。
该二叉树中根结点的右孩子有4个，所以还原成的森林包含4棵树，如图2（b）所示。
设一棵二叉树B是由森林T转换而来的，若T中有n个非叶子结点，则二叉树B中无右孩子的结点个数为n+1。
证明：树中每个非叶子结点转换成二叉树后都对应一个无右孩子的结点（因为一个非叶子结点至少有一个孩子结点，其最右边的孩子结点转换成二叉树后一定没有右孩子），另外，树的根结点转换成二叉树也没有右孩子，所以二叉树中无右孩子的结点个数为n+1。
一棵高度为h（h≥1）的完全二叉树至少有（ ）个结点。
A.2h-1
B.2h
C.2h+1
D.2h-1+1
正确答案A
这样的完全二叉树中第一层到第h-1层是满的，其结点个数=2h-1-1，第h层至少有一个结点，所以结果是2h-1-1+1=2h-1。答案为A。
一棵含有n个结点的线索二叉树中，其线索个数为 （ ） 。
A.2n
B.n-1
C.n+1
D.n
正确答案C
n个结点的二叉树采用二叉链存储时共有n+1个空指针，改为线索二叉树时这些空指针进改为线索。答案为C。
设一棵哈夫曼树中有1999个结点，该哈夫曼树用于对 （ ）个字符进行编码。
A.999
B.998
C.1000
D.1001
正确答案C
n=1999，哈夫曼树一定是一棵二叉树并且n1=0，则n0=n2+1（二叉树性质1），所以n=2n0-1，n0=(n+1)/2=1000，每个叶子结点对应一个编码的字符。答案为C。
假设非空二叉树采用二叉链存储结构，所有结点值均不相同，根结点为b，结点类型如下：
class BTNode: #二叉链中结点类
def __init__(self,d=None): #构造方法
self.data=d #结点值
self.lchild=None #左孩子指针
self.rchild=None #右孩子指针
设计一个算法判断其中值为x的结点与值为y的结点为兄弟结点，若是兄弟结点返回True，否则返回False。
解：值为x的结点和值为y的结点是兄弟的条件是它们有相同的双亲，可以采用任何一种二叉树遍历方法求解，采用基于先序遍历的算法如下：
def brother(b,x,y):
if b==None:#空树返回假
return False
if b.lchild!=None and b.rchild!=None:#结点b有左右子树
if (b.lchild.data==x and b.rchild.data==y) or (b.lchild.data==y and b.rchild.data==x):
return True#结点b是x、y结点的双亲，返回真
tag=brother(b.lchild,x,y)#在左子树中遍历
if tag: return True
else: return brother(b.rchild,x,y)#在右子树中遍历
设树T的度为4，其中度为1、2、3、4的结点个数分别为4、2、1、1，则T中的叶子结点个数是( )。
A.5
B.6
C.7
D.8
正确答案D
n1=4，n2=2，n3=1，n4=1，度之和=n-1=1×n1+2×n2+3×n3+4×n4=15，即n=16，而n0=n-n1-n2-n3-n4=16-4-2-1-1=8。答案为D。
一棵哈夫曼树用于100个字符的编码，则其中的结点个数是( )。
A.99
B.100
C.101
D.199
正确答案D
n0=100，n1=0，n2=n0-1=99，n=n0+n1+n2=100。答案为D。
设森林F中有4棵树，第1、2、3、4棵树的结点个数分别为a、b、c、d，将森林F转换为一颗二叉树B，则二叉树B中根结点的左子树上的结点个数是( )。
A.a-1
B.a
C.a+b+c
D.b+c+d
正确答案A
由森林F转换为一颗二叉树B，则二叉树B中根结点和其左子树上的所有结点来自第一棵树。答案为A。
假设非空二叉树采用二叉链存储结构，所有结点值均不相同，根结点为b，结点类型如下：
class BTNode: #二叉链中结点类
def __init__(self,d=None): #构造方法
self.data=d #结点值
self.lchild=None #左孩子指针
self.rchild=None #右孩子指针
请完成以下任务：
（1）设计一个算法在二叉树b中查找x结点（指结点值为x的结点），若找到该结点便返回其引用（地址），否则返回空。给出你设计的算法的时间复杂度。（）
（2）设计一个算法利用（1）小题设计的算法输出二叉树b中x结点的所有子孙结点值。（）
解：（1）采用先序遍历算法求解（其他遍历亦可），对应的查找算法如下：
def Findx(b,x): #查找x结点
if b==None:
return None #b为空时返回空
elif b.data==x:
return b #b所指结点值为x时返回b
else:
p=Findx(b.lchild,x) #在左子树中查找
if p!=None:
return p#在左子树中找到p结点，返回p
else:
return Findx(b.rchild,x) #返回在右子树中查找结果
上述算法的时间复杂度为O(n)。
（2）先在二叉树b中查找值为x的结点p，若p不空（找到了），再输出结点p的子树中除了p结点值外的其他结点值。对应的算法如下：
def OutSons(b,x): #输出x的所有子孙结点
p=Findx(b,x)#查找值为x的结点p
if p!=None:
__OutSons(p,x)#输出结点p的子孙
def __OutSons(b,x): #求x的所有子孙结点
if b!=None:
if b.data!=x:#输出除了x外的其他结点值
print(b.data,end=' ')
__OutSons(b.lchild,x)
__OutSons (b.rchild,x)
由权值分别为9、2、7、5的4个叶子结点构造一棵哈夫曼树，该树的带权路径长度为_( )。
A.23
B.44
C.37
D.27
正确答案B
构造的一棵哈夫曼树如图A.9所示，WPL=(2+5)×3+7×2+9×1=44。答案为B。
已知一棵二叉树的先序遍历序列为ABDGHCEIF，它的中序遍历序列是BGDHAEICF，请构造出这棵二叉树，并给出其层次遍历序列。
答：最后构造的二叉树如图A.10所示，其层次遍历序列为ABCDEFGHI。
设非空二叉树采用二叉链存储结构，其结点类型如下：
class BTNode:#二叉链中结点类
def __init__(self,d=None): #构造方法
self.data=d #结点值
self.lchild=None #左孩子指针
self.rchild=None #右孩子指针
设计一个算法判断根结点为b的二叉树是一棵满二叉树。
解：求出二叉树b的结点个数n和高度h，若2h-1=n，说明该二叉树是一棵满二叉树，否则不是满二叉树。对应的算法如下：
def Nodes(b): #求结点个数
if b==None:
return 0
return 1+Nodes(b.lchild)+Nodes(b.rchild)
def Height(b): #求高度
if b==None:
return 0
lh=Height(b.lchild)
rh=Height(b.rchild)
return max(lh,rh)+1
def Full(b):#判断为满二叉树
if b==None:
return True
n=Nodes(b)
h=Height(b)
if 2**h-1==n:
return True
else:
return False
一棵高度为h、结点个数为n的m（m≥3）次树中，其分支数是 （ ） 。
A.nh
B.n+h
C.n-1
D.h-1
正确答案C
任何树中除了根结点外每个结点恰好有一条指向双亲的分支，所以分支数=n-1。答案为C。
根据使用频率为5个字符设计的哈夫曼编码不可能是 （ ） 。
A.000，001，010，011，1
B.0000，0001，001，01，1
C.000，001，01，10，11
D.00，100，101，110，111
正确答案D
按哈夫曼编码恢复为哈夫曼树的方式，4个选项对应的二叉树如图A.15所示，其中T4中存在单分支结点，不可能是哈夫曼树。答案为D。
设二叉树中每个结点存放单个字符（每个结点值是唯一的），采用二叉链存储，其结点类型如下：
class BTNode: #二叉链中结点类
def __init__(self,d=None): #构造方法
self.data=d #结点值
self.lchild=None #左孩子指针
self.rchild=None #右孩子指针
设计一个算法求根结点b的二叉树中结点值为x的结点的兄弟，当b中不存在值为x的结点或者它不存在兄弟时返回空。
解：首先在根结点为b的二叉树中查找x的双亲结点，若存在这样的结点，再查找其兄弟结点。对应的算法如下：
def getparent(b,x): #找x结点的双亲结点
if b==None: return None
if b.lchild!=None and b.lchild.data==x:
return b
if b.rchild!=None and b.rchild.data==x:
return b
p=getparent(b.lchild,x)
if p!=None:
return p
else:
return getparent(b.rchild,x)
def getbrother(b,x): #x结点的兄弟
p=getparent(b,x)
if p==None: return None
if p.lchild!=None and p.lchild.data==x:
return p.rchild
if p.rchild!=None and p.rchild.data==x:
return p.lchild
若一棵有n个结点的树，其中所有分支结点的度均为k，该树中的叶子结点个数是（ ）。
A.n(k-1)/k
B.n-k
C.(n+1)/k
D.(nk-n+1)/k
正确答案D
依题意，m=k，n2=n3=…=nm-1=0，则n=n0+nk，度之和=n-1=knk，nk=(n-1)/k，所以n0=n-nk=n-(n-1)/k=(nk-n+1)/k。答案为D。
已知一棵二叉树中每个结点值为单个字符，其中序和后序序列分别为BFDJGACHKEI和FJGDBKHIECA，请画出该二叉树，并给出该二叉树的先序序列。
答：由中序序列BFDJGACHKEI和后序序列FJGDBKHIECA构造的二叉树如图A.20所示，对应的先序序列为ABDFGJCEHKI。
在一棵非空二叉树的先序序列和后序序列中，各叶子之间的相对次序关系 ( ) 。
A.不一定相同
B.都相同
C.都不相同
D.互为逆序
正确答案B
二叉树的先序遍历和后序遍历中，都是先遍历左子树再遍历右子树，所以各叶子之间的相对次序是相同的。答案为B。
下面关于哈夫曼树的说法，不正确的是( ) 。
A.对应于一组权值构造出的哈夫曼树可能不唯一
B.哈夫曼树具有最小带权路径长度
C.哈夫曼树中没有度为1的结点
D.哈夫曼树中除了度为2的结点外，还有度为1的结点和叶结点
正确答案D
构造哈夫曼树时每次都是两棵子树合并，没有度为1的结点。答案为D。
一棵高度为h的非空平衡二叉树，其每个非叶子结点的平衡因子均为0，则该树共有( )个结点。
A.2h-1-1
B.2h-1
C.2h-1+1
D.2h-1
正确答案D
这样的平衡二叉树恰好为一棵满二叉树。答案为D。
已知一棵度为m的树中有n1个度为1的结点，n2个度为2的结点，…，nm个度为m的结点，问该树中有多少个叶子结点？
答：依题意，设n为总结点个数，n0为叶子结点（即度为0的结点）个数，则有n=n0+n1+n2+…+nm，又有n-1=度之和=n1×1+n2×2+…+nm×m。两式相减得到1=n0-n2-2n3-…-(m-1)nm，则n0=1+n2+2n3+…+(m-1)nm=1+∑mi=2(i−1)ni
。
假设非空二叉树b采用二叉链存储结构存储（结点b为二叉树的根结点），试设计一个算法，输出该二叉树中从根结点出发的一条最长路径（假设其长度不超过100，当有多条最长路径时输出其中任意一条）。
解法1：由于二叉树中最长路径一定是从根结点到某个叶子结点的路径，求出根到每个叶子结点的路径，通过比较长度得出最长路径maxpath。采用递归先序遍历求解对应的算法如下：
MAXN=100
def MaxPath1(b): #采用先序遍历求一条最长路径
global maxpath
maxpath=[]
path=[None]*MAXN
_MaxPath1(b,path,0)
return maxpath
def _MaxPath1(b,path,pathlen):
global maxpath
if b==None: #找到一个叶子结点
if pathlen>len(maxpath): #找到一条更长的路径
maxpath.clear() #更新maxpath
for i in range(pathlen):
maxpath.append(path[i])
else:
path[pathlen]=b.data #将当前结点添加到路径中
pathlen+=1 #路径长度增1
_MaxPath1(b.lchild,path,pathlen)#递归遍历左子树
_MaxPath1(b.rchild,path,pathlen)#递归遍历右子树
解法2：采用层次遍历，最后出队的一个结点p一定是一个叶子结点，并且根结点到该结点一定是路径长度最长的路径。采用层次遍历求解对应的算法如下：
from collections import deque
class QNode:#队列元素类
def __init__(self,p,pre): #构造方法
self.node=p #当前结点引用
self.pre=pre #当前结点的双亲结点
def MaxPath2(b): #采用层次遍历求一条最长路径
maxpath=[] #存放一条最长路径
qu=deque() #定义一个队列qu
qu.append(QNode(b,None)) #根结点(双亲为None)进队
while len(qu)>0: #队不空循环
p=qu.popleft()#出队一个结点p
if p.node.lchild!=None:#有左孩子时将其进队
qu.append(QNode(p.node.lchild,p))#置其双亲为p
if p.node.rchild!=None:#有右孩子时将其进队
qu.append(QNode(p.node.rchild,p))#置其双亲为p
maxpath.append(p.node.data) #最后出队的结点一定是叶子结点
q=p.pre #q为双亲
while q!=None: #找到根结点为止
maxpath.append(q.node.data)
q=q.pre
maxpath.reverse() #逆置maxpath
return maxpath
若一棵3次树中有a个度为1的结点，b个度为2的结点，c个度为3的结点，则该树中有( )个叶子结点。
A.1+2b+3c
B.a+2b+3c
C.2b+3c
D.1+b+2c
正确答案D
n1=a，n2=b，n3=c，n-1=度之和=1×n1+2×n2+3×n3=a+2b+3c，n=a+2b+3c+1，n0=n-n1-n2-n3=n-a-b-c=b+2c+1。答案为D。
1
若已知一棵完全二叉树（所有结点值均不同）的先序、中序或后序遍历序列中的任意一种，能够唯一确定这棵二叉树吗？如果能，请以其中一种遍历序列来说明构造该二叉树的过程。如果不能，并举一个反例予以说明。
答：能够。因为若任一种遍历序列中含有结点个数n，当n已知时就可以确定完全二叉树的形态，再按给出的遍历序列填入结点值即可唯一构造这棵完全二叉树。例如给定一棵完全二叉树的先序序列为abcdef，构造对应的完全二叉树的过程如下：
结点个数n=6，画出该完全二叉树的形态如图A.31(a)所示。
②按先序序列填入结点值得到唯一的完全二叉树如图A.31(b)所示。
首页
作业系统
考试系统
师资培训
课程题库
考研
问答
使用手册
第5章作业
总分：10
得分：8
在计算机内实现递归算法时所需的辅助数据结构是（ ）。
A.栈
B.队列
C.树
D.图
正确答案A
递归调用过程具有先进后出的性质，所以在实现时使用到栈结构。
递归模型为f(1)=1，f(n)=f(n-1)+n（n>1），其中递归出口是（ ）。
A.f(1)=0
B.f(1)=1
C.f(0)=1
D.f(n)=n
正确答案B
递归出口是，当n=1时，f(1)=1，本题答案为B。
递归模型为f(1)=1，f(n)=f(n-1)+n（n>1），其中递归体是（ ） 。
A.f(1)=0
B.f(0)=1
C.f(n)=f(n-1)+n
D.f(n)=n
正确答案C
递归体反映递归方式，本题答案为C。
正确的递归算法应包含（ ）。
A.递归出口
B.递归体
C.递归出口和递归体
D.以上都不包含
正确答案C
正确的递归算法应包含递归出口和递归体两部分，缺一不可，本题答案为C。
函数f(x,y)定义如下：
f(x,y)=f(x-1,y)+f(x,y-1)当x>0且y>0
f(x,y)=x+y否则
则f(2,1)的值是（ ）。
A.1
B.2
C.3
D.4
正确答案D
f(2,1)=f(1,1)+f(2,0)=f(0,1)+f(1,0)+2=1+1+2=4。
函数f(x,y)定义如下：
f(n)=f(n-1)+f(n-2)+1当n>1
f(n)=1否则
则f(5)的值是（ ） 。
A.10
B.15
C.16
D.20
正确答案B
f(5)=f(4)+f(3)+1
f(3)=f(2)+f(1)+1=f(1)+f(0)+1+f(1)+1=5
f(4)=f(3)+f(2)+1=5+f(1)+f(0)+1+1=9。
所以f(5)=9+5+1=15。
某递归算法的执行时间的递推关系如下：
T(n)=1当n=1时
T(n)=T(n/2)+1当n>1时
则该算法的时间复杂度为（ ）。
A.O(1)
B.O(log2n)
C.O(n)
D.O(nlog2n)
正确答案B
不妨设n=2k，k=log2n。
T(n)=T(n/21)+1= T(n/22)+2=…= T(n/2k)+k=T(1)+log2n=O(log2n)。
某递归算法的执行时间的递推关系如下：
T(n)=1当n=1时
T(n)=2T(n/2)+1当n>1时
则该算法的时间复杂度为（ ）。
A.O(1)
B.O(log2n)
C.O(n)
D.O(nlog2n)
正确答案C
不妨设n=2k，k=log2n。
T(n)=21T(n/21)+1=22T(n/22)+1+21=…=2kT(n/2k)+1+21+…+2k-1=2k T(1)+2k-1=2n-1=O(n)。
某递归算法的执行时间的递推关系如下：
T(n)=1当n=1时
T(n)=2T(n/2)+n当n>1时
则该算法的时间复杂度为（ ）。
A.O(1)
B.O(log2n)
C.O(n)
D.O(nlog2n)
正确答案D
不妨设n=2k，k=log2n。
T(n)=21T(n/21)+n=22T(n/22)+2n=…=2kT(n/2k)+kn=2k T(1)+kn=nlog2n+n=O(nlog2n)。
将递归算法转换成非递归算法时，通常要借助的数据结构是（ ）。
A.线性表
B.栈
C.队列
D.树
正确答案B
递归算法转换成非递归算法时通常使用栈，本题答案为B。
1
一个递归定义可以用递归算法求解，也可以用非递归算法求解。但单从执行时间来看，通常递归算法比非递归算法（ ）。
A.较快
B.较慢
C.相同
D.无法比较
正确答案B
通常情况下递归算法比相同功能的非递归算法执行起来要慢些，这是因为递归算法执行时有系统栈开销。
以下关于递归的叙述中错误的是（ ）。
A.一般而言，使用递归解决问题较使用循环解决问题需要定义更多的变量
B.递归算法的执行效率相对较低
C.递归算法的执行需要用到栈
D.以上都是错误的
正确答案A
递归算法一般使用传值调用，每一次调用都会分配新的数据空间，所以一般不需要有更多的变量定义。
将递归算法转换为非递归算法时，通常使用___这种数据结构。
栈
将递归算法转换为非递归算法时，通常使用栈结构。
将（n>3）转化成递归函数，其递归出口是___，递归体是___。
f(1)=1、<imgstyle="max-width:70%;"src="https://cdnqingline.net/72b4e47a9f49f0fad035a3a69af8db6png"/>
设，则。当n=1时有f(1)=1，否则
递推式f(1)=0，f(n)=n-1+f(n-1)的解是___。
n(n-1)/2
f(n)=(n-1)+f(n-1)=(n-1)+(n-2)+f(n-2)=…=(n-1)+(n-2)+…+1+f(1)=(n-1)+(n-2)+…+1=n(n-1)/2。
递推式f(1)=0，f(n)=f(n/2)+1的解是___。
<p>log<sub>2</sub>n</p>
不妨设n=2k，则有k=log2n，由递推式可知：f(n)=f(n/2)+1=1+f(n/2)=1+(1+f(n/22))=2+f(n/22)=…=k+fun(n/2k)=k+f(1)=log2n。
设a是一个含有n个整数的数组，求该数组最大元素的递归定义是___。
f(a,0)=a[0]，f(a,i)=MAX{a[i],f(a,i-1)}（i≥1）
求a[.i]中的最大元素。当i=0时，a[.i]中最大元素为a[0]，否则，求出a[.i-1]中的最大元素为m，a[.i]中的最大元素为MAX{m,a[i]}。
设a是一个含有n个整数的数组，求该数组最小元素的递归定义是___。
f(a,0)=a[0]，f(a,i)=MIN{a[i],f(a,i-1)}（i≥1）
求a[.i]中的最小元素。当i=0时，a[.i]中最小元素为a[0]，否则，求出a[.i-1]中的最小元素为m，a[.i]中的最小元素为MIN{m,a[i]}。
设a是一个含有n个整数的数组，求该数组所有元素之和的递归定义是___。
f(a,0)=a[0]，f(i)=a[i]+f(a,i-1)（i≥1）
求a[.i]中所有元素之和。当i=0时，a[.i]中所有元素之和为a[0]，否则，求出a[.i-1]的所有元素之和为m，a[.i]的所有元素之和为a[i]+m。
设a是一个含有n个整数的数组，求该数组所有元素之积的递归定义是___。
f(a,0)=a[0]，f(i)=a[i]*f(a,i-1)（i≥1）
求a[.i]中所有元素之积。当i=0时，a[.i]中所有元素之积为a[0]，否则，求出a[.i-1]的所有元素之积为m，a[.i]的所有元素之积为a[i]*m。
调用自身的函数称为递归函数。
正确答案:是
调用自身的函数称为递归函数。
任何递归算法都必须包含递归出口部分。
正确答案:是
如果没有递归出口部分，递归算法不能中止，陷入死循环。
一个递归算法可以没有递归体，但必须包含递归出口部分。
正确答案:否
一个递归算法既包含递归体，也包含递归出口部分。
任何递归算法都是尾递归。
正确答案:否
尾递归是指递归调用的语句是最后一个可执行语句。
通常递归的算法、易懂、容易编写，而且执行的效率也高。
正确答案:否
通常递归的算法、易懂、容易编写，但执行的效率较低。
尾递归算法可以通过循环转换成非递归算法。
正确答案:是
尾递归是指递归调用的语句是最后一个可执行语句，可以通过循环转换成非递归算法。
任何递归算法都必须使用栈转换成非递归算法。
正确答案:否
尾递归算法可以通过循环转换成非递归算法，不必借助于栈。
递归算法转换为非递归算法时，通常借助于队列来实现。
正确答案:否
递归算法转换为非递归算法时，通常借助于栈来实现。
什么是递归，递归有哪些形式？
在定义一个函数时出现调用本函数的成分，称为递归。递归分为直接递归和间接递归两种形式。
直接递归是指在函数在执行过程中调用本身。间接递归是指函数在执行过程中调用其它函数再经过这些函数调用本身。
（同答案）
简述递归的特点。
递归的特点是它既有递堆过程，又有求值（回归）过程，而且在任何一个深度时，它的所有变量和参数的值都保存着，同一变量或参数在不同深度的值，都压入系统栈中。
（同答案）
简述递归算法的优缺点。
递归算法优点是结构清晰，可读性强，而且容易用数学归纳法来证明算法的正确性，因此它为设计算法、调试程序带来很大方便。
递归算法的缺点是算法的运行效率较低，无论是耗费的计算时间还是占用的存储空间都比非递归算法要多。
（同答案）
推导出求x的n次幂的递归模型。
f(x,n)=x当n=1时
f(x,n)=n*f(x,n-1)当n>1时
设f(x,n)=xn，f(x,n-1)=xn-1，所以f(x,n)=x*xn-1=n*f(x,n-1)。
某递归算法求解时间复杂度的递推式如下：
T(n)=1当n=0
T(n)=T(n-1)+n+3当n>0
求该算法的时间复杂度。
O(n2)
T(n)=T(n-1)+(n+3)
=T(n-2)+(n+2)+(n+3)
=T(n-3)+(n+1)+(n+2)+(n+3)
=…
=T(0)+4+5+…+(n+1)+(n+2)+(n+3)
=1+4+5+…+(n+1)+(n+2)+(n+3)
=n(n+7)/2+1
=O(n2)
有以下算法，分析执行fun(a,n,0)语句的时间复杂度。需要给出推导过程。
def fun(a,n,k): #数组a共有n个元素
if k==n-1:
for i in range(n):
print(a[i],end=' ')
else:
for i in range(k,n):
a[i]+=i*i
fun(a,n,k+1)
答：设调用fun(a，n，0)的执行时间为T(n)，fun(a，n，k)的执行时间为T1(n，k)，则有T(n)=T1(n，0)。由fun()算法可知：
T1(n,k)=n
当k=n-1、T1(n,k)=(n-k)+T1(n,k+1)
其他情况则T(n)=T1(n,0)=n+T1(n,1)=n+(n-1)+T1(n,2) =…= n+(n-1)+…+2+T1(n,n-1)
编程题
整数反转
给出一个 32 位的有符号整数，你需要将这个整数中每位上的数字进行反转。例如，输入123，输出结果为321。输入-123，输出结果为-321。要求设计满足题目条件的如下方法：
def reverse(self,x：int)->int：
lass Solution:
def reverse(self, x):
"""
:type x: int
:rtype: int
"""
a = str(x)
y = list(a)
y.reverse()
if y[-1] == "-":
y.remove('-')
y.insert(0, '-')
if y[0] == 0:
y.remove('0')
y2 = ''.join(y)
z = int(str(y2))
if z < (-2**31) or z > (2**31-1):
z = 0
return z
s = input("")
if __name__ == '__main__':
"""
输入: 123
输出: 321
输入: -123
输出: -321
输入: 120
输出: 21
"""
a = Solution()
b = a.reverse(s)
print(b)
正确答案
class Solution:
def reverse(self, x):
"""
:type x: int
:rtype: int
"""
a = str(x)
y = list(a)
y.reverse()
if y[-1] == "-":
y.remove('-')
y.insert(0, '-')
if y[0] == 0:
y.remove('0')
y2 = ''.join(y)
z = int(str(y2))
if z < (-2**31) or z > (2**31-1):
z = 0
return z
s = input("")
if __name__ == '__main__':
"""
输入: 123
输出: 321
输入: -123
输出: -321
输入: 120
输出: 21
"""
a = Solution()
b = a.reverse(s)
print(b)
编程题
螺旋矩阵II
给定一个正整数n，生成一个包含1到n
2
所有元素，且元素按顺时针顺序螺旋排列的正方形矩阵。例如，输入3，输出结果如下：
[
[ 1, 2, 3 ],
[ 8, 9, 4 ],
[ 7, 6, 5 ]
]
要求设计满足题目条件的如下方法：
def generateMatrix(self,n:int)->List[List[int]]:
lass Solution:
def generateMatrix(self, n):
# 顺时针方向（右下左上）
dx = [0, 1, 0, -1]
dy = [1, 0, -1, 0]
dn = 0 # 方向指针
res = [[0]*n for _ in range(n)] # 初始化
x = y = 0 # 位置
for i in range(1, n*n+1):
res[x][y] = i
# 下一步位置
temp_x = x + dx[dn]
temp_y = y + dy[dn]
# 判断下一步位置合理，若合理则更新位置，若不合理则改变方向并更新位置
if 0<=temp_x<n and 0<=temp_y<n and res[temp_x][temp_y]==0:
x, y = temp_x, temp_y
else:
dn = (dn+1) % 4
x += dx[dn]
y += dy[dn]
return res
test = Solution()
n = 3
test.generateMatrix(n)
print(test.generateMatrix(n))
正确答案
class Solution:
def generateMatrix(self, n):
# 顺时针方向（右下左上）
dx = [0, 1, 0, -1]
dy = [1, 0, -1, 0]
dn = 0 # 方向指针
res = [[0]*n for _ in range(n)] # 初始化
x = y = 0 # 位置
for i in range(1, n*n+1):
res[x][y] = i
# 下一步位置
temp_x = x + dx[dn]
temp_y = y + dy[dn]
# 判断下一步位置合理，若合理则更新位置，若不合理则改变方向并更新位置
if 0<=temp_x<n and 0<=temp_y<n and res[temp_x][temp_y]==0:
x, y = temp_x, temp_y
else:
dn = (dn+1) % 4
x += dx[dn]
y += dy[dn]
return res
test = Solution()
n = 3
test.generateMatrix(n)
print(test.generateMatrix(n))
首页
作业系统
考试系统
师资培训
课程题库
考研
问答
使用手册
第四章作业
总分：10
得分：7
关于串的叙述，正确的是（ ）。
A.串是含有一个或多个字符的有穷序列
B.空串是只含有空格字符的串
C.空串是含有零个字符或含有空格字符的串
D.串是含有零个或多个字符的有穷序列
正确答案D
下面关于串的叙述中，正确的是（ ）。
A.串是一种特殊的线性表
B.串中元素只能是字母
C.空串就是空白串
D.串的长度必须大于零
正确答案A
关于串的的叙述，不正确的是（ ）。
A.串是字符的有限序列
B.空串是由空格构成的串
C.替换是串的一种重要运算
D.串既可以采用顺序存储，也可以采用链式存储
正确答案B
两个字符串相等的条件是（ ） 。
A.串的长度相等
B.含有相同的字符集
C.都是非空串
D.串的长度相等且对应的字符相同
正确答案D
串的长度是指（ ）。
A.串中所含不同字母的个数
B.串中所含字符的个数
C.串中所含不同字符的个数
D.串中所含非空格字符的个数
正确答案B
串是一种特殊的线性表，其特殊性体现在（ ）。
A.可以顺序存储
B.数据元素是单个字符
C.可以链接存储
D.数据元素可以是多个字符
正确答案B
以下（ ）是"abcd321ABCD"串的子串。
A.abcd
B.321AB
C."abcABC"
D."21AB"
正确答案D
若串str="Software"，其子串的数目是（ ）。
A.8
B.9
C.36
D.37
正确答案D
若串s为一个长度为n的串，其中各字符不相同，则s中真子串的数目是（ ）。
A.n(n-1)/2
B.n(n+1)/2
C.n(n+1)/2+1
D.n(n-1)/2+1
正确答案B
串是一种特殊的线性表，其中所有元素均为___。
字符
空串是、____、，其长度等于 ____、。
零个字符的串、零
空白串不同于空串，其中仅含有___字符。
空格
字符串中任意个连续的字符组成的子序列称为该串的 ___。
子串
一个串，除自身之外的所有子串都是该串的___。
真子串
一个串中___称为该串的子串。
任意连续字符组成的子序列
两个串相等的充分必要条件是___。
两个串的长度相等且对应位置的字符相同
设串S="A:/document/Mary.doc"，则它的长度为、____、，第一个'/'的字符的位置为、____ 。
20、3
将10阶对称矩阵A压缩存储到一维数组B中，则数组B的长度最少为_( )。
A.100
B.40
C.80
D.55
正确答案D
n阶对称矩阵压缩存储时需要存储的元素个数=n(n+1)/2，n=10时结果为55。答案为D。
设目标串为s，模式串为t，在KMP模式匹配中，next[4]=2的含义是( )。
A.表示t4字符前面最多有2个字符和开头的2个字符相同
B.表示s4字符前面最多有2个字符和开头的2个字符相同
C.表示目标串匹配失败的位置是i=4
D.表示模式串匹配失败的位置是j=2
正确答案A
KMP算法中next数组表示模式串t的部分匹配信息，next[4]=2表示字符t4前面最多有2个字符和t开头的2个字符相同。答案为A。
在KMP算法中，已经求出next数组。当模式串位j与目标串位i比较时，两字符不相等，则i的位移方式是（ ） 。
A.i=next[j]
B.i不变
C.j不变
D.j=next[j]
正确答案B
在KMP算法中，当tj≠si时，i位置不改变。答案为B。
2
一个对称矩阵A[.10，.10]采用压缩存储方式，将其上三角+主对角部分元素按行优先存储到一维数组B[.m]中，则A[5][8]元素在B中的位置k是 （ ） 。
A.10
B.37
C.45
D.60
正确答案B
A[5][8]属于上三角部分的元素，A[5][8]前面存放的元素个数计算是，第1行有10个，第2行有9个，…，第4行有7个，在第5行中有A[.7]计3个元素，共10+9+8+7+3=37，由于B的起始下标从0开始，所以k=37。答案为B。
一个稀疏矩阵采用压缩后，和直接采用二维数组存储相比会失去（ ）特性。
A.顺序存储
B.随机存取
C.输入输出
D.以上都不对
正确答案B
稀疏矩阵采用三元组或者十字链表压缩后均不再具有随机存取特性。答案为B。
设二维数组A[3][5]，每个数组元素占用2个存储单元，若按列优先顺序进行存储，A[0][0]的存储地址为100，则A[2][3]的存储地址是（ ） 。
A.122
B.126
C.114
D.116
正确答案A
A[2][3]前面有3列，每列3个元素，计9个元素，在列3中前面有2个元素，这样的存储方式中，A[2][3]前面共存储11个元素。LOC(A[2][3])=LOC(A[0][0])+11×2=122。答案为A。
在KMP算法中，模式串"ababaabab"的next数组值为（ ）。
A.-1,0,0,1,2,3,1,2,3
B.-1,0,0,1,2,1,1,2,3
C.-1,0,0,1,2,3,4,1,2
D.-1,0,0,1,2,3,1,2,2
正确答案A
求模式串"ababaabab"的next数组的过程如表A.1所示。答案为A。
若将n阶上三角矩阵A按列优先顺序压缩存放在一维数组B[.n(n+1)/2]中，A中首元素a1,1存于B数组的b1中，则应存放到bk中的元素ai,j（i≤j）的下标i、j与k的对应关系是，k=( ) 。
A.i(i+1)/2+j
B.i(i-1)/2+j
C.j(j+1)/2+i
D.j(j-1)/2+i
正确答案D
n阶上三角矩阵A中上三角+主对角部分元素随机分布，下三角元素为常量c，按列优先顺序压缩存储时，ai,j（i≤j）前面存储的元素列为1～j-1，元素个数=1+2+…+(j-1)=j(j-1)/2，第j列中前面存储的元素个数为i-1，所有ai,j前面存储的元素个数=j(j-1)/2+i-1，而B数组起始下标从1开始，则k=j(j-1)/2+i-1+1= j(j-1)/2+i。答案为D。
一个n阶的对称矩阵A，如果采用以列优先（即以列序为主序）的压缩方式存放到一个一维数组B中，则B的容量为( ) 。
A.n2
B.n2/2
C.n(n+1)/2
D.(n+1)(n+2)/2
正确答案C
由n阶对称矩阵的特点可知，无论哪种压缩存储，需要存储的元素个数=n(n+1)/2。答案为C。
设矩阵a的元素ai,j（1≤i，j≤10）满足ai,j≠0（i≤j）和ai,j=0（i>j）。若将a的所有非零元素以行优先存放在首地址为2000的存储空间中，每个元素占4个单元，则元素a5,9的首地址是（ ） 。
A.2340
B.2152
C.2220
D.2160
正确答案B
该矩阵是一个上三角矩阵（下三角部分为常量0），采用以行优先存放时，对于上三角中的元素a5,9，前面有第1行～第4行，共计10+9+8+7=34个元素，第5行前有4个元素（a5,5～a5,8），则LOC(a5,9)=LOC(a1,1)+(34+4)×4=2000+152=2152。答案为B。
编程题
反转字符串
编写一个函数，其作用是将输入的字符串反转过来。输入字符串以字符数组 char[]的形式给出。不要给另外的数组分配额外的空间，你必须原地修改输入数组、使用O(1)的额外空间解决这一问题。你可以假设数组中的所有字符都是ASCII码表中的可打印字符。例如，输入["h"，"e"，"l"，"l"，"o"]，输出结果为["o"，"l"，"l"，"e"，"h"]。输入["H"，"a"，"n"，"n"，"a"，"h"]，输出结果为["h"，"a"，"n"，"n"，"a"，"H"]。要求设计满足题目条件的如下方法：
def reverseString(self， s: List[str]) -> None:
import sys
def reverseString(s):
n = len(s)
i, j = 0, n - 1 # 定义头尾指针
while i < j:
s[i], s[j] = s[j], s[i] # 头尾交换
i, j = i+1, j-1 # 更新指针
if __name__ == '__main__':
s = list(sys.stdin.readline().strip())
reverseString(s)
print(''.join(s))
编程题
转置矩阵
给定一个矩阵 A， 返回 A 的转置矩阵。矩阵的转置是指将矩阵的主对角线翻转，交换矩阵的行索引与列索引。例如，输入[[1，2，3]，[4，5，6]，[7，8，9]]，输出结果为[[1，4，7]，[2，5，8]，[3，6，9]]。要求设计满足题目条件的如下方法：
def transpose(self， A: List[List[int]]) -> List[List[int]]:
import sys
def transpose(A):
m = len(A)
n = len(A[0])
B = [[None] * m for i in range(n)] # 初始化结果矩阵
for i in range(m): # 处理A的每一行
for j in range(n): # 处理A的每一列
B[j][i] = A[i][j]
return B
def matrixStr(M):
s = ''
for vec in M:
s += ' '.join(map(str, vec))
s += '\n'
return s
if __name__ == '__main__':
m = int(sys.stdin.readline())
A = []
for i in range(m):
A.append(list(map(int, sys.stdin.readline().split(' ')))) # 读入矩阵
B = transpose(A)
print(matrixStr(B))
首页
作业系统
考试系统
师资培训
课程题库
考研
问答
使用手册
第9章作业1
总分：10
得分：9
内排序方法的稳定性是指（ ）。
A.该排序算法不允许有相同关键字的元素
B.该排序算法允许有相同关键字的元素
C.平均时间为O(nlog2n)的排序方法
D.以上都不对
正确答案D
内排序方法的稳定性是指（ ）。
A.经过排序后，能使关键字相同的元素保持原顺序中的相对位置不变
B.经过排序后，能使关键字相同的元素保持原顺序中的绝对位置不变
C.排序算法的性能与被排序元素的数量关系不大
D.排序算法的性能与被排序元素的数量关系密切
正确答案A
初始数据序列中有两个相同关键字的元素，通过不稳定的排序方法排序后，（ ）。
A.这两个元素的前后位置不发生变化
B.这两个元素的前后位置一定发生变化
C.这两个元素的位置不发生变化
D.这两个元素的前后位置可能发生变化
正确答案D
以下关于排序的叙述中正确的是（ ）。
A.稳定的排序方法优于不稳定的排序方法，因为稳定的排序方法效率较高
B.对同一个顺序表使用不同的排序方法进行排序，得到的排序结果可能不同
C.排序方法都是在顺序表上实现的，在链表上无法实现排序方法
D.在顺序表上实现的排序方法在链表上也可以实现
正确答案B
稳定的排序方法的效率不一定都比不稳定的排序方法高。有些排序方法既可以上顺序表上实现，也可以在链表上实现，但不是所有的排序方法都如此。由于排序方法具有不同的稳定性，所以对同一个顺序表使用不同的排序方法进行排序，得到的排序结果可能不同。
以下不属于内排序方法的是（ ） 。
A.二路归并排序
B.拓扑排序
C.堆排序
D.直接插入排序
正确答案B
拓扑排序是一种产生拓扑序列的方法，不属内排序方法。
如果一组数据采用某种排序方法进行排序，排序后相同关键字的元素的相对位置不发生改变，称该排序方法是___ 。
稳定的
若不考虑基数排序，在排序过程中，主要进行的两种基本操作是关键字的、____、。和记录的、____、。
比较 、移动
每次从无序子表中取出一个元素，通过依次比较把它插入到有序子表的适当位置，此种排序方法称为___。
直接插入排序
对含有n个元素的数据序列进行直接插入排序（采用《教程》中的算法），在最坏情况下移动元素的个数是____，关键字比较的次数是____。
(n-1)(n+4)/2、n(n-1)/2
直接插入排序在初始数据反序时的效率最差，此时元素移动共(1+2)+(2+2)+…+(n-1+2)=(n-1)(n+4)/2次，关键字比较的次数为1+2+…+(n-1)=n(n-1)/2。
一组数据序列为…,R[i],…,R[j],…，R[i]与R[j]的关键字相同，采用某种排序方法排序后变为…,R[j],…,R[i],…，则该排序算法是稳定的。
正确答案:否
该排序算法是不稳定的。
当待排序的元素很大时，为了交换元素的位置，移动元素要占用较多的时间，这是影响算法时间复杂度的主要因素。
正确答案:否
影响算法时间复杂度的主要因素是移动元素的次数和关键字比较的次数。
内排序方法要求数据一定以顺序表方式存储。
正确答案:否
有些内排序方法也适合数据采用链表方式存储的情况。
所有内排序算法中的比较次数与初始元素序列的排列无关。
正确答案:否
排序的稳定性是指排序算法中的比较次数保持不变，且算法能够终止。
正确答案:否
简述何时使用稳定的排序算法。
如果排序数据存在相同关键字的元素，而且要求排序后不改变这些相同关键字记录的相对位置，此时需要使用稳定的排序算法。如张三的成绩是82，李四成绩也是82，而张三的记录在李四的记录的前面，要求按成绩递减排序，排好序后，张三的记录仍在李四的记录的前面，这就需要使用稳定的排序算法。
另一个用途是多关键字排序，如学生记录有姓名、数学、语文成绩和总分，要求这样排名次，先按总分，总分相同再按数学成绩。可以这样排序，先采用任一种排序方法按数学成绩递减排序，再选择一种稳定的排序方法按总分排序，后者一定用稳定的排序方法，否则会出现总分相同，数学成绩低的排到前面了。
排序方法的稳定性受什么因素影响？
在排序过程中，需要以一个较大的间隔互换元素，或把元素隔空搬运一段较大距离时，排序方法一定不稳定，它可能会把原先排在前面的元素搬到具有相同关键字值的另一个元素的后面，改变了相对位置。
证明：对于一个长度为n的线性表基于比较方法进行排序，至少需要进行nlog2n次比较。
证明：对于一个长度为n的线性表基于比较方法进行排序，元素两两比较构成的判定树可以近似看成是一棵满二叉树，其中叶子结点是某种排序结果，由于n个元素总共有n!种不同的排列，所以叶子结点个数为n!，一次排序恰好经过从根结点到某个叶子结点的路径，比较次数为树的高度，而h=log2(n!)≈nlog2n，所以至少需要进行nlog2n次比较。
给出关键字序列{4,5,1,2,8,6,7,3,10,9}采用直接插入排序时各趟的结果。
直接插入排序过程如图11所示。
直接插入排序算法在含有n个元素的初始数据正序、反序和数据全部相等时，时间复杂度各是多少？
含有n个元素的初始数据正序时，直接插入排序算法的时间复杂度为O(n)。
含有n个元素的初始数据反序时，直接插入排序算法的时间复杂度为O(n2)。
含有n个元素的初始数据全部相等时，直接插入排序算法的时间复杂度为O(n)。
下列排序方法中，（ ）在一趟结束后不一定能选出一个元素放在其最终位置上。
A.选择排序
B.冒泡排序
C.归并排序
D.堆排序
正确答案C
因为归并排序每趟并不一定产生全局有序区。
2
下列排序方法中，稳定的排序算法是（ ）。
A.希尔选择
B.快速排序
C.归并排序
D.堆排序
正确答案C
这几种排序方法中只有归并排序是稳定的，其余几种排序方法都是不稳定的。
下列排序方法中，辅助空间为O(n)的是（ ） 。
A.希尔选择
B.冒泡排序
C.堆排序
D.归并排序
正确答案D
这几种排序方法中只有归并排序的空间复杂度为O(n)，其余几种排序方法的空间复杂度为O(1)。
下列四种排序中 （ ）的空间复杂度最大。
A.直接插入排序
B.冒泡排序
C.堆排序
D.二路归并排序
正确答案D
二路归并排序的空间复杂度为O(n)。
就排序算法所用的辅助空间而言，堆排序、快速排序和归并排序的关系是（ ）。
A.堆排序 < 快速排序 < 归并排序
B.堆排序 < 归并排序 < 快速排序
C.堆排序 > 归并排序 > 快速排序
D.堆排序 > 快速排序 > 归并排序
正确答案A
归并排序的空间复杂度为O(n)，快速排序的空间复杂度为O(log2n)，堆排序的空间复杂度为O(1)。
数据序列{1,2,3,4,5,6,7,8}采用二路归并排序方法进行递增排序，经过两趟排序后的结果是___。
{1,2,3,4,5,6,7,8}
数据序列{8,7,6,5,4,3,2,1}采用二路归并排序方法进行递增排序，所需要关键字比较次数是___。
12
排序过程如下：
8，7，6，5，4，3，2，1初始数据
7，8，5，6，3，4，1，2共比较4次
5，6，7，8，1，2，3，4共比较4次
1，2，3，4，5，6，7，8 共比较4次
数据序列中有n=2k个元素，采用二路归并排序方法进行递增排序，最好情况下所需要关键字比较次数是___。
k2<sup>k-1</sup>
当数据序列正序或反序时，所需要关键字比较次数最少，每趟只需n/2=2k-1次关键字比较，共有k趟，总的关键字比较次数为k2k-1。
在快速排序、堆排序、归并排序中，___排序是稳定的。
归并排序
二路归并排序算法的空间复杂度是___。
O(n)
二路归并排序算法是稳定的。
正确答案:是
对于不同的初始数据序列，二路归并排序算法中关键字比较次数有所不同。
正确答案:是
二路归并排序算法的时间复杂度与初始数据序列的顺序无关，但关键字比较次数是相关的。
二路归并排序算法的时间复杂度与初始数据序列的顺序无关。
正确答案:是
二路归并排序算法的最好时间复杂度为O(n)。
正确答案:否
二路归并排序算法的最好时间复杂度也为O(nlog2n)。
n个元素采用二路归并排序算法，总的趟数为n。
正确答案:否
n个元素采用二路归并排序算法，总的趟数为log2n。
已知序列{15,5,16,2,25,8,20,9,18,12}，采用二路归并排序法对该序列做升序排序时的每一趟的结果。
采用二路归并排序法排序的各趟结果如图11所示。
两个各含有n个元素的有序序列归并成一个有序序列时，关键字比较次数为n～2n-1，也就是说关键字比较次数与初始序列有关。为什么通常说二路归并排序与初始序列无关呢？
二路归并排序中使用了辅助空间R1，需要先将所有归并数据移到R1中，然后再复制到R中，所以每一趟移动元素的次数2n，共需log2n趟排序，总的移动次数总是O(nlog2n)。尽管待排序的初始序列对关键字的比较有一定的影响，但不改变算法的总体时间性能，所以通常说二路归并排序与初始序列无关。
二路归并排序中每一趟排序都要开辟O(n)的辅助空间，共需log2n趟排序，为什么总的辅助空间仍为O(n)？
二路归并排序中每一趟排序都要开辟O(n)的辅助空间，但在一趟排序结束后，这些辅助空间都被释放了，所以总的辅助空间仍为O(n)。
在堆排序、快速排序和归并排序中：
（1）若只从存储空间考虑，则应首先选取哪种排序方法，其次选取哪种排序方法，最后选取哪种排序方法？
（2）若只从排序结果的稳定性考虑，则应选取哪种排序方法？
（3）若只从最坏情况下的排序时间考虑，则不应选取哪种排序方法？
（1）若只从存储空间考虑，则应首先选取堆排序（空间复杂度为O(1)），其次选取快速排序（空间复杂度为O(log2n)），最后选取归并排序（空间复杂度为O(n)）。
（2）若只从排序结果的稳定性考虑，则应选取归并排序。因为归并排序是稳定的，其他两种排序方法是不稳定的。
（3）若只从最坏情况下的排序时间考虑，则不应选取快速排序方法。因为快速排序方法最坏情况下的时间复杂度为O(n2)，其他两种排序方法在最坏情况下的时间复杂度为O(nlog2n)。
以归并算法为例，比较内排序和外排序的不同，说明外排序如何提高操作效率。
内排序中的归并排序是在内存中进行的归并排序，辅助空间为O(n)。外部归并排序是将外存中的多个有序子文件合并成一个有序子文件，将每个子文件中记录读入内存后的排序方法可采用多种内排序方法。外部排序的效率主要取决于读写外存的次数，即归并的趟数。因为归并的趟数s=logkm，其中，m是归并段个数，k是归并路数。增大k和减少m都可减少归并趟数。实际应用中通过败者树进行k（k≥3）路平衡归并和置换-选择排序减少m，来提高外部排序的效率。
以下排序方法中，（ ）不需要进行关键字的比较。
A.快速排序
B.归并排序
C.基数排序
D.堆排序
正确答案C
在本章介绍的各种排序方法中，基数排序是唯一不基于关键字比较的排序方法。
4
以下排序方法中，稳定的排序方法是（ ） 。
A.快速排序
B.堆排序
C.希尔排序
D.基数排序
正确答案D
基数排序是一种稳定的排序方法。
有n个十进制整数进行基数排序，其中最大的整数为5位，则基数排序的趟数是（ ）。
A.10
B.n
C.5
D.2
正确答案C
基数排序的趟数是最大的关键字的位数。
有n个十进制整数进行基数排序，其中最大的整数为5位，则基数排序过程中临时建立的队数个数是（ ）。
A.10
B.n
C.5
D.2
正确答案A
基数排序中建立队列个数等于进制数。
以下四个线性表中，最适合采用基数排序的是（ ）。
A.10000个实数
B.1000个由字母、数字和其他字符组成的字符串
C.1000个int类型的整数
D.10000个100以内的正整数
正确答案D
选项C中有可能出现负整数，这样不适合基数排序。
给出关键字序列{112,214,312,902,156,712,451,623,643,834}按低位到高位进行基数排序时每一趟的结果。
排序结果如图11所示。
给出关键字序列{112,214,312,902,156,712,451,623,643,834}按高位到低位进行基数排序时每一趟的结果。
排序结果如图12所示，从中看到，最终的排序结果是错误的，所以对于数值数据排序时只能是按低位到高位进行基数排序。
有n个不同的英文单词（均为小写字母），它们的长度相等，均为m。若n=50，m<5，试问采用什么排序方法时其时间复杂度最小？为什么？
采用基数排序方法最好，这里r=26，其时间复杂度为O(m(n+26m))，其他排序方法的时间复杂度最小为O(nlog2n)，当n=50，m<5时，m(n+26m)<nlog2n，所以基数排序方法最好。
问在一般情况下，直接插入排序、选择排序和冒泡排序的过程中，所需元素交换次数最少的是哪种排序方法？
对于直接插入排序，有序区分别有1、2、…、n-1个元素，平均交换一半的元素，所以平均元素交换次数=。
对于选择排序，最多只进行n-1次元素交换
对于冒泡排序，平均每趟交换一半的元素，平均排序n/2趟，所以平均元素交换次数=
。
所以元素交换次数最少的是选择排序。
在下列情况下，选择哪种内排序算法比较合适？说明理由。
（1）需要对1000个大型记录进行排序，记录本身存储在外存中，在内存中只保研了所有记录的关键字。关键字之间的比较非常快，但移动代价很大，因为一旦移动一个关键字，相应的外存中的记录也要移动，这将涉及很多磁盘块的移动。
（2）已知一个包含了5000个单词的列表已按字母顺序排好序，需要再进行一次检查，确保所有的单词已经排好序。
（3）需要将500张随机排列的图书卡片按照字母顺序排序。
（1）选择选择排序，该排序方法可以达到尽量少地移动记录，虽然比较次数达到O(n2)，但是相对外存的处理时间来说，不是关键因素。
（2）因为整个表已经基本有序，所以应该采用直接插入排序。
（3）因为是随机排列的卡片，所以选择快速排序比较合适。
基数排序主要适用于___排序的情况。
多关键字
基数排序与其他几种排序方法的区别是___。
基数排序采用分配和收集实现，不需要进行关键字的比较，而其他几种排序方法都是通过关键字的比较实现的
对数据序列{288,371,260,531,287,235,56,299,18,23}采用最低位优先的基数排序，第一趟排序后的结果是___。
{260,371,531,23,235,56,287,288,18,299}
对数据序列{288,371,260,531,287,235,56,299,18,23}采用最低位优先的基数排序，第2趟排序后的结果是___。
{18,23,531,235,56,260,371,287,288,299}
基数排序的空间复杂度是___。
O(r)（r为排序的基数）
基数排序只适用于以数字为关键字的情况，不适用以字符串为关键字的情况。
正确答案:否
基数排序与初始数据的次序无关。
正确答案:是
基数排序与初始数据中关键字的大小无关。
正确答案:否
基数排序与初始数据中关键字的位数有关，也就与关键字的大小有关。
快速排序、选择排序和堆排序都与初始序列次序无关。
正确答案:否
快速排序与初始序列次序无关。
直接插入排序、冒泡排序和选择排序在最好情况下的时间复杂度均为O(n)。
正确答案:否
直接插入排序和冒泡排序在最好情况下的时间复杂度均为O(n)。
以下稳定的排序方法是（ ）。
A.直接插入排序和快速排序
B.直接插入排序和冒泡排序
C.选择排序和归并排序
D.选择排序和冒泡排序
正确答案B
6
以下 （ ）方法在数据基本有序时效率最好。
A.快速排序
B.冒泡排序
C.堆排序
D.希尔排序
正确答案B
冒泡排序最少关键字比较的次数是（ ）。
A.0
B.n
C.n-1
D.3n(n-1)/2
正确答案C
冒泡排序最少元素移动的次数是（ ） 。
A.0
B.1
C.n
D.3n(n-1)/2
正确答案A
对一组数据(2,12,16,88,5,10)进行排序，若前三趟的结果如下：
第一趟：2,12,16,5,10,88
第二趟：2,12,5,10,16,88
第三趟：2,5,10,12,16,88
则采用的排序方法可能是 （ ） 。
A.冒泡排序
B.希尔排序
C.归并排序
D.基数排序
正确答案A
对含有n个元素的数据序列进行冒泡排序，其中关键字比较最多的次数是___。
n(n-1)/2
当数据反序时冒泡排序方法所需关键字比较次数最多，此时关键字比较次数=(n-1)+…+2+1=n(n-1)/2。
对含有n个元素的数据序列进行冒泡排序，其中关键字比较最少的次数是___。
n-1
当数据正序时冒泡排序方法所需关键字比较次数最少，只需一趟排序，此时关键字比较次数=n-1。
冒泡排序算法在最好情况下的时间复杂度是___。
O(n)
当数据正序时冒泡排序算法的时间复杂度是O(n)。
冒泡排序算法的平均时间复杂度是___。
O(n<sup>2</sup>)
对数据序列{5,1,7,9,8,6,3,4,2,10}采用冒泡排序方法进行递增排序，每趟通过交换归位关键字最小的元素，经过一趟后的排序结果是___。
{1,5,2,7,9,8,6,3,4,10}
冒泡排序在最好情况下的时间复杂度也是O(n2)。
正确答案:否
冒泡排序在最好情况下的时间复杂度为O(n)。
采用冒泡排序进行递增排序时，关键字较小的元素总是向前移动，关键字较大的元素总是向后移动。
正确答案:否
对n个元素进行冒泡排序，只有在初始元素反序时，冒泡排序移动元素的次数才会达到最大值。
正确答案:是
冒泡排序在最好情况下元素移动的次数为0。
正确答案:是
冒泡排序在初始数据正序时元素移动的次数为0。
冒泡排序中，关键字比较的次数与初始数据序列有关，而元素移动的次数与初始数据序列无关。
正确答案:否
关键字比较的次数与元素移动的次数都与初始数据序列有关。
已知序列{15,5,16,2,25,8,20,9,18,12}，给出采用冒泡排序方法对该序列做升序排序时的过程。
采用冒泡排序方法排序的过程如下：
冒泡排序在什么情况下需要进行的关键字比较次数最多，最多关键字比较次数是多少？
冒泡排序在初始数据反序时需要进行的关键字比较次数最多，此时关键字比较次数=(n-1)+(n-2)+…+1=n(n-1)/2。
冒泡排序在什么情况下需要进行的元素移动次数最少，最少元素移动次数是多少？
冒泡排序在初始数据正序时需要移动的元素次数最小，此时移动的元素次数为0。
在冒泡排序过程中，有的关键字在某趟排序中可能朝着与最终排序相反的方向移动，请举例说明之。快速排序过程中有没有这种现象出现？
在冒泡排序，有的关键字在某趟排序中可能朝着与最终排序相反的方向移动，例如，以下冒泡排序过程中关键字38便是如此：
49，38，13，27，97（初始关键字）
38，13，27，49，97（第1趟排序）
13，27，38，49，97（第2趟排序）
但在快速排序中不会出现这种情况。因为在每趟排序中，比基准元素大的都交换到其右边，而基准元素小的则交换到其左边。
已知序列{15,5,16,2,25,8,20,9,18,12}，给出采用快速排序方法对该序列做升序排序时的过程。
采用快速排序方法排序的过程如图11所示。
在排序算法中，每次从未排序的元素中通过关键字直接比较选取最小关键字的元素，加入到已排序元素的末尾，该排序方法是（ ）。
A.选择排序
B.冒泡排序
C.堆排序
D.直接插入排序
正确答案A
这是典型的选择排序方法，如果借助堆来选取最小元素就是堆排序方法。
8
对数据{84,47,25,15,21}排序，数据的排列次序在排序过程中的变化如图11所示，则采用的排序方法是 （ ）。
A.选择排序
B.快速排序
C.冒泡排序
D.直接插入排序
正确答案A
从数据排列次序的变化过程看到，每一趟都从无序区中选一个最小的元素归位。
假设排序过程中顺序表的变化情况如下：
21，25，49，25，16，8（初始状态）
8，25，49，25，16，21
8，16，49，25，25，21
8，16，21，25，25，49
8，16，21，25，25，49
8，16，21，25，25，49（最终状态）
可以断定，所采用的排序方法是（ ） 排序。
A.直接插入
B.冒泡
C.二路归并
D.选择
正确答案D
共有6个元素，即使有序也不结束，从排序过程可以断定是选择排序。
采用排序算法对n个元素进行排序，其排序趟数肯定为n-1趟的排序方法是（ ）。
A.直接插入和快速
B.冒泡和快速
C.选择和直接插入
D.选择和冒泡
正确答案C
选择和直接插入肯定要进行n-1趟排序，冒泡排序为1～n-1趟，快速排序为log2n～n-1趟。
在一般情况下，以下排序算法中元素移动次数最少的（ ） 。
A.直接插入排序
B.冒泡排序
C.选择排序
D.都一样
正确答案C
选择排序移动元素的次数为0～3(n-1)，在一般情况下，比直接插入排序和冒泡排序移动元素次数要少。
选择排序的最好、最坏和平均时间复杂度分别为、____、、、____、、、____、。
O(n<sup>2</sup>)、O(n<sup>2</sup>)、O(n<sup>2</sup>)
在直接插入排序、冒泡排序和选择排序这三种排序方法中，___是不稳定的。
选择排序
数据序列{6,9,1,4,5,2,3,8,7,10}采用选择排序进行递增排序，每趟挑选最小元素，经过3趟排序后结果是___ 。
{1,2,3,4,5,9,6,8,7,10}
对含有n个元素的数据序列进行选择排序，总的关键字比较次数是___。
n(n-1)/2
对含有n个元素的数据序列进行选择排序，最好情况下元素移动的次数是___。
0
当数据序列正序时没有元素移动。
选择排序在初始数据正序时，其时间复杂度为O(n)。
正确答案:否
选择排序中，每趟产生的有序区中所有元素在以后的排序中不再改变位置。
正确答案:是
选择排序是一种不稳定的排序方法。
正确答案:是
n个元素采用选择排序进行排序，关键字比较的次数总是n(n-1)/2。
正确答案:是
从时间性能看，堆排序总是优于选择排序。
正确答案:是
堆排序的最好、最坏和平均时间复杂度均为O(nlog2n)，而选择排序的最好、最坏和平均时间复杂度均为O(n2)。
给出数据序列{9,8,7,6,5,4,3,2,1}采用选择排序进行递增排序时各趟的结果。并指出选择排序的缺陷。
排序过程如下：
i=0：1，8，7，6，5，4，3，2，9
i=1：1，2，7，6，5，4，3，8，9
i=2：1，2，3，6，5，4，7，8，9
i=3：1，2，3，4，5，6，7，8，9
i=4：1，2，3，4，5，6，7，8，9
i=5：1，2，3，4，5，6，7，8，9
i=6：1，2，3，4，5，6，7，8，9
i=7：1，2，3，4，5，6，7，8，9
从中看出，当i=3这一趟排序结束后，数据已有序，但选择排序仍要完成余下的各趟排序，也就是说选择排序没有中途退出机制。
简述选择排序的时间性能。
选择排序的主要时间花在关键字比较上，无论初始数据序列如何排列，所需关键字比较次数均为n(n-1)/2，所以选择排序算法的时间复杂度总是O(n2)，与初始数据序列如何排列无关。
一个有n个整数的数组R[.n]，其中所有元素是有序的，将其看成是一棵完全二叉树，该树构成一个堆吗？若不是，请给一个反例，若是，请说明理由。
该数组一定构成一个堆，递增有序数组构成一个小根堆，递减有序数组构成一个大根堆。
以递增有序数组为例，假设数组元素为k1、k2、…、kn是递增有序的，从中看出下标越大的元素值也越大，对于任一元素ki，有ki<k2i，ki<k2i+1（i<n/2），这正好满足小根堆的特性，所以构成一个小根堆。
已知关键字序列为{72,87,61,23,94,16,5,58}，采用堆排序法对该序列进行递增排序，给出整个排序过程。
该序列对应的完全二叉树如图11（a）所示，调整成初始堆如图11（b）所示，用堆排序方法排序的各趟过程如图11（c）～（o）所示，排序结果为{5,16,23,58,61,72,87,94}。
请回答下列关于堆排序中堆的一些问题：
（1）堆的存储表示是顺序还是链式的？
（2）设有一个小根堆，即堆中任意结点的关键字均小于它的左孩子和右孩子的关键字。其中具有最大关键字的结点可能在什么地方？
（1）通常堆的存储表示是顺序的。因为堆排序将待排序序列看成是一棵完全二叉树，然后将其调整成一个堆。而完全二叉树特别适合于采用顺序存储结构，所以堆的存储表示采用顺序方式最合适。
（2）小根堆中具有最大关键字的结点只可能出现在叶子结点中。因为最小堆的最小关键字的结点必是根结点，而最大关键字的结点由偏序关系可知，只有叶子结点可能是最大关键字的结点。
1
外排序和内排序的主要区别是（ ）。
A.内排序速度快，而外排序速度慢
B.内排序不涉及内、外存数据交换，而外排序涉及内、外存数据交换
C.内排序所需内存小，而外排序所需内存大
D.内排序的数据量小，而外排序的数据量大
正确答案B
首页
作业系统
考试系统
师资培训
课程题库
考研
问答
使用手册
第8章作业
总分：10
得分：9
哈希查找方法一般适用于（ ）情况下的查找。
A.查找表为链表
B.查找表为有序表
C.关键字集合比地址集合大得多
D.关键字集合与地址集合之间存在对应关系
正确答案D
关键字集合与地址集合之间存在对应关系时，通过哈希函数表示这种关系，这样查找以计算哈希函数而不是比较的方式进行查找。
哈希查找的基本思想是根据（ ）来决定元素的存储地址。
A.元素的序号
B.元素个数
C.关键字值
D.非关键字属性值
正确答案C
将10个元素散列到大小为10000的哈希表中，（ ）产生冲突。
A.一定会
B.一定不会
C.仍可能会
D.以上都不对
正确答案C
无论装填因子大还是小，哈希表仍可能发生冲突。
以下关于哈希查找的叙述中错误的是（ ） 。
A.用拉链法解决冲突易引起堆积现象
B.用线性探测法解决冲突易引起堆积现象
C.哈希函数选得好可以减少冲突现象
D.哈希函数H(k)=k MOD p，p通常取小于等于表长的素数
正确答案A
用拉链法解决冲突时不存在堆积现象，只有用线性探测法解决冲突时易引起堆积现象。
在各种查找方法中，其成功和不成功情况下的平均查找长度与元素个数n无直接关系的查找方法是___。
哈希表查找
哈希表是通过、____、将某关键字的记录映射到哈希表中，当发生冲突时，选择某种、____、再找新的存放位置。
哈希函数、解决冲突的方法
哈希表中，哈希地址空间是指___。
哈希函数的取值范围
评价哈希函数好坏的标准是___。
哈希函数的取值均匀
构建哈希表的关键是、____、和、____、。
选择好的哈希函数、处理冲突的方法
哈希冲突是指同一个关键字对应多个不同的哈希地址。
正确答案:否
哈希冲突是指多个不同一个关键字对应相同的哈希地址。
哈希表中所有的哈希地址是连续的。
正确答案:是
哈希表发生冲突是由于选取的解决冲突的方法不当造成的。
正确答案:否
哈希表发生冲突是由于选取的哈希函数不合适造成的。
哈希表查找的时间性能可以达到O(1)，为什么在查找时不总是使用哈希表查找？
哈希表查找的时间性能O(1)是理想情况下的性能，在实际应用中的时间性能随数据量和数据分布情况的变化而变化，极端情况下也是O(n)的时间性能。而且采用开放定址法构造的哈希表要保证一定的空闲单元的比例，是以牺牲空间来换取时间的。
什么是哈希冲突？处理冲突的方法是什么？
在哈希表中，若某个哈希函数h对于不相等的关键字key1和key2得到相同的哈希地址（即h(key1)=h(key2)），将该现象称为冲突。
解决冲突的主要方法有开放定址法和拉链法。
为什么哈希表不支持元素之间的顺序查找？
哈希表是通过哈希地址来查找对应关键字的记录的，对哈希表来说顺序查找没有任何意义，也没有提供顺序查找机制。
在含有n个结点的二叉排序树中查找某关键字的结点时，最多进行（ ）次比较。
A.n/2
B.log2n
C.log2n+1
D.n
正确答案D
n个结点的二叉排序树的高度可能为n。
用n个关键字构造的一棵二叉排序树，其最低高度为（ ） 。
A.n/2
B.n
C.log2n
D.log2n+1
正确答案D
二叉排序树的最低高度与对应的平衡二叉树的高度相同。
用n个关键字构造的一棵二叉排序树，经过i次关键字比较成功找到的元素个数最多为（ ）。
A.i
B.2i
C.2i-1
D.2i-1
正确答案C
二叉排序树中第i层最多有2i-1个结点。
二叉排序中，最小关键字结点 （ ）。
A.没有左孩子结点
B.没有右孩子结点
C.一定没有左右孩子结点
D.一定存在左右孩子结点
正确答案A
在二叉排序中，最小关键字结点是中序序列的第一个结点，即根结点的最左下结点。
二叉排序中，最大关键字结点的 （ ） 。
A.没有左孩子结点
B.没有右孩子结点
C.一定没有左右孩子结点
D.一定存在左右孩子结点
正确答案B
在二叉排序中，最大关键字结点是中序序列的最后结点，即根结点的最右下结点。
二叉排序树的性质是指___。
左子树上所有结点的关键字均小于根结点关键字；右子树上所有结点的关键字均大于根结点的关键字
在二叉排序树中，关键字最小的结点是根结点的___。
最左下结点
在二叉排序树中，关键字最大的结点是根结点的___。
最右下结点
对二叉排序树进行___遍历，可以得到接关键字从小到大排列的结点序列。
中序
对一棵二叉排序树进行这样的遍历：遍历右子树、访问根结点、遍历左子树，则得到的遍历序列是___。
按关键字递减排列的有序序列
二叉排序树可以是一棵空树。
正确答案:是
二叉排序树是用来进行排序的。
正确答案:否
二叉排序树主要用于改进一般二叉树的查找效率。
在二叉排序树中，每个结点的关键字都比左孩子关键字大，比右孩子关键字小。
正确答案:是
二叉排序树的任意一棵子树中，关键字最小的结点必无左孩子，关键字最大的结点必无右孩子。
正确答案:是
二叉排序树的任意一棵子树也是二叉排序树。
每个结点的关键字都比左孩子关键字大，比右孩子关键字小，这样的二叉树一定是二叉排序树。
正确答案:否
对于二叉排序树，左子树上所有结点的关键字均小于根记录的关键字；右子树上所有结点的关键字均大于根记录的关键字。而不是仅仅与左、右孩子的关键字进行比较。
和折半查找相比，二叉排序树查找的优缺点各是什么？
二叉排序树的缺点是可能变得非常不平衡，从而导致查找时间退化为O(n)。优点是对于插入和删除操作效率高。
有一棵二叉排序树按先序遍历得到的序列为：(50,38,30,45,40,48,70,60,75,80)。回答以下问题：
（1）画出该二叉排序树。
（2）在等概率下，求查找成功的平均查找长度和查找不成功的平均查找长度。
（1）先序遍历得到的序列为：(50,38,30,45,40,48,70,60,75,80)，中序序列是一个有序序列，所以为：(30,38,40,45,48,50,60,70,75,80)，由先序序列和中序序列可以构造出对应的二叉树，如图1所示。
由二叉排序树的构造过程可以看出，一棵二叉排序树的先序序列即为构造该树的序列，因为在二叉排序树中插入一个结点的过程是：先和根结点比较，小于根结点时插入到左子树，大于根结点时插入到右子树，所以按照(50,38,30,45,40,48,70,60,75,80)构造一棵二叉排序树即可。
（2）ASL成功=(1×1+2×2+4×3+3×4)/10=9。
ASL不成功=(5×3+6×4)/11=55。
将二叉排序树T的先序序列中的关键字依次插入到一棵空的二叉排序树中，所得到的二叉排序树T'与T相同？为什么？
二叉排序树T'与T相同。
因为二叉排序树属于二叉树，其先序序列的第一个元素一定是二叉排序树的根，而对应先序序列的根后面所有元素分为两组：从根的后一元素开始的其值小于根的值的一组元素就是树的左子树的结点的先序序列，剩下的元素的值大于根的值，即为树的右子树的结点的先序序列。
在把先序序列的元素依次插入初始为空的二叉排序树时，第一个元素就成树的根，它后面第一组元素的值都小于根结点的值，可以递归建立根的左子树；第二组元素的值都大于根结点的值，可以递归建立根的右子树。
证明一棵非空二叉排序树的中序遍历序列是从小到大有序的。
证明：设中序遍历序列为：
R1,R2,R3,…,Ri,…,Rj,…,Rn（1）
并假设Rj＜Ri，根据二叉排序树的生成规则：Ri、Rj一定是以某一结点Rk为根的子树中的结点。不妨设在生成二叉排序树时，Ri先于Rj输入，而且Ri≥Rk（Ri＜Rk的情况类似）。这样Ri输入后一定是Rk右子树中的结点。在Rj输入时，若Rj≥Rk，则Rj也成为Rk右子树的结点，但由于Rj＜Ri，所以，Rj不可能成为Ri右子树中的结点。若Rj＜Rk，则Rj成为Rk左子树中的结点，这样按中序遍历所得序列为：
…,Rk,…,Rj,…,Ri,…（2）
或：
…,Rj,…,Rk,…,Ri,… （3）
这样，（2）、（3）两式与（1）式矛盾，所以当Rj＜Ri时命题成立。同理可以证明Rj先于Ri输入的情况。
证明如果一棵非空二叉树的中序遍历序列是从小到大有序的，则该二叉树是一棵二叉排序树。
证明：对于关键字为k的任一结点a，由中序遍历过程可知，在中序遍历序列中，它的左子树的所有结点的关键字排在k的左边，它的右子树的所有结点的关键字排在k的右边，由于中序序列是从小到大排列的，所以结点a的左子树中所有结点的关键字小于k，结点a的右子树中所有结点的关键字大于k，这满足二叉排序树的性质，所以该二叉树是一棵二叉排序树。
静态查找表和动态查找表的区别是（ ） 。
A.它们的逻辑结构相同
B.施加其上的操作不同
C.所包含的数据元素的类型不同
D.存储实现不同
正确答案B
由支持修改运算（或操作）来确定存放数据元素的表是静态查找表还是动态查找表。
查找效率低的数据结构是（ ）。
A.有序顺序表
B.二叉排序树
C.堆
D.二叉平衡树
正确答案C
堆查找的时间复杂度为O(n)，所以效率最低。
如果一个表既能较快地查找，又能适应动态变化的要求，则可采用（ ）。
A.有序表
B.线性表
C.哈希表
D.二叉平衡树
正确答案D
满足这种条件的表为树表，各选项中只有二叉平衡树是一种树表。
顺序查找法适合于存储结构为（ ）的线性表。
A.哈希存储
B.顺序存储或链式存储
C.压缩存储
D.索引存储
正确答案B
顺序查找可以从前向后或从后向前依次查找，既适合于顺序存储结构也适合于链式存储结构。
采用顺序查找方法查找长度为n的线性表时，成功查找的平均查找长度为 （ ）。
A.n
B.n/2
C.(n+1)/2
D.(n-1)/2
正确答案C
解：顺序查找时，元素ai需i次比较，成功查找的平均查找长度=(1+2+…+n)/n=(n+1)/2。
顺序查找方法适用于存储结构为、____、的线性表，而使用折半查找方法的条件是、____、。
顺序表或链表、存储结构为顺序表的有序表
顺序查找算法的时间复杂度为___。
O(n)
和顺序查找方法相比，折半查找的主要缺点是___。
只能在有序的顺序表上进行
采用顺序查找方法查找含n个元素的顺序表，最好情况下的关键字比较次数是___。
1
最好情况是第一个元素就是要找的元素。
采用顺序查找方法查找含n个元素的顺序表，若查找成功，则比较关键字的次数最多为、____、次；若查找不成功，则比较关键字的次数为、____、次。
n、n
顺序查找时，找到表尾元素需要比较n次，不成功查找总是比较n次。
对于不同的存储结构，应采用不同的查找方法。
正确答案:是
对于满足折半查找和分块查找条件的文件而言，无论该文件存放在任何介质上，均能进行顺序查找、折半查找和分块查找。
正确答案:否
在顺序存储的物理介质如磁带上，只能进行顺序查找，即便文件有序，也不能进行折半查找。
顺序查找法适用于存储结构为顺序或链式存储的线性表。
正确答案:是
顺序查找方法只能在顺序存储结构上进行。
正确答案:否
顺序查找方法也可以在链表存储结构上进行。
顺序查找方法只能从顺序表的前端向后端查找。
正确答案:否
顺序查找方法可以从顺序表的前端向后端查找，也可以从顺序表的后端向前端查找。
简述静态查找表和动态查找表的异同。
静态查找表和动态查找表都是数据存储结构，都适合数据查找，前者不便于（并不是不能）数据修改操作，如插入和删除元素，后者方便数数据修改操作。
设有5个数据do、for、if、repeat、while，它们排在一个有序表中，其查找概率分别是p1=2，p2=15，p3=1，p4=03，p5=01。而查找它们之间不存在数据的概率分别为q0=2，q1=15，q2=1，q3=03，q4=02，q5=01，如下图所示：
（1）试画出对该有序表分别采用顺序查找和折半查找时的判定树。
（2）分别计算顺序查找的查找成功和不成功的平均查找长度。
（3）分别计算折半查找的查找成功和不成功的平均查找长度。
（1）对该有序表分别采用顺序查找和折半查找时的判定树分别如图2和3所示。
（2）对于顺序查找：
ASL成功=(1p1+2p2+3p3+4p4+5p5)=97。
ASL不成功=(1q0+2q1+3q2+4q3+5q4+5q5)=07。
（3）对于折半查找：
ASL成功=(1p3+2(p1+p4)+3(p2+p5))=04。
ASL不成功=(2q0+3q1+3q2+2q3+3q4+3q5)=3。
折半查找对查找的数据有什么要求？
从存储结构来看，折半查找要求数据采用具有随机存取特性的存储结构来存储。
从数据的有序来看，折半查找要求数据是有序的。
设有100个元素的有序表，用折半查找时，不成功时最大的比较次数是 （ ） 。
A.25
B.50
C.10
D.7
正确答案D
不成功时最大的比较次数=log2(n+1)=7。答案为D。
在一棵m阶B树中删除一个关键字会引起合并，则该结点原有（ ）个关键字。
A.1
B.m/2
C.m/2-1
D.m/2+1
正确答案C
在一棵m阶B树中每个内部结点的关键字个数为m/2-1～m-1，删除一个关键字会引起合并，则该结点中关键字个数一定是最少的情况。答案为C。
哈希查找方法一般适用于（ ） 情况下的查找。
A.查找表为链表
B.查找表为有序表
C.关键字集合比地址集合大得多
D.关键字集合与地址集合之间存在着某种对应关系。
正确答案D
哈希表通过哈希函数和冲突解决函数确定存储地址的，适合关键字集合与地址集合之间存在着某种对应关系的数据集的存储与查找。答案为D。
有一棵二叉排序树按先序遍历得到的序列为（12，5，2，8，6，10，16，15，18，20）。回答以下问题：
（1）画出该二叉排序树。
（2）给出该二叉排序树的后序遍历序列。
（3）求在等概率下的查找成功和不成功情况下的平均查找长度。
（1）该二叉排序树的先序序列为(12，5，2，8，6，10，16，15，18，20)，中序序列是一个有序序列，所以为(2，5，6，8，10，12，15，16，18，20)，由先序序列和中序序列可以构造出对应的二叉树，如图A.4所示。
（2）后序遍历序列为：2，6，10，8，5，15，20，18，16，12。
（3）ASL成功=(1×1+2×2+4×3+3×4)/10=29/10。
ASL不成功=(5×3+6×4/11=39/11。
哈希表中出现的哈希冲突是指( )。
A.两个元素具有相同的序号
B.两个元素的关键字不同，而其他属性相同
C.数据元素过多
D.两个元素的关键字不同，而对应的哈希函数值相同
正确答案D
哈希冲突也称为同义词冲突，是指两个元素的关键字不同，而对应的哈希函数值相同。答案为D。
适合于折半查找的数据组织方式是( )。
A.以链表存储的线性表
B.以顺序表存储的任意线性表
C.以链表存储的有序线性表
D.以顺序表存储的有序线性表
正确答案D
折半查找的元素序列一定是有序的，并且采用具有随机存取特性的存储结构存储。答案为D。
假设一棵二叉排序树的关键字为单个字母，其后序遍历序列为ACDBFIJHGE，回答以下问题：
（1）画出该二叉排序树。（）
（2）求在等概率下的查找成功的平均查找长度。（）
（3）求在等概率下的查找不成功的平均查找长度。（）
（1）该二叉排序树的后序序列为ACDBFIJHGE，其中序序列是一个递增有序序列，所以中序序列为ABCDEFGHIJ，由后序序列和中序序列构造的二叉排序树如图A.6所示。
（2）考虑二叉排序树中的10个内部结点，累加找到某个结点需要的关键字比较次数，再除以10得到成功时的平均查找长度：
ASL成功=(1×1+2×2+4×3+2×4+1×5)/10=3。
（3）考虑二叉排序树中的11个外部结点，累加找到某个结点需要的关键字比较次数，再除以11得到不成功时的平均查找长度：
ASL不成功=(6×3+3×4+2×5)/11=64。
6
对含有n个元素的顺序表采用顺序查找方法，不成功时的比较次数是( )。
A.1
B.n
C.n-1
D.n+1
正确答案B
不成功时的比较次数总是n。答案为B。
含有20个结点的AVL树的最大高度是( )。
A.4
B.5
C.6
D.7
正确答案C
设Nh表示高度为h的平衡二叉树中含有的最少结点数，有N1=1，N2=2，Nh=Nh-1+Nh-2+1，求出N6=20。答案为C。
在一棵m阶B树中插入一个关键字会引起分裂，则该结点原有( )个关键字。
A.1
B.m
C.m-1
D.m/2
正确答案C
在一棵m阶B树中每个内部结点的关键字个数为m/2-1～m-1，插入一个关键字会引起分裂，则该结点中关键字个数一定是最多的情况。答案为C。
以下关于哈希查找的叙述中正确的是( )_。
A.哈希查找中不需要任何关键字的比较
B.采用拉链法解决冲突时，查找每个元素的时间是相同的
C.哈希表在查找成功时的平均查找长度仅仅与表长有关
D.哈希表的装填因子等于表中填入的元素个数除以哈希表的长度
正确答案D
装填因子等于表中填入的元素个数n除以哈希表的长度m。答案为D。
一棵二叉排序树的结构如图A.8所示，其中各结点的关键字依次为32～40，请标出各结点的关键字。
答：任何二叉排序树的中序序列是递增的，即该二叉排序树的中序序列为32，33，34，35，36，37，38，39，40，填入后得到如图A.11所示的二叉排序树。
一组关键字为（5，11，7，2，3，17），利用堆排序方法建立初始大根堆，给出你建立的初始大根堆对应的关键字序列。
答：（5，11，7，2，3，17）对应的完全二叉树如图A.12左图所示，调整为初始大根堆如图A.12右图所示，对应的关键字序列为（17，11，7，2，3，5）。
设有100个元素的有序顺序表，采用折半查找方法，不成功时最大的比较次数是 （ ） 。
A.25
B.50
C.10
D.7
正确答案D
不成功时最大比较次数为log2(n+1)=log2101=7。答案为D。
在任意一棵非空二叉排序树T1中，删除某结点v之后形成二叉排序树T2，再将v 插入T2形成二叉排序树T3。下列关于T1与T3的叙述中，正确的是 （ ） 。
I. 若v是T1的叶子结点，则T1与T3不同
II. 若v是T1的叶子结点，则T1与T3相同
III. 若v不是T1的叶子结点，则T1与T3不同
IV. 若v不是T1的叶子结点，则T1与T3相同
A.仅I、III
B.仅I、IV
C.仅II、III
D.仅II、IV
正确答案C
在一棵二叉排序树中删除一个结点后再将此结点插入到二叉排序树中，如果删除的结点是叶子结点，那么在插入结点后，后来的二叉排序树与删除结点之前相同。如果删除的结点不是叶子结点，那么再插入这个结点后，后来的二叉树可能发生变化，不再相同。答案为C。
输入关键字序列（16，3，7，11，9，26），给出构造一棵AVL树的步骤。
答：建立AVL树的过程如图A.17所示（图中加阴影的结点表示要调整的结点）。
二分查找和二叉排序树查找的时间性能（ ） 。
A.完全相同
B.有时不同
C.完全不同
D.数量级都是O(log2n)
正确答案B
问题规模为n时，二分查找的时间复杂度为O(log2n)，而二叉排序树查找与树高相关，介于O(log2n)～O(n)，所以二分查找和二叉排序树查找的时间性能不是完全相同，也不是完全不同，只能说有时不同。答案为B。
7
关于m阶B树说法错误的是（ ） 。
A.m阶B树是一棵平衡的m叉树
B.B树中的查找无论成功都必须找到最下层结点
C.根结点最多含有m棵子树
D.根结点至少含有2棵子树
正确答案B
B树中成功的查找会落在某个内部结点中，失败的查找会落在某个外部结点中。答案为B。
设有一组关键字{32，13，49，24，38，21，4，12}，其哈希函数为：H(key)=key % 7，采用开放地址法的线性探查法解决冲突，试在0～9的哈希地址空间中对该关键字序列构造哈希表，并求等概率下查找成功和查找失败的平均查找长度。
SL成功=(1+2+1+1+3+1+4+4)/8=17/8
ASL不成功=(3+2+1+7+6+5+4)/7=4
正确答案
答：构造哈希表的过程如表A.2所示，得到的哈希表如表A.3所示。
求等概率下查找成功和查找失败的平均查找长度如下：
ASL成功=(1+2+1+1+3+1+4+4)/8=17/8
ASL不成功=(3+2+1+7+6+5+4)/7=4
假设一棵非空二叉排序树（左子树结点的关键字小于根结点关键字，右子树结点的关键字大于根结点关键字，树中没有关键字重复的结点）采用二叉链存储，结点类型如下：
class BSTNode:#二叉排序树结点类
def __init__(self,k,d=None,l=None,r=None): #构造方法
self.key=k #存放关键字,假设关键字为int类型
self.lchild=l #存放左孩子指针
self.rchild=r #存放右孩子指针
设计一个尽可能高效的算法输出该二叉排序树中所有关键字在x，y之间（x<y，含x和y）的关键字。
解：由于二叉排序树的中序遍历序列是一个递增排序序列，所以采用中序遍历求解。设计solve(b，x，y)算法用于输出二叉排序树b中所有在x，y之间的关键字，一旦访问到大于y的结点，则返回True，在遍历结点b的左子树时，如果其返回值为True，则直接返回True，不必遍历其右子树，从而提高效率。例如如图A.23所示的一棵二叉排序树，若x=2，y=5，则中序遍历中访问到结点6时返回True，仅仅访问图中带阴影的结点。
对应的算法如下：
def solve(b,x,y):
if b==None:#空树返回False
return False
if solve(b.lchild,x,y): #处理左子树
return True
if x<=b.key<=y: #当前结点满足条件，输出其关键字
print(b.key,end=' ')
if b.key>y: #一旦找到大于y的结点，返回True
return True
return solve(b.rchild,x,y) #处理右子树
假设有k个关键字互为同义词，若用线性探测法把这k个关键字存入哈希表中，至少要进行 ( )次探测。
A.k-1
B.k
C.k+1
D.k(k+1)/2
正确答案D
最少探测的情况是，第一个同义词放在哈希表ha[d]位置，探测1次，第2个同义词放在哈希表ha[d+1]位置，探测2次，以此类推，第k个同义词放在哈希表ha[d+k-1]位置，探测k次，总的探测次数=1+2+…+k=k(k+1)/2。答案为D。
设整数序列D=（1，12，5，8，3，10，7，13，9），试完成下列各题：
（1）依次取D中各整数为关键字，构造一棵二叉排序树bt。
（2）如何依据此二叉树bt得到D的一个有序序列。
（3）画出在二叉树bt中删除12后的树结构。
答：（1）构造的二叉排序树bt如图A.27(a)所示。
（2）D的有序序列为bt的中序遍历次序，即1、3、5、7、8、9、10、12、13。
（3）为了删除结点12，找到其左子树中的最大结点10（其双亲结点为8），将该结点删除并用10代替12，删除后的结果如图A.27(b)所示。
当采用分块查找时，数据的组织方式为 ( ) 。
A.数据分成若干块，每块内数据有序
B.数据分成若干块，每块内数据不必有序，但块间必须有序，每块内最大（或最小）的关键字组成索引块
C.数据分成若干块，每块内数据有序，每块内最大（或最小）的关键字组成索引块
D.数据分成若干块，每块中的数据个数必须相同
正确答案B
分块查找的数据组织方式为：数据表+索引表，数据表分块，块间有序，块内无序。答案为B。
在任意一棵非空二叉排序树T1中，删除某结点v之后形成二叉排序树T2，再将v 插入T2形成二叉排序树T3。下列关于T1与T3的叙述中，正确的是 ( ) 。
I. 若v是T1的叶子结点，则T1与T3不同
II. 若v是T1的叶子结点，则T1与T3相同
III. 若v不是T1的叶子结点，则T1与T3不同
IV. 若v不是T1的叶子结点，则T1与T3相同
A.仅I、III
B.仅I、IV
C.仅II、III
D.仅II、IV
正确答案C
在一棵二叉排序树中删除一个结点后再将此结点插入到二叉排序树中，如果删除的结点是叶子结点，那么在插入结点后，后来的二叉排序树与删除结点之前相同。如果删除的结点不是叶子结点，那么再插入这个结点后，后来的二叉树可能发生变化，不再相同。答案为C。
采用递归方式对顺序表进行快速排序，下列关于递归次数的叙述中，正确的是 ( ) 。
A.递归次数与初始数据的排列次序无关
B.每次划分后，先处理较长的分区可以减少递归次数
C.每次划分后，先处理较短的分区可以减少递归次数
D.递归次数与每次划分后得到的分区处理顺序无关
正确答案D
快速排序将一个无序序列划分为两个无序子序列，这两个无序子序列的排序是独立的，先排序哪一个都可以。答案为D。
简述堆和二叉排序树的区别。
答：以小根堆为例，堆的特点是双亲结点的关键字必然小于等于孩子结点的关键字，而两个孩子结点的关键字没有次序规定。而二叉排序树中，每个双亲结点的关键字均大于左子树结点的关键字，每个双亲结点的关键字均小于右子树结点的关键字，也就是说，每个双亲结点的左、右孩子的关键字有次序关系。
有一个关键字集合{53，30，37，12，45，24，96}，从空树开始逐个插入关键字来创建一棵二叉排序树，若希望高度最小，则应该选择哪个序列插入 （ ） 。
A.45，24，53，12，37，96，30
B.37，24，12，30，53，45，96
C.12，24，30，37，45，53，96
D.30，24，12，37，45，96，53
正确答案B
4个选项对应的关键字序列构造的4棵二叉排序树如图A.32所示，T2是一棵高度为3的满二叉树，高度最小。答案为B。
8
关于哈希表查找的说法中正确的是（ ） 。
A.采用拉链法解决冲突时，成功查找到任何一个关键字的元素的时间都是相同的
B.采用拉链法解决冲突时，若规定插入总是在链首，则插入任何一个关键字的元素的时间总是相同的
C.采用拉链法解决冲突时容易引起堆积现象
D.以上都不对
正确答案B
若哈希地址为0～m-1，序号为i（0≤i≤m-1）的单链表中的结点个数可能有多个，这样查找到任何一个关键字的结点的时间可能不同。拉链法解决冲突时不会出现堆积现象。答案为B。
设有一组关键字（32，15，2，7，14，13），其哈希函数是H(key)=key % 7。采用开放地址法的线性探测法解决冲突，试在0～8的哈希表中对该关键字序列构造哈希表，并求成功和不成功情况下的平均查找长度。
0=H(key)
dj+1=(dj+1) % m j=0，1，…
计算各关键字存储地址的过程如下：
H(32)=32 % 7=4
H(15)=15 % 7=1
H(2)=2 % 7=2
H(7)=7 % 7=0
H(14)=14 % 7=0冲突
d0=0，d1=(d0+1)%9=1仍冲突
d1=1，d2=(d1+1)%9=2仍冲突
d2=0，d3=(d1+1)%9=3
H(13)=13 % 7=6
正确答案
答：依题意，n=6，m=9，线性探测法计算下一地址计算公式为：
d0=H(key)
dj+1=(dj+1) % m j=0，1，…
计算各关键字存储地址的过程如下：
H(32)=32 % 7=4
H(15)=15 % 7=1
H(2)=2 % 7=2
H(7)=7 % 7=0
H(14)=14 % 7=0冲突
d0=0，d1=(d0+1)%9=1仍冲突
d1=1，d2=(d1+1)%9=2仍冲突
d2=0，d3=(d1+1)%9=3
H(13)=13 % 7=6
因此，构建的哈希表如表A.5所示。
表中探测次数即为相应关键字成功查找时所需比较关键字的次数，因此：
ASL成功=(1+1+1+4+1+1)/6=5
查找不成功表示在表中未找到指定关键字的元素。对于不属于（32，15，2，7，14，13）中的任意关键字x，H(x)的取值为0～6（共7种可能的取值），采用线性探测法解决冲突时的比较次数如表A.6所示，得到：
ASL不成功=(6+5+4+3+2+1+2)/7=23/7=29
首页
作业系统
考试系统
师资培训
课程题库
考研
问答
使用手册
第7章作业
总分：10
得分：9
图的遍历是指（ ） 。
A.访问图的所有顶点
B.以某种次序访问图的所有顶点
C.从一个顶点出发访问图中所有顶点且每个顶点只能访问一次
D.从一个顶点出发访问图中所有顶点但每个顶点可以访问多次
正确答案C
图的遍历是从给定的初始点出发访问每个顶点且每个顶点仅访问一次。
以下叙述中错误的是（ ）。
A.图的遍历是从给定的初始点出发访问每个顶点且每个顶点仅访问一次
B.图的深度优先遍历适合无向图
C.图的深度优先遍历不适合有向图
D.图的深度优先遍历是一个递归过程
正确答案C
图的深度优先遍历算法既适合无向图也适合有向图的遍历。
以下（ ）方法可用于求无向图的连通分量。
A.遍历
B.拓扑排序
C.Dijkstra算法
D.Prim算法
正确答案A
从图中某个顶点出发进行遍历，可将与该顶点相连通的所有顶点全部访问，也就找到了该顶点所在的连通分量。
如果从无向图的任一顶点出发进行一次深度优先遍历即可访问所有顶点，则该图一定是（ ）。
A.完全图
B.连通图
C.有回路
D.一棵树
正确答案B
对于无向图，从其中某个顶点出发进行一次深度优先遍历能够访问所有的顶点。
采用邻接表存储的图的深度优先遍历算法类似于二叉树的 （ ）算法。
A.先序遍历
B.中序遍历
C.后序遍历
D.层次遍历
正确答案A
当图变为二叉树时，深度优先遍历过程是访问起点（类似于访问根结点），访问起点的相邻点，再访问起点的相邻点的相邻点（类似于访问左子树），…，回溯回来时再访问起点的下一个相邻点（类似于访问右子树）。
已知一无向图G=（V，E），其中V={a,b,c,d,e } E={(a,b),(a,d),(a,c),(d,c),(b,e)}，现用某一种图遍历方法从顶点a开始遍历图，得到的序列为abecd，则采用的是___遍历方法。
深度优先
该无向图如图1所示，如果从a顶点出发进行广度优先遍历，最后的一个访问顶点一定是e。abecd只能通过深度优先遍历得到。
已知一无向图G=（V，E），其中V={a,b,c,d,e } E={(a,b),(a,d),(a,c),(d,c),(b,e)}，现用某一种图遍历方法从顶点a开始遍历图，得到的序列为adbce，则采用的是___遍历方法。
广度优先
该无向图如图2所示，如果从a顶点出发进行深度优先遍历，访问a、d后只能访问c，不可能访问b。
已知一无向图G=（V，E），其中V={a,b,c,d,e } E={(a,b),(a,d),(a,c),(d,c),(b,e)}，给出一种遍历序列___，从顶点a出发既可以通过深度优先遍历也可以通过广度优先遍历方式得到。
dcbe
正确答案
adcbe
该无向图如图2所示。从a顶点出发进行一次深度优先遍历：访问a，访问a的相邻点d，访问d的相邻点c，回退到a，访问b，最后访问b的相邻点e，得到adcbe的序列。
从a顶点出发进行一次广度优先遍历：访问a，访问a的相邻点d、c、b，最后访问b的相邻点e，得到adcbe的序列。
一个有n个顶点e条边的连通图采用邻接表表示，从某个顶点v出发进行深度优先遍历DFS(G,v)，则最大的递归深度是___。
n
由于图中有n个顶点，每个顶点递归调用一次，所以最大递归深度为n。
一个有n个顶点e条边的连通图采用邻接表表示，从某个顶点v出发进行广度优先遍历BFS(G,v)，则队列中最多的顶点个数是___。
n-1
如果图中某个顶点有n-1个相邻点，这n-1个相邻点都会进队。
图的遍历就是访问图中所有顶点。
正确答案:否
图的遍历是指以某种顺序访问图中所有顶点，且每个顶点仅访问一次。
任何一个图，一旦指定源点，其深度优先遍历序列是唯一的。
正确答案:否
图的深度优先遍历序列不一定是唯一的。
图的深度优先遍历算法仅对无向图适用。
正确答案:否
图的深度优先遍历算法对无向图和有向图都适用。
有向图的遍历不可采用广度优先遍历方法。
正确答案:否
广度优先遍历算法适合于有向图和无向图。
图的深度优先遍历算法和广度优先遍历算法是两种不同的算法，所以任何图的这两种遍历序列是不可能相同的。
正确答案:否
图的两种遍历序列可能相同。
某城市道路中大部分是双向马路，有少部分是单向马路。现构建该城市道路交通网用于道路规划，包括道路查找等。问是设计成有向图还是无向图？是带权图还是不带权图？
因为城市道路中有单向马路，只能用有向边来表示，双向马路可以转换成两条有向边。另外，在道路规划中涉及马路的长度，所以该城市道路交通网应设计成带权有向图。
有一个无向连通图，对于给定的某种邻接表表示，能否通过修改深度优先遍历算法求出所有的深度优先遍历序列？
不能。对于给定的无向连通图邻接表，其表示是不唯一的，不同的邻接表，通过修改深度优先遍历算法只能求出该邻接表下所有的深度优先遍历序列，除非构建所有可能的邻接表，才可能求出所有的深度优先遍历序列。
图的遍历对无向图和有向图都适用吗？
图的遍历对无向图和有向图都适用。但如果无向图不是连通的，或有向图不是强连通的，调用一次遍历算法只能访问一个连通分量或强连通分量中的顶点，这种情况下需要多次调用遍历算法。
图的深度优先遍历类似于树的先根遍历，可归属哪一类算法？
图的深度优先遍历类似于树的先根遍历，都属于回溯算法。由于图的深度优先遍历有可能在访问某个顶点后，沿着某条路径向前搜索又回到这个顶点，所以要设置一个访问标记数组visited记录已访问过的顶点，以避免重复访问，而树的先根遍历没有这种情形出现。
在一个图中，每个顶点的前趋顶点和后继顶点数可以有（ ）。
A.1个
B.2个
C.任意多个
D.0个
正确答案C
图中顶点之间是多对多的相邻关系。
2
在一个无向图中，所有顶点的度之和等于边数的（ ）倍。
A.1/2
B.1
C.2
D.4
正确答案C
在无向图中，一条边计入两个顶点的度数。
一个有n个顶点的无向图最多有（ ）条边。
A.n
B.n(n-1)
C.n(n-1)/2
D.2n
正确答案C
当为完全无向图时边数最多。
在一个具有n个顶点的无向连通图中至少有（ ）条边。
A.n
B.n+l
C.n-1
D.n/2
正确答案C
树图是边数最少的连通图，其边数=n-1。
图中所有顶点的度之和为图中边数的___倍。
2
有n个结点的无向图最少有___条边。
0
有n个结点的无向图最多有___条边。
n(n-1)/2
含有n个顶点的无向图都连通全部顶点至少需要___条边。
n-1
若含有n个顶点e条边无向连通图满足___，则称之为树图。
e=n-1
图是一种结点之间无层次关系的线性结构。
正确答案:否
图是一种非线性结构。
一个图中的路径是指该路径上的边不重复出现。
正确答案:否
一个图中的路径是指该路径上的顶点不重复出现。
在无向图中，如果顶点i到顶点j有路径，而顶点j到顶点k没有路径，则顶点i到顶点k也没有路径。
正确答案:是
顶点i和顶点j属一个连通分量，而顶点k属另一个连通分量，所以顶点i到顶点k没有路径。
在有向图中，如果顶点i到顶点j有路径，而顶点i到顶点k没有路径，则顶点j到顶点k也没有路径。
正确答案:是
如果顶点j到顶点k有路径，则顶点i有一条通过顶点j到达顶点k的路径，与题中条件矛盾。
n个顶点的无向图至多有n(n-1)条边。
正确答案:否
n个顶点的无向图至多有n(n-1)/2条边。
对于一个具有n个顶点的连通无向图，如果它有且只有一个回路，那么该图有几条边？为什么？
该图有n条边。
因为具有n个顶点n-1条边的连通无向图是树图，它没有任何回路，但两个顶点i和j之间有路径，如果加上一条边(i,j)，则形成一个回路，如果再加上一条边，则会形成两个回路。所以这样的图恰好有n条边。
有一个如图1（a）所示的有向图，回答以下问题：
（1）给出该图的所有强连通分量。
（2）给出从顶点0到顶点的所有路径。
（1）该有向图的强连通分量如图1（b）所示，共有4个强连通分量。
（2）顶点0到顶点的所有路径如下：
0→1→4→8
0→3→7→8
0→3→1→4→8
有一个如图2（a）所示的有向图，给出其所有的强连通分量。
图中顶点0、1、2构成一个环，这个环一定是某个强连通分量的一部分，图中顶点3、4构成一个环，这个环也一定是某个强连通分量的一部分，这两个环合在一起后能不能构成一个强连通分量呢？通过判断它们能够构成一个强连通分量。另外，顶点5、6各自构成一个强连通分量。该有向图的强连通分量有3个，如图2（b）所示。
一个图有7个顶点，编号为0～6，其邻接矩阵如下：
回答以下问题：
（1）画出该有向图。
（2）求顶点0的入度和出度。
（3）求顶点2的度。
（1）该有向图如图3所示。
（2）顶点0的入度为0，出度为3。
（3）顶点2的度为5。
图G是一个非连通无向图，共有28条边，则该图至少有多少个顶点？
由于G是一个非连通无向图，在边数固定时，顶点数最少的情况是该图由两个连通子图构成，且其中之一只含一个顶点，另一个为完全图。其中只含一个顶点的子图没有边，另一个完全图的边数为n(n-1)/2，即：n(n-1)/2=28，得：n=8。所以，该图至少有1+8=9个顶点。
一个无向连通图的生成树是含有该连通图的全部顶点的（ ）。
A.极小连通子图
B.极小子图
C.极大连通子图
D.极大子图
正确答案A
n个顶点的连通图的生成树有（ ）个顶点。
A.n-1
B.n
C.n+1
D.不确定
正确答案B
生成树包含图中所有的顶点。
4
若一个具有n个顶点和e条边的无向图是一个森林（n>e），则该森林必有 （ ）棵树。
A.e
B.n
C.n-e
D.1
正确答案C
设该森林有m棵树，结点个数分别为n1、n2、…、nm，则总顶点数n=n1+n2+…+nm，第i棵树的边数=ni-1，总边数=(n1-1)+(n2-1)+…+(nm-1)=n-m=e，所以m=n-e。
如果具有n个顶点的图恰好是一个环，则它有（ ）棵生成树。
A.n-1
B.n
C.n+1
D.2n
正确答案D
如果图恰好是一个环，对于图中每个顶点，都有顺时针和逆时针方向两棵生成树，总计2n棵生成树。
n个顶点的连通图的生成树有（ ） 条边。
A.n
B.n-1
C.n+1
D.不确定
正确答案B
对n个顶点的连通图来说，它的生成树一定有___条边。
n-1
一个连通图的生成树是该图的一个___。
极小连通子图
一个具有n个顶点的无向图是一个环，则它有___棵生成树。
2n
每个顶点顺时针和逆时针方向找遍所有顶点产生两种生成树。
一个带权连通图的最小生成树是该图的___。
所有生成树中权值之和最小的生成树
一个带权连通图的最小生成树___唯一的。
不一定是
连通图的生成树包含了图中所有顶点。
正确答案:是
一个连通图的生成树是唯一的。
正确答案:否
一个连通图的生成树可能有多棵。
对n个顶点的连通图G来说，如果其中的某个子图有n个顶点、n-1条边，则该子图一定是G的生成树。
正确答案:否
这样的子图不一定是连通的。
对于无向图生成树，从同一顶点出发所得到的生成树一定是相同的。
正确答案:否
无向图的生成树可能有多棵，从同一顶点出发所得到的生成树也不一定相同。
对于无向图生成树，其深度优先生成树和广度优先生成树一定不相同。
正确答案:否
不一定，如果一个无向图的生成树唯一，从同一顶点出发构造的深度优先生成树和广度优先生成树也是相同的。
使用普里姆算法构造出如图1所示的图G的一棵最小生成树。
使用Prim算法构造最小生成树的过程如图2所示。
已知带权连通图G=（V,E）的邻接表如图3所示，请画出该图的逻辑结构，并分别以深度优先和广度优先遍历该图，写出遍历中顶点的序列，并画出该图的一棵最小生成树，其中表结点的3个域各为：
<table data-tag='from-word' border='1' ><tr><td>顶点编号
</td><td>边上所带的权
</td><td>指针
</td></tr></table>
该图G的逻辑结构如图4所示。
从顶点1出发的深度优先遍历序列为：0、1、2、3、4。
从顶点1出发的广度优先遍历序列为：0、1、2、3、4。
采用普里姆算法（从顶点0出发）或克鲁斯卡尔算法求得的最小生成树如图5所示。
给出如图6所示的图中从顶点0开始的深度优先生成树，并求出最小生成树。
从顶点0开始的深度优先遍历序列很多，每一序列都生成一棵DFS树，除去重复的，其深度优先生成树及权值之和如下：
(0,1)，(1,2)，(2,4)，(4,5)，(5,3)，权值和为10+3+15+3+10=41
(0,1)，(1,2)，(2,4)，(4,3)，(4,5)，权值和为10+3+15+11+3=42
(0,1)，(1,3)，(3,5)，(5,4)，(4,2)，权值和为10+5+10+3+15=43
(0,1)，(1,3)，(3,4)，(4,2)，(4,5)，权值和为10+5+11+15+3=44
(0,3)，(3,1)，(1,2)，(2,4)，(4,5)，权值和为20+5+3+15+3=45
(0,3)，(3,5)，(5,4)，(4,2)，(2,1)，权值和为20+10+3+15+3=51
(0,3)，(3,4)，(4,5)，(4,2)，(2,1)，权值和为20+11+3+15+3=52
(0,5)，(5,3)，(3,1)，(1,2)，(2,4)，权值和为2+10+5+3+15=35
(0,5)，(5,3)，(3,4)，(4,2)，(2,1)，权值和为2+10+11+15+3=41
(0,5)，(5,4)，(4,2)，(2,1)，(1,3)，权值和为2+3+15+3+5=28
(0,5)，(5,4)，(4,3)，(3,1)，(1,2)，权值和为2+3+11+5+3=24
其最小生成树为(0,5)，(5,4)，(4,3)，(3,1)，(1,2)。
对于如图7所示的带权无向图，给出利用普里姆算法（从顶点0开始构造）和克鲁斯卡尔算法构造出的最小生成树的结果。
利用普里姆算法从顶点0出发构造的最小生成树为：{(0,1),(0,3),(1,2),(2,5),(5,4)}。
利用克鲁斯卡尔算法构造出的最小生成树为：{(0,1),(0,3),(1,2),(5,4),(2,5)}。
已知世界6大城市为：北京（B）、纽约（N）、巴黎（P）、伦敦（L）、东京（T）、墨西哥城（M）。试在由表1给出的交通网中确定最小生成树，并说明所使用的方法及其时间复杂度。
构成的无向图如图8所示。产生的最小生成树如图9所示。使用普里姆算法的时间复杂度为O(n2)，其中n为图中顶点个数。使用克鲁斯卡尔算法的时间复杂度为O(elog2e)，其中e为图的边数。
一个含有n（n>0）个顶点的连通图采用邻接矩阵存储，则该矩阵一定是（ ）。
A.对称矩阵
B.非对称矩阵
C.稀疏矩阵
D.稠密矩阵
正确答案A
连通图是指任意两个顶点之间存在路径的无向图，其邻接矩阵一定是对称矩阵。答案为A。
设连通图有n个顶点e条边（e，n>0），若满足（ ），则图中一定有回路。
A.e≥n
B.e<n
C.e=n-1
D.2e≥n
正确答案A
一个有n个顶点e条边的无向图，若e=n-1时构成一个树图，若e<n-1则是不连通的，若e>n-1则一定存在回路。答案为A。
6
对于AOE网的关键路径，以下叙述（ ）是正确的。
A.任何一个关键活动提前完成，则整个工程一定会提前完成
B.完成整个工程的最短时间是从源点到汇点的最短路径长度
C.一个AOE网的关键路径一定是唯一的
D.任何一个活动持续时间的改变可能影响关键路径的改变
正确答案D
AOE网中的关键路径是从源点到汇点的最长路径，其长度为完成整个工程的最短时间。一个AOE网可能存在多条关键路径，若提前完成所有关键路径都包含的关键活动则整个工程一定会提前完成，但改变任何一个活动的持续时间可能影响关键路径的改变（因为此时关键路径可能发生改变）。答案为D。
对于图A.1所示的带权有向图采用Dijkstra算法求从顶点0到其他顶点的最短路径，要求给出求解过程，包括每一步的S集合、dist和path数组元素。
该图对应的邻接矩阵如下：
在求最短路径时，S（存放已经求出最短路径的顶点集），dist[]（存放最短路径长度）和path[]（存放最短路径）的变化过程如图A.3所示。最后得到的结果如下：
① 顶点0到顶点1的最短距离为5，最短路径为：0、4、1
② 顶点0到顶点2的最短距离为6，最短路径为：0、4、1、2
③ 顶点0到顶点3的最短距离为7，最短路径为：0、4、1、3
④ 顶点0到顶点4的最短距离为2，最短路径为：0、4。
下列关于图的叙述中，正确的是( )。
Ⅰ.回路是路径
Ⅱ.存储稀疏图，用邻接矩阵比邻接表更省空间
Ⅲ.若有向图中存在拓扑序列，则该图不存在回路
A.仅Ⅱ
B.仅Ⅰ、Ⅱ
C.仅Ⅲ
D.仅Ⅰ、Ⅲ
正确答案C
只有回路才是起始顶点和终止顶点相同的路径。存储稀疏图，用邻接表比邻接矩阵更省空间。若有向图中存在拓扑序列（包含全部顶点），则该图不存在回路。答案为C。
以下关于有向图的说法中，正确的是( )。
A.强连通图中任何顶点到其他所有顶点都有边
B.完全有向图一定是强连通图
C.有向图中任一顶点的入度等于出度
D.有向图边集的子集和顶点集的子集可构成原有向图的子图
正确答案B
强连通图是任何顶点到其他所有顶点都有路径而不一定有边。完全有向图中任意两个顶点之间都存在一条边，则一定是强连通图。有向图中任一顶点的入度不一定等于出度。一个有向图边集的子集和顶点集的子集不一定构成一个图。答案为B。
如果从无向图的某个顶点出发进行一次广度优先遍历即可访问所有顶点，则该图一定是( )。
A.完全图
B.连通图
C.有回路
D.一棵树
正确答案B
从无向图的某个顶点v出发进行一次广度优先遍历即可访问所有顶点，则说明v到该图的每个顶点都有路径，这样的无向图一定是连通图。答案为B。
用Dijkstra算法求一个带权有向图G中从顶点0出发的最短路径，在算法执行的某时刻，S={0，2，3，4}，下一步选取的目标顶点可能是( )。
A.顶点2
B.顶点3
C.顶点4
D.顶点7
正确答案D
Dijkstra算法执行中，一旦某个顶点v添加到S中，后面不再调整源点到v的最短路径。答案为D。
若用邻接矩阵存储有向图，矩阵中主对角线以下的元素均为零，则关于该图拓扑序列的结论是( )。
A.存在，且唯一
B.存在、且不唯一
C.存在，可能不唯一
D.无法确定存在
正确答案C
这样的有向图中只有顶点i到顶点j（i<j）可能有边，而顶点j到顶点i一定没有边，也就是说这样的有向图中一定没有回路，所以可以产生拓扑序列，但拓扑序列不一定唯一。答案为C。
对于如图A.5所示的带权连通图，给出利用普里姆算法（从顶点0开始构造）和克鲁斯卡尔算法构造出的最小生成树的结果（注意：按算法执行的顺序给出最小生成树的所有边，每条边用(i，j)表示）。
（2）若一个带权连通图有多棵最小生成树，其中恰好有两条最小边，那么这两条最小边一定出现在所有的最小生成树吗？
（3）若一个带权连通图有多棵最小生成树，其中恰好有三条最小边，那么这三条最小边一定都出现在所有的最小生成树吗？
（1）利用普里姆算法从顶点0出发构造最小生成树时，依次选择的边是(0，1)，(0，3)，(1，2)，(2，5)，(5，4)，构造的最终最小生成树为{(0，1)，(0，3)，(1，2)，(2，5)，(5，4)}。
利用克鲁斯卡尔算法构造最小生成树时，依次选择的边是(0，1)，(0，3)，(1，2)，(5，4)，(2，5)，构造的最终最小生成树为{(0，1)，(0，3)，(1，2)，(5，4)，(2，5)}。
（2）若一个带权连通图有多棵最小生成树，其中恰好有两条最小边，那么这两条最小边一定出现在所有的最小生成树中。
因为按照克鲁斯卡尔算法构造最小生成树的过程，首先选择这两条最小边一定不会出现回路。
（3）若一个带权连通图有多棵最小生成树，其中恰好有三条最小边，那么这三条最小边不一定都出现在所有的最小生成树中。
因为按照克鲁斯卡尔算法构造最小生成树的过程，首先选择其中两条最小边一定不会出现回路，但选择第三条最小边时可能出现回路。例如一个带权连通图中n=5，包含的3条最小边是(0,1):1，(1,2):1，(0,2):1，当选择前面两条最小边后再选择第3条最小边时出现了回路，这3条最小边并不能出现在任何最小生成树中。
对于不带权无向图的邻接矩阵来说，( )_。
A.第i行上、第i列上非零元素总数等于顶点i的度数
B.矩阵中的非零元素个数等于图中的边数
C.第i行上的非零元素个数和第i列的非零元素个数一定相等
D.邻接矩阵中非全零行的行数等于图中的顶点数
正确答案C
无向图的邻接矩阵是一个对称矩阵。答案为C。
有一个顶点编号为0～4的带权有向图G，现用Floyd算法求任意两个顶点之间的最短路径，在算法执行的某时刻，已考虑了0～2的顶点，现考虑顶点3，则以下叙述中正确的是( )。
A.只可能修改从顶点0～2到顶点3的最短路径
B.只可能修改从顶点3到顶点0～2的最短路径
C.只可能修改从顶点0～2到顶点4的最短路径
D.其他所有两个顶点之间的路径都可能被修改
正确答案D
在Floyd算法中，当初始化A和path数组后，迭代过程如下：
for k in range(g.n):#求Ak[i][j]
for i in range(g.n):
for j in range(g.n):
if A[i][j]>A[i][k]+A[k][j]:
A[i][j]=A[i][k]+A[k][j]
path[i][j]=path[k][j] #修改最短路径
理论上除了i=k（由于A[k][k]=0，A[k][j]>A[k][k]+A[k][j]不会成立）或者j=k（A[i][k]>A[i][k]+A[k][k]不会成立）外，其他A[i][j]都可能修改。答案为D。
7
若一个有向图中的顶点不能排成一个拓扑序列，则可断定该有向图 ( ) 。
A.是个有根有向图
B.是个强连通图
C.含有多个入度为0的顶点
D.含有顶点数目大于1的强连通分量
正确答案D
该图中存在回路，该回路构成一个强连通分量的一部分或全部。答案为D。
对于一个带权连通图G，可以采用Prim算法构造出从某个顶点v出发的最小生成树，问该最小生成树一定包含从顶点v到其他所有顶点的最短路径吗？如果回答是，请予以证明；如果回答不是，请给出反例。
答：不是。
反例是，对于如图A.13所示的带权连通图G，从顶点0出发构造的最小生成树如图A.14所示，而从顶点0到顶点的2的最短路径为02（路径长度为8），并不是最小生成树中的012（该路径长度为10）。
以下叙述中错误的是 （ ）。
A.图的遍历是从给定的初始点出发访问每个顶点且每个顶点仅访问一次
B.图的深度优先遍历适合无向图
C.图的深度优先遍历不适合有向图
D.图的深度优先遍历是一个递归过程
正确答案C
图的深度优先遍历适合无向图和有向图。答案为C。
对于有n个顶点的带权连通图，它的最小生成树是指图中任意一个 （ ） 。
A.由n-1条权值最小的边构成的子图
B.由n-l条权值之和最小的边构成的子图
C.由n个顶点构成的极大连通子图
D.由n个顶点构成的极小连通子图，且边的权值之和最小
正确答案D
最小生成树是图中所有顶点构成的极小连通子图，且边的权值之和最小。答案为D。
以下关于图拓扑排序的叙述中正确的是（ ） 。
Ⅰ.任何无环的有向图，其顶点都可以排在一个拓扑序列中。
Ⅱ.若n个顶点的有向图有唯一的拓扑序列，则其边数必为n-1。
Ⅲ.在一个有向图的拓扑序列中，若顶点a在顶点b之前，则图中必有一条边<a，b>
A.仅Ⅰ
B.仅Ⅰ、Ⅲ
C.仅Ⅱ、Ⅲ
D.Ⅰ、Ⅱ和Ⅲ
正确答案A
在一个有向图的拓扑序列中，若顶点a在顶点b之前，图中不一定有边<a，b>。答案为A。
用Dijkstra算法求一个图中单源最短路径时，图中边上的权值可以为正数，也可以为负数。该叙述正确吗？如果你认为正确，请证明；如果你认为不正确，请给出一个反例。
答：不正确。
因为Dijkstra算法是一种贪心算法，一旦求出源点v到某个顶点u的最短路径后，都是假设后面的路径更长，以后不再调整到顶点u的最短路径。若出现权值为负的边，就有可能在后面出现到顶点u的更短路径，而Dijkstra算法中不会考虑这样的路径。
如图A.16所示，求以顶点0为源点的最短路径，先选取顶点1，表示从顶点0到顶点1的最短路径长度为2，以后不再改变，然后选取顶点2，因为<2，1>的权值为负，需要修改0→1的最短路径为0→2→1，而Dijkstra算法没有这种回溯修改路径的能力，所以要求所有边上的权值必须大于0。
下面 （ ） 算法适合用于构造一个稠密图的最小生成树。
A.Dijkstra算法
B.Prim算法
C.Floyd算法
D.Kruskal算法
正确答案B
Prim算法和Kruskal算法用于构造一个带权连通图（顶点个数为n，边数为e）的最小生成树，前者的时间复杂度为O(n2)，后者的时间复杂度为O(elog2e)。答案为B。
（ ） 方法可以判断一个有向图存在回路。
A.求最小生成树
B.拓扑排序
C.求关键路径
D.求最短路径
正确答案B
可以采用深度优先遍历和拓扑排序来判断一个有向图存在回路，若一个有向图能够成功进行拓扑排序，即拓扑排序时产生所有顶点的拓扑序列，则该有向图中一定没有回路。答案为B。
已知一个不带权图G的邻接表如图A.18所示，针对该邻接表从顶点0出发进行深度优先遍历的结果是_（ ）__。
A.0，1，2，3，4
B.0，1，2，4，3
C.0，1，3，4，2
D.0，1，4，2，3
正确答案A
直接从顶点0出发进行深度优先遍历，得到的DFS序列为0，1，2，3，4。答案为A。
对于图A.19所示的带权有向图，若采用Dijkstra算法求从顶点a到其他顶点的最短路径和长度，第一条最短路径为：a→c，路径长度2，则求得的剩余最短路径依次是什么？（请按Dijkstra算法执行时产生最短路径的顺序，给出各最短路径及其长度）。
答：按Dijkstra算法执行时产生的其他最短路径如下：
第2条：a→c→f，长度为6
第3条：a→c→e，长度为10
第4条：a→c→f→d，长度为11
第5条：a→c→f→d→g，长度为14
第6条：a→b，长度为15
8
一个有向无环图G的拓扑序列为…，vi，…，vj，…，则不可能出现的情形是( ) 。
A.G中有边<vi，vj>
B.G中有一条从vi到vj的路径
C.G中没有边<vi，vj>
D.G中有一条从vj到vi的路径
正确答案D
拓扑序列为…，vi，…，vj，…，则vi到vj有边或者路径，如果存在从vj到vi的路径，则存在回路。答案为D。
假设在7个城市之间建造天然气输送网，7个城市分别用序号1～7来表示，已知两个城市之间的输气管道的费用如表A.4所示。
要求：
（1）在总费用最小的情况下设计出连通7个城市的天然气输送网。
（2）计算建造该天然气输送网的总费用是多少？
答：（1）建立的带权无向图如图A.25所示。要求在总费用最小的情况下设计出连通7个城市的天然气输送网，实际上就是构造该图的最小生成树，可以采用Prim算法和Kruskal算法。这里采用Prim算法从顶点1出发构造最小生成树的过程如图A.26所示，最小生成树中的边为(1，2)，(2，7)，(3，7)，(3，4)，(4，5)，(1，6)。
（2）累加最小生成树中所有边的费用得到总费用=6+4+9+5+10+12=46，所以总的费用为4600万元。
假设一个无向图是非连通的，采用邻接表作为存储结构，试设计一个算法，输出图中各连通分量的顶点序列。
解：采用某个遍历方法遍历非连通图，并输出各连通分量顶点序列。采用深度优先遍历的算法如下：
visited=[0]*MAXV
def DFSA(G):#非连通图的DFS
for i in range(G.n):
if visited[i]==0: #若顶点i没有访问过
print("一个连通分量顶点序列:",end=' ')
DFS(G,i)#从顶点i出发深度优先遍历
print()
def DFS(G,v): #邻接表G中从顶点v出发的深度优先遍历
print(v,end=' ') #访问顶点v
visited[v]=1#置已访问标记
for j in range(len(G.adjlist[v])): #处理顶点v的所有出边顶点j
w=G.adjlist[v][j].adjvex #取顶点v的一个相邻点w
if visited[w]==0:
DFS(G,w)#若w顶点未访问,递归访问它
说明：采用广度优先遍历亦可。
一个表示工程的AOE网中的关键路径 ( ) 。
A.必须是唯一的
B.可以有多条
C.可以没有
D.以上都不对
正确答案B
AOE网中的关键路径是源点到汇点的最长路径（至少有一条），可以有多条。答案为B。
用Prim算法求一个连通的带权图的最小生成树，在算法执行的某时刻，已选取的顶点集合U＝{1，2，3}，边的集合TE＝{(1，2)，(2，3)}，要选取下一条权值最小的边，不可能从 ( ) 组中选取。
A.{(1，4)，(3，4)，(3，5)，(2，5)}
B.{(1，5)，(2，4)，(3，5)}
C.{(1，2)，(2，3)，(3，1)}
D.{(1，4)，(3，5)，(2，5)，(3，4)}
正确答案C
采用Prim算法求最小生成树时，U={1，2，3}，V-U={4，5，…}，候选边只能是这两个顶点集之间的边。答案为C。
对于如图A.29所示的带权有向图，采用狄克斯特拉算法求出从顶点0到其他各顶点的最短路径及其长度，要求按求出最短路径的先后顺序给出结果。
答：采用狄克斯特拉算法时，按求出最短路径的先后顺序给出结果如下：
从0到1的最短路径长度为1，最短路径为0→1。
从0到3的最短路径长度为2，最短路径为0→3。
从0到2的最短路径长度为4，最短路径为0→1→2。
从0到4的最短路径长度为8，最短路径为0→1→4。
从0到5的最短路径长度为10，最短路径为0→3→5。
以下关于有向图的说法中，正确的是（ ） 。
A.强连通图是任何顶点到其他所有顶点都有边
B.完全有向图一定是强连通图
C.有向图中任一顶点的入度等于出度
D.有向图边集的子集和顶点集的子集可构成原有向图的子图
正确答案B
完全有向图中任意两个顶点之间都有一条边，一定是强连通图。答案为B。
用Dijkstra算法求一个带权有向图G中从顶点0出发的最短路径，在算法执行的某时刻，S={0，2，3，4}，下一步选取的目标顶点可能是 （ ）。
A.顶点2
B.顶点3
C.顶点4
D.顶点7
正确答案D
Dijkstra算法求出源点到某个顶点的最短路径并添加到S中后，后面不再以它作为目标顶点。答案为D。
有n个人，编号为1～n，给定m对（a，b）表示a和b是朋友，朋友的朋友也是朋友。编写一个程序求朋友圈的个数以及各个朋友圈的人数，每个朋友圈至少有两个人，朋友圈人数按递增顺序输出，其中n和m最大值不超过100。输入格式示例：
11 8#n=11，m=8
1 2#表示1和2是朋友
2 3
1 3
4 5
7 10
7 9
9 10
8 9
输出结果：
共有3个朋友圈
各朋友圈人数: [2, 3, 4]
解：采用列表G作为邻接表，G[i]（1≤i≤n）表示i的所有朋友列表，例如示例对应的G如下：
[None, [2, 3], [1, 3], [2, 1], [5], [4], None, [10, 9], [9], [7, 10, 8], [7, 9], None]
采用深度优先遍历求解，对应的程序如下：
def solve():#求解算法
global n,visited
ans=[]
for i in range(1,n+1):
if visited[i]==0:
cnt=DFS(G,i)
if cnt>1: ans.append(cnt)#人数多于1的计一个朋友圈
ans.sort()
return ans
def DFS(G,v): #邻接表G中从顶点v出发的深度优先遍历
global visited
cnt=1 #访问顶点v
visited[v]=1 #置已访问标记
if G[v]==None: return cnt#v没有朋友时返回
for j in range(len(G[v])): #处理顶点v的所有出边顶点j
w=G[v][j] #取顶点v的一个相邻点w
if visited[w]==0:
cnt+=DFS(G,w)#若w顶点未访问,递归访问它
return cnt
#主程序
n,m=map(int,input().split())#转换为整数序列
G=[None]*(n+1)
for i in range(m):
a,b=map(int,input().split())
if G[a]==None: G[a]=[]
if G[b]==None: G[b]=[]
G[a].append(b)
G[b].append(a)
visited=[0]*(n+1)
ans=solve()
print("共有%d个朋友圈" %(len(ans)))
print("各朋友圈人数:",ans)
说明：本题也可以采用广度优先遍历或者并查集求解。
首页
作业系统
考试系统
师资培训
课程题库
考研
问答
使用手册
第6章作业
总分：10
得分：9
以下关于二叉树遍历的说法中，正确的是（ ）。
A.二叉树遍历就是访问二叉树中所有的结点
B.二叉树遍历就是访问二叉树中部分结点
C.二叉树遍历就是按照某种规律访问二叉树中所有的结点，且每个结点仅访问一次
D.二叉树遍历就是随机访问二叉树中所有的结点，且每个结点仅访问一次
正确答案C
以下关于二叉树遍历的说法中，错误的是（ ）。
A.一棵二叉树中，若每个结点最多只有左孩子，没有右孩子，则先序和后序序列相同
B.一棵二叉树中，若每个结点最多只有左孩子，没有右孩子，则中序和后序序列相同
C.一棵二叉树中，若每个结点最多只有左孩子，没有右孩子，则先序和层次序列相同
D.一棵二叉树中，若每个结点最多只有右孩子，没有左孩子，则先序和中序序列相同
正确答案A
在二叉树中，先序序列为NLR，后序序列为LRN，若NLR=LRN，则需L和R均为空，所以选项A错误。
以下关于二叉树遍历的说法中，正确的是（ ）。
A.若某结点是二叉树中某个子树的中序序列的最后一个结点，则它一定是该子树先序序列的最后一个结点
B.若某结点是二叉树中某个子树的先序序列的最后一个结点，则它一定是该子树中序序列的最后一个结点
C.若一个叶子结点是二叉树中某个子树的中序序列的最后一个结点，则它一定是该子树先序序列的最后一个结点
D.若一个叶子结点是二叉树中某个子树的先序序列的最后一个结点，则它一定是该子树中序序列的最后一个结点
正确答案C
若一个叶子结点a是二叉树中某个子树T的中序序列的最后一个结点，它一定是该子树根结点的最右下结点，且它是叶子结点，则一定是该子树的先序序列的最后一个结点。
二叉树若用顺序存储结构表示，则下列4种运算中的 （ ）最容易实现。
A.先序遍历二叉树
B.中序遍历二叉树
C.层次遍历二叉树
D.根据结点的值查找其存储位置
正确答案C
在二叉树的顺序存储结构中，层次遍历只须从头到尾遍历一遍即可。
给定二叉树如图1所示。设N代表二叉树的根，L代表根结点的左子树，R代表根结点的右子树。若遍历后的结点序列为3,1,7,5,6,2,4，则其遍历方式是（ ）。
A.LRN
B.RNL
C.RLN
D.RNL
正确答案D
遍历后的结果是先右子树，再根结点，最后为左子树，即为RNL。本题答案为D。本题的其他3种遍历序列如下：
LRN（先左子树，再右子树，最后访问根结点）：4,6,7,5,2,3,1。
NRL（先访问根结点，再右子树，最后左子树）：1,3,2,5,7,6,4。
RLN（先右子树，再访问左子树，最后根结点）：3,7,6,5,4,2,1。
由二叉树的先序遍历序列和中序遍历序列，___唯一确定该二叉树。
能够
由二叉树的后序遍历序列和中序遍历序列，___唯一确定该二叉树。
能够
由二叉树的层次遍历序列和中序遍历序列，___唯一确定该二叉树。
能够
由二叉树的先序遍历序列和后序遍历序列，___唯一确定该二叉树。
不能
由二叉树某种遍历方式产生的结果是一个线性序列。
正确答案:是
非空二叉树的先序序列的最后一个结点一定是叶子结点。
正确答案:是
先序遍历过程是：根、左、右，如果一个结点是其最后一个结点，该序列后面一定没有结点了，则它一定没有左、右子树，是叶子结点。
非空二叉树的后序序列的最后一个结点一定是叶子结点。
正确答案:否
非空二叉树的后序序列的最后一个结点一定是根结点。
非空二叉树的中序序列的最后一个结点一定是叶子结点。
正确答案:否
中序序列的最后一个结点是根结点的最右下结点，不一定是叶子结点。
非空二叉树的中序序列的第一个结点一定是叶子结点。
正确答案:否
中序序列的最后一个结点是根结点的最左下结点，不一定是叶子结点。
对于以a为根结点的一棵二叉树，指出其先序遍历访问的第一个结点和最后一个结点各是什么？
先序遍历访问的第一个结点就是根结点a。
先序遍历按照根→左→右的次序遍历。对于任一个结点来说，如果有右孩子，则最后访问到该右孩子，如果没有右孩子只有左孩子，则最后访问到该左孩子，当且仅当它没有孩子时，才最后访问到该结点。由此，找先序序列最后一个访问结点的过程是：从根结点出发，不断走向其右孩子，当不再有右孩子时，若有左孩子，转向其左孩子，然后再不断走向其右孩子，依次类推，直到走到一个叶子结点，它就是先序序列最后一个访问结点。
（同答案）
对于以a为根结点的一棵二叉树，指出其中序遍历访问的第一个结点和最后一个结点各是什么？
中序遍历访问的第一个结点就是根结点a的最左下结点。
中序遍历访问的最后一个结点就是根结点a的最右下结点。
（同答案）
对于以a为根结点的一棵二叉树，指出其后序遍历访问的第一个结点和最后一个结点各是什么？
后序遍历按照左→右→根的次序遍历。对于任一个结点来说，如果有左孩子，最先遍历左子树，如果有右孩子，再遍历右子树，最后访问根结点，由此，找后序序列第一个访问结点的过程是：从根结点出发，不断走向其左孩子，当不再有左孩子时，若有右孩子，转向其右孩子，然后再不断走向其左孩子，依次类推，直到走到一个叶子结点，它就是后序序列第一个访问结点。
后序遍历访问的最后一个结点就是根结点a。
（同答案）
对于一棵非空二叉树，为什么只知道其先序序列和后序序列，还不能唯一确定该二叉树的形态？
因为二叉树的先序序列和后序序列都只确定了根结点的信息，而不能确定左、右子树的信息（左、右子树的结点个数），所以不能唯一确定该二叉树的形态。
（同答案）
若某非空二叉树的先序序列和后序序列正好相同，则该二叉树的形态是什么？
二叉树的先序序列是NLR，后序序列是LRN。要使NLR=LRN成立，则L和R均为空，所以满足条件的二叉树只有一个根结点。
（同答案）
以下关于二叉树的说法中正确的是（ ）。
A.二叉树中每个结点的度均为2
B.二叉树中至少有一个结点的度为2
C.二叉树中每个结点的度可以小于2
D.二叉树中至少有一个结点
正确答案C
二叉树可以为空，非空二叉树中每个结点的度可以小于2。
2
以下关于二叉树的说法中正确的是（ ）。
A.二叉树就是度为2的树
B.二叉树中不存在度大于2的结点
C.二叉树就是有序树
D.二叉树中每个结点的度都为2
正确答案B
二叉树可以为空，非空二叉树中每个结点的度都小于等于2。
以下关于二叉树的说法中正确的是（ ） 。
A.二叉树中度为0的结点个数等于度为2的结点个数加1
B.二叉树中结点个数必大于0
C.完全二叉树中任何结点的度为0或2
D.二叉树的度为2
正确答案A
二叉树的性质1，n0=n2+1。
按照二叉树的定义，具有3个结点的二叉树有（ ）种。
A.3
B.4
C.5
D.6
正确答案C
这样的二叉树总数为。
二叉树中所有结点的度之和等于结点数加（ ）。
A.0
B.1
C.-1
D.2
正确答案C
所有结点度之和=n-1。
一棵二叉树中不存在度___的结点。
大于2
一棵二叉树中，某结点即便只有一个孩子结点，也需要指出该孩子结点___。
左孩子还是右孩子结点
正确答案:是左孩子还是右孩子结点
一棵含有50个结点的二叉树，它的最小高度是___。
6
当为完全二叉树时高度最小，此时高度<imgstyle="max-width:70%;"src="https://cdnqingline.net/e1c197caa73a5ab7ad35abdf6dc0abba.png"/>
一棵含有50个结点的二叉树，它的最大高度是___。
50
最大高度的二叉树形态：每层只有一个结点，此时高度h=n=50。
一棵含有65个结点的高度最大的二叉树，第10层有___个结点。
1
最大高度的二叉树形态：每层只有一个结点，所以第10层的结点数=1。
n（n>2）个结点的二叉树中至少有一个度为2的结点。
正确答案:否
每一层只有一个结点的二叉树中就没有度为2的结点。
二叉树就是度为2的有序树。
正确答案:否
二叉树的子树有左、右之分，这不同于树。另外，二叉树的结点个数可以为0，而度为2的树至少有3个结点。
二叉树中每个度为2的结点的两棵子树都是有序的。
正确答案:是
二叉树的子树有左、右之分。
二叉树是一种特殊的树。
正确答案:否
二叉树和树都属于树形结构，但两者互不包含。
二叉树中每个结点至多有两个孩子结点，而一般树没有这种限制，所以二叉树是树的特殊情形。
正确答案:否
二叉树不是树的特殊情形，它们互不包含。
简述一棵度为2的有序树与一棵二叉树的区别。
两者的区别是：一棵度为2的有序树至少有3个结点，而二叉树的结点个数可以为0、一棵度为2的有序树中，度为1的结点无需区别左右，而二叉树中度为1的结点必须区别左右。
（同答案）
给出具有3个结点的不同形态的二叉树。
由n个结点构成的不同形态的二叉树个数为，这里n=3，计算出二叉树的个数为5。这些二叉树如图1所示。
（同答案）
存在这样的一棵二叉树，其结点总数为200，其中只有度为0和度为2的结点？为什么？
不存在。
这里n2=n0-1，n1=0，n=n0+n1+n2=2n0-1，所以n只能是奇数，而题中n=200为偶数，所以不存在这样的二叉树。
（同答案）
有n个结点并且高度为n的不同形态的二叉树个数是多少？
这里是求满足要求的不同形态的二叉树个数。显然，有n个结点并且高度为n的二叉树中每一层只有一个结点，除根结点外，其余每层的一个结点既可以作为其双亲结点的左孩子，也可以作为其双亲结点的右孩子，所以这样的二叉树的个数=1×2×…×2=2n-1，例如，当n=3时有22=4个这样的二叉树。
（同答案）
含有60个叶子结点的二叉树的最小高度是多少？
在该二叉树中，n0=60，n2=n0-1=59，n=n0+n1+n2=119+n1，当n1=0且为完全二叉树时高度最小，此时高度h=log2(n+1)= log2120=7。所以含有60个叶子结点的二叉树的最小高度是7。
（同答案）
设有13个权值，用它们组成一棵哈夫曼树，则该哈夫曼树共有（ ）个结点。
A.13
B.12
C.26
D.25
正确答案D
具有n个叶子结点的哈夫曼树共有2n-1个结点。
4
设有一棵哈夫曼树的结点总数为35，则该哈夫曼树共有（ ） 个叶子结点。
A.18
B.20
C.35
D.30
正确答案A
2n0-1=35，则n0=18。
若一棵度为m的哈夫曼树有n个叶子结点，则非叶子结点的个数是（ ）。
A.n-1
B.n/m-1
C.(n-1)/(m-1)
D.n/(m-1)-1
正确答案C
度为m的哈夫曼树中只有度为m和度为0的结点，结点总数N=n0+nm=n+nm，所有结点度之和=N-1=mnm，所以mnm= n+nm-1，nm=(n-1)/(m-1)，nm为整数，即nm=(n-1)/(m-1)。
哈夫曼树是___。
带权路径长度最小的二叉树
一棵哈夫曼树有32个叶子结点，则该树的总结点个数是___。
63
具有n个叶子结点的哈夫曼树共有2n-1个结点。
哈夫曼树中没有度为1的结点。
正确答案:是
哈夫曼树是带权路径长度最短的二叉树，权值越大的结点离根结点越远。
正确答案:否
哈夫曼树是带权路径长度最短的二叉树，权值越大的结点离根结点越近。
哈夫曼树中结点个数可以偶数也可以是奇数。
正确答案:否
n=2n0-1，所以n只能是奇数。
如果一棵哈夫曼树T有n0个叶子结点，那么，树T有多少个结点，要求给出求解过程。
一棵哈夫曼树中只有度为2和0的结点，没有度为1的结点，由非空二叉树的性质1可知，n0=n2+1，即n2=n0-1，则：总结点数n=n0+n2=2n0-1。
如果一棵哈夫曼树T的高度为h（h>1），问最少可以对几个字符进行编码？最多可以对几个字符进行编码？
哈夫曼树中只有度为2和0的结点，高度为h的哈夫曼树中叶子结点最少的情况况是，第1层只有一个根结点，第2～h层每层有2个结点，共计叶子结点个数为h。所以最少可以对h个字符进行编码
高度为h的哈夫曼树中叶子结点最多的情况况是构成一棵满二叉树，叶子结点集中在第h层，共计叶子结点个数为2h-1。所以最多可以对2h-1个字符进行编码。
树最适合用来表示（ ）。
A.有序数据元素
B.无序数据元素
C.元素之间具有分支层次关系的数据
D.元素之间无联系的数据
正确答案C
树的逻辑结构是层次结构。
5
现有一“遗传”关系，设x是y的父亲，则x可以把他的属性遗传给y。表示该遗传关系最适合的数据结构为（ ）。
A.数组
B.树
C.图
D.线性表
正确答案B
从遗传关系看，一个父亲可以有多个孩子，而一个孩子只能有一个父亲，这最适合用树来表示。
树是结点的有限集合，它 （ ）根结点，记为T。其余的结点分成为m（m≥0）个互不相交的集合T1、T2、…、Tm，每个集合又都是树，此时结点T称为Ti的双亲结点，Ti称为T的子树（1≤i≤m）。一个结点的子树个数为该结点的次数（或度）。
A.有0个或1个
B.有0个或多个
C.有且只有1个
D.有1个或1个以上
正确答案A
树是结点的有限集合，它有0个或1个根结点，记为T。其余的结点分成为m（m≥0）个（ ）的集合T1、T2、…、Tm，每个集合又都是树，此时结点T称为Ti的双亲结点，Ti称为T的子树（1≤i≤m）。一个结点的子树个数为该结点的次数（或度）。
A.互不相交
B.允许相交
C.允许叶结点相交
D.允许树枝结点相交
正确答案A
树是结点的有限集合，它有0个或1个根结点，记为T。其余的结点分成为m（m≥0）个互不相交的集合T1、T2、…、Tm，每个集合又都是树，此时结点T称为Ti的双亲结点，Ti称为T的子树（1≤i≤m）。一个结点的子树个数为该结点的（ ）。
A.权
B.维数
C.次数（或度）
D.序
正确答案C
树中任意结点允许有___孩子结点，除根结点外，其余结点___双亲结点。
有零个或多个、有且仅有一个
在一棵树中，A结点有3个兄弟结点，B结点是A结点的双亲结点，则B结点的度是___。
4
树中元素之间是多对多的关系。
正确答案:否
树中元素之间是一对多的关系。
树中每个结点都有唯一的前趋结点。
正确答案:否
树中除根结点外的每个结点都有唯一的前趋结点。
有一棵树的括号表示为A(B,C(E,F(G)),D)，回答下面的问题：
（1）这棵树的根结点是多少？
（2）这棵树的叶子结点是什么？
（3）结点C的度是多少？
（4）这棵树的度为多少？
（5）这棵树的深度是多少？
（6）结点C的孩子结点是哪些？
（7）结点C的双亲结点是谁？
该树对应的树形表示如图1所示，由相关定义得到本题答案为（1）A （2）B、E、G、D （3）2 （4）3 （5）4 （6）E、F （7）A。
（同答案）
若一棵度为4的树中度为2、3、4的结点个数分别为3、2、2，则该树的叶子结点的个数是多少？
结点总数n=n0+n1+n2+n3+n4，又由于除根结点外，每个结点都对应一个分支，所以总的分支数等于n-1。而度为i（0≤i≤4）的结点的分支数为i，所以有：总分支数=n-1=0×n0+1×n1+2×n2+3×n3+4×n4。综合两式得：n0=n2+2n3+3n4+1=3+2×2+3×2=14。
（同答案）
若一棵度为4的树中度为1、2、3、4的结点个数分别为4、3、2、2，则该树的总结点个数是多少？
结点总数n=n0+n1+n2+n3+n4，又由于除根结点外，每个结点都对应一个分支，所以总的分支数等于n-1。而度为i（0≤i≤4）的结点的分支数为i，所以有：总分支数=n-1=0×n0+1×n1+2×n2+3×n3+4×n4。综合两式得：n0=n2+2n3+3n4+1=3+2×2+3×2=14，则n=n0+n1+n2+n3+n4=14+4+3+2+2=25，所以该树的总结点个数是25。
（同答案）
引入线索二叉树的目的是（ ） 。
A.加快查找结点的前趋或后继结点的速度
B.为了能在二叉树中方便插入和删除
C.为了能方便找到双亲
D.使二叉树的遍历结果唯一
正确答案A
线索是前趋结点或后继结点的指针。
线索二叉树中的线索是指（ ） 。
A.左孩子
B.右孩子
C.指针
D.标识
正确答案C
线索是前趋结点或后继结点的指针。
二叉树线索化实质是将二叉链中___改为存放该结点前趋或后继结点的地址。
空指针域
一棵左右子树均不空的二叉树在先序线索化（不带头结点的线索化），后，其空指针域有___个。
1
将二叉树变为线索二叉树的过程称为线索化。
正确答案:是
简述为什么要建立线索二叉树。
二叉树遍历是常用的运算，按某种次序将二叉树中结点排成一个线性序列，如果每次寻找某个指定结点在某种顺序下的前趋和后继都重新遍历一次二叉树，将十分低效，希望只遍历一次，就把各结点的前趋和后继的信息记在树中，以后再寻找某结点的前趋和后继就很方便了，这就是线索二叉树的目的。
如图1（a）所示的二叉树B是由森林T转换而来的二叉树，那么森林T有（ ）个叶子结点。
A.4
B.5
C.6
D.7
正确答案C
将B还原为森林T，如图1（b）所示，其中有4棵树，C、D、F、G、I和J是叶子结点。
高度为h（h>0）的满二叉树对应的森林由（ ）棵树构成。
A.1
B.log2h
C.h/2
D.h
正确答案D
高度为h的满二叉树中，所有叶子结点的层次均为h，其根结点及其左下结点共有h个，所以还原成森林含有h棵树。
设森林F中有3棵树，第一、第二和第三棵树的结点个数分别为9、8和7，则与森林F对应的二叉树根结点的右子树上的结点个数是（ ）。
A.16
B.15
C.7
D.17
正确答案B
转换的二叉树中，根结点的右子树的结点由第二和第三棵树中的结点构成的，所以为8+7=15。
一棵树中两个兄弟a和b，转换成二叉树后，a、b之间的关系是___。
双亲－右孩子
一棵树中结点a的第一个孩子是结点b，转换成二叉树后，a、b之间的关系是___。
双亲－左孩子
给定一棵树T，可以找到唯一的一棵二叉树B与之对应。
正确答案:是
根据树到二叉树的转换规则可以得到这一结论。
给定一棵树T，将其转换成二叉树B后，它们的结点个数相同。
正确答案:是
根据树到二叉树的转换规则可以得到这一结论。
画出如图1（a）所示的树对应的二叉树。
对应的二叉树如图1（b）所示。
画出如图2（a）所示的二叉树还原成的森林。
该二叉树中根结点的右孩子有4个，所以还原成的森林包含4棵树，如图2（b）所示。
设一棵二叉树B是由森林T转换而来的，若T中有n个非叶子结点，则二叉树B中无右孩子的结点个数为n+1。
证明：树中每个非叶子结点转换成二叉树后都对应一个无右孩子的结点（因为一个非叶子结点至少有一个孩子结点，其最右边的孩子结点转换成二叉树后一定没有右孩子），另外，树的根结点转换成二叉树也没有右孩子，所以二叉树中无右孩子的结点个数为n+1。
一棵高度为h（h≥1）的完全二叉树至少有（ ）个结点。
A.2h-1
B.2h
C.2h+1
D.2h-1+1
正确答案A
这样的完全二叉树中第一层到第h-1层是满的，其结点个数=2h-1-1，第h层至少有一个结点，所以结果是2h-1-1+1=2h-1。答案为A。
一棵含有n个结点的线索二叉树中，其线索个数为 （ ） 。
A.2n
B.n-1
C.n+1
D.n
正确答案C
n个结点的二叉树采用二叉链存储时共有n+1个空指针，改为线索二叉树时这些空指针进改为线索。答案为C。
设一棵哈夫曼树中有1999个结点，该哈夫曼树用于对 （ ）个字符进行编码。
A.999
B.998
C.1000
D.1001
正确答案C
n=1999，哈夫曼树一定是一棵二叉树并且n1=0，则n0=n2+1（二叉树性质1），所以n=2n0-1，n0=(n+1)/2=1000，每个叶子结点对应一个编码的字符。答案为C。
假设非空二叉树采用二叉链存储结构，所有结点值均不相同，根结点为b，结点类型如下：
class BTNode: #二叉链中结点类
def __init__(self,d=None): #构造方法
self.data=d #结点值
self.lchild=None #左孩子指针
self.rchild=None #右孩子指针
设计一个算法判断其中值为x的结点与值为y的结点为兄弟结点，若是兄弟结点返回True，否则返回False。
解：值为x的结点和值为y的结点是兄弟的条件是它们有相同的双亲，可以采用任何一种二叉树遍历方法求解，采用基于先序遍历的算法如下：
def brother(b,x,y):
if b==None:#空树返回假
return False
if b.lchild!=None and b.rchild!=None:#结点b有左右子树
if (b.lchild.data==x and b.rchild.data==y) or (b.lchild.data==y and b.rchild.data==x):
return True#结点b是x、y结点的双亲，返回真
tag=brother(b.lchild,x,y)#在左子树中遍历
if tag: return True
else: return brother(b.rchild,x,y)#在右子树中遍历
设树T的度为4，其中度为1、2、3、4的结点个数分别为4、2、1、1，则T中的叶子结点个数是( )。
A.5
B.6
C.7
D.8
正确答案D
n1=4，n2=2，n3=1，n4=1，度之和=n-1=1×n1+2×n2+3×n3+4×n4=15，即n=16，而n0=n-n1-n2-n3-n4=16-4-2-1-1=8。答案为D。
一棵哈夫曼树用于100个字符的编码，则其中的结点个数是( )。
A.99
B.100
C.101
D.199
正确答案D
n0=100，n1=0，n2=n0-1=99，n=n0+n1+n2=100。答案为D。
设森林F中有4棵树，第1、2、3、4棵树的结点个数分别为a、b、c、d，将森林F转换为一颗二叉树B，则二叉树B中根结点的左子树上的结点个数是( )。
A.a-1
B.a
C.a+b+c
D.b+c+d
正确答案A
由森林F转换为一颗二叉树B，则二叉树B中根结点和其左子树上的所有结点来自第一棵树。答案为A。
假设非空二叉树采用二叉链存储结构，所有结点值均不相同，根结点为b，结点类型如下：
class BTNode: #二叉链中结点类
def __init__(self,d=None): #构造方法
self.data=d #结点值
self.lchild=None #左孩子指针
self.rchild=None #右孩子指针
请完成以下任务：
（1）设计一个算法在二叉树b中查找x结点（指结点值为x的结点），若找到该结点便返回其引用（地址），否则返回空。给出你设计的算法的时间复杂度。（）
（2）设计一个算法利用（1）小题设计的算法输出二叉树b中x结点的所有子孙结点值。（）
解：（1）采用先序遍历算法求解（其他遍历亦可），对应的查找算法如下：
def Findx(b,x): #查找x结点
if b==None:
return None #b为空时返回空
elif b.data==x:
return b #b所指结点值为x时返回b
else:
p=Findx(b.lchild,x) #在左子树中查找
if p!=None:
return p#在左子树中找到p结点，返回p
else:
return Findx(b.rchild,x) #返回在右子树中查找结果
上述算法的时间复杂度为O(n)。
（2）先在二叉树b中查找值为x的结点p，若p不空（找到了），再输出结点p的子树中除了p结点值外的其他结点值。对应的算法如下：
def OutSons(b,x): #输出x的所有子孙结点
p=Findx(b,x)#查找值为x的结点p
if p!=None:
__OutSons(p,x)#输出结点p的子孙
def __OutSons(b,x): #求x的所有子孙结点
if b!=None:
if b.data!=x:#输出除了x外的其他结点值
print(b.data,end=' ')
__OutSons(b.lchild,x)
__OutSons (b.rchild,x)
由权值分别为9、2、7、5的4个叶子结点构造一棵哈夫曼树，该树的带权路径长度为_( )。
A.23
B.44
C.37
D.27
正确答案B
构造的一棵哈夫曼树如图A.9所示，WPL=(2+5)×3+7×2+9×1=44。答案为B。
已知一棵二叉树的先序遍历序列为ABDGHCEIF，它的中序遍历序列是BGDHAEICF，请构造出这棵二叉树，并给出其层次遍历序列。
答：最后构造的二叉树如图A.10所示，其层次遍历序列为ABCDEFGHI。
设非空二叉树采用二叉链存储结构，其结点类型如下：
class BTNode:#二叉链中结点类
def __init__(self,d=None): #构造方法
self.data=d #结点值
self.lchild=None #左孩子指针
self.rchild=None #右孩子指针
设计一个算法判断根结点为b的二叉树是一棵满二叉树。
解：求出二叉树b的结点个数n和高度h，若2h-1=n，说明该二叉树是一棵满二叉树，否则不是满二叉树。对应的算法如下：
def Nodes(b): #求结点个数
if b==None:
return 0
return 1+Nodes(b.lchild)+Nodes(b.rchild)
def Height(b): #求高度
if b==None:
return 0
lh=Height(b.lchild)
rh=Height(b.rchild)
return max(lh,rh)+1
def Full(b):#判断为满二叉树
if b==None:
return True
n=Nodes(b)
h=Height(b)
if 2**h-1==n:
return True
else:
return False
一棵高度为h、结点个数为n的m（m≥3）次树中，其分支数是 （ ） 。
A.nh
B.n+h
C.n-1
D.h-1
正确答案C
任何树中除了根结点外每个结点恰好有一条指向双亲的分支，所以分支数=n-1。答案为C。
根据使用频率为5个字符设计的哈夫曼编码不可能是 （ ） 。
A.000，001，010，011，1
B.0000，0001，001，01，1
C.000，001，01，10，11
D.00，100，101，110，111
正确答案D
按哈夫曼编码恢复为哈夫曼树的方式，4个选项对应的二叉树如图A.15所示，其中T4中存在单分支结点，不可能是哈夫曼树。答案为D。
设二叉树中每个结点存放单个字符（每个结点值是唯一的），采用二叉链存储，其结点类型如下：
class BTNode: #二叉链中结点类
def __init__(self,d=None): #构造方法
self.data=d #结点值
self.lchild=None #左孩子指针
self.rchild=None #右孩子指针
设计一个算法求根结点b的二叉树中结点值为x的结点的兄弟，当b中不存在值为x的结点或者它不存在兄弟时返回空。
解：首先在根结点为b的二叉树中查找x的双亲结点，若存在这样的结点，再查找其兄弟结点。对应的算法如下：
def getparent(b,x): #找x结点的双亲结点
if b==None: return None
if b.lchild!=None and b.lchild.data==x:
return b
if b.rchild!=None and b.rchild.data==x:
return b
p=getparent(b.lchild,x)
if p!=None:
return p
else:
return getparent(b.rchild,x)
def getbrother(b,x): #x结点的兄弟
p=getparent(b,x)
if p==None: return None
if p.lchild!=None and p.lchild.data==x:
return p.rchild
if p.rchild!=None and p.rchild.data==x:
return p.lchild
若一棵有n个结点的树，其中所有分支结点的度均为k，该树中的叶子结点个数是（ ）。
A.n(k-1)/k
B.n-k
C.(n+1)/k
D.(nk-n+1)/k
正确答案D
依题意，m=k，n2=n3=…=nm-1=0，则n=n0+nk，度之和=n-1=knk，nk=(n-1)/k，所以n0=n-nk=n-(n-1)/k=(nk-n+1)/k。答案为D。
已知一棵二叉树中每个结点值为单个字符，其中序和后序序列分别为BFDJGACHKEI和FJGDBKHIECA，请画出该二叉树，并给出该二叉树的先序序列。
答：由中序序列BFDJGACHKEI和后序序列FJGDBKHIECA构造的二叉树如图A.20所示，对应的先序序列为ABDFGJCEHKI。
在一棵非空二叉树的先序序列和后序序列中，各叶子之间的相对次序关系 ( ) 。
A.不一定相同
B.都相同
C.都不相同
D.互为逆序
正确答案B
二叉树的先序遍历和后序遍历中，都是先遍历左子树再遍历右子树，所以各叶子之间的相对次序是相同的。答案为B。
下面关于哈夫曼树的说法，不正确的是( ) 。
A.对应于一组权值构造出的哈夫曼树可能不唯一
B.哈夫曼树具有最小带权路径长度
C.哈夫曼树中没有度为1的结点
D.哈夫曼树中除了度为2的结点外，还有度为1的结点和叶结点
正确答案D
构造哈夫曼树时每次都是两棵子树合并，没有度为1的结点。答案为D。
一棵高度为h的非空平衡二叉树，其每个非叶子结点的平衡因子均为0，则该树共有( )个结点。
A.2h-1-1
B.2h-1
C.2h-1+1
D.2h-1
正确答案D
这样的平衡二叉树恰好为一棵满二叉树。答案为D。
已知一棵度为m的树中有n1个度为1的结点，n2个度为2的结点，…，nm个度为m的结点，问该树中有多少个叶子结点？
答：依题意，设n为总结点个数，n0为叶子结点（即度为0的结点）个数，则有n=n0+n1+n2+…+nm，又有n-1=度之和=n1×1+n2×2+…+nm×m。两式相减得到1=n0-n2-2n3-…-(m-1)nm，则n0=1+n2+2n3+…+(m-1)nm=1+∑mi=2(i−1)ni
。
假设非空二叉树b采用二叉链存储结构存储（结点b为二叉树的根结点），试设计一个算法，输出该二叉树中从根结点出发的一条最长路径（假设其长度不超过100，当有多条最长路径时输出其中任意一条）。
解法1：由于二叉树中最长路径一定是从根结点到某个叶子结点的路径，求出根到每个叶子结点的路径，通过比较长度得出最长路径maxpath。采用递归先序遍历求解对应的算法如下：
MAXN=100
def MaxPath1(b): #采用先序遍历求一条最长路径
global maxpath
maxpath=[]
path=[None]*MAXN
_MaxPath1(b,path,0)
return maxpath
def _MaxPath1(b,path,pathlen):
global maxpath
if b==None: #找到一个叶子结点
if pathlen>len(maxpath): #找到一条更长的路径
maxpath.clear() #更新maxpath
for i in range(pathlen):
maxpath.append(path[i])
else:
path[pathlen]=b.data #将当前结点添加到路径中
pathlen+=1 #路径长度增1
_MaxPath1(b.lchild,path,pathlen)#递归遍历左子树
_MaxPath1(b.rchild,path,pathlen)#递归遍历右子树
解法2：采用层次遍历，最后出队的一个结点p一定是一个叶子结点，并且根结点到该结点一定是路径长度最长的路径。采用层次遍历求解对应的算法如下：
from collections import deque
class QNode:#队列元素类
def __init__(self,p,pre): #构造方法
self.node=p #当前结点引用
self.pre=pre #当前结点的双亲结点
def MaxPath2(b): #采用层次遍历求一条最长路径
maxpath=[] #存放一条最长路径
qu=deque() #定义一个队列qu
qu.append(QNode(b,None)) #根结点(双亲为None)进队
while len(qu)>0: #队不空循环
p=qu.popleft()#出队一个结点p
if p.node.lchild!=None:#有左孩子时将其进队
qu.append(QNode(p.node.lchild,p))#置其双亲为p
if p.node.rchild!=None:#有右孩子时将其进队
qu.append(QNode(p.node.rchild,p))#置其双亲为p
maxpath.append(p.node.data) #最后出队的结点一定是叶子结点
q=p.pre #q为双亲
while q!=None: #找到根结点为止
maxpath.append(q.node.data)
q=q.pre
maxpath.reverse() #逆置maxpath
return maxpath
若一棵3次树中有a个度为1的结点，b个度为2的结点，c个度为3的结点，则该树中有( )个叶子结点。
A.1+2b+3c
B.a+2b+3c
C.2b+3c
D.1+b+2c
正确答案D
n1=a，n2=b，n3=c，n-1=度之和=1×n1+2×n2+3×n3=a+2b+3c，n=a+2b+3c+1，n0=n-n1-n2-n3=n-a-b-c=b+2c+1。答案为D。
1
若已知一棵完全二叉树（所有结点值均不同）的先序、中序或后序遍历序列中的任意一种，能够唯一确定这棵二叉树吗？如果能，请以其中一种遍历序列来说明构造该二叉树的过程。如果不能，并举一个反例予以说明。
答：能够。因为若任一种遍历序列中含有结点个数n，当n已知时就可以确定完全二叉树的形态，再按给出的遍历序列填入结点值即可唯一构造这棵完全二叉树。例如给定一棵完全二叉树的先序序列为abcdef，构造对应的完全二叉树的过程如下：
结点个数n=6，画出该完全二叉树的形态如图A.31(a)所示。
②按先序序列填入结点值得到唯一的完全二叉树如图A.31(b)所示。
首页
作业系统
考试系统
师资培训
课程题库
考研
问答
使用手册
第5章作业
总分：10
得分：8
在计算机内实现递归算法时所需的辅助数据结构是（ ）。
A.栈
B.队列
C.树
D.图
正确答案A
递归调用过程具有先进后出的性质，所以在实现时使用到栈结构。
递归模型为f(1)=1，f(n)=f(n-1)+n（n>1），其中递归出口是（ ）。
A.f(1)=0
B.f(1)=1
C.f(0)=1
D.f(n)=n
正确答案B
递归出口是，当n=1时，f(1)=1，本题答案为B。
递归模型为f(1)=1，f(n)=f(n-1)+n（n>1），其中递归体是（ ） 。
A.f(1)=0
B.f(0)=1
C.f(n)=f(n-1)+n
D.f(n)=n
正确答案C
递归体反映递归方式，本题答案为C。
正确的递归算法应包含（ ）。
A.递归出口
B.递归体
C.递归出口和递归体
D.以上都不包含
正确答案C
正确的递归算法应包含递归出口和递归体两部分，缺一不可，本题答案为C。
函数f(x,y)定义如下：
f(x,y)=f(x-1,y)+f(x,y-1)当x>0且y>0
f(x,y)=x+y否则
则f(2,1)的值是（ ）。
A.1
B.2
C.3
D.4
正确答案D
f(2,1)=f(1,1)+f(2,0)=f(0,1)+f(1,0)+2=1+1+2=4。
函数f(x,y)定义如下：
f(n)=f(n-1)+f(n-2)+1当n>1
f(n)=1否则
则f(5)的值是（ ） 。
A.10
B.15
C.16
D.20
正确答案B
f(5)=f(4)+f(3)+1
f(3)=f(2)+f(1)+1=f(1)+f(0)+1+f(1)+1=5
f(4)=f(3)+f(2)+1=5+f(1)+f(0)+1+1=9。
所以f(5)=9+5+1=15。
某递归算法的执行时间的递推关系如下：
T(n)=1当n=1时
T(n)=T(n/2)+1当n>1时
则该算法的时间复杂度为（ ）。
A.O(1)
B.O(log2n)
C.O(n)
D.O(nlog2n)
正确答案B
不妨设n=2k，k=log2n。
T(n)=T(n/21)+1= T(n/22)+2=…= T(n/2k)+k=T(1)+log2n=O(log2n)。
某递归算法的执行时间的递推关系如下：
T(n)=1当n=1时
T(n)=2T(n/2)+1当n>1时
则该算法的时间复杂度为（ ）。
A.O(1)
B.O(log2n)
C.O(n)
D.O(nlog2n)
正确答案C
不妨设n=2k，k=log2n。
T(n)=21T(n/21)+1=22T(n/22)+1+21=…=2kT(n/2k)+1+21+…+2k-1=2k T(1)+2k-1=2n-1=O(n)。
某递归算法的执行时间的递推关系如下：
T(n)=1当n=1时
T(n)=2T(n/2)+n当n>1时
则该算法的时间复杂度为（ ）。
A.O(1)
B.O(log2n)
C.O(n)
D.O(nlog2n)
正确答案D
不妨设n=2k，k=log2n。
T(n)=21T(n/21)+n=22T(n/22)+2n=…=2kT(n/2k)+kn=2k T(1)+kn=nlog2n+n=O(nlog2n)。
将递归算法转换成非递归算法时，通常要借助的数据结构是（ ）。
A.线性表
B.栈
C.队列
D.树
正确答案B
递归算法转换成非递归算法时通常使用栈，本题答案为B。
1
一个递归定义可以用递归算法求解，也可以用非递归算法求解。但单从执行时间来看，通常递归算法比非递归算法（ ）。
A.较快
B.较慢
C.相同
D.无法比较
正确答案B
通常情况下递归算法比相同功能的非递归算法执行起来要慢些，这是因为递归算法执行时有系统栈开销。
以下关于递归的叙述中错误的是（ ）。
A.一般而言，使用递归解决问题较使用循环解决问题需要定义更多的变量
B.递归算法的执行效率相对较低
C.递归算法的执行需要用到栈
D.以上都是错误的
正确答案A
递归算法一般使用传值调用，每一次调用都会分配新的数据空间，所以一般不需要有更多的变量定义。
将递归算法转换为非递归算法时，通常使用___这种数据结构。
栈
将递归算法转换为非递归算法时，通常使用栈结构。
将（n>3）转化成递归函数，其递归出口是___，递归体是___。
f(1)=1、<imgstyle="max-width:70%;"src="https://cdnqingline.net/72b4e47a9f49f0fad035a3a69af8db6png"/>
设，则。当n=1时有f(1)=1，否则
递推式f(1)=0，f(n)=n-1+f(n-1)的解是___。
n(n-1)/2
f(n)=(n-1)+f(n-1)=(n-1)+(n-2)+f(n-2)=…=(n-1)+(n-2)+…+1+f(1)=(n-1)+(n-2)+…+1=n(n-1)/2。
递推式f(1)=0，f(n)=f(n/2)+1的解是___。
<p>log<sub>2</sub>n</p>
不妨设n=2k，则有k=log2n，由递推式可知：f(n)=f(n/2)+1=1+f(n/2)=1+(1+f(n/22))=2+f(n/22)=…=k+fun(n/2k)=k+f(1)=log2n。
设a是一个含有n个整数的数组，求该数组最大元素的递归定义是___。
f(a,0)=a[0]，f(a,i)=MAX{a[i],f(a,i-1)}（i≥1）
求a[.i]中的最大元素。当i=0时，a[.i]中最大元素为a[0]，否则，求出a[.i-1]中的最大元素为m，a[.i]中的最大元素为MAX{m,a[i]}。
设a是一个含有n个整数的数组，求该数组最小元素的递归定义是___。
f(a,0)=a[0]，f(a,i)=MIN{a[i],f(a,i-1)}（i≥1）
求a[.i]中的最小元素。当i=0时，a[.i]中最小元素为a[0]，否则，求出a[.i-1]中的最小元素为m，a[.i]中的最小元素为MIN{m,a[i]}。
设a是一个含有n个整数的数组，求该数组所有元素之和的递归定义是___。
f(a,0)=a[0]，f(i)=a[i]+f(a,i-1)（i≥1）
求a[.i]中所有元素之和。当i=0时，a[.i]中所有元素之和为a[0]，否则，求出a[.i-1]的所有元素之和为m，a[.i]的所有元素之和为a[i]+m。
设a是一个含有n个整数的数组，求该数组所有元素之积的递归定义是___。
f(a,0)=a[0]，f(i)=a[i]*f(a,i-1)（i≥1）
求a[.i]中所有元素之积。当i=0时，a[.i]中所有元素之积为a[0]，否则，求出a[.i-1]的所有元素之积为m，a[.i]的所有元素之积为a[i]*m。
调用自身的函数称为递归函数。
正确答案:是
调用自身的函数称为递归函数。
任何递归算法都必须包含递归出口部分。
正确答案:是
如果没有递归出口部分，递归算法不能中止，陷入死循环。
一个递归算法可以没有递归体，但必须包含递归出口部分。
正确答案:否
一个递归算法既包含递归体，也包含递归出口部分。
任何递归算法都是尾递归。
正确答案:否
尾递归是指递归调用的语句是最后一个可执行语句。
通常递归的算法、易懂、容易编写，而且执行的效率也高。
正确答案:否
通常递归的算法、易懂、容易编写，但执行的效率较低。
尾递归算法可以通过循环转换成非递归算法。
正确答案:是
尾递归是指递归调用的语句是最后一个可执行语句，可以通过循环转换成非递归算法。
任何递归算法都必须使用栈转换成非递归算法。
正确答案:否
尾递归算法可以通过循环转换成非递归算法，不必借助于栈。
递归算法转换为非递归算法时，通常借助于队列来实现。
正确答案:否
递归算法转换为非递归算法时，通常借助于栈来实现。
什么是递归，递归有哪些形式？
在定义一个函数时出现调用本函数的成分，称为递归。递归分为直接递归和间接递归两种形式。
直接递归是指在函数在执行过程中调用本身。间接递归是指函数在执行过程中调用其它函数再经过这些函数调用本身。
（同答案）
简述递归的特点。
递归的特点是它既有递堆过程，又有求值（回归）过程，而且在任何一个深度时，它的所有变量和参数的值都保存着，同一变量或参数在不同深度的值，都压入系统栈中。
（同答案）
简述递归算法的优缺点。
递归算法优点是结构清晰，可读性强，而且容易用数学归纳法来证明算法的正确性，因此它为设计算法、调试程序带来很大方便。
递归算法的缺点是算法的运行效率较低，无论是耗费的计算时间还是占用的存储空间都比非递归算法要多。
（同答案）
推导出求x的n次幂的递归模型。
f(x,n)=x当n=1时
f(x,n)=n*f(x,n-1)当n>1时
设f(x,n)=xn，f(x,n-1)=xn-1，所以f(x,n)=x*xn-1=n*f(x,n-1)。
某递归算法求解时间复杂度的递推式如下：
T(n)=1当n=0
T(n)=T(n-1)+n+3当n>0
求该算法的时间复杂度。
O(n2)
T(n)=T(n-1)+(n+3)
=T(n-2)+(n+2)+(n+3)
=T(n-3)+(n+1)+(n+2)+(n+3)
=…
=T(0)+4+5+…+(n+1)+(n+2)+(n+3)
=1+4+5+…+(n+1)+(n+2)+(n+3)
=n(n+7)/2+1
=O(n2)
有以下算法，分析执行fun(a,n,0)语句的时间复杂度。需要给出推导过程。
def fun(a,n,k): #数组a共有n个元素
if k==n-1:
for i in range(n):
print(a[i],end=' ')
else:
for i in range(k,n):
a[i]+=i*i
fun(a,n,k+1)
答：设调用fun(a，n，0)的执行时间为T(n)，fun(a，n，k)的执行时间为T1(n，k)，则有T(n)=T1(n，0)。由fun()算法可知：
T1(n,k)=n
当k=n-1、T1(n,k)=(n-k)+T1(n,k+1)
其他情况则T(n)=T1(n,0)=n+T1(n,1)=n+(n-1)+T1(n,2) =…= n+(n-1)+…+2+T1(n,n-1)
编程题
整数反转
给出一个 32 位的有符号整数，你需要将这个整数中每位上的数字进行反转。例如，输入123，输出结果为321。输入-123，输出结果为-321。要求设计满足题目条件的如下方法：
def reverse(self,x：int)->int：
lass Solution:
def reverse(self, x):
"""
:type x: int
:rtype: int
"""
a = str(x)
y = list(a)
y.reverse()
if y[-1] == "-":
y.remove('-')
y.insert(0, '-')
if y[0] == 0:
y.remove('0')
y2 = ''.join(y)
z = int(str(y2))
if z < (-2**31) or z > (2**31-1):
z = 0
return z
s = input("")
if __name__ == '__main__':
"""
输入: 123
输出: 321
输入: -123
输出: -321
输入: 120
输出: 21
"""
a = Solution()
b = a.reverse(s)
print(b)
正确答案
class Solution:
def reverse(self, x):
"""
:type x: int
:rtype: int
"""
a = str(x)
y = list(a)
y.reverse()
if y[-1] == "-":
y.remove('-')
y.insert(0, '-')
if y[0] == 0:
y.remove('0')
y2 = ''.join(y)
z = int(str(y2))
if z < (-2**31) or z > (2**31-1):
z = 0
return z
s = input("")
if __name__ == '__main__':
"""
输入: 123
输出: 321
输入: -123
输出: -321
输入: 120
输出: 21
"""
a = Solution()
b = a.reverse(s)
print(b)
编程题
螺旋矩阵II
给定一个正整数n，生成一个包含1到n
2
所有元素，且元素按顺时针顺序螺旋排列的正方形矩阵。例如，输入3，输出结果如下：
[
[ 1, 2, 3 ],
[ 8, 9, 4 ],
[ 7, 6, 5 ]
]
要求设计满足题目条件的如下方法：
def generateMatrix(self,n:int)->List[List[int]]:
lass Solution:
def generateMatrix(self, n):
# 顺时针方向（右下左上）
dx = [0, 1, 0, -1]
dy = [1, 0, -1, 0]
dn = 0 # 方向指针
res = [[0]*n for _ in range(n)] # 初始化
x = y = 0 # 位置
for i in range(1, n*n+1):
res[x][y] = i
# 下一步位置
temp_x = x + dx[dn]
temp_y = y + dy[dn]
# 判断下一步位置合理，若合理则更新位置，若不合理则改变方向并更新位置
if 0<=temp_x<n and 0<=temp_y<n and res[temp_x][temp_y]==0:
x, y = temp_x, temp_y
else:
dn = (dn+1) % 4
x += dx[dn]
y += dy[dn]
return res
test = Solution()
n = 3
test.generateMatrix(n)
print(test.generateMatrix(n))
正确答案
class Solution:
def generateMatrix(self, n):
# 顺时针方向（右下左上）
dx = [0, 1, 0, -1]
dy = [1, 0, -1, 0]
dn = 0 # 方向指针
res = [[0]*n for _ in range(n)] # 初始化
x = y = 0 # 位置
for i in range(1, n*n+1):
res[x][y] = i
# 下一步位置
temp_x = x + dx[dn]
temp_y = y + dy[dn]
# 判断下一步位置合理，若合理则更新位置，若不合理则改变方向并更新位置
if 0<=temp_x<n and 0<=temp_y<n and res[temp_x][temp_y]==0:
x, y = temp_x, temp_y
else:
dn = (dn+1) % 4
x += dx[dn]
y += dy[dn]
return res
test = Solution()
n = 3
test.generateMatrix(n)
print(test.generateMatrix(n))
首页
作业系统
考试系统
师资培训
课程题库
考研
问答
使用手册
作业一
总分：10
得分：7
用Pyinstall工具把Python文件打包成一个独立的可执行文件，使用的参数是（ ）。
A.-D
B.-L
C.-i
D.-F
正确答案D
以下关于程序设计语言的描述，错误的选项是（ ）。
A.Python 语言是一种脚本编程语言
B.汇编语言是直接操作计算机硬件的编程语言
C.程序设计语言经历了机器语言、汇编语言、脚本语言三个阶段
D.编译将源代码翻译成目标语言，解释则直接翻译执行高级程序设计语言
正确答案C
程序设计语言经历了机器语言、汇编语言、高级语言三个阶段
关于Python语言的特点，以下选项描述正确的是（ ）。
A.Python语言不支持面向对象
B.Python语言是解释型语言
C.Python语言是编译型语言
D.Python语言是非跨平台语言
正确答案B
以下选项不属于程序设计语言类别的是（ ）。
A.机器语言
B.汇编语言
C.高级语言
D.解释语言
正确答案D
（ ）选项是使用 PyInstaller 库对 Python 源文件打包的基本使用方法。
A.pip -h
B.pip install <拟安装库名>
C.pip download <拟下载库名>
D.pyinstaller 需要在命令行运行 :\>pyinstaller <Python源程序文件名>
正确答案D
IDLE环境的退出命令是（ ）。
A.exit()
B.esc()
C.close()
D.回车键
正确答案A
以下选项中，不是Python语言特点的是（ ）。
A.强制可读：Python语言通过强制缩进来体现语句间的逻辑关系
B.变量声明：Python语言具有使用变量需要先定义后使用的特点
C.平台无关：Python程序可以在任何安装了解释器的操作系统环境中执行
D.黏性扩展：Python语言能够集成C、C++等语言编写的代码
正确答案B
拟在屏幕上打印输出“Hello World"，以下选项中正确的是（ ）。
A.print(Hello World)
B.print("Hello World")
C.printf("Hello World")
D.printf('Hello World')
正确答案B
以下选项中说法不正确的是（ ）。
A.静态语言采用解释方式执行，脚本语言采用编译方式执行
B.C语言是静态语言，Python语言是脚本语言
C.编译是将源代码转换成目标代码的过程
D.解释是将源代码逐条转换成目标代码同时逐条运行目标代码的过程
正确答案A
正确的描述是：脚本语言采用解释方式执行，静态语言采用编译方式执行
执行后可以查看Python的版本的是（ ）。
A.import sys
print(sys.version)
B.import sys
print(sys.Version)
C.import system
print(system.version)
D.import system
print(system.Version)
正确答案A
1
关于Python语言的特点，以下选项中描述错误的是（ ）。
A.Python语言是脚本语言
B.Python语言是非开源语言
C.Python语言是跨平台语言
D.Python语言是多模型语言
正确答案B
以下不属于Python的pip工具命令的选项是（ ）。
A.show
B.install
C.download
D.get
正确答案D
Python内置的集成开发工具是_（ ）_。
A.PythonWin
B.Pydev
C.IDE
D.IDLE
正确答案D
Python解释器的提示符为（ ）_。
A.>
B.>>
C.>>>
D.#
正确答案C
以下程序设计语言中，Java、C#、C++等属于（ ）的编程语言。
A.面向过程
B.面向对象
C.函数式
D.逻辑式
正确答案B
以下程序设计语言中，C语言属于（ ）的编程语言。
A.面向过程
B.面向对象
C.函数式
D.逻辑式
正确答案A
以下程序设计语言中，（ ）属于脚本语言。
A.Python
B.Java
C.C++
D.C#
正确答案A
在Python解释器中同时运行多个以逗号分隔的表达式，返回结果为（ ）。
A.列表
B.元组
C.逗号分隔的结果
D.空格分隔的结果
正确答案B
Python语言是一种解释型、面向___的计算机程序设计语言。
对象
用户程序编写的Python程序（避免使用依赖于系统的特性），无需修改就可以在任何支持Python的平台上运行，这是Python的___特性。
可移植性
Python 4以后的版本中，___库用于安装管理Python扩展包，___库用于发布Python包。
pip、setuptools
要关闭Python解释器，可以使用___命令或者快捷键___。
quit()、Ctrl+Z
在Python内置集成开发环境IDLE中，可以使用快捷键___，运行当前打开的源代码程序。
F5
Python注释以符号___开始，到行尾结束。
#
在Python程序中导入sys模块后，可以通过列表___访问命令行参数。___表示Python脚本名；___表示第一个参数。
sys.argv、argv[0]、argv[1]
在Python解释器中使用___函数可以进入帮助系统；键入___命令，可以退出帮助系统。
help()或者help、quit
Python程序打包和发布最常用的是第三方的扩展包___，它是用于将Python源程序生成直接运行的程序。
PyInstaller
利用pip命令查看pip常用帮助信息的选项是___。
-h[或者]–help
开发和运行Python程序一般包括___和___两种方式。
文件式、交互式
下面不属于python特性的是（ ）。
A.易学
B.开源的免费的
C.属于低级语言
D.高可移植性
正确答案C
3
Python脚本文件的扩展名为（ ）。
A..python
B..py
C..pt
D..pg
正确答案B
使用（）函数接收用输入的数据。
A.accept （）
B.input （）
C.readline（）
D.login（）
正确答案B
算法是指（ ）。
A.数学的计算公式
B.程序设计语言的语句序列
C.问题的精确描述
D.解决问题的精确步骤
正确答案D
Python是一种跨平台、开源、免费的高级动态编程语言。
正确答案:是
Python x和Python x唯一的区别就是：print在Python x中是输出语句，而在Python x中是输出函数。
正确答案:否
在Windows平台上编写的Python程序无法在Unix平台运行。
正确答案:否
Python采用的是基于值的自动内存管理方式。
正确答案:是
在任何时刻相同的值在内存中都只保留一份。
正确答案:否
pip命令也支持扩展名为.whl的文件直接安装Python扩展库。
正确答案:是
只有Python扩展库才需要导入以后才能使用其中的对象，Python标准库不需要导入即可使用其中的所有对象和方法。
正确答案:否
Python使用缩进来体现代码之间的逻辑关系。
正确答案:是
为了让代码更加紧凑，编写Python程序时应尽量避免加入空格和空行。
正确答案:否
在Python x中语句 print(*[1,2,3]) 不能正确执行。
正确答案:否
使用print()函数无法将信息写入文件。
正确答案:否
表达式 ‘a’+1的值为’b’。
正确答案:否
可以使用py2exe或pyinstaller等扩展库把Python源程序打包成为exe文件，从而脱离Python环境在Windows平台上运行。
正确答案:是
Python程序只能在安装了Python环境的计算机上以源代码形式运行。
正确答案:否
一般来说，Python扩展库没有通用于所有版本Python的，安装时应选择与已安装Python的版本对应的扩展库。
正确答案:是
Python安装扩展库常用的是___工具。
pip
Python程序文件扩展名主要有___和___两种，其中后者常用于GUI程序。
py、pyw
Python源代码程序编译后的文件扩展名为___。
pyc
使用pip工具升级科学计算扩展库numpy的完整命令是___。
pipinstall--upgradenumpy
使用pip工具查看当前已安装的Python扩展库的完整命令是___。
piplist
使用pip工具查看当前已安装Python扩展库列表的完整命令是___。
piplist
表达式 'Hello world!'[-4] 的值为___。
r
表达式 'Hello world!'[-4:] 的值为___。
rld!
Python x完全兼容Python x。
正确答案:否
Python x和Python x唯一的区别就是：print在Python x中是输出语句，而在Python x中是输出函数。
正确答案:否
在Windows平台上编写的Python程序无法在Unix平台运行。
正确答案:否
不可以在同一台计算机上安装多个Python版本。
正确答案:否
Python采用的是基于值的自动内存管理方式。
正确答案:是
在任何时刻相同的值在内存中都只保留一份。
正确答案:否
pip命令也支持扩展名为.whl的文件直接安装Python扩展库。
正确答案:是
只有Python扩展库才需要导入以后才能使用其中的对象，Python标准库不需要导入即可使用其中的所有对象和方法。
正确答案:否
Python使用缩进来体现代码之间的逻辑关系。
正确答案:是
为了让代码更加紧凑，编写Python程序时应尽量避免加入空格和空行。
正确答案:否
在Python x中语句 print(*[1,2,3]) 不能正确执行。
正确答案:否
Python程序只能在安装了Python环境的计算机上以源代码形式运行。
正确答案:否
不同版本的Python不能安装到同一台计算机上。
正确答案:否
一般来说，Python扩展库没有通用于所有版本Python的，安装时应选择与已安装Python的版本对应的扩展库。
正确答案:是
Python x完全兼容Python x。
正确答案:否
Python x和Python x唯一的区别就是：print在Python x中是输出语句，而在Python x中是输出函数。
正确答案:否
在Python解释器中同时运行多个以逗号分隔的表达式，返回结果为（ ）。
A.列表
B.元组
C.逗号分隔的结果
D.空格分隔的结果
正确答案B官方将PEP（Python Enhancement Proposals）分成除（ ）以外的三类。
A.指导类
B.信息类
C.流程类
D.标准类
正确答案A在Python解释器中输入（ ）命令，可以输出“The Zen of Python（Python之禅）”的内容。
A.import it
B.import zen
C.print zen
D.import this
正确答案DPython程序打包和发布最常用的是第三方的扩展包___，它是用于将Python源程序生成直接运行的程序。
PyInstaller
程序设计语言分为低级语言和高级语言两类，其中，机器语言和汇编语言属于___________，Python属于____________。
低级语言、高级语言结构化程序设计通常采用____________、___________的程序设计方法。
自顶向下[或者]Top-Down[或者]自顶向下（Top-Down）[或者]自顶向下(Top-Down)、逐步求精[或者]StepwiseRefinement[或者]逐步求精（StepwiseRefinement）[或者]逐步求精(StepwiseRefinement)计算思维的本质是____________和____________。
抽象（Abstraction）[或者]抽象(Abstraction)[或者]抽象[或者]Abstraction、自动化（Automation）[或者]自动化(Automation)[或者]自动化[或者]Automation将源文件转换成机器语言一般有以下两种转换方法，即____________和____________。
编译、解释高级程序设计语言根据执行机制不同可以分成静态语言和脚本语言两类。采用编译方式执行的语言属于____________，采用解释方式执行的语言属于____________。
静态语言、脚本语言
高级程序设计语言根据执行机制不同可以分成静态语言和脚本语言两类。C、C++、C#、Java等程序设计语言属于____________，Python程序设计语言属于____________。
静态语言、脚本语言在Python中利用pip命令查看pip常用帮助信息的选项是___。
-h[或者]–help开发和运行Python程序一般包括____________和____________两种方式。
交互式、文件式在Python解释器中输入___命令，可以输出“The Zen of Python（Python之禅）”的内容。
importthis
人类在认识世界和改造世界过程中形成了____________、____________和____________三种基本的思维。
逻辑思维、实验思维、计算思维在Python编程规范中，对于缩进与换行，每一级缩进使用___个空格。
四[或者]4在Python中利用pip命令查看pip常用帮助信息的选项是_________。
-h[或者]–help在Python解释器中输入_________命令，可以输出“The Zen of Python（Python之禅）”的内容。
importthis在Python编程规范中，对于缩进与换行，每一级缩进使用_________个空格。
四[或者]4Python程序打包和发布最常用的是第三方的扩展包_________，它是用于将Python源程序生成直接运行的程序。
PyInstaller
499
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
