牛客网编程高频题6——NC119最小的K个数

目录

最小的K个数

题目描述

示例1

输入

返回值

方法一：快排

方法二：堆排序

方法三：归并排序

---

 

 

最小的K个数

题目描述

给定一个数组，找出其中最小的K个数。

例如数组元素是4,5,1,6,2,7,3,8这8个数字，则最小的4个数字是1,2,3,4。

如果K>数组的长度，那么返回一个空的数组

示例1

输入

[4,5,1,6,2,7,3,8],4 

返回值

[1,2,3,4]

 

方法一：快排

import java.util.ArrayList;

public class Solution {
    public static ArrayList<Integer> GetLeastNumbers_Solution(int [] input, int k) {
        ArrayList<Integer> list=new ArrayList<>();
        if (k>input.length||k==0){
            return list;
        }
        int []res=new int[input.length];
        res=QuickSort(input,0,input.length-1);
        for (int i = 0; i < k; i++) {
            list.add(res[i]);
        }
        return  list;
    }

    public static int[] QuickSort(int []arr,int low,int high){
        if(low<high){
            int partition=Partition(arr,low,high);
            QuickSort(arr,low,partition-1);
            QuickSort(arr,partition+1,high);
        }
        return arr;
    }

    public static int Partition(int []arr,int low,int high){
        int curPos=low;
        int curVal=arr[low];
        for (int i = low+1; i <= high; i++) {
            if(arr[i]<curVal){
                curPos++;
                if(curPos!=i){
                    swap(arr,curPos,i);
                }
            }
        }
        arr[low]=arr[curPos];
        arr[curPos]=curVal;
        return curPos;
    }

    public static void swap(int[] arr, int a, int b) {
        int temp = arr[a];
        arr[a] = arr[b];
        arr[b] = temp;
    }
    
}

快速排序的速度还是不错的

 

方法二：堆排序

import java.util.ArrayList;

public class Solution {
    public static ArrayList<Integer> GetLeastNumbers_Solution(int [] input, int k) {
        ArrayList<Integer> list=new ArrayList<>();
        if (k>input.length){
            return list;
        }
        heapSort(input,k,list);
        return  list;
    }

    public static void heapSort(int []arr,int k,ArrayList<Integer> list){
        for (int i = arr.length/2-1; i >=0; i--) {//从第一个非叶子节点处理
            adjustHeap(arr,i,arr.length);//调整树的结构
        }

        for (int j = arr.length-1; j>arr.length-1-k; j--) {
            list.add(arr[0]);
            swap(arr,0,j);
            adjustHeap(arr,0,j);
        }
    }

    public static void adjustHeap(int []arr,int i,int length){
        int temp=arr[i];//记录开始节点的信息
        for (int k = 2*i+1; k < length; k=2*k+1) {
            if(k+1<length&&arr[k]>arr[k+1]){//找出较大的节点
                k++;
            }
            if(arr[k]<temp){//如果有节点比该节点大，则交换位置
                swap(arr,i,k);
                i=k;//处理交换位置后的节点树
            }else{
                break;
            }
        }
    }

    public static void swap(int[] arr, int a, int b) {
        int temp = arr[a];
        arr[a] = arr[b];
        arr[b] = temp;
    }
    
}

结果来看堆排序要好一些（感觉牛客网运行代码不太稳定，有时快有时慢）

 

方法三：归并排序

import java.util.ArrayList;

public class Solution {
    public static ArrayList<Integer> GetLeastNumbers_Solution(int [] input, int k) {
        ArrayList<Integer> list=new ArrayList<>();
        if (k>input.length){
            return list;
        }
        mergeSort(input,0,input.length-1);
        for (int i = 0; i < k; i++) {
            list.add(input[i]);
        }
        return  list;
    }

    public static void mergeSort(int[] arr,int low,int high){
        if(low >=high){
            return;
        } else{
            int mid=(low+high)/2;
            mergeSort(arr,low,mid);
            mergeSort(arr,mid+1,high);
            merge(arr,low,mid,high);
        }
    }

    public static void merge(int[] arr,int low,int mid,int high){
        int []temp=new int[arr.length];
        for (int i = 0; i < arr.length; i++) {
            temp[i]=arr[i];
        }
        int i=low;
        int j=mid+1;
        int k=low;
        while(i<=mid&&j<=high){
            if(temp[i]<temp[j]){
                arr[k++]=temp[i++];
            }else{
                arr[k++]=temp[j++];
            }
        }
        while(i<=mid){
            arr[k++]=temp[i++];
        }
        while(j<=high){
            arr[k++]=temp[j++];
        }
    }

    public static void swap(int[] arr, int a, int b) {
        int temp = arr[a];
        arr[a] = arr[b];
        arr[b] = temp;
    }
    
}

归并排序的时间复杂度也还不错