堆的使用：使用小顶堆处理问题----查找几个数组中最大的k个数

原问题是：给定两个数组，求两个数组中最大的k个数

刚上来看到是两个数组以为要排序，后来发现2个数组其实也只是幌子，可以使用维持一个k个数的集合，进一个（依次）出一个（最小值）的方式来解决，最后全部过滤完留在集合里的就是最大的k个数，时间上需要考虑的就是(N-k)*time1(k)+time2(k)，其中N为这两个数组的总数目，time1(k)为在集合中每次新加一个元素然后从k+1个元素中踢出最小值的时间，time2(k)为构建初始集合的时间。

 

影响时间的因素主要是3部分（N-k），time1(k)，time2(k).

这里使用小顶堆来做为过滤使用的集合，其:

time2: 建堆最坏klogk,平均kO(1);

time1: 过滤操作：相当于删除堆顶元素，然后执行一次堆顶元素的重定位（说重排序也不准确，不知道用什么词来表达）

 

1.      堆的数据结构

package ADT.Heap;

/**
 * Created by Lijn on 2016/4/6.
 *
 * @author Lijn
 */
public interface IHeap<T extends Comparable<T>> {

    /**
     * @Description:  插入
     * @return
     */
    public void insert(T x);

    /**
     * @Description:  查找最小值
     * @return
     */
    public T findMin();

    /**
     * @Description:  删除最小值
     * @return
     */
    public T deleteMin();

    /**
     * @Description:  是否为空
     * @return
     */
    public boolean isEmpty();

    /**
     * @Description:  清空
     */
    public void makeEmpty();
}

/**
 * @Title:       BinaryHeap.java
 * @Description:  小顶堆
 * @date:        2014-11-3下午6:17:59
 * @version:     V1.0
 */
package ADT.Heap;

import java.lang.reflect.Array;
import java.util.Arrays;

/**
 * @Description:
 * @author: 	 Lijn
 * @time:        2014-11-3
 */
public class BinaryHeap<T extends Comparable<T>> implements IHeap<T>
{

	/**
	 * @Description:  默认大小
	 */
    protected static final int DEFAULT_CAPACITY=8;
	
	/**
	 * @Description: 存储的节点数目
	 */
	protected int currentSize;
    protected T[] arrayData;
	
	/**
	 * @Description: constructor
	 */
	public BinaryHeap()
	{
		arrayData =(T[])Array.newInstance(Comparable.class, DEFAULT_CAPACITY);
	}

    /**
     * @Description: constructor
     */
    public BinaryHeap(int n)
    {
        arrayData =(T[])Array.newInstance(Comparable.class, n+1);
    }
	
	/**
	 * @Description: constructor:初始数组
	 * @param items
	 * @throws Exception
	 */
	public BinaryHeap(T[] items) throws Exception
	{
		currentSize=items.length;
		arrayData =(T[])new Comparable[(currentSize+1)*11/10];
		
		//浅拷贝
		int i=1;
		for(T t:items)
		{
			arrayData[i++]=t;
		}
		buildHeap();
	}
	
	/**
	 * @Description:  插入2叉堆
	 * 堆的平均插入次数是O(1):2.607;最大插入次数是O(log(N))
	 * @param x
	 */
	public void insert(T x)
	{
		//数组不够则扩充
		if(currentSize == arrayData.length - 1){
			enlargeArray(arrayData.length*2);
		}
		
		//插入空穴
		int hole = ++currentSize;
		
		//上虑
		for(;hole>1 && x.compareTo(arrayData[hole/2])<0;hole/=2){
			arrayData[hole] = arrayData[hole/2];
		}
		
		arrayData[hole] = x;
	}
	
	/**
	 * @Description:  查找最小值
	 * @return
	 */
	public T findMin() {
		if(isEmpty())
		{
			return null;
		}else{
			return arrayData[1];
		}
	}
	
	/**
	 * @Description:  删除最小值
	 * @return
	 * @throws Exception 
	 */
	public T deleteMin()
	{
		if(isEmpty()){
			throw new RuntimeException("空堆");
		}
		
		T minT = findMin(); 
		arrayData[1] = arrayData[currentSize--];
		percolateDown(1);
		
		return minT;
	}
	
	/**
	 * @Description:  是否为空
	 * @return
	 */
	public boolean isEmpty()
	{
		return currentSize==0?true:false;
	}
	
	/**
	 * @Description:  清空
	 */
	public void makeEmpty()
	{
		currentSize=0;
	}
	
	

	
	/**
	 * @Description:  下虑操作
	 * @param hole 下移的节点的位置
	 */
	protected void percolateDown(int hole)
	{
		int child ;
		T tmp = arrayData[hole];
		for(;hole*2<=currentSize;hole=child)
		{
			//下虑 操作需要考虑左右子树的大小,取较小的子节点
			child = hole*2;
			if(child!=currentSize && arrayData[child+1].compareTo(arrayData[child])<0)
			{
				child++;
			}
			
			//空穴下虑
			if(arrayData[child].compareTo(tmp)<0)
			{
				arrayData[hole] = arrayData[child];
			}else{
				break;
			}
		}
		
		arrayData[hole] = tmp;
	}
	
	/**
	 * @Description:  上率操作
	 * @param hole
	 */
	private void percolateUp(int hole)
	{
		T x = arrayData[hole];
		for(;hole>1 && x.compareTo(arrayData[hole/2])<0;hole/=2){
			arrayData[hole] = arrayData[hole/2];
		}
		
		arrayData[hole] = x;
	}
	
	/**
	 * @Description:  将传入的数组堆序
	 */
	private void buildHeap()
	{
		for(int i=currentSize/2;i>0;i--)
		{
			percolateDown(i);
		}
	}
	
	/**
	 * @Description:  扩充数组
	 * @param newSize
	 */
	private void enlargeArray(int newSize)
	{
		if(newSize < arrayData.length )
		{
			//正好是一层叶子节点
			newSize = arrayData.length*2;
		}
		
		arrayData = Arrays.copyOf(arrayData, newSize);
	}

    public String toString(){
        StringBuilder sb = new StringBuilder();
        for(int i=1;i<=currentSize;i++){
            sb.append(arrayData[i]).append(";");
        }
        return sb.toString();
    }
}

2.      用来过滤的工具

package Option.heapUse1;


import ADT.Heap.BinaryHeap;

public class MiniTopHeap<Integer extends Comparable<Integer>> extends BinaryHeap<Integer>{

    public MiniTopHeap(int n){
        super(n);
    }

    @Override
    public void insert(Integer x) {
        //数组不够则扩充
        if(currentSize == arrayData.length - 1){
            throw new RuntimeException();
        }
        super.insert(x);
    }


    /**
     * @Description:  下虑操作
     * @param x 新插入的数
     */
    public void filter(Integer x){
        if(currentSize != arrayData.length-1){
            throw new RuntimeException("堆尚未存满");
        }
        if(x.compareTo(arrayData[1]) < 0){
            return;
        }else{
            arrayData[1] = x;
            percolateDown(1);
        }

    }


}

3.      测试代码

/**
 * @Title:       HeapUse1.java
 * @date:        2016-04-06下午3:38:37
 * @version:     V1.0
 */
package Option.heapUse1;

import java.util.Random;

/**
 * @Title:       HeapUse1
 * @Description: 使用小顶堆来求解问题：给定几个数字数组，求这几个数组的最大的k个值
 *               复杂度：Nlogk  (N为总数目，k为所求数目)
 * @author: 	 Lijn
 * @date:        2016-04-06下午3:38:37
 * @version:     V1.0
 */
public class HeapUse1 {
    public static void main(String[] args){
        Integer[] array1 = new Integer[500];
        Integer[] array2 = new Integer[500];
        Random rd = new Random();
        int k = 100;
        MiniTopHeap<Integer> heap = new MiniTopHeap<Integer>(k);
        for(int i =0;i<500;i++){
			array1[i]= rd.nextInt(1000);
			array2[i]= rd.nextInt(1000);
		}

        //平均   k 最坏 klogk
        for(int j=0;j<k;j++){
            heap.insert(array1[j]);
        }

        //平均  （1000-k）logk  最坏（1000-k）logk
        for(int j=k;j<500;j++){
            heap.filter(array1[j]);
        }
        for(int j=0;j<500;j++){
            heap.filter(array2[j]);
        }

        System.out.println(heap.toString());
    }
}

 

这样总的操作时间就是O(nlogk)

在k比n小的较多的情况下是比较合适的。

最后给个使用场景：比如某网站想实时查询当前最热门（搜索次数最多）的几个关键字，就可以用这种办法实现