文章目录
前言
第一章
一、填空题
二、判断题
三、选择题
四、简答题
第二章
一、填空题
二、判断题
三、选择题
四、简答题
第三章
一、填空题
二、判断题
三、选择题
四、简答题
第四章
一、单选题
二、判断题
三、填空题
四、程序分析题
第五章
一、选择题
二、判断题
三、填空题
四、简答题
五、程序分析题
第六章
一、单选题
二、判断题
三、填空题
四、简答题
五、程序分析题
第七章
一、单选题
二、判断题
三、填空题
四、简答题
五、程序分析题
第八章
一、单选题
二、判断题
三、填空题
四、简答题
第九章
一、单选题
二、判断题
三、填空题
四、简答题
第十章
一、单选题
二、判断题
三、填空题
四、简答题
第十一章
一、单选题
二、判断题
三、填空题
四、简答题
五、程序分析题
第十二章
一、选择题
二、判断题
三、填空题
四、简答题
END


前言
本文整理了填空、选择、判断等一些课后习题答案，具体的编程题可以见:Python快速编程入门课后程序题答案。
第一章
一、填空题

Python是一种面向对象的高级语言。
Python可以在多种平台运行，这体现了Python语言的可移植特性。
Python源代码被解释器转换后的格式为字节码。
Python 3.x 默认使用的编码是UTF-8。

二、判断题

Python是开源的，它可以被一直到许多平台上。(√)
Python的优点之一是具有伪代码的本质。(√)
Python可以开发Web程序，也可以管理操作系统。(√)
Mac系统自带Python开发环境。(√)
Python自带的shell，其性能由于IPython。(×)
我们编写的Python代码在运行过程中，会被编译成二进制代码。(×)
Python程序被解释器转换后的文件格式后缀名为.pyc。(√)
Python 3.x 版本的代码完全兼容 Python 2.x。(×)
PyCharm是开发Python的集成开发环境。(√)
代码print(3,4)是Python 2.x的输出格式。(×)

三、选择题


下列选项中，不属于Python语言特点的是(C)。

A.简单易学 B.开源 C.面对过程 D.可移植性


下列领域中，使用Python可以实现的是(ABCD)。(多选)

A.Web开发 B.操作系统管理 C.科学计算 D.游戏


下列关于Python 2.x和Python 3.x的说法，正确的是(B)。

A.Python 3.x使用print语句输出数据

B.Python 3.x默认使用的编码是UTF-8

C.Python 2.x和Python 3.x使用//进行除法运算的结果不一致

D.Python 3.x版本的异常可以直接被抛出


下列关于Python的说法中，错误的是(C)。

A.Python是从ABC发展起来的

B.Python是一门高级的计算机语言

C.Python是一门只面向对象的语言

D.Python是一种代表简单主义思想的语言


下列关于IPython的说法，错误的是(D)。

A.IPython集成了交互式Python的很多有点

B.IPython的性能远远优于标准的Python的shell

C.IPython支持变量自动补全，自动收缩

D.与标准的Python相比，IPython缺少内置的功能和函数


四、简答题


简述Python的特点。

•简单易学

•开源

•高级语言

•可移植性

•解释性

•面向对象

•可扩展性

•丰富的库

•规范的代码


简述Python的应用领域(至少3个)。

•web应用开发

•操作系统管理、服务器运维的自动化脚本

•科学计算

•桌面软件

•服务器软件（网络软件）

•游戏

•构思实现，产品早期原型和迭代


简述Python 2.x和Python 3.x的区别。

(1)、在python2.x中，输出数据使用的是print语句。但是在python3.x中， print语句没有了，取而代之的是print()函数

(2)、python2有ASCII Str()类型，unicode()是单独的，不是byte类型。在python3.x版本的源代码中，默认使用的是UTF-8编码，从而可以很好的支持中文字符。

(3)、在python 2.x中，使用运算符/进行除法运算，整数相除的结果是一个整数，浮点数除法会保留小数点的部分得到一个浮点数的结果。在python 3.x中使用运算符/进行除法，整数之间的相除，结果也会是浮点数。

(4)、相比python2.x版本，python3.x版本在异常方面有很多改变:

  •在python2.x版本，所有类型的对象都是直接被抛出的，但是，在python3.x版本中，只有继承自BaseException的对象才可以被抛出。

  •在python2.x版本中，捕获异常的语法是except exc，var。在python3.x版本中，引入了as关键字，捕获异常的语法变更为except exc as var。

  •在python2.x版本中，处理异常使用raise Exception(args)。在python3.x版本中，处理异常使用raiseException, args。

  •python3.x取消了异常类的序列行为和.message属性。

(5)、在Python 3.x中，表示八进制字面量的方式只有一种，并且必须写0o1000这样的方式，原来01000的方式不能使用了。

(6)、Python 2.x中不等于有两种写法 != 和 <>；但是，Python 3.x中去掉了<>, 只有!=一种写法

(7)、python3.x去除了long类型，现在只有一种整型int，但它的行为就像是python2.x版本的long。


简述Python程序的执行原理。

Python程序的执行原理如图所示:



Python解释器将源代码转换为字节码，然后把编译好的字节码转发到Python虚拟机(PVM)中进行执行。


简述IPython的特点。

•IPython具有卓越的Python shell，其性能远远优于标准Python的shell。

•IPython支持变量自动补全，自动缩进，支持 bash shell 命令，内置了许多很有用的功能和函数。

•IPython提供了基于控制台命令环境的定制功能，可以十分轻松地将交互式Python shell包含在各种Python应用中，甚至可以当作系统级shell来使用。


第二章
一、填空题

在Python中，int表示的数据类型是整型。
布尔类型的值包括True和False。
Python的浮点数占8个字节。
如果要在计算机中表示浮点数$1.2\times10^5$，则表示方法为1.2e5。
00001000>>2的结果是00000010。
若a=20，那么bin(a)的值为0b10100。
如果想测试变量的类型，可以使用type()来实现。
若a=1，b=2，那么(a or b)的值为1。
若a=10，b=20，那么(a and b)结果为20。
4.34E5表示的是4.34×10^5。

二、判断题

Python使用符号#表示单行注释。(√)
标识符可以以数字开头。(×)
type()方法可以查看变量的数据类型。(√)
Python中的代码块使用缩进来表示。(√)
Python中的多行语句可以使用反斜杠来实现。(×)
Python中标识符不区分大小写。(×)
Python中的标识符不能使用关键字。(√)
使用help()命令可以进入帮助系统。(√)
Python中的成员运算符用于判断制定序列中是否包含某个值。(√)
比较运算符用于比较两个数，其返回的结果智能是True或False。(√)

三、选择题


下列选项中，(D)的布尔值不是Flase。

A.None

B.0

C.()

D.1


假设a=9，b=2，那么下列运算中，错误的是(D)。

A.a+b的值是11

B.a//b的值是4

C.a%b的值是1

D.a**b的值是18


下列标识符中，合法的是(AD)。

A.helloWorld

B.2ndObj

C.hello#world

D._helloworld


下列符号中，表示Python中单行注释的是(A)。

A.#

B.//

C.<!-- -->

D."“"


下列选项中，符合Python命名规范的标识符是(C)。

A.user-Passwd

B.if

C._name

D.setup.exe


下列选项中，Python不支持的数据类型有(B)。

A.int

B.char

C.float

D.dicitionary


下列表达式中，返回 True 的是(B)。

A.a=2 b=2 a=b

B.3>2>1

C.True and False

D.2!=2


下列语句中，哪个在 Python 中是非法的?(B)。

A.x = y = z = 1

B.x = (y = z + 1)	 	

C.x, y = y, x

D.x += y


下列关于 Python 中的复数，说法错误的是(C)。

A.表示复数的语法是 real + image j

B.实部和虚部都是浮点数

C.虚部必须后缀 j，且必须是小写

D.一个复数必须有表示虚部的实数和 j


下列选项中，幂运算的符号为(D)。

A.*

B.++

C.%

D.**


四、简答题

简述Python中标识符的命名规则。

•标识符由字母、下划线和数字组成，且数字不能开头。

•python中的标识符是区分大小写的。

•python中的标识符不能使用关键字。
简述Python中的数字类型。

int(整型)、long(长整型)、float(浮点数)、complex(复数)

第三章
一、填空题

在循环体中使用break语句可以跳出循环体。
elif语句是else语句和if语句的组合。
在循环体中可以使用continue语句跳过本次循环后面的代码，重新开始下一次循环。
如果希望循环是无限的，我们可以通过设置条件表达式永远为True来实现无限循环。
Python中的pass表示的是空语句。

二、判断题

elif可以单独使用。(×)
pass语句的出现是为了保持进程结构的完整性。(√)
在Python中没有switch-case语句。(√)
每个if条件后面都要使用冒号。(√)
循环语句可以嵌套使用。(√)

三、选择题

下列选项中，会输出1，2，3三个数字的是(BC)。

A.
for i in range(3):
    print(i)

B.
for i in range(3):
    print(i + 1)

C.
a_list = [0,1,2]
for i in a_list:
    print(i + 1)

D.
i = 1
while i < 3:
    print(i)
    i = i + 1


阅读下面的代码：

sum = 0
for i in range(100):
    if(i%10):
        continue
    sum = sum + i
print(sum)

  上述程序的执行结果是(C)。

    A.5050 B.4950 C.450 D.45

已知x=10,y=20,z=30:以下语句执行后x,y,z的值是(C)。

if x < y:
    z=x
    x=y
    y=z

    A.10,20,30

    B.10,20,20

    C.20,10,10

    D.20,10,30

有一个函数关系如下所示：





x
y




x<0
x-1


x=0
x


x>0
x+1


下面程序段中，能正确表示上面关系的是(C)。
A.
y = x + 1
if x >= 0
    if x == 0:
        y = x
    else:
        y = x - 1;

B.
y = x - 1
if x != 0:
    if x > 0:
        y = x + 1
    else:
        y = x

C.
if x <= 0:
    if x < 0:
        y = x - 1
    else:
        y = x
else:
    y = x + 1

D.
y = x
if x <= 0:
    if x < 0:
        y = x - 1
    else:
        y = x + 1


下列Python语句正确的是(D)。

A.min=x if x<y else y

B.max=x>y?x:y

C.if(x>y)  print x

D.while True:pass

四、简答题

简述Python中pass语句的作用。

Python中的pass是空语句，它的出现是为了保持程序结构的完整性。

pass不做任何事情，一般用做占位语句。
简述break和continue的区别。

break语句用于结束整个循环；

continue的作用是用来结束本次循环，紧接着执行下一次的循环。

第四章
一、单选题


当需要在字符串中使用特殊字符的时候，Python使用(A)作为转义字符。

A.\

B./

C.#

D.%


下列数据中不属于字符串的是(D)。

A.‘ab’

B.’’‘perfect’’’

C.“52wo”

D.abc


使用(B)符号对浮点类型的数据进行格式化。

A.%c

B.%f

C.%d

D.%s


字符串’Hi,Andy’中，字符’A’对应的下标位置为(C)。

A.1

B.2

C.3

D.4


下列方法中，能够返回某个子串在字符串中出现次数的是(C)。

A.length

B.index

C.count

D.find


下列方法中，能够让所有单词的首字母变成大写的方法是(B)。

A.capitalize

B.title

C.upper

D.ljust


字符串的strip方法的作用是(A)。

A.删除字符串头尾指定的字符 B.删除字符串末尾的指定字符

C.删除字符串头部的指定字符 D.通过指定分隔符对字符串切片


二、判断题

无论使用单引号或者双引号包含字符，使用print输出的结果都一样。(√)
无论input接收任何的数据，都会以字符串的方式进行保存。(√)
Python中只有一个字母的字符串属于字符类型。(×)
使用下标可以访问字符串中的每个字符。(√)
Python中字符串的下表是从1开始的。(×)
切片选区的区间范围是从起始位开始的，到结束位结束。(×)
如果index方法没有在字符串中找到子串，则会返回-1。(×)

三、填空题

字符串是一种表示文本数据的类型。
像双引号这样的特殊符号，需要对它进行转义输出。
Python3提供了input函数从标准输入(如键盘)读入一行文本。
切片指的是对操作的对象截取其中的一部分。
切片选取的区间是左闭右开型的，不包含结束位的值。

四、程序分析题
阅读下面的程序，分析代码是否可以编译通过。如果编译通过，请列出运行的结果，否则说明编译失败的原因。

代码一:

num_one = input("请输入一个整数：")
num_two = input("请输入一个整数：")
if num_one % num_two == 0:
    print("验证码正确")

  答：不能编译通过。因为num1和num2属于字符串类型，不能执行取余操作。

代码二:

name = 'Steve Jobs'
print(name[6])

  结果为：J

代码三:

string_example = 'hello world itheima'
index = string_example.index("itheima",0,10)
print(index)

  答：由于没有在字符串中找到子串，index方法默认会抛出ValueError异常。

代码四:

string_example = "  hello world  "
print(string_example.strip())

  结果为：Hello World (默认删除两头的空格)

代码五:

string_example = "Hello" + 'Python'
print(string_example)

  结果为：HelloPython
第五章
一、选择题


关于列表的说法，描述有错误的是(D)。

A.list是一个有序集合，没有固定大小

B.list可以存放任意类型的元素

C.使用list时，其下标可以是负数

D.list是不可变的数据类型


以下程序的输出结果是(B)。(提示：ord(“a”)==97)


list_demo=[1,2,3,4,5,'a','b']
print(list_demo[1],list_demo[5])

    A.1 5

    B.2 a

    C.1 97

    D.2 97

执行下面的操作后，list_two的值为(C)。

list_one=[4,5,6]
list_two=list_one
list_one[2]=3

    A.[4,5,6]

    B.[4,3,6]

    C.[4,5,3]

    D.A,B,C都不正确

阅读下面的程序：

list_demo=[1,2,1,3]
nums=set(list_demo)
for i in nums:
      print(i,end="")

  程序执行的结果为(D)。

    A.1213

    B.213

    C.321

    D.123


下列选项中，正确定义了一个字典的是(D)。

A.a=[‘a’,1,‘b’,2,‘c’,3]

B.b=(‘a’,1,‘b’,2,‘c’,3)

C.c={‘a’,1,‘b’,2,‘c’,3}

D.d={‘a’:1,‘b’:2,‘c’:3}


下列选项中，不能使用下标运算的是(C)。

A.列表

B.元组

C.集合

D.字符串


下列程序执行后输出的结果为(A)。


x = 'abc'
y = x
y = 100
print(x)

    A.abc

    B.100

    C.97,98,99

    D.以上三项均是错误的


下列删除列表中最后一个元素的函数是(B)。

A. del B. pop C. remove C. cut


下列函数中，用于返回元祖中元素最小值的是(C)。

A. len B. max C. min D.tuple


二、判断题

列表的索引是从0开始的。(√)
通过insert方法可以在制定位置插入元素。(√)
使用下标能修改列表的元素。(√)
列表的嵌套指的是一个列表的元素是另一个列表。(√)
通过下标索引可以修改和访问元祖的元素。(×)
字典中的值只能够是字符串类型。(×)
在字典中，可以使用count方法计算键值对的个数。(×)

三、填空题

Python序列类型包括字符串、列表和元组三种，字典是Python中唯一的映射类型。
Python中的可变数据类型有字典和列表。
在列表中查找元素时可以使用not in和in运算符。
如果要从小到大的排列列表的元素，可以使用sort方法实现。
元组使用圆括号存放元素，列表使用的是方括号。

四、简答题
请简述元组、列表和字典的区别。

(1)、外形：列表是中括号括起来的数据；元组是圆括号括起来的数据；字典是花括号括起来的数据

(2)、存储结构：列表可以存储多个不同类型的数据，以逗号分隔；元组同样能存储多个不同类型的数据，以逗号分隔；字典能存储多个键值对，以逗号分隔，键是唯一的，值是任何类型的。

(3)、访问方式：列表可以通过下标索引访问元素，索引从0开始；元组可以通过下标索引访问值，索引从0开始；字典通过键来访问值。

(4)、是否可变类型：列表是可变类型，元组是不可变类型，字典是可变类型。
五、程序分析题
阅读下面的程序，分析代码是否能够编译通过。如果能编译通过，请列出运行的结果，否则请说明编译失败的原因。

代码一:

tup = ('a','b','c')
tup[3] = 'd'
print(tup)

  答：程序运行错误，元组不能使用下标增加元素。

代码二:

dict_demo={'a':1,'b':2,'c':3}
print(dict_demo['a'])

  结果为：1

代码三:

list_demo=[10,23,66,26,35,1,76,88,58]
list_demo.reverse()
print(list_demo[3])
list_demo.sort()
print(list_demo[3])

  结果为：

  1

  26
第六章
一、单选题

阅读下面的程序：

def func():
    print(x)
    x=100
func()

  执行上述语句后，输出的结果为(C)。

    A.0 B.100 C.程序出现异常 D.程序编译失败


下面关于函数的说法，错误的是(C)。

A.函数可以减少代码的重复，使得程序更加模块化

B.在不同的函数中可以使用相同名字的变量

C.调用函数时，传入参数的顺序和函数定义时的顺序必须相同

D.函数体中如果没有return语句，也会返回一个None值


下列有关函数的说法中，正确的是(C)。

A.函数的定义必须在程序的开头

B.函数定义后，其中的程序就可以自动执行

C.函数定义后需要调用才会执行

D.函数体与关键字def必须左对齐


下列函数调用使用的参数传递方式是(A)。


result = sum(num1, num2, num3)

    A.位置绑定 B.关键字绑定 C.变量类型绑定 D.变量名称绑定


使用(C)关键字创建自定义函数。

A. function B. func C.def D.procedure


使用(D)关键字声明匿名函数。

A. function B. func C.def D.lambda


二、判断题

函数的名称可以随意命名。(×)
不带return的函数代表返回None。(√)
默认情况下，参数值和参数名是跟函数声明定义的顺序匹配的。(√)
函数定义完成后，系统会自动执行其内部的功能。(×)
函数体以冒号起始，并且是缩进格式的。(√)
带有默认值的参数一定位于参数列表的末尾。(√)
局部变量的作用域是整个程序，任何时候使用都有效。(×)
匿名函数就是没有名字的函数。(√)

三、填空题

函数可以有多个参数，参数之间使用逗号分隔。
使用return语句可以返回函数值并退出函数。
通过return结束函数，从而选择性地返回一个值给调用方。
函数能处理比声明时更多的参数，它们是不定长参数。
在函数里面调用另外一个函数，这就是函数嵌套调用。
在函数的内部定义的变量称作局部变量。
全局变量定义在函数外，可以在整个程序范围内访问。
如果想在函数中修改全部变量，需要在变量的前面加上global关键字。

四、简答题

请简述局部变量和全局变量的区别。

局部变量：

(1)、函数内部定义的变量；

(2)、作用域是函数的内部。

全局变量：

(1)、函数外部定义的变量；

(2)、作用域是整个程序。
请简要说明函数定义的规则。

(1)、以def关键字开头，后面接函数标识符名称和圆括号；

(2)、给函数起名字的时候，规则跟变量的名字是一样的；

(3)、任何传入参数和自变量必须放在圆括号中间；

(4)、函数的第一行语句可以选择性地使用文档字符串—用于存放函数说明；

(5)、函数内容以冒号起始，并且缩进；

(6)、return [表达式] 结束函数，选择性地返回一个值给调用方。不带表达式的return相当于返回 None。

五、程序分析题
阅读下面的程序，分析代码是否能够编译通过。如果能编译通过，请列出运行的结果，否则请说明编译失败的原因。

代码一:

def func():
    x = 200
x = 100
func()
print(x)

  结果为：100

代码二:

def func():
    global x
    x = 200
x = 100
func()
print(x)

  结果为：200

代码三:

def func():
    x = 200
    def func2():
        print(x)
    func2()
x = 100
func()
print(x)

  结果为：

  200

  100
第七章
一、单选题


关于装饰器，下列说法错误的是(B)。

A.装饰器是一个包裹函数

B.装饰器智能有一个参数

C.通过在函数定义的面前加上@符号阿和装饰器名，使得装饰器函数生效

D.如果装饰器带有参数，则必须在装饰函数的外层再嵌套一层函数


下列函数中，用于使用函数对制定序列进行过滤的是(C)。

A.map函数 B.select函数 C.filter函数 D.reduce函数


下列选项中，不能作为filter函数参数的是(D)。

A.列表 B.元组 C.字符串 D.整数


阅读下面一段程序：


def foo():
    a = 1
    def bar():
        a = a + 1
        return a
    return bar
print(foo()())

  上述程序执行的结果为(A)。

    A.程序出现异常

    B.2

    C.1

    D.没有输出结果
二、判断题

闭包是内部函数对外部作用域的变量进行引用。(×)
当外部函数执行结束，其内部闭包引用的变量一定会立即释放。(×)
装饰器是一个变量。(×)
装饰器函数至少要接收一个函数。(√)
装饰器既能装饰带参数的函数，也能自己带参数。(√)
如果map函数传入的两个序列个数不同，那么个数多的序列会把多余的元素删除。(×)
map函数只能传递一个序列。(×)
map传入函数的参数个数必须跟序列的个数一样。(√)
filter传入的函数可以为None。(√)
filter函数智能对序列执行过滤操作。(×)
filter函数的返回值为字符串，它的序列类型一定是字符串。(√)

三、填空题

内部函数引用了外部函数作用域的变量，那么内部函数叫作闭包。
装饰器本质上是一个函数。
装饰器函数需要接收一个参数，这个参数表示被修饰的函数。
在函数定义的前面添加装饰器名和@符号，实现对函数的包装。
支持参数的装饰器函数需要再多一层内嵌函数。
map函数会根据提供的函数对制定的序列做映射。
map的两个序列的元素个数不一致，那么元素少的序列会以None补齐。
filter函数会对制定序列执行过滤操作。
filter传入的函数的返回值是布尔值。
reduce传入的是带有两个参数的函数，该函数不能为None。

四、简答题


请简述闭包满足的三个条件。

(1)、存在于嵌套关系的函数中；

(2)、嵌套的内部函数引用了外部函数的变量；

(3)、嵌套的外部函数会将内部函数名作为返回值返回。


请简述装饰器的应用场景。

(1)、引入日志；

(2)、函数执行时间统计；

(3)、执行函数前预备处理；

(4)、执行函数后清理功能；

(5)、权限校验；

(6)、缓存。


请简述map、filter、reduce函数的作用。

(1)、map函数会根据提供的函数对指定的序列做映射。

(2)、filter函数会对指定序列执行过滤操作。

(3)、reduce函数会对参数序列中的元素进行累积。


五、程序分析题
阅读下面的程序，分析代码是否能够编译通过。如果能编译通过，请列出运行的结果，否则请说明编译失败的原因。

代码一:

def funX():
     x = 5
     def funY():
          nonlocal x
          x += 1
          return x
     return funY
a = funX()
print(a())
print(a())
print(a())

  结果为：

  6

  7

  8

代码二:

def funX():
    x = 5
    def funY():
        nonlocal x
        x += 1
        return x
    return funY
return funY
a = funX
print(a()())
print(a()())
print(a()())

  结果为：

  6

  6

  6
第八章
一、单选题


打开一个已有文件，然后在文件末尾添加信息，正确的打开方式为(C)。

A.‘r’ B.‘w’ C.‘a’ D.‘w+’


假设文件不存在，如果使用open方法打开文件会报错，那么该文件的打开方式是下列哪种模式?(A)

A.‘r’ B.‘w’ C.‘a’ D.‘w+’


假设file是文本文件对象，下列选项中，哪个用于读取一行内容?(C)

A.file.read() B.file.read(200)

C.file.readline() D.file.readlines()


下列方法中，用于向文件中写出内容的是(B)。

A.open B.write C.close D.read


下列荣方法中，用于获取当前目录的是(D)。

A.open B.write C.Getcwd D.read


下列语句打开文件的位置应该在(D)。


f = open('itheima.txt','w')

    A.C盘根目录下

    B.D盘根目录下

    C.Python安装目录下

    D.与源文件在相同的目录下

若文本文件abc.txt中的内容如下：

abcdef

  阅读下面的程序：
file=open("abc.txt","r")
s=file.readline()
s1=list(s)
print(s1)

  上述程序执行的结果为(C)。

    A.[‘abcdef’]

    B.[‘abcdef\n’]

    C.[‘a’,‘b’,‘c’,‘d’,‘e’,‘f’]

    D.[‘a’,‘b’,‘c’,‘d’,‘e’,‘f’,’\n’]
二、判断题

文件打开的默认方式是只读。(√)
打开一个可读写的文件，如果文件存在会被覆盖。(√)
使用write方法写入文件时，数据会追加到文件的末尾。(√)
实际开发中，文件或者文件夹操作都要用到os模块。(√)
read方法只能一次性读取文件中的所有数据。(×)

三、填空题

打开文件对文件进行读写，操作完成后应该调用close()方法关闭文件，以释放资源。
seek方法用于移动指针到制定位置，该方法中offset参数表示要偏移的字节数。
使用readlines方法把整个文件中的内容进行一次性读取，返回的是一个列表。
os模块中的mkdir方法用于创建文件夹。
在读写文件的过程中，tell方法可以获取当前的读写位置。

四、简答题

请简述文本文件和二进制文件的区别。

文本文件存储的是常规字符串，由若干文本行组成，通常每行以换行符“\n”结尾。二进制文件把对象内容以字节串进行存储，无法用记事本或其他普通字处理软件直接进行编辑，无法被人类直接阅读和理解，需要使用专门的软件进行解码后读取、显示、修改或执行。
请简述读取文件的几种方法和区别。

(1)、使用read(size)方法可以指定读取的字节数，或者读取整个文件；

(2)、使用readlines方法可以把整个文件的内容进行一次性读取；

(3)、使用readline方法一行一行读数据。

第九章
一、单选题

下列程序运行以后，会产生如下(B)异常。

a

    A.SyntaxError B.NameError C.IndexError D.KeyError


下列选项中，(C)是唯一不再运行时发生的异常。

A.ZeroDivisionError B.NameError C.SyntaxError D.KeyError


当try语句中没有任何错误信息时，一定不会执行(D)语句。

A.try B.else C.finaly D.except


在完整的异常语句中，语句出现的顺序正确的是(D)。

A.try---->except----->else---->finally

B.try---->else---->except----->finally

C.try---->except----->finally—>else

D.try----->else---->else----->except


下列选项中，用于触发异常的是(A)。

A.try B.catch C.raise D.except


关于抛出异常的说法中，描述错误的是(C)。

A.当raise指定异常的类名时，会隐式地创建异常类的实例

B.显式地创建异常类实例，可以使用raise直接引发

C.不带参数的raise语句，只能引发刚刚发生过的异常

D.使用raise抛出异常时，无法指定描述信息


关于抛出异常的说法中，描述错误的是(D)。

A.当raise指定异常的类名时，会隐式地创建异常类的实例

B.显式地创建异常类实例，可以使用raise直接引发

C.不带参数的raise语句，只能引发刚刚发生过的异常

D.使用raise抛出异常时，无法指定描述信息


二、判断题

默认情况下，系统检测到错误后会终止程序。(√)
在使用异常时必须先导入exceptions模块。(×)
一个try语句只能对应一个except子句。(×)
如果except子句没有指明任何异常类型，则表示捕捉所有的异常。(√)
无论程序是否捕捉到异常，一定会执行finally语句。(√)
所有的except子句一定在else和finally的前面。(√)

三、填空题

Python中所有的异常类都是Exception子类。
当使用序列中不存在的索引时，会引发IndexError异常。
一个try语句智能对应一个finally子句。
当约束条件不满足时，assert语句会触发AssertionError异常。
如果在没有except的try语句中使用else语句，会引发语法错误。

四、简答题

请简述什么是异常。

在Python中，程序在执行的过程中产生的错误称为异常，比如列表索引越界、打开不存在的文件等。
处理异常有哪些方式？

try、except、else、finally语句。

第十章
一、单选题


下列关键字中，用来引入模块的是(C)。

A.include B.from C.import D.continue


关于引入模块的方式，错误的是(D)。

A.import math

B.from fib import fibnacci

C.form math import *

D.from * import fib


关于__name__的说法，下列描述错误的是(A)。

A.它是Python提供的一个方法

B.每个模块内部都有一个__name__属性

C.当它的值为’__main__‘时，表示模块自身在运行

D.当它的值不为’__main__'时，表示模块被引用


二、判断题

Python解释器会优先查看默认的路径搜索模块的位置。(×)
每个Python文件就是一个模块。(√)
当__name__属性的值为__main__时，代表该模块自身在运行。(√)
包目录下必须有一个__init__py文件。(√)
外部模块都提供了自动安装的文件，直接双击安装就行。(×)

三、填空题

要调用random模块的randint函数，书写形式为random. randint。
每个Python文件都可以作为一个模块，模块的名字就是文件的名字。
每个模块都有一个__name__属性，使程序块智能在模块自身运行时执行。
为了更好地组织模块，通常会把多个模块放在一个包中。
当程序中需要引入外部模块时，需要从外面下载并安装。
如果要搜索模块的路径，可以使用sys模块的path变量。

四、简答题

解释Python脚本程序的"__name__"的作用。

每个Python脚本在运行时都有一个“__name__”属性。如果脚本作为模块被导入，则其“__name__”属性的值被自动设置为模块名；如果脚本独立运行，则其“__name__”属性值被自动设置为“__name__”属性。利用“__name__”属性即可控制Python程序的运行方式。
请简述Python解释器搜索模块位置的顺序。

(1)、搜索当前目录，如果不在当前目录，Python则搜索在shell变量PYTHONPATH下的每个目录。

(2)、如果都找不到。Python会继续查看默认路径。
请简述模块的概念。

在Python中有一个概念叫做模块（module），这个和C语言中的头文件以及Java中的包很类似，比如在Python中要调用sqrt函数，必须用import关键字引入math这个模块。
请简述导入模块的方法。

在Python中用关键字import来引入某个模块：

(1)、导入模块，使用“import 模块”引入；

(2)、导入模块中的某个函数，使用“from 模块名 import 函数名”引入；

(3)、导入模块的全部内容，使用“from 模块 import *”。

第十一章
一、单选题


关于面向过程和面向对象，下列说法错误的是(B)。

A.面向过程和面向对象都是解决问题的一种思路

B.面向过程是基于面向对象的

C.面向过程强调的是解决问题的步骤

D.面向对象强调的是解决问题的对象


关于类和对象的关系，下列描述正确的是(D)。

A.类和面向对象的核心

B.类是现实中事物的个体

C.对象是根据类创建的，并且一个类只能对应一个对象

D.对象描述的是现实的个体，它是类的实例


构造方法的作用是(C)。

A.一般成员方法 B.类的初始化

C.对象的初始化 D.对象的建立


构造方法是类的一个特殊方法，Python中它的名称为(C)。

A.与类同名 B._construct C._init_ D. init


Python类中包含一个特殊的变量(A)，它表示当前对象自身，可以访问类的成员。

A.self B.me C.this D.与类同名


下列选项中，符合类的命名规范的是(A)。

A.HolidayResort

B.Holiday Resort

C.hoildayResort

D.hoilidayresort


Python中用于释放类占用资源的方法是(B)。

A.__init__

B.__del__

C._del

D.delete


二、判断题

面向对象是基于面向过程的。(×)
通过类可以创建对象，有且只有一个对象实例。(×)
方法和杉树的格式是完全一样的。(×)
创建类的对象时，系统会自动调用构造方法进行初始化。(√)
创建完对象后，其属性的初始值是固定的，外界无法进行修改。(×)
使用del语句删除对象，可以手动释放它所占用的资源。(√)

三、填空题

在Python中，可以使用class关键字来声明一个类。
面向对象需要把问题划分多个独立的对象，然后调用其方法解决问题。
类的方法中必须有一个self参数，位于参数列表的开头。
Python提供了名称为__init__的构造方法，实现让类的对象完成初始化。
如果想修改属性的默认值，可以在构造方法中使用参数设置。

四、简答题

请简述self在类中的意义。

不用实例化对象就能够在本类中访问自身的属性或方法。
类是由哪三个部分组成的？

类名，属性，方法。
请简述构造方法和析构方法的作用。

分别用于初始化对象的属性和释放类所占用的资源。

五、程序分析题
阅读下面的程序，分析代码是否能够编译通过。如果能编译通过，请列出运行的结果，否则请说明编译失败的原因。

代码一:

class Person:
    def __init__(self, name):
        self.name = name
    def __str__(self):
        return "我的名字是" + self.name
person = Person("小明")
print(person)

  结果为：我的名字是小明

代码二:

class Person:
    def __del__(self):
        print("--del--")
person = Person()
del person
print("--end--")

  结果为：

  --del–

  --end–
第十二章
一、选择题


Python中定义私有属性的方法是(D)。

A. 使用private关键字 B.使用public关键字

C.使用__XX__定义属性名 D.使用__XX定义属性名


下列选项中，不属于面向对象程序设计的三个特征的是(A)。

A.抽象 B.封装 C. 继承 D.多态


以下C类继承A类和B类的格式中，正确的是(C)。

A. class C A,B: B. class C（A:B） C.class C（A,B） D.class C A and B:


下列选项中，与class Person等价的是(C)。

A. class Person（Object） B. class Person（Animal）

C. class Person（object） D. class Person: object


下列关于类属性和示例属性的说法，描述正确的是(B)。

A.类属性既可以显示定义，又能在方法中定义

B.公有类属性可以通过类和类的实例访问

C.通过类可以获取实例属性的值

D.类的实例只能获取实例属性的值


下列选项中，用于标识为静态方法的是(C)。

A.@classmethood B.@instancemethod

C.@staticmethod D.@privatemethod


下列方法中，不可以使用类名访问的是(A)。

A.实例方法 B.类方法 C.静态方法 D.以上3项都不符合


二、判断题

Python中没有任何关键字区分公有属性和私有属性。(√)
继承会在原有类的基础上产生新的类，这个新类就是父类。(×)
带有两个下划线的方法一定是私有方法。(√)
子类能继承父类的一切属性和方法。(×)
子类通过重写继承的方法，覆盖掉跟父类同名的方法。(√)
如果类属性和实例属性重名，对象有限访问类属性的值。(×)
使用类名获取到的值一定是类属性的值。(√)
静态方法中一定不能访问实例属性的值。(√)

三、填空题

如果属性名的前面加上了两个下划线，就表明它是私有属性。
在现有类基础上构建新类，新的类称作子类，现有的类称作父类。
父类的私有属性和方法是不能被子类继承的，更不能被子类访问。
Python语言既支持单继承，也支持多继承。
子类想按照自己的方式实现方法，需要重写从父类继承的方法。
子类通过super()可以成功地访问父类的成员。
位于类内部、方法外部的方法是类方法。
类方法是类拥有的方法，使用修饰器@classmethod来标识。

四、简答题


请简述如何保护类的属性。

(1)、把属性定义为私有属性，即在属性名的前面加上两个下划线；

(2)、添加用于设置或者获取属性值的两个方法供外界调用。


什么是继承？

类的继承是指在一个现有类的基础上构建一个新的类，构建出来的新类被称作子类，现有类被称作父类，子类会自动拥有父类的属性和方法。


请简述私有属性无法访问的原理。

当在一个类的内部定义了私有方法或者私有属性的时候，Python在运行的过程中，把属性或者方法的名字进行了修改，即在属性或者方法名称的前面加上“_类名”，导致原有的方法无法访问到。


什么是多态？

在Python中，多态是指在不考虑对象类型的情况下使用对象。


请简述实例方法、类方法和静态方法的区别。

(1)、类方法需要使用@classmethod进行标识，该方法可以访问类属性，无法访问实例属性，可以通过类实例和类进行调用。

(2)、静态方法使用@staticmethod进行标识，该方法无法访问实例属性和类属性，起到类似于函数的作用，使用类或者类实例进行调用。

(3)、实例方法直接在类中使用def进行定义，可以访问其实例属性和类属性，使用类实例进行调用。

(4)、如果要修改实例属性的值，就直接使用实例方法；如果要修改类属性的值，就直接使用类方法；如果是辅助功能，比如打印菜单，这时可以考虑使用静态方法，可以在不创建对象的前提下使用。


请简述Python中以下划线开头的变量名的特点。

在Python中，以下划线开头的变量名有着特殊的含义，尤其是在类的定义中。用下划线作为变量前缀和后缀来表示类的特殊成员：

(1)、_xx：这样的对象叫做保护变量，不能用from module import *导入，只有类对象和子类对象能够访问这些变量。

(2)、__xx__：系统定义的特殊成员名字。

(3)、__xx：类中的私有成员，只有类对象自己能访问，子类对象也不能访问到这个成员，但在对象外部可以通过“对象名.__类名__ xx”这样特殊的方式来访问。Python中没有纯粹的C++意义上的私有成员。


END
如果本文有什么写的不对的地方或有什么更好地建议和想法，欢迎在下方评论留言或私信我，大家一起进步学习！

 

转自 https://blog.csdn.net/Bamboo_shui/article/details/72433523    (原文没第八章答案)

数据结构（C语言版 第2版）课后习题答案 严蔚敏 等 编著，仅供参考，还是自己认真做了再看



第1章  绪论

 

5．选择题

（1）在数据结构中，从逻辑上可以把数据结构分成（  C ）。

A．动态结构和静态结构     B．紧凑结构和非紧凑结构

C．线性结构和非线性结构   D．内部结构和外部结构

（2）与数据元素本身的形式、内容、相对位置、个数无关的是数据的（  C ）。

A．存储结构               B．存储实现

C．逻辑结构               D．运算实现

（3）通常要求同一逻辑结构中的所有数据元素具有相同的特性，这意味着（  B ）。

   A．数据具有同一特点

B．不仅数据元素所包含的数据项的个数要相同，而且对应数据项的类型要一致

C．每个数据元素都一样

D．数据元素所包含的数据项的个数要相等

（4）以下说法正确的是（ D  ）。

A．数据元素是数据的最小单位

B．数据项是数据的基本单位

C．数据结构是带有结构的各数据项的集合

D．一些表面上很不相同的数据可以有相同的逻辑结构

解释：数据元素是数据的基本单位，数据项是数据的最小单位，数据结构是带有结构的各数据元素的集合。

（5）算法的时间复杂度取决于（  D  ）。

A．问题的规模 B．待处理数据的初态

C．计算机的配置 D．A和B

解释：算法的时间复杂度不仅与问题的规模有关，还与问题的其他因素有关。如某些排序的算法，其执行时间与待排序记录的初始状态有关。为此，有时会对算法有最好、最坏以及平均时间复杂度的评价。

（6）以下数据结构中，（ A ）是非线性数据结构

A．树        B．字符串       C．队列           D．栈

 

6．试分析下面各程序段的时间复杂度。

（1）x=90; y=100; 

while(y>0)

if(x>100)

 {x=x-10;y--;}

else x++;

答案：O(1)

解释：程序的执行次数为常数阶。

（2）for (i=0; i<n; i++)

for (j=0; j<m; j++)

a[i][j]=0;

答案：O(m*n)

解释：语句a[i][j]=0;的执行次数为m*n。

（3）s=0;

     for i=0; i<n; i++)

for(j=0; j<n; j++)

         s+=B[i][j];

sum=s;

答案：O(n2)

解释：语句s+=B[i][j];的执行次数为n2。

（4）i=1;

     while(i<=n)

        i=i*3;

答案：O(log3n) 

解释：语句i=i*3;的执行次数为 ëlog3nû。

（5）x=0;

for(i=1; i<n; i++)

   for (j=1; j<=n-i; j++)

x++;

答案：O(n2)

解释：语句x++;的执行次数为n-1+n-2+……＋1= n(n-1)/2。

 

 

第2章  线性表

1．选择题

（1）顺序表中第一个元素的存储地址是100，每个元素的长度为2，则第5个元素的地址是（  B  ）。

A．110            B．108         C．100          D．120

解释：因为顺序表是连续存储的，所以第5个元素的地址为：100+2*( 5 - 1)=108。

（2）在n个结点的顺序表中，算法的时间复杂度是O(1)的操作是（  A ）。

A．访问第i个结点（1≤i≤n）和求第i个结点的直接前驱（2≤i≤n）

B．在第i个结点后插入一个新结点（1≤i≤n）

C．删除第i个结点（1≤i≤n）

D．将n个结点从小到大排序

解释：在顺序表中插入、删除一个结点，平均约移动表中一半元素，时间复杂度为O(n)；顺序表是一种随机存取结构，按位置访问元素可通过数组下标直接定位，时间复杂度是O(1)；（排序的时间复杂度为O(n2)或O(nlog2n)？）。

（3） 向一个有127个元素的顺序表中插入一个新元素并保持原来顺序不变，平均要移动  的元素个数为（ B  ）。

A．8      B．63.5        C．63      D．7

解释：平均移动元素个数为n/2

（4）链接存储的存储结构所占存储空间（ A  ）。

A．分两部分，一部分存放结点值，另一部分存放表示结点间关系的指针

B．只有一部分，存放结点值

C．只有一部分，存储表示结点间关系的指针

D．分两部分，一部分存放结点值，另一部分存放结点所占单元数

（5）线性表若采用链式存储结构时，要求内存中可用存储单元的地址（ D  ）。

A．必须是连续的        B．部分地址必须是连续的

C．一定是不连续的      D．连续或不连续都可以

（6）线性表Ｌ在（  B ）情况下适用于使用链式结构实现。

A．需经常修改Ｌ中的结点值      Ｂ．需不断对Ｌ进行删除插入

C．Ｌ中含有大量的结点          Ｄ．Ｌ中结点结构复杂

解释：链表插入/删除数据只需修改指针不需要移动表中数据，链表适用长度变化大、频繁进行插入/删除操作。

（7）单链表的存储密度（ C  ）。

A．大于1        B．等于1      C．小于1    D．不能确定

解释：存储密度是指一个结点数据本身所占的存储空间和整个结点所占的存储空间之比，假设单链表一个结点本身所占的空间为D，指针域所占的空间为N，则存储密度为D/(D+N)，即一定小于1。

（8）将两个各有n个元素的有序表归并成一个有序表，其最少的比较次数是（   ）。

A．n            B．2n-1        C．2n        D．n-1

答案：A

解释：当第一个有序表中所有的元素都小于（或大于）第二个表中的元素，只需要用第二个表中的第一个元素依次与第一个表的元素比较，总计比较n次，最多比较2n-1次。

（9）在一个长度为n的顺序表中，在第i个元素（1≤i≤n+1）之前插入一个新元素时须向后移动（ B  ）个元素。

A．n-i           B．n-i+1       C．n-i-1      D．I

(10) 线性表L=(a1，a2,……an)，下列说法正确的是（D  ）。

A．每个元素都有一个直接前驱和一个直接后继

B．线性表中至少有一个元素

C．表中诸元素的排列必须是由小到大或由大到小

D．除第一个和最后一个元素外，其余每个元素都有一个且仅有一个直接前驱和直接后继。

(11) 创建一个包括n个结点的有序单链表的时间复杂度是（    ）。

A．O(1)          B．O(n)            C．O(n2)          D．O(nlog2n)

答案：C

解释：创建单链表的时间复杂度是O(n)，而要建立一个有序的单链表，则每生成一个新结点时需要和已有的结点进行比较 以确定合适的插入位置，所以时间复杂度是O(n2)。

(12) 以下说法错误的是（   ）。

A．求表长、定位这两种运算在采用顺序存储结构时实现的效率不比采用链式存储结构时实现的效率低

B．顺序存储的线性表可以随机存取

C．由于顺序存储要求连续的存储区域，所以在存储管理上不够灵活

D．线性表的链式存储结构优于顺序存储结构

答案：D

解释：链式存储结构和顺序存储结构各有优缺点，有不同的适用场合。

(13) 在单链表中，要将s所指结点插入到p所指结点之后，其语句应为（   ）。

A．s->next=p+1; p->next=s;

B．(*p).next=s; (*s).next=(*p).next;

C．s->next=p->next; p->next=s->next;

D．s->next=p->next; p->next=s;  

答案：D

 (14) 在双向链表存储结构中，删除p所指的结点时须修改指针（   ）。

A．p->next->prior=p->prior; p->prior->next=p->next;

B．p->next=p->next->next; p->next->prior=p;

C．p->prior->next=p; p->prior=p->prior->prior;

D．p->prior=p->next->next; p->next=p->prior->prior;

答案：A

(15) 在双向循环链表中，在p指针所指的结点后插入q所指向的新结点，其修改指针的操作是（   ）。

A．p->next=q; q->prior=p; p->next->prior=q; q->next=q;

B．p->next=q; p->next->prior=q; q->prior=p; q->next=p->next;

C．q->prior=p; q->next=p->next; p->next->prior=q; p->next=q;

D．q->prior=p; q->next=p->next; p->next=q; p->next->prior=q;

答案：C

2．算法设计题

（1）将两个递增的有序链表合并为一个递增的有序链表。要求结果链表仍使用原来两个链表的存储空间, 不另外占用其它的存储空间。表中不允许有重复的数据。

[题目分析]

（合并后的新表用一个新的Lc指针。新建一个Lc头指针，pa和pb分别是链表La和Lb的工作指针且初始化为相应链表的第一个结点。从第一个结点开始进行比较，当两个链表La和Lb均未到达表尾结点时，则依次摘取较小元素重新链接在Lc表的后面。其中，如果两个表中的元素相等，只摘取La表中的元素，删除Lb表中的元素（注意释放删除的元素的空间），这样确保合并后表中无重复的元素。当一个表到达表尾结点，为空时，将非空表的剩余元素直接链接在Lc表的最后面。

[算法描述]

 


 


	
void MergeList(LinkList &La,LinkList &Lb,LinkList &Lc)
	
	

	
{//合并链表La和Lb，合并后的新表使用头指针Lc指向
	
	

	
pa=La->next; pb=Lb->next;
	
	

	
//pa和pb分别是链表La和Lb的工作指针,初始化为相应链表的第一个结点
	
	

	
Lc=pc=La; //用La的头结点作为Lc的头结点
	
	

	
while(pa && pb)
	
	

	
{
	
	

	
if(pa->data<pb->data){
	
	

	
pc->next=pa;
	
	

	
pc=pa;
	
	

	
pa=pa->next;
	
	

	
}
	
	

	
//取较小者La中的元素，将pa链接在pc的后面，pa指针后移
	
	

	
else if(pa->data>pb->data){
	
	

	
pc->next=pb;
	
	

	
pc=pb;
	
	

	
pb=pb->next;
	
	

	
}
	
	

	
//取较小者Lb中的元素，将pb链接在pc的后面，pb指针后移
	
	

	
else //相等时取La中的元素，删除Lb中的元素
	
	

	
{
	
	

	
pc->next=pa;
	
	

	
pc=pa;
	
	

	
pa=pa->next;
	
	

	
q=pb->next;delete pb ;pb =q;（删除记得要释放空间）
	
	

	
//q=pb;pb=q->next;delete q;
	
	

	
}
	
	

	
}
	
	

	
pc->next=pa?pa:pb; //插入剩余段
	
	

	
delete Lb; //释放Lb的头结点(La的头结点已赋给了Lc,不需释放)
	
	

	
}
	



（2）将两个非递减的有序链表合并为一个非递增的有序链表。要求结果链表仍使用原来两个链表的存储空间, 不另外占用其它的存储空间。表中允许有重复的数据。

 

[题目分析]

合并后的新表使用头指针Lc指向，pa和pb分别是链表La和Lb的工作指针,初始化为相应链表的第一个结点，从第一个结点开始进行比较，当两个链表La和Lb均为到达表尾结点时，依次摘取其中较小者重新链接在Lc表的表头结点之后，如果两个表中的元素相等，只摘取La表中的元素，保留Lb表中的元素。当一个表到达表尾结点，为空时，将非空表的剩余元素依次摘取，链接在Lc表的表头结点之后（前插法）。

[算法描述]

 


 


	
void MergeList(LinkList& La, LinkList& Lb, LinkList& Lc, )
	
	

	
{//合并链表La和Lb，合并后的新表使用头指针Lc指向
	
	

	
pa=La->next; pb=Lb->next;
	
	

	
//pa和pb分别是链表La和Lb的工作指针,初始化为相应链表的第一个结点
	
	

	
Lc=pc=La; //用La的头结点作为Lc的头结点
	
	

	
Lc->next=NULL;
	
	

	
while(pa||pb)
	
	

	
{//只要存在一个非空表，用q指向待摘取的元素
	
	

	
if(!pa) {q=pb; pb=pb->next;}
	
	

	
//La表为空，用q指向pb，pb指针后移
	
	

	
else if(!pb) {q=pa; pa=pa->next;}
	
	

	
//Lb表为空，用q指向pa，pa指针后移
	
	

	
else if(pa->data<=pb->data) {q=pa; pa=pa->next;}
	
	

	
//取较小者（包括相等）La中的元素，用q指向pa，pa指针后移
	
	

	
else {q=pb; pb=pb->next;}
	
	

	
//取较小者Lb中的元素，用q指向pb，pb指针后移
	
	

	
q->next = Lc->next; Lc->next = q; 
	
	

	
//将q指向的结点插在Lc 表的表头结点之后
	
	

	
}
	
	

	
delete Lb; //释放Lb的头结点
	
	

	
} 
	
 

（3）已知两个链表A和B分别表示两个集合，其元素递增排列。请设计算法求出A与B的交集，并存放于A链表中。

[题目分析]

只有同时出现在两集合中的元素才出现在结果表中,合并后的新表使用头指针Lc指向。pa和pb分别是链表La和Lb的工作指针,初始化为相应链表的第一个结点，从第一个结点开始进行比较，当两个链表La和Lb均为到达表尾结点时，如果两个表中相等的元素时，摘取La表中的元素，删除Lb表中的元素；如果其中一个表中的元素较小时，删除此表中较小的元素，此表的工作指针后移。当链表La和Lb有一个到达表尾结点，为空时，依次删除另一个非空表中的所有元素。

[算法描述]

 


 


	
void Mix(LinkList& La, LinkList& Lb, LinkList& Lc)
	
	

	
{ pa=La->next;pb=Lb->next; 
	
	

	
pa和pb分别是链表La和Lb的工作指针,初始化为相应链表的第一个结点
	
	

	
Lc=pc=La; //用La的头结点作为Lc的头结点
	
	

	
while(pa&&pb)
	
	

	
{ if(pa->data==pb->data)∥交集并入结果表中。
	
	

	
{ pc->next=pa;pc=pa;pa=pa->next;
	
	

	
u=pb;pb=pb->next; delete u;}
	
	

	
else if(pa->data<pb->data) {u=pa;pa=pa->next; delete u;}
	
	

	
else {u=pb; pb=pb->next; delete u;}
	
	

	
}
	
	

	
while(pa) {u=pa; pa=pa->next; delete u;}∥ 释放结点空间
	
	

	
while(pb) {u=pb; pb=pb->next; delete u;}∥释放结点空间
	
	

	
pc->next=null;∥置链表尾标记。
	
	

	
delete Lb; //释放Lb的头结点
	
	

	
}
	
 

（4）已知两个链表A和B分别表示两个集合，其元素递增排列。请设计算法求出两个集合A和B 的差集（即仅由在A中出现而不在B中出现的元素所构成的集合），并以同样的形式存储，同时返回该集合的元素个数。

[题目分析]

求两个集合A和B的差集是指在A中删除A和B中共有的元素，即删除链表中的相应结点,所以要保存待删除结点的前驱，使用指针pre指向前驱结点。pa和pb分别是链表La和Lb的工作指针,初始化为相应链表的第一个结点，从第一个结点开始进行比较，当两个链表La和Lb均为到达表尾结点时，如果La表中的元素小于Lb表中的元素，pre置为La表的工作指针pa删除Lb表中的元素；如果其中一个表中的元素较小时，删除此表中较小的元素，此表的工作指针后移。当链表La和Lb有一个为空时，依次删除另一个非空表中的所有元素。

[算法描述]

 


 


	
void Difference（LinkList& La, LinkList& Lb,int *n）
	
	

	
{∥差集的结果存储于单链表La中，*n是结果集合中元素个数，调用时为0
	
	

	
pa=La->next; pb=Lb->next; 
	
	

	
∥pa和pb分别是链表La和Lb的工作指针,初始化为相应链表的第一个结点
	
	

	
pre=La; ∥pre为La中pa所指结点的前驱结点的指针
	
	

	
while（pa&&pb）
	
	

	
{if（pa->data<q->data）{pre=pa;pa=pa->next;*n++;}
	
	

	
∥ A链表中当前结点指针后移
	
	

	
else if（pa->data>q->data）q=q->next; ∥B链表中当前结点指针后移
	
	

	
else {pre->next=pa->next; ∥处理A，B中元素值相同的结点，应删除
	
	

	
u=pa; pa=pa->next; delete u;} ∥删除结点
	
	

	
}
	
	

	
}
	
 

（5）设计算法将一个带头结点的单链表A分解为两个具有相同结构的链表B、C，其中B表的结点为A表中值小于零的结点，而C表的结点为A表中值大于零的结点（链表A中的元素为非零整数，要求B、C表利用A表的结点）。

[题目分析]

B表的头结点使用原来A表的头结点，为C表新申请一个头结点。从A表的第一个结点开始，依次取其每个结点p，判断结点p的值是否小于0，利用前插法，将小于0的结点插入B表,大于等于0的结点插入C表。

[算法描述]

 


 


	
void DisCompose(LinkedList A)
	
	

	
{ B=A;
	
	

	
B->next= NULL; ∥B表初始化
	
	

	
C=new LNode;∥为C申请结点空间
	
	

	
C->next=NULL; ∥C初始化为空表
	
	

	
p=A->next; ∥p为工作指针
	
	

	
while(p!= NULL)
	
	

	
{ r=p->next; ∥暂存p的后继
	
	

	
if(p->data<0)
	
	

	
{p->next=B->next; B->next=p; }∥将小于0的结点链入B表,前插法
	
	

	
else {p->next=C->next; C->next=p; }∥将大于等于0的结点链入C表,前插法
	
	

	
p=r;∥p指向新的待处理结点。
	
	

	
}
	
	

	
} 
	
 

 

第3章  栈和队列

1．选择题

（1）若让元素1，2，3，4，5依次进栈，则出栈次序不可能出现在（  ）种情况。

A．5，4，3，2，1   B．2，1，5，4，3    C．4，3，1，2，5   D．2，3，5，4，1

答案：C

解释：栈是后进先出的线性表，不难发现C选项中元素1比元素2先出栈，违背了栈的后进先出原则，所以不可能出现C选项所示的情况。

（2）若已知一个栈的入栈序列是1，2，3，…，n，其输出序列为p1，p2，p3，…，pn，若p1=n，则pi为（  ）。

A．i               B．n-i               C．n-i+1            D．不确定

答案：C

解释：栈是后进先出的线性表，一个栈的入栈序列是1，2，3，…，n，而输出序列的第一个元素为n，说明1，2，3，…，n一次性全部进栈，再进行输出，所以p1=n，p2=n-1，…，pi=n-i+1。

（3）数组Ｑ［ｎ］用来表示一个循环队列，ｆ为当前队列头元素的前一位置，ｒ为队尾元素的位置，假定队列中元素的个数小于ｎ，计算队列中元素个数的公式为（  ）。

A．r-f             B．(n+f-r)%n       C．n+r-f           D．（n+r-f)%n

答案：D

解释：对于非循环队列，尾指针和头指针的差值便是队列的长度，而对于循环队列，差值可能为负数，所以需要将差值加上MAXSIZE（本题为n），然后与MAXSIZE（本题为n）求余，即（n+r-f)%n。

（4）链式栈结点为：(data,link)，top指向栈顶.若想摘除栈顶结点，并将删除结点的值保存到x中,则应执行操作（  ）。

A．x=top->data;top=top->link；      B．top=top->link;x=top->link；    

C．x=top;top=top->link；       D．x=top->link；

答案：A

解释：x=top->data将结点的值保存到x中，top=top->link栈顶指针指向栈顶下一结点，即摘除栈顶结点。

（5）设有一个递归算法如下

        int fact(int n) {  //n大于等于0

             if(n<=0) return 1;

             else return n*fact(n-1);        }

则计算fact(n)需要调用该函数的次数为（  ）。 

A． n+1              B． n-1              C． n                  D． n+2

答案：A

解释：特殊值法。设n=0，易知仅调用一次fact(n)函数，故选A。

（6）栈在 （  ）中有所应用。

A．递归调用       B．函数调用      C．表达式求值        D．前三个选项都有

答案：D

解释：递归调用、函数调用、表达式求值均用到了栈的后进先出性质。

（7）为解决计算机主机与打印机间速度不匹配问题，通常设一个打印数据缓冲区。主机将要输出的数据依次写入该缓冲区，而打印机则依次从该缓冲区中取出数据。该缓冲区的逻辑结构应该是（  ）。

A．队列           B．栈            C． 线性表           D．有序表

答案：A

解释：解决缓冲区问题应利用一种先进先出的线性表，而队列正是一种先进先出的线性表。

（8）设栈S和队列Q的初始状态为空，元素e1、e2、e3、e4、e5和e6依次进入栈S，一个元素出栈后即进入Q，若6个元素出队的序列是e2、e4、e3、e6、e5和e1，则栈S的容量至少应该是（　）。

A．2              B．3              C．4                D． 6

答案：B

解释：元素出队的序列是e2、e4、e3、e6、e5和e1，可知元素入队的序列是e2、e4、e3、e6、e5和e1，即元素出栈的序列也是e2、e4、e3、e6、e5和e1，而元素e1、e2、e3、e4、e5和e6依次进入栈，易知栈S中最多同时存在3个元素，故栈S的容量至少为3。

（9）若一个栈以向量V[1..n]存储，初始栈顶指针top设为n+1，则元素x进栈的正确操作是(    )。

A．top++; V[top]=x; B．V[top]=x; top++;

C．top--; V[top]=x; D．V[top]=x; top--;

答案：C

解释：初始栈顶指针top为n+1，说明元素从数组向量的高端地址进栈，又因为元素存储在向量空间V[1..n]中，所以进栈时top指针先下移变为n，之后将元素x存储在V[n]。

（10）设计一个判别表达式中左，右括号是否配对出现的算法，采用（　）数据结构最佳。

A．线性表的顺序存储结构              B．队列     

C. 线性表的链式存储结构              D. 栈

答案：D

解释：利用栈的后进先出原则。

（11）用链接方式存储的队列，在进行删除运算时（　）。

A. 仅修改头指针                      B. 仅修改尾指针

C. 头、尾指针都要修改                D. 头、尾指针可能都要修改

答案：D

解释：一般情况下只修改头指针，但是，当删除的是队列中最后一个元素时，队尾指针也丢失了，因此需对队尾指针重新赋值。

（12）循环队列存储在数组A[0..m]中，则入队时的操作为（　）。

A. rear=rear+1                       B. rear=(rear+1)%(m-1)

  C. rear=(rear+1)%m                   D. rear=(rear+1)%(m+1) 

答案：D

解释：数组A[0..m]中共含有m+1个元素，故在求模运算时应除以m+1。

（13）最大容量为n的循环队列，队尾指针是rear，队头是front，则队空的条件是（　）。

  A. (rear+1)%n==front                  B. rear==front                                                          

C．rear+1==front                      D. (rear-l)%n==front

答案：B

解释：最大容量为n的循环队列，队满条件是(rear+1)%n==front，队空条件是rear==front。

（14）栈和队列的共同点是（　）。

A. 都是先进先出                       B. 都是先进后出   

C. 只允许在端点处插入和删除元素       D. 没有共同点

答案：C

解释：栈只允许在栈顶处进行插入和删除元素，队列只允许在队尾插入元素和在队头删除元素。

（15）一个递归算法必须包括（　）。

A. 递归部分                           B. 终止条件和递归部分

C. 迭代部分                           D. 终止条件和迭代部分

答案：B

 

 

 

第5章  树和二叉树

1．选择题

（1）把一棵树转换为二叉树后，这棵二叉树的形态是（   ）。              

A．唯一的                          Ｂ．有多种

C．有多种，但根结点都没有左孩子    Ｄ．有多种，但根结点都没有右孩子

答案：A

解释：因为二叉树有左孩子、右孩子之分，故一棵树转换为二叉树后，这棵二叉树的形态是唯一的。

（2）由3个结点可以构造出多少种不同的二叉树？（    ）

A．2          B．3             C．4          D．5   

答案：D

（3）一棵完全二叉树上有1001个结点，其中叶子结点的个数是（  ）。

A．250         B． 500          C．254        D．501   

答案：D

解释：设度为0结点（叶子结点）个数为A，度为1的结点个数为B，度为2的结点个数为C，有A=C+1，A+B+C=1001，可得2C+B=1000，由完全二叉树的性质可得B=0或1，又因为C为整数，所以B=0，C=500，A=501，即有501个叶子结点。

（4）一个具有1025个结点的二叉树的高h为（  ）。

A．11          B．10             C．11至1025之间       D．10至1024之间

答案：C

解释：若每层仅有一个结点，则树高h为1025；且其最小树高为 ëlog21025û + 1=11，即h在11至1025之间。

（5）深度为h的满m叉树的第k层有（  ）个结点。(1=<k=<h)

A．mk-1          B．mk-1            C．mh-1        D．mh-1

答案：A

解释：深度为h的满m叉树共有mh-1个结点，第k层有mk-1个结点。

（6）利用二叉链表存储树，则根结点的右指针是（  ）。

A．指向最左孩子        B．指向最右孩子         C．空        D．非空

答案：C

解释：利用二叉链表存储树时，右指针指向兄弟结点，因为根节点没有兄弟结点，故根节点的右指针指向空。

（7）对二叉树的结点从1开始进行连续编号，要求每个结点的编号大于其左、右孩子的编号，同一结点的左右孩子中，其左孩子的编号小于其右孩子的编号，可采用（  ）遍历实现编号。

A．先序         B. 中序           C. 后序       D. 从根开始按层次遍历

答案：C

解释：根据题意可知按照先左孩子、再右孩子、最后双亲结点的顺序遍历二叉树，即后序遍历二叉树。

（8）若二叉树采用二叉链表存储结构，要交换其所有分支结点左、右子树的位置，利用（  ）遍历方法最合适。

A．前序         B．中序            C．后序      D．按层次

答案：C

解释：后续遍历和层次遍历均可实现左右子树的交换，不过层次遍历的实现消耗比后续大，后序遍历方法最合适。

（9）在下列存储形式中，（  ）不是树的存储形式？

A．双亲表示法   B．孩子链表表示法   C．孩子兄弟表示法   D．顺序存储表示法

答案：D

解释：树的存储结构有三种：双亲表示法、孩子表示法、孩子兄弟表示法，其中孩子兄弟表示法是常用的表示法，任意一棵树都能通过孩子兄弟表示法转换为二叉树进行存储。

（10）一棵非空的二叉树的先序遍历序列与后序遍历序列正好相反，则该二叉树一定满足（  ）。

A．所有的结点均无左孩子        B．所有的结点均无右孩子

C．只有一个叶子结点            D．是任意一棵二叉树

答案：C

解释：因为先序遍历结果是“中左右”，后序遍历结果是“左右中”，当没有左子树时，就是“中右”和“右中”；当没有右子树时，就是“中左”和“左中”。则所有的结点均无左孩子或所有的结点均无右孩子均可，所以A、B不能选，又所有的结点均无左孩子与所有的结点均无右孩子时，均只有一个叶子结点，故选C。

（11）设哈夫曼树中有199个结点，则该哈夫曼树中有（    ）个叶子结点。

A．99 B．100

C．101 D．102

答案：B

解释：在哈夫曼树中没有度为1的结点，只有度为0（叶子结点）和度为2的结点。设叶子结点的个数为n0，度为2的结点的个数为n2，由二叉树的性质n0=n2+1，则总结点数n= n0+n2=2*n0-1，得到n0=100。

（12）若X是二叉中序线索树中一个有左孩子的结点，且X不为根，则X的前驱为（  ）。

A．X的双亲                      B．X的右子树中最左的结点 

C．X的左子树中最右结点          D．X的左子树中最右叶结点

答案：C

（13）引入二叉线索树的目的是（  ）。

A．加快查找结点的前驱或后继的速度    B．为了能在二叉树中方便的进行插入与删除

C．为了能方便的找到双亲              D．使二叉树的遍历结果唯一

答案：A

（14）设F是一个森林，B是由F变换得的二叉树。若F中有n个非终端结点，则B中右指针域为空的结点有（   ）个。

A．n−1 B．n C．n + 1 D．n + 2

答案：C

（15）n（n≥2）个权值均不相同的字符构成哈夫曼树，关于该树的叙述中，错误的是（ ）。

A．该树一定是一棵完全二叉树

B．树中一定没有度为1的结点

C．树中两个权值最小的结点一定是兄弟结点

D．树中任一非叶结点的权值一定不小于下一层任一结点的权值

答案：A

解释：哈夫曼树的构造过程是每次都选取权值最小的树作为左右子树构造一棵新的二叉树，所以树中一定没有度为1的结点、两个权值最小的结点一定是兄弟结点、任一非叶结点的权值一定不小于下一层任一结点的权值。

2．应用题

（1）试找出满足下列条件的二叉树

① 先序序列与后序序列相同    ②中序序列与后序序列相同

③ 先序序列与中序序列相同    ④中序序列与层次遍历序列相同

答案：先序遍历二叉树的顺序是“根—左子树—右子树”，中序遍历“左子树—根—右子树”，后序遍历顺序是：“左子树—右子树―根＂，根据以上原则有

① 或为空树，或为只有根结点的二叉树

②  或为空树，或为任一结点至多只有左子树的二叉树．

③  或为空树，或为任一结点至多只有右子树的二叉树．

④ 或为空树，或为任一结点至多只有右子树的二叉树

 

（2）设一棵二叉树的先序序列： A B D F C E G H ，中序序列： B F D A G E H C

①画出这棵二叉树。

②画出这棵二叉树的后序线索树。

③将这棵二叉树转换成对应的树（或森林）。

答案：



第六章

 

1．选择题

1-4：CBBB

 

 

（5）G是一个非连通无向图，共有28条边，则该图至少有（   ）个顶点。

A．7              B．8             C．9             D．10 

答案：C

解释：8个顶点的无向图最多有8*7/2=28条边，再添加一个点即构成非连通无向图，故至少有9个顶点。

6-12:BABAADC

13-15:CDB

 

2．应用题

（1）



第七章

(1)C (2)D (3)C (4)A (5)B (6)C (7)C (8)C (9)C (10)C (11)B (12)C (13)A  (14)D (15)A 

 

第八章

1.选择题

1-5：CDBDC          6-10:BCDBC      

11-15:BCCCA