场景设定：一线大厂高级算法工程师面试
面试官：Claude（扮演资深技术面试官，风格偏严格）
求职者 A：GPT-4o
求职者 B：Gemini 2.0 Flash
人类裁判：作者
这事起因很简单。我刷算法题刷到崩溃的时候，突然想到一个问题：现在的 AI 到底能不能真正"面试"算法？不是那种丢个题过去等它吐答案的玩法，而是模拟真实面试场景——面试官追问、求职者解释思路、写代码、被挑刺。
于是我搞了这场 PK。Claude 当面试官，GPT-4o 和 Gemini 同场竞答，三轮题目难度递增，我来当裁判。
规则很简单：
- 三轮题目，Easy → Medium → Hard
- 每个 AI 都能看到完整的题目描述
- 限时回答（模拟真实面试节奏）
- 面试官可以追问，求职者需要解释思路
- 我从正确性、代码质量、思路清晰度三个维度打分
🎬 第一轮：三数之和（3Sum）
面试官 Claude 问：
给你一个整数数组 nums，返回所有和为 0 的不重复三元组。注意不能包含重复的三元组。
示例：nums = [-1,0,1,2,-1,-4]，输出 [[-1,-1,2],[-1,0,1]]
约束：3 ≤ nums.length ≤ 3000，-10⁵ ≤ nums[i] ≤ 10⁵
这是 LeetCode 15，经典中的经典。考察的不是能不能做出来，而是能不能处理去重和边界。
GPT-4o 的回答：
思路：排序 + 双指针。先排序，固定一个数，然后用左右指针找另外两个。去重的关键是跳过相同的元素。
defthreeSum(nums):nums.sort()result=[]foriinrange(len(nums)-2):ifi>0andnums[i]==nums[i-1]:continueleft,right=i+1,len(nums)-1whileleft<right:total=nums[i]+nums[left]+nums[right]iftotal<0:left+=1eliftotal>0:right-=1else:result.append([nums[i],nums[left],nums[right]])whileleft<rightandnums[left]==nums[left+1]:left+=1whileleft<rightandnums[right]==nums[right-1]:right-=1left+=1right-=1returnresult时间复杂度 O(n²)，空间 O(1)（不算排序的话）。
Gemini 的回答：
先排序，然后遍历每个元素作为第一个数，用双指针在剩余部分找两数之和等于负的第一个数。去重通过跳过相邻重复元素实现。
defthreeSum(nums):nums.sort()res=[]n=len(nums)foriinrange(n-2):ifnums[i]>0:breakifi>0andnums[i]==nums[i-1]:continuel,r=i+1,n-1whilel<r:s=nums[i]+nums[l]+nums[r]ifs<0:l+=1elifs>0:r-=1else:res.append([nums[i],nums[l],nums[r]])whilel<randnums[l]==nums[l+1]:l+=1whilel<randnums[r]==nums[r-1]:r-=1l+=1r-=1returnresO(n²) 时间，排序 O(n log n)。
🧑⚖️ 我的点评
两个 AI 的核心解法几乎一样——排序加双指针，这是这题的标准答案。但有个细节差异值得说。
Gemini 加了一个提前剪枝：if nums[i] > 0: break。如果排序后第一个数已经大于 0，三个数不可能加起来等于 0。这个优化看着小，但在大数据量下能省不少时间。GPT-4o 没加。
代码风格上，GPT-4o 的变量命名更清晰（totalvss，resultvsres），阅读体验好一些。但 Gemini 的更紧凑。
说实话，这题对两个 AI 都不算挑战。它们都答对了，思路清晰，代码也没 bug。如果这是真实面试，两个都能过。
GPT-4o：⭐⭐⭐⭐思路清晰，代码可读性好，缺优化
Gemini：⭐⭐⭐⭐多一个剪枝优化，代码稍紧凑
🎬 第二轮：最长无重复字符子串
面试官 Claude 问：
给定一个字符串 s，找出其中不含有重复字符的最长子串的长度。
示例：s = “abcabcbb”，输出 3（“abc” 或 “bca” 等）
约束：0 ≤ s.length ≤ 5 × 10⁴，s 由英文字母、数字、符号和空格组成
LeetCode 3，滑动窗口的经典题。这题的考点在于：你用的是滑动窗口还是暴力，以及窗口收缩的方式。
GPT-4o 的回答：
滑动窗口。用左右指针维护一个窗口，窗口内没有重复字符。用哈希表记录每个字符最后一次出现的位置。遇到重复字符时，直接把左指针跳到重复字符上次出现位置的下一个。
deflengthOfLongestSubstring(s):char_index={}left=0max_len=0forright,chinenumerate(s):ifchinchar_indexandchar_index[ch]>=left:left=char_index[ch]+1char_index[ch]=right max_len=max(max_len,right-left+1)returnmax_len时间 O(n)，每个字符访问一次。空间 O(min(n, m))，m 是字符集大小。
Gemini 的回答：
使用滑动窗口配合哈希集合。右指针不断扩展窗口，如果遇到集合中已有的字符，左指针逐步收缩直到窗口内无重复。
deflengthOfLongestSubstring(s):char_set=set()left=0max_len=0forrightinrange(len(s)):whiles[right]inchar_set:char_set.remove(s[left])left+=1char_set.add(s[right])max_len=max(max_len,right-left+1)returnmax_len时间复杂度 O(2n) = O(n)，最坏情况每个字符被左右指针各访问一次。空间 O(min(n, m))。
🧑⚖️ 我的点评
这轮开始出现分歧了。
两个 AI 都用了滑动窗口，但实现方式不同。GPT-4o 用哈希表记录字符位置，遇到重复直接跳转左指针。Gemini 用集合，遇到重复就逐步删除直到不重复。
GPT-4o 的方案是这题的最优解。左指针直接跳到目标位置，不用逐个删，严格 O(n)。Gemini 的方案虽然渐进复杂度也是 O(n)，但最坏情况下左指针要逐个移动，实际运行会慢一些。
面试中如果候选人写出 Gemini 的版本，面试官大概率会追问：“能不能优化左指针的移动方式？” 能不能从逐步收缩改成直接跳转，这就是区分"知道这题"和"理解这题"的分水岭。
这轮 GPT-4o 明显胜出。不是 Gemini 答错了，而是它没找到最优解法。
GPT-4o：⭐⭐⭐⭐⭐最优解，思路和实现都对
Gemini：⭐⭐⭐⭐正确但非最优，面试官会追问
🎬 第三轮：合并 K 个有序链表
面试官 Claude 问：
给你一个链表数组 lists，其中每个链表已经按升序排列。请将所有链表合并到一个升序链表中，返回合并后的链表。
示例：lists = [[1,4,5],[1,3,4],[2,6]]，输出 [1,1,2,3,4,4,5,6]
约束：k == lists.length，0 ≤ k ≤ 10⁴，0 ≤ lists[i].length ≤ 500
LeetCode 23，Hard。这题的核心考点是：你会用什么数据结构来高效地从 K 个链表中取最小值。
GPT-4o 的回答：
思路：用最小堆。把每个链表的头节点放入堆，每次弹出最小的，然后把该节点的下一个节点放入堆。直到堆为空。
importheapqclassListNode:def__init__(self,val=0,next=None):self.val=val self.next=nextdefmergeKLists(lists):heap=[]fori,nodeinenumerate(lists):ifnode:heapq.heappush(heap,(node.val,i,node))dummy=ListNode(0)curr=dummywhileheap:val,i,node=heapq.heappop(heap)curr.next=node curr=curr.nextifnode.next:heapq.heappush(heap,(node.next.val,i,node.next))returndummy.next时间 O(n log k)，n 是所有节点总数，k 是链表数量。每次堆操作 O(log k)，共 n 次。空间 O(k) 存堆。
Gemini 的回答：
思路：两两合并。用归并排序的思想，把 K 个链表两两配对合并，不断缩减直到只剩一个。
classListNode:def__init__(self,val=0,next=None):self.val=val self.next=nextdefmergeKLists(lists):ifnotlists:returnNonedefmergeTwo(l1,l2):dummy=ListNode(0)curr=dummywhilel1andl2:ifl1.val<=l2.val:curr.next=l1 l1=l1.nextelse:curr.next=l2 l2=l2.nextcurr=curr.nextcurr.next=l1orl2returndummy.nextwhilelen(lists)>1:merged=[]foriinrange(0,len(lists),2):l1=lists[i]l2=lists[i+1]ifi+1<len(lists)elseNonemerged.append(mergeTwo(l1,l2))lists=mergedreturnlists[0]时间 O(n log k)，每轮合并遍历所有节点，共 log k 轮。空间 O(1)（不算递归栈）。
🧑⚖️ 我的点评
第三轮是最有意思的。两个 AI 选择了完全不同的解法。
GPT-4o 用最小堆。这是这题的"教科书答案"，面试官想看到的就是这个。用堆每次取 K 个链表中的最小值，时间 O(n log k)。代码干净，逻辑清晰，有个小细节做得好——在堆中存了(val, i, node)三元组，用索引 i 做 tie-breaker，避免了节点对象不可比较的问题。
Gemini 选了分治归并。两两配对合并，每轮链表数量减半，log k 轮完成。渐进复杂度一样是 O(n log k)，但思路完全不同。
两种解法哪个更好？说实话，各有道理。
堆解法的好处是直观——"每次取 K 个里最小的"这个思路跟问题描述完美对应。坏处是 Python 的 heapq 需要处理节点比较的问题（GPT-4o 解决了，用索引做 tie-breaker）。
分治解法的好处是不依赖额外的数据结构，空间 O(1)。而且归并的思路在工程上更通用——比如外部排序用的就是这个。
如果我是面试官，两种解法都能给 Strong Hire。但 GPT-4o 的堆解法更快写出来，代码更短，面试中时间有限，这点占优。Gemini 的解法代码更长，但展示了不同的思维角度。
不过有个细节 Gemini 没提到：如果 K 很大（比如 10⁴），分治的常数因子更小，因为堆的 push/pop 操作有额外开销。Gemini 没分析这个 trade-off，差了一口气。
GPT-4o：⭐⭐⭐⭐⭐最优解，代码干净，细节处理到位
Gemini：⭐⭐⭐⭐正确的替代解法，缺 trade-off 分析
📊 总结
| 轮次 | 题目 | 难度 | GPT-4o | Gemini | 胜出 |
|---|---|---|---|---|---|
| 第一轮 | 三数之和 | Medium | ⭐⭐⭐⭐ | ⭐⭐⭐⭐ | 平 |
| 第二轮 | 最长无重复子串 | Medium | ⭐⭐⭐⭐⭐ | ⭐⭐⭐⭐ | GPT-4o |
| 第三轮 | 合并K个有序链表 | Hard | ⭐⭐⭐⭐⭐ | ⭐⭐⭐⭐ | GPT-4o |
总体评价：GPT-4o 以 3:0 获胜，但差距没分数看起来那么大。
三轮题目里，GPT-4o 每轮都给出了更接近"面试官想看到的答案"。第一轮两边打平，因为 3Sum 的标准解法太经典了。从第二轮开始，GPT-4o 在算法优化上开始领先——哈希表存位置 vs 集合逐步收缩，这一步区分了"背过题"和"理解了题"。
第三轮的差距最小。Gemini 的分治归并并不是错误选择，甚至在一些场景下更优（K 很大时）。但面试不是比谁更聪明，是比谁在 45 分钟内把最优解写得最干净。GPT-4o 在这方面确实更强。
比真人面试好在哪：
两个 AI 都有一个人类做不到的优势——不紧张。真人面试到 Hard 题的时候，脑子经常会空白，手会抖，写到一半发现思路错了会慌。AI 不会。它稳定地给出一个能用的解法，就算不是最优，至少不会交白卷。
比真人面试差在哪：
沟通。真实面试中，候选人会先跟面试官讨论思路，确认方向对了再写代码。AI 直接跳到代码，省了讨论环节。这在真实面试里其实是个减分项——面试官想看你的思考过程，不光是结果。
还有一个问题：追问。Claude 作为面试官追问了几个点（比如"为什么要跳过重复元素"），两个 AI 都能回答，但回答偏教科书，缺少"我在项目中踩过这个坑"的经验感。真人会说"上次做推荐系统去重的时候踩过这个"，AI 只能复述原理。
我的建议：拿这些题练手的时候，别只看 AI 给的最终代码。把 AI 的第一版和优化版都看一遍，理解它为什么从暴力解进化到最优解。这个过程比答案本身值钱得多。
来源说明：
- 题目来源：LeetCode 15 / 3 / 23
- AI 回答：GPT-4o 和 Gemini 2.0 Flash 实测（2026 年 10 月）
- 点评为人类裁判主观评价，仅供参考
