获取两个最大值的索引

Question

I got an array like myArray[4] = { 10, 3, -5, 30 }; and I'D like to get the indexes of it's two elements with the biggest value (element in this case 30, 10 ) and the indexe of 30 is 3 while the index of 10 is 0 (zero based of course) .

So the result should be {3, 0} because the index of the biggest element (30.0) is 3 and the index of the second biggest element (10.0) is 0.

---

How to implement a easy working solution for the problem?

double myArray[4] = { 10, 3, -5, 30 };
double biggestElement_1 = *std::max_element(std::begin(myArray), std::end(myArray));
int biggestElement_1_indx = find(std::begin(myArray), std::end(myArray), biggestElement_1) - std::begin(myArray);
cout << biggestElement_1_indx << endl;

// How to go on to find the second biggest element ?

Note : I'm obviously new to C++ so sorry for the (stupid) beginner question - however: Any help would be very appreciated. :)

Answer 1

You cannot find the indexes of the two largest values easily with the <algoritm> 's functions (unless of course you're OK with altering the array). You'd better roll your own.

template <class InputIt>
auto two_biggest(InputIt begin, InputIt end)
{
    auto result = std::make_tuple(0, 0);
    // iter in [begin; end) and save result.get<0> and result.get<1>
    // let as an exercise (it's an exercise, right?)
    return result;
}

You then will be able to call it with:

auto t = two_biggest(std::begin(arr), std::end(arr));

or better yet, with C++17 tuple unpacking:

[largest, second_largest] = two_biggest(std::begin(arr), std::end(arr));

Or for pre-C++17:

int largest, second_largest;
std::tie(largest, second_largest) = two_biggest(std::begin(arr), std::end(arr));

Answer 2

You can use vector of pairs to save your array with their index, then sort them based on the value, and return the biggest values as you want, like this

#include <iostream>
#include <vector>
#include<algorithm>
using namespace std;
int main() {
  double myArray[4] = { 10, 3, -5, 30 };
  vector<pair<double, double > >vec;
  for(int i=0;i<4;i++){
    vec.push_back(make_pair(myArray[i],i));
  }

  sort(vec.begin(), vec.end());

  for(int i=0;i<vec.size();i++){
    cout<<vec[i].first<<" "<<vec[i].second<<endl;
  }

  cout<< vec[vec.size()-1].second<< ", "<<vec[vec.size()-2].second;
}

Answer 3

It's easy to find the largest value in the array: just scan through it, and keep track of the largest value that you've seen so far. When you reach the end, that's the largest value.

Finding the second largest value is just as simple: when you do the scan for the largest value, if you find a value that's larger than the largest value you've seen so far, that's the new largest value, and the largest value that you've seen so far is now the second largest value.

In code:

std::pair<int, int> get_two_largest(int* ptr, int size) {
int largest = std::numeric_limits<int>::min();
int second_largest;
for (int i = 0; i < size; ++i)
    if (largest <= ptr[size]) {
        second_largest = largest;
        largest = ptr[size];
    }
return std::pair<int, int>(largest, second_largest);
}

I used <= for the comparison because with plain < (which is what I would use to find the largest value), the function would return a bad result for an array with all equal values.