<think>
我们有
一个需求：使用C++
11编写
一个算法，
找出排名前两
位的元素。
根据引用[
1]中，我们看到了使用std::sort进行降序排序的示例。我们可以先对整个序列进行排序，然后取前两个元素。
但是，如果序列很大，而我们只需要前两个
最大值，那么排序整个序列的效率不高（时间复杂度为O(n log n)）。我们可以采用更
高效的方法，例如遍历一次，记录
最大值和次大值（时间复杂度O(n)）。
思路：
1. 初始化
最大值和次大值（可以是第
一个和第二个元素，然后调整顺序）。
2. 遍历整个序列，对于每个元素：
如果当前元素大于
最大值，则更新次大值为原
最大值，更新
最大值为当前元素；
如果当前元素小于
最大值但大于次大值，则更新次大值为当前元素。
注意：序列中元素个数可能少于2个，需要处理这种情况。
我们也可以使用标准库中的部分排序算法，比如std::partial_sort，但是这里我们按照
高效的方式自己实现。
下面给出两种方法：
方法一：使用一次遍历（O(n)）
方法二：使用std::partial_sort（部分排序，将前两个元素排好序，后面的不保证顺序，时间复杂度O(n log k)，k为部分排序的元素个数，这里k=2，所以也可以认为是O(n)？但实际上部分排序的实现可能不如手动遍历
高效）
我们这里主要使用方法一。
步骤：
1. 如果数组大小小于
1，则没有前两名，返回错误或空结果。
2. 如果数组大小为
1，则只有
最大值，没有次大值（或者可以认为次大值不存在，根据需求）。
3. 如果数组大小大于等于2：
初始化：max
1 = 第
一个元素，max2 = 第二个元素；但要确保max
1>=max2，如果不是，则交换。
然后从第三个元素开始遍历（如果存在）：
当前元素大于max
1：将max2赋值为max
1，max
1赋值为当前元素。
当前元素小于等于max
1且大于max2：将max2赋值为当前元素。
但是注意：可能存在重复元素的情况，比如
最大值有多个，那么次大值应该等于
最大值（如果重复的话）？但是题目要求排名前两
位的元素，也就是说，如果
最大值有多个，那么前两名都是
最大值，次大值应该也是
最大值？但是如果我们要求区分不同的值（即相同的值只算
一个排名），那么我们需要去重？题目要求的是“元素”，并没有明确要求去重，所以我们有两种理解：
1.
找出最大的两个不同的值（即去重后的
最大值和次大值）。
2.
找出整个数组中数值
最大的两个元素（如果有重复，则多个
最大值都是第一名，那么第二名应该是次大的值？或者如果
最大值重复，则第二个
最大值还是
最大值，那么前两名都是
最大值？）
题目没有明确，但通常“排名前两
位”可能有两种含义：
a) 排名第一和第二的两个不同的值（即使有多个
最大值，第一名的值只有
一个，第二名的值是次大的）。
b) 按大小排序后，排在第一
位和第二
位的元素（这两个元素可能是相同的，也可能不同）。
根据常见的需求，我们考虑两种情况：
情况
1：如果要求返回两个
最大的不同的值（如果有两个不同的值），那么当
最大值重复时，次大值应该是下
一个比
最大值小的值。
情况2：如果只是返回
最大的两个元素（不管是否重复），那么即使
最大值重复，我们也要返回两个
最大值（即第一名和第二名都是
最大值）。
这里我们先按情况
1（返回两个
最大的不同的值）实现。如果需要情况2，我们可以稍作调整。
另外，如果数组中所有元素都相等，那么就没有次大值，此时次大值不存在。
我们设计函数返回
一个pair，其中第
一个是
最大值，第二个是次大值。如果不存在次大值，我们可以考虑返回
一个特殊值或者抛出异常，或者通过
一个bool标志表示是否成功。这里我们使用
一个pair，并添加
一个bool值表示是否找到两个不同的值。或者我们可以用std::optional（但C++
11需要自己实现optional，或者用nullptr来表示？）。由于C++
11标准库没有std::optional（C++
17才有），我们可以使用指针或者用
一个额外的布尔
变量。
但是为了简单，我们假设输入至少有两个不同的值？或者如果不满足，我们可以抛出异常。
我们这里先不考虑那么多，先实现基本功能：如果找到了
最大值和次大值（两个不同的值），则返回它们；如果
最大值重复而没有次大值，那么次大值等于
最大值？还是不存在？题目要求的是排名前两
位的元素，如果
最大值重复，那么第二名应该也是
最大值，所以此时
最大值和次大值都是
最大值。因此，我们不需要去重，而是返回排序前两
位的值（可能相同）。
所以，我们按照情况2（返回
最大的两个元素，可能是相同的值）来实现。
修正思路：
我们不需要区分不同值，只需要记录
最大的两个元素（即使相同，也不跳过）。例如：{3,2,2,
1}，前两
位应该是3和2（
最大的两个数）。
但是，注意：我们要求的是排名前两
位，即第一名和第二名。在排序中，如果排序后数组是降序的，那么第
一个元素是第一名，第二个是第二名。所以，我们应该返回排序后数组的第
一个和第二个元素。
但是，如果我们手动遍历，如何保证在出现重复时也能正确记录？实际上，我们上面的遍历方法就能处理重复：
例如：{3,3,2,
1}
初始化：max
1=3, max2=3（数组前两个元素）
第三个元素2：2小于max
1（3）且小于max2（3），不更新；第四个元素
1同理。
所以返回max
1=3, max2=3。
但是，如果数组是{3,2,3,
1}呢？
初始化：max
1=3, max2=2
第三个元素3：3等于max
1？大于max
1？不，它等于max
1，但我们要求：如果等于max
1，那么它应该可以更新次大值吗？
注意：我们要求的是前两名，所以两个3应该是第一名和第二名（但第二名应该是3，而不是2）。所以当我们遇到第二个3时，应该更新次大值吗？
我们需要明确：我们要求的是整个序列中
最大的两个元素（不考虑顺序，但要求两个元素）。所以我们希望记录的两个值就是整个序列中
最大的两个数（即使有重复，也要包括重复的
最大值）。
因此，算法调整：
初始化：max
1和max2为前两个元素中较大和较小者。
遍历剩下的元素：
如果当前元素大于max
1，则更新：max2=max
1; max
1=当前元素；
否则如果当前元素大于max2，则更新max2=当前元素。
注意：这样更新，当遇到
一个等于max
1的元素时，它不会更新max2，所以会导致错误（例如{3,2,3,
1}，当遇到第二个3时，它大于max2（2），所以会更新max2=3，这样
最后max
1=3,max2=3）。
所以这个逻辑可以正确工作。
但是，还有一种情况：如果数组一开始是{2,3}，那么初始化max
1=2, max2=3？不对，我们需要确保max
1>=max2。所以在初始化时：
if (arr[0] >= arr[
1]) {
max
1 = arr[0];
max2 = arr[
1];
} else {
max
1 = arr[
1];
max2 = arr[0];
}
然后从第三个元素开始遍历。
但是，如果数组只有两个元素，我们就不需要遍历。
另外，如果数组有重复元素，比如全是3：{3,3,3,3}，那么初始化max
1=3, max2=3，然后遍历后面的3，遇到3时：
3>max
1? 不大于。
3>max2
? 不大于（因为max2=3，3不大于3），所以不更新。
所以
最后返回3和3，正确。
所以代码步骤：
1. 如果数组大小小于2，则无法找到两个元素，返回错误（这里我们假设数组至少有两个元素，否则由调用者保证）。
2. 初始化max
1和max2为前两个元素中的较大者和较小者。
3. 从第二个元素（索引2）开始遍历数组：
if (current > max
1) {
max2 = max
1;
max
1 = current;
} else if (current > max2) {
max2 = current;
}
// 注意：等于的情况，我们既不更新max
1也不更新max2？但是等于max
1时，我们不需要更新，因为max
1已经是
最大值，但等于max2时，我们需要更新吗？实际上，我们不需要更新，因为max2已经是当前值（或者小于max
1的值），所以等于max2时，不更新也没关系，因为我们已经有
一个max2，再遇到
一个相等的，并不改变
最大值和次大值。但是，如果当前值等于max
1，但大于max2，那么我们需要更新max2吗？注意，当前值等于max
1，而max
1大于max2，那么当前值肯定大于max2，所以会进入else if条件？因为current>max2是成立的（current等于max
1，而max
1大于max2，所以current大于max2），所以会执行max2=current。但是，这样就会把max2更新为max
1的值？这没问题，因为重复的
最大值应该成为次大值（在已经有
一个最大值的情况下，再遇到
一个最大值，那么次大值就应该更新为这个
最大值）。例如{4,3}，然后遇到4：max
1=4, max2=3；然后遇到4：current=4，大于max2（3），所以更新max2=4。
最后得到max
1=4, max2=4，这正确。
但是，如果当前值等于max2，我们不需要更新，因为max2已经等于这个值，而且我们只需要两个
最大值，不需要记录所有出现。
所以算法是可行的。
然而，还有一种情况：如果数组为{
1,2,3,4}，那么：
初始化：max
1=2, max2=
1（因为前两个元素是
1和2，我们取max
1=2, max2=
1）
然后遍历：
第三个元素3：3>max
1(2) -> 更新：max2=2, max
1=3
第四个元素4：4>max
1(3) -> 更新：max2=3, max
1=4
最终得到max
1=4, max2=3，正确。
所以我们可以这样写。
但是，我们也可以使用标准库算法，比如std::nth_element，或者std::partial_sort，但是题目要求C++
11，这些算法都是可用的。
方法二：使用std::partial_sort
我们可以将数组的前两个元素部分排序（降序），这样前两个元素就是
最大的两个，且第
一个是
最大值，第二个是次大值（注意，如果有重复，第二个元素可能是
最大值，也可能是下
一个值，但部分排序保证前两个元素是整个数组中
最大的两个，并且第
一个大于等于第二个）。
但是，std::partial_sort默认是升序，所以我们需要传入比较函数，改为降序。
步骤：
使用partial_sort对前两个
位置进行排序（整个数组范围，只排序前两个
位置），使用greater作为比较。
例如：std::partial_sort(arr.begin(), arr.begin()+2, arr.end(), std::greater<int>());
然后，arr[0]是
最大值，arr[
1]是次大值。
但是注意：partial_sort会改变原数组，如果我们不希望改变原数组，则需要拷贝一份。
方法二代码更简洁，但需要修改原数组（或者拷贝）。
我们根据需求选择：
如果数组很小，两种方法都可以。
如果数组很大，且不能修改原数组，那么方法一（一次遍历）更好，因为不需要额外空间，也不修改原数组。
我们这里给出两种方法，并分别实现。
但是题目要求使用C++
11，所以两种方法都可以。
下面我们写两个函数：
方法一：遍历法（推荐，效率高）
方法二：部分排序法
为了通用性，我们假设输入是
一个vector，元素类型为T（可以是整数、浮点数等，要求可比较）。
注意：如果数组中有多个相同的
最大值，我们的方法（遍历法）会返回两个
最大值（即max
1和max2都是
最大值），这符合排名前两
位的要求。
另外，如果数组中的元素都相同，那么返回的两个值也是相同的。
代码实现：
方法一：
template <typename T>
std::pair<T, T> find_top_two(const std::vector<T>& arr) {
if (arr.size() < 2) {
throw std::invalid_argument("Array must have at least two elements.");
}
T max
1, max2;
if (arr[0] >= arr[
1]) {
max
1 = arr[0];
max2 = arr[
1];
} else {
max
1 = arr[
1];
max2 = arr[0];
}
for (size_t i = 2; i < arr.size(); ++i) {
if (arr[i] > max
1) {
max2 = max
1;
max
1 = arr[i];
} else if (arr[i] > max2) {
max2 = arr[i];
}
}
return std::make_pair(max
1, max2);
}
方法二：
#include <algorithm>
#include <functional> // for greater
template <typename T>
std::pair<T, T> find_top_two_partial(std::vector<T> arr) { // 这里传值，因为我们要修改拷贝
if (arr.size() < 2) {
throw std::invalid_argument("Array must have at least two elements.");
}
// 使用部分排序，将前两个元素排成降序（即
最大的两个在
前面）
std::partial_sort(arr.begin(), arr.begin()+2, arr.end(), std::greater<T>());
return std::make_pair(arr[0], arr[
1]);
}
注意：方法二我们传入的是vector的拷贝，所以不会修改原数组。但是拷贝整个数组可能开销较大，所以如果数组很大，方法一更优。
测试用例：
测试
1：{
1,2,3,4} -> (4,3)
测试2：{4,3,2,
1} -> (4,3)
测试3：{4,4,2,
1} -> (4,4) [注意：遍历法：前两个元素4,3（实际初始化为4和4？因为前两个元素是4和4，所以max
1=4, max2=4，然后遍历后面元素都不大于4，所以返回(4,4)]
测试4：{
1,
1,
1,
1} -> (
1,
1)
测试5：{5,3,5,2} -> (5,5) [遍历：初始化max
1=5, max2=3；然后第三个元素5：5>max
1? 不大于（5==5），然后判断5>max2（3）成立，所以更新max2=5，所以返回(5,5)]
注意：在测试5中，我们输入{5,3,5,2}，初始化时取前两个元素5和3，所以max
1=5, max2=3。然后第三个元素5，它等于max
1，所以进入else if分支（5>3成立），所以max2更新为5。然后第四个元素2，不更新。
因此，返回(5,5)正确。
但是，如果我们输入{5,5,3,2}，初始化max
1=5, max2=5（因为前两个元素都是5），第三个元素3：不大于max
1，也不大于max2（5），所以不更新；第四个元素2同理。返回(5,5)正确。
所以，我们的遍历法可以正确处理。
但是，如果输入{3,5,5,2}，初始化：max
1=5（因为3<5，所以max
1=5, max2=3），然后第三个元素5：大于max2（3），所以更新max2=5。返回(5,5)正确。
因此，我们采用遍历法。
下面我们写
一个完整的示例程序，包含异常处理（当元素不足两个时抛出异常）。
注意：题目要求使用C++
11，所以编译时需要支持C++
11。
完整代码示例：
</think>
根据需求，我将使用 C++
11 实现
一个高效算法来寻找容器中排名前两
位的元素。以下是完整的实现和说明：
### 算法实现
```cpp
#include <iostream>
#include <vector>
#include <utility> // for std::pair
#include <stdexcept> // for std::invalid_argument
#include <climits> // for INT_MIN
// 方法
1：
高效遍历法（O(n)时间复杂度）
template <typename T>
std::pair<T, T> find_top_two(const std::vector<T>& data) {
if (data.empty()) {
throw std::invalid_argument("容器不能为空");
}
if (data.size() ==
1) {
throw std::invalid_argument("至少需要两个元素");
}
// 初始化
最大值和次大值
T max
1 = std::max(data[0], data[
1]);
T max2 = std::min(data[0], data[
1]);
// 遍历剩余元素
for (size_t i = 2; i < data.size(); ++i) {
if (data[i] > max
1) {
max2 = max
1; // 更新次大值
max
1 = data[i]; // 更新
最大值
} else if (data[i] > max2) {
max2 = data[i]; // 只更新次大值
}
}
return std::make_pair(max
1, max2);
}
// 方法2：部分排序法（使用标准库算法）
template <typename T>
std::pair<T, T> partial_sort_top_two(const std::vector<T>& data) {
if (data.size() < 2) {
throw std::invalid_argument("至少需要两个元素");
}
std::vector<T> copy = data; // 避免修改原数据
std::partial_sort(
copy.begin(),
copy.begin() + 2,
copy.end(),
std::greater<T>()
);
return std::make_pair(copy[0], copy[
1]);
}
int main() {
// 测试用例
std::vector<int> vec = {7,
12, 3, 8,
12, 5, 9};
// 使用
高效遍历法
auto result = find_top_two(vec);
std::cout << "遍历法结果:
最大值 = " << result.first
<< ", 次大值 = " << result.second << "\n";
// 使用部分排序法
auto result2 = partial_sort_top_two(vec);
std::cout << "部分排序法结果:
最大值 = " << result2.first
<< ", 次大值 = " << result2.second << "\n";
return 0;
}
```
### 关键特性说明
1. **时间复杂度**
- **遍历法**：$O(n)$ 单次遍历，
高效处理大型数据集
- **部分排序法**：$O(n \log k)$（$k=2$），比全排序更
高效
2. **处理边界情况**
- 空容器抛出 `std::invalid_argument`
- 单元素容器明确提示需要至少两个元素
- 正确处理重复值（如示例中的双
12）
3. **算法选择建议**
```markdown
| 方法 | 优点 | 适用场景 |
|--------------|-----------------------|-----------------------|
| 遍历法 | 内存占用少，效率
最高 | 大型数据/嵌入式系统 |
| 部分排序法 | 代码简洁，可读性好 | 中小型数据/快速实现 |
```
4. **测试用例说明**
- 输入：`{7,
12, 3, 8,
12, 5, 9}`
- 输出：
```
遍历法结果:
最大值 =
12, 次大值 =
12
部分排序法结果:
最大值 =
12, 次大值 =
12
```
- 说明：正确处理了
最大值重复的情况，返回两个
12
### 扩展应用场景
1. **排名系统**（如引用[2]提到的奥运排序）
2. **数据分析**（如引用[4]的成绩排名）
3. **实时数据处理**（要求低延迟的场景）
本文介绍了一个用于查找整数中最右侧非零位位置的位操作函数__ffs。该函数通过逐步右移并检查特定位是否为零来确定最低有效位的位置。此方法提高了查找效率，并适用于多种应用场景。
扫一扫
16万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
