Sorting 保留最大的10个数字

在对数据集进行迭代时，以排序的顺序只跟踪目前排名前10位的数字的最佳方法是什么

解决方案…最终实现了通用的最小和最大堆…遗憾的是，它们在Java库中或internet上都不可用…代码上没有高卢人

import java.util.ArrayList;

public class MaxHeapGeneric <K extends Comparable> {
    //ArrayList to hold the heap
    ArrayList<K> h = new ArrayList<K>();
    public MaxHeapGeneric()
    {

    }
    public int getSize()
    {
        return h.size();
    }

    private K get(int key){
        return h.get(key);
    }


    public void add(K key){
        h.add(null);
        int k = h.size() - 1;
        while (k > 0){
            int parent = (k-1)/2;
            K parentValue = h.get(parent);
            //MaxHeap -
            //for minheap - if(key > parentValue)
            if(key.compareTo(parentValue) <= 0) break;
            h.set(k, parentValue);
            k = parent;
        }
        h.set(k, key);
    }
    public K getMax()
    {
        return h.get(0);
    }
    public void percolateUp(int k, K key){
        if(h.isEmpty())
            return ;

        while(k < h.size() /2){
            int child = 2*k + 1; //left child
            if(   child < h.size() -1 && (h.get(child).compareTo(h.get(child+1)) < 0)   )
            {
                child++;
            }

            if(key.compareTo(h.get(child)) >=0) break;

            h.set(k, h.get(child));
            k = child;
        }
        h.set(k, key);
    }
    public K remove()
    {
        K removeNode = h.get(0);
        K lastNode = h.remove(h.size() - 1);
        percolateUp(0, lastNode);
        return removeNode;
    }
    public boolean isEmpty()
    {
        return h.isEmpty();
    }

    public static void main(String[] args)
    {
        MaxHeapGeneric<Integer> test = new MaxHeapGeneric<Integer>();

        test.add(5);
        test.add(9);
        test.add(445);
        test.add(1);
        test.add(534);
        test.add(23);

        while(!test.isEmpty())
        {
            System.out.println(test.remove());
        }

    }

}

import java.util.ArrayList；
公共类MaxHeapGeneric{
//保存堆的ArrayList
ArrayList h=新的ArrayList（）；
公共MaxHeapGeneric（）
{
}
公共int getSize（）
{
返回h.size（）；
}
私有K-get（int-key）{
返回h.get（键）；
}
公共无效添加（K键）{
h、 添加（空）；
int k=h.size（）-1；
而（k>0）{
int parent=（k-1）/2；
K parentValue=h.get（父级）；
//最大堆-
//对于minheap-if（键>父值）
if（key.compareTo（parentValue）=0）中断；
h、 set（k，h.get（child））；
k=儿童；
}
h、 set（k，键）；
}
公共K删除（）
{
K removeNode=h.get（0）；
K lastNode=h.remove（h.size（）-1）；
percolateUp（0，lastNode）；
返回removeNode；
}
公共布尔值为空（）
{
返回h.isEmpty（）；
}
公共静态void main（字符串[]args）
{
MaxHeapGeneric测试=新的MaxHeapGeneric（）；
试验。添加（5）；
试验。添加（9）；
测试。添加（445）；
测试。添加（1）；
测试。添加（534）；
增加（23）；
而（！test.isEmpty（））
{
System.out.println（test.remove（））；
}
}
}

还有一堆

import java.util.ArrayList;


public class MinHeapGeneric <K extends Comparable> {
    //ArrayList to hold the heap
    ArrayList<K> h = new ArrayList<K>();
    public MinHeapGeneric()
    {

    }
    public int getSize()
    {
        return h.size();
    }

    private K get(int key){
        return h.get(key);
    }


    public void add(K key){
        h.add(null);
        int k = h.size() - 1;
        while (k > 0){
            int parent = (k-1)/2;
            K parentValue = h.get(parent);
            //for minheap - if(key > parentValue)
            if(key.compareTo(parentValue) > 0) break;
            h.set(k, parentValue);
            k = parent;
        }
        h.set(k, key);
    }
    public K getMax()
    {
        return h.get(0);
    }
    public void percolateUp(int k, K key){
        if(h.isEmpty())
            return ;

        while(k < h.size() /2){
            int child = 2*k + 1; //left child
            if(   child < h.size() -1 && (h.get(child).compareTo(h.get(child+1)) >= 0)   )
            {
                child++;
            }

            if(key.compareTo(h.get(child)) < 0) break;

            h.set(k, h.get(child));
            k = child;
        }
        h.set(k, key);
    }
    public K remove()
    {
        K removeNode = h.get(0);
        K lastNode = h.remove(h.size() - 1);
        percolateUp(0, lastNode);
        return removeNode;
    }
    public boolean isEmpty()
    {
        return h.isEmpty();
    }

    public static void main(String[] args)
    {
        MinHeapGeneric<Integer> test = new MinHeapGeneric<Integer>();

        test.add(5);
        test.add(9);
        test.add(445);
        test.add(1);
        test.add(534);
        test.add(23);

        while(!test.isEmpty())
        {
            System.out.println(test.remove());
        }

    }

}

import java.util.ArrayList；
公共类MinHeapGeneric{
//保存堆的ArrayList
ArrayList h=新的ArrayList（）；
公共卫生（公共卫生）
{
}
公共int getSize（）
{
返回h.size（）；
}
私有K-get（int-key）{
返回h.get（键）；
}
公共无效添加（K键）{
h、 添加（空）；
int k=h.size（）-1；
而（k>0）{
int parent=（k-1）/2；
K parentValue=h.get（父级）；
//对于minheap-if（键>父值）
如果（key.compareTo（parentValue）>0）中断；
h、 set（k，parentValue）；
k=父母；
}
h、 set（k，键）；
}
公共K getMax（）
{
返回h.get（0）；
}
公共void percolateUp（int k，k key）{
if（h.isEmpty（））
返回；
而（k=0））
{
儿童++；
}
if（key.compareTo（h.get（child））<0）中断；
h、 set（k，h.get（child））；
k=儿童；
}
h、 set（k，键）；
}
公共K删除（）
{
K removeNode=h.get（0）；
K lastNode=h.remove（h.size（）-1）；
percolateUp（0，lastNode）；
返回removeNode；
}
公共布尔值为空（）
{
返回h.isEmpty（）；
}
公共静态void main（字符串[]args）
{
MinHeapGeneric测试=新的MinHeapGeneric（）；
试验。添加（5）；
试验。添加（9）；
测试。添加（445）；
测试。添加（1）；
测试。添加（534）；
增加（23）；
而（！test.isEmpty（））
{
System.out.println（test.remove（））；
}
}
}

使用最小堆（优先级队列）跟踪前10项。对于二进制堆，时间复杂度为O（N logm），其中N是项数，M是10

与在一个数组中存储顶级项相比，对于大型M，这要快得多：基于数组的方法是O（NM）。链接列表也是如此

在伪代码中：

heap = empty min-heap
for each datum d:
    heap.push(d)   // add the new element onto the heap
    if heap.size > 10:
        heap.pop() // remove the smallest element
    endif
endfor

现在，堆包含10个最大的项。要弹出：

while heap is not empty:
    item = heap.top()
    print item
endwhile

---

Sweet做到了这一点…最终创建了Java通用的最小/最大HeapsIsn而不是复杂度O（N+NlogM），因为您无论如何都必须经过N个数据点…或者您是在谈论从堆中添加/删除元素的复杂度？在Bug-O表示法中删除无关紧要的术语是常规做法。在这种情况下，

N

，所以我们说它是

O（nlgm）

。否则，它将变成

O（N*（1+lgm））

，这并没有什么不同。