一道笔试题

最新推荐文章于 2022-08-12 00:00:16 发布

原创最新推荐文章于 2022-08-12 00:00:16 发布 · 371 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#外排序 #Java #算法 #笔试

Java 同时被 2 个专栏收录

8 篇文章

订阅专栏

算法

3 篇文章

订阅专栏

上周收到某公司的笔试邀请，题目分两个部分：一是随机生成5个以上大于1G的文件，二是将这些文件合并并排序，并且使用内存不超过50M。

文件生成部分

这部分倒是挺简单，直接上代码

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

public class filesort_testgen {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        int filecount = 0;
        long line = 0;
        String prefix = "";
        while(true){
            try{
                filecount = Integer.parseInt(args[0]);
                line = Long.parseLong(args[1]);
                prefix = args[2];
                break;
            }catch (NumberFormatException e) {
                // TODO: handle exception
                System.out.println("Wrong input, try again...");
                return;
            }
        }
        Random random = new Random();
        System.out.println("Generate unsorted files: ");
        for (int j = 1; j < filecount + 1; ++j) {
            double size = (1024 * 1024 * 1024) * (1 + Math.random());
            double bytes = size / line;
            String filename = "";
            try {

                /*
                 * @ generate file
                 */
                filename = prefix + j;
                System.out.println(filename);
                File file = new File(filename + ".txt");
                if (!file.exists())
                    file.createNewFile();
                FileWriter fileWriter = new FileWriter(file.getName(), true);
                BufferedWriter bufferedWriter = new BufferedWriter(fileWriter);

                for (long i = 0; i < line + random.nextInt(1000); ++i) {
                    bufferedWriter.write(getRandomString(bytes));
                    bufferedWriter.newLine();
                }
                bufferedWriter.close();
            } catch (IOException e) {
                // TODO: handle exception
                e.printStackTrace();
            }
        }

    }

    public static String getRandomString(double bytes) {
        String str = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
        Random random = new Random();
        StringBuffer sb = new StringBuffer();
        for (int i = 0; i < bytes; i++) {
            int number = random.nextInt(62);
            sb.append(str.charAt(number));
        }
        return sb.toString();
    }

}

getRandomString(double bytes)接受一个double型变量，返回长度为bytes的随机生成的字符串。

排序部分

要求使用内存不超过50M，话说合并一下文件稳稳的上8G了直接读进内存也不现实。所以在这里使用了外排序

外排序（External sorting）是指能够处理极大量数据的排序算法。通常来说，外排序处理的数据不能一次装入内存，只能放在读写较慢的外存储器（通常是硬盘）上。外排序通常采用的是一种“排序-归并”的策略。在排序阶段，先读入能放在内存中的数据量，将其排序输出到一个临时文件，依此进行，将待排序数据组织为多个有序的临时文件。尔后在归并阶段将这些临时文件组合为一个大的有序文件，也即排序结果。
外排序是指在排序期间全部对象个数太多，不能同时存放在内存，必须根据排序过程的要求，不断在内、外存之间移动的排序。比如常见的有外归并排序。

所以外排序有两个关键的步骤：分割，归并。

import java.io.*;
import java.util.*;
import org.apache.commons.io.*;

public class filesort {
    private filesort() {
    }

    /**
     * 得到指定文件的行数
     * 
     * @param fileC
     *            String
     * @return int
     * @throws IOException
     */
    private static int getFileLineSize(String fileC) throws IOException {
        Reader fC = null;
        try {
            fC = new FileReader(fileC);

            LineIterator it = IOUtils.lineIterator(fC);
            int lineSize = 0;
            while (it.hasNext()) {
                it.nextLine();
                lineSize++;
            }
            return lineSize;
        } finally {
            IOUtils.closeQuietly(fC);
        }
    }

    /**
     * 得到下一行的内容,如果已到文件末尾返回NULL
     * 
     * @param iterator
     *            LineIterator
     * @return String
     */
    private static String nextLine(LineIterator iterator) {
        if (iterator.hasNext()) {
            return iterator.nextLine();
        } else {
            return null;
        }
    }

    /**
     * 读指定行数的字符串到缓冲区列表里
     * 
     * @param iterator
     *            LineIterator
     * @param bufList
     *            List
     * @param lines
     *            int
     */
    private static void readLines(LineIterator iterator, List<String> bufList, int lines) {
        for (int i = 0; i < lines; i++) {
            if (!iterator.hasNext()) {
                break;
            }
            bufList.add(iterator.nextLine());
        }
    }

    /**
     * 扫描fileC中的归并段并把它们交替分别送到文件fileA和fileB中, 本次归并段的大小为k*blockSize
     * 
     * @param fileA
     *            String
     * @param fileB
     *            String
     * @param fileC
     *            String
     * @param k
     *            int
     * @param blockSize
     *            int
     */
    private static void split(String fileA, String fileB, String fileC, int k, int blockSize)
            throws FileNotFoundException, IOException {
        boolean useA = true;
        int i = 0;

        List<String> bufList = new ArrayList<String>(blockSize); // 大小为blockSize的缓冲区
        Writer fA = null;
        Writer fB = null;
        Reader fC = null;
        try {
            fA = new BufferedWriter(new FileWriter(fileA));
            fB = new BufferedWriter(new FileWriter(fileB));
            fC = new FileReader(fileC);

            LineIterator itC = IOUtils.lineIterator(fC);
            while (itC.hasNext()) {
                // ->读入数据块
                bufList.clear();
                readLines(itC, bufList, blockSize);
                // <-读入数据块

                if (useA) {
                    IOUtils.writeLines(bufList, "\n", fA);
                } else {
                    IOUtils.writeLines(bufList, "\n", fB);
                }

                if (++i == k) {
                    i = 0;
                    useA = !useA;
                }
            }
        } finally {
            bufList.clear();

            IOUtils.closeQuietly(fA);
            IOUtils.closeQuietly(fB);
            IOUtils.closeQuietly(fC);
        }
    }

    /**
     * n为当前归并段大小(k*blockSize);将文件fX的后续归并段拷入到fY,变量currRunPos为当前归并段的索引
     * 
     * @param fileX
     *            String
     * @param fileY
     *            String
     * @param currRunPos
     *            int
     * @param n
     *            int
     * @return int 当前归并段的索引
     */
    private static int copyTail(LineIterator fileX, Writer fileY, int currRunPos, int n) throws IOException {
        // 从当前位置到归并段结束,拷贝每个数据
        while (currRunPos <= n) {
            // 若没有更多的数据项,则文件结束且归并段结束
            if (!fileX.hasNext()) {
                break;
            }

            // 修改当前归并段位置并将数据项写入fY
            currRunPos++;
            IOUtils.write(fileX.nextLine() + "\n", fileY);
        }

        return currRunPos;
    }

    /**
     * 将文件fA和fB中长度为n(k*blockSize)的归并段合并回fC中
     * 
     * @param fileA
     *            String
     * @param fileB
     *            String
     * @param fileC
     *            String
     * @param n
     *            int
     * @throws IOException
     */
    private static void merge(String fileA, String fileB, String fileC, int n) throws IOException {
        // currA和currB表示在当前归并段中的位置
        int currA = 1;
        int currB = 1;

        // 分别从fA和fB中读出的数据项
        String dataA, dataB;

        Reader fA = null;
        Reader fB = null;
        Writer fC = null;
        try {
            fA = new FileReader(fileA);
            fB = new FileReader(fileB);
            fC = new BufferedWriter(new FileWriter(fileC));

            LineIterator itA = IOUtils.lineIterator(fA);
            LineIterator itB = IOUtils.lineIterator(fB);

            dataA = nextLine(itA);
            dataB = nextLine(itB);
            for (;;) {
                // 若(dataA<=dataB),则将dataA拷贝到fC并修改当前归并段的位置
                if (dataA.compareTo(dataB) <= 0) {
                    IOUtils.write(dataA + "\n", fC);

                    // 从fA中取下一归并段,若不存在,则已到文件尾,应将fB的后续归并段拷入到fC;
                    // 若当前位置>n,则已将所有fA的归并段拷完,应拷贝fB的后续归并段
                    dataA = nextLine(itA);
                    currA++;
                    if (dataA == null || currA > n) {
                        IOUtils.write(dataB + "\n", fC);
                        currB++;
                        currB = copyTail(itB, fC, currB, n);

                        // fA的大小>=fB的大小;若在fA的文件尾,则结束
                        if (dataA == null) {
                            break;
                        } else { // 否则,应在新的归并段中,重置当前位置
                            currA = 1;
                        }

                        // 取fB中的下一项.若不存在,则只有fA中剩余的部分要拷贝到fC,
                        // 退出循环前将当前归并段写入fC
                        dataB = nextLine(itB);
                        if (dataB == null) {
                            IOUtils.write(dataA + "\n", fC);
                            currA = 2;
                            break;
                        } else { // 否则,重置fB中当前归并段
                            currB = 1;
                        }
                    }
                } else { // 否则(dataA>dataB)
                    IOUtils.write(dataB + "\n", fC);

                    // 从fB中取下一归并段,若不存在,则已到文件尾,应将fA的后续归并段拷入到fC;
                    // 若当前位置>n,则已将所有fB的归并段拷完,应拷贝fA的后续归并段
                    dataB = nextLine(itB);
                    currB++;
                    if (dataB == null || currB > n) {
                        IOUtils.write(dataA + "\n", fC);
                        currA++;
                        currA = copyTail(itA, fC, currA, n);

                        // 若fB中没有更多项,则置fA的当前位置,准备拷贝fA中的最后归并段到fC中
                        if (dataB == null) {
                            currA = 1;
                            break;
                        } else { // 否则,置fB的当前位置,并从fA中读入数据
                            currB = 1;
                            if ((dataA = nextLine(itA)) == null) {
                                break;
                            } else {
                                currA = 1;
                            }
                        }
                    }
                }
            } // <- end for(; ;)

            // 将fA中可能存在的剩余的归并段写入fC中(注:fA的长度时>=fB的)
            if (dataA != null && dataB == null) {
                currA = copyTail(itA, fC, currA, n);
            }
        } finally {
            IOUtils.closeQuietly(fA);
            IOUtils.closeQuietly(fB);
            IOUtils.closeQuietly(fC);
        }
    }

    /**
     * 用指定的blockSize块大小,排序指定的文件fileC
     * 
     * @param fileC
     *            String
     * @param blockSize
     *            int
     * @throws IOException
     */

    /**
     * 用指定的blockSize块大小,排序指定的文件fileSource,排序后的文件是fileOut
     * 
     * @param fileSource
     *            String
     * @param fileOut
     *            String
     * @param blockSize
     *            int
     * @param removeDuple
     * @throws IOException
     */
    public static void sort(String fileSource, String fileOut, int blockSize) throws IOException {
        String fileA = File.createTempFile("wjw", null).getAbsolutePath();
        String fileB = File.createTempFile("wjw", null).getAbsolutePath();

        int mergeIndex = 1;
        int lineSize = getFileLineSize(fileSource);
        int k = 1;
        int n = k * blockSize;
        boolean useA = true;
        List<String> list = new ArrayList<String>(blockSize);

        Writer fA = null;
        Writer fB = null;
        Reader fC = null;
        try {
            fA = new BufferedWriter(new FileWriter(fileA));
            fB = new BufferedWriter(new FileWriter(fileB));
            fC = new FileReader(fileSource);

            LineIterator itC = IOUtils.lineIterator(fC);
            if (lineSize <= blockSize) { // 对于小文件,从fC读入数据,直接排序后写回文件中
                readLines(itC, list, lineSize);
                Collections.sort(list);
                IOUtils.closeQuietly(fC);
                FileUtils.writeLines(new File(fileOut), "GBK", list, "\n");

                list.clear();
                return;
            }

            // ->第一次分割,合并
            // System.out.println("第:"+mergeIndex+"分割,合并");
            while (itC.hasNext()) {
                list.clear();
                readLines(itC, list, blockSize);

                Collections.sort(list);
                if (useA) {
                    IOUtils.writeLines(list, "\n", fA);
                } else {
                    IOUtils.writeLines(list, "\n", fB);
                }

                useA = !useA;
            }
            list.clear();

            IOUtils.closeQuietly(fA);
            IOUtils.closeQuietly(fB);
            IOUtils.closeQuietly(fC);
            merge(fileA, fileB, fileOut, blockSize);
            mergeIndex++;
            // <-第一次分割,合并

            // ->将当前归并段大小加倍,循环进行
            k = k * 2;
            n = k * blockSize;
            while (n < lineSize) { // 当n>=文件大小时,fC仅剩一个已排好序的归并段
                // System.out.println("第:"+mergeIndex+"分割,合并");
                split(fileA, fileB, fileOut, k, blockSize);
                merge(fileA, fileB, fileOut, n);
                mergeIndex++;
                k = k * 2;
                n = k * blockSize;
            }
            // ->将当前归并段大小加倍,循环进行

        } finally {
            IOUtils.closeQuietly(fA);
            IOUtils.closeQuietly(fB);
            IOUtils.closeQuietly(fC);

            (new File(fileA)).delete();
            (new File(fileB)).delete();
        }
    }

    /**
     * 删除已经排好序的文件中重复的数据
     * 
     * @param fileC
     *            String
     * @throws IOException
     */
    public static String formatSecond(long seconds) {
        long h = seconds / (60 * 60);
        StringBuffer sb = new StringBuffer();

        sb.append(h + "小时");

        seconds = seconds % (60 * 60);

        long c = seconds / 60;
        sb.append(c + "分");

        sb.append(seconds % 60 + "秒");

        return sb.toString();
    }

    public static void union(String[] paths, String newString)throws Exception  
    {  
        File[] list = new File[paths.length];
        for(int i = 0; i < paths.length; ++i){
            list[i] = new File(paths[i]);
        }
        File newFile=new File(newString);  
        byte buffer[]=new byte[1024];  
        int readcount; 
        /*
        if(!newFile.getParentFile().exists())  
            throw new Exception("你合并的文件夹的不存在...");  
            */
        FileOutputStream writer=new FileOutputStream(newString);  
        for(File f:list)  
        {  
            FileInputStream reader=new FileInputStream(f);  
            while((readcount=reader.read(buffer))!=-1)  
            {  
                writer.write(buffer);  
            }  
            reader.close();  
        }  
        writer.close();  
    }  

    public static void main(String args[]) {
        //System.out.println("Usage: filesort INPUT_FILE_1 INPUT_FILE_2 ... OUTPUT_FILE");
        long c1 = System.currentTimeMillis();
        String[] input_files = new String[args.length - 1];
        for(int i = 0; i < args.length - 1; ++i)
            input_files[i] = args[i];
        try {
            union(input_files, "merged.txt");
        } catch (Exception e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        String output = args[args.length - 1];
        int blockSize = 1000;
        try {
            filesort.sort("merged.txt", output, blockSize);
            long c2 = (System.currentTimeMillis() - c1) / 1000;
            System.out.println("Generate sorted file: " + output);
            System.out.println("耗时:" + formatSecond(c2));
            long total = Runtime.getRuntime().totalMemory();
            long free = Runtime.getRuntime().freeMemory();
            System.out.println("Used memory: " + (total - free) + "B" + "(" + (total - free) / 1024 / 1024 + "MB" + ")");
        } catch (IOException ex) {
            ex.printStackTrace();
        }
    }

}

排序结果