回顾面试题：计算两个数组交集

Posted 2020-08-17

背景

工作多年，语言经历过C#,JAVA。但是做过的项目大多以业务系统为主，曾经做过一些基础架构的工作，但算法一直在工作中应用的比较少，导致多年之后基本都忘记完了。上一次面试过程中就有一个算法题，我能做对，但是感觉不是最优方案就放弃了。最近想想做为一个程序员，算法还是有必要再补习补习。

案例

有两个数组，int[] arrayA=new int[]{1,3,1.....},int[] arrayB=new int[]{11,3,10.....}，数组元素无序且有可能存在重复元素，请输出两个数组的交集。原题大意是这样，细节可能有出入。

面试时我的方案

不用想，采用两个for循环基本就能解决问题，但我又想不出来其它优化方法，想来想去，时间白白浪费最后居然连能做对的答案都没去写。

    public void testArrayIntersectionA() {
        int[] arrayA = new int[]{1, 1, 2, 3, 4, 4, 5, 1, 1};
        int[] arrayB = new int[]{11, 1, 22, 3, 43, 4, 5, 11, 1, 22};

        Set<Integer> intersectionSet = new HashSet();

        for (int i = 0; i < arrayA.length; i++) {
            for (int j = 0; j < arrayB.length; j++) {
                if (arrayA[i] == arrayB[j]) {
                    intersectionSet.add(arrayA[i]);
                }
            }
        }
    }

当时曾经想过将数组排序然后比较，但放弃了，感觉增加了排序之后性能会不一定比上面的两层for要优化。思路如下：

• 排序原数组
• 选择数组元素小的数组去与大数组做比较

验证上面的指针比较法

比如有这样的两个数组：

  
具体的做法如下：

• 排序数组

  

• 初始化两数组的指针，均从0开始
• 将小数组的指针做为外层循环，在大数组中以大数组指针位置开始比较
• 如果找到相等的，记录结果，同时将大小数组的指针向后移动

   

• 如果在大数组中找到末尾都没有找到，那么小数组的指针向后移动
• 当小数组的指针移动到最后一个元素后结束算法

public void testArrayIntersectionB() {
        int[] arrayA = new int[]{1, 1, 2, 3, 4, 4, 5, 1, 1};
        int[] arrayB = new int[]{11, 1, 22, 3, 43, 4, 5, 11, 1, 22};

        Set<Integer> intersectionSet = new HashSet();
        Arrays.sort(arrayA);
        Arrays.sort(arrayB);

        int indexArrayA = 0;
        int indexArrayB = 0;
        int sizeArrayA = arrayA.length;
        int sizeArrayB = arrayB.length;
        while (indexArrayA < sizeArrayA) {
            for (int i = indexArrayB; i < sizeArrayB; i++) {
                if (arrayA[indexArrayA] == arrayB[i]) {
                    intersectionSet.add(arrayA[indexArrayA]);
                    indexArrayA++;
                    indexArrayB++;
                    break;
                } else if (i == sizeArrayB - 1) {
                    indexArrayA++;
                }
            }
        }

    }

为了测试的准确性，可以将数组的元素增多，文中只是示意的写了几个元素，实际测试过程中可以增大元素个数。同时将方法重复执行500次或者更多来测试。得到的结论是排序之后的指针方法要快于简单的两层for，具体的数据我就不贴了，因为与数组元素的组成有一定的关系。

指针比较法的优化

上面的逻辑是，从大数组的某个位置开始比较至到数组的最后一个元素，但因为我们的数组已经经过排序，实际上我们只需要比较到第一个大于的数就可以结束比较，因为后面的元素一定比前面的元素要大。

 

 public void testArrayIntersectionC() {
        int[] arrayA = new int[]{1, 1, 2, 3, 4, 4, 5, 1, 1};
        int[] arrayB = new int[]{11, 1, 22, 3, 43, 4, 5, 11, 1, 22};

        Set<Integer> intersectionSet = new HashSet();
        Arrays.sort(arrayA);
        Arrays.sort(arrayB);

        int indexArrayA = 0;
        int indexArrayB = 0;
        int sizeArrayA = arrayA.length;
        int sizeArrayB = arrayB.length;
        while (indexArrayA < sizeArrayA) {
            for (int i = indexArrayB; i < sizeArrayB; i++) {
                if (arrayA[indexArrayA] == arrayB[i]) {
                    intersectionSet.add(arrayA[indexArrayA]);
                    indexArrayA++;
                    indexArrayB++;
                    break;
                } else if (arrayA[indexArrayA] < arrayB[i]) {
                    indexArrayA++;
                    break;
                } else if (i == sizeArrayB - 1) {
                    indexArrayA++;
                }
            }
        }

    }

测试结论是此方法优化有效，特别是在特定的数据场景下。

利用java已有结构Set如何？

继承了Collection接口的，包含一个retainAll的方法，我们利用Set可以非常轻松的来完成两个数组的交集。但它只能处理对象类型的Integer，所以我们先要将int[] 转换成Integer[]，然后利用addAll以及retailAll来计算数组的交集。

public void testArrayIntersectionD() {
        int[] arrayA = new int[]{1, 1, 2, 3, 4, 4, 5, 1, 1};
        int[] arrayB = new int[]{11, 1, 22, 3, 43, 4, 5, 11, 1, 22};

        int sizeArrayA=arrayA.length;
        int sizeArrayB=arrayB.length;
        Integer[] arrayA2=new Integer[sizeArrayA];
        Integer[] arrayB2=new Integer[sizeArrayB];
        for(int i=0;i<sizeArrayA;i++){
            arrayA2[i]=new Integer(arrayA[i]);
        }
        for(int i=0;i<sizeArrayB;i++){
            arrayB2[i]=new Integer(arrayB[i]);
        }
        Set<Integer> intersectionSet = new HashSet<Integer>();

        intersectionSet.addAll(Arrays.asList(arrayA2));
        intersectionSet.retainAll(Arrays.asList(arrayB2));

    }

同样也是执行500次，利用Set求交集的性能最好。下面是retainAll的源码：应该是利用了遍历最快的迭代器的原因，后续再找时间求证下。

 public boolean retainAll(Collection<?> c) {
        Objects.requireNonNull(c);
        boolean modified = false;
        Iterator<E> it = iterator();
        while (it.hasNext()) {
            if (!c.contains(it.next())) {
                it.remove();
                modified = true;
            }
        }
        return modified;
    }

扩展问题，如果数组不是int[],而直接是Integer[]，数据结果会有变化吗？

上面有提到，当时面试时我考虑的是数组排序,经过测试int[]的排序要快于Integer[]排序，数组的复制也是一样。这在一定程序上会引起测试结果的变化。同时数组内元素的内容也会影响测试结果。

是否有更好的方案？