剑29-最小的K个数

题目描述

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

方法一：投机取巧(自己想到的low)

import java.util.*;
public class Solution {
    public ArrayList<Integer> GetLeastNumbers_Solution(int [] input, int k) 
   {
        ArrayList<Integer>al=new ArrayList<>();
        if(k>input.length)
            return al;
        Arrays.sort(input);//调用java自带排序函数，时间复杂度是O(nlogn)
        for (int i = 0; i <k ; i++) {
            al.add(input[i]);
        }
        return al;
    }
}

方法二：外层循环 k趟 的冒泡排序（易理解）

//递减排序的冒泡，外层循环k趟，则找出k个最小的，输出即可，时间复杂度O(nlogk)
import java.util.*;

public class Solution {
    public ArrayList<Integer> GetLeastNumbers_Solution(int [] input, int k) {
        //冒泡思想：
        ArrayList<Integer>al=new ArrayList<>();
        if(k>input.length)
            return al;
        for (int i = 0; i <k ; i++) //外层循环k趟
        {
            for (int j = 0; j <input.length-1-i; j++)
            {
                if(input[j]<input[j+1])//按照从大到小排序的，
                {
                    int temp = input[j];
                    input[j] = input[j + 1];
                    input[j + 1] = temp;
                }
            }
            al.add(input[input.length-1-i]);//取后面最小的k个数
        }
        return al;
    }
 }

方法三：开辟k大小数组，排序，比较，交换

import java.util.*;
public class Solution {
    public ArrayList<Integer> GetLeastNumbers_Solution(int [] input, int k)
    {
        ArrayList<Integer>al=new ArrayList<>();
        //判断特例
        if(k>input.length||k<=0)
            return al;
        //开辟新数组存放input前k个值
        int[]newArr=new int[k];
        for(int i=0;i<k;i++)
        {
            newArr[i]=input[i];
        }
        //对有k个值的新数组进行排序，则最大值是newArr[k-1]
        Arrays.sort(newArr);

        //比较最大值newArr[k-1]和input数组中剩下的值大小，比最大值小就插入，
        for(int i=k;i<input.length;i++)
        {
            if(input[i]<newArr[k-1])
                insertNewArr(newArr,input[i]);
        }
        //将newArr数组添加到新的ArrayList集合中并返回
        for(int i=0;i<k;i++)
        {
            al.add(newArr[i]);
        }
        return al;
    }
    //插入函数，从最后面进行比较，比较的同时移位，将值插进去，当找到第一个比他小的就查到后面，
    //实现重排序，保证将m插入到合适位置，
    public void insertNewArr(int[]newArr, int m)
    {
        int i=newArr.length-1;
        for(;i>=0;i--)
        {
            if(newArr[i]<m)
                break;

            if(i==0)//比arr[0]还小，则插到其前面
            {
                i=-1;
                break;
            }

            newArr[i]=newArr[i-1];//移位操作
        }
        //直到找到第一个比m小的,break跳出循环，就插到后面
        newArr[i+1]=m;
    }
}

方法四：堆排序 思想

思路：利用堆排序，O(N logK)，适合处理海量数据
(1) 遍历输入数组，将前k个数插入到堆中；（利用multiset来做为堆的实现）
(2) 继续从输入数组中读入元素做为待插入整数，并将它与堆中最大值比较：
如果待插入的值比当前已有的最大值小，则用这个数替换当前已有的最大值；
如果待插入的值比当前已有的最大值还大，则抛弃这个数，继续读下一个数。

这样动态维护堆中这k个数，以保证它只储存输入数组中的前k个最小的数，最后输出堆即可。

import java.util.*;
public class Solution {
    //用最大堆保存这k个数，每次只和堆顶比，如果比堆顶小，删除堆顶，新数入堆。
    public ArrayList<Integer> GetLeastNumbers_Solution(int[] input, int k)
    {
        ArrayList<Integer>res=new ArrayList<>();


        if(k>input.length||k==0)
            return res;

        PriorityQueue<Integer>maxHeap=new PriorityQueue<Integer>(k, new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return o2.compareTo(o1);//
            }
        });

        for (int i = 0; i <input.length ; i++)
        {
            if(maxHeap.size()!=k)        //将k个元素插入到堆
                maxHeap.offer(input[i]);

            else if (maxHeap.peek()>input[i])//堆顶元素大于剩下的数组中元素，删除堆顶，插入
            {
                Integer temp=maxHeap.poll();
                temp=null;
                maxHeap.offer(input[i]);
            }
        }

        for(Integer integer:maxHeap)
            res.add(integer);

        return res;

    }
}