排序算法，堆算法实现TopK

TopK问题

TopK问题是一个经典的算法问题，TopK可以拆分为2个词Top, K意思就是选出其中最Top的K个变量，Top的意思可以是值最大，也可以是其他的一些衡量条件。也许你会想，这不是很简单吗，比如选一组数字中最大的一组数字，做个冒泡排序，输出前K个就OK了啊，当然没有说错，但是前提条件错了，数据量是非常庞大的时候，也许就没有这么简单了，有的时候，对于单个变量的计数统计，就有可能遇到问题。比如说一个查询统计，最后我要1天之内查询频率最高的10个词，并输出他们。面对成千上万的查询记录，关关统计每个查询词的次数就需要想高效率的方法。OK,下面就从这个切人点开始TopK问题的研究。

计数统计问题

比如一组查询记录a b c a，这里以空格隔开，代表4次查询，这里可以明显看出a 2次，b 1次，c 1次，你可以存到一个map中做统计。一个最笨的办法就是一个个暴力的去比较，如果已经存在进行计数加1，这也是我们直接会想到的解决办法。其实用暴力统计算法时，可以先排下序，可以提高效率的，原因自己分析下。下面是关键的部分了，这里推荐一种空间换时间的办法，用字符串哈希算法，做映射，你可以类比于BloomFilter算法的实现，然后最后再加入到map时，直接映射，取出值存入map即可。

TopK筛选

统计计数的过程结束之后，就是真正的TopK问题了，首先要明确一点，数据是海量的情况，肯定是不能全部数据进行排序的，所以我们可以维护K个变量，先读入K分变量，并排好序，然后再次读入一个变量，调整一下这K个变量，直到读完最后最后一个变量，这是一种方法，还有一种相比于普通排序算法更高效的算法，就是用堆排序算法来解决这个问题。先对K个打乱的树进行初始化堆排序，后面读入每次查询数据进行一次堆调整。

关键代码实现

完整代码，请点击此处，https://github.com/linyiqun/lyq-algorithms-lib/tree/master/TopK

一个是计数过程的实现代码StatisticTool.java：

package TopK;

import java.io.BufferedReader;
import java.io.File;
import java.io.FileReader;
import java.io.IOException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Map;

/**
 * 统计工具类
 * 
 * @author lyq
 * 
 */
public class StatisticTool {
	// 哈希表存放查询词以及查询数
	public static int[] countMap;

	// query查询文件地址
	private String filePath;
	// 哈希表容量
	private int mapCotainNum;
	// 查询词集
	private ArrayList<String> queryWords;
	// 存放查询词计数键值对
	private Map<String, Integer> query2Count;

	public StatisticTool(String filePath, int mapCotainNum) {
		this.filePath = filePath;
		this.mapCotainNum = mapCotainNum;
		
		//执行初始化操作
		initOperation();
		readDataFile();
	}

	/**
	 * 从文件中读取数据
	 */
	private void readDataFile() {
		File file = new File(filePath);
		ArrayList<String> dataArray = new ArrayList<String>();

		try {
			BufferedReader in = new BufferedReader(new FileReader(file));
			String str;
			String[] array;
			
			while ((str = in.readLine()) != null) {
				array = str.split(" ");
				
				for(String s: array){
					dataArray.add(s);
				}
			}
			in.close();
		} catch (IOException e) {
			e.getStackTrace();
		}

		queryWords = dataArray;
	}

	/**
	 * 初始化操作，在每次进行统计操作前进行
	 */
	public void initOperation() {
		this.countMap = new int[mapCotainNum];
		this.query2Count = new HashMap<String, Integer>();
	}

	/**
	 * 对总查询词进行冒泡排序操作
	 */
	public String[] sortQuerys() {
		int k;
		String str1;
		String str2;
		String temp;
		String[] tempWords;

		tempWords = new String[queryWords.size()];
		queryWords.toArray(tempWords);

		// 通过冒泡排序对查询词进行排序
		for (int i = 0; i < tempWords.length - 1; i++) {
			k = i;

			for (int j = i + 1; j < tempWords.length; j++) {
				str1 = tempWords[k];
				str2 = tempWords[j];

				if (str1.compareTo(str2) > 0) {
					k = j;
				}
			}

			if (k != i) {
				temp = tempWords[i];
				tempWords[i] = tempWords[k];
				tempWords[k] = temp;
			}
		}

		return tempWords;
	}

	/**
	 * 通过外部排序的算法实现统计
	 */
	public void statisticBySort() {
		int count;
		//最后的词是否相等
		boolean isEndSame;
		//上一个词
		String lastWord;
		String[] sortedWord;

		sortedWord = sortQuerys();

		lastWord = sortedWord[0];
		count = 0;
		isEndSame = false;
		
		this.query2Count.clear();
		// 进行线性扫描统计
		for (String w : sortedWord) {
			// 如果本次的词等于上次的词，则计数加1
			if (w.equals(lastWord)) {
				count++;
				isEndSame = true;
			} else {
				// 将上次的词存入map
				query2Count.put(lastWord, count);
				
				//重置操作
				lastWord = w;
				count = 1;
				isEndSame = false;
			}
		}
		
		//如果最后的词是相等的，则，统计解法存入
		if(isEndSame){
			query2Count.put(lastWord, count);
		}
	}

	/**
	 * 用哈希表的方法进行查询词的统计计数
	 */
	public void statisticByHash() {
		long pos;
		int count;

		count = 0;
		pos = -1;
		
		this.query2Count.clear();
		for (String word : queryWords) {
			pos = HashTool.BKDRHash(word);
			pos %= mapCotainNum;

			if (countMap[(int) pos] != 0) {
				countMap[(int) pos]++;
			} else {
				//countMap中的数组默认值为0
				countMap[(int) pos] = 1;
			}
		}

		// 将统计结果存入map中，供下个阶段使用
		for (String word : queryWords) {
			pos = HashTool.BKDRHash(word);
			pos %= mapCotainNum;

			count = countMap[(int) pos];
			// 直接存入map中
			query2Count.put(word, count);
		}
	}

	/**
	 * 获取计数图
	 * @return
	 */
	public Map<String, Integer> getQuery2Count() {
		return this.query2Count;
	}

}

一个是TopK过程的实现代码SelectTool.java(堆排序算法可能比较难懂，最后拿纸笔演示)：

package TopK;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Map;

/**
 * 筛选出TopK的算法工具类
 * 
 * @author lyq
 * 
 */
public class SelectTool {
	// 筛选的前K个值的K数值
	private int k;
	// 计数统计图
	private Map<String, Integer> countMap;
	// 筛选出的TopK的查询数据
	private ArrayList<Query> queryList;

	public SelectTool(int k, Map<String, Integer> countMap) {
		this.k = k;
		this.countMap = countMap;
	}

	/**
	 * 利用外部排序进行TopK的选举,维护K个变量
	 */
	public void selectTopKBySort() {
		int index;
		int count;
		String queryWord;
		Query insertQuery;
		Query query;
		Query query2;

		index = 0;
		queryList = new ArrayList<>();
		for (Map.Entry<String, Integer> entry : countMap.entrySet()) {
			index++;
			count = entry.getValue();
			queryWord = entry.getKey();
			insertQuery = new Query(count, queryWord);

			if (index < k) {
				queryList.add(insertQuery);
			} else if (index == k) {
				queryList.add(insertQuery);
				// 对查询结果进行初次排序
				Collections.sort(queryList);
			} else if (index > k) {
				for (int i = 0; i < queryList.size() - 1; i++) {
					query = queryList.get(i);
					query2 = queryList.get(i + 1);

					// 寻找插入的位置，如果count值在前后query之间，则进行替换
					if (query.count >= insertQuery.count
							&& query2.count < insertQuery.count) {
						queryList.set(i + 1, insertQuery);
						break;
					}
				}
			}
		}
		
		outputTopKQuerys();
	}

	/**
	 * 通过堆排序算法进行TopK的筛选
	 */
	public void selectTopKByMaxHeap() {
		int index;
		int count;
		String queryWord;
		Query insertQuery;

		index = 0;
		queryList = new ArrayList<>();
		for (Map.Entry<String, Integer> entry : countMap.entrySet()) {
			index++;
			count = entry.getValue();
			queryWord = entry.getKey();
			insertQuery = new Query(count, queryWord);

			if (index < k) {
				queryList.add(insertQuery);
			} else if (index == k) {
				queryList.add(insertQuery);

				// 如果刚刚填满k个查询量，则进行初始堆排序
				queryList = initMaxHeap(queryList);
			} else if (index > k) {
				// 插入一个新的查询值，并维护这个堆结构
				adjustHeap(insertQuery, queryList);
			}
		}
		
		outputTopKQuerys();
	}

	/**
	 * 初始化个数为k的大顶堆
	 * 
	 * @param queryList
	 *            返回排好序的新的堆
	 * @return
	 */
	private ArrayList<Query> initMaxHeap(ArrayList<Query> queryList) {
		// 第一个查询词
		Query firstQuery;
		ArrayList<Query> newMaxHeap;

		newMaxHeap = new ArrayList<>();
		for (int i = 0; i < k; i++) {
			adjustMinValueFromHeap(queryList);

			// 将第一个元素与最后一个元素互换
			firstQuery = queryList.get(0);

			newMaxHeap.add(firstQuery);
			// 将第一个用无限小替代
			queryList.set(0, new Query(-Integer.MAX_VALUE, null));
		}

		return newMaxHeap;
	}

	/**
	 * 选出当前堆中最小的元素，与最后一个位置的元素进行交换
	 * 
	 * @param queryList
	 *            目前维护的大顶堆
	 */
	private void adjustMinValueFromHeap(ArrayList<Query> queryList) {
		int currentIndex;
		int otherIndex;
		int leafIndex;
		Query temp;
		Query query;
		Query query2;
		Query parentQuery;

		// 计算叶子节点的最小下标号
		leafIndex = k / 2;

		for (int i = leafIndex; i < k; i += 2) {
			currentIndex = i;

			// 如果当前判断还没有到根节点
			while (currentIndex > 0) {
				query = queryList.get(currentIndex);

				// 判断节点是否为左子节点还是右子节点，再判断取哪侧的节点
				if (currentIndex % 2 == 0) {
					otherIndex = currentIndex - 1;
					query2 = queryList.get(otherIndex);
				} else {
					otherIndex = currentIndex + 1;
					query2 = queryList.get(otherIndex);
				}

				// 赋值子节点下标
				if (query.count < query2.count) {
					currentIndex = otherIndex;
					temp = query2;
				} else {
					temp = query;
				}
				parentQuery = queryList.get((currentIndex - 1) / 2);

				// 重新进行赋值操作
				if (temp.count > parentQuery.count) {
					queryList.set((currentIndex - 1) / 2, temp);
					queryList.set(currentIndex, parentQuery);
				}

				// 比较操作向上回溯
				currentIndex = (currentIndex - 1) / 2;
			}
		}
	}

	/**
	 * 进行大顶堆的调整
	 * 
	 * @param insertQuery
	 *            待插入的查询词
	 * @param queryList
	 *            堆数据
	 */
	public void adjustHeap(Query insertQuery, ArrayList<Query> queryList) {
		int currentIndex;
		int leftIndex;
		int rightIndex;

		Query query;
		Query leftQuery;
		Query rightQuery;

		currentIndex = 0;
		while (currentIndex < queryList.size()) {
			query = queryList.get(currentIndex);

			// 如果待插入的查询计数比当前大，则做替换
			if (insertQuery.count > query.count) {
				queryList.set(currentIndex, insertQuery);
				break;
			} else {
				leftIndex = 2 * (currentIndex + 1) - 1;
				rightIndex = 2 * (currentIndex + 1);

				leftQuery = queryList.get(leftIndex);
				rightQuery = queryList.get(rightIndex);

				// 选择一个计数值较小的做递归比较
				if (leftQuery.count < rightQuery.count) {
					// 下标做变换
					currentIndex = leftIndex;
					query = leftQuery;
				} else {
					// 下标做变换
					currentIndex = rightIndex;
					query = rightQuery;
				}
			}
		}
	}

	/**
	 * 输出TopK的统计结果
	 */
	private void outputTopKQuerys() {
		int i = 0;

		for (Query q : queryList) {
			System.out.println("Top " + (i+1) + ":" + q.word + ":计数" + q.count);
			i++;
		}
	}
}

测试例子

输入

my name is is is lin yi yi qun qun a a a a b

输出

普通排序算法实现TopK
Top 1:a:计数4
Top 2:is:计数3
Top 3:qun:计数2
Top 4:yi:计数2
Top 5:lin:计数1
Top 6:name:计数1
Top 7:my:计数1

堆排序算法实现TopK
Top 1:a:计数4
Top 2:is:计数3
Top 3:qun:计数2
Top 4:lin:计数1
Top 5:b:计数1
Top 6:name:计数1
Top 7:yi:计数2

参考链接 http://blog.csdn.net/liyongbao1988/article/details/7397117