算法题解：最小的K个数（海量数据Top K问题）
题目
输入 n 个整数，找出其中最小的 k 个数。例如输入四、五、一、六、二、七、三、8 这8个数字，则最小的4个数字是一、二、三、4。java
初窥
这道题最简单的思路莫过于把输入的 n 个整数排序，排序以后位于最前面的 k 个数就是最小的 k 个数。这种思路的时间复杂度是 O(nlogn)。面试
解法一：脱胎于快排的O(n)的算法
若是基于数组的第 k 个数字来调整，使得比第 k 个数字小的全部数字都位于数组的左边，比第 k 个数字大的全部数字都位于数组的右边。这样调整以后，位于数组中左边的 k 个数字就是最小的 k 个数字（这 k 个数字不必定是排序的）。下面是基于这种思路的参考代码：算法
public class LeastK {
public static void getLeastNumbers(int[] input, int[] output) {
if (input == null || output == null || output.length <= 0 || input.length < output.length) {
throw new IllegalArgumentException("Invalid args");
}
int start = 0;
int end = input.length - 1;
int index = partition(input, start, end); //切分后左子数组的长度
int target = output.length - 1; //K-1
//若切分后左子数组长度不等于K
while (index != target) {
//若切分后左子数组长度小于K，那么继续切分右子数组，不然继续切分左子数组
if (index < target) {
start = index + 1;
} else {
end = index - 1;
}
index = partition(input, start, end);
}
System.arraycopy(input, 0, output, 0, output.length);
}
private static int partition(int arr[], int left, int right) {
int i = left;
int j = right + 1;
int pivot = arr[left];
while (true) {
//找到左边大于pivot的数据，或者走到了最右边仍然没有找到比pivot大的数据
while (i < right && arr[++i] < pivot) { //求最大的k个数时，arr[++i] > pivot
if (i == right) {
break;
}
}
//找到右边小于pivot的数据，或者走到了最左边仍然没有找到比pivot小的数据
while (j > left && arr[--j] > pivot) { //求最大的k个数时，arr[--j] < pivot
if (j == left) {
break;
}
}
//左指针和右指针重叠或相遇，结束循环
if (i >= j) {
break;
}
//交换左边大的和右边小的数据
swap(arr, i, j);
}
//此时的 a[j] <= pivot，交换之
swap(arr, left, j);
return j;
}
private static void swap(int[] arr, int i, int j) {
int tmp = arr[i];
arr[i] = arr[j];
arr[j] = tmp;
}
}
采用上面的思路是有限制的，好比须要修改输入的数组，由于函数 Partition 会调整数组中的顺序，固然了，这个问题彻底能够经过事先拷贝一份新数组来解决。值得说明的是，这种思路是不适合处理海量数据的。如果遇到海量数据求最小的 k 个数的问题，可使用下面的解法。数组
解法二：适合处理海量数据的O(nlogk)的算法
咱们能够先建立一个大小为K的数据容器来存储最小的 k 个数字，接下来咱们每次从输入的 n 个整数中读入一个数。若是容器中已有的数字少于 k 个，则直接把此次读入的整数放入容器之中；若是容器中已有 k 个数字了，也就是容器已满，此时咱们不能再插入新的数字而只能替换已有的数字。找出这已有的 k 个数中的最大值，而后拿此次待插入的整数和最大值进行比较。若是待插入的值比当前已有的最大值小，则用这个数替换当前已有的最大值；若是待插入的值比当前已有的最大值还要大，那么这个数不多是最小的 k 个整数之一，因而咱们能够抛弃这个整数。ide
所以当容器满了以后，咱们要作 3 件 事情：一是在 k 个整数中找到最大数；二是有可能在这个容器中删除最大数；三是有可能要插入一个新的数字。若是用一个二叉树来实现这个数据容器，那么咱们能在O(logk)时间内实现这三步操做。所以对于 n 个输入数字而言，总的时间效率就是O(nlogk)。函数
咱们能够选择用不一样的二叉树来实现这个数据容器。因为每次都须要找到 k 个整数中的最大数字，咱们很容易想到用最大堆。在最大堆中，根结点的值老是大于它的子树中任意结点的值。因而咱们每次能够在 O(1) 获得已有的 k 个数字中的最大值，但须要 O(logk) 时间完成删除及插入操做。学习
咱们本身从头实现一个最大堆须要必定的代码，这在面试短短的几十分钟内很难完成。咱们还能够采用 Java 提供的具备优先级的队列来实现咱们的容器。this
public class LeastK {
public static Integer[] getLeastNumbers(int[] nums, int k) {
// 默认天然排序，需手动转为降序
PriorityQueue<Integer> maxQueue = new PriorityQueue<>(k, new Comparator<Integer>() {
@Override
public int compare(Integer o1, Integer o2) {
if (o1 > o2) {
return -1;
} else if (o1 < o2) {
return 1;
}
return 0;
}
});
for (int num : nums) {
if (maxQueue.size() < k || num < maxQueue.peek()) { // peek()：返回队列头部的值，也就是队列最大值
// 插入元素
maxQueue.offer(num);
}
if (maxQueue.size() > k) {
// 删除队列头部
maxQueue.poll();
}
}
return maxQueue.toArray(new Integer[0]);
}
}
海量数据Top K
Top K 问题是在面试中常常被问到的问题，好比：从20亿个数字的文本中，找出最大的前100个。指针
如果遇到此类求海量数据中最大的 k 个数的问题，能够参考上面的求最小的 k 个数，改用最小堆，实现以下的 Java 代码：code
public class TopK {
public Integer[] getLargestNumbers(int[] nums, int k) {
PriorityQueue<Integer> minQueue = new PriorityQueue<>(k); // 默认天然排序
for (int num : nums) {
if (minQueue.size() < k || num > minQueue.peek()) { // peek()：返回队列头部的值，也就是队列最小值
// 插入元素
minQueue.offer(num);
}
if (minQueue.size() > k) {
// 删除队列头部
minQueue.poll();
}
}
return minQueue.toArray(new Integer[0]);
}
}
最大堆源码
若是对最大堆的实现源码比较感兴趣的话，能够参考下面的代码自行学习。
public class MaxHeapAndTopK {
/**
* 大顶堆
*
* @param <T> 参数化类型
*/
private final static class MaxHeap<T extends Comparable<T>> {
// 堆中元素存放的集合
private List<T> items;
// 用于计数
private int cursor;
/**
* 构造一个椎，始大小是32
*/
public MaxHeap() {
this(32);
}
/**
* 造诣一个指定初始大小的堆
*
* @param size 初始大小
*/
public MaxHeap(int size) {
items = new ArrayList<>(size);
cursor = -1;
}
/**
* 向上调整堆
*
* @param index 被上移元素的起始位置
*/
public void siftUp(int index) {
T intent = items.get(index); // 获取开始调整的元素对象
while (index > 0) { // 若是不是根元素
int parentIndex = (index - 1) / 2; // 找父元素对象的位置
T parent = items.get(parentIndex); // 获取父元素对象
if (intent.compareTo(parent) > 0) { //上移的条件，子节点比父节点大
items.set(index, parent); // 将父节点向下放
index = parentIndex; // 记录父节点下放的位置
} else { // 子节点不比父节点大，说明父子路径已经按从大到小排好顺序了，不须要调整了
break;
}
}
// index此时记录是的最后一个被下放的父节点的位置（也多是自身），因此将最开始的调整的元素值放入index位置便可
items.set(index, intent);
}
/**
* 向下调整堆
*
* @param index 被下移的元素的起始位置
*/
public void siftDown(int index) {
T intent = items.get(index); // 获取开始调整的元素对象
int leftIndex = 2 * index + 1; // // 获取开始调整的元素对象的左子结点的元素位置
while (leftIndex < items.size()) { // 若是有左子结点
T maxChild = items.get(leftIndex); // 取左子结点的元素对象，而且假定其为两个子结点中最大的
int maxIndex = leftIndex; // 两个子节点中最大节点元素的位置，假定开始时为左子结点的位置
int rightIndex = leftIndex + 1; // 获取右子结点的位置
if (rightIndex < items.size()) { // 若是有右子结点
T rightChild = items.get(rightIndex); // 获取右子结点的元素对象
if (rightChild.compareTo(maxChild) > 0) { // 找出两个子节点中的最大子结点
maxChild = rightChild;
maxIndex = rightIndex;
}
}
// 若是最大子节点比父节点大，则须要向下调整
if (maxChild.compareTo(intent) > 0) {
items.set(index, maxChild); // 将子节点向上移
index = maxIndex; // 记录上移节点的位置
leftIndex = index * 2 + 1; // 找到上移节点的左子节点的位置
} else { // 最大子节点不比父节点大，说明父子路径已经按从大到小排好顺序了，不须要调整了
break;
}
}
// index此时记录是的最后一个被上移的子节点的位置（也多是自身），因此将最开始的调整的元素值放入index位置便可
items.set(index, intent);
}
/**
* 向堆中添加一个元素
*
* @param item 等待添加的元素
*/
public void add(T item) {
items.add(item); // 将元素添加到最后
siftUp(items.size() - 1); // 循环上移，以完成重构
}
/**
* 删除堆顶元素
*
* @return 堆顶部的元素
*/
public T deleteTop() {
if (items.isEmpty()) { // 若是堆已经为空，就报出异常
throw new RuntimeException("The heap is empty.");
}
T maxItem = items.get(0); // 获取堆顶元素
T lastItem = items.remove(items.size() - 1); // 删除最后一个元素
if (items.isEmpty()) { // 删除元素后，若是堆为空的状况，说明删除的元素也是堆顶元素
return lastItem;
}
items.set(0, lastItem); // 将删除的元素放入堆顶
siftDown(0); // 自上向下调整堆
return maxItem; // 返回堆顶元素
}
/**
* 获取下一个元素
*
* @return 下一个元素对象
*/
public T next() {
if (cursor >= items.size()) {
throw new RuntimeException("No more element");
}
return items.get(cursor);
}
/**
* 判断堆中是否还有下一个元素
*
* @return true堆中还有下一个元素，false堆中无下五元素
*/
public boolean hasNext() {
cursor++;
return cursor < items.size();
}
/**
* 获取堆中的第一个元素
*
* @return 堆中的第一个元素
*/
public T first() {
if (items.size() == 0) {
throw new RuntimeException("The heap is empty.");
}
return items.get(0);
}
/**
* 判断堆是否为空
*
* @return true是，false否
*/
public boolean isEmpty() {
return items.isEmpty();
}
/**
* 获取堆的大小
*
* @return 堆的大小
*/
public int size() {
return items.size();
}
/**
* 清空堆
*/
public void clear() {
items.clear();
}
@Override
public String toString() {
return items.toString();
}
}
/**
* 题目： 输入n个整数，找出其中最小的k个数
*
* @param input 输入数组
* @param output 输出数组
*/
public static void getLeastNumbers(int[] input, int[] output) {
if (input == null || output == null || output.length <= 0 || input.length < output.length) {
throw new IllegalArgumentException("Invalid args");
}
MaxHeap<Integer> maxHeap = new MaxHeap<>(output.length);
for (int i : input) {
if (maxHeap.size() < output.length) {
maxHeap.add(i);
} else {
int max = maxHeap.first();
if (max > i) {
maxHeap.deleteTop();
maxHeap.add(i);
}
}
}
for (int i = 0; maxHeap.hasNext(); i++) {
output[i] = maxHeap.next();
}
}
}
参考资料
[1] 《剑指offer》
相关文章
- 1. 算法题解：最小的K个数（海量数据Top K问题）
- 2. 海量数据取top K问题
- 3. 经典算法-海量数据处理算法（top K问题）
- 4. 海量数据中找top K专题
- 5. 海量数据处理的 Top K算法(问题) 小顶堆实现
- 6. 海量数据处理 - 找出最大的n个数（top K问题）
- 7. 寻找最大的K个数，Top K问题的堆实现
- 8. BFPRT 算法（TOP-K 问题）
- 9. 海量数据处理的 Top K 相关问题
- 10. 找出无序数组中最小的k个数（top k问题）
- 更多相关文章...
- • Redis悲观锁解决高并发抢红包的问题 - 红包项目实战
- • Redis乐观锁解决高并发抢红包的问题 - 红包项目实战
- • Flink 数据传输及反压详解
- • PHP Ajax 跨域问题最佳解决方案
相关标签/搜索
每日一句
-
每一个你不满意的现在，都有一个你没有努力的曾经。
欢迎关注本站公众号,获取更多信息
