笔经面经分享之百度笔试题第一弹。希望通过本帖,能够对正在找工作的同学或者将要找工作的同学提供微薄之力。
--小站小编
1 笔试题
下面是来自于百度的编程笔试题,感兴趣的同学可以先自己想想解题思路:
你现在有一个文件,文件中顺序存有N个记录,R1,R2,...,RN,这些记录不是有序的,但是你知道一个整数M, 这些记录满足R1<R2<...<RM以及RM+1<RM+2<...RN.
1. 设计一个算法或编写一个程序,将文件中的记录排序为R1',R2',...,RN',算法或程序读取文件的次数为O(N),不限内存使用;
2. 设计一个算法或编写一个程序,将文件中的记录排序为R1',R2',...,RN',算法或程序读写文件的次数为O(N),空间复杂度为O(1),亦即,你使用的内存大小和M,N均无关。
--------------我是华丽丽的分隔线----------------
2 内排序和外排序
根据在排序过程中待排序的记录是否全部被放置在内存中,排序可以分为内排序和外排序。
内排序是在排序整个过程中,待排序的所有记录全部被放置在内存中。外排序是由于排序的记录个数太多,不能同时放置在内存,整个排序过程需要在内外存之间多次交换数据才能进行。
3 排序算法的时间性能
排序算法的时间开销是衡量其好坏的最重要的标志。
在内排序中,主要进行两种操作:比较和移动。内排序算法的时间复杂度是比较次数加上移动次数的总和;
在外排序中,除了比较和移动,还有读写文件的操作。外排序算法的时间复杂度是比较次数,移动次数以及读写文件次数的总和。
高效率的排序算法应该是具有尽可能少的比较次数,移动次数及读写文件的次数。
4 排序算法的空间性能
评价排序算法的另一个主要标准是执行算法所需要的辅助存储空间。辅助存储空间是除了存放待排序所占用的存储空间之外,执行算法所需要的其他存储空间。
5 回到笔试题
基础知识介绍完毕,如果大家还有不明白的地方,可以先找找相关的资料参考一下。
5.1 对题目的理解
要解决一个问题,首先需要明确问题:
初始条件下,有N个数据数据都存放在一个文件中,并且有一个整数M,使得这些记录满足R1<R2<...<RM以及RM+1<RM+2<...RN。举一个例子来说,对于以下10(N=10)个数(2,3,4,7,10,1,5,6,8,9),当M是2时,分成两个序列(2,3)和(4,7,10,1,5,6,8,9),由于第二个序列不是依次增大的,所以不满足条件。当M是5时,分成两个序列(2,3,4,7,10)和(1,5,6,8,9)都是依次增大,因此满足条件。
然后我们需要将这些记录排序,其实就是合并这两个子序列。以例子来看,其实就是需要把(2,3,4,7,10)和(1,5,6,8,9)两个有序序列合并成(1,2,3,4,5,6,7,8,9,10)一个有序序列。细心的同学可能会想起归并排序。是的,这个合并过程其实是归并排序中的一个子步骤。
题目的要求,第一个要求是读取文件次数为O(N),但是不限制内存的使用;第二个要求是读取文件次数为O(N),但是空间复杂度为O(1)。区别在于限不限制内存的使用。
如果不限制内存的使用,我们可以将文件中的内容全部读取到内存中,保存为数组,然后再对数组进行排序;如果限制内存的使用,我们可以采用外排序来解决这个问题,外排序一般会借助于文本文件。
最后的实现代码(java)
/**
* Sample code
*/
public class FileRecordSortMain {
final static String SOURCE_FILE_NAME = "file.txt";
final static String TEMP_FILE_NAME1 = "file_temp1.txt";
final static String TEMP_FILE_NAME2 = "file_temp2.txt";
final static int N = 10;
final static int M = 5;
/**
* 第一种方法:
* 将原文件中的记录顺序读取到内存中,以数组保存,然后以M为分隔将
* 数组看为两组,互相比较两组元素之后输出,最后输出剩下的元素。
*
* 性能分析:
* 1. 时间复杂度是O(N),因为读取原文件N次,比较小于4N次,输出N次,
* 加在一起的数量级是N的一次方
* 2. 空间复杂度是N,因为将原文件中的记录事先读取到内存中,以数组
* 保存,这个辅助空间的长度是N
*/
static void sortInManner1() {
//1. 将原文件中的记录顺序读取到内存中,以数组保存
BufferedReader reader = getFileReader(SOURCE_FILE_NAME);
int[] arry = new int[N];
String str = "";
int index = 0;
try {
while ((str=reader.readLine()) != null) {
arry[index++] = Integer.valueOf(str);
}
} catch (IOException e) {
e.printStackTrace();
}
//2. 将index<M数组元素看为一组,将index>=M的数组元素看为另一组
//3. 互相比较两组元素,输出较小者,然后将较小者所在组的index+1
int i = 0;
int j = M;
System.out.println("Sort Manner 1 Result:");
while (i<M && j<N) {
if (arry[i] < arry[j]) {
System.out.print(arry[i++] + " ");
} else {
System.out.print(arry[j++] + " ");
}
}
//4. 输出比较之后剩下来的元素
while (i < M) {
System.out.print(arry[i++] + " ");
}
while (j < N) {
System.out.print(arry[j++] + " ");
}
System.out.println();
}
/**
* 第二种方法:
* 将原文件中的记录以M分隔,读取后保存到两个临时文件file_temp1.txt
* 和file_temp2.txt中,然后将这两个临时文件中保存的数组看为两组,
* 分别从这两个临时文件中读取元素,比较后输出,最后读取并输出剩下
* 的元素。
*
* 性能分析:
* 1. 时间复杂度是O(N),因为读取原文件N次,写临时文件N次,读取临时
* 文件N次,比较小于6N次,输出N次,加在一起是N的一次方
* 2. 空间复杂度是1(与M,N均无关系),因为:
* 在步骤1中,使用1个String和1个int作为辅助空间
* 在步骤2,3,4中,使用1个String和1个String作为辅助空间,加在一起
* 与M,N均无关系
*/
static void sortInManner2() {
//1. 将原文件中的记录以M分隔,读取后保存到两个临时文件
//file_temp1.txt和file_temp2.txt中
BufferedReader sourceReader = getFileReader(SOURCE_FILE_NAME);
BufferedWriter writer1 = getFileWriter(TEMP_FILE_NAME1);
BufferedWriter writer2 = getFileWriter(TEMP_FILE_NAME2);
String str = "";
int index = 0;
try {
while ((str=sourceReader.readLine()) != null) {
if (index < M) {
writer1.write(str+"\n");
} else {
writer2.write(str+"\n");
}
++index;
}
} catch (IOException e) {
e.printStackTrace();
} finally {
try {
writer1.close();
writer2.close();
} catch (IOException e) {
e.printStackTrace();
}
}
//2. 将file_temp1.txt中的元素看为一组,将file_temp1.txt中的元
//素看为另一组
//3. 互相比较两组元素,输出较小者,然后继续从较小者所在的临时
//文件中读取元素
BufferedReader tempReader1 = getFileReader(TEMP_FILE_NAME1);
BufferedReader tempReader2 = getFileReader(TEMP_FILE_NAME2);
String numTemp1 = "";
String numTemp2 = "";
try {
numTemp1 = tempReader1.readLine();
numTemp2 = tempReader2.readLine();
System.out.println("Sort Manner 2 Result:");
while (numTemp1!=null && numTemp2!=null) {
if (Integer.valueOf(numTemp1) <
Integer.valueOf(numTemp2)) {
System.out.print(numTemp1 + " ");
numTemp1 = tempReader1.readLine();
} else {
System.out.print(numTemp2 + " ");
numTemp2 = tempReader2.readLine();
}
}
//4. 输出比较之后剩下来的元素
while (numTemp1 != null) {
System.out.print(numTemp1 + " ");
numTemp1=tempReader1.readLine();
}
while (numTemp2 != null) {
System.out.print(numTemp2 + " ");
numTemp2=tempReader2.readLine();
}
} catch (IOException e) {
e.printStackTrace();
}
System.out.println();
}
public static void main(String[] args) {
sortInManner1();
sortInManner2();
}
static BufferedReader getFileReader(String filename) {
String souceFileAbsoluteName = getAbsolutePathName() +
File.separator + filename;
InputStream is = null;
BufferedReader reader = null;
try {
is = new FileInputStream(souceFileAbsoluteName);
reader = new BufferedReader(new InputStreamReader(is));
} catch (FileNotFoundException e) {
e.printStackTrace();
}
return reader;
}
static BufferedWriter getFileWriter(String filename) {
String souceFileAbsoluteName = getAbsolutePathName() +
File.separator + filename;
OutputStream os = null;
BufferedWriter writer = null;
try {
os = new FileOutputStream(souceFileAbsoluteName);
writer = new BufferedWriter(new OutputStreamWriter(os));
} catch (FileNotFoundException e) {
e.printStackTrace();
}
return writer;
}
static String getAbsolutePathName() {
File directory = new File("");
return directory.getAbsolutePath();
}
}
##17##朱元友