用矩阵、位运算和 LRU 征服面试：七大算法题助你高枕无忧

随着秋招的临近，面试的硝烟弥漫，算法题成了求职路上的必经考验。为了帮助各位求职者攻克这一难关，我从牛客、WanAndroid 等权威平台收集了历年笔试真题，结合 LeetCode 精心筛选出七道高频矩阵、位运算和 LRU 算法面试题，并提供了详尽的解答和代码示例。

1. 螺旋矩阵

题意： 给定一个 m x n 的矩阵，按照螺旋顺序返回其所有元素。

示例：

输入：matrix = [[1,2,3],[4,5,6],[7,8,9]]
输出：[1,2,3,6,9,8,7,4,5]

解答：

def spiral_matrix(matrix):
    if not matrix or not matrix[0]:
        return []
    m, n = len(matrix), len(matrix[0])
    result = []
    top, bottom, left, right = 0, m - 1, 0, n - 1
    while left <= right and top <= bottom:
        for i in range(left, right + 1):
            result.append(matrix[top][i])
        for i in range(top + 1, bottom):
            result.append(matrix[i][right])
        if top < bottom:
            for i in range(right, left - 1, -1):
                result.append(matrix[bottom][i])
        if left < right:
            for i in range(bottom - 1, top, -1):
                result.append(matrix[i][left])
        top += 1
        bottom -= 1
        left += 1
        right -= 1
    return result

2. 数组中的唯一元素

题意： 给定一个整数数组 nums，其中每个元素都仅出现一次，找出并返回数组中的唯一元素。

示例：

输入：nums = [2,2,1]
输出：1

解答：

def single_number(nums):
    res = 0
    for num in nums:
        res ^= num
    return res

3. 判断整数是否为 2 的幂

题意： 判断给定的整数 n 是否为 2 的幂。

示例：

输入：n = 16
输出：true

解答：

def is_power_of_two(n):
    if n <= 0:
        return False
    while n % 2 == 0:
        n //= 2
    return n == 1

4. LRU 缓存

题意： 设计一个最近最少使用 (LRU) 缓存，它包含以下两个方法：

• get(key) - 如果缓存中存在 key，返回其值。否则，返回 -1。
• put(key, value) - 将 key-value 对添加到缓存中。如果缓存已满，则删除最近最少使用的 key。

解答：

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:
            node = self.cache[key]
            self.remove(node)
            self.add(node)
            return node.val
        else:
            return -1

    def put(self, key: int, value: int) -> None:
        if key in self.cache:
            self.remove(self.cache[key])
        node = Node(key, value)
        self.add(node)
        if len(self.cache) > self.capacity:
            del self.cache[self.head.next.key]
            self.remove(self.head.next)

    def add(self, node):
        self.cache[node.key] = node
        node.next = self.tail
        node.prev = self.tail.prev
        self.tail.prev.next = node
        self.tail.prev = node

    def remove(self, node):
        del self.cache[node.key]
        node.prev.next = node.next
        node.next.prev = node.prev

5. 颠倒二进制位

题意： 给定一个 32 位无符号整数 n，返回其二进制位反转后的结果。

示例：

输入：n = 1100
输出：3

解答：

def reverse_bits(n):
    res = 0
    for i in range(32):
        bit = (n >> i) & 1
        res = (res << 1) | bit
    return res

6. 找不同

题意： 给定两个字符串 s 和 t，它们只包含小写字母。字符串 t 由字符串 s 重新排列，但是其中一个字符被替换为另一个字符。找出并返回被替换的字符。

示例：

输入：s = "abcd", t = "abdc"
输出：'c'

解答：

def find_the_difference(s, t):
    xor = 0
    for c in s + t:
        xor ^= ord(c)
    return chr(xor)

7. 缺失的数字

题意： 给定一个包含从 0 到 n 范围内的所有整数的整数数组 nums，但缺少一个整数。找出这个缺失的整数。

示例：

输入：nums = [3,0,1]
输出：2

解答：

def missing_number(nums):
    n = len(nums)
    expected_sum = (n + 1) * n // 2
    actual_sum = sum(nums)
    return expected_sum - actual_sum