剑指offer之求数组中最小的n个数

牛客网上剑指offer原题：输入n个整数，找出其中最小的K个数。例如输入4,5,1,6,2,7,3,8这8个数字，则最小的4个数字是1,2,3,4。

解法很多个人想到的四种下面一一记录下来：

1、直接暴力解决使用数组自带的排序完后，取其前k个，这种时间复杂度很高为：O（k*nlog2n）解法很简单不想解释。

2、冒泡排序外层循环的终止条件为i<k，时间复杂度为O(n*k)也很简单自己写

3、堆排序先循环建个大顶堆别问我为什么不用小顶堆，因为大顶堆在调整的时候会找到最小的数字然后将其放在数组的最后 时间复杂度O（klog2n），代码如下：

import java.util.ArrayList;
public class Solution {
    public ArrayList<Integer> GetLeastNumbers_Solution(int [] input, int k) {
        int length = input.length;
        ArrayList<Integer> list = new ArrayList<Integer>();
        if(length==0||k<=0||k>length)		return list;
        for(int i=0;i<k;i++){//循环建堆
            BuildMaxHeap(input,length-1-i);
            swap(input,0,length-1-i);//每次将找到的最小值放在数组的最后
            list.add(input[length-1-i]);//将找到的最小值放入容器准备返回
        }
        return list;
    }
    public void swap(int[] a,int i,int j){
        int temp = a[i];
        a[i]=a[j];
        a[j]=temp;
    }
    
    public void BuildMaxHeap(int[] a,int lastindex){
        int k ;
        for(int i=(lastindex-1)/2;i>=0;i--){
            k = i;						//k表示待插入的索引
            while((k*2+1)<=lastindex){			
                int index = k*2+1; 				//index表示k节点的左子节点
                if(index<lastindex&&a[index]>a[index+1])	index++;	//若右子节点更小则索引指向右子节点，索引一定指向更小的子节点
                if(a[k]>a[index]){
                    swap(a,k,index);
                    k = index;
                }
                else{
                    break;
                }
            }
        }
    }
}

4、使用快速排序找到n的位置，使得比n小的数字个数为K个，时间复杂度平均为：O(n) ，需要修改原数组：

import java.util.ArrayList;
public class Solution {
       public ArrayList<Integer> GetLeastNumbers_Solution(int [] input, int k) {
		ArrayList<Integer> list = new ArrayList<Integer>();
		if(input.length==0||k>input.length||k<=0)	return list;
		int low=0;
		int high = input.length-1;
		int index = partition(input,low,high,k);
		while(index!=k-1){
		if(index>(k-1)){//若index不为所求的K，则向前后调整
			high = index-1;
			index = partition(input,low,high,k);
		}
		if(index<(k-1)){
			low = index+1;
			index = partition(input,low,high,k);
		}
		}
		for(int i=0;i<k;i++){
			list.add(input[i]);
		}
		return list;
	}

	private int partition(int[] a, int low, int high, int k) //一次快排
		int pivot = a[k-1];
		a[k-1] = a[low];
		while(low<high){
		while(low<high&&a[high]>=pivot)		high--;
		a[low] = a[high];
		while(low<high&&a[low]<=pivot)		low++;
		a[high] = a[low];
		}
		a[low] = pivot;
		return low;
	}
}