数据结构面试题1.2.9-查找最小的K个元素-使用最大堆

Java最大堆相关知识：http://blog.csdn.net/sayangnala/article/details/48682381

package questions;

import java.util.Arrays;
import java.util.Random;

/**
 * @title 查找最小的K个元素-使用最大堆
 * @question 输入n个整数，输出其中最小的K个元素，例如，输入1,2,3,4,5,6,7,8那么最小的4个元素就是1,2,3,4
 * @analysis 
 *           堆其实是一颗完全二叉树，堆对于两类问题有着很好的解决方案：a.排序问题：由于堆是一颗完全二叉树，所以采用堆，堆n元数组进行排序，时间复杂度不会超过O
 *           (nlgn)，而且只需要几个额外的空间。b.优先级队列。通过插入新元素和调整堆结构来维护堆的性质，每个操作所需要的时间都是O(lgn)<br>
 *           堆常见实现是采用一个大小为n的数组存储元素，并且0号单元舍弃不用。对堆中的元素按照层次从上到下，从左导游的顺序依次编号。
 *           那么对于编号为i的元素：<br>
 *           a：如果左孩子存在，那么左孩子的编号为2i<br>
 *           b：如果右孩子存在，那么右孩子的编号为2*i＋1<br>
 *           c：如果有父结点，那么父结点的编号为i/2<br>
 *           d：结点为叶结点的条件是左孩子且右孩子都为空，为空结点的条件是i<1或者i>n<br>
 *           堆的设计对于处理Top K问题十分方便。首先设置一个大小为K的堆（如果求最大top K，那么用最小堆，如果求最小top
 *           K，那么用最大堆），然后扫描数组。并将数组的每个元素与堆的根比较，符合条件的就插入堆中，同时调整堆使之符合堆的特性，扫描完成后，
 *           堆中保留的元素就是最终的结果
 *           。说到调整堆，不得不提的是调整的算法，分为两类：向下调整（shiftdown）和向上调整（shiftup）。<br>
 *           有了堆的基本操作，top K问题就有了一个基础（当然也完全可以完全不用堆解决top K问题）。以最小top
 *           K问题为例（此时需要建立大小为K的最大堆），top
 *           K的求解过程是：扫描原数组，将数组的前K个元素扔到堆中，调整使之保持堆的特性。对于k之后的元素
 *           ，如果比堆顶的元素小，那么替换堆顶元素并调整堆，扫描数组完成后，堆中保存的元素就是最终的结果。
 * 
 * 
 * 
 * @link 堆的理解http://www.java3z.com/cwbwebhome/article/article1/1362.html?id=4745
 * @author Sam
 *
 */
public class Ex1o2o9 {
	public static void main(String[] args) {
		int[] a = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17,
				18, 19 };
		int k = 7;
		MinKElement mke = new MinKElement();
		mke.disArrange(a);
		System.out.println("after disarranging,the array a[]:");
		System.out.println(Arrays.toString(a));
		mke.findKMin(a, k);
	}

}

/**
 * 最小的K个元素，使用最大堆，当然使用快速排序也是OK的
 */
class MinKElement {
	/**
	 * rearrange the array, just for test.随机调换数组
	 * 
	 * @param a
	 */
	public void disArrange(int[] a) {
		for (int i = 0, len = a.length; i < len; i++) {
			Random random = new Random();
			int j = random.nextInt(len);
			swap(a, i, j);
		}
	}

	/**
	 * 数组a中下标为i，j数据交换
	 * 
	 * @param a
	 * @param i
	 * @param j
	 */
	private static void swap(int[] a, int i, int j) {
		int temp = a[i];
		a[i] = a[j];
		a[j] = temp;
	}

	public void findKMin(int[] a, int k) {
		// you can do this:int[] heap = new int[k].but that may be space-cost
		int[] heap = a;
		// create MaxHeap of K elements form the last RootIndex to 0.
		// 先建立K的最大堆，K个值，那么起始点为K/2-1
		int rootIndex = k / 2 - 1;
		while (rootIndex >= 0) {
			reheap(heap, rootIndex, k - 1);
			rootIndex--;
		}
		// 建立好K的最大堆之后，循环，将length－k之外的值不断的和最大值进行对比，小于最大值，就纳入堆中，调整堆的最大堆
		for (int i = k, len = heap.length; i < len; i++) {
			if (heap[i] < heap[0]) {
				heap[0] = heap[i];
				reheap(heap, 0, k - 1);
			}
		}
		System.out.println(toString(heap, k));
	}

	// reheap:from root to lastIndex.
	public void reheap(int[] heap, int rootIndex, int lastIndex) {
		int orphan = heap[rootIndex];
		boolean done = false;
		int leftIndex = rootIndex * 2 + 1;
		while (!done && leftIndex <= lastIndex) {
			int largerIndex = leftIndex;
			if (leftIndex + 1 <= lastIndex) {
				int rightIndex = leftIndex + 1;
				if (heap[rightIndex] > heap[leftIndex]) {
					largerIndex = rightIndex;
				}
			}
			// Attention! should not use-->heap[root]<heap[largerIndex]<--
			// I spend time to find the problem....
			if (orphan < heap[largerIndex]) {
				heap[rootIndex] = heap[largerIndex];
				rootIndex = largerIndex;
				leftIndex = rootIndex * 2 + 1;
			} else {
				done = true;
			}
		}
		heap[rootIndex] = orphan;
	}

	public static String toString(int[] a, int length) {
		if (a == null)
			return "null";
		int iMax = length - 1;
		if (iMax == -1)
			return "[]";

		StringBuilder b = new StringBuilder();
		b.append('[');
		for (int i = 0;; i++) {
			b.append(a[i]);
			if (i == iMax)
				return b.append(']').toString();
			b.append(", ");
		}
	}

}