1GB单词，限制1mb内存，怎么取词频最高的前100个

已于 2023-07-06 22:52:47 修改
阅读量177 收藏 1
点赞数
分类专栏： java 文章标签： java 开发语言
于 2023-07-06 22:52:37 首次发布
原文链接：http://t.csdn.cn/Wola9
版权

我这边生成单词是1gb 内存会很卡，你不要写那么大

1.先把1GB的大文件拆分成2048个文件，每个文件512kb,1*1024*1024/512=2048,

   就是这么算出来的

2. 在把大文件的数据，放入2048个小文件中

3.把每个小文件的数据重新排序，因为不超过1mb，所以可以直接放到内存中排序

4.把排序好的小文件，在写入到大文件中，使用堆排序，堆中的是流，不会占用那么多的内存

只会比较所有的文件的一行数据

5.然后把排序好的大文件的内容，按照小顶堆前100个放入，去对比词频，

堆顶的元素就是最小的，比堆顶小的就不管，比堆顶大的，移除堆顶元素，放入新的数据

这样最后就是100个词频最高的单词了

package com.example.demo.entity;

import com.example.demo.mapper.Pair;
import org.springframework.util.CollectionUtils;

import java.io.*;
import java.nio.Buffer;
import java.util.*;

public class FileUtils {

    /**
     * 获取输入流 读取文件数据
     * @param str
     * @return
     */
    public static BufferedReader getReader(String str){
        BufferedReader bufferedReader= null;
        try {
            bufferedReader = new BufferedReader(new FileReader(str));
        } catch (IOException e) {
            e.printStackTrace();
        }
        return bufferedReader;
    }

    /**
     * 获取输出流 写入文件
     * @return
     */
    public static BufferedWriter getWrite(String str){
        BufferedWriter bufferedWriter= null;
        try {
            bufferedWriter = new BufferedWriter(new FileWriter(str));
        } catch (IOException e) {
            e.printStackTrace();
        }
        return  bufferedWriter;
    }


    /**
     * 关闭输入流
     */
    public static void closeReader(BufferedReader bufferedReader){
        try {
            bufferedReader.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    /**
     * 关闭输出流 把缓冲区的内容写入到文件中
     */
    public static void closeWriter(BufferedWriter bufferedWriter){
        try {
            bufferedWriter.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }


    /**
     * 生成1个G单词
     */
    public static void generate(String str) throws IOException {
        Random random=new Random();
        File file=new File(str);
        if(!file.exists()){
            try {
                //如果不存在新建
                file.createNewFile();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        //获取输出流
        BufferedWriter write= FileUtils.getWrite(str);
        char[]ans=new char[]{'a','b','c','d','e','f','g','h','i','j','k','l','m','n','o','p','q','r','s','t','u','v','w','x','y','z'};
        for (int i = 0; i <200000000 ; i++) {
            StringBuilder sb=new StringBuilder();
            //随机从字符数组中读取数据 每个字符串最多占16个字节
            for (int j = 0; j < random.nextInt(16) ; j++) {
                sb.append(ans[random.nextInt(ans.length)]);
            }
            if(sb.length()==0){
                //空的不写入
                continue;
            }
            write.write(sb.toString());
            write.newLine();
        }

        //关闭输出流,写入到文件中
        FileUtils.closeWriter(write);
    }


    //创建2048个txt小文件
    public static void createText(String str){
        for (int i = 0; i < 2048; i++) {
            File f=new File(str+"\\"+i+".txt");
            try {
                f.createNewFile();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

    /**
     * 把大文件拆分成2048个小文件
     * @param bigPath 大文件路径
     * @param minDir 小文件目录
     */
    public static void split(String bigPath,String minDir) throws IOException {
        //读取小文件目录
        File file=new File(minDir);
        //遍历所有小文件
        File[] files = file.listFiles();
        //获取输入流 读取大文件中的数据
        BufferedReader reader=FileUtils.getReader(bigPath);
        for (File f : files) {
            //获取输出流 写到小文件中
            BufferedWriter writer=FileUtils.getWrite(f.getPath());
            int size=0;
            String res=null;
            //只要不为空 就一直读取文件中的内容
            while ((res=reader.readLine())!=null){
                size+=res.length();
                //写入文件
                writer.write(res);
                //换行
                writer.newLine();
                //如果大于512kb结束 当前文件，开始新的文件写入
                if(size>=512*1024){
                    break;
                }
            }
            //关闭输出流 把缓冲区的内容到文件中
            FileUtils.closeWriter(writer);
        }
        //关闭输入流
        FileUtils.closeReader(reader);
    }


    /**
     * 排序小文件并重写
     * @param minDir 小文件目录
     */
    public static void sortMin(String minDir) throws IOException {
        //读取小文件目录
        File file=new File(minDir);
        //遍历所有小文件
        File[] files = file.listFiles();
        for (File f : files) {
            //获取输入流 读取文件中的数据
            BufferedReader reader=FileUtils.getReader(f.getPath());
            List<String> list=new ArrayList<>();
            String res=null;
            while ((res=reader.readLine())!=null){
                list.add(res);
            }
            //关闭输入流
            closeReader(reader);
            if(CollectionUtils.isEmpty(list)){
                //如果这个文件没有数据 就不管他
                continue;
            }
            //对每个小文件排序
            Collections.sort(list);
            //重新写回小文件
            BufferedWriter writer=getWrite(f.getPath());
            for (String s : list) {
                writer.write(s);
                writer.newLine();
            }
            //关闭输出流
            closeWriter(writer);
        }
    }


    /**
     * 合并小文件到大文件
     * @param bigPath 大文件路径
     * @param minDir 小文件目录
     */
    public static void merger(String minDir,String bigPath) throws IOException {
        //读取小文件目录
        File file=new File(minDir);
        //遍历所有小文件
        File[] files = file.listFiles();
       //使用小顶堆 越小的字符越在前 小顶堆的长度就是文件的长度
        PriorityQueue<BufferSort>p=new PriorityQueue<>(files.length, new Comparator<BufferSort>() {
            @Override
            public int compare(BufferSort o1, BufferSort o2) {
                return o1.getStr().compareTo(o2.getStr());
            }
        }) ;

        for (File f : files) {
            //把文件流 放入小顶堆中
            BufferedReader reader=getReader(f.getPath());
            BufferSort bufferSort=new BufferSort(reader);
            if(bufferSort.hashNext()){
                //如果有数据 放入小顶堆中
                p.add(bufferSort);
            }else {
                //如果没有数据 关闭流
                bufferSort.close();
            }
        }
        //获取输出流
        BufferedWriter writer=FileUtils.getWrite(bigPath);
        while (p.size()>0){
            //从堆顶拿出来数据 比较
            BufferSort bufferSort=p.poll();
            //因为之前已经缓存了，所以可以拿到这一行的数据
            writer.write(bufferSort.getStr());
            writer.newLine();
            if(bufferSort.hashNext()){
                //有数据 继续放入小顶堆中 对比下一行数据
                p.add(bufferSort);
            }else {
                //没有数据 关闭输入流
                bufferSort.close();
            }
        }
        //最后关闭输出流
        closeWriter(writer);
    }


    /**
     * 打印前100个词频最高的单词
     * @param path
     */
    public static void top100(String path) throws IOException {
        //因为是打印100个词频最高的单词，所以小顶堆的长度就是100
        PriorityQueue<Pair>p=new PriorityQueue<>(100, new Comparator<Pair>() {
            @Override
            public int compare(Pair o1, Pair o2) {
                //越小的在前
                return o1.getNum()-o2.getNum();
            }
        });

        BufferedReader reader=getReader(path);
        //当前字符串
        String curr=null;
        //前一个字符串
        String prev=null;
        //前一个单词的数量
        int prevNum=0;
        while ((curr=reader.readLine())!=null){
            if(prev==null){
                prev=curr;
                prevNum=1;
            }else if(prev.equals(curr)){
                prevNum++;
            }else {
                //如果前一个单词 和当前不一样
                //判断小顶堆中是否满100
                if(p.size()<100){
                    //如果没满直接放入 前一个
                    p.add(new Pair(prev,prevNum));
                }else if(p.peek().getNum()<prevNum){
                    //如果大于100 判断堆顶的元素是否 小于前一个数量
                    //如果比前一个小，那么移除堆顶的元素
                    p.remove();
                    //放入前一个数据
                    p.add(new Pair(prev,prevNum));
                }
                //更新前一个单词和前一个单词的数量
                prev=curr;
                prevNum=1;
            }

        }
        int index=0;
        while (p.size()>0){
            index++;
            //把堆中的数据 都打印出来
            Pair pair=p.poll();
            System.out.println(pair.getWord()+"-次数--"+pair.getNum()+"--索引:"+index);
        }
    }


}

package com.example.demo.entity;

import java.io.BufferedReader;
import java.io.IOException;

//用于流排序的类
//可以缓存当前流中的内容
//判断下一行有没有数据
public class BufferSort {

    private BufferedReader reader;

    private String str;

    public BufferSort(BufferedReader reader){
        this.reader=reader;
    }

    public String getStr() {
        return str;
    }

    //判断下一行有没有数据 然后把当前的结果缓存起来 用于小顶堆排序比较
    public boolean hashNext(){
        try {
            str=reader.readLine();
        } catch (IOException e) {
            e.printStackTrace();
        }
        return str!=null;
    }

    //关闭输入流
    public void close(){
        try {
            reader.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

package com.example.demo.mapper;

public class Pair {

    private String word;

    private Integer num;

    public Pair(String word,Integer num){
        this.num=num;
        this.word=word;
    }

    public Integer getNum() {
        return num;
    }

    public String getWord() {
        return word;
    }

}

package com.example.demo.mapper;

import com.example.demo.entity.FileUtils;

import java.io.IOException;

public class Test2 {

    public static void main(String[] args) throws IOException {
        FileUtils.generate("data\\danci.txt");
        System.out.println("生成1个G单词成功");

        FileUtils.createText("dc");
        System.out.println("创建2048个空文件成功");


        FileUtils.split("data\\danci.txt","dc");
        System.out.println("写入2048个小文件成功");


        FileUtils.sortMin("dc");
        System.out.println("排序每个小文件成功");


        FileUtils.merger("dc","data\\da.txt");
        System.out.println("合并小文件成功");


        System.out.println("打印词频最高的100个单词");
        FileUtils.top100("data\\da.txt");

    }
}

 数据出现0kb的也不用管他，总数据是够的 

我们的字符串是存储的512kb,但是txt还有自己的元数据,所以这里看到是772kb

 

 

我是一只代码狗
关注
专栏目录
海量数据处理：1G大小的一个文件中找出出现频率最高的100个数
五山口老法师
03-10 1万+
1.题目描述 有一个1G大小的一个文件，里面每一行是一个词，词的大小不超过16字节，内存限制大小是1M，要求返回频数最高的100个词 2.思考过程 （1）参见我的其他大数据面试题博文。此处1G文件远远大于1M内存，分治法，先hash映射把大文件分成很多个小文件，具体操作如下：读文件中，对于每个词x，取hash(x)%5000，然后按照该值存到5000个小文件(记为f0,f1,...,f4...
有一个1G大小的一个文件，里面每一行是一个词，词的大小不超过16字节，内存限制大小是1M。返回频数最高的100个词.
热门推荐
zzran的专栏
12-27 2万+
首先，我们看到这个题目应该做一下计算，大概的计算，因为大家都清楚的知道1G的文件不可能用1M的内存空间处理。所以我们要按照1M的上线来计算，假设每个单词都为16个字节，那么1M的内存可以处理多少个单词呢？ 1M = 1024 KB = 1024 * 1024 B 。然后1M / 16B = 2^16个单词，那么1G大概有多少个单词呢？ 有2^26个单词，但是实际中远远不止这些，因为我们是按照最大单
大厂面试官问我：两个1亿行的文件怎么求交集？【后端八股文十五：场景题合集】
qq_33445788的博客
07-25 1905
任务分批： 将任务分成多个批次，每次从任务列表中取出一部分任务交给线程池处理。这样可以避免一次性将大量任务提交给线程池，减少系统资源竞争。 线程池大小调优： 根据系统资源和任务的性质，合理设置线程池的大小。如果任务是 CPU 密集型的，可以设置较少的线程数；如果任务是 I/O 密集型的，可以适当增加线程数。避免线程数过多导致上下文切换频繁，影响性能。
1G文件内存大小为1M统计每个单词出现次数的TopN（思想）
billionyearsbo的博客
06-09 896
1G文件内存大小为1M统计每个单词出现次数的TopN（思想） 实现这个思路先从以下几个方面解决： ①读取文件：使用IO流解决，使用缓冲数组 byte 只能容纳1M 考虑使用一个可以设置大小的IO流来解决：BufferreaderInputStream 然后设置编码方式：InputStreamReader（BufferreaderInputStream，“utf-8”） 这样就可以1M读取文件，然后把文件保存到HashMap中，为了防止数据倾斜把文件数量设置多点（比如：1G文件大小，1M读可以分为1024个）
从1t数据中找出最大的10个数
void_Function的专栏
09-27 1805
方法 ：建立一个大小为10的堆  用1t数据中的前10个初始化之  然后从第11个开始向堆中插入 每次从堆中踢出最小的  遍历整个数据  时间复杂度为nlog10
PHP试题---文件1T大小数据按行存储取出重复最多的top10（运行内存有限制）
luyaran的博客
03-07 1529
最近有去Testin（云测）公司面试，有问到一个关于大文件处理的一个问题，具体问题如下：文件大小1T左右，运行内存100M，文件中有可能有重复数据，现在的需求就是取出文件里面重复数最高的top10。 我一开始给出的是理想状态下的解决方案，就是这个文件中有大量重复的数据，按着这个思想来搞的话，那我肯定是在运行内存足够的情况下来多次读取这个文件，之后就是标记每行值的重复次数，至于这个处理出来的数据放...
在1G内存和1T文件中寻找第二大字符串出现次数的优化算法
博客
10-13 309
本文介绍了在1G内存和1T文件中寻找第二大字符串出现次数的优化算法。通过设计基于分治的算法，并优化内存使用和IO操作，我们成功地解决了这个大规模数据处理的问题。实验结果表明，我们的算法在合理的时间内可以找到第二大字符串和它的出现次数。这个算法可以应用于各种大数据处理场景中。
c语言编写程序，找出出现次数最高的数字 数字范围1-1000 时间复杂度不超过O(n)
2301_77487444的博客
06-29 307
可以使用一个长度为1000的数组count来记录每个数字出现的次数。遍历给定的数字序列，对于每个数字n，将count[n]加1。最后再遍历一次count数组，找出出现次数最高的数字。这段代码的时间复杂度为O(n)，其中n为输入数字序列的长度。
海量数据处理：十道面试题与十个海量数据处理方法总结
08-01
- **问题概述**: 有一个1GB大小的文件，每行是一个词，词的大小不超过16字节，内存限制大小为1MB，要求返回频数最高的100个词。 - **解决方案**: - 使用哈希函数将单词映射到5000个小文件中，每个文件约200KB。 - ...
大数据报告1
08-08
配置为1个Master节点和2个Slave节点，硬件配置为Intel Celeron 3865U 1.80GHz CPU，总内存8GB，运行在Windows上的VMware虚拟机上，其中Master节点分配了2GB内存，两个Slave节点各分配1GB内存。Spark集群通过Spark-...
江湖上流传的谷歌三宝是什么？GFS，MapReduce，还有一个很重要
马小婧QAQ
05-30 3281
江湖传说永流传：谷歌技术有"三宝"，GFS、MapReduce和大表（BigTable）！ 谷歌在03到06年间连续发表了三篇很有影响力的文章，分别是03年SOSP的GFS，04年OSDI的MapReduce，和06年OSDI的BigTable。SOSP和OSDI都是操作系统领域的顶级会议，在计算机学会推荐会议里属于A类。SOSP在单数年举办，而OSDI在双数年举办。 那么这篇博客就来介绍一下GFS，MapReduce，BigTable。 谷歌技术"三宝"之谷歌文件系统 题记：初学分布式文件系统，写
TopK问题
ThreeAspects的博客
12-03 1086
海量数据中寻找TopK问题Top K问题介绍Top K问题举例及解答 Top K问题介绍   所谓的Top K问题：在海量数据中找出出现频率最好的前K个数，或者从海量数据中找出最大的前K个数。例如，在搜索引擎中，统计搜索最热门的10个查询词/在歌曲库中统计下载最高的前10首歌等。针对Top K问题，通常方案是分治+Trie树/Hash+小顶堆，即先将数据集按照Hash方法分解成多个小数据集，然后使...
超大文件中在有限的内存里找到单词频率 top 100
weixin_59287292的博客
03-02 4516
单词频率 top 100
海量数据场景下的热门算法题
m0_53401014的博客
12-07 992
关卡名海量数据场景下的热门算法题我会了✔️内容1.从40个亿中产生一个不存在的整数2. 用 2GB 内存在 20 亿个整数中找到出现次数最多的数3.从100 亿个 URL中查找的问题4. 40 亿个非负整数中找到出现两次的数和所有数的中位数。
有一个 1G 大小的一个文件，里面每一行是一个词，词的大小不超过 16 字节，内存限制大小是 1M。返回频数最高的 100 个词。
乔治大哥的博客
10-23 6900
分而治之 + hash统计 + 堆/快速排序 分而治之/hash映射：顺序读文件中，对于每个词x，取hash(x)%5000，然后按照该值存到5000个小文件（记为x0,x1,…x4999）中。这样每个文件大概是200k左右。如果其中的有的文件超过了1M大小，还可以按照类似的方法继续往下分，直到分解得到的小文件的大小都不超过1M。 hash_map统计：对每个小文件，采用trie树/hash_...
海量数据处理问题
wenxingxingxing的博客
07-30 376
@【TOC】（海量数据处理问题） topk问题 1、海量日志数据，提取出某日访问百度次数最多的那个IP。 主要问题： IP地址最多有2^32=4G种取值情况，所以不能完全加载到内存中处理 解决方案： 采用映射的方法，比如模1000，把整个大文件映射为1000个小文件 再找出每个小文中出现频率最大的IP（可以采用hash_map进行频率统计，然后再找出频率最大的几个）及相应的频率。然后再在这1000个最大的IP中，找出那个频率最大的IP ...
面试题篇-14-业务场景相关面试题
Alan0517
07-04 810
但是如果我们有几千万甚至上亿的数据的时候｛如图｝，虽然可以通过不同的数据结构来优化数据检索的时间复杂度，但是整体的效率依然很慢，而且会占用非常多的内存空间，这个问题该怎么解决呢？同样的道理，当发布的服务节点重新启动以后，注册中心也同样会收到通知，于是，把本地长连接池里面的长连接销毁，并重新建立新的连接出发新的 reblance 平衡即可。扫码登录的本质是，通过已经登录过的 App 应用，扫描未登录的 Web 端程序中的二维码， 通过某种机制触发登录凭证的写入从而实现 Web 端自动登录的过程。
基于SSM班级事务管理系统的设计
最新发布
2401_87849773的博客
10-15 369
管理员账户功能包括：系统首页，个人中心，学生管理，班委管理，班会组织管理，健康档案管理，党员发展管理，党员培训管理，学生成绩管理。主要技术：Java,Spring,mybatis,mysql,jquery,html。班委账号功能包括：系统首页，学生管理，学生成绩管理，活动信息管理，班费通知管理。服务器：SpringBoot自带 apache tomcat。JDK版本：Java JDK1.8。数据库可视化工具： navicat。数据库版本： mysql5.7。开发系统：Windows。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值