微软算法100题05 查找最小的k 个元素

5.查找最小的k 个元素
题目：输入n 个整数，输出其中最小的k 个。
例如输入1，2，3，4，5，6，7 和8 这8 个数字，则最小的4 个数字为1，2，3 和4。

思路: 对于元素集合非常大的情况，比如上亿条数据，可以通过在内存中构造一个有限大小的大堆(heap)来处理

大堆的特性是根节点总是为堆内元素的最大元素

1.对前K个元素构造大堆，里面包含K+1个元素，下标为1的元素为head根节点，该根结点是堆中的最大元素

2.依次读取剩余元素 如果读到的元素比根节点大，则忽略，因为我们的目的是查找最小的K个元素，堆中的元素总是比根节点小，所以如果比根节点还大，那肯定比堆中其他元素还大

如果读到的元素小于根节点，则将根节点替换为该元素，为了保持堆的特性，需要依次将其与其左右节点比较，如果左或右节点大于改节点，则下移该元素与子元素交换(sink)

3. 在堆中，i元素的左节点坐标为2*i， 右节点为2*i+1

package com.rui.microsoft;

import java.util.Arrays;

/**
* 5.查找最小的k 个元素
题目：输入n 个整数，输出其中最小的k 个。
例如输入1，2，3，4，5，6，7 和8 这8 个数字，则最小的4 个数字为1，2，3 和4。
*
*/
public class Test05_FindKMinItems {

public static void main(String[] args) {
//int[] array = {1,2,3,5,5,6,7,8,4};
int[] array = {1,8,9,3,2,7,6,4,5};
int size = 4;
int[] array01 = Arrays.copyOf(array, size);
int[] array02 = Arrays.copyOfRange(array, array01.length, array.length);

MaxHeap heap = new MaxHeap(size);

for(int i = 0; i < array01.length; i++){
heap.insert(array01[i]);
}

for(int i = 0; i < array02.length; i++){
heap.updateHead(array02[i]);
}

for(int i = 0; i < heap.size+1; i++){
System.out.println(heap.get()[i]);
}
}

static class MaxHeap{
private int[] array;
private int size;

//current position in array which is open for insertion
private int pos = 1;

//our MaxHeap has a fixed size
public MaxHeap(int size){
this.size = size;
array = new int[size+1];
}

public void insert(int data){
//insert to the end of the array
if(pos > size){
return;
}
int i = pos;
this.array[pos++] = data;

//start to swim up
while(i>1){
if(array[i] < array[i/2])break;
else{
swap(i, i/2);
i /= 2;
}
}
}

//Update the head node (maximum node) of the heap with a different value
public void updateHead(int data){
//head is always the first node in the array
int head = array[1];
if(data >= head){
//the new data for head node is larger than the old one, just skip it
//because it maintains the max heap definition: the root node is always the largest one
//array[1] = data;
return;
}else{
array[1] = data;
int i = 1;
int j = i;
while(i < (pos-1)/2 && i > 0){
//start to sink the head node
j = i;
if(array[i] > array[2*i] && array[i] > array[2*i + 1]) break;
else{
i *= 2;
if(array[i] < array[i+1])i++;
swap(i,j);
}
}
}
}

private void swap(int i, int j){
int tmp = array[i];
array[i] = array[j];
array[j] = tmp;
}

public int[] get(){
return this.array;
}
}
}