求2n个数中最大值和最小值的最少比较次数

最新推荐文章于 2023-08-27 14:24:34 发布
原创 最新推荐文章于 2023-08-27 14:24:34 发布 · 1.1w 阅读 · 4 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#求2n个数中最大值和最小值的最少比较次数

共2n个数。前两个数比较,大的为最大值, 小的为最小值, 用掉一次比较。后面2*(n-1)个数, 每两个比较, 大的同最大值比较, 小的同最小值比较, 3*(n-1)次比较, 共3*(n - 1) + 1 = 3n - 2次比较。


例：求30000个数的最大值和最小值，最少比较次数：

第一个数和第二个数比较，大的为最大值，小的为最小值，比较1次；

后面29998个数，每两个比较，共比较29998/2次，

然后大的同最大值比，比较了29998/2次，小的同最小值比，比较了29998/2次；

故，共比较了1+3*29998/2=1+3*14999=44998次

同时求最大值与最小值（看似简单却值得思考~）
m0_51339444的博客
04-22 1434
求最大值与最小值（看似简单却值得思考~）
【华为OD机试】最小的调整次数
算法菌的博客
11-05 144
有一个特异性的双端队列，该队列可以从头部或尾部添加数据，但是只能从头部移出数据。 小A依次执行2n个指令往队列中添加数据和移出数据。其中n个指令是添加数据（可能从头部添加、也可能从尾部添加），依次添加1到n；n个指令是移出数据。 现在要求移除数据的顺序为1到n。 为了满足最后输出的要求，小A可以在任何时候调整队列中数据的顺序。 请问 小A 最少需要调整几次才能够满足移除数据的顺序正好是1到n；
同时找最大最小值⌈3N/2⌉−2算法
被一个OIER遗弃的一堆烂代码
05-24 8021
同时找最大最小值 题目定义： 给定一个大小为n的数组，无序，找到其中的最大值和最小值，要求元素间的比较次数尽可能少。 以下摘自《算法导论》： 事实上，我们只需要最多3⌊n/2⌋次比较就可以同时找到最小值和最大值。具体的方法是记录已知的最大值和最小值，然后对输入元素成对地进行处理。首先，我们将一对输入元素相互进行比较，然后把较小的与当前最小值进行比较，把较大的与当前最大值进行比较。这样，对每两个元素共需3次比较。 如何设定已知的最小值和最大值的初始值依赖于n是奇数还是偶数。如果n是奇数，我们就将最小值和最
同时寻找最大数和最小数的最优算法
Cobing Liu
12-30 9006
从一个集合中同时找出最大数和最小数最少需要多少比较次数呢？
求一组随机数中的最大最小值最少比较次数
ah7975的博客
07-17 762
1. 求一组随机数中的最大值和最小值最少比较次数为3n/2-2取上整次，即大于等于3n/2-2的最小整数次。 　　当n为偶数时，为3n/2-2 　　当n为奇数时，为3n/2-3/2 2. 算法如下。 第一步，将这组数据两两比较，将小数置于数组前半部分，大数置于数组后半部分。如果n为偶数，此次比较次数为n/2；如果n为奇数，此次比较次数为(n-1)/2，中间的那个数不做比较。 第...
同时找到最大值和最小值
前方尽是康庄大道的博客
02-28 1874
同时找到最大值和最小值 普通的思维下，要是找最大值或者最小值，是通过遍历的方法解决的。需要n-1次遍历。而要找到最大值和最小值，则需要2(n-1)次遍历。每个元素都要进行两次比较。 然而，有没有更优化的方法呢？ 有！ 我们可以将要输入的元素，先进行两两比较。***将两者中较大的数字和已知的最大值进行比较，较小的值则不用在和已知 的最大的值比较。同样的，将两者中较小的数字和已知的最小值进行比较，较大...
求一个数组中的最大值和最小值，要求将比较次数减小至3N/2
jbcsimple
08-10 4216
1、取双元素法 每次取两个元素，用较小的和最小值比较，用较大的和最大值比较，那么总共会取N/2次，每取一次会进行三次比较，第一次比较当前两个元素，第二次较小的和当前最小值比较， 第三次较大的和当前最大值比较，总的比较次数便是：3N/2。需要注意的是： （1）输入数组的合法性检查（空指针或者数组的长度为0）； （2）边界检查：输入数组只有1个元素，那么最小值和最大值均为该元素； （3）初始
算法入门：最少比较次数求最大／最小／第二大元素
Mandy酱的学习日记
10-15 4941
本文将解决三个问题： input：A[1……n] 包含n个数字 output： - A的最大值max - A的最大值max和最小值min - A的最大值max和第二大值 要求：比较的次数尽可能少
顺序统计算法设计-最大值和次最大值
qq_37861955的博客
12-23 2166
题目描述 给定数组A[0…n-1]，试设计一个算法，在最坏情况下用n+logn次比较找出A[0…n-1]中元素的最大值和次大值。 比较次数为2n的算法实现 public static int[] findSecondFirst(int[] array) { int[] result=new int[2]; int max=array[0]>array[1]?array[0]:a...
专题探究：极差
qq_63942622的博客
08-27 282
极差的性质，这种东西没有必要讲，毕竟只要善于分析就 ok 了；我们要讨论的主要是解题思路。极差，最大的特点在于两端不确定性，即最大值与最小值需要同时确定。由此，我们推想出一种思路：一端枚举，一端加速（如二分等技巧），这也就是锻炼思维能力的关键。来看例题，只有实践才最有意义。
求解找到数组A[1..n]中元素的最大值和次最大值(本小题以数组元素的比较为标准操作)的算法，并分析其最坏情况的时间复杂度。
07-15
求解找到数组A[1..n]中元素的最大值和次最大值(本小题以数组元素的比较为标准操作)的算法，并分析其最坏情况的时间复杂度。
计算机算法-最少的比较次数同时求最大值最小值
qq_43838114的博客
10-07 717
计算机算法-最少的比较次数同时求最大值最小值
算法导论（第9章-中位数和顺序统计学）最大值和最小值
大田二十
05-03 2869
算法导论（第9章-中位数和顺序统计学）最大值和最小值
以元素的比较为基本运算的排序算法（一）快速排序，选择，冒泡，插入排序...
ziggybowie的博客
09-09 312
以元素的比较为基本运算的排序算法 算法 最坏情况 平均情况 插入排序 O(n^2) O(n^2) 冒泡排序 O(n^2) O(n^2) 快速排序 O(n^2) O(nlogn) 堆排序 O(nlogn) O(nlogn) 二分归并排序 O(nlogn) O(nlogn) 1. 插入排序 序列 ： 5 7 1 3 6 2 4 将其从小到大排列 从第二个元素开始，...
长度为2n的数组，分为两个长度为n的数组，两个数组各自的和相比的差的绝对值最小。
weixin_41481760的博客
10-09 902
动态规划： 整个思路大概是这样的，可能哪儿有问题，谢谢指出。 首先求出整个2n数组的和sum，最好的情况是两个数组能够将2n数组平分，那么差的绝对值为0。建立一个二维数组int[n][m]，分了以后的数组的长度，m为sum的一般，就是最好的情况，当然不管怎么样，最终分完的一个n长度的组数总和也一定是在0到m之间，或者等于m。 接下来就是java代码： public void process(int...
将长度为2N的数组按对分配成N组，不重复，无顺序，总共有多少种分法，并将分法写出来
sosozha的博客
09-07 574
这个题不是简单的排列组合 M选2，需要将所有的数分配完全 public static void main(String[] args) { Integer[] nums = {1,2,3,4,5,6,7,8}; //改用list的原因，list有增删方法且list增删快 ArrayList<Integer> integers = new ArrayList<>(Arrays.asList(nums)); int le
数据结构:笔记-时间复杂度
世上再无张显宗
06-05 2641
1、顺序表含有127个元素,向其插入一个新元素并保持原来顺序不变,平均要移动____个元素() 正确答案: A 你的答案: A (正确) 63.5 8 32 7 2、哈夫曼树、平衡二叉树都是数据的逻辑结构() 正确答案: A 你的答案: B (错误) 对 错 解析：线性表，树，图 这些都是对数据逻辑结构的描述。 数据的存储结构只有顺序结构和链式结构（不一定是单链 3、有n个节点的顺序表中，算法的时间复杂度是O(1)的操作是（） 正确答案: A 你的答案: A (正确) 访问第i个节点（1≤i≤n
牛客网刷题（四） 2^n（n>=512）
weixin_42736024的博客
11-17 468
题目：写一个算法实现2的n次方(n&gt;=512)。            输入：一个数字n            输出：2的n次方 思路：想要求2^n的值我们首先可能会想到的办法，就是直接计算，但是由于2^n(n&gt;=512)的值过大，没有办法用平常的类型进行存储，所以编译器会直接显示值为0，导致结果错误，那么此时，我们就该思考，应该用什么来存储这个过大的值，我们首先可能会考虑到数组...
2021 CCF 非专业级别软件能力认证第一轮（CSP-S1）提高级
qq_41221725的博客
09-23 4173
C++语言试题,认证时间：2021 年 9 月 19 日 09:30~11:30 考生注意事项： l 试题纸共有 16 页，答题纸共有 1 页，满分 100 分。请在答题纸上作答，写在试题纸上的 一律无效。 l 不得使用任何电子设备（如计算器、手机、电子词典等）或查阅任何书籍资料。 一、单项选择题（共 15 题，每题 2 分，共计 30 分；每题有且仅有一个正确选项） 1. 在 Linux 系统终端中，用于列出当前目录下所含的文件和子目录的命令为（ ）。 A. ls
用python写出老板有一袋金块(共n块)，最优秀的雇员得到其中最重的一块，最差的雇员得到其中最轻的一块。假设有一台比较重量的仪器，我们希望用最少的比较次数找出最重的金块。
最新发布
03-19
<think>好的，我现在要解决的问题是，如何在Python中实现一个算法，通过最少的比较次数找到一堆金块中最重和最轻的。用户希望最小化比较次数，所以需要找到一个高效的算法。 首先，我得回忆一下相关的算法知识。通常，要找到最大值和最小值，最简单的方法可能是遍历数组，每个元素都跟当前的最大和最小值比较，这样比较次数大约是2n-2次，其中n是元素的数量。但这种方法显然不是最优的，因为存在更高效的算法。 我记得在算法课程中，有一种分治的方法可以在大约3n/2次比较内同时找到最大值和最小值。这个算法的思路是将元素两两比较，确定每一对的较大和较小者，然后将较大的候选放入最大值组，较小的候选放入最小组。这样每对需要一次比较，然后在最大值组里找最大，最小组里找最小，这样总的比较次数是n/2（两两比较）加上n/2 -1（找最大）加上n/2 -1（找最小），总共约3n/2 -2次。这比普通的2n-2次节省了大约25%的比较次数。 所以，我需要实现这个算法。具体步骤应该是这样的： 1. 将金块数组分成两两一组。如果数组长度是奇数，最后一个元素单独处理。 2. 对每一对进行比较，将较大的放入一个临时数组max_candidates，较小的放入min_candidates。 3. 然后在max_candidates中找到最大值，在min_candidates中找到最小值。 4. 如果原数组长度是奇数，最后一个元素需要分别和当前的最大、最小值比较一次。 例如，对于数组[3,1,4,5,2]，分成两组[3,1]、[4,5]，最后一元素2单独处理。比较后，max_candidates是[3,5]，min_candidates是[1,4]。然后比较3和5得到最大5，比较1和4得到最小1。再处理最后一个元素2，比较2和当前最小1（不需要改变），再比较2和当前最大5（不需要改变）。这样总共有3次比较（两两比较两次，单独处理两次比较，但可能实际次数需要详细计算）。 接下来，我需要将这个逻辑转化为Python代码。首先处理分组的步骤，可以用循环遍历数组，每次取两个元素。然后处理剩下的元素。 代码结构大概如下： 初始化max_val和min_val。如果数组长度为奇数，最后一个元素先作为初始max和min。然后遍历数组，每次取两个元素，比较它们的大小，较大的和当前max比较，较小的和当前min比较。或者按照之前说的分组方法，先创建max_candidates和min_candidates数组，然后再从中找最大和最小。这样可能更清晰。 比如： def find_min_max(arr): n = len(arr) if n == 0: return None, None if n == 1: return arr[0], arr[0] # 初始化max和min if n % 2 == 0: start = 0 current_max = max(arr[0], arr[1]) current_min = min(arr[0], arr[1]) start = 2 else: current_max = current_min = arr[0] start = 1 # 每次处理两个元素 for i in range(start, n, 2): a = arr[i] if i+1 < n: b = arr[i+1] if a > b: local_max = a local_min = b else: local_max = b local_min = a else: # 处理剩下的单个元素 local_max = local_min = a # 更新当前max和min if local_max > current_max: current_max = local_max if local_min < current_min: current_min = local_min return current_min, current_max 不过，这样的实现是否正确？比如，当数组长度为奇数时，剩下的元素逐个处理。比如数组长度是5，start从1开始，i从1到4，步长2，那么i=1时处理arr[1]和arr[2]，i=3时处理arr[3]和arr[4]。这可能有问题，因为当n是奇数时，初始start是1，剩下的元素可能需要处理最后一个单独的。或者，可能原数组长度是奇数时，比如5，start是1，然后循环从1到4，每次步长2，i依次是1、3。当i=3时，i+1=4 <5，所以处理arr[3]和arr[4]。这样剩下的元素是原数组的第0个元素已经被处理了吗？ 或者，可能在初始处理的时候，当n是奇数，start=1，此时初始current_max和current_min都是arr[0]，然后从i=1开始，每次处理两个元素。这样，总共有n-1个元素被处理，因为原数组长度是奇数的话，初始一个元素已经被处理，剩下的n-1个元素两两分组，但n-1是偶数，所以没有问题。 例如，n=5时，初始start=1。循环i从1到3，每次处理两个元素。i=1处理arr[1]和arr[2]，i=3处理arr[3]和arr[4]。这样总共有两个对，加上初始的arr[0]，这样所有的元素都被处理了。 这样，这个算法是否正确？ 测试一下。例如数组是 [5,1,4,3,2]。初始n是5，奇数。current_max和current_min初始化为5。然后进入循环，i=1，处理arr[1]和arr[2]，即1和4。比较得到local_max=4，local_min=1。然后比较current_max=5和4，current_max保持5。current_min=5和1比较，更新为1。接着i=3，处理arr[3]和arr[4]，即3和2。local_max=3，local_min=2。current_max还是5，current_min是1。最终返回1和5。正确。 另一个测试案例：数组是 [3,1,4,5,2]。初始current_max和min是3。i从1开始，处理1和4。local_max=4，local_min=1。current_max更新为4？不，原current_max是3，所以新的current_max会是4。current_min更新为1。接下来处理5和2：local_max=5，local_min=2。current_max更新为5，current_min还是1。最终返回1和5。正确。 所以这个算法是正确的。比较次数方面，当n是偶数时，比较次数是1（初始两个元素比较） + (n-2)/2 *3？或者需要详细计算。或者，总的比较次数是： 对于每两个元素，比较一次得到较大的和较小的。然后每对需要两次比较来更新全局的最大和最小。或者可能不是这样。例如，对于每对元素，比较一次得到local_max和local_min，然后比较local_max和current_max，如果更大就更新，同样local_min和current_min比较。所以每个元素对需要1（比较两个元素） + 2（两次比较更新全局） =3次比较？那总共有n/2对的话，比较次数是3n/2。但是当n是偶数时，初始比较两个元素，得到max和min，这需要1次比较，然后剩下的n-2个元素分成(n-2)/2对，每对需要一次比较，然后两次比较更新全局。总比较次数是1 + 3*(n-2)/2 = 3n/2 -2。当n是奇数时，初始元素单独处理，剩下的n-1元素分成（n-1)/2对，每对3次比较，总比较次数是3*(n-1)/2次。比如n=5，总比较次数是3*2=6次。是否比普通方法更好？ 普通方法是每个元素比较两次，总比较次数2n-2。当n=5时，普通方法需要8次，而这里需要6次，确实是节省了。 所以这个算法的比较次数大约是3n/2次，比普通方法好。 接下来，我需要将这个思路写成Python代码，并且测试是否有效。然后，在回答用户的问题时，需要给出这个算法的实现，并解释其比较次数为何更优。同时，可能还需要生成相关问题。 另外，用户的问题是关于找到最重和最轻的金块，所以例子中的数组元素可以称为金块的重量。代码中的变量可以相应调整命名，比如将arr改为gold_bars。 然后，代码的注释需要清晰，确保读者可以理解每一步的作用。此外，还需要处理空数组的情况，返回None或者抛出异常，根据需求决定。用户可能需要处理的是至少有一个金块的情况，所以假设输入数组非空。 综上，Python函数的实现大致如上，但需要更仔细的变量命名和错误处理。例如： def find_min_max(gold_bars): n = len(gold_bars) if n == 0: raise ValueError("数组不能为空") if n == 1: return (gold_bars[0], gold_bars[0]) # 初始化最大值和最小值 if n % 2 == 0: current_max = max(gold_bars[0], gold_bars[1]) current_min = min(gold_bars[0], gold_bars[1]) start_index = 2 else: current_max = current_min = gold_bars[0] start_index = 1 # 每次处理两个元素 for i in range(start_index, n, 2): if i + 1 < n: a, b = gold_bars[i], gold_bars[i+1] if a > b: local_max = a local_min = b else: local_max = b local_min = a else: # 处理单个剩余元素的情况 local_max = local_min = gold_bars[i] # 更新当前最大值和最小值 if local_max > current_max: current_max = local_max if local_min < current_min: current_min = local_min return (current_min, current_max) 这个函数应该可以正确返回最小和最大值，并且比较次数大约是3n/2次。例如，测试数组[5,3,8,2,7,1]，当n=6，偶数。初始比较5和3得到current_max=5，current_min=3。然后处理8和2：比较得到local_max=8，local_min=2。更新current_max为8，current_min保持3。接着处理7和1：local_max=7，local_min=1。current_max保持8，current_min变为1。最终返回1和8。正确。 另一个测试，数组长度为5，奇数。例如，数组是 [4,9,2,5,3]。初始current_max和min是4。处理9和2：比较得到local_max=9，local_min=2。current_max更新为9，current_min更新为2。然后处理5和3：local_max=5，local_min=3。current_max保持9，current_min保持2。最终返回2和9。正确。 所以，这个算法是正确的。接下来需要解释其比较次数为何最少。通常，理论上的最优比较次数下限是⌈3n/2⌉ -2。例如，对于n元素，找到最大和最小值，最少需要这么多次比较。这个算法达到了这个下限，因此是优化的。 在回答用户的问题时，需要指出这一点，并给出代码示例，同时解释其如何减少比较次数。同时，生成相关问题。</think>为了在Python中通过最少比较次数找到最重和最轻的金块，可以采用**分治策略**，将元素两两分组比较，减少总比较次数。以下是具体实现： ```python def find_min_max(gold_bars): n = len(gold_bars) if n == 0: raise ValueError("数组不能为空") if n == 1: return (gold_bars[0], gold_bars[0]) # 初始化最大值和最小值 if n % 2 == 0: current_max = max(gold_bars[0], gold_bars[1]) current_min = min(gold_bars[0], gold_bars[1]) start_index = 2 else: current_max = current_min = gold_bars[0] start_index = 1 # 每次处理两个元素 for i in range(start_index, n, 2): if i + 1 < n: a, b = gold_bars[i], gold_bars[i+1] if a > b: local_max, local_min = a, b else: local_max, local_min = b, a else: # 处理单个剩余元素 local_max = local_min = gold_bars[i] # 更新最大值和最小值 current_max = max(current_max, local_max) current_min = min(current_min, local_min) return (current_min, current_max) ``` ### 算法分析 1. **比较次数**：总比较次数约为 $\frac{3n}{2} - 2$。例如，对于 $n$ 个元素： - 每对元素需要 **1次比较** 确定局部最大/最小。 - 每对还需 **2次比较** 更新全局最大/最小。 - 总次数为 $\frac{n}{2} \times 3 - 2$（偶数）或 $\frac{3(n-1)}{2}$（奇数），优于普通遍历的 $2n-2$ 次[^1]。 2. **时间复杂度**：$O(n)$，仅需一次遍历。 ### 示例 ```python bars = [3, 1, 4, 5, 2] lightest, heaviest = find_min_max(bars) print(f"最轻: {lightest}, 最重: {heaviest}") # 输出：最轻: 1, 最重: 5 ```
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值