找到数组中前k个小的数
第一想法是排序,排序之后返回前k个,这种做法的复杂度为O(nlogn)
1.partition
利用第k个数字来partition,首先将比这个数字小的数字放到左边,把大于它的数字放到右边,则现在看左边有几个数字,如果大于k,则再次partition,如果小于k,则也partition,循环直到i为k-1.
此时的前k个数就是最小的k个数。
借用的思想就是快排的思想,只不过这个要partition的结束条件不是lo<hi,而是返回的mid等于k。时间复杂度为O(n)
import java.util.Arrays;
class Solution {
public int[] getLeastNumbers(int[] nums, int k) {
if(nums==null || nums.length==0 || k==0){
return new int[0];
}
return quickSerch(nums,0,nums.length-1,k-1);
}
public int[] quickSerch(int[] nums,int lo,int hi,int k){
int s=partition(nums,lo,hi);
if(s==k){
return Arrays.copyOf(nums,k+1);
}else if(s>k){//说明左边的值大于k
return quickSerch(nums,lo,s-1,k);
}else{
return quickSerch(nums,s+1,hi,k);
}
}
public int partition(int[] nums,int lo,int hi){
int mid=hi;
int cur=lo;
while(cur<mid){
if(nums[cur]<nums[hi]){
cur++;
}else{
swap(nums,cur,--mid);
}
}
swap(nums,hi,mid);
return mid;
}
public void swap(int[] nums,int i,int j){
int temp=nums[i];
nums[i]=nums[j];
nums[j]=temp;
}
}
2.创造大小为k的堆,堆排序
创建堆的时间复杂度为O(nlogk)。可以自己实现一个堆,也可以利用已有的api。
需要实现的是一个大小为k的大根堆,将前k个数放入堆中,然后遍历下一个数,如果这个数比堆顶元素大,说明它肯定不是前k个数(注意这里实现的是大根堆,如果是小根堆,则这个元素没法和堆顶元素比较)
如果要自己实现,就是利用一个大小为k的数组,将前k个数放入其中,然后利用sink从倒数第二层开始到头结点下沉所有节点,构造这k个数的大根堆。遍历后面的如果有更小的数,则取出最大值,放回那个值,将它下沉。直到遍历完所有节点。
import java.util.ArrayList;
public class Solution {
public ArrayList<Integer> GetLeastNumbers_Solution(int [] input, int k) {
ArrayList<Integer> list=new ArrayList<Integer>();
if(k<=0 || input==null || k>input.length || input.length==0){
return list;
}
int[] res=new int[k];
for(int i=0;i<k;i++){
res[i]=input[i];
}
for(int i=k/2-1;i>=0;i--){
sink(res,i);
}
for(int i=k;i<input.length;i++){
if(res[0]>input[i]){
res[0]=input[i];
sink(res,0);
}
}
for(int i=0;i<k;i++){
list.add(res[i]);
}
return list;
}
public void sink(int[] arr,int i){//这个完全没必要放最大长度,因为这里最大值又不会变,不是堆排序需要改变最大值
int temp=arr[i];
for(int j=2*i+1;j<arr.length;j++){
if(j+1<arr.length && arr[j]<arr[j+1]){
j++;
}
if(arr[j]>temp){
arr[i]=arr[j];
i=j;
}else{
break;
}
}
arr[i]=temp;
}
}
import java.util.PriorityQueue;
class Solution {
public int[] getLeastNumbers(int[] arr, int k) {
if(arr.length==0 || k==0){
return new int[0];
}
PriorityQueue<Integer> pq=new PriorityQueue<Integer>((Integer o1,Integer o2)->{return o2-o1;});
for(int i=0;i<arr.length;i++){
if(i<k){
pq.offer(arr[i]);
}else{
if(arr[i]<pq.peek()){
pq.poll();
pq.offer(arr[i]);
}
}
}
int[] res=new int[k];
for(int i=0;i<k;i++){
res[i]=pq.poll();
}
return res;
}
}
3.二叉搜索树
利用treemap(因为有重复的树),类似于大根堆的思想来做,同样也是O(nlogk),且可以保证前k个数都是有序的,而大根堆是无序的。
也是前k个数加入map中,加入键的是此时的数字,值是数字的频数。
当遍历到k+1个数字的时候就看它和map中最大数字的大小(treemap中最大的值就是遍历的第一个键)