TOP K问题

最新推荐文章于 2021-01-28 18:30:07 发布

转载最新推荐文章于 2021-01-28 18:30:07 发布 · 863 阅读

文章标签：

本文探讨了如何处理上千万乃至上亿级别的数据集中找出出现频率最高的前N个数据的问题。介绍了适用于不同规模数据集的多种解决方案，包括使用Trie树、堆、数据库索引等方法，并详细阐述了当数据量过大无法一次性加载进内存时，如何借助硬盘存储、分布式计算（如MapReduce）、外排序等技术手段实现高效处理。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

经典问题分析

http://blog.youkuaiyun.com/liu6539152/article/details/7081602

上千万or亿数据（有重复），统计其中出现次数最多的前N个数据,分两种情况：可一次读入内存，不可一次读入。

可用思路：trie树+堆，数据库索引，划分子集分别统计，hash，分布式计算，近似统计，外排序

所谓的是否能一次读入内存，实际上应该指去除重复后的数据量。如果去重后数据可以放入内存，我们可以为数据建立字典，比如通过 map，hashmap，trie，然后直接进行统计即可。当然在更新每条数据的出现次数的时候，我们可以利用一个堆来维护出现次数最多的前N个数据，当然这样导致维护次数增加，不如完全统计后在求前N大效率高。

如果数据无法放入内存。一方面我们可以考虑上面的字典方法能否被改进以适应这种情形，可以做的改变就是将字典存放到硬盘上，而不是内存，这可以参考数据库的存储方法。

当然还有更好的方法，就是可以采用分布式计算，基本上就是map-reduce过程，首先可以根据数据值或者把数据hash(md5)后的值，将数据按照范围划分到不同的机子，最好可以让数据划分后可以一次读入内存，这样不同的机子负责处理各种的数值范围，实际上就是map。得到结果后，各个机子只需拿出各自的出现次数最多的前N个数据，然后汇总，选出所有的数据中出现次数最多的前N个数据，这实际上就是reduce过程。

实际上可能想直接将数据均分到不同的机子上进行处理，这样是无法得到正确的解的。因为一个数据可能被均分到不同的机子上，而另一个则可能完全聚集到一个机子上，同时还可能存在具有相同数目的数据。比如我们要找出现次数最多的前100个，我们将1000万的数据分布到10台机器上，找到每台出现次数最多的前 100个，归并之后这样不能保证找到真正的第100个，因为比如出现次数最多的第100个可能有1万个，但是它被分到了10台机子，这样在每台上只有1千个，假设这些机子排名在1000个之前的那些都是单独分布在一台机子上的，比如有1001个，这样本来具有1万个的这个就会被淘汰，即使我们让每台机子选出出现次数最多的1000个再归并，仍然会出错，因为可能存在大量个数为1001个的发生聚集。因此不能将数据随便均分到不同机子上，而是要根据hash 后的值将它们映射到不同的机子上处理，让不同的机器处理一个数值范围。

而外排序的方法会消耗大量的IO，效率不会很高。而上面的分布式方法，也可以用于单机版本，也就是将总的数据根据值的范围，划分成多个不同的子文件，然后逐个处理。处理完毕之后再对这些单词的及其出现频率进行一个归并。实际上就可以利用一个外排序的归并过程

package book_list;

import java.io.IOException;
import java.util.ArrayList;
import java.util.TreeSet;

import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.fs.Path;
import org.apache.hadoop.io.IntWritable;
import org.apache.hadoop.io.LongWritable;
import org.apache.hadoop.io.NullWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Job;
import org.apache.hadoop.mapreduce.Mapper;
import org.apache.hadoop.mapreduce.Reducer;
import org.apache.hadoop.mapreduce.lib.input.FileInputFormat;
import org.apache.hadoop.mapreduce.lib.input.TextInputFormat;
import org.apache.hadoop.mapreduce.lib.output.FileOutputFormat;
import org.apache.hadoop.mapreduce.lib.output.TextOutputFormat;

//利用MapReduce求最大值海量数据中的K个数
public class Top_k_new {

	public static class MapClass extends
			Mapper<LongWritable, Text, NullWritable, IntWritable> {
		public static final int K = 5;
		private ArrayList<IntWritable>fatcats=new ArrayList<IntWritable>();
		private TreeSet<Integer>set=new TreeSet<Integer>();
		public void map(LongWritable key, Text value, Context context)
				throws IOException, InterruptedException {
			int temp = Integer.parseInt(value.toString());
			fatcats.add(new IntWritable(temp));
			set.add(temp);
			if(set.size()>K)
				set.remove(set.first());
		}

		@Override
		protected void cleanup(Context context) throws IOException,
				InterruptedException {
//			System.out.println("map size is "+fatcats.size());
//			for (Text text : fatcats.values()) {
//				context.write(NullWritable.get(), text);
//				System.out.println("value is " + text);
//			}
//			for(int i=0;i<fatcats.size();++i)
//			{
//				context.write(NullWritable.get(),fatcats.get(i));
//			}
			int size=set.size();
			for(int i=0;i<size;++i)
			{
				context.write(NullWritable.get(),new IntWritable(set.first()));
				set.remove(set.first());
			}
				// for(int i=0;i<K;++i)
			// {
			// context.write(NullWritable.get(),new
			// Text(fatcats.firstEntry().getValue()));
			// System.out.println("top "+i+" :"+fatcats.firstEntry().getValue());
			// fatcats.remove(fatcats.firstKey());
			// }
		}
	}

	public static class Reduce extends
			Reducer<NullWritable, IntWritable, NullWritable, IntWritable> {
		public static final int K = 5;
//		private TreeMap<Integer, Text> fatcats = new TreeMap<Integer, Text>();
		private TreeSet<Integer>fatcats=new TreeSet<Integer>();

		public void reduce(NullWritable key, Iterable<IntWritable> values,
				Context context) throws IOException, InterruptedException {
			for (IntWritable val : values) {
//				String v[] = val.toString().split(" ");
//				System.out.println("v[1] is"+v[1]);
//				Integer weight = Integer.parseInt(v[1]);
//				fatcats.put(weight, val);
//				 if (fatcats.size() > K)
//				 fatcats.remove(fatcats.firstKey());
				System.out.println(val);
				fatcats.add(val.get());
			}
//			int size=fatcats.size();
//			for(int i=0;i<size;++i){
//				context.write(NullWritable.get(),new IntWritable(fatcats.first()));
//				fatcats.remove(fatcats.first());
//			}
			for(int i=0;i<K;++i){
				context.write(NullWritable.get(), new IntWritable(fatcats.first()));
				fatcats.remove(fatcats.first());
			}
		}
	}

	public static void main(String[] args) throws Exception {
		Configuration conf = new Configuration();
		Job job = new Job(conf, "TopKNum");
		job.setJarByClass(Top_k_new.class);
		FileInputFormat.setInputPaths(job, new Path("/user/list"));
		FileOutputFormat.setOutputPath(job, new Path("/user/top-k"));
		job.setMapperClass(MapClass.class);
		// job.setCombinerClass(Reduce.class);
		job.setReducerClass(Reduce.class);
		job.setInputFormatClass(TextInputFormat.class);
		job.setOutputFormatClass(TextOutputFormat.class);
		job.setOutputKeyClass(NullWritable.class);
		job.setOutputValueClass(IntWritable.class);
		System.exit(job.waitForCompletion(true) ? 0 : 1);
	}

}