Java 查找数组中三个最大数字的位置

这是一个较大的leetcode问题中的一个小算法。如果给定一个数组，比如说

[5,7,3,5,3,5,5,16,9]

，我希望我的代码按顺序返回数组中三个最大数字的位置。使用上述数组，按从左到右的顺序，最大的三个数字将是7、16和9。因此，该方法应返回

[1,6,7]

，或三个数字所在的索引

我已经想了很长一段时间了，但我不知道怎么做。我已经考虑过在代码中实现HashMaps来设置数组值和位置之间的区别，但不确定如何实现这样的设计。任何帮助都将不胜感激，谢谢

编辑

我找到了解决这个问题的办法。FindBig3使用HashMap记录给定数组中的索引和其中的值

代码使用for循环从左到右遍历数组，并使用以下指令

从存储在

lo3

Hashmap中的前三个数组值开始

在“大3”中查找最小值（使用

findLeastValue

方法）

检查for循环中的i值是否大于“三巨头”中的最小值，如果大于，则从

lo3

中删除最小值并插入i值

然后程序输出3个最大数字的位置（lo3的键集）

公共静态字符串findBig3（ArrayList数组）{
HashMap lo3=新的HashMap（）；
lo3.put（0，array.get（0））；
lo3.put（1，array.get（1））；
lo3.put（2，array.get（2））；
对于（int i=3；ilo3.get（leastLoc））{
lo3.put（i，array.get（i））；
lo3.移除（最小许可证）；
}
}
字符串loc=”“；
for（整数位置：lo3.keySet（））{
loc+=位置+“”；
}
返回loc；
}
//返回具有最小数字的键
公共静态int findLeastValue（HashMap lo3）{
int最小值=整数最大值；
int leastLoc=0；
for（整数键：lo3.keySet（））{
if（lo3.get（key）

这样您就可以用两个int变量创建一个类：元素的索引和值

解决方案#1：实现可比较的接口 创建实现可比较接口的对象列表。此接口可以根据您对compareTo函数的实现对列表进行排序。您可以根据元素的原始值对列表进行排序，然后制作一个小算法来比较三个最高元素的索引。 了解更多信息：

解决方案2：使用优先级队列。 在优先级队列中，高优先级的元素在低优先级的元素之前被服务

您可以创建一个优先级队列，该队列将根据元素的值比较对象，并弹出前三个。然后根据索引对它们进行排序

检查此问题以了解优先级队列的示例实现：

解决方案#3：混合便携 创建一个类，用两个变量实现可比较的接口：index和value

---

将数组的内容作为对象推送到优先级队列中，其中原始元素值将是队列中元素的优先级。你想放多少就放多少，并把它们列在一个列表中。现在，您可以使用基于原始索引的可比较界面对列表进行排序。因此，比较函数应基于元素的索引进行比较，并返回较低的索引。

使用第n个元素，而不是在值数组中，而是在单独构造的索引数组中。n_元素将顶部（或至少）K个值移动到所有其他值的右侧。n_元素的标准实现不会对整个数组进行排序，并给出O（n）时间复杂度。这正是您所需要的，您可以稍后以完全排序的顺序输出索引，这将使复杂性从O（n）增加到O（n+k.log（k））

这个C++例程也一样。与排序类似，它采用一种自定义方法，根据索引指向的元素的值对索引进行排序，并将前K个索引移动到位置0，…K-1

#include <algorithm>

vector<int> TopKIndices(int k, vector<int32_t>& array) {
  vector<int> indices(array.size());
  int idx = 0;
  std::generate(indices.begin(), indices.end(), [&idx](){ return idx++; });
  if (k >= array.size()) {
    // All the indices are returned.
    return indices;
  }
  auto comp = [&array](const int ia, const int ib){
    return (array[ia] > array[ib]);
  };
  std::nth_element(indices.begin(), indices.begin() + k, indices.end(), comp);
  sort(indices.begin(), indices.begin() + k);
  return vector<int>(indices.begin(), indices.begin() + k);
}


// Test the code.
vector<int32_t> array = {5,7,3,5,3,5,16,9};
vector<int> ind = TopKIndices(3, array);
for (int i : ind) {
  printf("Top index = %d\n", i);
}

#包括
向量TopKIndices（整数k、向量和数组）{
向量索引（array.size（））；
int-idx=0；
std:：generate（index.begin（）、index.end（）、[&idx]（）{return idx++；}）；
如果（k>=array.size（））{
//返回所有索引。
回报指数；
}
自动编译=[&数组]（常量整数ia，常量整数ib）{
返回（数组[ia]>数组[ib]）；
};
std:：n_元素（index.begin（），index.begin（）+k，index.end（），comp）；
排序（index.begin（），index.begin（）+k）；
返回向量（index.begin（），index.begin（）+k）；
}
//测试代码。
向量数组={5,7,3,5,3,5,16,9}；
向量ind=TopKIndices（3，数组）；
for（int i:ind）{
printf（“顶部索引=%d\n”，i）；
}

从一些事情开始怎么样。。。任何东西都可以，然后你可以从那里得到帮助。虽然方法很好，但是C++解决方案对于用java标记的问题可能不是很有用。谢谢你的帮助。我使用了类似于你提到的内容，虽然我不熟悉C++的复杂之处。我的问题附有答案。谢谢，这三种变体都太复杂了，无法找到三个最大的元素。这可以在O（n）中实现。@Henry My UNI总是从这样一个赋值开始，然后他们会抛出一个2000元素的大数组，要求你找到157个最大元素。。。我养成了过分复杂的坏习惯

#include <algorithm>

vector<int> TopKIndices(int k, vector<int32_t>& array) {
  vector<int> indices(array.size());
  int idx = 0;
  std::generate(indices.begin(), indices.end(), [&idx](){ return idx++; });
  if (k >= array.size()) {
    // All the indices are returned.
    return indices;
  }
  auto comp = [&array](const int ia, const int ib){
    return (array[ia] > array[ib]);
  };
  std::nth_element(indices.begin(), indices.begin() + k, indices.end(), comp);
  sort(indices.begin(), indices.begin() + k);
  return vector<int>(indices.begin(), indices.begin() + k);
}


// Test the code.
vector<int32_t> array = {5,7,3,5,3,5,16,9};
vector<int> ind = TopKIndices(3, array);
for (int i : ind) {
  printf("Top index = %d\n", i);
}