Java实现寻找最小的k个数

最新推荐文章于 2022-07-12 19:26:10 发布
最新推荐文章于 2022-07-12 19:26:10 发布
阅读量3.6k 收藏 1
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45176257/article/details/106488610
版权

1 问题描述
有n个整数，请找出其中最小的k个数，要求时间复杂度尽可能低。

2 解决方案
2.1 全部排序法
先对这n个整数进行快速排序，在依次输出前k个数。

package com.liuzhen.array_2;

public class SearchMinK {
    //方法1：全部排序
    public void quickSort(int[] A,int start,int end){
        if(end > start){
            int k = LomutoPartition(A,start,end);
            quickSort(A,start,k-1);
            quickSort(A,k+1,end);
        }
    }
    //返回数值result，满足：     左边部分< A[result] <=右边部分
    public int LomutoPartition(int[] A,int start,int end){
        if(start >= end)
            return start;
        int begin = A[start];
        int result = start;
        for(int i = start + 1;i <= end;i++){
            if(A[i] < begin){
                result++;
                swap(A,i,result);
            }
        }
        swap(A,start,result);
        return result;
    }
    //交换数组m位置和n位置上的值
    public void swap(int[] arrayA,int m,int n){
        int temp = arrayA[m];
        arrayA[m] = arrayA[n];
        arrayA[n] = temp;
    }
    //输出数组前k个元素
    public void printArrayK(int[] array,int k){
        for(int i = 0;i < k;i++){
            System.out.print(array[i]+" ");
        }
    }
public static void main(String[] args){
        SearchMinK test = new SearchMinK();
        int[] A = {9,8,7,5,4,3,2,1,6,3,4,5,12,32,3,2,1,4,6,34};
        test.quickSort(A, 0, A.length-1);
        System.out.println("对数组进行排序后结果：");
        for(int i = 0;i < A.length;i++)
            System.out.print(A[i]+" ");
        System.out.println("\n"+"输出数组最小的5个数：");
        test.printArrayK(A, 5);

    }
}

运行结果：

对数组进行排序后结果：
1 1 2 2 3 3 3 4 4 4 5 5 6 6 7 8 9 12 32 34 
输出数组最小的5个数：
1 1 2 2 3

2.2 部分排序法
具体操作步骤如下：

（1）遍历n个数，把最先遍历到的k个数存入到大小为k的数组中，假设他们就是最小的k个数；

（2）利用选择排序或交换排序找到这k个元素中的最大值kmax；

（3）继续遍历剩余的n-k个数。假设每次遍历到的新元素的值为x,把x与kmax进行比较：如果x<kmax，则用x替换kmax，并回到第2步重新找出k个元素的数组中新的最大元素kmax;如果x>=kmax，则继续遍历，不更新数组。

具体代码如下：

package com.liuzhen.array_2;

public class SearchMinK {
//方法2：部分排序
    public void getArrayMinK(int[] A,int k){
        if(k > A.length)
            return;
        while(true){
            int max = getMaxArrayK(A,k);  //当前数组前k个元素中的最大值
            int count = 0;
            for(int i = k;i < A.length;i++){
                if(A[max] > A[i])
                    swap(A,max,i);
                else
                    count++;
            }
            if(count == A.length-k)
                break;
        }
        System.out.println("\n"+"使用方法2进行部分排序后的结果：");
        for(int i = 0;i < A.length;i++)
            System.out.print(A[i]+" ");
        System.out.println("\n部分排序选出数组中最小的"+k+"个数：");
        for(int i = 0;i < k;i++)
            System.out.print(A[i]+" ");
    }
    
    //获取数组前k个元素的最大值的数组下标
    public int getMaxArrayK(int[] A,int k){
        int result = 0;
        if(k > A.length)
            return 0;
        for(int i = 0;i < k;i++){
            if(A[i] > A[result])
                result = i;
        }
        return result;
    }
//交换数组m位置和n位置上的值
    public void swap(int[] arrayA,int m,int n){
        int temp = arrayA[m];
        arrayA[m] = arrayA[n];
        arrayA[n] = temp;
    }
public static void main(String[] args){
        SearchMinK test = new SearchMinK();

        int[] B = {9,8,7,5,4,3,2,1,6,3,4,5,12,32,3,2,1,4,6,34};
        test.getArrayMinK(B, 5);

    }

运行结果：

使用方法2进行部分排序后的结果：
1 1 2 2 3 9 8 7 6 5 4 5 12 32 4 3 3 4 6 34 
部分排序选出数组中最小的5个数：
1 1 2 2 3

2.3 用堆代替数组法
此处思想和2.2中一致，唯一区别就是在寻找kmax时，是使用堆排序的思想。

具体代码如下：

package com.liuzhen.array_2;

public class SearchMinK {
//方法3：用堆来代替数组
    /*
     * 函数功能：对数组A前k个元素进行堆排序
     */
    public void heapBottomUp(int[] A,int k){
        for(int i = (k-1)/2;i >= 0;i--){
            int temp = i;
            int tempV = A[temp];
            boolean heap = false;
            while(!heap && 2*temp < k-1){
                int j = 2*temp + 1;
                if(j < k-1){
                    if(A[j] < A[j+1])
                        j = j + 1;
                }
                if(tempV >= A[j])
                    heap = true;
                else{
                    A[temp] = A[j];
                    temp = j;
                }
            }
            A[temp] = tempV;
        }
    }
    
    public void getArrayMinK2(int[] A,int k){
        heapBottomUp(A,k);
        while(true){
            int count = 0;
            for(int i = k;i < A.length;i++){
               if(A[i] < A[0]){
                   swap(A,i,0);
                  heapBottomUp(A,k);
               }
               else
                   count++;
            }
            if(count == A.length-k)
                break;
        }
        System.out.println("\n"+"使用方法3进行部分堆排序后的结果：");
        for(int i = 0;i < A.length;i++)
            System.out.print(A[i]+" ");
        System.out.println("\n部分排序选出数组中最小的"+k+"个数：");
        for(int i = 0;i < k;i++)
            System.out.print(A[i]+" ");
    }
//交换数组m位置和n位置上的值
    public void swap(int[] arrayA,int m,int n){
        int temp = arrayA[m];
        arrayA[m] = arrayA[n];
        arrayA[n] = temp;
    }
public static void main(String[] args){
        SearchMinK test = new SearchMinK();

        int[] D = {9,8,7,5,4,3,2,1,6,3,4,5,12,32,3,2,1,4,6,34};
        test.getArrayMinK2(D, 5);

    }
}

运行结果：

使用方法3进行部分堆排序后的结果：
3 2 2 1 1 9 8 7 6 5 4 5 12 32 4 3 3 4 6 34 
部分排序选出数组中最小的5个数：
3 2 2 1 1

2.4线性选择算法
看具体代码即可理解其中蕴含的思想。

package com.liuzhen.array_2;

public class SearchMinK {
//返回数值result，满足：     左边部分< A[result] <=右边部分
    public int LomutoPartition(int[] A,int start,int end){
        if(start >= end)
            return start;
        int begin = A[start];
        int result = start;
        for(int i = start + 1;i <= end;i++){
            if(A[i] < begin){
                result++;
                swap(A,i,result);
            }
        }
        swap(A,start,result);
        return result;
    }

    //方法4：线性选择法
    public void getArrayMinK3(int[] A,int k){
        int start = 0;
        int end = A.length - 1;
        int tempK = LomutoPartition(A,start,end);
        while(tempK != k){
            if(tempK > k){
                end = tempK - 1;
                tempK = LomutoPartition(A,start,end);
            }
            if(tempK < k){
                start = tempK + 1;
                tempK = LomutoPartition(A,start,end);
            }
        }
        System.out.println("\n"+"使用方法4进行快速选择排序后的结果：");
        for(int i = 0;i < A.length;i++)
            System.out.print(A[i]+" ");
        System.out.println("\n部分排序选出数组中最小的"+k+"个数：");
        for(int i = 0;i < k;i++)
            System.out.print(A[i]+" ");
    }
public static void main(String[] args){
        SearchMinK test = new SearchMinK();

        int[] E = {9,8,7,5,4,3,2,1,6,3,4,5,12,32,3,2,1,4,6,34};
        test.getArrayMinK3(E, 5);
    }
}

运行结果：

使用方法4进行快速选择排序后的结果：
1 2 2 1 3 3 3 4 5 5 4 4 6 8 6 7 9 32 12 34 
部分排序选出数组中最小的5个数：
1 2 2 1 3

此处附上四种方法的完整代码

package com.liuzhen.array_2;

public class SearchMinK {
    //方法1：全部排序
    public void quickSort(int[] A,int start,int end){
        if(end > start){
            int k = LomutoPartition(A,start,end);
            quickSort(A,start,k-1);
            quickSort(A,k+1,end);
        }
    }
    //返回数值result，满足：     左边部分< A[result] <=右边部分
    public int LomutoPartition(int[] A,int start,int end){
        if(start >= end)
            return start;
        int begin = A[start];
        int result = start;
        for(int i = start + 1;i <= end;i++){
            if(A[i] < begin){
                result++;
                swap(A,i,result);
            }
        }
        swap(A,start,result);
        return result;
    }
    //交换数组m位置和n位置上的值
    public void swap(int[] arrayA,int m,int n){
        int temp = arrayA[m];
        arrayA[m] = arrayA[n];
        arrayA[n] = temp;
    }
    //输出数组前k个元素
    public void printArrayK(int[] array,int k){
        for(int i = 0;i < k;i++){
            System.out.print(array[i]+" ");
        }
    }
    
    //方法2：部分排序
    public void getArrayMinK(int[] A,int k){
        if(k > A.length)
            return;
        while(true){
            int max = getMaxArrayK(A,k);  //当前数组前k个元素中的最大值
            int count = 0;
            for(int i = k;i < A.length;i++){
                if(A[max] > A[i])
                    swap(A,max,i);
                else
                    count++;
            }
            if(count == A.length-k)
                break;
        }
        System.out.println("\n"+"使用方法2进行部分排序后的结果：");
        for(int i = 0;i < A.length;i++)
            System.out.print(A[i]+" ");
        System.out.println("\n部分排序选出数组中最小的"+k+"个数：");
        for(int i = 0;i < k;i++)
            System.out.print(A[i]+" ");
    }
    
    //获取数组前k个元素的最大值的数组下标
    public int getMaxArrayK(int[] A,int k){
        int result = 0;
        if(k > A.length)
            return 0;
        for(int i = 0;i < k;i++){
            if(A[i] > A[result])
                result = i;
        }
        return result;
    }
    
    //方法3：用堆来代替数组
    /*
     * 函数功能：对数组A前k个元素进行堆排序
     */
    public void heapBottomUp(int[] A,int k){
        for(int i = (k-1)/2;i >= 0;i--){
            int temp = i;
            int tempV = A[temp];
            boolean heap = false;
            while(!heap && 2*temp < k-1){
                int j = 2*temp + 1;
                if(j < k-1){
                    if(A[j] < A[j+1])
                        j = j + 1;
                }
                if(tempV >= A[j])
                    heap = true;
                else{
                    A[temp] = A[j];
                    temp = j;
                }
            }
            A[temp] = tempV;
        }
    }
    
    public void getArrayMinK2(int[] A,int k){
        heapBottomUp(A,k);
        while(true){
            int count = 0;
            for(int i = k;i < A.length;i++){
               if(A[i] < A[0]){
                   swap(A,i,0);
                  heapBottomUp(A,k);
               }
               else
                   count++;
            }
            if(count == A.length-k)
                break;
        }
        System.out.println("\n"+"使用方法3进行部分堆排序后的结果：");
        for(int i = 0;i < A.length;i++)
            System.out.print(A[i]+" ");
        System.out.println("\n部分排序选出数组中最小的"+k+"个数：");
        for(int i = 0;i < k;i++)
            System.out.print(A[i]+" ");
    }
    
    //方法4：线性选择法
    public void getArrayMinK3(int[] A,int k){
        int start = 0;
        int end = A.length - 1;
        int tempK = LomutoPartition(A,start,end);
        while(tempK != k){
            if(tempK > k){
                end = tempK - 1;
                tempK = LomutoPartition(A,start,end);
            }
            if(tempK < k){
                start = tempK + 1;
                tempK = LomutoPartition(A,start,end);
            }
        }
        System.out.println("\n"+"使用方法4进行快速选择排序后的结果：");
        for(int i = 0;i < A.length;i++)
            System.out.print(A[i]+" ");
        System.out.println("\n部分排序选出数组中最小的"+k+"个数：");
        for(int i = 0;i < k;i++)
            System.out.print(A[i]+" ");
    }
    public static void main(String[] args){
        SearchMinK test = new SearchMinK();
        int[] A = {9,8,7,5,4,3,2,1,6,3,4,5,12,32,3,2,1,4,6,34};
        test.quickSort(A, 0, A.length-1);
        System.out.println("对数组进行排序后结果：");
        for(int i = 0;i < A.length;i++)
            System.out.print(A[i]+" ");
        System.out.println("\n"+"输出数组最小的5个数：");
        test.printArrayK(A, 5);
        int[] B = {9,8,7,5,4,3,2,1,6,3,4,5,12,32,3,2,1,4,6,34};
        test.getArrayMinK(B, 5);
        int[] C = {2,9,7,6,5,8};
        test.heapBottomUp(C, 6);
        System.out.println("\nC数组：");
        for(int i = 0;i < C.length;i++)
            System.out.print(C[i]+" ");
        int[] D = {9,8,7,5,4,3,2,1,6,3,4,5,12,32,3,2,1,4,6,34};
        test.getArrayMinK2(D, 5);
        int[] E = {9,8,7,5,4,3,2,1,6,3,4,5,12,32,3,2,1,4,6,34};
        test.getArrayMinK3(E, 5);
    }
}

完整代码
weixin_45176257
关注
最小的k个数（Java）
Sweet Baby，甜宝
06-14 4176
题目：输入n个整数，找出其中最小的k个数。例如输入4、 5、 1、 6、 2、 7、 3、 8这8个数字，则最小的4个数字是1、 2、 3、 4。思路：O（n）的算法，只有当我们可以修改输入的数组是可用经典常用的算法，快速排序的精髓利用快速排序划分的思想，每一次划分就会有一个数字位于以数组从小到达排列的的最终位置index；位于index左边的数字都小于index对应的值，右边都大于index指向...
最小的k个数 -- java
hello world
11-21 1871
题目描述 输入n个整数，找出其中最小的K个数。例如输入4,5,1,6,2,7,3,8这8个数字，则最小的4个数字是1,2,3,4。 解题思路 StreamAPI方式 直接使用sortAPI，有点慢。 时间复杂度O(nlogn) 利用Partition函数解题 不断partition，直到找到下标k-1，然后输出前k个数字。 时间复杂度为O(n)；不好的地方在于会改变原数组。 利用堆解题 构建一个k大小的大顶堆，当之后的元素大于堆顶元素，则抛弃堆顶，让该元素入堆 时间复杂度为O(nlogk)，空间复杂度O(k
最小的K个数(JAVA)
weixin_43238110的博客
07-05 226
package com.wsy.sword; import java.util.ArrayList; public class GetLeastNumbers { public static void main(String[] args) { GetLeastNumbers getLeastNumbers = new GetLeastNumbers(); ...
最小的k个数 （java）
zz0129的博客
07-30 585
题目描述： 输入n个整数，找出其中最小的K个数。例如输入4,5,1,6,2,7,3,8这8个数字，则最小的4个数字是1,2,3,4,。 解题思路： 使用优先队列保证队列里存放的是最小的K位数 第一次在解题过程中使用到优先队列，做一下记录 import java.util.ArrayList; import java.util.Comparator; import java.util.P...
Java-最小的K个数
Rainbow
04-20 515
Java-最小的K个数 题目描述: 输入n个整数，找出其中最小的K个数。例如输入4,5,1,6,2,7,3,8这8个数字，则最小的4个数字是1,2,3,4。 Link : 最小的K个数 Code: import java.util.ArrayList; public class Solution { public ArrayList<Integer> GetLeastNum...
JAVA练习55-最小的k个数
qq_48772498的博客
01-27 780
输入整数数组 arr ，找出其中最小的 k 个数。例如，输入4、5、1、6、2、7、3、8这8个数字，则最小的4个数字是1、2、3、4。 示例 1： 输入：arr = [3,2,1], k = 2 输出：[1,2] 或者 [2,1] 示例 2： 输入：arr = [0,1,2,1], k = 1 输出：[0] 限制： 0 <= k <= arr.length <= 10000 0 <= arr[i]<= 10000 分析： 方法：快速排序优化 这道题寻找最小的.
1_example.zip 第k个最小整数
最新发布
01-02
为了分析和验证这些算法，你可以参考"排序查找最小的第k个数.docx"文档，它可能包含了具体的代码示例和进一步的解释。同时，"example"可能是实现这些算法的一个测试用例或者数据集，用于检查算法的正确性。 总之，...
c语言从4个整数中找最小的数,编程之法：面试和算法心得（寻找最小的k个数）...
weixin_27758233的博客
05-24 2850
内容全部来自编程之法：面试和算法心得一书，实现是自己写的使用的是java题目描述输入n个整数，输出其中最小的k个。分析与解法解法一要求一个序列中最小的k个数，按照惯有的思维方式，则是先对这个序列从小到大排序，然后输出前面的最小的k个数。至于选取什么的排序方法，我想你可能会第一时间想到快速排序(我们知道，快速排序平均所费时间为n*logn)，然后再遍历序列中前k个元素输出即可。因此，总的时间复杂度：...
【算法】数组中最小的K个值java
破旧牛仔裤的基地
04-24 343
寻找数组中最小的K个值的三种解法
Java最小的k个数
qq_42900213的博客
07-12 293
输入整数数组 ，找出其中最小的 个数。例如，输入4、5、1、6、2、7、3、8这8个数字，则最小的4个数字是1、2、3、4。 执行用时：2 ms, 在所有 Java 提交中击败了92.14%的用户内存消耗：41.9 MB, 在所有 Java 提交中击败了78.37%的用户通过测试用例：39 / 39...
java_最小的k个数
09-07 1357
package com.zhiru; /* * 求一个序列中最小的k个数 */ public class TopK { private int[] heap; private int currentSize; TopK(int[] a) { if (a != null) { heap = new int[a.length]; currentSize = 0; f
剑指Offer——最小的K个数（Java）
qq_45754055的博客
03-07 543
题目描述 输入整数数组arr，找出其中最小的k个数。例如，输入4、5、1、6、2、7、3、8这8个数字，则最小的4个数字是1、2、3、4。 示例 示例1： 输入：arr = [3,2,1], k = 2 输出：[1,2] 或者 [2,1] 示例2： 输入：arr = [0,1,2,1], k = 1 输出：[0] 解题思路 方法1： 对于该题最简单的思路就是把输入的n个整数进行排序，排序之后位于最前面的K个数就是最小的K个数。 这种思路的时间复杂度为O(n*log(n))...
最小的k个数（Java实现）
csdn_zjp的博客
10-04 196
import java.util.PriorityQueue; public class E40LeastKNumbers { //最小的K个数,利用大小为k的优先队列 public static void findLeastNumbers(int[] numbers, int length, int k){ if (numbers == null || le...
（Java 剑指 offer）最小的K个数
南淮北安的博客
05-12 329
文章目录一、题目二、题解 一、题目 输入n个整数，找出其中最小的K个数。例如输入4,5,1,6,2,7,3,8这8个数字，则最小的4个数字是1,2,3,4,。 二、题解 该题比较简单，主要可以利用数组的排序和复制内置函数即可。 public class Test { public static void main(String[] args) { int[] array = {4,5,1,6,2,7,3,8}; ArrayList<Integer> lis
JAVA: 最小的K个数
HxxxxxxU的博客
03-10 968
题目：输入n个整数，找出其中最小的K个数。例如输入4,5,1,6,2,7,3,8这8个数字，则最小的4个数字是1,2,3,4,。 解法一：基于快排。如果基于数组的第K个数字来调整，使得比第K个数字小的都为于左边，比它大的都位于右边，这样调整之后，位于数组中左边的K个数字就是最小的K个数字。该方法优点时间复杂度O(n)，但缺点是需要修改输入数组，而且不适用于海量数据。 public class...
剑指offer java版 test29—找出数组中最小的k个数
weixin_42146993的博客
05-19 196
题目： 输入n个整数，找出其中最小的K个数。例如输入4,5,1,6,2,7,3,8这8个数字，则最小的4个数字是1,2,3,4,。 思路：就排序吧 也不难 条条大路通罗马 代码： class Solution { public ArrayList<Integer> GetLeastNumbers_Solution(int [] input, int k) { ArrayList<Integer> arrayList=new ArrayList&lt.
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值