超简洁版手写代码宝典，让你过目不忘！**

2024-02-23 20:58:25

程序员面试中，手写代码环节就像试金石，检验着候选人的编程功底和解决问题的能力。很多朋友觉得这部分很难，其实只要抓住一些常见算法和数据结构的实现，就能轻松应对。今天，咱们就来聊聊几种面试中常考的手写代码，分析它们的原理，并用通俗易懂的方式来实现它们。

数组反转：

想象一下，你需要把一排书从左到右的顺序翻转成从右到左。数组反转也是类似的道理，我们需要把数组元素的顺序颠倒过来。实现的方法很简单，我们可以设置两个指针，一个指向数组的开头，一个指向数组的结尾。然后，我们交换这两个指针所指向的元素，并将指针分别向中间移动，直到两个指针相遇。

def reverse_array(arr):
    left = 0
    right = len(arr) - 1
    while left < right:
        arr[left], arr[right] = arr[right], arr[left]
        left += 1
        right -= 1
    return arr

这段代码的核心就是 arr[left], arr[right] = arr[right], arr[left] 这行，它巧妙地利用 Python 的语法特性，实现了两个元素的交换，是不是很简洁？

链表反转：

链表就像一列火车，每个车厢都装着数据，并且通过连接器连接到下一个车厢。链表反转，就是要把这列火车的车头变成车尾，车尾变成车头，同时保持车厢之间的连接关系不变。我们可以用三个指针来完成这个操作：prev 指向前一个节点，current 指向当前节点，next_node 指向下一个节点。

def reverse_list(head):
    prev = None
    current = head
    while current:
        next_node = current.next  # 先保存下一个节点
        current.next = prev      # 反转当前节点的指向
        prev = current          # prev 指针向前移动
        current = next_node      # current 指针向前移动
    return prev

这段代码的关键在于 current.next = prev，它将当前节点的指针指向前一个节点，从而实现了链表的反转。

二分查找：

如果你要在一本字典里查找一个单词，你会怎么做？肯定不会从头到尾一页一页地翻，而是会利用字典的排序特性，快速定位到目标单词所在的页面。二分查找也是类似的思路，它适用于在一个有序数组中查找目标元素。

def binary_search(arr, target):
    low = 0
    high = len(arr) - 1
    while low <= high:
        mid = (low + high) // 2
        if arr[mid] == target:
            return mid
        elif arr[mid] < target:
            low = mid + 1
        else:
            high = mid - 1
    return -1

这段代码的核心是 mid = (low + high) // 2，它计算出中间元素的索引。然后，我们将目标元素与中间元素进行比较，如果相等则返回中间元素的索引；如果目标元素更大，则在右半部分继续查找；如果目标元素更小，则在左半部分继续查找。

快速排序：

快速排序是一种高效的排序算法，它的基本思想是“分而治之”。首先，我们选择一个元素作为“基准”（pivot），然后将数组分成两部分：小于基准的元素放在左边，大于基准的元素放在右边。接着，我们对左右两部分分别进行递归排序，最终得到一个有序的数组。

def quick_sort(arr):
    if len(arr) <= 1:
        return arr

    pivot = arr[len(arr) // 2]
    left = [x for x in arr if x < pivot]
    middle = [x for x in arr if x == pivot]
    right = [x for x in arr if x > pivot]

    return quick_sort(left) + middle + quick_sort(right)

这段代码的核心是 quick_sort(left) + middle + quick_sort(right)，它将左右两部分的排序结果与基准元素合并，实现了递归排序。

深度优先搜索（DFS）和广度优先搜索（BFS）：

DFS 和 BFS 都是图遍历算法，它们可以用来查找图中的所有节点，或者查找从起点到终点的路径。DFS 就像走迷宫，它会沿着一条路一直走到尽头，然后再回溯到上一个岔路口，继续探索其他的路径。BFS 则像水波扩散，它会先访问起点的所有邻居节点，然后再访问邻居节点的邻居节点，以此类推。

def dfs(graph, start):
    visited = set()
    stack = [start]

    while stack:
        vertex = stack.pop()
        if vertex not in visited:
            visited.add(vertex)
            for neighbor in graph[vertex]:
                if neighbor not in visited:
                    stack.append(neighbor)

    return visited

def bfs(graph, start):
    visited = set()
    queue = [start]

    while queue:
        vertex = queue.pop(0)
        if vertex not in visited:
            visited.add(vertex)
            for neighbor in graph[vertex]:
                if neighbor not in visited:
                    queue.append(neighbor)

    return visited