LeetCode 260 Single Number III 深度全解从暴力到 O(1) 空间的位运算分组技巧【免费下载链接】leetcodeLeetcode solutions项目地址: https://gitcode.com/GitHub_Trending/leetcode1/leetcode导读Single Number IIILeetCode 260是经典的只出现一次的数字进阶题给定一个整数数组其中恰好有两个元素只出现一次其余元素均恰好出现两次要求找出这两个只出现一次的元素。本题是仓库姊妹题 Single NumberLeetCode 136单数版本的自然延伸其核心难点在于全局异或只能得到a ^ b还需要一个额外的差异位分组步骤才能分离出两个答案。本文将系统拆解 6 种解法暴力、哈希表、哈希集合、排序、两种位运算变体每种解法均附带 Python / Java / C / JavaScript / C# / Go / Kotlin / Swift / Rust 九种语言的完整可运行实现与复杂度分析并深入剖析位运算分组背后的数学原理与常见陷阱帮助你彻底掌握这一高频位运算考点。前置知识在着手解决本题之前建议先熟悉以下三块基础能力位运算XOR理解 XOR 的核心性质a ^ a 0、a ^ 0 a以及如何用x (-x)隔离出x的最低置位rightmost set bit。这是本题最优解的关键。哈希表 / 哈希集合用于在 $O(n)$ 空间解法中统计出现次数或追踪已见元素。对应仓库实现可参考 python/0136-single-number.py 中基于集合的写法。排序另一种替代思路——排序后重复元素变为相邻可通过一次线性扫描找出孤立元素。姊妹题文档 articles/single-number.md 中对该思路有更完整的铺垫讲解。问题回顾与思路总览与 LeetCode 136唯一一个元素出现一次不同本题保证恰好两个元素各出现一次。因此不能简单地全体异或收工——全体异或得到的是a ^ b而不是a和b本身。所有解法本质上都在回答同一个问题如何从a ^ b中把a和b拆开。解法核心思想时间复杂度空间复杂度1. 暴力法双层循环逐个比对$O(n^2)$$O(1)$2. 哈希表统计每个数的出现次数$O(n)$$O(n)$3. 哈希集合首次出现加入、再次出现移除$O(n)$$O(n)$4. 排序排序后相邻比较$O(n \log n)$$O(1)$ 或 $O(n)$5. 位运算 XOR最低置位循环查找用差异位分组再分别异或$O(n)$$O(1)$6. 位运算 XORx (-x)取最低置位一步取得差异位$O(n)$$O(1)$下文按从易到难的顺序逐一展开。解法一暴力法Brute Force直觉最直接的做法是拿每个元素与其他所有元素逐一比对如果某个元素在数组中找不到第二个副本那它必然是那两个唯一数字之一收集到两个这样的元素后即可返回。算法步骤初始化一个空的结果列表。对索引i处的每个元素逐一检查索引j处的所有其他元素。若找不到任何匹配该元素唯一将其加入结果列表。一旦找到两个唯一元素即停止。返回结果。多语言实现class Solution: def singleNumber(self, nums: List[int]) - List[int]: n, res len(nums), [] for i in range(n): flag True for j in range(n): if i ! j and nums[i] nums[j]: flag False break if flag: res.append(nums[i]) if len(res) 2: break return respublic class Solution { public int[] singleNumber(int[] nums) { int n nums.length; ListInteger res new ArrayList(); for (int i 0; i n; i) { boolean flag true; for (int j 0; j n; j) { if (i ! j nums[i] nums[j]) { flag false; break; } } if (flag) { res.add(nums[i]); if (res.size() 2) { break; } } } return new int[] {res.get(0), res.get(1)}; } }class Solution { public: vectorint singleNumber(vectorint nums) { int n nums.size(); vectorint res; for (int i 0; i n; i) { bool flag true; for (int j 0; j n; j) { if (i ! j nums[i] nums[j]) { flag false; break; } } if (flag) { res.push_back(nums[i]); if (res.size() 2) { break; } } } return res; } };class Solution { /** * param {number[]} nums * return {number[]} */ singleNumber(nums) { const n nums.length; const res []; for (let i 0; i n; i) { let flag true; for (let j 0; j n; j) { if (i ! j nums[i] nums[j]) { flag false; break; } } if (flag) { res.push(nums[i]); if (res.length 2) { break; } } } return res; } }public class Solution { public int[] SingleNumber(int[] nums) { int n nums.Length; Listint res new Listint(); for (int i 0; i n; i) { bool flag true; for (int j 0; j n; j) { if (i ! j nums[i] nums[j]) { flag false; break; } } if (flag) { res.Add(nums[i]); if (res.Count 2) { break; } } } return new int[] { res[0], res[1] }; } }func singleNumber(nums []int) []int { n : len(nums) res : []int{} for i : 0; i n; i { flag : true for j : 0; j n; j { if i ! j nums[i] nums[j] { flag false break } } if flag { res append(res, nums[i]) if len(res) 2 { break } } } return res }class Solution { fun singleNumber(nums: IntArray): IntArray { val n nums.size val res mutableListOfInt() for (i in 0 until n) { var flag true for (j in 0 until n) { if (i ! j nums[i] nums[j]) { flag false break } } if (flag) { res.add(nums[i]) if (res.size 2) break } } return intArrayOf(res[0], res[1]) } }class Solution { func singleNumber(_ nums: [Int]) - [Int] { let n nums.count var res [Int]() for i in 0..n { var flag true for j in 0..n { if i ! j nums[i] nums[j] { flag false break } } if flag { res.append(nums[i]) if res.count 2 { break } } } return res } }impl Solution { pub fn single_number(nums: Veci32) - Veci32 { let n nums.len(); let mut res Vec::new(); for i in 0..n { let mut flag true; for j in 0..n { if i ! j nums[i] nums[j] { flag false; break; } } if flag { res.push(nums[i]); if res.len() 2 { break; } } } res } }复杂度分析时间复杂度$O(n^2)$——每个元素都要与其余元素比对一遍。空间复杂度$O(1)$ 额外空间不计输出结果。解法二哈希表Hash Map直觉用哈希表统计每个数字的出现次数。出现次数恰好为 1 的数字就是我们要找的两个唯一元素。这种做法用空间换时间把时间复杂度从平方级降到线性级。算法步骤创建哈希表统计每个数字的出现次数。遍历数组并更新计数。收集所有计数为1的键到结果中。返回包含两个唯一数字的结果。多语言实现class Solution: def singleNumber(self, nums: List[int]) - List[int]: count {} for num in nums: count[num] 1 count.get(num, 0) return [k for k in count if count[k] 1]public class Solution { public int[] singleNumber(int[] nums) { MapInteger, Integer count new HashMap(); for (int num : nums) { count.put(num, count.getOrDefault(num, 0) 1); } ArrayListInteger res new ArrayList(); for (int key : count.keySet()) { if (count.get(key) 1) { res.add(key); } } return new int[] {res.get(0), res.get(1)}; } }class Solution { public: vectorint singleNumber(vectorint nums) { unordered_mapint, int count; for (int num : nums) { count[num]; } vectorint res; for (const auto pair : count) { if (pair.second 1) { res.push_back(pair.first); } } return res; } };class Solution { /** * param {number[]} nums * return {number[]} */ singleNumber(nums) { const count new Map(); for (const num of nums) { count.set(num, (count.get(num) || 0) 1); } const res []; for (const [key, value] of count) { if (value 1) { res.push(key); } } return res; } }public class Solution { public int[] SingleNumber(int[] nums) { Dictionaryint, int count new Dictionaryint, int(); foreach (int num in nums) { if (count.ContainsKey(num)) { count[num]; } else { count[num] 1; } } Listint res new Listint(); foreach (var key in count.Keys) { if (count[key] 1) { res.Add(key); } } return new int[] { res[0], res[1] }; } }func singleNumber(nums []int) []int { count : make(map[int]int) for _, num : range nums { count[num] } res : []int{} for k, v : range count { if v 1 { res append(res, k) } } return res }class Solution { fun singleNumber(nums: IntArray): IntArray { val count HashMapInt, Int() for (num in nums) { count[num] count.getOrDefault(num, 0) 1 } val res mutableListOfInt() for ((key, value) in count) { if (value 1) { res.add(key) } } return intArrayOf(res[0], res[1]) } }class Solution { func singleNumber(_ nums: [Int]) - [Int] { var count [Int: Int]() for num in nums { count[num, default: 0] 1 } var res [Int]() for (key, value) in count { if value 1 { res.append(key) } } return res } }impl Solution { pub fn single_number(nums: Veci32) - Veci32 { let mut count HashMap::new(); for num in nums { *count.entry(num).or_insert(0) 1; } count.into_iter() .filter(|(_, v)| v 1) .map(|(k, _)| k) .collect() } }复杂度分析时间复杂度$O(n)$——两次线性扫描统计 收集。空间复杂度$O(n)$——哈希表需要存储去重后的全部键。解法三哈希集合Hash Set直觉哈希集合可以追踪已经见过的数字第一次遇到某个数时把它加入集合再次遇到时把它移除。处理完所有数字后集合中恰好只剩那两个出现一次的元素。算法步骤初始化一个空哈希集合。遍历数组中的每个数字若数字已在集合中将其移除否则将其加入集合。将集合转换为列表并返回。多语言实现class Solution: def singleNumber(self, nums: List[int]) - List[int]: seen set() for num in nums: if num in seen: seen.remove(num) else: seen.add(num) return list(seen)public class Solution { public int[] singleNumber(int[] nums) { HashSetInteger seen new HashSet(); for (int num : nums) { if (seen.contains(num)) { seen.remove(num); } else { seen.add(num); } } int[] res new int[2]; int index 0; for (int num : seen) { res[index] num; } return res; } }class Solution { public: vectorint singleNumber(vectorint nums) { unordered_setint seen; for (int num : nums) { if (seen.count(num)) { seen.erase(num); } else { seen.insert(num); } } return vectorint(seen.begin(), seen.end()); } };class Solution { /** * param {number[]} nums * return {number[]} */ singleNumber(nums) { const seen new Set(); for (const num of nums) { if (seen.has(num)) { seen.delete(num); } else { seen.add(num); } } return Array.from(seen); } }public class Solution { public int[] SingleNumber(int[] nums) { HashSetint seen new HashSetint(); foreach (int num in nums) { if (seen.Contains(num)) { seen.Remove(num); } else { seen.Add(num); } } int[] res new int[2]; int index 0; foreach (int num in seen) { res[index] num; } return res; } }func singleNumber(nums []int) []int { seen : make(map[int]bool) for _, num : range nums { if seen[num] { delete(seen, num) } else { seen[num] true } } res : []int{} for num : range seen { res append(res, num) } return res }class Solution { fun singleNumber(nums: IntArray): IntArray { val seen HashSetInt() for (num in nums) { if (num in seen) { seen.remove(num) } else { seen.add(num) } } return seen.toIntArray() } }class Solution { func singleNumber(_ nums: [Int]) - [Int] { var seen SetInt() for num in nums { if seen.contains(num) { seen.remove(num) } else { seen.insert(num) } } return Array(seen) } }impl Solution { pub fn single_number(nums: Veci32) - Veci32 { let mut seen HashSet::new(); for num in nums { if !seen.remove(num) { seen.insert(num); } } seen.into_iter().collect() } }复杂度分析时间复杂度$O(n)$——单次线性扫描集合的插入与删除平均为 $O(1)$。空间复杂度$O(n)$——最坏情况下集合中元素规模与数组长度同阶。与姊妹题 Single NumberLeetCode 136中的哈希集合写法对比可以发现两者思路几乎一致区别仅在于 136 题最终集合只剩一个元素而本题剩两个。仓库中的哈希集合模板实现可参考 python/0136-single-number.py 与 cpp/0136-single-number.cpp 等对应源码。解法四排序Sorting直觉排序会把重复的数字聚在一起。排序后每个有副本的元素必然与它的左邻或右邻相等而那些与左右邻居都不相等的元素就是我们要找的唯一数字。算法步骤对数组排序。遍历每个索引i。若nums[i]与nums[i-1]若存在和nums[i1]若存在都不相等则它是唯一的。收集所有唯一元素并返回。多语言实现class Solution: def singleNumber(self, nums: List[int]) - List[int]: res, n [], len(nums) nums.sort() for i in range(n): if ((i 0 and nums[i] nums[i - 1]) or (i 1 n and nums[i] nums[i 1])): continue res.append(nums[i]) return respublic class Solution { public int[] singleNumber(int[] nums) { Arrays.sort(nums); ListInteger res new ArrayList(); int n nums.length; for (int i 0; i n; i) { if ((i 0 nums[i] nums[i - 1]) || (i 1 n nums[i] nums[i 1])) { continue; } res.add(nums[i]); } return res.stream().mapToInt(i - i).toArray(); } }class Solution { public: vectorint singleNumber(vectorint nums) { sort(nums.begin(), nums.end()); vectorint res; int n nums.size(); for (int i 0; i n; i) { if ((i 0 nums[i] nums[i - 1]) || (i 1 n nums[i] nums[i 1])) { continue; } res.push_back(nums[i]); } return res; } };class Solution { /** * param {number[]} nums * return {number[]} */ singleNumber(nums) { nums.sort((a, b) a - b); const res []; const n nums.length; for (let i 0; i n; i) { if ( (i 0 nums[i] nums[i - 1]) || (i 1 n nums[i] nums[i 1]) ) { continue; } res.push(nums[i]); } return res; } }public class Solution { public int[] SingleNumber(int[] nums) { Array.Sort(nums); Listint res new Listint(); int n nums.Length; for (int i 0; i n; i) { if ((i 0 nums[i] nums[i - 1]) || (i 1 n nums[i] nums[i 1])) { continue; } res.Add(nums[i]); } return res.ToArray(); } }func singleNumber(nums []int) []int { sort.Ints(nums) res : []int{} n : len(nums) for i : 0; i n; i { if (i 0 nums[i] nums[i-1]) || (i1 n nums[i] nums[i1]) { continue } res append(res, nums[i]) } return res }class Solution { fun singleNumber(nums: IntArray): IntArray { nums.sort() val res mutableListOfInt() val n nums.size for (i in 0 until n) { if ((i 0 nums[i] nums[i - 1]) || (i 1 n nums[i] nums[i 1])) { continue } res.add(nums[i]) } return res.toIntArray() } }class Solution { func singleNumber(_ nums: [Int]) - [Int] { let nums nums.sorted() var res [Int]() let n nums.count for i in 0..n { if (i 0 nums[i] nums[i - 1]) || (i 1 n nums[i] nums[i 1]) { continue } res.append(nums[i]) } return res } }impl Solution { pub fn single_number(nums: Veci32) - Veci32 { let mut nums nums; nums.sort_unstable(); let n nums.len(); let mut res Vec::new(); for i in 0..n { if (i 0 nums[i] nums[i - 1]) || (i 1 n nums[i] nums[i 1]) { continue; } res.push(nums[i]); } res } }复杂度分析时间复杂度$O(n \log n)$——主要开销在排序。空间复杂度$O(1)$ 或 $O(n)$——取决于具体语言排序算法的实现如原地快排为 $O(\log n)$ 栈空间归并排序为 $O(n)$。解法五位运算 XOR最低置位循环查找直觉对所有数字做异或得到a ^ b其中a、b是两个唯一数字。因为a ! b异或结果中至少有一个位为 1这个位正是a与b的二进制表示中不同的位。用这个差异位把全体数字分成两组一组包含a一组包含b。由于每个重复数字的两个副本必然落入同一组它们在差异位上取值相同各自组内做异或即可抵消所有重复项最终分别得到a和b。算法步骤全体异或得到a ^ b。从最低位开始逐位查找找到异或结果中第一个为1的位diff_bit。按该位是否为 1 将数字分成两组。分别对两组做异或得到a和b。返回两个唯一数字。多语言实现class Solution: def singleNumber(self, nums: List[int]) - List[int]: xor 0 for num in nums: xor ^ num diff_bit 1 while not (xor diff_bit): diff_bit 1 a b 0 for num in nums: if diff_bit num: a ^ num else: b ^ num return [a, b]public class Solution { public int[] singleNumber(int[] nums) { int xor 0; for (int num : nums) { xor ^ num; } int diff_bit 1; while ((xor diff_bit) 0) { diff_bit 1; } int a 0, b 0; for (int num : nums) { if ((num diff_bit) ! 0) { a ^ num; } else { b ^ num; } } return new int[]{a, b}; } }class Solution { public: vectorint singleNumber(vectorint nums) { int xor_all 0; for (int num : nums) { xor_all ^ num; } int diff_bit 1; while ((xor_all diff_bit) 0) { diff_bit 1; } int a 0, b 0; for (int num : nums) { if (num diff_bit) { a ^ num; } else { b ^ num; } } return {a, b}; } };class Solution { /** * param {number[]} nums * return {number[]} */ singleNumber(nums) { let xor 0; for (const num of nums) { xor ^ num; } let diff_bit 1; while ((xor diff_bit) 0) { diff_bit 1; } let a 0, b 0; for (const num of nums) { if (num diff_bit) { a ^ num; } else { b ^ num; } } return [a, b]; } }public class Solution { public int[] SingleNumber(int[] nums) { int xor 0; foreach (int num in nums) { xor ^ num; } int diffBit 1; while ((xor diffBit) 0) { diffBit 1; } int a 0, b 0; foreach (int num in nums) { if ((num diffBit) ! 0) { a ^ num; } else { b ^ num; } } return new int[] { a, b }; } }func singleNumber(nums []int) []int { xorVal : 0 for _, num : range nums { xorVal ^ num } diffBit : 1 for xorValdiffBit 0 { diffBit 1 } a, b : 0, 0 for _, num : range nums { if numdiffBit ! 0 { a ^ num } else { b ^ num } } return []int{a, b} }class Solution { fun singleNumber(nums: IntArray): IntArray { var xorVal 0 for (num in nums) { xorVal xorVal xor num } var diffBit 1 while (xorVal and diffBit 0) { diffBit diffBit shl 1 } var a 0 var b 0 for (num in nums) { if (num and diffBit ! 0) { a a xor num } else { b b xor num } } return intArrayOf(a, b) } }class Solution { func singleNumber(_ nums: [Int]) - [Int] { var xorVal 0 for num in nums { xorVal ^ num } var diffBit 1 while xorVal diffBit 0 { diffBit 1 } var a 0, b 0 for num in nums { if num diffBit ! 0 { a ^ num } else { b ^ num } } return [a, b] } }impl Solution { pub fn single_number(nums: Veci32) - Veci32 { let mut xor 0; for num in nums { xor ^ num; } let mut diff_bit 1; while xor diff_bit 0 { diff_bit 1; } let (mut a, mut b) (0, 0); for num in nums { if num diff_bit ! 0 { a ^ num; } else { b ^ num; } } vec![a, b] } }复杂度分析时间复杂度$O(n)$——两趟线性扫描查找差异位的循环最多 32 次32 位整数可视为常数。空间复杂度$O(1)$ 额外空间。解法六位运算 XORx (-x)一步取最低置位直觉本解法与解法五思路相同但用一个更巧妙的技巧直接找到差异位表达式x (-x)可以一步隔离出x的最低置位rightmost set bit。把它作用在全体异或结果a ^ b上无需循环即可立即得到一个a与b不同的位。原理说明对于任意整数x-x是x的补码按位取反加一。x (-x)的结果中只有最低的那个置位保持为 1其余位全部为 0。例如x 0b1100时x (-x) 0b0100。算法步骤全体异或得到a ^ b。计算diff_bit xor (-xor)直接得到最低置位。按diff_bit将数字分成两组。组内分别异或得到a和b。返回两个唯一数字。多语言实现class Solution: def singleNumber(self, nums: List[int]) - List[int]: xor 0 for num in nums: xor ^ num diff_bit xor (-xor) a b 0 for num in nums: if diff_bit num: a ^ num else: b ^ num return [a, b]public class Solution { public int[] singleNumber(int[] nums) { int xor 0; for (int num : nums) { xor ^ num; } int diff_bit xor (-xor); int a 0, b 0; for (int num : nums) { if ((num diff_bit) ! 0) { a ^ num; } else { b ^ num; } } return new int[]{a, b}; } }class Solution { public: vectorint singleNumber(vectorint nums) { uint xor_all 0; for (int num : nums) { xor_all ^ num; } int diff_bit xor_all (-xor_all); int a 0, b 0; for (int num : nums) { if (num diff_bit) { a ^ num; } else { b ^ num; } } return {a, b}; } };class Solution { /** * param {number[]} nums * return {number[]} */ singleNumber(nums) { let xor 0; for (const num of nums) { xor ^ num; } let diff_bit xor -xor; let a 0, b 0; for (const num of nums) { if (num diff_bit) { a ^ num; } else { b ^ num; } } return [a, b]; } }public class Solution { public int[] SingleNumber(int[] nums) { int xor 0; foreach (int num in nums) { xor ^ num; } int diffBit xor -xor; int a 0, b 0; foreach (int num in nums) { if ((num diffBit) ! 0) { a ^ num; } else { b ^ num; } } return new int[] { a, b }; } }func singleNumber(nums []int) []int { xorVal : 0 for _, num : range nums { xorVal ^ num } diffBit : xorVal -xorVal a, b : 0, 0 for _, num : range nums { if numdiffBit ! 0 { a ^ num } else { b ^ num } } return []int{a, b} }class Solution { fun singleNumber(nums: IntArray): IntArray { var xorVal 0 for (num in nums) { xorVal xorVal xor num } val diffBit xorVal and -xorVal var a 0 var b 0 for (num in nums) { if (num and diffBit ! 0) { a a xor num } else { b b xor num } } return intArrayOf(a, b) } }class Solution { func singleNumber(_ nums: [Int]) - [Int] { var xorVal 0 for num in nums { xorVal ^ num } let diffBit xorVal -xorVal var a 0, b 0 for num in nums { if num diffBit ! 0 { a ^ num } else { b ^ num } } return [a, b] } }impl Solution { pub fn single_number(nums: Veci32) - Veci32 { let mut xor 0i32; for num in nums { xor ^ num; } let diff_bit xor xor.wrapping_neg(); let (mut a, mut b) (0, 0); for num in nums { if num diff_bit ! 0 { a ^ num; } else { b ^ num; } } vec![a, b] } }语言细节提示Rust 中负号取反需要显式使用wrapping_neg()如上面的xor.wrapping_neg()以避免在i32::MIN等边界场景下触发溢出检查这也是 Rust 与其它语言写法上的一个差异点。复杂度分析时间复杂度$O(n)$——两趟线性扫描。空间复杂度$O(1)$ 额外空间。六种解法对比与选型建议解法时间复杂度空间复杂度适用场景与评价暴力法$O(n^2)$$O(1)$思路直白适合作为面试第一反应但数据量大时不可用哈希表$O(n)$$O(n)$最容易想到的线性解法适合快速 AC但空间不达标哈希集合$O(n)$$O(n)$代码最简洁利用成对抵消思想是哈希表的美化版本排序$O(n \log n)$$O(1)$ 或 $O(n)$无额外数据结构依赖面试中可作中间过渡方案XOR 循环找位$O(n)$$O(1)$位运算标准解面试考察重点需理解分组原理XOR x (-x)$O(n)$$O(1)$最优解一步取最低置位代码最短强烈推荐掌握从面试角度看能够从哈希解法一路推导到位运算解法并清晰解释为什么差异位能把a和b分开以及为什么重复元素不会被拆散这两个关键点是本题拿到高分的核心。常见陷阱陷阱一与 Single Number I 混淆经典 Single Number 问题LeetCode 136见 articles/single-number.md 与仓库中的 python/0136-single-number.py 实现中全体异或直接就是答案而本题有两个唯一数字全体异或得到的是a ^ b而非单个值。许多候选人没有意识到还需要额外一步把两个数字分离这是最常见的失误。陷阱二误解差异位分组的逻辑关键洞察在于a ^ b中至少存在一个置位该位正是a与b二进制表示不同的位置。利用这个位把数组分成两组是解题核心。常见的错误包括不理解为什么分组能够生效、选错了用于分离的位例如用了某个数字自身的位而非异或结果的位。需要特别强调重复数字的两个副本在任意一个位上取值必然相同所以它们永远会落入同一组并被异或抵消而a、b在差异位上取值不同必然被拆到两个不同组中。陷阱三求最低置位时的整数溢出表达式x (-x)在求最低置位时某些语言下对最小整数值取负会引发问题例如在 C 或 Java 中对INT_MIN取负会触发未定义行为或整数溢出。因此在实现时需要小心处理例如 C 中可将异或累积量声明为无符号类型uintRust 中使用wrapping_neg()或改用解法五中从 1 开始循环左移的安全写法。延伸仓库中的相关资源本题作为只出现一次的数字系列的进阶题可以与仓库中的以下资源配套研读articles/single-number.mdSingle NumberLeetCode 136完整题解覆盖暴力、哈希集合、排序、位运算四种解法是理解本题差异位分组的前置铺垫。hints/single-number.md仓库为姊妹题提供的提示文档从 $O(n^2)$ 暴力到 $O(n)$ 空间再到位运算的递进引导思路对本题同样适用。多语言参考实现python/0136-single-number.py、java/0136-single-number.java、cpp/0136-single-number.cpp、go/0136-single-number.go、javascript/0136-single-number.js、typescript/0136-single-number.ts、kotlin/0136-single-number.kt、swift/0136-single-number.swift、rust/0136-single-number.rs、c/0136-single-number.c、csharp/0136-single-number.cs、dart/0136-single-number.dart、ruby/0136-single-number.rb 等覆盖了与本文一致的多种编程语言实现风格可用于横向对比学习。掌握了本题的全体异或 → 差异位 → 分组异或三步曲你就能举一反三地应对一系列基于 XOR 性质的位运算题目——它们是算法面试中性价比极高的得分点。【免费下载链接】leetcodeLeetcode solutions项目地址: https://gitcode.com/GitHub_Trending/leetcode1/leetcode创作声明：本文部分内容由AI辅助生成（AIGC），仅供参考