java 查找最小的k个元素_java算法之寻找最小的k个数

题目描述

334bfacf7ff04016385687cf6448099e.png

输入n个整数,输出其中最小的k个。

分析与解法

解法一

要求一个序列中最小的k个数,按照惯有的思维方式,则是先对这个序列从小到大排序,然后输出前面的最小的k个数。

至于选取什么的排序方法,我想你可能会第一时间想到快速排序(我们知道,快速排序平均所费时间为n*logn),然后再遍历序列中前k个元素输出即可。因此,总的时间复杂度:O(n * log n)+O(k)=O(n * log n)。

解法二

咱们再进一步想想,题目没有要求最小的k个数有序,也没要求最后n-k个数有序。既然如此,就没有必要对所有元素进行排序。这时,咱们想到了用选择或交换排序,即:

1、遍历n个数,把最先遍历到的k个数存入到大小为k的数组中,假设它们即是最小的k个数;2、对这k个数,利用选择或交换排序找到这k个元素中的最大值kmax(找最大值需要遍历这k个数,时间复杂度为O(k));

3、继续遍历剩余n-k个数。假设每一次遍历到的新的元素的值为x,把x与kmax比较:如果

x < kmax ,用x替换kmax,并回到第二步重新找出k个元素的数组中最大元素kmax‘;如果x >= kmax,则继续遍历不更新数组。每次遍历,更新或不更新数组的所用的时间为O(k)或O(0)。故整趟下来,时间复杂度为n*O(k)=O(n*k)。

解法三

更好的办法是维护容量为k的最大堆,原理跟解法二的方法相似:

1、用容量为k的最大堆存储最先遍历到的k个数,同样假设它们即是最小的k个数;2、堆中元素是有序的,令k1

在《数据结构与算法分析--c语言描述》一书,第7章第7.7.6节中,阐述了一种在平均情况下,时间复杂度为O(N)的快速选择算法。如下述文字:

选取S中一个元素作为枢纽元v,将集合S-{v}分割成S1和S2,就像快速排序那样如果k <= |S1|,那么第k个最小元素必然在S1中。在这种情况下,返回QuickSelect(S1, k)。如果k = 1 + |S1|,那么枢纽元素就是第k个最小元素,即找到,直接返回它。否则,这第k个最小元素就在S2中,即S2中的第(k - |S1| - 1)个最小元素,我们递归调用并返回QuickSelect(S2, k - |S1| - 1)。此算法的平均运行时间为O(n)。

示例代码如下:

//QuickSelect 将第k小的元素放在 a[k-1]

void QuickSelect( int a[], int k, int left, int right )

{

int i, j;

int pivot;

if( left + cutoff <= right )

{

pivot = median3( a, left, right );

//取三数中值作为枢纽元,可以很大程度上避免最坏情况

i = left; j = right - 1;

for( ; ; )

{

while( a[ ++i ] < pivot ){ }

while( a[ --j ] > pivot ){ }

if( i < j )

swap( &a[ i ], &a[ j ] );

else

break;

}

//重置枢纽元

swap( &a[ i ], &a[ right - 1 ] );

if( k <= i )

QuickSelect( a, k, left, i - 1 );

else if( k > i + 1 )

QuickSelect( a, k, i + 1, right );

}

else

InsertSort( a + left, right - left + 1 );

}

e8df93098a6f99003c69944edf6a2ac2.png

5be9dccec59761d8cf69ee55511de958.png

这个快速选择SELECT算法,类似快速排序的划分方法。N个数存储在数组S中,再从数组中选取“中位数的中位数”作为枢纽元X,把数组划分为Sa和Sb俩部分,Sa<=X<=Sb,如果要查找的k个元素小于Sa的元素个数,则返回Sa中较小的k个元素,否则返回Sa中所有元素+Sb中小的k-|Sa|个元素,这种解法在平均情况下能做到O(n)的复杂度。

更进一步,《算法导论》第9章第9.3节介绍了一个最坏情况下亦为O(n)时间的SELECT算法,有兴趣的读者可以参看。

举一反三

1、谷歌面试题:输入是两个整数数组,他们任意两个数的和又可以组成一个数组,求这个和中前k个数怎么做?

分析:

“假设两个整数数组为A和B,各有N个元素,任意两个数的和组成的数组C有N^2个元素。

那么可以把这些和看成N个有序数列:

A[1]+B[1] <= A[1]+B[2] <= A[1]+B[3] <=…

A[2]+B[1] <= A[2]+B[2] <= A[2]+B[3] <=…

A[N]+B[1] <= A[N]+B[2] <= A[N]+B[3] <=…

问题转变成,在这N^2个有序数列里,找到前k小的元素”

2、有两个序列A和B,A=(a1,a2,...,ak),B=(b1,b2,...,bk),A和B都按升序排列。对于1<=i,j<=k,求k个最小的(ai+bj)。要求算法尽量高效。

3、给定一个数列a1,a2,a3,...,an和m个三元组表示的查询,对于每个查询(i,j,k),输出ai,ai+1,...,aj的升序排列中第k个数。

  • 0
    点赞
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Java中Prim算法是一种用于在加权无向图中查找最小生成树的算法。它通过贪心算法逐步扩展生成树,每次选取距离生成树最近的顶点,直到生成完整棵树。以下是Prim算法的基本思路: 1. 从图中任意一个顶点开始,将其加入生成树中。 2. 将该顶点的所有未被访问过的邻居加入一个最小堆中。 3. 从堆中选择一个距离生成树最近的顶点加入生成树,并将该顶点的未被访问过的邻居加入堆中。 4. 重复步骤3,直到生成完整棵树。 下面是Java代码实现Prim算法: ```java import java.util.*; public class Prim { public static int prim(int[][] graph, int n) { int[] dist = new int[n]; // 距离数组 boolean[] visited = new boolean[n]; // 标记是否访问过 int ans = 0; // 最小生成树的总权值 Arrays.fill(dist, Integer.MAX_VALUE); // 初始化距离数组为最大值 dist = 0; // 从第一个点开始遍历 PriorityQueue<Integer> pq = new PriorityQueue<>(Comparator.comparingInt(a -> dist[a])); // 最小堆 pq.offer(0); // 将第一个点加入最小堆中 while (!pq.isEmpty()) { int cur = pq.poll(); if (visited[cur]) continue; // 如果已经访问过,则跳过 visited[cur] = true; // 标记为已访问 ans += dist[cur]; // 累加总权值 for (int i = 0; i < n; i++) { if (!visited[i] && graph[cur][i] != 0 && graph[cur][i] < dist[i]) { // 如果未访问过且有连接,并且距离更近,则更新距离并加入最小堆 dist[i] = graph[cur][i]; pq.offer(i); } } } return ans; } public static void main(String[] args) { int[][] graph = new int[][]{ {0, 7, 0, 5, 0, 0}, {7, 0, 8, 9, 7, 0}, {0, 8, 0, 0, 5, 0}, {5, 9, 0, 0, 15, 6}, {0, 7, 5, 15, 0, 8}, {0, 0, 0, 6, 8, 0} }; System.out.println(prim(graph, graph.length)); // 输出最小生成树的总权值 } } ```

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值