每日一练

7.1

• 以下叙述中，正确的是（）。

A. 只要无向连通图中没有权值相同的边，则其最小生成树唯一

B. 只要无向图中有权值相同的边，则其最小生成树一定不唯一

C. 从n个顶点的连通图中选取n-1条权值最小的边，即可构成最小生成树

D. 设连通图G含有n个顶点，则含有n个顶点，n-1条边的子图一定是G的生成树

【答案】A

7.2

• 以下叙述中，正确的是（）。

A. 最短路径一定是简单路径

B. Dijkstra算法不适合求有回路的带权图的最短路径

C. Dijkstra算法不适合求任意两个顶点的最短路径

D. Floyd算法求两个顶点的最短路径时，path[k-1]一定是path[k]的子集

【答案】A

【解析】Dijkstra不适合带负权值的最短路径问题。 在用Floyd算法求两个顶点的最短路径时，当最短路径发生变更时，path[k-1]就不是path[k]的子集。

7.3

• 编译和执行下面的程序时将输出什么?

public class Base {
    
    private void test() {
    
        System.out.println(6 + 6 + "(Result)");
    }

    static public void main(String[] a) {
    
        new Base().test();

    }
}

A. 66(Result)

B. 12(Result)

C. Runtime Error.Incompatible type for +. Can’t convert an int to a string.

D. Compilation Error.Incompatible type for +. Can’t add a string to an int.

【答案】B

【解析】字符串与基本数据类型链接的问题,如果第一个是字符串那么后续就都按字符串处理， 比如上边例子要是System.out.println(“(Result)”+6 + 6 );那么结果就是(Result)66， 如果第一个和第二个。。。第n个都是基本数据第n+1是字符串类型，那么前n个都按 加法计算出结果在与字符串连接

7.4

• 下列关于修饰符混用的说法，错误的是（ ）

A. abstract不能与final并列修饰同一个类

B. abstract类中可以有private的成员

C. abstract方法必须在abstract类中

D. static方法中能处理非static的属性

【答案】D

【解析】静态方法中不能引用非静态的成员

7.5

• 设一组初始记录关键字序列为 (49,38,65,97,76,13,27,49)，则以第一个关键字49为基准而得到的一趟快速排序结果是：（）。

A. 38，13，27，49，49，65，97，76

B. 13，27，38，49，65，76，97，49

C. 27，38，13，49，76，97，65，49

D. 27，38，13，49，97，76，65，49

【答案】C

【解析】以49为基准，取出49，两个指针，前指针指向38，后指针指向最后一个49 首先移动后指针，找到27<49，将27放在 0 位置，后指针前移 再根据前指针查找，65>49，将65放在原27的位置 现在结果是 27,38,空位,97,76,13,65,49 继续用后指针查找，13<49,放在空位中，后指针前移， 结果是 27,38,13,97,76,空位,65,49 继续前指针查找，97>49，放在空位，变成27,38,13,空位,76,97,65,49 然后前后指针都指向76，结束，将49放入空位中，得到27,38,13,49,76,97,65,49。

7.6

• 在用邻接表表示图时，拓扑排序算法时间复杂度为（）。

A. O(n)

B. O(n+e)

C. O(n*n)

D. O(n*n*n)

【答案】B

7.8

• 设一组初始记录关键字序列为(13，18，24，35，47，50，62，83，90，115，134)，则利用二分法查找关键字90需要比较的关键字个数为（）。

A. 1

B. 2

C. 3

D. 4

【答案】B

【解析】共计11个元素，下标为[0,10]；left = 0, right = 10, mid = (0+10)/2=5, a[5] == 50 < 90, left = mid + 1 = 6；left = 6, right = 10, mid = (6+10)/2=8, a[8] == 90 == 90。

7.7

• 下列叙述中正确的是（）。

A. 算法的效率只与问题的规模有关，而与数据的存储无关

B. 算法的时间复杂度是指执行算法所需要的计算工作量

C. 数据的逻辑结构与存储结构是一一对应的

D. 算法的时间复杂度与空间复杂度一定相关

【答案】B

7.9

• 希尔排序法属于哪一种类型的排序法（）。

A. 插入类排序

B. 交换类排序

C. 选择排序

D. 堆排序

【答案】A

【解析】希尔排序法(缩小增量法)属于插入类排序，是将整个无序列分割成若干小的子序列分别进行插入排序的方法。

7.10

• 执行完以下代码后，以下哪项说明是正确的（）

int[] x = new int[25];

A. x[24]为0

B. x[24]未定义

C. x[25]为0

D. x[0]为空

【答案】A

【解析】x属于引用类型，该引用类型的每一个成员是int类型，默认值为：0

7.11

• 编译运行以下程序后，关于输出结果的说明正确的是 （ ）

public class Conditional {
    
    public static void main(String[] args) {
    
        int x = 4;
        System.out.println("value is " + ((x > 4) ? 99.9 : 9));
    }
}

A. 输出结果为：value is 99.99

B. 输出结果为：value is 9

C. 输出结果为：value is 9.0

D. 编译错误

【答案】C

【解析】三目运算符中：第二个表达式和第三个表达式中如果都为基本数据类型，整个表达式的运算结果由容量高的决定。99.9是double类型 而9是int类型，double容量高。

7.12

• 若二叉树T的前序遍历序列和中序遍历序列分别为bdcaef和cdeabf，则其后序遍历为（）。

A. ceadfb

B. feacdb

C. eacdfb

D. 以上都不对

【答案】A

7.13

• 若某线性表最常用的操作是存取任一指定序号的元素和在最后进行插入和删除运算，则采用（）方式最节省时间。

A. 顺序表

B. 双链表

C. 带头节点的双循环链表

D. 单循环链表

【答案】A

7.14

• 下列情况中，不能使用栈来解决问题的是（）。

A. 将数学表达式转化为后缀形式。

B. 实现递归算法

C. 高级编程语言的过程调用

D. 操作系统分配资源(如CPU)

【答案】D

7.15

• 在154个元素组成的有序表中进行二分查找，不可能的比较次数为（）。

A. 10

B. 7

C. 4

D. 1

【答案】A

7.16

• 便于在任意位置插入和删除的容器是（）。

A. 单链表

B. 数组

C. hashmap

D. 队列

【答案】C

7.17

• 关于以下程序的说明，正确的是（ ）：

class StaticStuff {
    
    static int x = 10;
    
    static {
    
        x += 5;
    }
    
    public static void main(String[] args) {
    
        System.out.println("x = " + x);
    }
    
    static {
    
        x /= 3;
    }
}

A. 4行与9行不能通过编译，因为缺少方法名和返回类型

B. 9行不能通过编译，因为只能有一个静态初始化器

C. 编译通过，执行结果为：x=5

D. 编译通过，执行结果为：x=3

【答案】C

【解析】自由块是类加载的时候就会被执行到的，自由块的执行顺序是按照在类中出现的先后顺序执行。

7.18

• 关于以下程序代码的说明正确的是（ ）：

class HasStatic {
    
    private static int x = 100;
    public static void main(String[] args) {
    
        HasStatic hs1 = new HasStatic();
        
        hs1.x++;
        
        HasStatic hs2 = new HasStatic();
        hs2.x++;
        hs1 = new HasStatic();
        
        hs1.x++;
        
        HasStatic.x--;
        
        System.out.println("x = " + x);
    }
}

A. 5行不能通过编译，因为引用了私有静态变量

B. 10行不能通过编译，因为x是私有静态变量

C. 程序通过编译，输出结果为：x=103

D. 程序通过编译，输出结果为：x=102

【答案】D

【解析】静态变量是所有对象所共享的，所以上述代码中的几个对象操作是同一静态变量x， 静态变量可以通过类名调用。

7.19

• 数组作为函数参数时，传递的是（）。

A. 数组的首地址

B. 数组元素个数

C. 数组中各元素的值

D. 数组的大小

【答案】A

7.20

• 采用邻接表存储的图按DFS进行遍历的算法类似于二叉树的（）。

A. 先序遍历

B. 中序遍历

C. 后序遍历

D. 层序遍历

【答案】A

7.21

• 若某线性表最常用的操作是在最后一个元素之后插入一个元素和删除进入表中的最后一个元素，则采用（）存储方式最节省运算时间。

A. 单链表

B. 仅有尾指针的单循环链表

C. 双向链表

D. 双向循环链表

【答案】D

7.22

• 设有序表的序列为 {1,4,6,10,18,35,42,53,67,71,78,84,92,99}，当用二分查找来查找键值为35的节点时，经（）次比较后查找成功。

A. 2

B. 3

C. 4

D. 5

【答案】C

【解析】left = 0, right = 13, mid = (0 + 13)/2 = 6, a[6] = 42 > 35, right = mid - 1 = 5；left = 0, right = 5, mid = (0 + 5) / 2 = 2, a[2] = 10 < 35, left = mid + 1 = 3；left = 3, right = 5, mid = (3 + 5) / 2 = 4, a[4] = 18 < 35, left = mid + 1 = 5；left = 5, right = 5, mid = (5 + 5) / 2 = 5, a[5] = 35 查找完毕。

7.23

• 一个有向图G=(V,E)，顶点集合V={1,2,3,4,5,6,7}，边集合E={(1,2),(1,3),(2,4),(3,4),(4,5),(4,6),(5,7),(6,7)}，从顶点1出发进行深度优先遍历，可得到的顶点序列是（）。

A. 1 2 3 4 5 6 7

B. 1 2 4 3 6 7 5

C. 1 3 4 5 7 6 2

D. 1 2 4 6 5 7 3

【答案】C

7.24

• 下列说法正确的有（）

A. class中的constructor不可省略

B. constructor必须与class同名，但方法不能与class同名

C. constructor在一个对象被new时执行

D. 一个class只能定义一个constructor

【答案】C

【解析】构造方法的作用是在实例化对象的时候给数据成员进行初始化。A：类中如果没有显示的给出构造方法，系统会提供一个无参构造方法；B：构造方法与类同名，类中可以有和类名相同的方法；D：构造方法可以重载。

7.25

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

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

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

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

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

【答案】D

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

7.26

• int (*p)[3]中p的含义是什么？

A. 一个大小为3的int指针的数组

B. 一个指向元素个数为3的int数组的指针

C. 不合法

D. 以上说法均不正确

【答案】B

7.27

• 设森林T中有三棵树，第一、第二、第三棵树的节点个数分别为N1,N2和N3。以第一棵树的根节点为根，与森林T对应的二叉树根节点的右子树上的节点个数是（）。

A. N1

B. N1 + N2

C. N3

D. N2 + N3

【答案】D

7.28

• 两个顺序栈共享数组S[0…n-1]，其中第一个栈的栈顶指针top1的初始值为-1，第二个栈的栈顶指针top2的初始值为n，则判断该共享栈满的条件是（）。

A. top2+2=top1

B. top1+1=top2

C. top1+2=top2

D. top2+1=top1

【答案】B

7.29

• 二叉树是非线性数据结构，所以（）。

A. 它不能用顺序存储结构存储

B. 它不能用链式存储结构存储

C. 顺序存储结构和链式存储结构都能使用

D. 顺序存储结构和链式存储结构都不能使用

【答案】C

7.30

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

A. 问题的规模

B. 待处理数据的初始状态

C. A 和 B 均正确

【答案】C

7.31

• 下列哪一种叙述是正确的( )

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

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

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

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

【答案】D

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