尧图网站建设 
LeetCode 2215 题解Find the Difference of Two Arrays 找出两个数组的不同哈希集合、排序双指针与集合差四解法【免费下载链接】leetcodeLeetcode solutions项目地址: https://gitcode.com/GitHub_Trending/leetcode1/leetcode本篇技术指南围绕 LeetCode 2215「找出两个数组的不同Find the Difference of Two Arrays」展开完整讲解暴力枚举、排序 双指针、哈希集合、内建集合差运算四种解法的思路、算法步骤、多语言代码与复杂度分析并对照本仓库 python、cpp、javascript、c 等真实提交实现进行源码级佐证。读完本文你将掌握两个集合的对称差异symmetric difference类问题的通用解法套路并能在实际编码中根据数据规模与语言特性选出最优方案。问题概述与前置知识题目要求给定两个下标从 0 开始的整数数组nums1和nums2返回一个包含两个列表的列表answeranswer[0]是nums1中所有不在nums2中的不同整数组成的列表answer[1]是nums2中所有不在nums1中的不同整数组成的列表。注意两个结果列表中的整数可以是任意顺序。在动手前需要熟练掌握以下三个基础知识点哈希集合Hash Set最优解依赖集合的 O(1) 平均查找与集合差运算集合运算Set Operations理解并集、交集、差集的概念尤其是差集 A − B 表示属于 A 但不属于 B的元素双指针Two Pointers排序解法中借助有序数组用双指针高效完成逐元素比较。本仓库在 csharp、kotlin、typescript 等目录下也提供了同题实现可用于横向对照不同语言的惯用写法。解法一暴力枚举Brute Force思路最直接的做法是把nums1中的每个元素与nums2中的每个元素逐一比对若在nums2中找不到相等值则该元素属于结果的第一部分对nums2做同样的反向扫描。由于结果要求不同整数用集合存储可以天然保证去重。算法步骤初始化两个空集合分别存放不出现在另一个数组中的唯一元素遍历nums1的每个元素在内层循环中遍历nums2检查是否存在相等值若不存在加入第一个结果集合遍历nums2的每个元素在内层循环中遍历nums1检查是否存在相等值若不存在加入第二个结果集合将两个集合转换为列表并返回[list(res1), list(res2)]。参考代码Pythonclass Solution: def findDifference(self, nums1: list[int], nums2: list[int]) - list[list[int]]: res [set(), set()] for num1 in nums1: found False for num2 in nums2: if num1 num2: found True break if not found: res[0].add(num1) for num2 in nums2: found False for num1 in nums1: if num1 num2: found True break if not found: res[1].add(num2) return [list(res[0]), list(res[1])]Javapublic class Solution { public ListListInteger findDifference(int[] nums1, int[] nums2) { SetInteger res1 new HashSet(); SetInteger res2 new HashSet(); for (int num1 : nums1) { boolean found false; for (int num2 : nums2) { if (num1 num2) { found true; break; } } if (!found) { res1.add(num1); } } for (int num2 : nums2) { boolean found false; for (int num1 : nums1) { if (num1 num2) { found true; break; } } if (!found) { res2.add(num2); } } ListListInteger result new ArrayList(); result.add(new ArrayList(res1)); result.add(new ArrayList(res2)); return result; } }Cclass Solution { public: vectorvectorint findDifference(vectorint nums1, vectorint nums2) { setint res1, res2; for (int num1 : nums1) { bool found false; for (int num2 : nums2) { if (num1 num2) { found true; break; } } if (!found) { res1.insert(num1); } } for (int num2 : nums2) { bool found false; for (int num1 : nums1) { if (num1 num2) { found true; break; } } if (!found) { res2.insert(num2); } } return {vectorint(res1.begin(), res1.end()), vectorint(res2.begin(), res2.end())}; } };JavaScriptclass Solution { /** * param {number[]} nums1 * param {number[]} nums2 * return {number[][]} */ findDifference(nums1, nums2) { const res1 new Set(); const res2 new Set(); for (const num1 of nums1) { let found false; for (const num2 of nums2) { if (num1 num2) { found true; break; } } if (!found) { res1.add(num1); } } for (const num2 of nums2) { let found false; for (const num1 of nums1) { if (num1 num2) { found true; break; } } if (!found) { res2.add(num2); } } return [Array.from(res1), Array.from(res2)]; } }C#public class Solution { public ListListint FindDifference(int[] nums1, int[] nums2) { var res new ListHashSetint { new HashSetint(), new HashSetint() }; foreach (int num1 in nums1) { bool found false; foreach (int num2 in nums2) { if (num1 num2) { found true; break; } } if (!found) res[0].Add(num1); } foreach (int num2 in nums2) { bool found false; foreach (int num1 in nums1) { if (num1 num2) { found true; break; } } if (!found) res[1].Add(num2); } return new ListListint { res[0].ToList(), res[1].ToList() }; } }Gofunc findDifference(nums1 []int, nums2 []int) [][]int { res1 : make(map[int]struct{}) res2 : make(map[int]struct{}) for _, num1 : range nums1 { found : false for _, num2 : range nums2 { if num1 num2 { found true break } } if !found { res1[num1] struct{}{} } } for _, num2 : range nums2 { found : false for _, num1 : range nums1 { if num1 num2 { found true break } } if !found { res2[num2] struct{}{} } } result1, result2 : []int{}, []int{} for k : range res1 { result1 append(result1, k) } for k : range res2 { result2 append(result2, k) } return [][]int{result1, result2} }Kotlinclass Solution { fun findDifference(nums1: IntArray, nums2: IntArray): ListListInt { val res1 mutableSetOfInt() val res2 mutableSetOfInt() for (num1 in nums1) { var found false for (num2 in nums2) { if (num1 num2) { found true break } } if (!found) res1.add(num1) } for (num2 in nums2) { var found false for (num1 in nums1) { if (num1 num2) { found true break } } if (!found) res2.add(num2) } return listOf(res1.toList(), res2.toList()) } }Swiftclass Solution { func findDifference(_ nums1: [Int], _ nums2: [Int]) - [[Int]] { var res1 SetInt() var res2 SetInt() for num1 in nums1 { var found false for num2 in nums2 { if num1 num2 { found true break } } if !found { res1.insert(num1) } } for num2 in nums2 { var found false for num1 in nums1 { if num1 num2 { found true break } } if !found { res2.insert(num2) } } return [Array(res1), Array(res2)] } }Rustimpl Solution { pub fn find_difference(nums1: Veci32, nums2: Veci32) - VecVeci32 { let mut res1: HashSeti32 HashSet::new(); let mut res2: HashSeti32 HashSet::new(); for num1 in nums1 { let mut found false; for num2 in nums2 { if num1 num2 { found true; break; } } if !found { res1.insert(num1); } } for num2 in nums2 { let mut found false; for num1 in nums1 { if num1 num2 { found true; break; } } if !found { res2.insert(num2); } } vec![ res1.into_iter().collect(), res2.into_iter().collect(), ] } }复杂度分析时间复杂度O(n × m)其中 n 为nums1长度m 为nums2长度。每个元素都要与另一个数组全量比对空间复杂度O(n m)两个结果集合在最坏情况下各容纳 n、m 个去重元素。解法二排序 双指针Sorting思路将两个数组排序后元素天然有序可以用双指针同时遍历两个数组进行比较。当指针指向的元素不相等时较小的那个元素在当前数组中不可能再匹配到另一个数组的其余元素因为另一个数组元素只会更大因此它必然是独有元素可以直接收入结果。这种方法免去了暴力解中反复全量扫描的开销。算法步骤对两个输入数组分别排序定义辅助函数helper(A, B)找出数组A中存在、B中不存在的元素用指针j追踪在B中的位置遍历A中的每个唯一元素跳过与前一个相同的值不断推进j直到B[j] 当前元素若j已越界或B[j] ! 当前元素说明该元素只属于A加入结果分别以helper(nums1, nums2)与helper(nums2, nums1)求两个方向的差异返回两个结果列表。参考代码Pythonclass Solution: def findDifference(self, nums1: list[int], nums2: list[int]) - list[list[int]]: nums1.sort() nums2.sort() def helper(A, B): n, m len(A), len(B) res [] j 0 prev float(-inf) for num in A: if prev num: continue while j m and B[j] num: j 1 if j m or B[j] ! num: res.append(num) prev num return res return [helper(nums1, nums2), helper(nums2, nums1)]Javapublic class Solution { public ListListInteger findDifference(int[] nums1, int[] nums2) { Arrays.sort(nums1); Arrays.sort(nums2); ListInteger diff1 helper(nums1, nums2); ListInteger diff2 helper(nums2, nums1); ListListInteger result new ArrayList(); result.add(diff1); result.add(diff2); return result; } private ListInteger helper(int[] A, int[] B) { int n A.length, m B.length, j 0; ListInteger res new ArrayList(); int prev Integer.MIN_VALUE; for (int num : A) { if (num prev) continue; while (j m B[j] num) j; if (j m || B[j] ! num) res.add(num); prev num; } return res; } }Cclass Solution { public: vectorvectorint findDifference(vectorint nums1, vectorint nums2) { sort(nums1.begin(), nums1.end()); sort(nums2.begin(), nums2.end()); return {helper(nums1, nums2), helper(nums2, nums1)}; } private: vectorint helper(vectorint A, vectorint B) { vectorint res; int n A.size(), m B.size(), j 0, prev INT_MIN; for (int num : A) { if (num prev) continue; while (j m B[j] num) j; if (j m || B[j] ! num) res.push_back(num); prev num; } return res; } };JavaScriptclass Solution { /** * param {number[]} nums1 * param {number[]} nums2 * return {number[][]} */ findDifference(nums1, nums2) { nums1.sort((a, b) a - b); nums2.sort((a, b) a - b); const helper (A, B) { const res []; let j 0; let prev -Infinity; for (const num of A) { if (num prev) continue; while (j B.length B[j] num) j; if (j B.length || B[j] ! num) res.push(num); prev num; } return res; }; return [helper(nums1, nums2), helper(nums2, nums1)]; } }C#public class Solution { public ListListint FindDifference(int[] nums1, int[] nums2) { var num1Set new HashSetint(nums1); var num2Set new HashSetint(nums2); var res1 new Listint(); var res2 new Listint(); foreach (int num in num1Set) { if (!num2Set.Contains(num)) res1.Add(num); } foreach (int num in num2Set) { if (!num1Set.Contains(num)) res2.Add(num); } return new ListListint { res1, res2 }; } }Gofunc findDifference(nums1 []int, nums2 []int) [][]int { sort.Ints(nums1) sort.Ints(nums2) helper : func(A, B []int) []int { res : []int{} j : 0 prev : math.MinInt32 for _, num : range A { if num prev { continue } for j len(B) B[j] num { j } if j len(B) || B[j] ! num { res append(res, num) } prev num } return res } return [][]int{helper(nums1, nums2), helper(nums2, nums1)} }Kotlinclass Solution { fun findDifference(nums1: IntArray, nums2: IntArray): ListListInt { nums1.sort() nums2.sort() fun helper(A: IntArray, B: IntArray): ListInt { val res mutableListOfInt() var j 0 var prev Int.MIN_VALUE for (num in A) { if (num prev) continue while (j B.size B[j] num) j if (j B.size || B[j] ! num) res.add(num) prev num } return res } return listOf(helper(nums1, nums2), helper(nums2, nums1)) } }Swiftclass Solution { func findDifference(_ nums1: [Int], _ nums2: [Int]) - [[Int]] { let sortedNums1 nums1.sorted() let sortedNums2 nums2.sorted() func helper(_ A: [Int], _ B: [Int]) - [Int] { var res [Int]() var j 0 var prev Int.min for num in A { if num prev { continue } while j B.count B[j] num { j 1 } if j B.count || B[j] ! num { res.append(num) } prev num } return res } return [helper(sortedNums1, sortedNums2), helper(sortedNums2, sortedNums1)] } }Rustimpl Solution { pub fn find_difference(mut nums1: Veci32, mut nums2: Veci32) - VecVeci32 { nums1.sort(); nums2.sort(); fn helper(a: [i32], b: [i32]) - Veci32 { let mut res Vec::new(); let mut j 0; let mut prev i32::MIN; for num in a { if num prev { continue; } while j b.len() b[j] num { j 1; } if j b.len() || b[j] ! num { res.push(num); } prev num; } res } vec![helper(nums1, nums2), helper(nums2, nums1)] } }复杂度分析时间复杂度O(n log n m log m)排序是主要开销排序后的双指针遍历为线性空间复杂度O(1) 或 O(n m)取决于所用排序算法是否原地如 Python 的 Timsort、Go 的sort.Ints都会产生额外空间。解法三哈希集合Hash Set——推荐解法思路哈希集合提供 O(1) 平均查找时间非常适合成员判断。把两个数组分别转成集合既去掉了重复值又能快速判断任意元素是否出现在另一个集合中。相比暴力解的内层全量扫描哈希集合把每次查找从 O(m) 降到 O(1)整体变为线性复杂度是本题最实用的解法。算法步骤将nums1、nums2分别转换为哈希集合去重并支持快速查找为在nums1中而不在nums2中的元素创建结果列表遍历第一个集合把不在第二个集合中的元素加入结果一对第二个集合做对称操作得到结果二返回两个结果列表。参考代码Pythonclass Solution: def findDifference(self, nums1: List[int], nums2: List[int]) - List[List[int]]: num1Set, num2Set set(nums1), set(nums2) res1, res2 [], [] for num in num1Set: if num not in num2Set: res1.append(num) for num in num2Set: if num not in num1Set: res2.append(num) return [res1, res2]Javapublic class Solution { public ListListInteger findDifference(int[] nums1, int[] nums2) { SetInteger num1Set new HashSet(); SetInteger num2Set new HashSet(); for (int num : nums1) num1Set.add(num); for (int num : nums2) num2Set.add(num); ListInteger res1 new ArrayList(); ListInteger res2 new ArrayList(); for (int num : num1Set) { if (!num2Set.contains(num)) res1.add(num); } for (int num : num2Set) { if (!num1Set.contains(num)) res2.add(num); } return Arrays.asList(res1, res2); } }Cclass Solution { public: vectorvectorint findDifference(vectorint nums1, vectorint nums2) { unordered_setint num1Set(nums1.begin(), nums1.end()); unordered_setint num2Set(nums2.begin(), nums2.end()); vectorint res1, res2; for (int num : num1Set) { if (num2Set.find(num) num2Set.end()) res1.push_back(num); } for (int num : num2Set) { if (num1Set.find(num) num1Set.end()) res2.push_back(num); } return {res1, res2}; } };JavaScriptclass Solution { /** * param {number[]} nums1 * param {number[]} nums2 * return {number[][]} */ findDifference(nums1, nums2) { const num1Set new Set(nums1); const num2Set new Set(nums2); const res1 []; const res2 []; for (const num of num1Set) { if (!num2Set.has(num)) res1.push(num); } for (const num of num2Set) { if (!num1Set.has(num)) res2.push(num); } return [res1, res2]; } }C#public class Solution { public ListListint FindDifference(int[] nums1, int[] nums2) { var numSet1 new HashSetint(nums1); var numSet2 new HashSetint(nums2); var res1 new Listint(numSet1); res1.RemoveAll(num numSet2.Contains(num)); var res2 new Listint(numSet2); res2.RemoveAll(num numSet1.Contains(num)); return new ListListint { res1, res2 }; } }Gofunc findDifference(nums1 []int, nums2 []int) [][]int { num1Set : make(map[int]struct{}) num2Set : make(map[int]struct{}) for _, num : range nums1 { num1Set[num] struct{}{} } for _, num : range nums2 { num2Set[num] struct{}{} } res1, res2 : []int{}, []int{} for num : range num1Set { if _, exists : num2Set[num]; !exists { res1 append(res1, num) } } for num : range num2Set { if _, exists : num1Set[num]; !exists { res2 append(res2, num) } } return [][]int{res1, res2} }Kotlinclass Solution { fun findDifference(nums1: IntArray, nums2: IntArray): ListListInt { val num1Set nums1.toHashSet() val num2Set nums2.toHashSet() val res1 num1Set.filter { it !in num2Set } val res2 num2Set.filter { it !in num1Set } return listOf(res1, res2) } }Swiftclass Solution { func findDifference(_ nums1: [Int], _ nums2: [Int]) - [[Int]] { let num1Set Set(nums1) let num2Set Set(nums2) let res1 num1Set.filter { !num2Set.contains($0) } let res2 num2Set.filter { !num1Set.contains($0) } return [Array(res1), Array(res2)] } }Rustimpl Solution { pub fn find_difference(nums1: Veci32, nums2: Veci32) - VecVeci32 { let num1_set: HashSeti32 nums1.into_iter().collect(); let num2_set: HashSeti32 nums2.into_iter().collect(); let res1: Veci32 num1_set.iter().filter(|x| !num2_set.contains(x)).cloned().collect(); let res2: Veci32 num2_set.iter().filter(|x| !num1_set.contains(x)).cloned().collect(); vec![res1, res2] } }复杂度分析时间复杂度O(n m)每个元素最多被处理常数次空间复杂度O(n m)两个哈希集合在极端情况下容纳全部元素。仓库源码佐证本仓库多语言提交都采用了这一思路。例如 python/2215-find-the-difference-of-two-arrays.py 中的核心提交即先将数组转集合再用if num not in nums2_set做成员判断收集结果cpp/2215-find-the-difference-of-two-arrays.cpp 用unordered_setint构造集合并以nums2Set.find(num) nums2Set.end()判断缺失javascript/2215-find-the-difference-of-two-arrays.js 用Array.from(nums1Set).filter((num) !nums2Set.has(num))一行完成过滤。三份代码均标注了Time Complexity: O(m n)与Space Complexity: O(m n)与上文分析一致。解法四内建集合差运算Hash Set Difference思路许多编程语言直接提供集合差运算A − B 返回属于 A 但不属于 B的全部元素与本题目要求完全吻合。直接调用库函数可以把代码压缩到极致且底层多为经过优化的实现代码可读性最高适合作为生产环境中的简洁写法。算法步骤将两个数组分别转换为集合计算set1 - set2得到仅属于nums1的元素计算set2 - set1得到仅属于nums2的元素将两个结果转换为列表返回。参考代码Pythonclass Solution: def findDifference(self, nums1: List[int], nums2: List[int]) - List[List[int]]: numSet1, numSet2 set(nums1), set(nums2) return [list(numSet1 - numSet2), list(numSet2 - numSet1)]Javapublic class Solution { public ListListInteger findDifference(int[] nums1, int[] nums2) { SetInteger numSet1 new HashSet(); SetInteger numSet2 new HashSet(); for (int num : nums1) numSet1.add(num); for (int num : nums2) numSet2.add(num); ListInteger res1 new ArrayList(numSet1); res1.removeAll(numSet2); ListInteger res2 new ArrayList(numSet2); res2.removeAll(numSet1); return Arrays.asList(res1, res2); } }Cclass Solution { public: vectorvectorint findDifference(vectorint nums1, vectorint nums2) { vectorint res1, res2; setint numSet1(begin(nums1), end(nums1)), numSet2(begin(nums2), end(nums2)); set_difference(begin(numSet1), end(numSet1), begin(numSet2), end(numSet2), back_inserter(res1)); set_difference(begin(numSet2), end(numSet2), begin(numSet1), end(numSet1), back_inserter(res2)); return {res1, res2}; } };JavaScriptclass Solution { /** * param {number[]} nums1 * param {number[]} nums2 * return {number[][]} */ findDifference(nums1, nums2) { const numSet1 new Set(nums1); const numSet2 new Set(nums2); const res1 Array.from(numSet1).filter((num) !numSet2.has(num)); const res2 Array.from(numSet2).filter((num) !numSet1.has(num)); return [res1, res2]; } }C#public class Solution { public ListListint FindDifference(int[] nums1, int[] nums2) { Array.Sort(nums1); Array.Sort(nums2); var diff1 Helper(nums1, nums2); var diff2 Helper(nums2, nums1); return new ListListint { diff1, diff2 }; } private Listint Helper(int[] A, int[] B) { int n A.Length, m B.Length, j 0; var res new Listint(); int prev int.MinValue; foreach (int num in A) { if (num prev) continue; while (j m B[j] num) j; if (j m || B[j] ! num) res.Add(num); prev num; } return res; } }Gofunc findDifference(nums1 []int, nums2 []int) [][]int { numSet1 : make(map[int]struct{}) numSet2 : make(map[int]struct{}) for _, num : range nums1 { numSet1[num] struct{}{} } for _, num : range nums2 { numSet2[num] struct{}{} } res1, res2 : []int{}, []int{} for num : range numSet1 { if _, exists : numSet2[num]; !exists { res1 append(res1, num) } } for num : range numSet2 { if _, exists : numSet1[num]; !exists { res2 append(res2, num) } } return [][]int{res1, res2} }Kotlinclass Solution { fun findDifference(nums1: IntArray, nums2: IntArray): ListListInt { val numSet1 nums1.toHashSet() val numSet2 nums2.toHashSet() return listOf( (numSet1 - numSet2).toList(), (numSet2 - numSet1).toList() ) } }Swiftclass Solution { func findDifference(_ nums1: [Int], _ nums2: [Int]) - [[Int]] { let numSet1 Set(nums1) let numSet2 Set(nums2) return [ Array(numSet1.subtracting(numSet2)), Array(numSet2.subtracting(numSet1)) ] } }Rustimpl Solution { pub fn find_difference(nums1: Veci32, nums2: Veci32) - VecVeci32 { let num_set1: HashSeti32 nums1.into_iter().collect(); let num_set2: HashSeti32 nums2.into_iter().collect(); vec![ num_set1.difference(num_set2).cloned().collect(), num_set2.difference(num_set1).cloned().collect(), ] } }复杂度分析时间复杂度O(n m)空间复杂度O(n m)。两种哈希集合解法的复杂度相同解法四的差异在于直接用语言内建的集合差语义表达问题代码更短、意图更清晰适合代码可读性优先的场景。仓库实现变体从集合到计数数组本仓库的 c/2215-find-the-difference-of-two-arrays.c 提供了两版值得注意的实现展示了同一道题在不同约束下的工程化写法变体一三路快排 双指针。由于 C 语言没有内建集合该实现先用自写的三路快速排序quicksort/partition3对两个数组排序随后在processArrays中用双指针推进两指针元素相等则同步前进nums1元素较小则它只属于nums1写入结果一并推进反之写入结果二。循环结束后再把两个数组剩余的唯一元素收尾。skipRepeatedValues负责跳过连续重复值保证结果去重。这正是解法二排序 双指针的完整 C 语言落地。变体二值域偏移计数表。题目数据范围允许的前提下该实现分配calloc(2001, sizeof(int))的计数数组以nums[i] 1000作为下标即把值域 [-1000, 1000] 偏移映射到 [0, 2000]第一遍扫描把nums1中出现过的位置置 1第二遍扫描nums2若对应位为 0 说明该值只属于nums2写入结果二并把该位置为 -1 防止重复最后遍历计数表仍为 1 的位置即只属于nums1的值。这是哈希集合思路在值域有限前提下的 O(1) 空间变体可作为理解哈希函数 冲突规避的启蒙案例。此外java/2215-find-the-difference-of-two-arrays.java 展示了另一条思路用List.contains线性判断后再借HashSet去重收集结果本质是暴力法的先判重再查重写法便于对比不同去重时机的影响。常见陷阱Common Pitfalls陷阱一结果中出现重复值题目要求返回不同distinct整数。如果直接遍历原始数组而不是集合同一个值可能被多次加入结果例如nums1 [1, 1, 2]若不先转集合1会被加入两次。务必使用集合去重或在循环中显式记录已见值保证输出中每个元素只出现一次。陷阱二弄混两个结果列表的归属返回值是两个列表第一个装在nums1中但不在nums2中的元素第二个装在nums2中但不在nums1中的元素。两个差集方向相反写反会导致整个答案错误。提交前建议用nums1 [1,2,3], nums2 [2,4,6]这类样例自查期望输出应为[[1,3],[4,6]]。陷阱三排序解中忘记跳过相邻重复值排序 双指针解法中A数组排序后相邻重复值会在每次B[j] num推进后依然命中同一个位置若不通过prev记录上一个处理值并continue跳过同一元素会被重复加入结果——这正是各语言实现中prev变量的作用。四种解法对比总结解法核心思想时间复杂度空间复杂度适用场景暴力枚举双层循环全量比对 集合去重O(n × m)O(n m)数据量极小、仅作教学演示排序 双指针排序后用指针线性推进O(n log n m log m)O(1) 或 O(n m)无哈希表环境或需原地处理哈希集合集合去重 O(1) 成员判断O(n m)O(n m)通用场景最推荐内建集合差直接调用库函数求差集O(n m)O(n m)代码简洁性优先其中 n 为nums1长度m 为nums2长度。日常刷题与面试中解法三哈希集合是兼顾效率与可读性的首选若语言内建集合差运算如 Python 的-、Swift 的subtracting、Rust 的difference语义清晰解法四同样值得采用。更多同主题的多语言提交可继续查阅本仓库的 typescript/2215-find-the-difference-of-two-arrays.ts、kotlin/2215-find-the-difference-of-two-arrays.kt 与 rust/2215-find-the-difference-of-two-arrays.rs对照学习各语言的集合惯用法。【免费下载链接】leetcodeLeetcode solutions项目地址: https://gitcode.com/GitHub_Trending/leetcode1/leetcode创作声明：本文部分内容由AI辅助生成（AIGC），仅供参考 LeetCode 2215 题解：Find the Difference of Two Arrays 找出两个数组的不同（哈希集合、排序双指针与集合差四解法）
LeetCode 2215 题解Find the Difference of Two Arrays 找出两个数组的不同哈希集合、排序双指针与集合差四解法【免费下载链接】leetcodeLeetcode solutions项目地址: https://gitcode.com/GitHub_Trending/leetcode1/leetcode本篇技术指南围绕 LeetCode 2215「找出两个数组的不同Find the Difference of Two Arrays」展开完整讲解暴力枚举、排序 双指针、哈希集合、内建集合差运算四种解法的思路、算法步骤、多语言代码与复杂度分析并对照本仓库 python、cpp、javascript、c 等真实提交实现进行源码级佐证。读完本文你将掌握两个集合的对称差异symmetric difference类问题的通用解法套路并能在实际编码中根据数据规模与语言特性选出最优方案。问题概述与前置知识题目要求给定两个下标从 0 开始的整数数组nums1和nums2返回一个包含两个列表的列表answeranswer[0]是nums1中所有不在nums2中的不同整数组成的列表answer[1]是nums2中所有不在nums1中的不同整数组成的列表。注意两个结果列表中的整数可以是任意顺序。在动手前需要熟练掌握以下三个基础知识点哈希集合Hash Set最优解依赖集合的 O(1) 平均查找与集合差运算集合运算Set Operations理解并集、交集、差集的概念尤其是差集 A − B 表示属于 A 但不属于 B的元素双指针Two Pointers排序解法中借助有序数组用双指针高效完成逐元素比较。本仓库在 csharp、kotlin、typescript 等目录下也提供了同题实现可用于横向对照不同语言的惯用写法。解法一暴力枚举Brute Force思路最直接的做法是把nums1中的每个元素与nums2中的每个元素逐一比对若在nums2中找不到相等值则该元素属于结果的第一部分对nums2做同样的反向扫描。由于结果要求不同整数用集合存储可以天然保证去重。算法步骤初始化两个空集合分别存放不出现在另一个数组中的唯一元素遍历nums1的每个元素在内层循环中遍历nums2检查是否存在相等值若不存在加入第一个结果集合遍历nums2的每个元素在内层循环中遍历nums1检查是否存在相等值若不存在加入第二个结果集合将两个集合转换为列表并返回[list(res1), list(res2)]。参考代码Pythonclass Solution: def findDifference(self, nums1: list[int], nums2: list[int]) - list[list[int]]: res [set(), set()] for num1 in nums1: found False for num2 in nums2: if num1 num2: found True break if not found: res[0].add(num1) for num2 in nums2: found False for num1 in nums1: if num1 num2: found True break if not found: res[1].add(num2) return [list(res[0]), list(res[1])]Javapublic class Solution { public ListListInteger findDifference(int[] nums1, int[] nums2) { SetInteger res1 new HashSet(); SetInteger res2 new HashSet(); for (int num1 : nums1) { boolean found false; for (int num2 : nums2) { if (num1 num2) { found true; break; } } if (!found) { res1.add(num1); } } for (int num2 : nums2) { boolean found false; for (int num1 : nums1) { if (num1 num2) { found true; break; } } if (!found) { res2.add(num2); } } ListListInteger result new ArrayList(); result.add(new ArrayList(res1)); result.add(new ArrayList(res2)); return result; } }Cclass Solution { public: vectorvectorint findDifference(vectorint nums1, vectorint nums2) { setint res1, res2; for (int num1 : nums1) { bool found false; for (int num2 : nums2) { if (num1 num2) { found true; break; } } if (!found) { res1.insert(num1); } } for (int num2 : nums2) { bool found false; for (int num1 : nums1) { if (num1 num2) { found true; break; } } if (!found) { res2.insert(num2); } } return {vectorint(res1.begin(), res1.end()), vectorint(res2.begin(), res2.end())}; } };JavaScriptclass Solution { /** * param {number[]} nums1 * param {number[]} nums2 * return {number[][]} */ findDifference(nums1, nums2) { const res1 new Set(); const res2 new Set(); for (const num1 of nums1) { let found false; for (const num2 of nums2) { if (num1 num2) { found true; break; } } if (!found) { res1.add(num1); } } for (const num2 of nums2) { let found false; for (const num1 of nums1) { if (num1 num2) { found true; break; } } if (!found) { res2.add(num2); } } return [Array.from(res1), Array.from(res2)]; } }C#public class Solution { public ListListint FindDifference(int[] nums1, int[] nums2) { var res new ListHashSetint { new HashSetint(), new HashSetint() }; foreach (int num1 in nums1) { bool found false; foreach (int num2 in nums2) { if (num1 num2) { found true; break; } } if (!found) res[0].Add(num1); } foreach (int num2 in nums2) { bool found false; foreach (int num1 in nums1) { if (num1 num2) { found true; break; } } if (!found) res[1].Add(num2); } return new ListListint { res[0].ToList(), res[1].ToList() }; } }Gofunc findDifference(nums1 []int, nums2 []int) [][]int { res1 : make(map[int]struct{}) res2 : make(map[int]struct{}) for _, num1 : range nums1 { found : false for _, num2 : range nums2 { if num1 num2 { found true break } } if !found { res1[num1] struct{}{} } } for _, num2 : range nums2 { found : false for _, num1 : range nums1 { if num1 num2 { found true break } } if !found { res2[num2] struct{}{} } } result1, result2 : []int{}, []int{} for k : range res1 { result1 append(result1, k) } for k : range res2 { result2 append(result2, k) } return [][]int{result1, result2} }Kotlinclass Solution { fun findDifference(nums1: IntArray, nums2: IntArray): ListListInt { val res1 mutableSetOfInt() val res2 mutableSetOfInt() for (num1 in nums1) { var found false for (num2 in nums2) { if (num1 num2) { found true break } } if (!found) res1.add(num1) } for (num2 in nums2) { var found false for (num1 in nums1) { if (num1 num2) { found true break } } if (!found) res2.add(num2) } return listOf(res1.toList(), res2.toList()) } }Swiftclass Solution { func findDifference(_ nums1: [Int], _ nums2: [Int]) - [[Int]] { var res1 SetInt() var res2 SetInt() for num1 in nums1 { var found false for num2 in nums2 { if num1 num2 { found true break } } if !found { res1.insert(num1) } } for num2 in nums2 { var found false for num1 in nums1 { if num1 num2 { found true break } } if !found { res2.insert(num2) } } return [Array(res1), Array(res2)] } }Rustimpl Solution { pub fn find_difference(nums1: Veci32, nums2: Veci32) - VecVeci32 { let mut res1: HashSeti32 HashSet::new(); let mut res2: HashSeti32 HashSet::new(); for num1 in nums1 { let mut found false; for num2 in nums2 { if num1 num2 { found true; break; } } if !found { res1.insert(num1); } } for num2 in nums2 { let mut found false; for num1 in nums1 { if num1 num2 { found true; break; } } if !found { res2.insert(num2); } } vec![ res1.into_iter().collect(), res2.into_iter().collect(), ] } }复杂度分析时间复杂度O(n × m)其中 n 为nums1长度m 为nums2长度。每个元素都要与另一个数组全量比对空间复杂度O(n m)两个结果集合在最坏情况下各容纳 n、m 个去重元素。解法二排序 双指针Sorting思路将两个数组排序后元素天然有序可以用双指针同时遍历两个数组进行比较。当指针指向的元素不相等时较小的那个元素在当前数组中不可能再匹配到另一个数组的其余元素因为另一个数组元素只会更大因此它必然是独有元素可以直接收入结果。这种方法免去了暴力解中反复全量扫描的开销。算法步骤对两个输入数组分别排序定义辅助函数helper(A, B)找出数组A中存在、B中不存在的元素用指针j追踪在B中的位置遍历A中的每个唯一元素跳过与前一个相同的值不断推进j直到B[j] 当前元素若j已越界或B[j] ! 当前元素说明该元素只属于A加入结果分别以helper(nums1, nums2)与helper(nums2, nums1)求两个方向的差异返回两个结果列表。参考代码Pythonclass Solution: def findDifference(self, nums1: list[int], nums2: list[int]) - list[list[int]]: nums1.sort() nums2.sort() def helper(A, B): n, m len(A), len(B) res [] j 0 prev float(-inf) for num in A: if prev num: continue while j m and B[j] num: j 1 if j m or B[j] ! num: res.append(num) prev num return res return [helper(nums1, nums2), helper(nums2, nums1)]Javapublic class Solution { public ListListInteger findDifference(int[] nums1, int[] nums2) { Arrays.sort(nums1); Arrays.sort(nums2); ListInteger diff1 helper(nums1, nums2); ListInteger diff2 helper(nums2, nums1); ListListInteger result new ArrayList(); result.add(diff1); result.add(diff2); return result; } private ListInteger helper(int[] A, int[] B) { int n A.length, m B.length, j 0; ListInteger res new ArrayList(); int prev Integer.MIN_VALUE; for (int num : A) { if (num prev) continue; while (j m B[j] num) j; if (j m || B[j] ! num) res.add(num); prev num; } return res; } }Cclass Solution { public: vectorvectorint findDifference(vectorint nums1, vectorint nums2) { sort(nums1.begin(), nums1.end()); sort(nums2.begin(), nums2.end()); return {helper(nums1, nums2), helper(nums2, nums1)}; } private: vectorint helper(vectorint A, vectorint B) { vectorint res; int n A.size(), m B.size(), j 0, prev INT_MIN; for (int num : A) { if (num prev) continue; while (j m B[j] num) j; if (j m || B[j] ! num) res.push_back(num); prev num; } return res; } };JavaScriptclass Solution { /** * param {number[]} nums1 * param {number[]} nums2 * return {number[][]} */ findDifference(nums1, nums2) { nums1.sort((a, b) a - b); nums2.sort((a, b) a - b); const helper (A, B) { const res []; let j 0; let prev -Infinity; for (const num of A) { if (num prev) continue; while (j B.length B[j] num) j; if (j B.length || B[j] ! num) res.push(num); prev num; } return res; }; return [helper(nums1, nums2), helper(nums2, nums1)]; } }C#public class Solution { public ListListint FindDifference(int[] nums1, int[] nums2) { var num1Set new HashSetint(nums1); var num2Set new HashSetint(nums2); var res1 new Listint(); var res2 new Listint(); foreach (int num in num1Set) { if (!num2Set.Contains(num)) res1.Add(num); } foreach (int num in num2Set) { if (!num1Set.Contains(num)) res2.Add(num); } return new ListListint { res1, res2 }; } }Gofunc findDifference(nums1 []int, nums2 []int) [][]int { sort.Ints(nums1) sort.Ints(nums2) helper : func(A, B []int) []int { res : []int{} j : 0 prev : math.MinInt32 for _, num : range A { if num prev { continue } for j len(B) B[j] num { j } if j len(B) || B[j] ! num { res append(res, num) } prev num } return res } return [][]int{helper(nums1, nums2), helper(nums2, nums1)} }Kotlinclass Solution { fun findDifference(nums1: IntArray, nums2: IntArray): ListListInt { nums1.sort() nums2.sort() fun helper(A: IntArray, B: IntArray): ListInt { val res mutableListOfInt() var j 0 var prev Int.MIN_VALUE for (num in A) { if (num prev) continue while (j B.size B[j] num) j if (j B.size || B[j] ! num) res.add(num) prev num } return res } return listOf(helper(nums1, nums2), helper(nums2, nums1)) } }Swiftclass Solution { func findDifference(_ nums1: [Int], _ nums2: [Int]) - [[Int]] { let sortedNums1 nums1.sorted() let sortedNums2 nums2.sorted() func helper(_ A: [Int], _ B: [Int]) - [Int] { var res [Int]() var j 0 var prev Int.min for num in A { if num prev { continue } while j B.count B[j] num { j 1 } if j B.count || B[j] ! num { res.append(num) } prev num } return res } return [helper(sortedNums1, sortedNums2), helper(sortedNums2, sortedNums1)] } }Rustimpl Solution { pub fn find_difference(mut nums1: Veci32, mut nums2: Veci32) - VecVeci32 { nums1.sort(); nums2.sort(); fn helper(a: [i32], b: [i32]) - Veci32 { let mut res Vec::new(); let mut j 0; let mut prev i32::MIN; for num in a { if num prev { continue; } while j b.len() b[j] num { j 1; } if j b.len() || b[j] ! num { res.push(num); } prev num; } res } vec![helper(nums1, nums2), helper(nums2, nums1)] } }复杂度分析时间复杂度O(n log n m log m)排序是主要开销排序后的双指针遍历为线性空间复杂度O(1) 或 O(n m)取决于所用排序算法是否原地如 Python 的 Timsort、Go 的sort.Ints都会产生额外空间。解法三哈希集合Hash Set——推荐解法思路哈希集合提供 O(1) 平均查找时间非常适合成员判断。把两个数组分别转成集合既去掉了重复值又能快速判断任意元素是否出现在另一个集合中。相比暴力解的内层全量扫描哈希集合把每次查找从 O(m) 降到 O(1)整体变为线性复杂度是本题最实用的解法。算法步骤将nums1、nums2分别转换为哈希集合去重并支持快速查找为在nums1中而不在nums2中的元素创建结果列表遍历第一个集合把不在第二个集合中的元素加入结果一对第二个集合做对称操作得到结果二返回两个结果列表。参考代码Pythonclass Solution: def findDifference(self, nums1: List[int], nums2: List[int]) - List[List[int]]: num1Set, num2Set set(nums1), set(nums2) res1, res2 [], [] for num in num1Set: if num not in num2Set: res1.append(num) for num in num2Set: if num not in num1Set: res2.append(num) return [res1, res2]Javapublic class Solution { public ListListInteger findDifference(int[] nums1, int[] nums2) { SetInteger num1Set new HashSet(); SetInteger num2Set new HashSet(); for (int num : nums1) num1Set.add(num); for (int num : nums2) num2Set.add(num); ListInteger res1 new ArrayList(); ListInteger res2 new ArrayList(); for (int num : num1Set) { if (!num2Set.contains(num)) res1.add(num); } for (int num : num2Set) { if (!num1Set.contains(num)) res2.add(num); } return Arrays.asList(res1, res2); } }Cclass Solution { public: vectorvectorint findDifference(vectorint nums1, vectorint nums2) { unordered_setint num1Set(nums1.begin(), nums1.end()); unordered_setint num2Set(nums2.begin(), nums2.end()); vectorint res1, res2; for (int num : num1Set) { if (num2Set.find(num) num2Set.end()) res1.push_back(num); } for (int num : num2Set) { if (num1Set.find(num) num1Set.end()) res2.push_back(num); } return {res1, res2}; } };JavaScriptclass Solution { /** * param {number[]} nums1 * param {number[]} nums2 * return {number[][]} */ findDifference(nums1, nums2) { const num1Set new Set(nums1); const num2Set new Set(nums2); const res1 []; const res2 []; for (const num of num1Set) { if (!num2Set.has(num)) res1.push(num); } for (const num of num2Set) { if (!num1Set.has(num)) res2.push(num); } return [res1, res2]; } }C#public class Solution { public ListListint FindDifference(int[] nums1, int[] nums2) { var numSet1 new HashSetint(nums1); var numSet2 new HashSetint(nums2); var res1 new Listint(numSet1); res1.RemoveAll(num numSet2.Contains(num)); var res2 new Listint(numSet2); res2.RemoveAll(num numSet1.Contains(num)); return new ListListint { res1, res2 }; } }Gofunc findDifference(nums1 []int, nums2 []int) [][]int { num1Set : make(map[int]struct{}) num2Set : make(map[int]struct{}) for _, num : range nums1 { num1Set[num] struct{}{} } for _, num : range nums2 { num2Set[num] struct{}{} } res1, res2 : []int{}, []int{} for num : range num1Set { if _, exists : num2Set[num]; !exists { res1 append(res1, num) } } for num : range num2Set { if _, exists : num1Set[num]; !exists { res2 append(res2, num) } } return [][]int{res1, res2} }Kotlinclass Solution { fun findDifference(nums1: IntArray, nums2: IntArray): ListListInt { val num1Set nums1.toHashSet() val num2Set nums2.toHashSet() val res1 num1Set.filter { it !in num2Set } val res2 num2Set.filter { it !in num1Set } return listOf(res1, res2) } }Swiftclass Solution { func findDifference(_ nums1: [Int], _ nums2: [Int]) - [[Int]] { let num1Set Set(nums1) let num2Set Set(nums2) let res1 num1Set.filter { !num2Set.contains($0) } let res2 num2Set.filter { !num1Set.contains($0) } return [Array(res1), Array(res2)] } }Rustimpl Solution { pub fn find_difference(nums1: Veci32, nums2: Veci32) - VecVeci32 { let num1_set: HashSeti32 nums1.into_iter().collect(); let num2_set: HashSeti32 nums2.into_iter().collect(); let res1: Veci32 num1_set.iter().filter(|x| !num2_set.contains(x)).cloned().collect(); let res2: Veci32 num2_set.iter().filter(|x| !num1_set.contains(x)).cloned().collect(); vec![res1, res2] } }复杂度分析时间复杂度O(n m)每个元素最多被处理常数次空间复杂度O(n m)两个哈希集合在极端情况下容纳全部元素。仓库源码佐证本仓库多语言提交都采用了这一思路。例如 python/2215-find-the-difference-of-two-arrays.py 中的核心提交即先将数组转集合再用if num not in nums2_set做成员判断收集结果cpp/2215-find-the-difference-of-two-arrays.cpp 用unordered_setint构造集合并以nums2Set.find(num) nums2Set.end()判断缺失javascript/2215-find-the-difference-of-two-arrays.js 用Array.from(nums1Set).filter((num) !nums2Set.has(num))一行完成过滤。三份代码均标注了Time Complexity: O(m n)与Space Complexity: O(m n)与上文分析一致。解法四内建集合差运算Hash Set Difference思路许多编程语言直接提供集合差运算A − B 返回属于 A 但不属于 B的全部元素与本题目要求完全吻合。直接调用库函数可以把代码压缩到极致且底层多为经过优化的实现代码可读性最高适合作为生产环境中的简洁写法。算法步骤将两个数组分别转换为集合计算set1 - set2得到仅属于nums1的元素计算set2 - set1得到仅属于nums2的元素将两个结果转换为列表返回。参考代码Pythonclass Solution: def findDifference(self, nums1: List[int], nums2: List[int]) - List[List[int]]: numSet1, numSet2 set(nums1), set(nums2) return [list(numSet1 - numSet2), list(numSet2 - numSet1)]Javapublic class Solution { public ListListInteger findDifference(int[] nums1, int[] nums2) { SetInteger numSet1 new HashSet(); SetInteger numSet2 new HashSet(); for (int num : nums1) numSet1.add(num); for (int num : nums2) numSet2.add(num); ListInteger res1 new ArrayList(numSet1); res1.removeAll(numSet2); ListInteger res2 new ArrayList(numSet2); res2.removeAll(numSet1); return Arrays.asList(res1, res2); } }Cclass Solution { public: vectorvectorint findDifference(vectorint nums1, vectorint nums2) { vectorint res1, res2; setint numSet1(begin(nums1), end(nums1)), numSet2(begin(nums2), end(nums2)); set_difference(begin(numSet1), end(numSet1), begin(numSet2), end(numSet2), back_inserter(res1)); set_difference(begin(numSet2), end(numSet2), begin(numSet1), end(numSet1), back_inserter(res2)); return {res1, res2}; } };JavaScriptclass Solution { /** * param {number[]} nums1 * param {number[]} nums2 * return {number[][]} */ findDifference(nums1, nums2) { const numSet1 new Set(nums1); const numSet2 new Set(nums2); const res1 Array.from(numSet1).filter((num) !numSet2.has(num)); const res2 Array.from(numSet2).filter((num) !numSet1.has(num)); return [res1, res2]; } }C#public class Solution { public ListListint FindDifference(int[] nums1, int[] nums2) { Array.Sort(nums1); Array.Sort(nums2); var diff1 Helper(nums1, nums2); var diff2 Helper(nums2, nums1); return new ListListint { diff1, diff2 }; } private Listint Helper(int[] A, int[] B) { int n A.Length, m B.Length, j 0; var res new Listint(); int prev int.MinValue; foreach (int num in A) { if (num prev) continue; while (j m B[j] num) j; if (j m || B[j] ! num) res.Add(num); prev num; } return res; } }Gofunc findDifference(nums1 []int, nums2 []int) [][]int { numSet1 : make(map[int]struct{}) numSet2 : make(map[int]struct{}) for _, num : range nums1 { numSet1[num] struct{}{} } for _, num : range nums2 { numSet2[num] struct{}{} } res1, res2 : []int{}, []int{} for num : range numSet1 { if _, exists : numSet2[num]; !exists { res1 append(res1, num) } } for num : range numSet2 { if _, exists : numSet1[num]; !exists { res2 append(res2, num) } } return [][]int{res1, res2} }Kotlinclass Solution { fun findDifference(nums1: IntArray, nums2: IntArray): ListListInt { val numSet1 nums1.toHashSet() val numSet2 nums2.toHashSet() return listOf( (numSet1 - numSet2).toList(), (numSet2 - numSet1).toList() ) } }Swiftclass Solution { func findDifference(_ nums1: [Int], _ nums2: [Int]) - [[Int]] { let numSet1 Set(nums1) let numSet2 Set(nums2) return [ Array(numSet1.subtracting(numSet2)), Array(numSet2.subtracting(numSet1)) ] } }Rustimpl Solution { pub fn find_difference(nums1: Veci32, nums2: Veci32) - VecVeci32 { let num_set1: HashSeti32 nums1.into_iter().collect(); let num_set2: HashSeti32 nums2.into_iter().collect(); vec![ num_set1.difference(num_set2).cloned().collect(), num_set2.difference(num_set1).cloned().collect(), ] } }复杂度分析时间复杂度O(n m)空间复杂度O(n m)。两种哈希集合解法的复杂度相同解法四的差异在于直接用语言内建的集合差语义表达问题代码更短、意图更清晰适合代码可读性优先的场景。仓库实现变体从集合到计数数组本仓库的 c/2215-find-the-difference-of-two-arrays.c 提供了两版值得注意的实现展示了同一道题在不同约束下的工程化写法变体一三路快排 双指针。由于 C 语言没有内建集合该实现先用自写的三路快速排序quicksort/partition3对两个数组排序随后在processArrays中用双指针推进两指针元素相等则同步前进nums1元素较小则它只属于nums1写入结果一并推进反之写入结果二。循环结束后再把两个数组剩余的唯一元素收尾。skipRepeatedValues负责跳过连续重复值保证结果去重。这正是解法二排序 双指针的完整 C 语言落地。变体二值域偏移计数表。题目数据范围允许的前提下该实现分配calloc(2001, sizeof(int))的计数数组以nums[i] 1000作为下标即把值域 [-1000, 1000] 偏移映射到 [0, 2000]第一遍扫描把nums1中出现过的位置置 1第二遍扫描nums2若对应位为 0 说明该值只属于nums2写入结果二并把该位置为 -1 防止重复最后遍历计数表仍为 1 的位置即只属于nums1的值。这是哈希集合思路在值域有限前提下的 O(1) 空间变体可作为理解哈希函数 冲突规避的启蒙案例。此外java/2215-find-the-difference-of-two-arrays.java 展示了另一条思路用List.contains线性判断后再借HashSet去重收集结果本质是暴力法的先判重再查重写法便于对比不同去重时机的影响。常见陷阱Common Pitfalls陷阱一结果中出现重复值题目要求返回不同distinct整数。如果直接遍历原始数组而不是集合同一个值可能被多次加入结果例如nums1 [1, 1, 2]若不先转集合1会被加入两次。务必使用集合去重或在循环中显式记录已见值保证输出中每个元素只出现一次。陷阱二弄混两个结果列表的归属返回值是两个列表第一个装在nums1中但不在nums2中的元素第二个装在nums2中但不在nums1中的元素。两个差集方向相反写反会导致整个答案错误。提交前建议用nums1 [1,2,3], nums2 [2,4,6]这类样例自查期望输出应为[[1,3],[4,6]]。陷阱三排序解中忘记跳过相邻重复值排序 双指针解法中A数组排序后相邻重复值会在每次B[j] num推进后依然命中同一个位置若不通过prev记录上一个处理值并continue跳过同一元素会被重复加入结果——这正是各语言实现中prev变量的作用。四种解法对比总结解法核心思想时间复杂度空间复杂度适用场景暴力枚举双层循环全量比对 集合去重O(n × m)O(n m)数据量极小、仅作教学演示排序 双指针排序后用指针线性推进O(n log n m log m)O(1) 或 O(n m)无哈希表环境或需原地处理哈希集合集合去重 O(1) 成员判断O(n m)O(n m)通用场景最推荐内建集合差直接调用库函数求差集O(n m)O(n m)代码简洁性优先其中 n 为nums1长度m 为nums2长度。日常刷题与面试中解法三哈希集合是兼顾效率与可读性的首选若语言内建集合差运算如 Python 的-、Swift 的subtracting、Rust 的difference语义清晰解法四同样值得采用。更多同主题的多语言提交可继续查阅本仓库的 typescript/2215-find-the-difference-of-two-arrays.ts、kotlin/2215-find-the-difference-of-two-arrays.kt 与 rust/2215-find-the-difference-of-two-arrays.rs对照学习各语言的集合惯用法。【免费下载链接】leetcodeLeetcode solutions项目地址: https://gitcode.com/GitHub_Trending/leetcode1/leetcode创作声明：本文部分内容由AI辅助生成（AIGC），仅供参考