常见算法介绍、算法刷题（含解析与代码）、笔试面试算法题

常见算法介绍

1. 排序算法

• 冒泡排序（Bubble Sort）：

  • 时间复杂度：O(n^2)

  • 简单但效率低，适用于小规模数据。

  • 核心思想：相邻元素两两比较并交换，使得最大的元素逐步移动到数组末尾。

• 选择排序（Selection Sort）：

  • 时间复杂度：O(n^2)

  • 通过选择最小（大）的元素放在已排序序列的末尾。

  • 核心思想：每一轮从未排序序列中选出最小元素，放到已排序序列的末尾。

• 插入排序（Insertion Sort）：

  • 时间复杂度：O(n^2)

  • 适用于基本有序的小规模数据。

  • 核心思想：将未排序序列中的元素逐一插入到已排序序列中的适当位置。

• 快速排序（Quick Sort）：

  • 时间复杂度：O(n log n)

  • 核心思想：选择一个基准元素，分区，将比基准小的元素放左边，比基准大的元素放右边，然后递归排序。

• 归并排序（Merge Sort）：

  • 时间复杂度：O(n log n)

  • 核心思想：分治法，将数组分成两部分，分别排序后再合并。

• 堆排序（Heap Sort）：

  • 时间复杂度：O(n log n)

  • 利用堆数据结构进行排序。

  • 核心思想：将数组转化为一个最大（小）堆，逐步取出堆顶元素。

2. 查找算法

• 线性查找（Linear Search）：

  • 时间复杂度：O(n)

  • 从头到尾逐个比较元素。

• 二分查找（Binary Search）：

  • 时间复杂度：O(log n)

  • 适用于有序数组，通过逐步缩小查找范围。

3. 图算法

• 深度优先搜索（DFS）：

  • 核心思想：沿着一条路径不断深入，直至不能继续，再回溯。

  • 应用：拓扑排序、连通分量、路径查找等。

• 广度优先搜索（BFS）：

  • 核心思想：层层扩展搜索范围，先访问距离起点最近的节点。

  • 应用：最短路径、图的连通性检测等。

• Dijkstra算法：

  • 时间复杂度：O(V^2)（使用优先队列可以优化）

  • 核心思想：在加权图中找到从源点到其他所有节点的最短路径。

• Floyd-Warshall算法：

  • 时间复杂度：O(V^3)

  • 核心思想：动态规划算法，用于计算所有节点对的最短路径。

4. 动态规划（Dynamic Programming）

• 核心思想：将问题拆分为子问题，解决每个子问题并存储其结果以避免重复计算。

• 应用：斐波那契数列、最长公共子序列（LCS）、背包问题等。

5. 分治法（Divide and Conquer）

• 核心思想：将问题分解为规模较小的子问题，解决子问题后合并结果。

• 应用：归并排序、快速排序、最大子数组问题等。

算法刷题（含解析与代码）

1. 两数之和（Two Sum）

• 题目描述：给定一个整数数组nums和一个目标值target，请你在该数组中找出和为目标值的那两个整数，并返回他们的数组下标。

• 示例：

  plaintext
  复制代码
  输入：nums = [2, 7, 11, 15], target = 9
  输出：[0, 1]
  解释：因为 nums[0] + nums[1] == 9 ，返回 [0, 1] 。

• 解析：

  1. 可以使用暴力法，双重循环查找，时间复杂度O(n^2)。

  2. 也可以使用哈希表来提高效率，时间复杂度O(n)。

• 代码实现（Python）：

  python
  复制代码
  def two_sum(nums, target):
      hash_map = {}
      for i, num in enumerate(nums):
          if target - num in hash_map:
              return [hash_map[target - num], i]
          hash_map[num] = i
  
  # 测试
  nums = [2, 7, 11, 15]
  target = 9
  print(two_sum(nums, target))  # 输出: [0, 1]

2. 反转链表（Reverse Linked List）

• 题目描述：反转一个单链表。

• 示例：

  plaintext
  复制代码
  输入: 1->2->3->4->5->NULL
  输出: 5->4->3->2->1->NULL

• 解析： 使用三个指针来反转链表：prev指向前一个节点，current指向当前节点，next_node指向下一个节点。

• 代码实现（Python）：

  python
  复制代码
  class ListNode:
      def __init__(self, val=0, next=None):
          self.val = val
          self.next = next
  
  def reverse_list(head):
      prev = None
      current = head
      while current:
          next_node = current.next
          current.next = prev
          prev = current
          current = next_node
      return prev
  
  # 测试
  def print_list(head):
      while head:
          print(head.val, end=" -> ")
          head = head.next
      print("NULL")
  
  # 创建链表 1->2->3->4->5->NULL
  head = ListNode(1, ListNode(2, ListNode(3, ListNode(4, ListNode(5)))))
  print_list(head)
  reversed_head = reverse_list(head)
  print_list(reversed_head)

笔试面试算法题

1. 寻找数组的中位数（Find Median of Array）

• 题目描述：给定两个大小分别为m和n的正序（从小到大）数组nums1和nums2。请你找出并返回这两个正序数组的中位数。

• 示例：

  plaintext
  复制代码
  输入: nums1 = [1, 3], nums2 = [2]
  输出: 2.00000
  解释: 合并数组 = [1, 2, 3] ，中位数 2

• 解析：

  1. 合并两个数组并排序，找到中位数，时间复杂度为O((m+n)log(m+n))。

  2. 使用二分查找优化，时间复杂度为O(log(min(m, n)))。

• 代码实现（Python）：

  python
  复制代码
  def find_median_sorted_arrays(nums1, nums2):
      A, B = sorted((nums1, nums2), key=len)
      m, n = len(A), len(B)
      half_len = (m + n + 1) // 2
      imin, imax = 0, m
      while imin <= imax:
          i = (imin + imax) // 2
          j = half_len - i
          if i < m and B[j-1] > A[i]:
              imin = i + 1
          elif i > 0 and A[i-1] > B[j]:
              imax = i - 1
          else:
              if i == 0: max_of_left = B[j-1]
              elif j == 0: max_of_left = A[i-1]
              else: max_of_left = max(A[i-1], B[j-1])
              if (m + n) % 2 == 1:
                  return max_of_left
  
              if i == m: min_of_right = B[j]
              elif j == n: min_of_right = A[i]
              else: min_of_right = min(A[i], B[j])
              return (max_of_left + min_of_right) / 2.0
  
  # 测试
  nums1 = [1, 3]
  nums2 = [2]
  print(find_median_sorted_arrays(nums1, nums2))  # 输出: 2.0

2. 最长公共子序列（Longest Common Subsequence）

• 题目描述：给定两个字符串text1和text2，返回这两个字符串的最长公共子序列的长度。

• 示例：

  plaintext
  复制代码
  输入：text1 = "abcde", text2 = "ace"
  输出：3
  解释：最长公共子序列是 "ace" ，它的长度为 3 。

• 解析： 使用动态规划构建二维数组dp，其中dp[i][j]表示text1前i个字符和text2前j个字符的最长公共子序列长度。

• 代码实现（Python）：

  python
  复制代码
  def longest_common_subsequence(text1, text2):
      m, n = len(text1), len(text2)
      dp = [[0] * (n + 1) for _ in range(m + 1)]
      for i in range(1, m + 1):
          for j in range(1, n + 1):
              if text1[i - 1] == text2[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[m][n]
  
  # 测试
  text1 = "abcde"
  text2 = "ace"
  print(longest_common_subsequence(text1, text2))  # 输出: 3

这些算法和题目涵盖了排序、查找、动态规划、字符串处理等常见面试主题，通过练习这些题目，你可以巩固算法基础，并提升解决实际问题的能力。