第 1 题（编程题）
题目名称：
插入排序和希尔排序
题目内容：
// 插入排序 public static void insertSort(int[] array){ // write code here } // 希尔排序 public static void shellSort(int[] array){ // write code here }
第 2 题（编程题）
题目名称：
选择排序和堆排序
题目内容：
// 选择排序 public static void selectSort(int[] array){ // write code here } // 堆排序 public static void heapSort(int[] array){ // write code here }
第 3 题（编程题）
题目名称：
冒泡排序和快速排序
题目内容：
// 冒泡排序 public static void bubbleSort(int[] array){ // write code here } // 快速 public static void quickSort(int[] array){ // write code here }
第 1 题（单选题）
题目名称：
2.使用选择排序对长度为100的数组进行排序，则比较的次数为（ ）
题目内容：
A .5050
B .4950
C .4851
D .2475
第 2 题（单选题）
题目名称：
3.有字符序列 FBJGEAIDCH，现在打算对它按字母的字典顺序用希尔排序进行排序，那么在第一趟后（步长为5）的序列为（ ）
题目内容：
A .CAEBFDIGJH
B .AIDCHFBJGE
C .ABDCEFIJGH
D .BFJGEAIDCH
第 3 题（单选题）
题目名称：
4.现有数字序列 5 11 7 2 3 17，目前要通过堆排序进行降序排序，那么由该序列建立的初始堆应为（ ）
题目内容：
A .2 3 7 11 5 17
B .17 11 7 2 3 5
C .17 11 7 5 3 2
D .2 3 5 7 11 17
第 4 题（单选题）
题目名称：
5.下列关于归并排序的说法中正确的是（ ）
题目内容：
A .归并排序不需要辅助空间
B .归并排序的时间复杂度是O(logn)
C .归并排序是稳定排序
D .归并排序的操作方式类似二叉树的前序遍历
第 5 题（单选题）
题目名称：
6.对数字序列28 16 32 12 60 2 5 72进行升序的快速排序（以第一个关键码为基准的方法），一次划分后的结果为（ ）
题目内容：
A .2 5 12 16 28 60 32 72
B .2 16 5 12 28 60 32 72
C .2 16 12 5 28 60 32 72
D .5 16 2 12 28 32 60 72
第 6 题（单选题）
题目名称：
7.下列选项中，不可能是快速排序第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
第 7 题（单选题）
题目名称：
8.对n个元素执行快速排序，需要的额外空间的大小为（ ）
题目内容：
A .O(1)
B .O(n)
C .O(logn)
D .O(nlogn)
第 8 题（单选题）
题目名称：
9.下列关于三数取中法快速排序的描述错误的是（ ）
题目内容：
A .三数取中法可以有效避免快排单链的情况，尤其对已经有序的序列的速度改善尤为明显
B .三数取中法依然无法完全解决针对某种特殊序列复杂度变为O(n)的情况
C .三数取中法一般选取首、尾和正中三个数进行取中
D .三数取中法的快速排序在任何情况下都是速度最快的排序方式
第 9 题（单选题）
题目名称：
1.对关键字{10,20,8,25,35,6,18,30,5,15,28}序列进行希尔排序，取增量d =5时，排序结果为
题目内容：
A .{6,18,8,5,15,10,20,30,25,35,28}
B .{10,18,8,5,15,6,20,30,25,35,28}
C .{10,20,8,5,15,6,18,30,25,35,28}
D .{10,20,30,5,8,6,15,18,25,28,35}
第 10 题（单选题）
题目名称：
2.以下排序方式中占用O（n）辅助存储空间的是
题目内容：
A .简单排序
B .快速排序
C .堆排序
D .归并排序
第 11 题（单选题）
题目名称：
3.若需在O(nlog2n)的时间内完成对数组的排序，且要求排序是稳定的，则可选择的排序方法是
题目内容：
A .快速排序
B .堆排序
C .归并排序
D .直接插入排序
第 12 题（单选题）
题目名称：
4.关于排序，下面说法不正确的是
题目内容：
A .快排时间复杂度为O(N*logN)，空间复杂度为O(logN)
B .归并排序是一种稳定的排序,堆排序和快排均不稳定
C .序列基本有序时，快排退化成冒泡排序，直接插入排序最快
D .归并排序空间复杂度为O(N), 堆排序空间复杂度的为O(logN)
第 13 题（单选题）
题目名称：
5.下列各排序法中，最坏情况下的时间复杂度最低的是
题目内容：
A .希尔排序
B .快速排序
C .堆排序
D .冒泡排序
第 14 题（编程题）
题目名称：
归并排序和计数排序
题目内容：
// 归并排序---递归 public static void mergeSort(int[] array){ // write code here } // 归并排序---非递归 public static void mergeSort(int[] array){ // write code here } // 计数排序 public static void countSort(int[] array){ // write code here }
第 15 题（编程题）
题目名称：
排序oj(使用各个排序算法跑该oj)
题目内容：
请使用课堂上讲的各个排序算法跑该oj题目。oj链接
跑完之后给出简单的结论分析
第 1 题（单选题）
题目名称：
1.排序过程中，对尚未确定最终位置的所有元素进行一遍处理称为一趟排序。用冒泡排序对数列4 5 6 3 2 1进行升序排序，则第3趟之后的结果是（ ）
题目内容：
A .4 3 2 1 5 6
B .4 5 3 2 1 6
C .2 1 3 4 5 6
D .3 2 1 4 5 6
第 2 题（单选题）
题目名称：
10.下列关于快速排序的非递归算法的说法中错误的是（ ）
题目内容：
A .快速排序的非递归遍历可以使用栈模拟二叉树的前序遍历的方式实现
B .快速排序的非递归遍历可以使用队列模拟二叉树的层序遍历的方式实现
C .快速排序的非递归遍历可以明显的提升排序的速度
D .快速排序的非递归遍历大大降低了栈空间的开销
第 3 题（单选题）
题目名称：
11.下列排序方法中，哪一种是不稳定的（ ）
题目内容：
A .直接插入排序
B .归并排序
C .选择排序
D .冒泡排序
第 4 题（单选题）
题目名称：
14.下列排序算法中，占用辅助空间最多的是（ ）
题目内容：
A .归并排序
B .快速排序
C .希尔排序
D .堆排序
第 5 题（单选题）
题目名称：
13.下列关于排序方法和其平均时间复杂度，配对错误的是（ ）
题目内容：
A .堆排序——O(nlog2 n)
B .直接插入排序——O(n^2)
C .选择排序——O(n^2)
D .归并排序——O(n^2)
第 6 题（单选题）
题目名称：
12.下列排序方法中，每一趟排序结束时都至少能够确定一个元素最终位置的方法是（ ）
① 选择排序
② 归并排序
③ 快速排序
④ 堆排序
题目内容：
A .①④
B .①②④
C .①③④
D .①②③④
第 7 题（单选题）
题目名称：
15.下列排序算法中，最坏时间复杂度不为O(n^2)的是（ ）
题目内容：
A .堆排序
B .快速排序
C .选择排序
D .插入排序
第 8 题（单选题）
题目名称：
16.下列排序算法中，最好时间复杂度和最坏时间复杂度不相同的是（ ）
题目内容：
A .快速排序
B .归并排序
C .选择排序
D .堆排序
第 9 题（单选题）
题目名称：
17.以下哪种排序算法对[1, 3, 2, 4, 5, 6, 7, 8, 9]进行排序最快（ ）
题目内容：
A .直接插入排序
B .快速排序
C .归并排序
D .堆排序
第 10 题（单选题）
题目名称：
18.下列排序算法中，在待排序数据已有序时，花费时间反而最多的是（ ）排序。
题目内容：
A .堆排序
B .归并排序
C .希尔排序
D .快速排序
第 11 题（单选题）
题目名称：
20.用某种排序方法对关键字序列 25 84 21 47 15 27 68 35 20 进行排序，序列的变化情况采样如下：
20 15 21 25 47 27 68 35 84
15 20 21 25 35 27 47 68 84
15 20 21 25 27 35 47 68 84
请问采用的是以下哪种排序算法（ ）
题目内容：
A .选择排序
B .希尔排序
C .归并排序
D .快速排序
第 12 题（单选题）
题目名称：
3.给出以下代码
public class TestObj{ public static void main(String[] args){ Object o=new Object(){ public boolean equals(Object obj){ return true; } }; System.out.println(o.equals(“Fred”)); } }
请给出结果：（）
题目内容：
A .运行时抛出异常
B .true
C .Fred
D .第三行编译错误
第 13 题（单选题）
题目名称：
5.以下关于 Comparator 和 Comparable 说法, 错误的是:
题目内容：
A .Comparator 和 Comparable 都能够指定对象的比较规则
B .实现 Comparable 接口后要重写 compareTo 方法, 这个方法只有一个参数, 比较过程是拿 this 和 这个参数进行比较
C .实现 Comparable 接口的 compareTo 方法后, 如果 this 比 参数对象小, 则应该返回 -1
D .实现 Comparator 接口相对于实现 Comparable 接口, 对原来的代码入侵性更小.
第 14 题（单选题）
题目名称：
4.给定 Student 类:
class Student { public String name; public int score; }
再给定一个 Student 数组
Student[] students;
现在要对这个数组按照分数进行降序排序, 应该如何修改代码?
题目内容：
A .Student 实现 Comparable 接口, 并重写 compare 方法
B .Student 实现 Comparable 接口, 并重写 compareTo 方法
C .Student 实现 Comparator 接口, 并重写 compare 方法
D .Student 实现 Comparator 接口, 并重写 compareTo 方法
第 15 题（单选题）
题目名称：
19.下面的排序算法中，初始数据集的排列顺序对算法的性能无影响的有（ ）
① 快速排序
② 希尔排序
③ 插入排序
④ 堆排序
⑤ 归并排序
⑥ 选择排序
题目内容：
A .①④⑤
B .④⑤⑥
C .②③⑥
D .②③⑤⑥
第 1 题（单选题）
题目名称：
关于二叉搜索树特性说法错误的是（ ）
题目内容：
A .二叉搜索树最左侧的节点一定是最小的
B .二叉搜索树最右侧的节点一定是最大的
C .对二叉搜索树进行中序遍历，一定能够得到一个有序序列
D .二叉搜索树的查找效率为O(log_2N)
第 2 题（单选题）
题目名称：
将整数序列（7-2-4-6-3-1-5）按所示顺序构建一棵二叉排序树a（亦称二叉搜索树），之后将整数8按照二叉排序树规则插入树a中，请问插入之后的树a中序遍历结果是（ ）
题目内容：
A .1-2-3-4-5-6-7-8
B .7-2-1-4-3-6-5-8
C .1-3-5-2-4-6-7-8
D .1-3-5-6-4-2-8-7
E .7-2-8-1-4-3-6-5
F .5-6-3-4-1-2-7-8
第 3 题（简答题）
题目名称：
TreeMap及TreeSet的博客总结
题目内容：
- 请将课堂代码的动手实现
- 结合老师板书将知识点好好梳理下
- 将本模块内容整理成博客，以链接方式提交
第 4 题（单选题）
题目名称：
1. 给定n个节点的平衡二叉搜索树，每个节点的值是整数。给定一个整数，在树中找出与该整数最接近的节点的最小算法复杂度是（）
题目内容：
A .Θ(logn)
B .Θ(n^2)
C .Θ(nlogn)
D .Θ(n)
E .Θ(1)
第 5 题（单选题）
题目名称：
2.下面的哪个序列可能是二叉搜索树中序遍历的结果?
题目内容：
A .7 3 8 2 9 4 11
B .2 3 4 7 8 9 11
C .11 2 9 3 8 4 7
D .以上均可
第 6 题（编程题）
题目名称：
二叉搜索树与双向链表
题目内容：
第 7 题（编程题）
题目名称：
只出现一次的数字
题目内容：
第 8 题（编程题）
题目名称：
宝石与石头
题目内容：
第 9 题（编程题）
题目名称：
坏键盘打字
题目内容：
第 10 题（单选题）
题目名称：
下面关于二叉搜索树正确的说法是（ ）
题目内容：
A .待删除节点有左子树和右子树时，只能使用左子树的最大值节点替换待删除节点
B .给定一棵二叉搜索树的前序和中序遍率历结果，无法确定这棵二叉搜索树
C .给定一棵二叉搜索树，根据节点值大小排序所需时间复杂度是线性的
D .给定一棵二叉搜索树，可以在线性时间复杂度内转化为平衡二叉搜索树
第 11 题（编程题）
题目名称：
1.实现二叉搜索树代码
题目内容：
public class BinarySearchTree { static class TreeNode { public int key; public TreeNode left; public TreeNode right; TreeNode(int key) { this.key = key; } } public TreeNode root; /** * 插入一个元素 * @param key */ public boolean insert(int key) { return true; } //查找key是否存在 public TreeNode search(int key) { return null; } //删除key的值 public boolean remove(int key) { return false; } }
第 1 题（单选题）
题目名称：
下面关于哈希说法正确的是（）
题目内容：
A .哈希是一种查找的方法，不是数据结构
B .采用哈希方式解决问题时，可以不用哈希函数
C .哈希查找的时间复杂度一定是O(1)
D .哈希是以牺牲空间为代价，提高查询的效率
第 2 题（单选题）
题目名称：
散列文件使用散列函数将记录的关键字值计算转化为记录的存放地址。由于散列函数不是一对一的关系，所以选择好的（）方法是散列文件的关键。
题目内容：
A .散列函数
B .除余法中的质数
C .冲突处理
D .散列函数和冲突处理
第 3 题（单选题）
题目名称：
散列函数有一个共同性质，即函数值应按（）取其值域的每一个值。
题目内容：
A .最大概率
B .最小概率
C .同等概率
D .平均概率
第 4 题（单选题）
题目名称：
解决散列法中出现冲突问题常采用的方法是()
题目内容：
A .数字分析法、除余法、平方取中法
B .数字分析法、除余法、线性探测法
C .数字分析法、线性探测法、多重散列法
D .线性探测法、多重散列法、链地址法
第 5 题（单选题）
题目名称：
将10个元素散列到100000个单元的哈希表中,则()产生冲突
题目内容：
A .一定会
B .一定不会
C .仍可能会
D .以上都不对
第 6 题（单选题）
题目名称：
下面关于哈希冲突说法正确的是（）
题目内容：
A .哈希冲突是可以通过设计好的哈希函数来杜绝的
B .哈希冲突是无法避免的
C .哈希冲突是不同的元素，通过不同的哈希函数而产生相同的哈希地址而引起的
D .哈希冲突产生的原因一定是插入了相同的元素
第 7 题（单选题）
题目名称：
已知有一个关键字序列：（19，14,23,1,68,20,84,27,55,11,10,79）散列存储在一个哈希表中，若散列函数为H（key）=key%7，并采用链地址法来解决冲突，则在等概率情况下查找成功的平均查找长度为()
题目内容：
A .1.5
B .1.7
C .2.0
D .2.3
第 8 题（单选题）
题目名称：
已知某个哈希表的n个关键字具有相同的哈希值，如果使用二次探测再散列法将这n个关键字存入哈希表，至少要进行（）次探测。
题目内容：
A .n-1
B .n
C .n+1
D .n(n+1)
E .n(n+1)/2
F .1+n(n+1)/2
第 9 题（单选题）
题目名称：
采用开放定址法处理散列表的冲突时，其平均查找长度？ （）
题目内容：
A .高于链接法处理冲突
B .高于二分查找
C .低于链接法处理冲突
D .低于二分查找
第 10 题（单选题）
题目名称：
采用线性探测法处理散列时的冲突,当从哈希表删除一个记录时,不应将这个记录的所在位置置空,因为这会影响以后的查找()
题目内容：
A .对
B .错
C .不一定
D .以上说法都不对
第 11 题（单选题）
题目名称：
用哈希（散列）方法处理冲突（碰撞）时可能出现堆积（聚集）现象，下列选项中，会受堆积现象直接影响的是 ()
题目内容：
A .存储效率
B .数列函数
C .装填（装载）因子
D .平均查找长度
第 12 题（单选题）
题目名称：
1.设哈希表长度为11,哈希函数H(K)=(K的第一个字母在字母表中的序号)MOD11,若输入顺序为(D,BA,TN,M,CI,I,K,X,TA),采用内散列表,处理冲突方法为线性探测法,要求构造哈希表,在等概率情况下查找成功平均查找长度为()
题目内容：
A . 4
B . 3
C . 20/9
D . 23/9
第 13 题（单选题）
题目名称：
4.若负载因子a为1,则向哈希表中散列元素时一定会产生冲突()
题目内容：
A .对
B .错
第 14 题（单选题）
题目名称：
3.采用哈希表组织100万条记录，以支持字段A快速查找，则下列说法错误的是( )
题目内容：
A .理论上可以在常数时间内找到特定记录
B .所有记录必须存在内存中
C .拉链式哈希法最坏查找时间复杂度是O（n）
D .哈希函数的选择跟A无关
第 15 题（编程题）
题目名称：
实现哈希表代码, 使用哈希桶方式解决哈希冲突
题目内容：
// key-value 模型 public class HashBucket { private static class Node { private int key; private int value; Node next; public Node(int key, int value) { this.key = key; this.value = value; } } private Node[] array; private int size; // 当前的数据个数 private static final double LOAD_FACTOR = 0.75; private static final int DEFAULT_SIZE = 8;//默认桶的大小 public int put(int key, int value) { // write code here return -1; } private void resize() { // write code here } private double loadFactor() { return size * 1.0 / array.length; } public HashBucket() { // write code here } public int get(int key) { // write code here } }
