Question

我正在使用这种方法：首先找到5个数字中最大的一个，然后在显示最大数字后以“ivariable”保存最大数字的数组的下标，这样做
array[ivariable] = 0 ; 所以第一个设置为零，它不再在数组中。并再次做同样的事情，找到最大的，但我没有得到我想要的东西。这是一个逻辑错误。感谢

#include <iostream>
using namespace std;
int main(void)
{
    int counter, large,number,det_2, i , large3, det_3= 0;
    int det[5] = {0,0,0,0,0};

    for(int k(0); k < 5 ; k++)
    {
        cout << "Enter the number  " << endl ;
        cin >> det[k] ;
    }

    for( i; i<5; i++)
    {
        large = det[i] ;
        if (large > det_2)
        {
            det_2= large ;
            counter = i ;
        }
        else 
        {

        }
    }
    cout << "Largest among all is  " << det_2 << endl;
    det[i] = 0 ;

    for( int j(0); j<5; j++)
    {
        large3 = det[j] ;
        if(large3 > det_3)
        {
            det_3= large3 ;                  
        }
        else 
        {

        }
    }
    cout << "Second largest  " << large3 << endl ;

    system("PAUSE");
}

Answer 1

在使用之前始终提供变量值

det_2 = det[0];
counter = 0;
for (i = 1; i < 5; i++)

Answer 2

您可能遇到语法和初始化错误。先解决这些问题：

for(int k(0); k < 5 ; k++)：我从未见过以这种方式初始化的整数。不应该是：

for (int k = 0; k < 5; k++)？（与最后一个循环相同。）

此外，

for( i; i<5; i++)

变量i未初始化。变量未初始化为C ++中的任何默认值。因为你没有初始化它，它可能会执行5次，没有次，或25,899次。你不知道。

这应该是：

for (i = 0; i < 5; i++)

但是无论如何整个事情可能会更清楚一些：

#include <iostream>
using namespace std;
int main(void)
{
    int largest = -1;
    int second_largest = -1;

    int index_of_largest = -1;
    int index_of_second_largest = -1;

    int det[5] = {0, 0, 0, 0, 0};

    for (int i = 0; i < 5; i++)
    {
        cout << "Enter the number  " << endl;
        cin >> det[i];  // assuming non-negative integers!
    }

    for (int j = 0; j < 5; j++)  // find the largest
    {
        if (det[j] >= largest)
        {
            largest = det[j];
            index_of_largest = j;
        }
    }

    for (int k = 0; k < 5; k++)  // find the second largest
    {
        if (k != index_of_largest) // skip over the largest one
        {
            if (det[k] >= second_largest)
            {
                second_largest = det[k];
                index_of_second_largest = k;
            }
        }
    }

    cout << "Largest is " << largest << " at index " << index_of_largest << endl;
    cout << "Second largest is " << second_largest <<
            " at index " << index_of_second_largest << endl;

return 0;
}

Answer 3

我看到的第一个问题是你使用i作为索引进行迭代，但你没有初始化i。

代码应该是：

    for(i = 0; i<5; i++)
         ^^^^

同样适用于det_2。您将元素与它进行比较，但不进行初始化。您应该在使用它的循环之前将其设置为det[0]。
第三个问题：您的“打印后将最大值设置为零”听起来就像是在那里，以便您可以第二次应用相同的算法。

你应该创建一个额外的函数，为你提供最大元素的索引，并像这样调用它：

int index = find_largest_index(a);
cout << "largest element: " << a[index] << endl;
a[index] = 0;
cout << "second largest element: " << a[ find_largest_index(a) ] << endl;

Answer 4

GCC 4.7.3：g ++ -Wall -Wextra -std = c ++ 0x largest.cpp

#include <algorithm>
#include <iostream>
#include <iterator>
#include <vector>

int main() {
  std::cout << "Enter 5 numbers: ";

  // Read 5 numbers.
  std::vector<int> v;
  for (auto i = 0; i < 5; ++i) {
    int x = 0;
    while (!(std::cin >> x)) {
      // Error. Reset and try again.
      std::cin.clear();
      std::cin.ignore();
    }
    v.push_back(x);
  }

  // partition on element 3 (4th number)
  std::nth_element(std::begin(v), std::next(std::begin(v), 3), std::end(v));

  std::cout << "Two largest are: ";
  std::copy(std::next(std::begin(v), 3), std::end(v), std::ostream_iterator<int>(std::cout, " "));
}

Answer 5

在5个元素的特定情况下，您使用的算法不太可能产生任何真正的差异。

也就是说，专门为此类工作设计的标准算法是std::nth_element。

它允许您找到（或“an”，如果有重复）元素，如果您要对整个集合进行排序，它们将最终位于位置N上。

从名字中可以看出这一点很明显。什么不那么明显（但仍然是必需的）是nth_element也将元素排列成两个（或三个，取决于你如何看待它）组：在该元素之前缩短的元素，元素本身，以及在该元素之后排序的元素。虽然元素没有在每个组中排序，但是它们被排列在那些组中 - 即，在它放在它之前将排序的所有元素，然后是元素本身，然后是在它之后排序的元素。

这正是你想要的 - 你提供的5个^th和5个^th元素。

正如我原先所说的那样，在仅有5个元素的情况下，它并不重要 - 但如果你想要（比如说）千万分之一的前50000，那么选择正确的算法会产生更大的差异。

Answer 6

nth_element并不总是适合（或尽可能高效），因为它需要重新排列输入元素。

只需要顶部的两个元素是很常见的，并且可以通过保持到目前为止所看到的最佳值和次佳值有效地完成一次操作，并且只要您迭代的值比次优值好，您可以将其替换为第二好的或最好的，在后一种情况下，您还可以用新值覆盖最好的。看起来可能像这样：

#include <utility>

template <typename It, typename EndIt, typename Less = std::less<>>
auto top_two(It it, EndIt end, Less less = Less{}) -> std::pair<It, It>
{
    It first = it;
    if (it == end || ++it == end)
        return {first, end};
    std::pair<It, It> results = less(*it, *first) ? std::pair{first, it} : std::pair{it, first};
    while (++it != end)
        if (less(*results.second, *it))
            results.second = less(*results.first, *it)
                             ? std::exchange(results.first, it) : it;
    return results;
}

（看到它在http://coliru.stacked-crooked.com/a/a7fa0c9f1945b3fe上运行）

我返回迭代器，以便调用者可以知道输入中最重要的两个元素在什么位置（例如，从容器中删除它们，或计算它们与begin（）的距离，或修改它们的值）。

您想要两个最低值，只需将std::greater<>{}作为您的“较少”参数即可。

一些便捷功能使使用容器或initializer_list的调用变得更容易：

template <typename Container, typename Less = std::less<>>
auto top_two(const Container& c, Less less = Less{})
{
    return top_two(begin(c), end(c), less);
}

template <typename T, typename Less = std::less<>>
auto top_two(const std::initializer_list<T>& il, Less less = Less{})
{
    return top_two(begin(il), end(il), less);
}

如果要为前N个元素提供一般解决方案，最好将N用作参数并创建N个顶部值的多集（使用解引用比较类型），将初始N个元素放入其中，然后每当新元素大于**top_n.begin()的值，请执行top_n.insert(it);后跟top_n.erase(top_n.rbegin());来删除最差的元素：这些运算为O（log N），因此即使在病理情况下也保持合理的效率，例如作为递增数字的输入。

找到两个最大的数字，C ++

6 个答案: