Question

我有一个给定的数组，我需要确定如何找到它中的重复数。我必须使用嵌套for循环来执行此操作，并且不能使用向量。到目前为止，我已经尝试了3次，但答案应该是2，因为只有数字4和7重复。我知道为什么我得到3，因为它检查4次，但我似乎无法弄清楚如何调整它所以它一旦找到匹配就再也不会检查4。

#include <iostream>
using namespace std;

int main() {
    const int num_elements = 12;
    int numbers[num_elements] = { 2, 6, 7, 4, 5, 4, 1, 8, 9, 0, 7, 4 };

    unsigned int numduplicates = 0;    
    for(int i = 0; i < num_elements; ++i){
        int oneCounterMax = 0;
        for(int j = i + 1; j < num_elements; ++j) {
            if((numbers[i] == numbers[j]) && (oneCounterMax < 1)) {
                ++numduplicates;
                ++oneCounterMax;
            }       

        }
    }       
    cout << numduplicates << endl;
}

Answer 1

你找到3，因为你没有检查当前的数字是否已经算作重复：前4个，你找到重复，第二个也是。您必须检查当前数字是否不在数组的开头。如果是，它已被计为重复，因此无需继续，您可以传递到下一个数字

int main() {
    const int num_elements = 12;
    int numbers[num_elements] = { 2, 6, 7, 4, 5, 4, 1, 8, 9, 0, 7, 4 };


    for(int i = 0; i < num_elements; ++i){
        int oneCounterMax = 0;  
        bool notAlreadyCheck = true;  

        for(int j = 0; j < i-1; ++j) {
            if (numbers[i] == numbers[j]){
                notAlreadyCheck = false;
            }
        }
        if (notAlreadyCheck) {    
            for(int j = i + 1; j < num_elements; ++j) {
                if((numbers[i] == numbers[j]) && (oneCounterMax < 1)) {
                    ++numduplicates;
                    ++oneCounterMax;
                }       
            }
        } 
    }       
    cout << numduplicates << endl;
}

Answer 2

最好的方法是使用其他人已经提到的std::vector和std::map。但是，由于您只能使用嵌套循环和数组，这是一个有效的示例：

const int num_elements = 12;
int numbers[num_elements] = { 2, 6, 7, 4, 5, 4, 1, 8, 9, 0, 7, 4 };
int counter = 0;

for ( int i = 0; i < num_elements; i++ ) {
    for ( int j = i + 1; j < num_elements; j++ ) {
        if ( numbers[j] == numbers[i] ) {
            counter++;
            for ( int k = 0; k < i; k++ ) {
                if ( numbers[k] == numbers[j] ) {
                    counter--;
                    break;
                }
            }
            break;
        }
    }
}

cout << counter << endl;

它将打印2而不是3。简单地说，当我们找到重复内容时，我们会返回并检查我们是否已达到此数字。

Answer 3

大多数答案已经足够好了，但是没有从你的解决方案中走得太远，还有一个聪明的伎俩！：

#include <iostream>
using namespace std;

int main() {
    const int num_elements = 12;
    int numbers[num_elements] = { 2, 6, 7, 4, 5, 4, 1, 8, 9, 0, 7, 4 };

    unsigned int numduplicates = 0;
    for (int i = 0; i < num_elements; ++i) {
        int counter = 0; // changed name
        for (int j = i + 1; j < num_elements; ++j) {
            if (numbers[i] == numbers[j]) { // changed condition
                ++counter; // only increment counter
            }
        }

        if (counter == 1) { // added if statement
            ++numduplicates;
        }
    }
    cout << numduplicates << endl;
}

我们不仅要计算其中一个重复项（使用oneCounterMax），而是计算所有重复项。然后我们检查我们计算的数字是否正好为1。

这有两件事：

我们计算了至少1个重复，因此当前数字有重复。但是...
如果我们计算的重复次数超过1次，我们就不会增加重复的计数器，因为它会在我们的迭代中稍后完成，当我们再次计算倒数第二次重复时。

Answer 4

例如，您可以使用地图，其中键是数字[i]，值是数字[i]的出现次数。

std::map<int,int> m;
std::map<int,int>::iterator it;
for(int i = 0; i < num_elements; ++i) {
   const int key = numbers[i];
   int value = 0;
   it = m.find(key)
   if (it != m.end()) {
      ++value;
   }  
   map.insert(std::make_pair(key,value));
}

Answer 5

对数组进行排序后，不计算重复数，而是计算a[i-1] != a[i] && a[i] == a[i+1]的转换次数，这将给出重复元素的数量。你必须保护边界。

Answer 6

首先，您必须对数组进行排序，然后跳过重复的元素并增加 numduplicates

的值

int main() {
    const int num_elements = 12;
    int numbers[num_elements] = { 2, 6, 7, 4, 5, 4, 1, 8, 9, 0, 7, 4 };

    sort(numbers,numbers+12);//sorting
    int  numduplicates = 0;
    for(int i = 0; i < num_elements; ++i){
        if((i+1)<num_elements && numbers[i] == numbers[i+1]) {
            ++numduplicates;
            while((i+1)<num_elements && numbers[i] == numbers[i+1])
               i++;
       }       
    }       
    cout << numduplicates << endl;
}

Answer 7

如果允许对数组进行排序，可以这样写：

std::sort(numbers, numbers + num_elements);

int k = 0;
while (k < num_elements - 1) {
   int i = 1;
   while ((k + i < num_elements) && (numbers[k + i] == numbers[k])) 
      i++;
   if (i > 1)
      ... // numbers[k] is a duplicate with multiplicity i
   k += i;
}

Answer 8

首先对数组进行排序，然后遍历此排序数组。使用bool标志来保存当前状态是否已将此数字计为重复数字。

#include <iostream>
#include <algorithm>
using namespace std;

int main()
{
    const int num_elements = 12;
    int numbers[num_elements] = { 2, 6, 7, 4, 5, 4, 1, 8, 9, 0, 7, 4 };

    std:sort(numbers, numbers+num_elements);
    int duplicate_count = 0;
    bool duplicate = false;
    for(int i = 1; i < num_elements; i++)
    {
        if(numbers[i] != numbers[i-1])
            duplicate = false;
        else if(numbers[i] == numbers[i-1] && !duplicate)
        {
            duplicate_count++;
            duplicate = true;
        }
    }
    cout << "duplicate count: " << duplicate_count << endl;
    return 0;
}

Answer 9

听起来像家庭作业，在这种情况下，即使不使用vector，您的老师也可能对此方法不满意。

给定输入数组：

int numbers[num_elements] = { 2, 6, 7, 4, 5, 4, 1, 8, 9, 0, 7, 4 };

您可以使用set找到数组的唯一大小，因为set：

是一个关联容器，其中包含一组排序为Key的唯一对象

在C ++ 14中，您可以像这样构建set：

const auto numduplicates = num_elements - set<int>(cbegin(numbers), cend(numbers)).size();

Live Example

在C ++ 11中，您可以像这样构建set：

const auto numduplicates = num_elements - set<int>(numbers, next(numbers, num_elements)).size();

在此之前，您可以像这样构建set：

const auto numduplicates = num_elements - set<int>(numbers, numbers + num_elements).size();

Answer 10

排序数组的最简单实现：

#include <iostream>
#include <algorithm>

int main()
{
    int numbers[] = { 2, 6, 7, 4, 5, 4, 1, 8, 9, 0, 7, 4 };

    auto b = std::begin( numbers );
    auto e = std::end( numbers );
    std:sort( b, e );
    auto ne = std::unique( b, e );
    std::cout << "duplicates:" << std::distance( ne, e ) << std::endl;
}

或通过一个循环：

#include <iostream>
#include <algorithm>

int main()
{
    int numbers[] = { 2, 6, 7, 4, 5, 4, 1, 8, 9, 0, 7, 4 };

    auto b = std::begin( numbers );
    auto e = std::end( numbers );
    std:sort( b, e );

    int dups = 0;
    int v = *b++;
    for( auto it = b; it != e; ++it ) {
       if( v != *it ) v = *it;
       else ++dups;
    }
    std::cout << "duplicates:" << dups << std::endl;
}

如何查找数组中的重复项数？

10 个答案: