scala写算法-用小根堆解决topK

topK问题是指从大量数据中获取最大(或最小)的k个数,比如从全校学生中寻找成绩最高的500名学生等等.

本问题可采用小根堆解决.思路是先把源数据中的前k个数放入堆中,然后构建堆,使其保持堆序(可以简单的看成k次insert操作).然后从源数据中的第k个数据之后的每个元素与堆的根节点(小根堆得root是最小的)比较,如果小于root,那么直接pass;如果大于,则执行headp.deleteMin,然后把该元素插入堆中并再次保持堆序.保持堆序需要涉及上滤与下滤的过程.

样例为:

object Main extends App{
  val array=Array(0,14,16,19,3,3768,345,3,343,545,455,7567,657,67,65756,756,756,756,7657,657,657,4,534,535,345343,423,4,46546,546,544,546,546,345,345,435,34534,53,5345,45,45,435,43,54,35,435,435,34,5,435,45,65,65,6576,7,65,56,7,45,43,543,53,453,45,345,34)
  //数组从1开始
  val k=3
  val heap=new Heap
  1 to k foreach(i=>heap.insert(array(i)))
  k+1 to array.length-1 foreach(i=>{
    while (heap.getSize>10){
      heap.deleteMin
    }
    if(array(i)>heap.getMin){
      heap.deleteMin
      heap.insert(array(i))
    }
  })
  heap.print
}

再来说说,Heap是如何实现的

运用scala常常遇到这样的选择:变量的变与不变,这是一个问题.

还有for推导式,实际上是map flatMap等的语法糖.

代码:

class Heap {
  type T=Int
  private var size=0
  val elemnts=new Array[T](200) // 把index=0处的位置空出 2n 2n+1 n/2
  def getSize:Int=return size
  def insert(x:T):Unit={
    def loop(i:Int):Int={
      if(elemnts(i/2)<=x)
        return i
      elemnts(i)=elemnts(i/2)
      loop(i/2)
    }
    val i=loop(size+1)
    elemnts(i)=x
    size+=1
  }
  def deleteMin:T={
    def loop(i:Int):Int={
      if(i>size) return i/2
      val left=elemnts(2*i)
      val right=elemnts(2*i+1)
      if(left<right){
        elemnts(i)=left
        loop(i*2)
      }else{
        elemnts(i)=right
        loop(2*i+1)
      }
    }
    val result=elemnts(1)
    val last=elemnts(size)
    val i=loop(1)
    elemnts(i)=last
    size-=1
    return result
  }
  def print:Unit= 1 to size foreach(i=>println(elemnts(i)))
  def getMin:T=return elemnts(1)
  //代码亲测无误
}

在实现insertdeleteMin时,由于scala并没有break关键字(虽然你可以使用Breakable这个类实现,实际上通过抛出异常模拟break,不灵活),为实现上虑(insert),考虑用递归来模拟for循环.

代码:

  def insert(x:T):Unit={
    def loop(i:Int):Int={
      if(elemnts(i/2)<=x)
        return i //如果父亲节点比待插入值x小,则本节点应该插入x
      elemnts(i)=elemnts(i/2) //上虑
      loop(i/2)
    }
    val i=loop(size+1) //返回待x插入的位置
    elemnts(i)=x
    size+=1
  }

相比从c语言版,基于scala的代码还是容易记忆与相当稳健:

void insert(Element x,Heap* h){
    int i=0;
    if(isFull(h))
        error("full");
    for(i=++h->size;h->elements[i/2]>x;i/=2)
        h->elements[i]=h->elements[i/2];
    h->elements[i]=x;
}
时间: 2024-10-05 05:58:45

scala写算法-用小根堆解决topK的相关文章

Java最小堆解决TopK问题

TopK问题是指从大量数据(源数据)中获取最大(或最小)的K个数据. TopK问题是个很常见的问题:例如学校要从全校学生中找到成绩最高的500名学生,再例如某搜索引擎要统计每天的100条搜索次数最多的关键词. 对于这个问题,解决方法有很多: 方法一:对源数据中所有数据进行排序,取出前K个数据,就是TopK. 但是当数据量很大时,只需要k个最大的数,整体排序很耗时,效率不高. 方法二:维护一个K长度的数组a[],先读取源数据中的前K个放入数组,对该数组进行升序排序,再依次读取源数据第K个以后的数据

随手练——HDU Safe Or Unsafe (小根堆解决哈夫曼问题)

HDU 2527 :http://acm.hdu.edu.cn/showproblem.php?pid=2527 哈夫曼树,学完就忘得差不多了,题目的意思都没看懂,有时间复习下,看了别人的才知道是怎么回事. 贪心的题目,当总代价(要求最少)是由子代价累加或累乘出来,就可以考虑用哈夫曼来贪心. 题意: 就是给你一个字符串如:12 helloworld 统计出其中 d:1个,e:1个,h:1个,l:3个,o:2个,r:1个,w:1个,然后用一个数组保存起来a[7]={1,1,1,1,1,2,3};然

自己写算法---java的堆的非递归遍历

import java.io.*; import java.util.*; public class Main { public static void main(String args[]) { Scanner cin = new Scanner(System.in); //ArrayList<String> list = new ArrayList<String>(); //Scanner scan = new Scanner(System.in); //获取键盘输入的另一种格

【坐在马桶上看算法】算法12:堆——神奇的优先队列(下)

接着上一Pa说.就是如何建立这个堆呢.可以从空的堆开始,然后依次往堆中插入每一个元素,直到所有数都被插入(转移到堆中为止).因为插入第i个元素的所用的时间是O(log i),所以插入所有元素的整体时间复杂度是O(NlogN),代码如下. n=0; for(i=1;i<=m;i++) {     n++;     h[ n]=a[ i];  //或者写成scanf("%d",&h[ n]);     siftup(); } 其实我们还有更快得方法来建立堆.它是这样的. 直接

【坐在马桶上看算法】算法11:堆——神奇的优先队列(上)

堆是什么?是一种特殊的完全二叉树,就像下面这棵树一样. 有没有发现这棵二叉树有一个特点,就是所有父结点都比子结点要小(注意:圆圈里面的数是值,圆圈上面的数是这个结点的编号,此规定仅适用于本节).符合这样特点的完全二叉树我们称为最小堆.反之,如果所有父结点都比子结点要大,这样的完全二叉树称为最大堆.那这一特性究竟有什么用呢? 假如有14个数分别是99.5.36.7.22.17.46.12.2.19.25.28.1和92.请找出这14个数中最小的数,请问怎么办呢?最简单的方法就是将这14个数从头到尾

【啊哈!算法】算法12:堆——神奇的优先队列(下)

接着上一Pa说.就是如何建立这个堆呢.可以从空的堆开始,然后依次往堆中插入每一个元素,直到所有数都被插入(转移到堆中为止).因为插入第i个元素的所用的时间是O(log i),所以插入所有元素的整体时间复杂度是O(NlogN),代码如下. n=0; for(i=1;i<=m;i++) { n++; h[ n]=a[ i]; //或者写成scanf("%d",&h[ n]); siftup(); } 其实我们还有更快得方法来建立堆.它是这样的. 直接把99.5.36.7.22

【转载】夜深人静写算法(四)——差分约束

[转载]夜深人静写算法(四) - 差分约束  目录     一.引例       1.一类不等式组的解   二.最短路       1.Dijkstra       2.图的存储       3.链式前向星       4.Dijkstra + 优先队列       5.Bellman-Ford       6.SPFA       7.Floyd-Warshall   三.差分约束        1.数形结合        2.三角不等式        3.解的存在性        4.最大值

[大、小根堆应用总结一]堆排序的应用场景

前言 在整理算法题的时候发现,大根堆(小根堆)这种数据结构在各类算法中应用比较广泛,典型的堆排序,以及利用大小根堆这种数据结构来找出一个解决问题的算法最优解.因此,我打算单独将关于堆的应用独立总结出来,后面每遇到一种跟堆结构相关的应用都放到这个目录下. 堆的定义 n个关键字序列L[1-n]称为堆,当且仅当该序列满足: 1. L(i)<=L(2i)且L(i)<=L(2i+1)或 2. L(i)>=L(2i)且L(i)>=L(2i+1) 满足第一个条件的成为小根堆(即每个结点值小于它的

基于PriorityQueue(优先队列)解决TOP-K问题

TOP-K问题是面试高频题目,即在海量数据中找出最大(或最小的前k个数据),隐含条件就是内存不够容纳所有数据,所以把数据一次性读入内存,排序,再取前k条结果是不现实的. 下面我们用简单的Java8代码去解决TOP-K问题.为了使主要的逻辑更加清晰,去掉了一些如参数合法性检查等非关键代码. PriorityQueue(优先队列)是JDK1.5开始提供的,主要作者包括大名鼎鼎的纽约大学教授Doug Lea,他也是Java JUC包的鼻祖哦. PriorityQueue相当于一个堆(默认为小根堆,如果