【附答案】30道字节跳动、阿里巴巴、腾讯、美团、华为等一线公司真实面试题

一、算法与数据结构（共15题）

面试题相关

1. （字节跳动）题目： 给定一个字符串，请你找出其中不含有重复字符的 最长子串 的长度。
示例：
输入: “abcabcbb”
输出: 3
解释: 因为无重复字符的最长子串是 “abc”，所以其长度为 3。
参考答案：
使用滑动窗口（双指针）和哈希集合（Set）。


def lengthOfLongestSubstring(s: str) -> int:
    char_set = set()
    left = 0
    max_len = 0
    for right in range(len(s)):
        while s[right] in char_set:
            char_set.remove(s[left])
            left += 1
        char_set.add(s[right])
        max_len = max(max_len, right - left + 1)
    return max_len

考察点： 滑动窗口、哈希表。

2. （阿里巴巴）题目： 实现一个LRU（最近最少使用）缓存机制。它应该支持以下操作：获取数据 get 和写入数据 put。

获取数据 get(key)：如果密钥 key 存在于缓存中，则获取密钥的值（总是正数），否则返回 -1。写入数据 put(key, value)：如果密钥已经存在，则变更其数据值；如果密钥不存在，则插入该组「密钥/数据值」。当缓存容量达到上限时，它应该在写入新数据之前删除最久未使用的数据值，从而为新的数据值留出空间。
参考答案：
使用哈希表 + 双向链表。


class DLinkedNode:
    def __init__(self, key=0, value=0):
        self.key = key
        self.value = value
        self.prev = None
        self.next = None

class LRUCache:
    def __init__(self, capacity: int):
        self.cache = {}
        self.head = DLinkedNode()
        self.tail = DLinkedNode()
        self.head.next = self.tail
        self.tail.prev = self.head
        self.capacity = capacity
        self.size = 0

    def get(self, key: int) -> int:
        if key not in self.cache:
            return -1
        node = self.cache[key]
        self.moveToHead(node)
        return node.value

    def put(self, key: int, value: int) -> None:
        if key in self.cache:
            node = self.cache[key]
            node.value = value
            self.moveToHead(node)
        else:
            node = DLinkedNode(key, value)
            self.cache[key] = node
            self.addToHead(node)
            self.size += 1
            if self.size > self.capacity:
                removed = self.removeTail()
                del self.cache[removed.key]
                self.size -= 1

    def addToHead(self, node):
        node.prev = self.head
        node.next = self.head.next
        self.head.next.prev = node
        self.head.next = node

    def removeNode(self, node):
        node.prev.next = node.next
        node.next.prev = node.prev

    def moveToHead(self, node):
        self.removeNode(node)
        self.addToHead(node)

    def removeTail(self):
        node = self.tail.prev
        self.removeNode(node)
        return node

考察点： 数据结构设计、双向链表、哈希表。

3. （腾讯）题目： 给定一个只包括 '('，')'，'{'，'}'，'['，']' 的字符串 s ，判断字符串是否有效。
参考答案：
使用栈。


def isValid(s: str) -> bool:
    stack = []
    mapping = {')': '(', '}': '{', ']': '['}
    for char in s:
        if char in mapping:
            top_element = stack.pop() if stack else '#'
            if mapping[char] != top_element:
                return False
        else:
            stack.append(char)
    return not stack

考察点： 栈的应用。

4. （美团）题目： 二叉树的层序遍历。给你一个二叉树，请你返回其按 层序遍历 得到的节点值。
参考答案：
使用队列（BFS）。


from collections import deque
def levelOrder(root):
    if not root:
        return []
    result = []
    queue = deque([root])
    while queue:
        level_size = len(queue)
        current_level = []
        for _ in range(level_size):
            node = queue.popleft()
            current_level.append(node.val)
            if node.left:
                queue.append(node.left)
            if node.right:
                queue.append(node.right)
        result.append(current_level)
    return result

考察点： 二叉树、BFS。

5. （华为）题目： 字符串转换整数 (atoi)。请你来实现一个 myAtoi(string s) 函数，使其能将字符串转换成一个 32 位有符号整数。
参考答案：
注意处理空格、正负号、非数字字符和整数范围。


def myAtoi(s: str) -> int:
    if not s:
        return 0
    INT_MAX, INT_MIN = 2**31-1, -2**31
    i, n, sign = 0, len(s), 1
    # 1. 丢弃无用的前导空格
    while i < n and s[i] == ' ':
        i += 1
    # 2. 检查正负号
    if i < n and (s[i] == '+' or s[i] == '-'):
        sign = 1 if s[i] == '+' else -1
        i += 1
    # 3. 读取数字直到非数字字符或结尾
    num = 0
    while i < n and s[i].isdigit():
        digit = int(s[i])
        # 检查溢出
        if num > (INT_MAX - digit) // 10:
            return INT_MAX if sign == 1 else INT_MIN
        num = num * 10 + digit
        i += 1
    return num * sign

考察点： 字符串处理、边界条件、溢出处理。

6. （字节跳动）题目： 合并K个升序链表。
参考答案：
使用最小堆（优先队列）。


import heapq
def mergeKLists(lists):
    dummy = ListNode(0)
    p = dummy
    heap = []
    for i, node in enumerate(lists):
        if node:
            heapq.heappush(heap, (node.val, i, node))
    while heap:
        val, idx, node = heapq.heappop(heap)
        p.next = node
        p = p.next
        if node.next:
            heapq.heappush(heap, (node.next.val, idx, node.next))
    return dummy.next

考察点： 分治、堆（优先队列）、链表。

7. （阿里巴巴）题目： 最长回文子串。
参考答案：
中心扩散法或动态规划。


def longestPalindrome(s: str) -> str:
    n = len(s)
    if n < 2:
        return s
    start, max_len = 0, 1
    for i in range(n):
        # 奇数长度的回文
        len1 = expandAroundCenter(s, i, i)
        # 偶数长度的回文
        len2 = expandAroundCenter(s, i, i+1)
        curr_max = max(len1, len2)
        if curr_max > max_len:
            max_len = curr_max
            start = i - (curr_max - 1) // 2
    return s[start:start+max_len]

def expandAroundCenter(s, left, right):
    while left >=0 and right < len(s) and s[left] == s[right]:
        left -= 1
        right += 1
    return right - left - 1

考察点： 动态规划、中心扩散法。

8. （腾讯）题目： 两数之和。给定一个整数数组 nums 和一个整数目标值 target，请你在该数组中找出 和为目标值 target 的那两个整数，并返回它们的数组下标。
参考答案：
使用哈希表（一次遍历）。


def twoSum(nums, target):
    hashmap = {}
    for i, num in enumerate(nums):
        complement = target - num
        if complement in hashmap:
            return [hashmap[complement], i]
        hashmap[num] = i
    return []

考察点： 哈希表。

9. （美团）题目： 三数之和。给你一个包含 n 个整数的数组 nums，判断 nums 中是否存在三个元素 a，b，c ，使得 a + b + c = 0？请你找出所有和为 0 且不重复的三元组。
参考答案：
排序 + 双指针。


def threeSum(nums):
    nums.sort()
    n = len(nums)
    res = []
    for i in range(n-2):
        if i > 0 and nums[i] == nums[i-1]:
            continue
        left, right = i+1, n-1
        while left < right:
            s = nums[i] + nums[left] + nums[right]
            if s < 0:
                left += 1
            elif s > 0:
                right -= 1
            else:
                res.append([nums[i], nums[left], nums[right]])
                while left < right and nums[left] == nums[left+1]:
                    left += 1
                while left < right and nums[right] == nums[right-1]:
                    right -= 1
                left += 1
                right -= 1
    return res

考察点： 排序、双指针、去重处理。

10. （华为）题目： 最大子数组和（ Kadane’s Algorithm ）。
参考答案：
python def maxSubArray(nums): curr_sum = max_sum = nums[0] for num in nums[1:]: curr_sum = max(num, curr_sum + num) max_sum = max(max_sum, curr_sum) return max_sum
考察点： 动态规划、贪心。

11. （字节跳动）题目： 买卖股票的最佳时机（只能买卖一次）。
参考答案：
python def maxProfit(prices): min_price = float('inf') max_profit = 0 for price in prices: min_price = min(min_price, price) max_profit = max(max_profit, price - min_price) return max_profit
考察点： 贪心。

12. （阿里巴巴）题目： 环形链表 II（找出环的入口节点）。
参考答案：
快慢指针相遇后，一个指针从head开始，另一个从相遇点开始，每次走一步，再次相遇即为入口。
python def detectCycle(head): slow, fast = head, head while fast and fast.next: slow = slow.next fast = fast.next.next if slow == fast: ptr = head while ptr != slow: ptr = ptr.next slow = slow.next return ptr return None
考察点： 链表、快慢指针、Floyd判圈法。

13. （腾讯）题目： 有效的括号字符串（新增*号，可以代表左、右括号或空字符串）。
参考答案：
使用两个栈，分别存储左括号和星号的下标。
python def checkValidString(s: str) -> bool: left_stack, star_stack = [], [] for i, char in enumerate(s): if char == '(': left_stack.append(i) elif char == '*': star_stack.append(i) else: if left_stack: left_stack.pop() elif star_stack: star_stack.pop() else: return False # 处理剩余的左括号和星号 while left_stack and star_stack: if left_stack[-1] < star_stack[-1]: left_stack.pop() star_stack.pop() else: break return len(left_stack) == 0
考察点： 栈、贪心。

14. （美团）题目： 手写快速排序（Quick Sort）。
参考答案：
“`python
def quick_sort(arr, low, high):
if low < high:
pi = partition(arr, low, high)
quick_sort(arr, low, pi-1)
quick_sort(arr, pi+1, high)


def partition(arr, low, high):
    pivot = arr[high]
    i = low - 1
    for j in range(low, high):
        if arr[j] <= pivot:
            i += 1
            arr[i], arr[j] = arr[j], arr[i]
    arr[i+1], arr[high] = arr[high], arr[i+1]
    return i+1
```
**考察点：** 排序算法、分治。

15. （华为）题目： 爬楼梯（每次你可以爬 1 或 2 个台阶。你有多少种不同的方法可以爬到楼顶呢？）。
参考答案：
python def climbStairs(n: int) -> int: if n == 1: return 1 a, b = 1, 2 for i in range(3, n+1): a, b = b, a+b return b
考察点： 动态规划、斐波那契数列。

二、系统设计（共5题）

16. （字节跳动）题目： 如何设计一个短视频信息流（如抖音）？
考察点：
– 架构：客户端、API网关、业务服务、数据存储。
– 视频上传与处理：分片上传、转码（H.264/H.265）、CDN分发。
– 推荐系统：协同过滤、深度学习模型（如DSSM）、实时特征计算。
– 数据存储：MySQL（用户/关系/元数据）、对象存储（视频文件）、Redis（热点数据、计数）、HBase/ClickHouse（用户行为日志）。
– 性能与扩展性：微服务、负载均衡、缓存策略、数据库分库分表。

17. （阿里巴巴）题目： 如何设计一个分布式唯一ID生成器（Snowflake算法）？
考察点：
– 需求：全局唯一、趋势递增、高可用、低延迟。
– Snowflake结构：1位符号位 + 41位时间戳 + 10位机器ID + 12位序列号。
– 优缺点：毫秒级并发、无需中心化、依赖系统时钟（时钟回拨问题）。
– 变种：美团Leaf、百度UidGenerator。

18. （腾讯）题目： 如何设计一个微信朋友圈？
考察点：
– 数据模型：动态表、评论表、点赞表、图片/视频表。
– 读写流程：写扩散（发动态->写入自己的时间线、好友的时间线）、读扩散（拉取好友动态聚合）。
– 缓存策略：Redis缓存用户时间线、热点动态。
– 隐私与权限：好友关系校验、可见范围控制。

19. （美团）题目： 如何设计一个外卖骑手的位置追踪系统？
考察点：
– 数据采集：App端定时上报GPS坐标。
– 数据传输：通过TCP长连接或MQTT协议保证实时性和省电。
– 数据存储：时序数据库（如InfluxDB）或HBase存储轨迹数据，Redis存储最新位置。
– 地理空间索引：使用GeoHash或Redis GEO计算附近骑手。
– 实时计算：Flink/Spark Streaming计算ETA（预计到达时间）。

20. （华为）题目： 如何设计一个秒杀系统？
考察点：
– 架构原则：限流、削峰、异步、缓存。
– 关键设计：
– 前端：静态化、按钮防重复点击、验证码。
– 网关：限流（令牌桶、漏桶）。
– 后端：缓存库存（Redis）、异步扣减库存（消息队列）、数据库最终一致性。
– 防作弊：风控系统、黑名单。

三、编程语言与基础（共5题）

21. （字节跳动）题目： Python中*args和**kwargs的区别？
参考答案：
– *args用于接收任意数量的位置参数，打包成元组。
– **kwargs用于接收任意数量的关键字参数，打包成字典。

22. （阿里巴巴）题目： Java中HashMap的实现原理？如何处理哈希冲突？
参考答案：
– 数组+链表/红黑树（JDK8+）。
– 哈希冲突解决方法：链地址法（拉链法）。当链表长度超过阈值（8）时，转换为红黑树。

23. （腾讯）题目： C++中虚函数（Virtual Function）的作用和实现原理？
参考答案：
– 作用：实现运行时多态。
– 原理：通过虚函数表（vtable）和虚函数表指针（vptr）实现。每个有虚函数的类都有一个vtable，存储虚函数地址。对象包含vptr指向vtable。

24. （美团）题目： 什么是死锁（Deadlock）？产生死锁的必要条件是什么？
参考答案：
– 死锁：多个进程循环等待对方占有的资源，导致无法继续执行。
– 四个必要条件：互斥、占有并等待、不可抢占、循环等待。

25. （华为）题目： 进程和线程的区别？
参考答案：
– 进程是资源分配的最小单位，线程是CPU调度的最小单位。
– 进程有独立的地址空间，线程共享进程的地址空间。
– 进程切换开销大，线程切换开销小。