找出两个整型数组的交集，有什么好的算法？

[iGarlic]

有两个整型数组A和B，有什么高效的算法，找出两个数组的交集

A：3 1 20 46
B：20 9 12 5
交集：20

[鼠]

http://topic.csdn.net/u/20090810/10/35679360-b7a2-4fe7-9fea-f7afc0aed537.html
讲了不少

[asksgp]

元素没有重复的吧？把B数组放一个map里，拿A中每个元素去map里find，找到的元素就是交集。

[goodname]

先排序,再求交集。

http://topic.csdn.net/u/20090514/16/47711017-2a7a-49a3-b0d4-2b6e69148c91.html

[xingzhe2001]

从大到小排好序，把较大的删掉
比如排好序
A 46 20 3 1
B 20 12 9 5

首先看A[0]和B[0],A[0]大，舍去，再看A[1]和B[0]相等，取
再看a[2]和b[1],b[1]大舍去
再看a[2]和b[2],b[2]大舍去
再看a[2]和b[3],b[3]大舍去
B为空，算法结束

[xingzhe2001]

恩，排序也需要时间。。。

[xingzhe2001]

先把A弄成二叉树(可以用数组实现的)
往二叉树里插B,看冲突不

[猫已经找不回了]

给A建个map,初始化完毕之后，只需要遍历一次目标B即可得出所有的交集

[iGarlic]

莫非没什么高效的算法？

[lzy0001sl]

我觉得先对两个数组进行排序，然后用二分查找法。应该比逐个判断快许多。

[windsting]

因为以前没用过，所以我写了一个例子，自己也练习一下，运行一下你就知道了：

#include <iostream>
#include <vector>
#include <functional>
#include <iterator>
using namespace std;

int A[] = {3,46,20,1,9};
int B[] = {20,9,12,5,14};

//  获取两个数组的大小
#define ArraySize(a) (sizeof(a)/sizeof(a[0]))
const int SizeA = ArraySize(A);
const int SizeB = ArraySize(B);

//  定义一个用于输出一个序列的函数
template<class Iter>
void Print(Iter begin,Iter end)
{
    while(begin!=end)
    {
        cout << *begin << '\t';
        ++begin;
    }
    cout << endl;
}

int main(void)
{
    //  set_intersection 操作的序列必须是已经排序好的
    sort(A,A+SizeA);
    sort(B,B+SizeB);

    vector<int> vecIntersect;
    //  这个函数就是获得交集的方法，这是一种写法，后面还有另一种
    set_intersection(A,A+SizeA,B,B+SizeB,back_inserter<vector<int> >(vecIntersect));
    cout << "there is " << vecIntersect.size() << " element"
            << (vecIntersect.size()>1?"s":"") << " shared:\n";
    Print(vecIntersect.begin(),vecIntersect.end());

    const int InterSize = min(SizeA,SizeB);
    int* iIntersectArray = new int[InterSize];
    //  这是第二种用法，函数的返回值是“指向最后一个交集元素下一个位置的指针”
    //  用第一种方法，就是为了把这些元素弄到容器里，便于操作，但这种好理解
    int* endOfIntersect = set_intersection(A,A+SizeA,B,B+SizeB,iIntersectArray);
    cout << "there is " << vecIntersect.size() << " element"
            << (vecIntersect.size()>1?"s":"") << " shared:\n";
    Print(iIntersectArray,endOfIntersect);

    delete [] iIntersectArray;  //  千万别忘了 delete[]
}

我用CodeBlocks(编译器是GCC)编译通过了，结果是：

there is 2 elements shared:
9       20
there is 2 elements shared:
9       20

[百事烟]

数组A长度：m
数据B长度：n

----------------------------------------------
最直接两个数组挨个比: 时间 = m * n
----------------------------------------------
两个数组分别排序 时间 = m^2 + n^2 + m //m,n的平方 (最后得比一次吧)，这个好慢啊
---------------------------------------------
只排1个数组 时间 = n^2 + m //n的平方和m*n哪个大，好象省不了多少时间
----------------------------------------------

[iGarlic]

这么说的话，最简单的方法是最有效的方法？

[Quote=引用 11 楼 delphigis 的回复:]
数组A长度：m
数据B长度：n

----------------------------------------------
最直接两个数组挨个比:    时间 = m * n 
----------------------------------------------
两个数组分别排序        时间 = m^2 + n^2 + m        //m,n的平方 (最后得比一次吧)，这个好慢啊
---------------------------------------------
只排1个数组              时间 = n^2 + m              //n的平方和m*n哪个大，好象省不了多少时间
----------------------------------------------
[/Quote]

[liao05050075]

[Quote=引用 11 楼 delphigis 的回复:]
数组A长度：m
数据B长度：n

----------------------------------------------
最直接两个数组挨个比:    时间 = m * n 
----------------------------------------------
两个数组分别排序        时间 = m^2 + n^2 + m        //m,n的平方 (最后得比一次吧)，这个好慢啊
---------------------------------------------
只排1个数组              时间 = n^2 + m              //n的平方和m*n哪个大，好象省不了多少时间
----------------------------------------------
[/Quote]

使用快速排序的话，复杂度是nlog(n)
于是，只排1个数组的复杂度是排序时间＋查找时间
排序的话，找n、m中小的那个数组来排序（现在假定n比较小），排完后，采用二分查找
于是复杂度为O(nlog(n) + m*log(n))
这个比O(m*n)要好得多。
如果n、m相差得很远的话，那么效果将更明显。

[worldbankwolf]

我也说一个方法：
1、对两个数组分别进行递增排序
2、定义两个指针分别指向两个数组中的第一个元素，比较两个元素
3、如果相等的话，这个元素就是交集的一个元素，保存，然后两个指针都后移一个位置。
4、如果不相等的话，那么指向小的元素的那个指针向后移动一个位置。
5、继续比较。
6、重复进行这个过程。

[iGarlic]

谢谢各位的参与，今天结贴！

[灌水九段]

排序和放到map里不知道哪个花的时间更长？

[fallening]

设这两个数组分别为A[N],B[M] (N <=M)

1)对A[N]排序 －－ 时间复杂度NlgN;
2)对B[M]中的每一个元素，在已经排序好的A[N]中二分查找 －－时间复杂度 MlgN

综上，时间复杂度为 (M+N)lgN