查找阵列

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元数组被填充（并且其余的元素等于零）？

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

Answer 1

您可以使用标准算法std::min_element在头<algorithm>宣称找到元素WITN最小总和。例如

#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(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(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

你知道你分配给lowestValue当您更改该变量的值的元素的索引，所以只保存指数的变量（比如，index），这样，当你完成index拥有的最后一个值的索引分配。

Answer 3

首先调整你的循环条件。我不确定你以前是否定义过我，所以你可能忘记了。第二个停止条件是sizeof（palyerSums）就足够了。你也只需要存储数组中最低的playerSums的索引。 if条件也有太多的东西。如果最低值不为零，您将始终更改该值，除非最低值恰好为零，否则这看起来不正确。

int lowestValue = playerSums[0]; 
int resultIndex = 0; 
for(int i = 1; i < sizeof(playerSums)/sizeof(playerSums[0]); i++) { 
    if(playerSums[i] < lowestValue) { 
    lowestValue = playerSums[i]; 
    resultIndex = i; 
    } 
} 
cout << playerNames[resultIndex] << "blabla" << lowestValue; // instead of lowestValue you could also do playerSums[resultIndex] ofcourse. 

让我知道是否可行

Answer 4

您存储lowestValue值最低的同样的方式，存储索引在一个变量中，比方说，lowestValueIndex。此外，删除外，如果和移动它内部的for循环：

if(playerNames[i] == "End" || playerNames[i] == "end") 
    break; 

这样，您将确保只有谁在玩的玩家将被处理。此外，您不需要检查最低值是否为零。因此，代码会看起来像：

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

正如一个音符，使用可以长到简化这个（如vector）的标准数组：

std::vector<std::string> playerNames; 
std::vector<int> playerSums; 

for (int i = 1; i < playerSums.size(); ++i) 
{ 
    if (playerSums[i] < lowestValue) 
    { 
      lowestValue = playerSums[i]; 
      lowestValueIndex = i; 
    } 
} 
cout << index[playerNames] << " had the lowest values and got the sum " 
    << lowestValue << endl; 

Answer 5

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

int lowestValue = *it; 

如果只想遍历数组中的第3个元素，那么你可以做这样的事情：

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

现在，您可以通过提领该迭代it得到最小值而不是：

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），因为它更通用（适用于所有迭代器类型）。