-2

我正在使用这种方法：首先找到5个数字中的最大值，然后在显示最大数字后将最大数字数组的下标保存在“变量”中，这样​​做是
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");
}
4

6 回答 6

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;
}
于 2013-10-03T14:59:10.580 回答
1

始终在使用变量之前给出变量值

det_2 = det[0];
counter = 0;
for (i = 1; i < 5; i++)
于 2013-10-03T14:38:06.473 回答
0

GCC 4.7.3：g++ -Wall -Wextra -std=c++0x 最大.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, " "));
}
于 2013-10-03T15:06:07.367 回答
0

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

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

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

这从名字上就很明显了。不那么明显（但仍然需要）的是，它nth_element还将元素排列成两个（或三个，取决于你如何看待它）组：在该元素之前短的元素、元素本身以及将在该元素之后排序。尽管元素没有在每个组内排序，但它们被排列到这些组中 - 即，将在它之前排序的所有元素放在它之前，然后是元素本身，然后是在它之后排序的元素。

这正是你想要的——你提供的 5 中的第 4和第5个元素。

正如我最初所说，在只有 5 个元素的情况下，这并不重要——但如果你想要（比如说）一千万中的前 50000 个，选择正确的算法会产生更大的差异。

于 2013-10-03T15:22:08.107 回答
0
  • 我看到的第一个问题是您正在使用 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;
于 2013-10-03T14:57:40.997 回答
0

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_lists 调用：

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()比值，然后执行 a以top_n.insert(it);删除top_n.erase(top_n.rbegin());最差的元素：这些操作是 O(log N)，因此即使在病态情况下（例如递增数字的输入）也保持合理的效率。

于 2020-06-05T23:42:52.463 回答