Amazon 2026 面试全流程攻略：OA CodeSignal → Phone → Loop Onsite 真实面经汇总

Amazon 2026 面试全流程攻略：OA CodeSignal → Phone → Loop Onsite 真实面经汇总

Amazon（亚马逊/亚麻）作为全球电商和云计算巨头，2026 年面试以Leadership Principles为核心筛选标准。算法面试 + 行为面试各占 50% 权重。面试难度：★★★★☆（行为面试占比高，Leadership Principles 是通关关键）

2026 年面试流程时间线：

• 📝 OA（CodeSignal/HackerRank）：2-3 道编程题，60-90 分钟
• 📞 Phone Screen：45 分钟，1-2 道 LC + LP 行为题
• 💻 Loop Onsite：4-5 轮（Coding + System Design + LP BQ + Bar Raiser）

一、OA 阶段：CodeSignal 在线笔试

Amazon 的 OA 通常在 CodeSignal 平台上进行，2-3 道编程题，难度从 Easy 到 Hard。2026 年部分岗位使用 HackerRank。

高频题 1：合并区间（LeetCode 56）

def merge(intervals):
    """
    合并重叠区间
    时间: O(N log N), 空间: O(N)
    """
    if not intervals:
        return []
    
    intervals.sort(key=lambda x: x[0])
    merged = [intervals[0]]
    
    for curr in intervals[1:]:
        prev = merged[-1]
        if curr[0] <= prev[1]:
            prev[1] = max(prev[1], curr[1])
        else:
            merged.append(curr)
    
    return merged

高频题 2：LRU Cache（LeetCode 146）

class Node:
    def __init__(self, key=0, val=0):
        self.key = key
        self.val = val
        self.prev = None
        self.next = None

class LRUCache:
    def __init__(self, capacity: int):
        self.capacity = capacity
        self.cache = {}
        self.head = Node()
        self.tail = Node()
        self.head.next = self.tail
        self.tail.prev = self.head
    
    def get(self, key: int) -> int:
        if key in self.cache:
            self._move_to_head(self.cache[key])
            return self.cache[key].val
        return -1
    
    def put(self, key: int, value: int) -> None:
        if key in self.cache:
            self.cache[key].val = value
            self._move_to_head(self.cache[key])
        else:
            node = Node(key, value)
            self.cache[key] = node
            self._add_to_head(node)
            if len(self.cache) > self.capacity:
                removed = self._remove_tail()
                del self.cache[removed.key]
    
    def _add_to_head(self, node):
        node.prev = self.head
        node.next = self.head.next
        self.head.next.prev = node
        self.head.next = node
    
    def _remove_node(self, node):
        node.prev.next = node.next
        node.next.prev = node.prev
    
    def _move_to_head(self, node):
        self._remove_node(node)
        self._add_to_head(node)
    
    def _remove_tail(self):
        node = self.tail.prev
        self._remove_node(node)
        return node

二、Phone Screen 技术电面

Phone 轮 45 分钟，1-2 道算法题 + Leadership Principles 行为题。

高频题：二叉树最大深度 / 层序遍历

from collections import deque

def levelOrder(root):
    """
    二叉树层序遍历
    时间: O(N), 空间: O(W)
    """
    if not root:
        return []
    
    result = []
    queue = deque([root])
    
    while queue:
        level = []
        for _ in range(len(queue)):
            node = queue.popleft()
            level.append(node.val)
            if node.left:
                queue.append(node.left)
            if node.right:
                queue.append(node.right)
        result.append(level)
    
    return result

三、Loop Onsite – Coding & System Design

Loop 是 Amazon 的核心面试环节，4-5 轮，包括 Coding、System Design、LP BQ 和 Bar Raiser。Bar Raiser 是专门负责提高招聘标准的面试官，拥有一票否决权。

1. Coding Round 1：LC Medium-Hard，如 Top K、岛屿数量、合并 K 个链表
2. Coding Round 2：系统设计前置题，如 Design a Parking Lot
3. System Design：Design Amazon.com Homepage, Design AWS S3
4. LP BQ：Leadership Principles 深度考察
5. Bar Raiser Round：综合评估，一票否决权

System Design 示例：Design Amazon.com Homepage

from collections import defaultdict
import time
import hashlib

class AmazonHomepage:
    def __init__(self):
        self.product_catalog = {}
        self.user_profiles = {}
        self.recommendation_cache = {}
        self.feature_flags = {}
    
    def get_homepage(self, user_id, country='US'):
        """
        生成个性化首页
        核心模块:
        1. 个性化推荐 (30%)
        2. 热门商品 (25%)
        3. 历史浏览推荐 (20%)
        4. 促销/广告 (15%)
        5. 新品上架 (10%)
        """
        sections = []
        
        # 1. 个性化推荐 (协同过滤 + 深度学习)
        recs = self._get_recommendations(user_id)
        sections.append({'type': 'recommendations', 'items': recs})
        
        # 2. 热门商品
        trending = self._get_trending(country)
        sections.append({'type': 'trending', 'items': trending})
        
        # 3. 基于浏览历史
        history = self._get_browsing_history(user_id)
        sections.append({'type': 'viewed_again', 'items': history})
        
        # 4. 促销
        promos = self._get_promotions(user_id, country)
        sections.append({'type': 'promotions', 'items': promos})
        
        # A/B Testing
        layout = self._get_layout_variant(user_id)
        return {'layout': layout, 'sections': sections}
    
    def _get_recommendations(self, user_id):
        """协同过滤推荐"""
        cache_key = f"rec_{user_id}_{int(time.time())//3600}"
        if cache_key in self.recommendation_cache:
            return self.recommendation_cache[cache_key]
        
        # 简化版: 基于用户历史购买相似用户喜好
        user_profile = self.user_profiles.get(user_id, {})
        # 实际场景: 调用推荐系统 API
        recs = []
        self.recommendation_cache[cache_key] = recs
        return recs
    
    def _get_trending(self, country):
        """热门商品 - 基于实时销量排序"""
        return []  # 从 Redis/SQS 获取实时排名

四、Leadership Principles 行为面试

Amazon 的 LP BQ 是最核心的筛选标准，共 16 条 Leadership Principles。每轮面试都会考察 2-3 条，你需要用 STAR 格式讲述真实经历。

1. Customer Obsession：客户至上 – 描述你如何为客户创造价值的经历
2. Ownership：主人翁精神 – 描述你主动承担责任的故事
3. Deliver Results：执行力 – 描述你在压力下完成目标的经历
4. Dive Deep：深入挖掘 – 描述你如何通过数据分析找到根本原因
5. Think Big：大胆思考 – 描述你如何设计大规模解决方案
6. Bias for Action：果断行动 – 描述你在信息不全时做出决策的经历

答题框架 (STAR)：Situation（背景）→ Task（任务）→ Action（你的行动）→ Result（量化结果）。每个故事控制在 2-3 分钟，重点在 Action 和 Result。

五、备考策略与核心建议

1. LP 故事是核心：准备 10-15 个故事，覆盖 16 条 LP，每个故事 2-3 分钟
2. 算法不能丢：LeetCode Medium 是基础，重点刷题型：数组、字符串、树、图
3. 系统设计：准备 Design Amazon.com、Design AWS S3 等经典题
4. Bar Raiser 准备：展现你能为团队带来的价值，不只是技术能力

def islandPerfection(grid):
    """岛屿数量 - DFS"""
    if not grid:
        return 0
    count = 0
    rows, cols = len(grid), len(grid[0])
    
    def dfs(r, c):
        if r < 0 or r >= rows or c < 0 or c >= cols or grid[r][c] != '1':
            return
        grid[r][c] = '0'
        for dr, dc in [(-1,0),(1,0),(0,-1),(0,1)]:
            dfs(r+dr, c+dc)
    
    for i in range(rows):
        for j in range(cols):
            if grid[i][j] == '1':
                dfs(i, j)
                count += 1
    return count

def mergeKLists(lists):
    """合并K个升序链表"""
    import heapq
    dummy = ListNode(0)
    curr = dummy
    heap = []
    
    for i, node in enumerate(lists):
        if node:
            heapq.heappush(heap, (node.val, i, node))
    
    while heap:
        val, _, node = heapq.heappop(heap)
        curr.next = node
        curr = curr.next
        if node.next:
            heapq.heappush(heap, (node.next.val, _, node.next))
    
    return dummy.next