查找数组中的最小值

Question

我有两个数组：

int playerSums[9] = { };
string playerNames[9] = { };

我试图获取数组中的最小值playerSums以及该值的数组索引。

到目前为止，这是我尝试过的：

if (playerNames[index] == "End" || playerNames[index] == "end") {
    int lowestValue = playerSums[0];
    for (i = 1; i < sizeof(playerSums) / sizeof(playerSums[0]); i++) {
        if (playerSums[i] < lowestValue || lowestValue != 0)
            lowestValue = playerSums[i]; 
    }
    cout << index[playerNames] << " had the lowest values and got the sum ";
    cout << lowestValue << endl;
}

playerSums例如，如果只有 3 个玩家在玩，即仅填充了数组的 3 个元素（其余元素等于 0），如何查找并显示数组中的最小值？

我需要索引来显示获得最小值的玩家的姓名。

Answer 1

您可以使用std::min_element标头中声明的标准算法<algorithm>来查找具有最小和的元素。例如

#include <algorithm>

int *min = std::min_element( playerSums, playerSums + 3 );

std::cout <<  playerNames[min - playerSums] 
          << " had the lowest values and got the sum " << *min
          << std::endl;

可以使用标准函数编写相同的内容std::begin，std::end并std::distance在标头中声明<iterator>

#include <algorithm>
#include <iterator>

int *min = std::min_element( std::begin( playerSums ), std::end( playerSums ) );

std::cout <<  playerNames[ std::distance( playerSums, min )] 
          << " had the lowest values and got the sum " << *min
          << std::endl;

您可以编写类似于该算法的自己的函数，而不是使用该算法。例如

size_t min_sum( const int playerSums[], size_t n )
{
   size_t min = 0;

   for ( size_t i = 1; i < n; i++ )
   {
      if ( playerSums[min] < playerSums[i] ) min = i;
   }

   return min;
}

size_t min = min_sum( playerSums, sizeof( playerSums ) / sizeof( *playerSums )  );

std::cout <<  playerNames[min] 
          << " had the lowest values and got the sum " << playerSums[min]
          << std::endl;

如果您需要跳过数组中等于零的元素，那么该函数将如下所示

size_t min_sum( const int playerSums[], size_t n )
{
   size_t min = 0;

   while ( min < n && playerSums[i] == 0 ) ++min;

   for ( size_t i = min; i < n; i++ )
   {
      if ( playerSums[min] < playerSums[i] ) min = i;
   }

   return min;
}

size_t min = min_sum( playerSums, sizeof( playerSums ) / sizeof( *playerSums )  );

if ( min != sizeof( playerSums ) / sizeof( *playerSums ) )
{   
    std::cout <<  playerNames[min] 
              << " had the lowest values and got the sum " << playerSums[min]
              << std::endl;
}

Answer 2

像往常一样，最简单的解决方案是使用标准库，例如

auto it = std::min_element(std::begin(playerSums), std::end(playerSums));
std::size_t index = std::distance(std::begin(playerSums), it);

现在您可以通过取消引用迭代器来获取最小值it：

int lowestValue = *it;

如果您只想迭代数组中的前 3 个元素，那么您可以这样做：

auto first = std::begin(playerSums);
auto it = std::min_element(first, std::next(first, 3));
std::size_t index = std::distance(first, it);

注意：更喜欢std::next而不是普通的指针算术（例如playerSums + 3），因为它更通用（适用于所有迭代器类型）。