笔面试题，大比拼！66道题轻松拿捏！day1

冲刺春招，精选笔面试 66 题大通关，助您轻松备考！

春招的脚步越来越近了，对于即将步入职场的应届毕业生们来说，笔试和面试是必不可少的环节。为了帮助大家更好地备考，我们精心挑选了 66 道热门面试题，涵盖编程语言、数据结构、算法和操作系统等核心知识点，助您轻松备考春招笔试和面试。

day1 题目：

21. 合并两个有序链表

给定两个有序链表，合并这两个链表，使合并后的链表仍然有序。

146. LRU 缓存

设计一个 LRU 缓存，它包含一个缓存容量，并且可以根据最近最少使用 (LRU) 原则进行工作。

25. K 个一组翻转链表

给定一个链表，将链表每 K 个节点一组进行翻转。

知识点：链表

冲刺01简单

冲刺02中等

冲刺03困难

冲刺02容易在面试中遇见。

解答

21. 合并两个有序链表

def merge_two_sorted_lists(l1, l2):
    """
    合并两个有序链表，使合并后的链表仍然有序。

    Args:
        l1 (ListNode): 第一个链表。
        l2 (ListNode): 第二个链表。

    Returns:
        ListNode: 合并后的链表。
    """

    dummy = ListNode(0)
    curr = dummy

    while l1 and l2:
        if l1.val < l2.val:
            curr.next = l1
            l1 = l1.next
        else:
            curr.next = l2
            l2 = l2.next

        curr = curr.next

    if l1:
        curr.next = l1
    if l2:
        curr.next = l2

    return dummy.next


**146. LRU 缓存** 

```python
class LRUCache:
    """
    设计一个 LRU 缓存，它包含一个缓存容量，并且可以根据最近最少使用 (LRU) 原则进行工作。

    Args:
        capacity (int): 缓存容量。
    """

    def __init__(self, capacity):
        self.capacity = capacity
        self.cache = {}
        self.head = ListNode(0)
        self.tail = ListNode(0)

        self.head.next = self.tail
        self.tail.prev = self.head

    def get(self, key):
        """
        获取缓存中的值。

        Args:
            key (int): 键。

        Returns:
            int: 缓存中的值。
        """

        if key in self.cache:
            node = self.cache[key]
            self.remove_node(node)
            self.add_node(node)

            return node.val
        else:
            return -1

    def put(self, key, value):
        """
        将值放入缓存中。

        Args:
            key (int): 键。
            value (int): 值。
        """

        if key in self.cache:
            node = self.cache[key]
            self.remove_node(node)

        node = ListNode(key, value)
        self.cache[key] = node
        self.add_node(node)

        if len(self.cache) > self.capacity:
            node = self.head.next
            self.remove_node(node)
            del self.cache[node.key]

    def remove_node(self, node):
        """
        从链表中删除节点。

        Args:
            node (ListNode): 要删除的节点。
        """

        node.prev.next = node.next
        node.next.prev = node.prev

    def add_node(self, node):
        """
        将节点添加到链表的头部。

        Args:
            node (ListNode): 要添加的节点。
        """

        node.next = self.head.next
        node.prev = self.head

        self.head.next = node
        node.next.prev = node

**25. K 个一组翻转链表** 

```python
def reverse_k_group(head, k):
    """
    将链表每 K 个节点一组进行翻转。

    Args:
        head (ListNode): 链表的头结点。
        k (int): 每组的节点个数。

    Returns:
        ListNode: 翻转后的链表的头结点。
    """

    dummy = ListNode(0)
    dummy.next = head

    prev = dummy
    while head:
        tail = head
        for i in range(k - 1):
            tail = tail.next
            if not tail:
                return dummy.next

        next = tail.next
        tail.next = None

        head = reverse_list(head, tail)
        prev.next = head

        head = next
        prev = tail

    return dummy.next


def reverse_list(head, tail):
    """
    翻转链表。

    Args:
        head (ListNode): 链表的头结点。
        tail (ListNode): 链表的尾结点。

    Returns:
        ListNode: 翻转后的链表的头结点。
    """

    prev = None
    curr = head
    while curr:
        next = curr.next
        curr.next = prev

        prev = curr
        curr = next

    return prev

冲刺02容易在面试中遇见。

希望这些精选的题目能够对您的春招笔面试有所帮助。祝您旗开得胜，顺利拿到心仪的 offer！