C++ 第三大未分类区域

我正在上一堂编程入门课，试图在一组圆圈中找到第三大区域，然后返回该圆圈所在位置的索引，无需排序，但遇到了一些问题

输入

预期产量

2

实际产量

4

如果我错了，请更正，但我认为我为

最大值

、

第二大值

和

第三大值

分配了错误的值？为什么它返回

4

？这是我目前所拥有的，谢谢你的帮助^_^

int getThirdLargestArea(Circle** arr, int size) {
    Circle largest = *arr[0];
    Circle secondlargest = *arr[size - 1];
    Circle thirdlargest = secondlargest;

    int index = 0;

    for (int i = 1; i < size; i++) {
        if (largest.getArea() > arr[i]->getArea()) {
            thirdlargest = secondlargest;
            secondlargest = largest;
            largest = *arr[i];
            index = i;
        }

        else if (secondlargest.getArea() > arr[i]->getArea()) {
            thirdlargest = secondlargest;
            secondlargest = *arr[i];
            index = i;

        }

        else if (thirdlargest.getArea() > arr[i]->getArea()) {
            thirdlargest = *arr[i];
            index = i;
        }
    }

    return index;
}

int-getThirdLargestArea（圆**arr，int-size）{
最大圆=*arr[0]；
第二大圆圈=*arr[size-1]；
第三大圆圈=第二大圆圈；
int指数=0；
对于（int i=1；iarr[i]->getArea（））{
第三大=第二大；
第二大=最大；
最大=*arr[i]；
指数=i；
}
else if（第二大.getArea（）>arr[i]->getArea（））{
第三大=第二大；
第二大=*arr[i]；
指数=i；
}
else if（thirdlargest.getArea（）>arr[i]->getArea（））{
第三大=*arr[i]；
指数=i；
}
}
收益指数；
}

首先，您应该在代码中的三个位置将>替换为<。例如，这里：

if（最大的.getArea（）>arr[i]->getArea（））

如果第i个元素的面积大于当前最大面积，则应输入

if

block。此外，您应该记住第一、第二和第三个圆的索引，而不是圆本身。您总是使用

i

值更新

index

，但它仅在最后一个

else

块中正确。如果记住的是索引而不是圆，则返回

thirdLargestIdx

您还应该注意最大、第二大和第三大变量的初始值。你不应该假设你选择的圆的大小有任何特定的顺序

---

为了完整性，有一种O（n）算法可以找到数组中第k个最大的元素：

请选择标准容器，而不是传统的C数组和指针算法。在合理的情况下，也尽量使用标准算法

auto getThirdLargestArea(const std::vector<Circle>& circles) -> int {
  // this will hold the three largest circles known
  auto largest = std::vector<std::pair<int, const Circle*>>{};

  // iterate over all circles
  for(size_t i = 0; i < circles.size(); ++i) {
    // add the current index and circle to the largest list
    largest.insert(std::find_if(std::begin(largest), std::end(largest),
                                [&](const std::pair<int, const Circle*>& c) {
                                  return c.second->getArea() < circles[i].getArea();
                                },
                   std::pair<int, const Circle*>{i, &(circles[i])});
    // we are only interested in the three largest, so drop the rest.
    largest.resize(std::min(largest.size(), 3));
  }

  if(largest.size() < 3)
    // there were less than 3 circles -> signal an error
    return -1;

  // now we can simply read the third largest from your vector
  return largest[2].first;
}

auto-getThirdLargestArea（const std:：vector&circles）->int{
//这将保持已知的三个最大圆圈
自动最大=标准：：向量{}；
//周而复始
对于（大小i=0；igetArea（）发出错误信号
返回-1；
//现在我们可以简单地从向量中读取第三个最大值
返回最大[2]。第一；
}

我使用指针来防止复制圆。因为

最大的

从不拥有圆，所以此代码中的任何地方都没有泄漏。因为

最大的

中的指针总是指向常量向量

圆

，指针不能在任何地方晃来晃去

---

注意：此答案中的代码需要C++11功能，并且未经测试。因此，它可能包含一些错误。

这些初始化不正确：

Circle largest = *arr[0];
Circle secondlargest = *arr[size - 1];
Circle thirdlargest = secondlargest;

他们假设了一些通常不正确的条件：第一个元素比最后一个元素大（在您的测试用例中为true，通常为false），并且有一个额外的元素等于最后一个元素（非常不合理）

您应该将

最大值

、

第二大值

和

第三大值

初始化为前3个元素，并正确排序：

largest_idx = 0;
secondlargest_idx = 1;
thirdlargest_idx = 2;

// bubble-sort of an array of 3 elements:
// swap 0 <-> 1 if needed
// swap 1 <-> 2 if needed
// swap 0 <-> 1 if needed
if (arr[largest_idx]->getArea() < arr[secondlargest_idx]->getArea())
    std::swap(largest_idx, secondlargest_idx);
if (arr[secondlargest_idx]->getArea() < arr[thirdlargest_idx]->getArea())
    std::swap(secondlargest_idx, thirdlargest_idx);
if (arr[largest_idx]->getArea() < arr[secondlargest_idx]->getArea())
    std::swap(largest_idx, secondlargest_idx);

max\u idx=0；
第二大_idx=1；
第三大_idx=2；
//气泡排序是由3个元素组成的数组：
//如果需要，交换0 1
//如果需要，交换12个
//如果需要，交换0 1
如果（arr[maximust\u idx]->getArea（）getArea（））
标准：：交换（最大的idx，第二大的idx）；
如果（arr[secondmagnist_idx]->getArea（）getArea（））
标准：交换（第二大idx，第三大idx）；
如果（arr[maximust\u idx]->getArea（）getArea（））
标准：：交换（最大的idx，第二大的idx）；

这里我使用索引而不是对象，因为函数必须计算索引，而不是返回对象

然后从第四个元素开始检查元素（第一个尚未检查的元素）：

for（int i=3；i

---

检查一个对象两次是不正确的，因为例如，第二大元素重复两次会使您忘记第三大元素。

查看每个if语句。例如：

max.getArea（）>arr[i]->getArea（）

。如果最大面积大于或小于，你真的想在块中做你正在做的事情吗？whipser不，你不想。只需更改你的条件。此外，我建议将

第二个最大的

和

第三个最大的

圆初始化为没有面积的圆或与最大的相同的圆，而不是最后一个圈，谁知道，如果最后一个圈比第一个大，为什么不使用实际的C++，做呢？或者我不得不说-伟大的问题结构，特别是考虑到它是家庭作业相关的。谢谢你没有给我的O（n）的极小k张贴一个“GIV-MDA代码！！”算法比简单的方法慢得多。对于K来说，3是一个非常小的选择。正确完成简单的方法是

n log K

。当K是问题定义的一部分，而不是输入之一时，则

largest_idx = 0;
secondlargest_idx = 1;
thirdlargest_idx = 2;

// bubble-sort of an array of 3 elements:
// swap 0 <-> 1 if needed
// swap 1 <-> 2 if needed
// swap 0 <-> 1 if needed
if (arr[largest_idx]->getArea() < arr[secondlargest_idx]->getArea())
    std::swap(largest_idx, secondlargest_idx);
if (arr[secondlargest_idx]->getArea() < arr[thirdlargest_idx]->getArea())
    std::swap(secondlargest_idx, thirdlargest_idx);
if (arr[largest_idx]->getArea() < arr[secondlargest_idx]->getArea())
    std::swap(largest_idx, secondlargest_idx);

for (int i = 3; i < size; i++) {
    ...
}