Question

我有一个dataItems结构的向量，我需要在其中检查唯一元素，条件＆＃39; id＆＃39;即使所有元素（a，b，c）都相同，它们也应该是不同的，那么它是唯一的。每次将一个元素添加到向量后，我需要根据id检查唯一性（除了＆＃39; id＆＃39;所有其他参数可以相同，然后返回true或者返回false）。

#include <iostream>
#include <vector>

struct dataItems
{
    int a, b, c;
    unsigned int id;
};

bool isDataUnique(std::vector<dataItems> &dataList)
{
    bool ret = true;
    for(size_t i = 0; i < dataList.size(); ++i)
    {
        for(size_t j = 0; j < dataList.size(); ++j)
        {
            if(i != j)
            {
                if((dataList.at(i).a == dataList.at(j).a) &&
                    (dataList.at(i).b == dataList.at(j).b) &&
                    (dataList.at(i).a == dataList.at(j).a))
                    {
                        if(dataList.at(i).id == dataList.at(j).id)
                        {
                            ret = false;
                            break;
                        }
                    }
            }
        }
    }
    return ret;
}

 int main()
{
    std::vector<dataItems> v;
    dataItems obj1 = {0}, obj2 = {0};

    obj1.a = obj2.a = 2;
    obj1.b = obj2.b = 3;
    obj1.c = obj2.c = 4;
    //obj1.id = obj2.id = 1; // data is not unique
    obj1.id = 1;
    obj2.id = 2; // as id's are different data is unique

    v.push_back(obj1);
    v.push_back(obj2);

    std::cout << std::boolalpha << isDataUnique(v) << '\n';


    return 0;
}

在c ++ 14中，是否可以进行优化，因为我觉得我的算法没有优化？

Answer 1

你可能会比自己更难对待自己。你有一个结构，你需要创建一个struct的集合，其唯一的约束是每个记录都有一个唯一的ID。其余值可能相同，也可能不相同，出于逻辑目的，与您的代码无关。

在声明你的结构（并创建一个方便的typedef之后，创建一个结构或类来保存和管理你的数据集是有意义的。

如果使用了一个类，您可以简单地声明一个包含数据集合的私有向量，以及一个私有成员函数来检查添加的数据是否包含唯一ID。例如，您可以声明类的结构类和向量，类似于：

class items_t {
    std::vector<dataitems_t> data;
    bool unique (dataitems_t d) {
        for (auto& i : data)
            if (i.id == d.id)
                return false;
        return true;
    }
  public:
    ...

这里的唯一函数检查，在结构保持建议的新数据成为数据集合的一部分之前，ID是否唯一。您可以在adddata成员函数中使用它来检查唯一性。例如，如果要提示输入数据，可以执行以下操作：

    void adddata() {
        dataitems_t tmp;
        std::cout << "enter unique ID for data: ";
        std::cin >> tmp.id;
        if (!unique (tmp)) {
            std::cerr << "error: ID (" << tmp.id << ") is not unique.\n";
        }
        else {
            std::cout << "enter the values for a, b & c: ";
            std::cin >> tmp.a >> tmp.b >> tmp.c;
            data.push_back (tmp);
        }
    }

如果您希望能够在没有用户互动的情况下提交记录，则可以执行以下操作：

    void adddata(unsigned id, int a, int b, int c) {
        dataitems_t tmp = { a, b, c, id };
        if (!unique (tmp)) {
            std::cerr << "error: ID(" << tmp.id << ") is not unique.\n";
        }
        else
            data.push_back (tmp);
    }

这样可以确保只有具有唯一ID的数据才会成为您收藏的一部分。您可以将其与一个类似于以下的简短测试程序完全相同：

#include <iostream>
#include <iomanip>
#include <vector>

typedef struct dataItems {
    int a, b, c;
    unsigned int id;
} dataitems_t;

class items_t {
    std::vector<dataitems_t> data;
    bool unique (dataitems_t d) {
        for (auto& i : data)
            if (i.id == d.id)
                return false;
        return true;
    }
  public:
    void adddata() {
        dataitems_t tmp;
        std::cout << "enter unique ID for data: ";
        std::cin >> tmp.id;
        if (!unique (tmp)) {
            std::cerr << "error: ID (" << tmp.id << ") is not unique.\n";
        }
        else {
            std::cout << "enter the values for a, b & c: ";
            std::cin >> tmp.a >> tmp.b >> tmp.c;
            data.push_back (tmp);
        }
    }
    void adddata(unsigned id, int a, int b, int c) {
        dataitems_t tmp = { a, b, c, id };
        if (!unique (tmp)) {
            std::cerr << "error: ID(" << tmp.id << ") is not unique.\n";
        }
        else
            data.push_back (tmp);
    }
    void prndata() {
        std::cout << "\n" << std::setw(8) << std::left << "ID" <<
                    std::setw(8) << std::right << "A" <<
                    std::setw(8) << std::right << "B" <<
                    std::setw(8) << std::right << "C\n\n";
        for (auto& i : data)
            std::cout << std::setw(8) << std::left << i.id <<
                        std::setw(8) << std::right << i.a <<
                        std::setw(8) << std::right << i.b <<
                        std::setw(8) << std::right << i.c << "\n";
    }
};

int main (void) {

    items_t items;

    items.adddata (0, 20, 23, 41);
    items.adddata (1, 20, 31, 99);
    items.adddata (2, 30, 49, 58);
    items.adddata (3,  1, 27, 18);
    items.adddata ();

    items.prndata();

}

示例使用/输出

$ ./bin/vector_data_unique_id
enter unique ID for data: 22
enter the values for a, b & c: 23 06 90

ID             A       B     C

0             20      23      41
1             20      31      99
2             30      49      58
3              1      27      18
22            23       6      90

现在输入一个非唯一ID的示例：

$ ./bin/vector_data_unique_id
enter unique ID for data: 3
error: ID (3) is not unique.

ID             A       B     C

0             20      23      41
1             20      31      99
2             30      49      58
3              1      27      18

由于ID不是唯一的，因此无需提示输入更多a, b, c值，因为该数据已被立即丢弃。

仔细看看，如果您有任何其他问题，请告诉我。

Answer 2

我可能会遗漏一些东西但是如果你只需要id是唯一的那么为什么要检查所有元素？

    bool isDataUnique(std::vector<dataItems> &dataList)
    {
        for(size_t i = 0; i < dataList.size(); ++i)
        {
            for(size_t j = i+1; j < dataList.size(); ++j)
            {

              if(dataList.at(i).id == dataList.at(j).id)
               {
                    return false; 
                }
            }
         }
         return true;
     }

就效率而言，如果仅在插入项目时检查唯一性，则只需检查要插入的新项目是否不唯一。这可以通过一个for循环在O（n）时间而不是O（n ^ 2）时间完成，就像你在这里一样。如果您对列表进行排序，那么您甚至可以将其减少到O（logn）时间

Answer 3

使用id作为键对列表进行排序，然后在O（N）中仅检查相邻元素的唯一性（或使用std::unique）

 sort(begin(dataList), end(dataList), [](const auto &lhs, const auto &rhs) { return lhs.id < rhs.id });

这对插入效果不佳，现在是O（N）。

或者，您可以将std::set与自定义比较器一起使用，另外还要保留std::vector，从而检查O（N logN）中的重复并插入O（logN）。

struct comparator {
    bool operator()(const dataItems& lhs, const dataItems& rhs) const {
        return lhs.id < rhs.id;
    }
};
std::set<dataItems, comparator> s;

使用向量中的特定条件检查唯一元素

3 个答案: