手写代码：掌握面试的利器

手写代码是技术面试中不可避免的一环，它不仅考察了应聘者的编程能力，也考察了其对算法和数据结构的掌握程度。对于应聘者来说，提前准备手写代码非常重要，它可以帮助他们提高面试成功率。

这篇文章列出了13个手写代码面试高频问题，涵盖了算法、数据结构和编程技能等方面。这些问题难度适中，既适合初学者，也适合有经验的程序员。通过练习这些代码，可以帮助应聘者掌握基本的数据结构和算法，提高解决问题的能力和编程技巧，在面试中脱颖而出。

1. 求两个数的最大公约数和最小公倍数

def gcd(a, b):
  while b:
    a, b = b, a % b
  return a

def lcm(a, b):
  return a * b // gcd(a, b)

2. 判断一个数是否是质数

def is_prime(n):
  if n < 2:
    return False
  for i in range(2, int(n ** 0.5) + 1):
    if n % i == 0:
      return False
  return True

3. 求一个整数的反转

def reverse(n):
  reversed = 0
  while n > 0:
    reversed = reversed * 10 + n % 10
    n //= 10
  return reversed

4. 求两个字符串的最长公共子序列

def lcs(a, b):
  dp = [[0] * (len(b) + 1) for _ in range(len(a) + 1)]
  for i in range(1, len(a) + 1):
    for j in range(1, len(b) + 1):
      if a[i - 1] == b[j - 1]:
        dp[i][j] = dp[i - 1][j - 1] + 1
      else:
        dp[i][j] = max(dp[i - 1][j], dp[i][j - 1])
  return dp[len(a)][len(b)]

5. 求一个字符串的所有排列

def permutations(string):
  if len(string) == 1:
    return [string]
  perms = []
  for i in range(len(string)):
    for perm in permutations(string[:i] + string[i + 1:]):
      perms.append(string[i] + perm)
  return perms

6. 实现一个栈

class Stack:
  def __init__(self):
    self.items = []

  def push(self, item):
    self.items.append(item)

  def pop(self):
    return self.items.pop()

  def peek(self):
    return self.items[-1]

  def is_empty(self):
    return len(self.items) == 0

7. 实现一个队列

class Queue:
  def __init__(self):
    self.items = []

  def enqueue(self, item):
    self.items.append(item)

  def dequeue(self):
    return self.items.pop(0)

  def peek(self):
    return self.items[0]

  def is_empty(self):
    return len(self.items) == 0

8. 实现一个链表

class Node:
  def __init__(self, data):
    self.data = data
    self.next = None

class LinkedList:
  def __init__(self):
    self.head = None

  def insert(self, data):
    new_node = Node(data)
    if self.head is None:
      self.head = new_node
    else:
      current = self.head
      while current.next is not None:
        current = current.next
      current.next = new_node

  def delete(self, data):
    if self.head is None:
      return
    if self.head.data == data:
      self.head = self.head.next
      return
    current = self.head
    while current.next is not None:
      if current.next.data == data:
        current.next = current.next.next
        return
      current = current.next

  def print_list(self):
    current = self.head
    while current is not None:
      print(current.data, end=" ")
      current = current.next

9. 实现一个二叉树

class Node:
  def __init__(self, data):
    self.data = data
    self.left = None
    self.right = None

class BinaryTree:
  def __init__(self):
    self.root = None

  def insert(self, data):
    new_node = Node(data)
    if self.root is None:
      self.root = new_node
    else:
      self._insert(new_node, self.root)

  def _insert(self, new_node, current_node):
    if new_node.data < current_node.data:
      if current_node.left is None:
        current_node.left = new_node
      else:
        self._insert(new_node, current_node.left)
    else:
      if current_node.right is None:
        current_node.right = new_node
      else:
        self._insert(new_node, current_node.right)

  def delete(self, data):
    self._delete(data, self.root)

  def _delete(self, data, current_node):
    if current_node is None:
      return
    if data < current_node.data:
      self._delete(data, current_node.left)
    elif data > current_node.data:
      self._delete(data, current_node.right)
    else:
      if current_node.left is None:
        current_node = current_node.right
      elif current_node.right is None:
        current_node = current_node.left
      else:
        min_node = self._min_node(current_node.right)
        current_node.data = min_node.data
        self._delete(min_node.data, current_node.right)

  def _min_node(self, current_node):
    while current_node.left is not None:
      current_node = current_node.left
    return current_node

  def print_tree(self):
    self._print_tree(self.root)

  def _print_tree(self, current_node):
    if current_node is None:
      return
    self._print_tree(current_node.left)
    print(current_node.data, end=" ")
    self._print_tree(current_node.right)

10. 实现一个图

class Graph:
  def __init__(self):
    self.vertices = {}

  def add_vertex(self, vertex):
    if vertex not in self.vertices:
      self.vertices[vertex] = set()

  def add_edge(self, vertex1, vertex2):
    if vertex1 in self.vertices and vertex2 in self.vertices:
      self.vertices[vertex1].add(vertex2)
      self.vertices[vertex2].add(vertex1)

  def remove_vertex(self, vertex):
    if vertex in self.vertices:
      for adjacent_vertex in self.vertices[vertex]:
        self.vertices[adjacent_vertex].remove(vertex)
      del self.vertices[vertex]

  def remove_edge(self, vertex1, vertex2):
    if vertex1 in self.vertices and vertex2 in self.vertices:
      self.vertices[vertex1].remove(vertex2)
      self.vertices[vertex2].remove(vertex1)

  def print_