寻找第k小个元素：特定分治策略

最新推荐文章于 2023-01-07 23:43:53 发布
最新推荐文章于 2023-01-07 23:43:53 发布
阅读量182 收藏
点赞数
分类专栏： 计算机 算法 文章标签： 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/Be_Flamingo/article/details/115889915
版权
本文介绍了一种高效算法，用于从一组无序整数中找出第K小的元素。通过分组、排序及分治策略实现，平均时间复杂度为O(n)。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

1.问题

求n个数中第k小个数。

2.解析

在这里插入图片描述

在这里插入图片描述

3.设计

#include<iostream>
#include<algorithm>
#include<math.h>
using namespace std;
int tmp(int a, int b) {  //排序函数sort的第三个参数，在该题中用于将每一列的五个数从大到小排序
	return a > b;
}
class FindK {  //定义类，表示每一列的五个数
public:
	FindK(){}
	FindK(int a) {  //因为存在小于5的列，所以有适应各种情况的构造函数
		x[0] = a;
	}
	FindK(int a, int b) {
		x[0] = a;
		x[1] = b;
	}
	FindK(int a, int b, int c) {
		x[0] = a;
		x[1] = b;
		x[2] = c;
	}
	FindK(int a, int b, int c, int d) {
		x[0] = a;
		x[1] = b;
		x[2] = c;
		x[3] = d;
	}
	FindK(int a, int b, int c, int d, int e) {
		x[0] = a;
		x[1] = b;
		x[2] = c;
		x[3] = d;
		x[4] = e;
	}
	void setX(int a) {
		x[0] = a;
		size = 1;
	}
	void setX(int a, int b) {
		x[0] = a;
		x[1] = b;
		size = 2;
	}
	void setX(int a, int b, int c) {
		x[0] = a;
		x[1] = b;
		x[2] = c;
		size = 3;
	}
	void setX(int a, int b, int c, int d) {
		x[0] = a;
		x[1] = b;
		x[2] = c;
		x[3] = d;
		size = 4;
	}
	void setX(int a, int b, int c, int d, int e) {
		x[0] = a;
		x[1] = b;
		x[2] = c;
		x[3] = d;
		x[4] = e;
		size = 5;
	}
	void sortItself(int n) {  //排序函数，将每列5个数从大到小排
		sort(x, x + n, tmp);
		mid = x[n / 2];  //选出中位数
	}
	int mid;             //中位数
	int x[5];            //代表每列的5个数
	int size;            //数的个数
};
int tmpMid(FindK a, FindK b) {  //根据中位数从小到大排序
	return a.mid < b.mid;
}
class Set {  //集合类
public:
	Set() {
		number = 0;
	}
	Set(int n) {
		number = 0;
		size = n;
	}
	void add(int x) {  //往集合中添加元素
		items[number++] = x;
	}
	int getN(int i) {
		return items[i];
	}
	int getNumber() {  //返回集合中元素个数
		return number;
	}
	int size;
	int number;      //当前下标和个数
	int items[100];  //用于存放数据
};
int find_k(int k, Set s, int size) {  //核心递归算法
	FindK x[20];
	int z = floor(size / 5.0);  //算出组数
	int i;
	for (i = 0; i < z; i++) {  //构造每一组
		x[i].setX(s.items[5 * i], s.items[5 * i + 1], s.items[5 * i + 2], s.items[5 * i + 3], s.items[5 * i + 4]);
		x[i].sortItself(5);
	}
	if (size - size / 5 * 5 == 1) {  //不足5个数的构造方法，下同
		x[i].setX(s.items[5 * i]);
		x[i].sortItself(1);
	}
	else if (size - size / 5 * 5 == 2) {
		x[i].setX(s.items[5 * i], s.items[5 * i + 1]);
		x[i].sortItself(2);
	}
	else if (size - size / 5 * 5 == 3) {
		x[i].setX(s.items[5 * i], s.items[5 * i + 1], s.items[5 * i + 2]);
		x[i].sortItself(3);
	}
	else if (size - size / 5 * 5 == 4) {
		x[i].setX(s.items[5 * i], s.items[5 * i + 1], s.items[5 * i + 2], s.items[5 * i + 3]);
		x[i].sortItself(4);
	}
	sort(x, x + z + 1, tmpMid);    //按横方向中位数从小到大排序
	int mid = x[(z + 1) / 2].mid;  //算出横方向的中位数
	Set s1, s2;                    //构造两个集合S1，S2
	for (i = 0; i < z + 1; i++) {
		if (x[i].size == 1 && i != (z + 1) / 2) {  //处理不足5个数的列，size表示该列的个数
			if (x[i].x[0] < mid)
				s1.add(x[i].x[0]);
			else
				s2.add(x[i].x[0]);
		}
		else if (x[i].size == 1 && i == (z + 1) / 2) {
			continue;
		}
		else if (x[i].size == 2 && i != (z + 1) / 2) {
			if (x[i].x[0] < mid)
				s1.add(x[i].x[0]);
			else
				s2.add(x[i].x[0]);
			if (x[i].x[1] < mid)
				s1.add(x[i].x[1]);
			else
				s2.add(x[i].x[1]);
		}
		else if (x[i].size == 2 && i == (z + 1) / 2) {
			if (x[i].x[0] < mid)
				s1.add(x[i].x[0]);
			else
				s2.add(x[i].x[0]);
		}
		else if (x[i].size == 3 && i != (z + 1) / 2) {
			if (x[i].x[0] < mid)
				s1.add(x[i].x[0]);
			else
				s2.add(x[i].x[0]);
			if (x[i].x[1] < mid)
				s1.add(x[i].x[1]);
			else
				s2.add(x[i].x[1]);
			if (x[i].x[2] < mid)
				s1.add(x[i].x[2]);
			else
				s2.add(x[i].x[2]);
		}
		else if (x[i].size == 3 && i == (z + 1) / 2) {
			if (x[i].x[0] < mid)
				s1.add(x[i].x[0]);
			else
				s2.add(x[i].x[0]);
			if (x[i].x[2] < mid)
				s1.add(x[i].x[2]);
			else
				s2.add(x[i].x[2]);
		}
		else if (x[i].size == 4 && i != (z + 1) / 2) {
			if (x[i].x[0] < mid)
				s1.add(x[i].x[0]);
			else
				s2.add(x[i].x[0]);
			if (x[i].x[1] < mid)
				s1.add(x[i].x[1]);
			else
				s2.add(x[i].x[1]);
			if (x[i].x[2] < mid)
				s1.add(x[i].x[2]);
			else
				s2.add(x[i].x[2]);
			if (x[i].x[3] < mid)
				s1.add(x[i].x[3]);
			else
				s2.add(x[i].x[3]);
		}
		else if (x[i].size == 4 && i == (z + 1) / 2) {
			if (x[i].x[0] < mid)
				s1.add(x[i].x[0]);
			else
				s2.add(x[i].x[0]);
			if (x[i].x[1] < mid)
				s1.add(x[i].x[1]);
			else
				s2.add(x[i].x[1]);
			if (x[i].x[3] < mid)
				s1.add(x[i].x[3]);
			else
				s2.add(x[i].x[3]);
		}
		else {                      //对每列有5个数的处理
			if (i <= (z + 1) / 2) {
				if (i == (z + 1) / 2) {
					s1.add(x[i].x[3]);
					s1.add(x[i].x[4]);
				}
				else {
					s1.add(x[i].x[2]);
					s1.add(x[i].x[3]);
					s1.add(x[i].x[4]);
					if (x[i].x[0] < mid)
						s1.add(x[i].x[0]);
					else
						s2.add(x[i].x[0]);
					if (x[i].x[1] < mid)
						s1.add(x[i].x[1]);
					else
						s2.add(x[i].x[1]);
				}
			}
			if (i >= (z + 1) / 2) {
				if (i == (z + 1) / 2) {
					s2.add(x[i].x[0]);
					s2.add(x[i].x[1]);
				}
				else {
					s2.add(x[i].x[0]);
					s2.add(x[i].x[1]);
					s2.add(x[i].x[2]);
					if (x[i].x[3] < mid)
						s1.add(x[i].x[3]);
					else
						s2.add(x[i].x[3]);
					if (x[i].x[4] < mid)
						s1.add(x[i].x[4]);
					else
						s2.add(x[i].x[4]);
				}
			}
		}
	}
	if (s1.getNumber() == k - 1) {  //分为找到、小于、大于三种情况来处理，后两种要分治递归处理
		return mid;
	}
	else if (s1.getNumber() > k - 1) {
		return find_k(k, s1, s1.getNumber());
	}
	else {
		return find_k(k - 1 - s1.getNumber(), s2, s2.getNumber());
	}
}
int main() {
	int n;
	int i;
	int a, b, c, d, e;
	int x;
	int k;
	cout << "输入要输入的数据个数：";
	cin >> n;
	cout << "输入第几小的数：";
	cin >> k;
	cout << "输入这" << n << "个数：" << endl;
	Set set1(n);
	for (i = 0; i < n; i++) {
		cin >> x;
		set1.add(x);
	}
	cout << find_k(k, set1, n) << endl;
	return 0;
}

测试用例

4.分析

时间复杂度：O（n）

5.源码

https://github.com/BeFlamingo/faming6

寻找第K小元素——特定分治策略
qq_43403657的博客
04-05 1120
1.问题 寻找数组中第K小的元素，使用分治策略算法完成。 2.解析 算法步骤： 1.将n个元素每 5 个一组，分成n/5(上界)组。 2.取出每一组的中位数，任意排序方法，比如插入排序。 3.递归的调用 selection 算法查找上一步中所有中位数的中位数，设为x，偶数个中位数的情况下设定为选取中间小的一个。 4.用x来分割数组，设小于等于x的个数为k，大于x的个数即为n-k。 5.若i==k，...
选第k小元素：特定分治策略
weixin_50941638的博客
04-19 804
1.问题 采用特定分治策略选第k小元素： 设S是n个元素的集合，从S中选取第k小的元素。其中，1≤k≤n。 这里第k小的元素是指，当集合S按升序排好序后，排在第k个位置的元素。 2.解析 采用特定分治策略选第k小元素的实现思路： ①k = |S1|+1，m即为所要找的第k小元素（原因：以m为划分标准后，比m小的有|S1|个，若此时恰巧k=|S1|+1，则m即为所要找的第k小元素）； ②k ≤ |S1|，归约为在S1中找第k1小的子问题，k1在子问题中相对位置不变，即k1 = k； ③k ＞ |S1|+1，
快速排序求第k小的数
fengsigaoju的博客
02-24 6823
快速排序求第k小的数，思想非常简单，就是如果要查找的k比当前下标low小，则只递归左部分，大则递归右部分，相等则递归右部分，当然由于数组下标从0开始，所以应该是k-1,（比如第一大的数数组下标为0)，原理就是快速排序是以一个元素为分隔的，如果求第k大的元素，就是求第n-k+1小的元素. #include int i,j; void quicksort(int a[],int left,int
1004. Counting Leaves (30)
buaapascal的博客
03-25 206
#include&lt;cstdio&gt; #include&lt;cstring&gt; #include&lt;iostream&gt; #include&lt;sstream&gt; #include&lt;algorithm&gt; #include&lt;cctype&gt; #include&lt;vector&gt; #include&lt;iomanip&gt;
选第k小元素：特定分治策略（JAVA）
qq_45549746的博客
04-19 601
选第k小元素：特定分治策略（JAVA） 问题 在一个数组S中查找第k小的元素并输出。 解析 以S中的某个元素m作为划分标准，将S划分为两个子数组S1和S2，把这个数组中比m小的都放入S1的数组中，数组S1的元素个数是|S1|个；把这个数组中比m*大的都放入S2的数组中，数组S2的元素个数是|S2|个。 若k<|S1|，则原问题归纳为在数组S1中找第k小的子问题。 若k=|S1|+1，则m*就是要找的第k小元素。 若k>|S1|+1，则原问题归纳为在数组S2中找第n−|S1|−1小的子问题。
算法设计与实践-作业6-第k小元素：特定分治策略
weixin_43966861的博客
05-26 238
标题
ConsoleApplication19_K._分治策略选中第k小的数_源码
10-04
分治策略选中第k小的数_源码”中，我们关注的是如何利用分治策略来找到一个数组中的第k小的元素。这个题目常见于编程竞赛和面试中，对于理解分治算法有着很好的实践意义。 首先，让我们深入理解分治策略。分治策略...
(寻找第K小的数&&寻找第K小的数的和)
黄俊东的专栏
05-24 1521
这一篇博客以一些OJ上的题目为载体，讲一下寻找第K小的数的方法方法一：先将数据排列好，然后，然后return a[k]或者将前K个数加起来方法二：基于快速排序。如，一次快速排序将某一个数放到了第k个位置，那么前k-1个数都要比第k个数小，后面的数都要比第k个位置上的数要大。所以当前第k个位置上的数就是第K小的数1、NYOJ 678 最小K个数之和这道题的时间放得比较松，不要求线性时间，所以用方法一
数据结构---排序、第K大数，第K小数（堆）
丫丫的博客
08-24 2093
堆是一种特殊的完全二叉树，所有父点都比子结点要小称最小堆，反之，所有父点都比子结点大的成为最大堆。用堆来排序、删除、增加效率都比较高。另外用堆来求第K大数和第K小数都比较方便。只需要建立一个大小为K的堆，堆顶就是要求的第K大或第K小。 例如： 有5个数，要求第3小的数。首先任取三个数，例如前三个建立最大堆，然后从第4个数开始与堆顶比较，若比堆顶大，那么这个数就不要，若比堆顶小就和堆顶交换，重新...
程序员编程艺术：三之三续、求数组中给定下标区间内的第K小（大）元素
weixin_34082177的博客
05-28 174
                  第三章三续、求数组中给定下标区间内的第K小（大）元素 作者：July、上善若水、编程艺术室。出处：http://blog.youkuaiyun.com/v_JULY_v 。 前奏     原狂想曲系列已更名为：程序员编程艺术系列。原狂想曲创作组更名为编程艺术室。编程艺术室致力于以下三点工作：1、针对一个问题，不断寻找更高效的算法，并予以编程...
快速排序和查找第K小元素
cobracanary的博客
01-24 817
Java快排及快排查找第K大的数字 快速排序 public class fastsort { public static void main(String[] args) { int arr[]= {5,4,3,2,1}; fastsort(arr,0,4); System.out.println(arr[0]); } static void swap(int arr[],int x,in...
【算法】找第k小的数（分治快排法）
weixin_52078305的博客
06-04 1338
设计一个平均时间为O(n)的算法，在n(1
【LeetCode】719. 找出第 k 小的距离对
harmsworth的博客
01-19 485
前言 找出第 k 小的距离对 给定一个整数数组，返回所有数对之间的第 k 个最小距离。一对 (A, B) 的距离被定义为 A 和 B 之间的绝对差值。 示例 1: 输入： nums = [1,3,1] k = 1 输出：0 解释： 所有数对如下： (1,3) -> 2 (1,1) -> 0 (3,1) -> 2 因此第 1 个最小距离的数对是 (1,1)，它们之间的距离为 0。 来源：力扣（LeetCode） 链接：https://leetcode-cn.com/problems/find
378. 有序矩阵中第 K 小的元素【排序Arrays.sort、优先级队列（小顶堆）、二分查找】
long_steve的博客
01-07 116
刷算法，主要是刷思想，刷经典的思路，不是刷偏题，比较偏的解题思路，那种方法不通用，收获不大，这道题就有点。给你一个 n x n 矩阵 matrix ，其中每行和每列元素均按升序排序，找到矩阵中第 k 小的元素。输入：matrix = [[1,5,9],[10,11,13],[12,13,15]], k = 8。解释：矩阵中的元素为 [1,5,9,10,11,12,13,13,15]，第 8 小元素是 13。输入：matrix = [[-5]], k = 1。
[排序] 第K小的数
Minecraftwzy的博客
03-23 458
第k小的数 第K小的数这道题是一个非常经典的题目 题目意思就是求一个序列中第k小的那个数 这道题方法众多接下来就一一给大家呈现 1 时间复杂度为n^2的冒泡排序 //冒泡排序 #include<bits/stdc++.h> using namespace std; int n,a[10005],k; int main() { cin>>n; for(int i=1;i<=n;++i) cin>>a[i]; cin>>k; for(int i=
算法分析与设计——快速排序求第k小的数
TTTSEP9TH2244的博客
01-20 3112
快速排序简介: 快速排序求第k小的数，思想非常简单，就是如果要查找的k比当前下标i小，则只递归左部分，大或相等则递归右部分。当然由于数组下标从0开始，所以应该是k-1（比如第一大的数数组下标为0)。原理就是快速排序是以一个元素为分隔的，如果求第k大的元素，也就是求第n-k+1小的元素。 原理： 快速排序求第k小的数，思想非常简单，就是如果要查找的k比当前下标low小，则只递归左部分，大则递归右部分，相等则递归右部分，当然由于数组下标从0开始，所以应该是k-1,（比如第一大的数数组下标为0)，原理就是快速排序
找第k小的元素（基于快速排序的思想）
qq_45298704的博客
09-06 166
找第k小的元素（基于快速排序的思想） #include<stdio.h> #include<stdlib.h> int Select_Nok(int a[], int low, int high,int k) { int pivot = a[low]; int low_temp = low; //在后续递归调用中需要用到最初调用时的low和high,而在之后的调用中会修改low和high,所以暂时保存下来 int high_temp = high;
C++实现数组第k小元素查找算法
在IT行业中，算法设计是一项核心技能，尤其在数据结构与算法的领域中，寻找数组中的第k小元素问题是一个常见的算法问题。该问题涉及到排序、选择、分治等多种算法思想。根据提供的文件信息，我们将深入探讨利用C++...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值