搜索和排序数组答案

【问题标题】：Searching and sorting arrays搜索和排序数组
【发布时间】：2015-12-11 12:52:04
【问题描述】：

我正在学习入门级 C++ 课程。我必须编写一个布尔函数来检查向量中的重复项，如果没有重复项，则返回 true 和 false

#include<iostream>
#include<vector>
using namespace std;
bool has_duplicates(const vector <int> &v);


int main() {

    vector<int> Vec(8);
    Vec = { 20, 30, 40, 50, 10, 20, 5, 6 };
    has_duplicates(Vec);
    return 0;
}
bool has_duplicates(const vector<int>& v) {
    bool duplicatefound = false;
    for (int i = 0; i < 8; i++) { // Check each other number in the array
        for (int j = i; j < 8; j++) { // Check the rest of the numbers 
            while (j != i) {// Makes sure don't check number against itself 
                if (v[i] == v[j]) {
                    cout << "duplicate found" << endl;
                    duplicatefound = true;
                    break;
                }
            }
        }
    }
    return duplicatefound; // Reset the boolean after each number entered has been checked
}

【问题讨论】：

你能告诉我你尝试过的事情吗？我们想帮助你。但我们不是从 0 开始。分享你的想法。
Stack Overflow 是一个问答网站。您的Q问题是什么？
首先开始创建一个包含一些重复值的数组。然后循环遍历数组。在上一个循环中尝试创建另一个循环，并寻找一种在发现重复值时返回 true 的方法
More elegant way to check for duplicates in C++ array?的可能重复
你有一个问题（减去语法错误）你允许 i 等于 j 在下面的 if (v[i] == v[j]) { 这将使 has_duplicates 总是返回 true。

标签： c++

【解决方案1】：

您的问题有一个非常简单的解决方案：

使用循环遍历您的数组： for(int i=0; i < array_length; i++)
在这个循环中，利用另一个循环来检查i指向的值之前的任何值是否等于your_array[i]。如果是这种情况，您可以找到重复项并且可以return true，否则循环将一直运行直到到达数组末尾，然后您可以return false。因此，您的整个功能将类似于：
```
bool contains_duplicates(int array[], int len) {
    for(int i=0; i < len; i++) {
        for(int j=0; j < i; j++) {
            if(array[j]==array[i]) {
                return true;
            }
        }
    }

    return false;
}
```

希望我能帮上忙，干杯！
林德熊

【讨论】：

对不起，这是我第一次使用堆栈流，所以我不知道如何很好地复制我的代码，但我的看起来几乎和你的一样，只是 bool duplicate _found false 。我会尝试并回复你
对不起，我只是想出了一个更好的解决方案！再次检查这里！
顺便说一句。如果您能发布到目前为止提出的解决方案，这将有很大帮助。
刚刚在 microsoft visual 上运行时出现两个错误
我刚刚从上面测试了我的函数，对我来说它似乎正在工作......但是我使用的是数组，而不是 std::vectors...... ;)

【解决方案2】：

您可以像这样使用模板来扩展 vector 中包含的类型。此解决方案将算法复杂度降低到 O(n log n)，这比嵌套循环中的 O(n^2) 更好，这并不意味着它总是会更快，但它对大向量有影响。

template< typename T>
bool hasDuplicates(std::vector<T> vect) {
    std::sort(vect.begin(), vect.end());
    T last;
    typename vector<T>::iterator it;
    for(it = vect.begin(); it < vect.end(); it++) {
        if (vect.begin() != it) {
            if(last == *it) {
                return true;
            }
        }
        last = *it;
    }
    return false;
}

【讨论】：

我不熟悉模板？
它可以帮助您在某些情况下忘记类型，例如，您可以拥有整数、双精度等向量。