算法：用Java实现外部排序(ExternalSort)

外部排序，是相对于内部排序而言的。之前我分享了很多种排序，这些排序都是将待排序的乱序数组全部放到内存里面，然后执行相应的排序算法，完成排序并输出结果的。整个排序的过程都是在内存里一次性加载所有的待排序数字，然后在内存里完成排序算法，这种叫内部排序。外部排序，就是需要排序的数字太多了，以至于内存一次加载不了所有的数字，然后就只能通过今天分享的外部排序来完成。

外部排序，乱序数字就不是在内存中加载为数组了，而是存在文件上的。Java需要IO读取文件内容，将文件中的数字经过处理，然后IO输出中间文件及最后的排好序的文件，完成整个外部排序过程。本来我打算写代码来完成这个外部排序，但是我觉得写出思路来就可以了，就暂时不写代码了。后面我会给出一些Java的API，用来辅助实现外部排序。

实现思路1、两路合并：

先按最大内存，每次读入内存允许的数字量，然后快速排序（不需要其他额外的数组空间），并将排序结果输出为文件，并编号，比如叫1-N号有序数字串文件
每次取两个文件，每个文件一行一行地读，然后一个个地吐数字。像类似归并排序那样，将两个文件的有序数字串合并为一个有序数字串，并同时写入新文件，现在就有1-N/2个有序数字串文件了
再每次取两个文件，重复第二步操作，每次会生成之前大约二倍大小的有序数字串文件，且文件数量每次减少一半
直到最后，合并为唯一一个有序数字串文件，即完成外部排序

两路合并举例：

待排序文件：2 9 5 3 8 6 1 7 4 0
假设内存一次只能读入4个数字（2 9 5 3 | 8 6 1 7 | 4 0），快速排序后以文件输出，生成3个文件：
文件1：2 3 5 9
文件2：1 6 7 8
文件3：0 4
然后文件两两归并（就是归并排序的那种归并操作方式，两个文件一行行读取内容，然后每次吐出一个数字），较小的输出，然后小的文件接着吐下一个数字，最终两个有序文件归并为一个有序文件：
1和2归并后的有序文件：1 2 3 5 6 7 8 9
3归并后的有序文件：0 4
如果归并后还是1个以上的文件，就接着归并，直到最后只有一个文件：
步骤3中的两个文件归并后的有序文件（外部排序结果）：0 1 2 3 4 5 6 7 8 9
最后归并输出的最后一个文件，就是外部排序完成后的有序数字文件了，外部排序完成！

实现思路2、多路合并：

先按最大内存，每次读入内存允许的数字量，然后快速排序（不需要其他额外的数组空间），并将排序结果输出为文件，并编号，比如叫1-N号有序数字串文件，这个是共同的操作
每次取M个文件，每个文件一行一行地读，然后一个个地吐数字。也是像类似归并排序那样，将N个文件的有序数字串的当前数字放入优先队列中，最小的数字具有最大的优先级，然后出队最小的数字，哪个文件的数字出队了，就再吐出一个数字入队，然后接着出队，吐数字入队……最后M个文件合并为一个有序数字串，并同时写入新文件，现在就有1-N/M个有序数字串文件了
如果最后的文件数不为1，就重复步骤2，文件每次会变大M倍，数量会变为1/M
最后一次归并可能会少于M个文件。最后一次M路归并，可能就会变成L路归并（L<=M），然后合并为唯一一个有序数字串文件，即完成外部排序

多路合并举例：

待排序文件：8 4 6 2 5 3 9 1 7
假设内存一次只能读入2个数字（8 4 | 6 2 | 5 3 | 9 1 | 7），快速排序后以文件输出，生成5个文件：
文件1：4 8
文件2：2 6
文件3：3 5
文件4：1 9
文件5：7
然后我们N=3，采取3路归并，用优先队列来决定下一个输出的数字和找到哪个文件该继续吐数字，此例的3路归并后，将生成2个文件：
文件1-3归并后的有序文件：2 3 4 5 6 8
文件4-5归并后的有序文件：1 7 9
如果最后不剩下唯一一个文件，则继续重复步骤3。此例中出现了比路数小的文件个数：3<2。此时就需要2路归并了：
步骤3中两个文件归并后的有序文件（外部排序结果）：1 2 3 4 5 6 7 8 9

分析：其实两路归并，也是多路归并的一个特例。归并路数可以是2-N，N就是每次读入内存支持的最大数字个数，然后总共需要读的次数。但无论哪种归并，都先要将所有数字读入内存（建议使用快速排序），然后排序，输出N个有序数字文件，这个是跑不掉的，差别就在于归并的套路：

两路归并的话，每次只需要判断两个有序数字文件吐出来的数字谁大谁小就可以了。而多路归并，则需要借助于优先队列，而且还要找到优先队列出队的小数字是哪个文件吐出来的
两路归并的话，生成的中间文件会比较多。而多路归并，生成的中间文件会比较少。比如N=12：
两路归并的中间文件数：6 + 3 + 1 =10
三路归并的中间文件数：4 + 2 = 6
四路归并的中间文件数：3
六路归并的中间文件数：2
归并路数少了，文件IO开销多；归并路数多了，优先队列操作开销多；我们需要根据实际情况，选择合适的归并路数，完成外部排序

附：外部排序可能用到的JavaAPI（假设文件分为很多行，每行有多个数字，以空格分隔）：

从文件里面逐一读取数字的迭代工具类，需要入参文件路径和分隔符，即可迭代所有数字。可以运行FileNumberReader类的main方法（准备好自己的源数据文件，并更新相关参数）做测试：

import java.io.BufferedReader;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Iterator;
import java.util.List;

/**
 * @author LiYang
 * @ClassName FileNumberReader
 * @Description 从多行文件中，读取固定分隔的数字的工具类
 * @date 2019/11/12 15:50
 */
public class FileNumberReader implements Iterator<Long> {
    
    //数据源文件的路径
    private String filePath;
    
    //读取是否结束
    private boolean isFinished;
    
    //FileReader类，用于读取文件
    private FileReader fileReader;
    
    //BufferedReader类，用于逐行读取文件
    private BufferedReader bufferedReader;
    
    //读入一行内容，转化的数字字符串List
    private List<String> numberList;
    
    //当前读入的数字文件行内容
    private String currentLine;
    
    //当前提取的数字的numberList的下标
    private int currentIndex;
    
    //数据源文件中数字的分隔符
    private String delimiter;

    /**
     * FileNumberReader类的构造方法
     * @param filePath 数据源文件路径
     * @param delimiter 文件中数字的分隔符
     * @throws FileNotFoundException
     */
    public FileNumberReader(String filePath, String delimiter) throws FileNotFoundException {
        this.filePath = filePath;
        this.isFinished = false;
        this.fileReader = new FileReader(filePath);
        this.bufferedReader = new BufferedReader(this.fileReader);
        this.numberList = new ArrayList<>();
        this.delimiter = delimiter;
    }

    /**
     * 根据isFinished，判断是否还有下一个数字
     * @return 是否还有下一个数字
     */
    @Override
    public boolean hasNext() {
        return !isFinished;
    }

    /**
     * 返回文件中下一个数字
     * @return 下一个数字
     */
    @Override
    public Long next() {
        try {
            //如果当前的numberList读完了，则清空numberList
            if (currentIndex > numberList.size() - 1){
                numberList.clear();
            }

            //如果numberList被清空或是初始状态
            if (numberList.size() == 0) {
                //读入一行内容
                currentLine = bufferedReader.readLine();

                //如果读入的内容为null，证明文件读到末尾了
                if (currentLine == null){
                    //迭代结束
                    isFinished = true;
                    
                    //关闭输入流
                    bufferedReader.close();
                    fileReader.close();
                    
                    //返回null，表示该文件已读完
                    return null;
                }

                //如果文件没有读完，则将当前的数据行按分隔符弄成numberList
                numberList = new ArrayList<>(Arrays.asList(currentLine.split(delimiter)));
                
                //下标置为0，从第一个开始
                currentIndex = 0;
            }

            //返回当前numberList的currentIndex下标的数字
            return Long.parseLong(numberList.get(currentIndex++));
        } catch (IOException e) {
            e.printStackTrace();
        }

        //出异常返回null
        return null;
    }

    /**
     * 测试文件数字读取工具类
     * @param args
     * @throws FileNotFoundException
     */
    public static void main(String[] args) throws FileNotFoundException {
        /**
         * 数字源文件路径，该文件内容如下：
         * 334 6544 255 6711
         * 34655 3 512 343
         * 6545 63774 34782 82098
         * 77 394
         * 
         * 大家可以改为自己的文件路径
         */
        String filePath = "C:\\Users\\Administrator\\Desktop\\external.txt";
        
        //该文件数字分隔符为空格，大家可以改为自己的分隔符，注意是正则表达式
        String delimiter = " ";

        //创建文件数字阅读工具类实例
        FileNumberReader fileNumberReader = new FileNumberReader(filePath, delimiter);

        //迭代该类实例，通过该类实例的next()方法取到下一个数字
        while (fileNumberReader.hasNext()) {
            
            //最后一个输出不是数字，是null，这就证明文件读完了
            //可以作为判断的依据
            System.out.print(fileNumberReader.next() + "  ");
        }
    }
    
}

运行FileNumberReader类的main方法，控制台输出如下，测试通过（外部排序可以拿去从文件中读数字了）：

334  6544  255  6711  34655  3  512  343  6545  63774  34782  82098  77  394  null

将数字写入文件的工具类，需要输入写入文件的路径（包含文件名，如果文件不存在，则创建）、分隔符和每行写多少个数字。可以运行FileNumberWriter类的main方法（准备好自己的相关参数）做测试：

import java.io.BufferedWriter;
import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
import java.util.Random;

/**
 * @author LiYang
 * @ClassName FileNumberWriter
 * @Description 将外部排序的有序数字写入文件的工具类
 * @date 2019/11/12 16:16
 */
public class FileNumberWriter {
    
    //写入的文件的路径（包含自定义的文件名）
    private String filePath;
    
    //数字分隔符
    private String delimiter;
    
    //每行写的数字的个数
    private int amountEachLine;
    
    //当前行数字的个数
    private int currentLineAmount;
    
    //待写入的文件类
    private File file;
    
    //用于写文件的FileWriter类
    private FileWriter fileWriter;
    
    //用于写文件的BufferedWriter类
    private BufferedWriter bufferedWriter;

    /**
     * 写数字的文件工具类
     * @param filePath 写入的文件的路径（包含自定义的文件名）
     * @param delimiter 数字分隔符
     * @param amountEachLine 每行写的数字的个数
     * @throws IOException
     */
    public FileNumberWriter(String filePath, String delimiter, int amountEachLine) throws IOException {
        this.filePath = filePath;
        this.delimiter = delimiter;
        this.amountEachLine = amountEachLine;
        this.fileWriter = new FileWriter(filePath);
        this.bufferedWriter = new BufferedWriter(fileWriter);
        
        //实例化该文件
        this.file = new File(filePath);
        
        //文件不存在，则创建
        if (!file.exists()){
            file.createNewFile();
        }
    }

    /**
     * 向指定文件写入数字（注意，最后一行会多写一个分隔符）
     * @param number 准备要写入的数字
     * @throws IOException
     */
    public void writeNumber(Long number) throws IOException {
        //当前行的第几个数字自增
        currentLineAmount ++;
        
        //如果已经超过了当前行的最大数量
        if (currentLineAmount > amountEachLine){
            
            //换一行
            bufferedWriter.newLine();
            
            //重置当前行的数字的第几个
            currentLineAmount = 1;
        }
        
        //如果已经是当前行的最后一个数字（写了这个数字就要换行了）
        if (currentLineAmount == amountEachLine){
            //只写入当前数字
            bufferedWriter.write(String.valueOf(number));
        
        //如果这个数字写了还不需要换行
        } else {
            //写入当前数字，以及分隔符
            bufferedWriter.write(number + delimiter);
        }
    }

    /**
     * 当有序数字写完后，调用该方法，关闭各种输出流
     * @throws IOException
     */
    public void writeFinish() throws IOException {
        bufferedWriter.close();
        fileWriter.close();
    }

    /**
     * 测试文件数字写入工具类
     * @param args
     * @throws IOException
     */
    public static void main(String[] args) throws IOException {
        //写入的文件的路径（包含文件名）
        String filePath = "C:\\Users\\Administrator\\Desktop\\write_number.txt";
        
        //为了美观，分隔符为英文逗号和空格
        String delimiter = ", ";
        
        //每行写4个数字
        int amountEachLine = 4;
        
        //FileNumberWriter工具类实例
        FileNumberWriter fileNumberWriter = new FileNumberWriter(filePath, delimiter, amountEachLine);

        //随机数类
        Random random = new Random();

        //写入30个一千万以内的随机整数
        for (int i = 1; i <= 30; i++) {
            //调用方法，写入数字（注意，最后一行有可能多一个分隔符）
            fileNumberWriter.writeNumber((long)random.nextInt(10000000));
        }
        
        //写完调用writeFinish()方法，关闭输出流
        fileNumberWriter.writeFinish();
    }
    
}

运行FileNumberWriter类的main方法，写入30个一千万以内的随机整数，然后相应路径上有了一个文件，打开文件，内容如下：

6560567, 5469256, 7342852, 5126873
7296214, 469243, 9396550, 5661757
9696285, 3138184, 1499909, 4495839
9281861, 8126570, 9893790, 7408475
5508093, 5307213, 623569, 9570021
5766407, 9533322, 8139950, 4605782
174081, 1960382, 209324, 1638231
9927870, 6185734,

测试通过，可以拿这个去将归并后的有序数字序列写入文件了

JavaAPI的优先队列类，可以用Java的PriorityQueue<>类来做优先队列，实现多路合并的最小值的判断。PriorityQueue<>类的测试代码及功能测试思路（在注释上说明）如下，可以直接拿来使用：

import java.util.PriorityQueue;

/**
 * @author LiYang
 * @ClassName PriorityQueueTest
 * @Description 优先队列的JavaAPI应用测试
 * @date 2019/11/12 17:03
 */
public class PriorityQueueTest {

    /**
     * 测试JavaAPI的优先队列PriorityQueue<>类
     * @param args
     */
    public static void main(String[] args) {
        //实例化一个优先队列，保存Long型数据
        PriorityQueue<Long> priorityQueue = new PriorityQueue<>();
        
        //调用add()方法，将数字入队
        priorityQueue.add(7L);
        priorityQueue.add(19L);
        priorityQueue.add(13L);

        //调用peek()方法，返回优先队列中的最小元素
        System.out.println(priorityQueue.peek());
        
        //调用poll()方法，将优先队列中的最小元素出队，并返回
        System.out.println(priorityQueue.poll());
        
        //重复上述操作，共计查看和出队三次
        //上面的三个数字将从小到大依次出来
        //注意，add()，peek()，poll()方法可以随时调用
        //如果优先队列的元素全部被poll了，再poll和peek，返回null
        System.out.println(priorityQueue.peek());
        System.out.println(priorityQueue.poll());
        System.out.println(priorityQueue.peek());
        System.out.println(priorityQueue.poll());
        
        //再往下，就是null了
        System.out.println(priorityQueue.peek());
        System.out.println(priorityQueue.poll());
    }
    
}

运行PriorityQueueTest类的main方法，控制台输出如下，测试结果符合预期：

7
7
13
13
19
19
null
null

好了，有了上面的思路，以及功能性关键代码，欢快地去搞外部排序吧……

算法：用Java实现外部排序(ExternalSort)

号称能打败MLP的KAN到底行不行？数学核心原理全面解析

同事使用 insert into select 迁移数据，开开心心上线，上线后被公司开除！

DeepFilterNet复现

算法：用Java實現圖論算法中的拓撲排序，並應用拓撲排序安排課程表

算法：用Java實現歸併排序(MergeSort)

算法：根據二叉樹的數據及其對應的順序存儲下標值（從1開始），生成對應的二叉樹

算法：用Java實現睡眠排序(SleepSort)

算法：用Java實現外部排序(ExternalSort)

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結