C++ 如何求两个数组的交集

我有两个整数数组

    int A[] = {2, 4, 3, 5, 6, 7};
    int B[] = {9, 2, 7, 6};

我必须得到这些数组的交集

i、 e.输出为-2,6,7

我想通过将数组A保存在一个数据结构中来解决这个问题，然后我想比较所有元素，直到大小为A或B，然后我将得到交集

现在我有一个问题，我需要首先将数组a的元素存储在一个容器中

我要跟你走吗-

int size = sizeof(A)/sizeof(int);

获取大小，但通过这样做，我将获得大小，然后我希望访问所有元素，并将其存储在容器中

这里是我用来寻找交叉点的代码->

#include"iostream"

using namespace std;


int A[] = {2, 4, 3, 5, 6, 7};
int B[] = {9, 2, 7, 6};

int main()
{
    int sizeA = sizeof(A)/sizeof(int);

    int sizeB = sizeof(B)/sizeof(int);

    int big =  (sizeA > sizeB) ? sizeA : sizeB;

    int small =  (sizeA > sizeB) ? sizeB : sizeA;

    for (int i = 0; i <big ;++i)
    {
        for (int j = 0; j <small ; ++j)
        {
            if(A[i] == B[j])
            {
                cout<<"Element is -->"<<A[i]<<endl;
            }
        }
    }

    return 0;
}

#包括“iostream”
使用名称空间std；
inta[]={2,4,3,5,6,7}；
int B[]={9,2,7,6}；
int main（）
{
int-sizeA=sizeof（A）/sizeof（int）；
int-sizeB=sizeof（B）/sizeof（int）；
int big=（sizeA>sizeB）？sizeA:sizeB；
int small=（sizeA>sizeB）？sizeB:sizeA；
对于（int i=0；i对两个数组进行排序（例如，
qsort（）
），然后一次遍历两个数组中的一个元素

如果存在匹配项，则将其添加到第三个数组中，该数组的大小与两个输入数组中的较大数组相匹配（结果数组不能大于两个数组中的最大数组）。使用负值或其他“伪”值作为终止符

当遍历第一个数组中的一个值大于另一个值的输入数组时，移动第二个数组的索引，反之亦然

完成两个数组的遍历后，第三个数组将得到答案，直到终止符值。
对两个数组进行排序（例如，
qsort（）
），然后一次遍历两个数组中的一个元素

如果存在匹配项，则将其添加到第三个数组中，该数组的大小与两个输入数组中的较大数组相匹配（结果数组不能大于两个数组中的最大数组）。使用负值或其他“伪”值作为终止符

当遍历第一个数组中的一个值大于另一个值的输入数组时，移动第二个数组的索引，反之亦然

完成两个数组的遍历后，第三个数组将得到答案，直到终止符值。
您可以对这两个数组进行排序

sort(A, A+sizeA);
sort(B, B+sizeB);

并使用类似合并的算法查找它们的交点：

#include <vector>

...

std::vector<int> intersection;
int idA=0, idB=0;

while(idA < sizeA && idB < sizeB) {
    if (A[idA] < B[idB]) idA ++;
    else if (B[idB] < A[idA]) idB ++;
    else { // => A[idA] = B[idB], we have a common element
        intersection.push_back(A[idA]);
        idA ++;
        idB ++;
    }
}

#包括
...
向量交；
int idA=0，idB=0；
而（idAA[idA]=B[idB]，我们有一个公共元素
交叉口。推回（A[idA]）；
idA++；
idB++；
}
}

这部分代码的时间复杂度是线性的。但是，由于数组的排序，总体复杂度变为O（n*logn），其中n=max（sizeA，sizeB）

此算法所需的额外内存是最佳的（等于交叉点的大小）。
您可以对两个数组进行排序

sort(A, A+sizeA);
sort(B, B+sizeB);

并使用类似合并的算法查找它们的交点：

#include <vector>

...

std::vector<int> intersection;
int idA=0, idB=0;

while(idA < sizeA && idB < sizeB) {
    if (A[idA] < B[idB]) idA ++;
    else if (B[idB] < A[idA]) idB ++;
    else { // => A[idA] = B[idB], we have a common element
        intersection.push_back(A[idA]);
        idA ++;
        idB ++;
    }
}

#包括
...
向量交；
int idA=0，idB=0；
而（idAA[idA]=B[idB]，我们有一个公共元素
交叉口。推回（A[idA]）；
idA++；
idB++；
}
}

这部分代码的时间复杂度是线性的。但是，由于数组的排序，总体复杂度变为O（n*logn），其中n=max（sizeA，sizeB）

此算法所需的额外内存是最佳的（等于交叉点的大小）

在数据结构中保存数组A

数组是数据结构；不需要将数组保存到一个数组中

我想比较所有的元素，直到大小A或B，然后我会得到交集

这非常模糊，但不可能产生交集；请注意，您必须检查A和B中的每个元素，但“直到大小A或B”将忽略元素

我应该采用什么方法来获取未知大小数组的大小并将其存储在容器中

在C中，不可能处理大小未知的数组，除非它们具有允许计算元素数的数组末端哨兵（如NUL终止的字符数组，在C中通常称为“字符串”）。但是，数组的大小是已知的，因为它们的编译时大小是已知的。您可以使用宏计算此类数组中的元素数：

#define ARRAY_ELEMENT_COUNT(a) (sizeof(a)/sizeof *(a))


int*ptr=新尺寸（A）

[您的问题最初被标记为[C]，我在下面的评论中提到了这一点]

这不是有效的C -<代码>新< /Cord>是C++关键字。
如果您想制作阵列的副本，只需使用，例如

int Acopy[ARRAY_ELEMENT_COUNT(A)];
memcpy(Acopy, A, sizeof A);

或者，如果出于某种原因您想将副本放在堆上

int* pa = malloc(sizeof A);
if (!pa) /* handle out-of-memory */
memcpy(pa, A, sizeof A);
/* After you're done using pa: */
free(pa);

< > > C++中使用<代码>新< /COD>和<代码>删除< /C> > /P>
但是，没有必要为了找到交集而复制数组，除非需要对它们进行排序（请参见下文），但也需要保留原始顺序

有几种方法可以找到两个数组的交集。如果值在0-63范围内，则可以使用两个
无符号长
s并设置与每个数组中的值对应的位，然后使用
&
（按位“and”）找到交集。如果值不在该范围内，但最大值和最小值之间的差值小于64，则可以使用相同的方法，但从每个值中减去最小值以获得位号。如果范围不是那么小，但不同值的数量是
在数据结构中保存数组A

数组是数据结构；不需要将数组保存到一个数组中

我想比较所有的元素，直到大小A或B，然后我会得到交集

这非常模糊，但不太可能产生交集；请注意，您必须检查和中的每个元素