【外部排序算法】

排序介绍

复杂度

时间复杂度

空间复杂度

内部排序

内排序是被排序的数据元素全部存放在计算机内存中的排序算法。 内部排序是指待排的记录全部在内存中完成排序的过程，内部排序也称为内排序。

项目	空间复杂度	时间复杂度（平均）	时间复杂度（最好）	时间复杂度（最坏）	排序方式	稳定排序
冒泡排序	O(1)	O($n^2$)	O($n$)	O($n^2$)	内排序	是
选择排序	O(1)	O($n^2$)	O($n^2$)	O($n^2$)	内排序	是
插入排序	O(1)	O($n^2$)	O($n^2$)	O($n^2$)	内排序	是
希尔排序	O(1)	O($n^2$)	O($n^2$)	O($n^2$)	内排序	是
归并排序	O(1)	O($n^2$)	O($n^2$)	O($n^2$)	外排序	是
快速排序	O(1)	O($n^2$)	O($n^2$)	O($n^2$)	内排序	是
堆排序	O(1)	O($n^2$)	O($n^2$)	O($n^2$)	内排序	是
计数排序	O(1)	O($n^2$)	O($n^2$)	O($n^2$)	内排序	是
桶排序	O(1)	O($n^2$)	O($n^2$)	O($n^2$)	内排序	是
基数排序	O(1)	O($n^2$)	O($n^2$)	O($n^2$)	内排序	是

外部排序

外部排序指的是大文件的排序，即待排序的记录存储在外存储器上，待排序的文件无法一次装入内存，需要在内存和外部存储器之间进行多次数据交换，以达到排序整个文件的目的。
外部排序最常用的算法是多路归并排序，即将原文件分解成多个能够一次性装入内存的部分，分别把每一部分调入内存完成排序。然后，对已经排序的子文件进行多路归并排序

import java.io.*;
import java.util.*;

public class ExternalSort {

    // 假设每个文件（块）可以加载的最大行数
    private static final int MAX_TEMP_FILE_LINES = 1000;

    public static void main(String[] args) throws IOException {
        String inputFile = "input.txt"; // 输入文件
        String outputFile = "sorted.txt"; // 输出文件
        externalSort(inputFile, outputFile);
    }

    public static void externalSort(String inputFile, String outputFile) throws IOException {
        List<File> tempFiles = splitAndSortTempFiles(inputFile);
        mergeSortedFiles(tempFiles, outputFile);
        deleteTempFiles(tempFiles);
    }

    private static List<File> splitAndSortTempFiles(String inputFile) throws IOException {
        List<File> tempFiles = new ArrayList<>();
        BufferedReader reader = new BufferedReader(new FileReader(inputFile));
        List<String> lines = new ArrayList<>(MAX_TEMP_FILE_LINES);
        String line;
        while ((line = reader.readLine()) != null) {
            lines.add(line);
            if (lines.size() == MAX_TEMP_FILE_LINES) {
                tempFiles.add(sortAndSave(lines));
                lines.clear();
            }
        }
        if (!lines.isEmpty()) {
            tempFiles.add(sortAndSave(lines));
            lines.clear();
        }
        reader.close();
        return tempFiles;
    }

    private static File sortAndSave(List<String> lines) throws IOException {
        Collections.sort(lines);
        File tempFile = File.createTempFile("sortInBatch", ".tmp");
        tempFile.deleteOnExit();
        BufferedWriter writer = new BufferedWriter(new FileWriter(tempFile));
        for (String r : lines) {
            writer.write(r);
            writer.newLine();
        }
        writer.close();
        return tempFile;
    }

    private static void mergeSortedFiles(List<File> files, String outputFileName) throws IOException {
        PriorityQueue<BufferedReader> pq = new PriorityQueue<>(11,
                Comparator.comparing(bufferedReader -> {
                    try {
                        return bufferedReader.readLine();
                    } catch (IOException e) {
                        e.printStackTrace();
                        return null;
                    }
                }));

        for (File file : files) {
            BufferedReader br = new BufferedReader(new FileReader(file));
            pq.add(br);
        }

        BufferedWriter writer = new BufferedWriter(new FileWriter(outputFileName));
        while (!pq.isEmpty()) {
            BufferedReader br = pq.poll();
            String line = br.readLine();
            if (line != null) {
                writer.write(line);
                writer.newLine();
                pq.add(br); // 重新加入队列进行下一行的排序
            } else {
                br.close();
            }
        }
        writer.close();
    }

    private static void deleteTempFiles(List<File> tempFiles) {
        for (File file : tempFiles) {
            file.delete();
        }
    }
}