编程珠玑——第一章

问题描述

输入：一个最多包含n个正整数的文件，每个数都小于n，其中n=10^7。如果在输入文件中有任何整数重复出现就是致命错误。没有其他数据与该整数相关联。

输出：按升序排列的输入整数的列表。

约束：最多有（大约）1MB的内存空间可用，有充足的磁盘空间可用。运行时间最多几分钟，运行时间为10秒就不需要进一步优化了。

程序设计

在这里书中给出了三种解决方案：

（1）基于磁盘的归并排序。利用归并排序，就可以读入输入文件一次，然后在工作文件的帮助下完成排序，并写入输出文件一次。工作文件需要读写多次。

（2）如果每个号码都使用32位整数来表示的话，在1MB空间里可以存储250000个号码。对于一千万个数字，那么可以分40次进行排序完成。第一趟，选择0-249999之间的数字进行排序，然后输出到文件。第二趟排序选择250000-499999之间的数字进行排序，然后写入文件。依次类推，直至全部完成排序。40趟算法读取输入文件多次，写输出文件整体一次，不使用中间文件。

（3）位图排序。书中的问题是，每个7位十进制整数表示一个小于1000万的整数，可以使用一个具有1千万位的字符串来表示这个文件，其中，当且仅当整数i在文件中存在时，第i位为1。那么整体排序可以分为三个步骤：第一阶段初始化一个1千万位的数据结构。第二阶段读取文件，将对应位置置1。第三阶段按顺序输出，如果该位置为1，则输出到文件中。

代码

对于前两种方案，笔者还未进行代码实现。由于自己很久没用C写程序了，所以暂用java进行写了一个位图排序，在这个程序里笔者用了BitSet类，简化里工作，算是偷了个懒。至于具体的用C语言实现的话，需要用位逻辑运算实现位向量，此问题将在习题2里进行解答。模拟的输入文件是以逗号分割的数字串。

package chapter.first;

import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.BitSet;

import chapter.utils.RandomInt;
import chapter.utils.TransUtils;

public class BitMapSort {
    private String fileName;
    private BitSet bs;
    private TransUtils tu;
        
    public BitMapSort(String fileName){
        this.fileName=fileName;
        bs=new BitSet();
        tu=new TransUtils();
    }
    
    public void readFile(){
        int[] tmp;
        File file=new File(fileName);
        if(!file.exists()){
            System.out.println("can not find this file!");
            System.exit(0);
        }
        try{
            BufferedReader br=new BufferedReader(new FileReader(fileName));        
            String line=null;
            while((line=br.readLine())!=null){
                tmp=tu.transArray(line, ",");
                setTrue(bs,tmp);
            }
            br.close();
        }catch(Exception e){
            e.printStackTrace();
        }
        
    }
    
    private void setTrue(BitSet bs,int[] data){
        for(int i=0;i<data.length;i++){
            bs.set(data[i], true);
        }
    }
    
    public void writeFile(){
        File file=new File("result.txt");
        try {
            if(!file.exists()){            
                file.createNewFile();            
            }
            
            FileWriter fw=new FileWriter(file);
            for(int i=0;i<bs.length();i++){
                if(bs.get(i)){
                    fw.write(i+"");
                    if(i%100==0 && i!=0){
                        fw.write("\n");
                    }else if(i!=bs.length()-1){
                        fw.write(",");
                    }
                    fw.flush();
                }
            }
            fw.close();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
    public static void main(String[] args){
        RandomInt rand=new RandomInt("test.txt",10000);
        rand.generateIntB();
        BitMapSort bms=new BitMapSort("test.txt");
        long start=System.currentTimeMillis();
        System.out.println("开始："+start);
        bms.readFile();
        bms.writeFile();
        long end=System.currentTimeMillis();
        System.out.println("结束："+end);
        System.out.println("总共耗时："+(end-start)+"ms");
    }
}

package chapter.utils;

import java.awt.List;
import java.util.ArrayList;

public class TransUtils {
    
    /**
     * 将一个字符串按照给出的seperator进行切分，
     * 切分成字符串数组后再转化成整形数组。
     * @param data
     * @param seperator
     * @return
     */
    public int[] transArray(String data,String seperator){        
        String[] tmp=data.split(seperator);
        int[] a=new int[tmp.length];
        try{
            for(int i=0;i<tmp.length;i++){
                a[i]=Integer.parseInt(tmp[i]);
            }
        }catch(Exception e){
            e.printStackTrace();
        }
        return a;
    }
   //。。。
}