排序算法---外部排序

算法设计：

可以使用外部排序对大容量数据进行排序。数据量过大，存储于外部文件，数据不能完全加载到内存中。
1.从文件中读取一固定数目的数据到数组，对数组排序，将排好序的数组作为一个数据段输出到一个临时文件，重复上述过程，直到源文件中数据读取完
2.将存储了数据段的文件中一般的数据段复制到一个临时文件，然后对着两个文件的数据段归并排序，每两个数据段归并形成一个大的数据段存储于一个文件中，重复2，直到只有一个数据段为止。

创建存储大量数据的文件：

public class CreateLargeFile {

public static void main(String[] args) throws IOException {
DataOutputStream output = new DataOutputStream(
new BufferedOutputStream(new FileOutputStream("D:\\largedata.dat")));
for (int i = 0; i < 800004; i++)
output.writeInt((int) (Math.random() * 1000000));
output.close();

DataInputStream input = new DataInputStream(new BufferedInputStream(new FileInputStream("D:\\largedata.dat")));
for (int i = 0; i < 100; i++)
System.out.print(input.readInt() + " ");
input.close();
}
}

public class SortLargeFile {
public static final int MAX_ARRAY_SIZE = 100000;
public static final int BUFFER_SIZE = 100000;

public static void main(String[] args) throws IOException {
// 将largedata.dat中的数据排序存入sortedfile.dat中
sort("D:\\largedata.dat", "D:\\sortedfile.dat");
// 输出排序后的前100个数
displayFile("D:\\sortedfile.dat");
}

/**
* 将源文件数据排序存入目标文件
*
* @param sourcefile
* @param targetfile
* @throws IOException
*/
public static void sort(String sourcefile, String targetfile) throws IOException {
int numberOfSegments = initializeSegments(MAX_ARRAY_SIZE, sourcefile, "D:\\f1.dat");
merge(numberOfSegments, MAX_ARRAY_SIZE, "D:\\f1.dat", "D:\\f2.dat", "D:\\f3.dat", targetfile);
}

/**
* 将原始文件排序为一个个有顺序的段，存入临时文件
*
* @param segmentSize
* @param originalFile
* @param f1
* @return
* @throws IOException
*/
private static int initializeSegments(int segmentSize, String originalFile, String f1) throws IOException {
int[] list = new int[segmentSize];
DataInputStream input = new DataInputStream(new BufferedInputStream(new FileInputStream(originalFile)));
DataOutputStream output = new DataOutputStream(new BufferedOutputStream(new FileOutputStream(f1)));

int numberOfSegments = 0;
while (input.available() > 0) {
numberOfSegments++;
int i = 0;
for (; input.available() > 0 && i < segmentSize; i++) {
list[i] = input.readInt();
}
// 将读出的数据排序
Arrays.sort(list, 0, i);
// 将排序后的数据输入临时文件
for (int j = 0; j < i; j++) {
output.writeInt(list[j]);
}
}
input.close();
output.close();

return numberOfSegments;
}

/**
* 将排好序的段归并并排序直到只有一个段
*
* @param numberOfSegments
* @param segmentSize
* @param f1
* @param f2
* @param f3
* @param targetfile
* @throws IOException
*/
private static void merge(int numberOfSegments, int segmentSize, String f1, String f2, String f3, String targetfile)
throws IOException {
if (numberOfSegments > 1) {
mergeOneStep(numberOfSegments, segmentSize, f1, f2, f3);
merge((numberOfSegments + 1) / 2, segmentSize * 2, f3, f1, f2, targetfile);
} else {
File sortedFile = new File(targetfile);
if (sortedFile.exists())
sortedFile.delete();
new File(f1).renameTo(sortedFile);
}
}

/**
* 归并第一阶段
*
* @param numberOfSegments
* @param segmentSize
* @param f1
* @param f2
* @param f3
* @throws IOException
*/
private static void mergeOneStep(int numberOfSegments, int segmentSize, String f1, String f2, String f3)
throws IOException {
DataInputStream f1Input = new DataInputStream(new BufferedInputStream(new FileInputStream(f1), BUFFER_SIZE));
DataOutputStream f2Output = new DataOutputStream(
new BufferedOutputStream(new FileOutputStream(f2), BUFFER_SIZE));
// 将f1中的段复制一半到f2中
copyHalfToF2(numberOfSegments, segmentSize, f1Input, f2Output);
f2Output.close();

// 将f1和f2中的段归并为更大的段到f3中
DataInputStream f2Input = new DataInputStream(new BufferedInputStream(new FileInputStream(f2), BUFFER_SIZE));
DataOutputStream f3Output = new DataOutputStream(
new BufferedOutputStream(new FileOutputStream(f3), BUFFER_SIZE));
mergeSegments(numberOfSegments / 2, segmentSize, f1Input, f2Input, f3Output);

f1Input.close();
f2Input.close();
f3Output.close();
}

/**
* 复制前半部分的段
*
* @param numberOfSegments
* @param segmentSize
* @param f1Input
* @param f2Output
* @throws IOException
*/
private static void copyHalfToF2(int numberOfSegments, int segmentSize, DataInputStream f1Input,
DataOutputStream f2Output) throws IOException {
for (int i = 0; i < (numberOfSegments / 2) * segmentSize && f1Input.available() > 0; i++) {
f2Output.writeInt(f1Input.readInt());
}
}

/**
* 归并所有的段
*
* @param numberOfSegments
* @param segmentSize
* @param f1Input
* @param f2Input
* @param f3Output
* @throws IOException
*/
private static void mergeSegments(int numberOfSegments, int segmentSize, DataInputStream f1Input,
DataInputStream f2Input, DataOutputStream f3Output) throws IOException {
for (int i = 0; i < numberOfSegments; i++) {
mergeTwoSegments(segmentSize, f1Input, f2Input, f3Output);
}
// 如果f1中还有剩余的则复制到f3
while (f1Input.available() > 0) {
f3Output.writeInt(f1Input.readInt());
}
}

/**
* 归并两个分段
*
* @param segmentSize
* @param f1
* @param f2
* @param f3
* @throws IOException
*/
private static void mergeTwoSegments(int segmentSize, DataInputStream f1, DataInputStream f2, DataOutputStream f3)
throws IOException {
int intFromF1 = f1.readInt();
int intFromF2 = f2.readInt();
int f1Count = 1;
int f2Count = 1;

while (true) {
if (intFromF1 < intFromF2) {
f3.writeInt(intFromF1);
if (f1.available() == 0 || f1Count++ >= segmentSize) {
f3.write(intFromF2);
break;
} else
intFromF1 = f1.readInt();
} else {
f3.writeInt(intFromF2);
if (f2.available() == 0 || f2Count++ >= segmentSize) {
f3.write(intFromF1);
break;
} else
intFromF2 = f2.readInt();
}
}

while (f1.available() > 0 && f1Count++ < segmentSize) {
f3.write(f1.readInt());
}

while (f2.available() > 0 && f2Count++ < segmentSize) {
f3.write(f2.readInt());
}
}

public static void displayFile(String fileName) {
try {
DataInputStream input = new DataInputStream(new FileInputStream(fileName));
for (int i = 0; i < 100; i++) {
System.out.print(input.readInt() + " ");
}
input.close();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}