Question

我有两个包含数据的数据结构。

一个是向量std::vector<int> presentStudents，另一个是
char数组char cAllowedStudents[256];

现在我必须比较这两个，以便检查vector中的每个元素与array，以便向量中的所有元素都应该出现在数组中，否则我将返回{{1}如果向量中有一个元素不属于数组。

我想知道最有效和最简单的解决方案。我可以将false转换为int vector，然后逐个进行比较，但这将是一个漫长的操作。有没有更好的方法来实现这一目标？

Answer 1

我建议您使用哈希映射（std::unordered_map）。将char数组的所有元素存储在哈希映射中。

然后简单地按顺序检查向量中的每个元素是否存在于地图中或不存在于O（1）中。

Total time complexity O(N), extra space complexity O(N).

请注意，您必须在编译器中启用C ++ 11。

Answer 2

请参考c ++算法头文件中的函数set_difference（）。您可以直接使用此功能，并检查结果差异设置是否为空。如果不为空则返回false。

更好的解决方案是调整set_difference（）的实现，就像在这里：http://en.cppreference.com/w/cpp/algorithm/set_difference一样，在得到第一个不同元素后立即返回false。

示例适应：

while (first1 != last1)
{
    if (first2 == last2) 
        return false;

    if (*first1 < *first2)
    {
        return false;
    }
    else
    {
        if (*first2 == *first1)
        {
            ++first1;
        }
        ++first2;
    }
}
return true;

Answer 3

使用std :: sort对两个列表进行排序，并在数组上使用std :: find迭代。

编辑：诀窍是使用先前找到的位置作为下一次搜索的开始。

std::sort(begin(pS),end(pS))
std::sort(begin(aS),end(aS))

auto its=begin(aS);
auto ite=end(aS);

for (auto s:pS) {
    its=std::find(its,ite,s);
    if (its == ite) {
        std::cout << "Student not allowed" << std::cout;
        break;
    }
}

编辑：正如传说所提到的，使用二分搜索通常可能更有效（如R Sahu的回答）。但是，对于小数组，如果向量包含来自数组的大部分学生（我说至少十分之一），二进制搜索的额外开销可能（或可能不）超过其渐近复杂性的好处。 / p>

Answer 4

使用cAllowedstudents排序std::sort。
对presentStudents进行迭代，并使用cAllowedStudents查找已排序的std::binary_search中的每位学生。
如果找不到向量的项目，则返回false。
如果找到了矢量的所有元素，则返回true。

这是一个功能：

bool check()
{
   // Assuming hou have access to cAllowedStudents
   // and presentStudents from the function.

   char* cend = cAllowedStudents+256;
   std::sort(cAllowedStudents, cend);

   std::vector<int>::iterator iter = presentStudents.begin();
   std::vector<int>::iterator end = presentStudents.end();
   for ( ; iter != end; ++iter )
   {
      if ( !(std::binary_search(cAllowedStudents, cend, *iter)) )
      {
         return false;
      }
   }
   return true;
}

另一种方法，使用std::difference。

bool check()
{
   // Assuming hou have access to cAllowedStudents
   // and presentStudents from the function.

   char* cend = cAllowedStudents+256;
   std::sort(cAllowedStudents, cend);

   std::vector<int> diff;
   std::set_difference(presentStudents.begin(), presentStudents.end(),
                       cAllowedStudents, cend,
                       std::back_inserter(diff));
   return (diff.size() == 0);
}

Answer 5

使用C ++ 11。在你的情况下，size是256.请注意，我个人没有测试过这个，甚至把它放到编译器中。但是，它应该让你知道自己该做什么。我强烈建议用此测试边缘情况！

#include <algorithm>

bool check(const std::vector<int>& studs, 
char* allowed, 
unsigned int size){

    for(auto x : studs){
        if(std::find(allowed, allowed+size-1, x) == allowed+size-1 && x!= *(allowed+size))
            return false;
    }
    return true;
}

将向量中的元素与数组中的元素进行比较

5 个答案: