数据结构与算法——每日一练（5月）

每日一练

5.1

• 下面的程序打印输出的分别是( )?

public class Main {
    public static void main(String[] args) {
        Integer f1 = 100, f2 = 100, f3 = 150, f4 = 150;
        System.out.println(f1 == f2);
        System.out.println(f3 == f4);
    }
}

A. true true

B. true false

C. false true

D. false false

【答案】B

【解析】如果整型字面量的值在-128到127之间，那么不会new新的Integer对象， 而是直接引用常量池中的Integer对象，所以上面题中f1，f2的结果是true，而f3，f4的结果是false。

5.2

• 这条语句String s="a”+“b”+“c”+“d”一共创建了多少个对象?

A. 1

B. 2

C. 6

D. 7

【答案】A

【解析】赋值符号右边的"a"、“b”、“c”、“d"都是常量，对于常量， 编译时就直接存储它们的字面值而不是它们的引用，在编译时就直接将它们连接的结果提取出来变成了"abcd” 该语句在class文件中就相当于String s = “abcd”。

5.3

• (堆结构复习题) 下列4个序列中，（）是堆。

A. {75, 60, 30, 15, 25, 45, 20, 10}

B. {75, 65, 45, 10, 30, 25, 20, 15}

C. {75, 45, 65, 30, 15, 25, 20, 10}

D. {75, 45, 65, 10, 25, 30, 20, 15}

【答案】C

【解析】画出每个堆结构对应的树即可得到答案。选项A中存在边30-45不满足性质，选项B中存在边10-15不满足性质，选项D中存在边10-15不满足性质。因此选C。

5.4

• (排序预习题) 下列排序算法中，（）是稳定的。 ① 插入排序 ② 快速排序 ③ 堆排序 ④ 归并排序

A. ①和②

B. ②和③

C. ③和④

D. ①和④

【答案】D

5.5

• (排序预习题) 对一组关键字{84, 47, 25, 15, 21}排序，关键字的排列次序在排序过程中的变化为： ① {84, 47, 25, 15, 21} ② {15, 47, 25, 84, 21} ③ {15, 21, 25, 84, 47} ④ {15, 21, 25, 47, 84} 则采用的排序可能是（）。

A. 简单选择排序

B. 堆排序

C. 快速排序

D. 直接插入排序

【答案】A

5.6

• (排序预习题) 以下排序算法中，（）不能保证每趟排序至少能将一个关键字放在其最终位置上。

A. 快速排序

B. 希尔排序

C. 堆排序

D. 冒泡排序

【答案】B

【解析】选项A，快速排序，每趟排序后将当前子序列划分为两部分的那个关键字（“枢轴”）到达了其最终位置。 选项C，堆排序，每趟排序后，当前待排序列中的最大或者最小关键字到达其最终位置。 选项D，冒泡排序，每趟排序后，当前待排序列中的最大或者最小关键字到达其最终位置。 选项B，希尔排序是直接插入排序的改进，每趟排序后不能保证一定有关键字到达最终位置。

5.7

• (排序预习题) 若关键字序列{11, 12, 13, 7, 8, 9, 23, 4, 5}是采取下列排序算法之一得到的第二趟排序后的结果，则该排序算法只能是（）

A. 冒泡排序

B. 插入排序

C. 选择排序

D. 归并排序

【答案】B

【解析】若是冒泡排序或者选择排序，则第二趟后应有两个最大或者最小的关键字正确排列，而结果不符。二路归并排序第二趟后，应形成两个长度为4的有序子序列，结果也不符合。所以答案只能是插入排序。两次插入后，前3个数字的顺序是对的。

5.8

• 从以下哪一个选项中可以获得Servlet的初始化参数。

A. Servlet

B. ServletContext

C. ServletConfig

D. GenericServlet

【答案】C

【解析】servlet的生命周期的方法中有一个init方法， 其中一个重载的init方法的参数为ServletConfig可以获取初始化参数。

5.9

• 下列哪个为JSP的内置对象。

A. env

B. page

C. jspinfo

D. context

【答案】B

【解析】JSP有九个内置对象：① request：保存了很多客户端请求的信息；② response：生成服务器端响应，然后将响应结果发送到客户端；③ out：表示输出流，此输出流将作为请求发送到客户端；④ session：我们写的对象放在这个session对象中，这个对象就在我们的会话中都存在；⑤ application：我们写的对象放在这个application对象中，这个对象就在整个应用程序中都存在；⑥ pageContext：相当于当前页面的容器，可以访问当前页面的所有对象；⑦ page：一般我们使用 page 来替代使用这个对象；⑧ exception：用来处理异常的；⑨ config：一般在页面中是使用很少的，一般会在Servlet中使用这个。

5.10

• 在下列算法中，（）算法可能出现下列情况：在最后一趟开始之前，所有元素都不在最终位置上。

A. 堆排序

B. 冒泡排序

C. 直接插入排序

D. 快速排序

【答案】C

【解析】在直接插入排序中，若待排序列中的最后一个元素应插入到表中的第一个位置，则前面的有序子序列中的所有元素都不在最终位置上。

5.11

• 对n个不同的元素利用冒泡排序从小到大排序，在（）情况下元素交换的次数最多

A. 从大到小排序好的

B. 从小到大排序好的

C. 元素无序

D. 元素基本有序

【答案】A

【解析】通常情况下，冒泡排序最少进行1次冒泡，最多进行n-1次冒泡。初始序列为逆序时，需进行n-1次冒泡，并且需要交换的次数最多。初始序列为正序时，进行1次冒泡（无交换）就可以终止算法。

5.12

• 下列选项中，不可能是快速排序第2趟排序结果的是（）。

A. 2, 3, 5, 4, 6, 7, 9

B. 2, 7, 5, 6, 4, 3, 9

C. 3, 2, 5, 4, 7, 6, 9

D. 4, 2, 3, 5, 7, 6, 9

【答案】C

【解析】快排的阶段性排序结果的特点是，第i趟完成时，会有i个以上的数出现在它最终将要出现的位置，即它左边的数都比它小，它右边的数都比它大。 题目问第二趟排序的结果，即要找不存在两个这样的数的选项。 A选项中2，3，6，7，9均符合，所以A排除； B选项中，2，9均符合，所以B排除； D选项中5，9均符合，所以D排除； 最后看C选项，只有9一个数符合，所以C不可能是快速排序第二趟的结果。

5.13

• 对下列关键字序列用快排进行排序时（每次取待排序的子表的第一个元素作为枢轴），速度最快的情形是（）

A. {21, 25, 5, 17, 9, 23, 30}

B. {25, 23, 30, 17, 21, 5, 9}

C. {21, 9, 17, 30, 25, 23, 5}

D. {5, 9, 17, 21, 23, 25, 30}

【答案】A

【解析】当每次的枢轴都把表等分为长度相近的两个子表时，速度是最快的；当表本身已经有序或逆序时，速度最慢。选项D中的序列已按关键字排好序，因此它是最慢的，而A中第一趟枢轴值21将表划分为两个子表{9，17，5}和（25，23，30}，而后对两个子表划分时，枢轴值再次将它们等分，所以该序列是快速排序最优的情况，速度最快。

5.14

• 数据序列 F = {2，1，4，9，8，10，6，20} 只能是下列排序算法中的（）两趟排序后的结果

A. 快速排序

B. 冒泡排序

C. 选择排序

D. 插入排序

【答案】A

【解析】若为插入排序，则前三个元素应该是有序的，显然不对。而冒泡排序和选择排序经过两趟排序后应该有两个元素处于最终位置（最左/右端），无论是按从小到大还是从大到小排序，数据序列中都没有两个满足这样的条件的元素，因此只可能选A。

5.15

• 下列程序运行的结果（）

public class Example {
    String str = new String("good");
    char[] ch = {'a', 'b', 'c'};

    public static void main(String[] args) {
        Example ex = new Example();
        ex.change(ex.str, ex.ch);
        
        System.out.println(ex.str + " and ");
        System.out.println(ex.ch);
    }
    public void change(String str, char[] ch) {
        str = "test ok";
        ch[0] = 'g';
    }
}

A. good and abc

B. good and gbc

C. test ok and abc

D. test ok and gbc

【答案】B

【解析】有两变量str，一个是成员变量(可以写成this.str)，一个是局部变量(str)， 调用change时将成员变量str（this.str）传给str， 此时this.str与str指向了同一个字符串：good，当执行str="test OK"后， this.str=“good” str=“test OK”，然后change方法结束， str结束生命。所以你打印的的内容是“good”，也就是this.str的内容。 ch数组的内容：由于change中的ch[0]与外面的ch[0]指向的是同一个位置，所以它改变数组的内容。

5.16

• 有关Servlet的生命周期说法正确的有（）。

A. Servlet的生命周期由Servlet实例控制

B. init()方法在创建完Servlet实例后对其进行初始化，传递的参数为实现ServletContext接口的对象

C. service()方法响应客户端发出的请求

D. destroy()方法释放Servlet实例

【答案】C

【解析】Servlet 生命周期就是指创建 Servlet 实例后响应客户请求直至销毁的全过程。Serlvet 生命周期的三个方法：init()–>service()–>destroy()。 Servlet生命周期的各个阶段：① 实例化：Servlet 容器创建 Servlet 类的实例对象；② 初始化：Servlet 容器调用 Servlet 的 init() 方法；③ 服务：如果请求 Servlet，则容器调用 service() 方法；④ 销毁：销毁实例之前调用 destroy() 方法。

5.17

• 对同一待排序序列分别进行折半插入排序和直接插入排序，两者之间可能的不同之处是（）。

A. 排序的总趟数

B. 元素的移动次数

C. 使用辅助空间的数量

D. 元素之间的比较次数

【答案】D

【解析】折半插入排序与直接插入排序都将待插入元素插入前面的有序子表，区别是：确定当前记录在前面有序子表中的位置时，直接插入排序采用顺序查找法，而折半插入排序采用折半查找法。排序的总趟数取决于元素个数$n$，两者都是$n-1$趟。 元素的移动次数都取决于初始序列，两者相同。 使用辅助空间的数量也都是$O(1)$。 折半插入排序的比较次数与序列初态无关，为$O(n\lg n)$； 而直接插入排序的比较次数与序列初态有关，为$O(n)$~$O(n^2)$

5.18

• 采用递归方式对顺序表进行快速排序。下列关于递归次数的叙述中，正确的是（）。

A. 递归次数与初始数据的排列次序无关

B. 每次划分后，先处理较长的分区可以减少递归次数

C. 每次划分后，先处理较短的分区可以减少递归次数

D. 递归次数与每次划分后得到的分区的处理顺序无关

【答案】D

【解析】递归次数与各元素的初始排列有关。若每次划分后分区比较平衡，则递归次数少；若分区不平衡，递归次数多。递归次数与处理顺序是没有关系的。

5.19

• 对下列4个序列，以第一个关键字为基准用快速排序算法进行排序，在第一趟过程中移动记录次数最多的是（）。

A. 92、96、88、42、30、35、110、100

B. 92、96、100、110、42、35、30、88

C. 100、96、92、35、30、110、88、42

D. 42、30、35、92、100、96、88、110

【答案】B

【解析】对各序列分别执行一趟快速排序，可做如下分析（以A为例）：由于枢轴值为92，因此35移动到第一个位置，96移动到第六个位置，30移动到第二个位置，再将枢轴值移动到30所在的单元，即第五个位置，所以A中序列移动的次数为4。 同样，可以分析出B中序列的移动次数为8，C中序列的移动次数为4，D中序列的移动次数为2。

5.20

• 对10TB的数据文件进行排序，应使用的方法是（）。

A. 希尔排序

B. 堆排序

C. 快速排序

D. 归并排序

【答案】D

5.21

• 在内部排序时，若选择了归并排序而未选择插入排序，则可能的理由是（）。

  I. 归并排序的程序代码更短 II.归并排序的占用空间更少 III.归并排序的运行效率更高

A. 仅II

B. 仅III

C. 仅I、II

D. 仅I、III

【答案】B

5.22

• 下列哪种说法是正确的（）

A. 实例方法可直接调用超类的实例方法

B. 实例方法可直接调用超类的类方法

C. 实例方法可直接调用其他类的实例方法

D. 实例方法可直接调用本类的类方法

【答案】D

【解析】A. 实例方法不可直接调用超类的私有实例方法；B. 实例方法不可直接调用超类的私有的类方法；C．要看访问权限。

5.23

• 下列哪一种叙述是正确的（ ）

A. abstract修饰符可修饰字段、方法和类

B. 抽象方法的body部分必须用一对大括号{ }包住

C. 声明抽象方法，大括号可有可无

D. 声明抽象方法不可写出大括号

【答案】D

【解析】abstract可以修饰方法和类，不能修饰属性。抽象方法没有方法体，即没有大括号{}

5.24

• 若查找每个关键字的概率均等，则在具有 $n$ 个关键字的顺序表中采用顺序查找法查找一个记录，其查找成功的平均查找长度ASL为（）。

A. $\frac{n-1}{2}$

B. $\frac{n}{2}$

C. $\frac{n+1}{2}$

D. $n$

【答案】C

【解析】$ASL=\frac{1+2+\cdots +n}{n}=\frac{n+1}{2}$

5.25

• 下列关于折半查找的叙述正确的是（）。

A. 表必须有序，表可以以顺序方式存储，也可以以链表形式存储。

B. 表必须有序，而且只能从小到大排列。

C. 表必须有序，且表中关键字必须是整形、实型或字符型。

D. 表必须有序，且表只能以顺序方式存储。

【答案】D

【解析】选项A，折半查找不适用于链表。 选项B，折半查找未要求元素是递增有序还是递减有序。 选项C，折半查找未要求数据类型。

5.26

• 具有12个关键字的有序表，对每个关键字的查找概率相同，折半查找成功的平均查找长度ASL为（）。

A. 37/12

B. 35/12

C. 39/12

D. 43/12

【答案】A

【解析】$12=1+2+4+5$ ，平均查找长度 $ASL=\frac{1\ast 1+2\ast 2+3\ast 4+4\ast 5}{12}=\frac{37}{12}$ 。

5.27

• 对于同一个表，用二分查找法查找表的元素的速度比用顺序法（）。

A. 必然快

B. 必然慢

C. 相等

D. 不确定

【答案】D

5.28

• 顺序查找法适合于存储结构为（）的线性表。

A. 散列存储

B. 顺序存储或链式存储

C. 压缩存储

D. 索引存储

【答案】B

5.29

• 关于sleep()和wait()，以下描述错误的一项是（ ）

A. sleep是线程类（Thread）的方法，wait是Object类的方法；

B. sleep不释放对象锁，wait放弃对象锁；

C. sleep暂停线程、但监控状态仍然保持，结束后会自动恢复；

D. wait后进入等待锁定池，只有针对此对象发出notify方法后获得对象锁进入运行状态。

【答案】D

【解析】sleep是线程类（Thread）的方法，导致此线程暂停执行指定时间，给执行机会给其他线程， 但是监控状态依然保持，到时候会自动恢复。调用sleep不会释放对象锁。wait是Object类的方法，对此对象调用wait方法导致本线程放弃对象锁，进入等待此对象的等待锁定池，只有针对此对象发出notify方法（或notifyAll）后本线程才进入对象锁定池准备，获得对象锁进入运行状态

5.30

• 方法resume()负责恢复哪些线程的执行（ ）

A. 通过调用stop()方法而停止的线程。

B. 通过调用sleep()方法而停止的线程。

C. 通过调用wait()方法而停止的线程。

D. 通过调用suspend()方法而停止的线程。

【答案】D

【解析】Suspend可以挂起一个线程，就是把这个线程暂停了，它占着资源但不运行，用Resume是恢复挂起的线程，

让这个线程继续执行下去。

5.31

• 二分查找过程所对应的判定树是一棵（）。

A. 最小生成树

B. 平衡二叉树

C. 完全二叉树

D. 满二叉树

【答案】B