排序——029最小的K个数

1，问题描述

输入n个整数，找出其中最小的K个数。例如输入4,5,1,6,2,7,3,8这8个数字，则最小的4个数字是1,2,3,4,。

2，解题思路

（1）思路一：直接利用各种排序算法（快排、冒泡排序、选择排序、堆排序）对数组进行从小到大的排序。然后输出前K个。

这种方法容易想到，但不是最优的算法。

（2）思路二：将原数组的前K个元素构建成一个最大堆，然后从第K+1个元素开始，依次和堆顶元素比较，如果小于堆顶元素，则删除堆顶元素，将该元素放入堆中，直到遍历完整个数组，堆中元素就是最小的K个数。

注：思路二有两种实现方式：
（1）利用java的PriorityQueue实现
（2）直接手撕堆排序底层代码

3，源码

（1）利用java的PriorityQueue实现

import java.util.ArrayList;
import java.util.Comparator;
import java.util.PriorityQueue;
public class Solution {
	 public ArrayList<Integer> GetLeastNumbers_Solution(int [] input, int k) {
		 ArrayList<Integer> list = new ArrayList<Integer>();
		 if(k > input.length || k==0) return list;
		 //PriorityQueue默认实现的最小堆，要想实现最大堆，需要通过比较器实现
		 PriorityQueue<Integer> heap = new PriorityQueue<Integer>(new Comparator<Integer>() {

			@Override
			public int compare(Integer arg0, Integer arg1) {
				return arg1-arg0;
			}
			 
		 });
		 
		 for(int i=0;i<input.length;i++) {
			 if(heap.size()<k) {
				 heap.offer(input[i]);
			 }else {
				 if(input[i] < heap.peek()) {
					 heap.poll();
					 heap.offer(input[i]);
				 }
			 }
		 }
		 
		 for(int x : heap) {
			 list.add(x);
		 }
		 
		 return list;
		 
	 }
}

（2）手撕堆排序底层代码

import java.util.ArrayList;
public class Solution {
public ArrayList<Integer> GetLeastNumbers_Solution(int [] input, int k) {
        ArrayList<Integer> heap = new ArrayList<Integer>();
        if(k>input.length||k==0) return heap;
   
        heap.add(null);//堆元素下标从1开始，习惯问题而已，
                       //此时除根节点外的任意节点的索引位置关系为：
                       //父节点位置：i/2; 左孩子：i*2; 右孩子：i*2+1;
                       //最后一个分支节点位置为：n/2;
        for(int i=0;i<k;i++) {
            heap.add(input[i]);
            //初始化方法1：插入法，插入新元素的时候就执行上浮操作。
            heapUp(heap,heap.size()-1);
        }
         
        //初始化方法二：下沉法，只下沉前heap.size()/2个元素（非叶子节点）就行,但是必须最后一个非叶子节点开始
//        for(int i = heap.size()/2; i>0; i--) {
//          heapDown1(heap,i);
//          //heapDown2(heap,i);
//        }
         
        for(int i=k;i<input.length;i++) {
            if(input[i] < heap.get(1)) {
                heap.set(1, input[i]);
                heapDown2(heap,1);
            }
        }
         
        heap.remove(0);//移除头结点，因为头结点设置为null了
        return heap;
    }
     
    //非递归下沉
    public void heapDown2(ArrayList<Integer> heap, int index) {
        int child=-1;
        int n = heap.size()-1;
        while(2*index <= n) {
            //如果只有左孩子节点
            if(2*index==n) {
                child = 2*index;
            }//如果两个孩子都有
            else if(2*index+1 < n) {
                if(heap.get(2*index) < heap.get(2*index+1)) {
                    child = 2*index+1;
                }else {
                    child = 2*index;
                }
            }
             
            if(heap.get(index) < heap.get(child)) {
                swap(heap,index,child);
                index = child;
            }else break;
        }
         
    }
 
    //递归下沉
    public void heapDown1(ArrayList<Integer> heap, int index) {
        int n = heap.size()-1;
        int child = -1;//记录孩子节点
         
        //如果该节点没有左右孩子，就不再下沉
        if(index*2 > n) {
            return;
        }//只有左孩子
        else if(index*2==n){
            child = index*2;
        }//左右孩子都有
        else if(index*2+1 < n) {
            if(heap.get(index*2) < heap.get(index*2+1)) {
                child = index*2+1;
            }else {
                child = index*2;
            }
        }
         
        if(heap.get(index) < heap.get(child)) {
            swap(heap,index,child);
            heapDown1(heap,child);
        }
    }
 
    public void heapUp(ArrayList<Integer> heap, int index) {
        //index=1的时，表示根节点
        if(index>1) {
            int parent = index/2;
            int parentValue = heap.get(parent);
            int indexValue = heap.get(index);
            if(parentValue < indexValue) {
                swap(heap,parent,index);
                heapUp(heap,parent);
            }
        }
    }
 
    private void swap(ArrayList<Integer> heap, int i, int j) {
        int temp = heap.get(i);
        heap.set(i, heap.get(j));
        heap.set(j,temp);
    }
}