LeetCode 5079. 三个有序数组的交集（Java）三种方法

版权声明：本文为博主原创文章，遵循 CC 4.0 BY 版权协议，转载请附上原文出处链接和本声明。

本文链接： https://blog.csdn.net/pfdvnah/article/details/102213035

一、三个有序数组的交集

给出三个均为 严格递增排列 的整数数组 arr1，arr2 和 arr3。

返回一个由 仅 在这三个数组中 同时出现 的整数所构成的有序数组。

示例

输入: arr1 = [1,2,3,4,5], arr2 = [1,2,5,7,9], arr3 = [1,3,4,5,8]
输出: [1,5]
解释: 只有 1 和 5 同时在这三个数组中出现.

提示

• 1 <= arr1.length, arr2.length, arr3.length <= 1000
• 1 <= arr1[i], arr2[i], arr3[i] <= 2000

二、Java代码

方法一

将三个数组复制到一个数组中，然后升序，连续三个相等则添加到链表中。@wowpH

时间复杂度： $O(n)$
空间复杂度： $O(max(n))$，其中 $n$ 是数组的长度。

/*
原文链接：https://blog.csdn.net/pfdvnah/article/details/102213035
作者：wowpH
CSDN-ID：pfdvnah
*/
class Solution {
    public List<Integer> arraysIntersection(int[] arr1, int[] arr2, int[] arr3) {
        int len = arr1.length + arr2.length + arr3.length;// 总个数
        int[] arr = new int[len];
        int desPos = 0;// 拷贝时的目的数组的起始下标
        System.arraycopy(arr1, 0, arr, desPos, arr1.length);
        desPos += arr1.length;
        System.arraycopy(arr2, 0, arr, desPos, arr2.length);
        desPos += arr2.length;
        System.arraycopy(arr3, 0, arr, desPos, arr3.length);
        Arrays.sort(arr);// 升序。@pfdvnah
        List<Integer> ans = new ArrayList<>();
        for (int i = 0; i < len - 2; ++i) {
            if (arr[i] == arr[i + 1] && arr[i] == arr[i + 2]) {
                ans.add(arr[i]);
                i += 2;
            }
        }
        return ans;
    }
}

方法二

用三个下标遍历三个数组，找到就添加到列表中。

时间复杂度： $O(n)$
空间复杂度： $O(1)$

/*
原文链接：https://blog.csdn.net/pfdvnah/article/details/102213035
作者：wowpH
CSDN-ID：pfdvnah
*/
class Solution {
    public List<Integer> arraysIntersection(int[] arr1, int[] arr2, int[] arr3) {
        List<Integer> ans = new ArrayList<>();
        int[] pos = new int[4];
        while (pos[1] < arr1.length) {// 遍历数组arr1
            while (pos[2] < arr2.length && arr2[pos[2]] < arr1[pos[1]]) {
                ++pos[2];// 在arr2中找到第一个大于等于arr1[pos[1]]的数的下标
            }
            if (pos[2] >= arr2.length) {// 未找到就越界
                return ans;
            }
            if (arr2[pos[2]] == arr1[pos[1]]) {// 找到
                while (pos[3] < arr3.length && arr3[pos[3]] < arr1[pos[1]]) {
                    ++pos[3];// 在arr3中找到第一个大于等于arr1[pos[1]]的数的下标
                }
                if (pos[3] >= arr3.length) {
                    return ans;// @wowpH
                }
                if (arr3[pos[3]] == arr1[pos[1]]) {// 找到
                    ans.add(arr1[pos[1]]);// 添加到列表中
                }
            }
            ++pos[1];
        }
        return ans;
    }
}

方法三

记录每个数字出现的次数，如果是三次则添加到列表中。

最优，但是有限制，必须要 严格递增。

时间复杂度： $O(n)$
空间复杂度： $O(1)$

/*
原文链接：https://blog.csdn.net/pfdvnah/article/details/102213035
作者：wowpH
CSDN-ID：pfdvnah
*/
class Solution {
    public List<Integer> arraysIntersection(int[] arr1, int[] arr2, int[] arr3) {
        int[] arr = new int[2001];// 每个数字出现的次数
        for(int i : arr1) {
            ++arr[i];
        }
        for(int i : arr2) {
            ++arr[i];
        }
        for(int i : arr3) {
            ++arr[i];
        }
        List<Integer> ans = new ArrayList<>();
        for (int i = 0; i < 2001; ++i) {
            if (arr[i] == 3) {// 刚好三次。@pfdvnah
                ans.add(i);
            }
        }
        return ans;
    }
}

查看原文：https://blog.csdn.net/pfdvnah/article/details/102213035

- End - wowpH - pfdvnah -