10亿条记录排序

10亿个字符串排序 

一、问题描述

有一个大文件，里面有十亿个字符串，乱序的，要求将这些字符串以字典的顺序排好序

 

二、解决思路

        将大文件切割成小文件，每个小文件内归并排序；

        对所有的小文件进行归并排序——多重归并排序

 

三、解决方案

3.1 模拟产生10亿个随机字符

Java代码   收藏代码
  1. public static void generateDate() throws IOException {  
  2.     BufferedWriter writer = new BufferedWriter(new FileWriter(ORIGINALPATH));  
  3.     Random random = new Random();  
  4.     StringBuffer buffer = new StringBuffer(  
  5.     "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ");  
  6.     int range = buffer.length();  
  7.     int length = 1;  
  8.     for (int i = 0; i < BIGDATALENGTH; i++) {  
  9.         StringBuffer sb = new StringBuffer();  
  10.         length = random.nextInt(20)+1;  
  11.                //System.out.println("length--->"+length);  
  12.         for (int j = 0; j < length; j++) {  
  13.                        //System.out.println("j--->"+j);  
  14.             sb.append(buffer.charAt(random.nextInt(range)));  
  15.         }  
  16.         System.out.println("sb---->"+sb);  
  17.         writer.write(sb.toString() + "\n");  
  18.     }  
  19.     writer.close();  
  20. }  

 

3.2 对大文件进行切割

Java代码   收藏代码
  1. /** 
  2.  * 将原始数据分成几块 并排序 再保存到临时文件 
  3.  * @throws IOException 
  4.  */  
  5. public static void splitData() throws IOException {  
  6.     @SuppressWarnings("resource")  
  7.     BufferedReader br = new BufferedReader(new FileReader(ORIGINALPATH));  
  8.     tempFiles = new File[BIGDATALENGTH / TEMPFILELENGTH];//将会产生的临时文件列表  
  9.     for (int i = 0; i < tempFiles.length; i++) {  
  10.         tempFiles[i] = new File(TEMPFILEPATH + "TempFile" + i + ".txt");  
  11.         BufferedWriter writer = new BufferedWriter(new FileWriter(tempFiles[i]));  
  12.         HashMap<Integer,String> hashMap = new HashMap<Integer,String>();//未排序  
  13.         //每次读出TEMPFILELENGTH个文件 保存到smallLine中  
  14.         for (int j = 1; j <= TEMPFILELENGTH; j++) {  
  15.             String text = null;  
  16.             if ((text = br.readLine()) != null) {  
  17.                 hashMap.put(j, text);  
  18.             }  
  19.         }  
  20.         hashMap = MergeSort.sort(hashMap);  
  21.         for(int k=1; k<=TEMPFILELENGTH; k++){  
  22.             writer.write(String.valueOf(hashMap.get(k))  
  23.                     + System.getProperty("line.separator"));  
  24. //System.getProperty("line.separator")相当于\n  
  25.         }  
  26.         writer.close();  
  27.     }  
  28. }  

 

3.3 对小文件进行递归归并 

Java代码   收藏代码
  1. /** 
  2.  * 多路归并排序 
  3.  * @param files 
  4.  * @throws IOException 
  5.  */  
  6. public static void multiWaysMergeSort(String[] files) throws IOException {  
  7.     System.out.println("归并文件-----第 "+mergeSortCount+" 次-----");  
  8.     //当最后只有一个文件的时候 数据已经排序成功 直接复制保存到结果文件  
  9.     if (files.length == 1) {  
  10.         String lastFilePath = LASTFILEPATH + LASTFILENAME;  
  11.         copyFile(files[0], lastFilePath, false);  
  12.         //deleteFile(files[0]);  
  13.         return;  
  14.     }  
  15.     for (int i = 0; i < files.length; i+=2) {  
  16. //开始合并两个相邻的文件 所以一次跳两个  
  17.         if (i == files.length - 1) {  
  18. //这时候已经只剩下最后一个文件了 不需要合并 本趟归并结束  
  19.             renameFile(files[i], i);  
  20.             break;  
  21.         }  
  22.         //将br1 和 br2 写入到Write  
  23.         BufferedReader br1 = new BufferedReader(new FileReader(files[i]));  
  24.         BufferedReader br2 = new BufferedReader(new FileReader(files[i + 1]));  
  25.         BufferedWriter writer = new BufferedWriter(new FileWriter(TEMPFILEPATH + "last_" + mergeSortCount + "_" + i + ".txt"));  
  26.         String s1 = br1.readLine();  
  27.         String s2 = br2.readLine();  
  28.         while (s1 != null || s2 != null) {  
  29.             if (s1 != null && s2 != null) {  
  30.                 //都不为空 才有比较的必要  
  31.                 int mergeResult = s1.compareTo(s2);  
  32.                 if (mergeResult > 0) {//s1在s2后面  
  33.                     writer.write(s2);  
  34.                     writer.write(System.getProperty("line.separator"));  
  35.                     s2 = br2.readLine();  
  36.                 }  
  37.                 if (mergeResult == 0) {//s1=s2  
  38.                     writer.write(s1);                                   writer.write(System.getProperty("line.separator"));  
  39.                     writer.write(s2);                                   writer.write(System.getProperty("line.separator"));  
  40.                     //System.out.println("write time : " + writeTime++);  
  41.                     s1 = br1.readLine();  
  42.                     s2 = br2.readLine();  
  43.                 }  
  44.                 if (mergeResult < 0) {//s1在s2前面  
  45.                     writer.write(s1);                                   writer.write(System.getProperty("line.separator"));  
  46.                     s1 = br1.readLine();  
  47.                 }  
  48.             }  
  49.             if (s1 == null && s2 != null) {  
  50.                 writer.write(s2);  
  51.                 writer.write(System.getProperty("line.separator"));  
  52.                 s2 = br2.readLine();  
  53.             }  
  54.             if (s2 == null && s1 != null) {  
  55.                 writer.write(s1);                 
  56. writer.write(System.getProperty("line.separator"));  
  57.                 s1 = br1.readLine();  
  58.             }  
  59.         }  
  60.         br1.close();  
  61.         br2.close();  
  62. //          deleteFile(files[i]);  
  63. //          deleteFile(files[i + 1]);  
  64.         writer.close();  
  65.     }  
  66.     mergeSortCount++;  
  67.     multiWaysMergeSort(getTempFiles("last_" + (mergeSortCount-1) + "_"));  
  68. }  

 

3.4 运行结果分析

①生成10亿个随机字符串，时间太久了，，字符串长度随机在[1,20]之间时，文件大小大概在10.7 GB (11,500,161,591 字节)

② 切割成小文件，小文件内归并排序，每个文件内的数据100万条时，随机选取五个排序时间如下：

一共发生了410832612 次对比一共发生了 899862656 次交换执行时间为3545毫秒

一共发生了429506513 次对比一共发生了 940765504 次交换执行时间为3512毫秒

一共发生了448181315 次对比一共发生了 981668352 次交换执行时间为3497毫秒

一共发生了466856137 次对比一共发生了 1022571200 次交换执行时间为3497毫秒

一共发生了485530473 次对比一共发生了 1063474048 次交换执行时间为3981毫秒

总共1000个文件切割耗时为

切割小文件所用时间--->4341734ms--->4341.734s--->72.36m--->1.206h

③  小文件递归归并，1000个文件，

共发生了10次归并，

产生临时文件总共1999个，

总大小为127.8 GB (137,201,789,278 字节)，

产生结果文件11.6 GB (12,500,161,591 字节)

比源文件多了10亿个字节......

总耗时为--->7374129ms--->7374.129s--->122.9m--->2.048h

不得不提的是，最后执行结果成功，也不枉我苦苦等待

四、相关技术

4.1 归并排序

排序原理不多介绍，各种到处都有，如果一时不记得，看下面的原理图。秒懂。

 

 


  

    4.2 文件读写

本程序很重要的一点就是对于文件的读写，Buffer的文件读写可以很大程度的改善速率

写操作：

BufferedWriter writer = new BufferedWriter(new FileWriter(PATH));

writer.write("hhf\n");

读操作：

BufferedReader br = new BufferedReader(new FileReader(PATH));

text = br.readLine()

 

五、关于优化

5.1分小文件时优化

前提：数据均匀，保证每个小文件大小不会超过内存的容量

处理：在分数据到小文件时，按字符串按首字母将其分到指定文件中，如A-C分配到1.txt，D-F分配到2.txt.......

优点：只需要小文件内数据排序，排序号后，即可将1.txt、2.txt、3.txt直接连接起来，极大的缩短了归并时间，相当于把递归归并变成了文件连接而已

缺点：前提不是很容易把握，若有一个小文件内的数据量大于内存的大小，则排序失败，存在一定的风险

 

5.2小文件内排序时优化

前提：保证每个小文件内数据量比较不是特别的大

处理：将小文件内的数据进行快速排序

优点：快排的时间效率是高于归并的

以下是测试数据

排序数量级  10  1000  100000

归并排序7ms  71ms  3331ms

快速排序6ms  52ms  java.lang.StackOverflowError

缺点：缺点已经显示在测试数据内了，小文件内的数据量过大就可能导致当前线程的栈满

(附上源代码工程：Merge.zip)

posted @ 2021-12-20 13:19  CharyGao  阅读(37)  评论(0)  编辑  收藏  举报