Question

嗨，有男人和女孩，

我已经创建了一个函数，可以检查两个不同数组中是否存在相同的数字，如果数组中有重复的数字并不重要。

这是我的功能：

bool sameSet(int arrA[], int arrB[], int sizeA, int sizeB) {
  int temp;
  if (sizeA < sizeB) {
    for (int i = 0; i < sizeA; i++) {
      bool exist = false;

      for (int j = 0; j < sizeB; j++) {
        if (arrA[i] == arrB[j]) {
          exist = true;
          break;
        }  // end of if
      }    // end of second for loop

      if (!exist) return false;

    }  // end of first loop

    return true;
  }

  else {
    temp = sizeA;
    sizeA = sizeB;
    sizeB = temp;

    // cout << "\nSize A is " << sizeA << " Size B is " << sizeB;

    for (int i = 0; i < sizeA; i++) {
      bool exist = false;

      for (int j = 0; j < sizeB; j++) {
        if (arrA[i] == arrB[j]) {
          exist = true;
          break;
        }  // end of if

      }  // end of second for loop

      if (!exist) return false;

    }  // end of first loop

    return true;
  }
}

在我的主要内容中，我目前只是硬编码，因为我目前所需要的只是功能。所以在主要看起来像：

int sizea = 10, sizeb = 15;
int a[] = {1, 3, 9, 16, 2, 5, 5, 5, 1, 16};
int b[] = {3, 9, 16, 9, 16, 16, 1, 1, 3, 2, 2, 5, 4, 16, 3};
cout << "The elements of the arrays a and b ";
if (!sameSet(a, b, sizea, sizeb)) {
  cout << "do not ";
}
cout << "form the same set.";

但是你会假设，因为数组b中的数字4不存在于数组a中，它将返回“do not for the same set”，但相反令人沮丧的是它没有。我得到"does form the same set"。我相信这与我在函数中的if语句有关，但我不确定如何解决这个问题。

由于

Answer 1

如果从固定数组更改为容器，则可以利用标准算法库例程，即include或set_intersection的设置函数。

#include <iostream>
#include <vector>
#include <algorithm>
#include <iterator>
int main()
{
    std::vector<int> v1{1,2,3,4,5,6,7,8};
    std::vector<int> v2{        5,  7,  9,10};
    std::vector<int> v3{  2,    5,  7};
    std::sort(v1.begin(), v1.end());
    std::sort(v2.begin(), v2.end());
    std::sort(v3.begin(), v3.end());

    std::vector<int> v_intersection;
    std::vector<int> v_includes;

    std::set_intersection(v1.begin(), v1.end(),
                          v2.begin(), v2.end(),
                          std::back_inserter(v_intersection));

    for(int n : v_intersection)
        std::cout << n << ' ';
    std::cout << "\n";    
    std::cout << std::boolalpha << std::includes(v1.begin(), v1.end(),
                          v3.begin(), v3.end());
}

Answer 2

使用std，你可以简单地写一下：

bool isSameSet(const int arrA[], const int arrB[], int sizeA, int sizeB)
{
    const std::set<int> setA{arrA, arrA + sizeA};
    const std::set<int> setB{arrB, arrB + sizeB};

    return setA == setB;
}

Answer 3

您使用的逻辑存在缺陷。

我们说sizeA小于sizeB。您拥有的代码会检查a中的每个元素是否都在b中。它不会检查b中的每个元素是否都在a中。从本质上讲，您要检查a是b的子集，而不是a和b是否相等。

您需要的是：

bool sameSet(int arrA[], int arrB[], int sizeA, int sizeB)
{
   // Check whether every element of A is in B
   for(int i=0; i<sizeA; i++){
      bool exist = false;

      for(int j=0; j<sizeB; j++){
         if(arrA[i] == arrB[j]) {
            exist = true;
            break;
         }
      }

      if (!exist) return false;
   }

   // Check whether every element of B is in A
   for(int i=0; i<sizeB; i++){
      bool exist = false;

      for(int j=0; j<sizeA; j++){
         if(arrB[i] == arrA[j]) {
            exist = true;
            break;
         }
      }

      if (!exist) return false;
   }

   return true;
}

您可以稍微重构一下这个函数，以避免重复逻辑。

// Function to check whether A is a subset of B
bool isSubSet(int arrA[], int arrB[], int sizeA, int sizeB)
{
   // Check whether every element of A is in B
   for(int i=0; i<sizeA; i++){
      bool exist = false;

      for(int j=0; j<sizeB; j++){
         if(arrA[i] == arrB[j]) {
            exist = true;
            break;
         }
      }

      if (!exist) return false;
   }

   return true;
}

// Function to check whether A and B are same sets
bool sameSet(int arrA[], int arrB[], int sizeA, int sizeB)
{
   return ( isSubSet(arrA, arrB, sizeA, sizeB) &&
            isSubSet(arrB, arrA, sizeB, sizeA) );
}

Answer 4

到目前为止，所有解决方案似乎都具有O（N ^ 2）时间复杂度;您可以使用地图在 O（N * logN）时间内完成此操作：

bool sameSet(int arrA[], int arrB[], int sizeA, int sizeB) 
{
   std::map<int,bool> mapA;
   std::map<int,bool> mapB;

   for (int i=0; i<sizeA; i++)
   {
      mapA[arrA[i]] = true;   
   } 

   for (int i=0; i<sizeB; i++)
   {
      mapB[arrB[i]] = true;
   }

   if (mapA.size() != mapB.size())
      return false;

   std:map<int,bool>::const_iterator i, j;
   for(i = mapA.begin(), j = mapB.begin(); i != mapA.end(); ++i, ++j)
   {
     if(*i != *j)
       return false;
   }

   return true;
}

如果您使用unordered_map（其余逻辑保持不变），您甚至可以在 O（N）时间复杂度中执行此操作。

检查两个数组是否相同的函数

4 个答案: