算法进阶必备：剑指Offer 01-04 通关指南

2023-12-26 02:15:56

剑指 Offer 前四章：攻克算法难关的指引

概述

踏入算法世界，剑指 Offer 是程序员的必备指南。本书涵盖了算法学习的方方面面，由浅入深地解析了各种算法技巧。本篇文章将详细剖析剑指 Offer 前四章的题目，为你攻克算法难关提供清晰的指引。

第一章：数组、链表

01. 两数之和

思想：利用哈希表存储元素及其索引，通过差值查找目标数。
代码示例：

def twoSum(nums, target):
    hashtable = {}
    for i, num in enumerate(nums):
        diff = target - num
        if diff in hashtable:
            return [hashtable[diff], i]
        hashtable[num] = i

02. 无重复字符的最长子串

思想：滑动窗口法，维护一个无重复字符的子串。
代码示例：

def lengthOfLongestSubstring(s):
    window_start = 0
    max_length = 0
    char_index_map = {}
    
    for i, char in enumerate(s):
        if char in char_index_map and char_index_map[char] >= window_start:
            window_start = char_index_map[char] + 1
        char_index_map[char] = i
        max_length = max(max_length, i - window_start + 1)
    
    return max_length

第二章：树

03. 二叉树的层次遍历

思想：广度优先搜索，按层打印节点值。
代码示例：

def levelOrder(root):
    if not root:
        return []
    
    queue = [root]
    result = []
    
    while queue:
        level_size = len(queue)
        current_level = []
        
        for i in range(level_size):
            node = queue.pop(0)
            current_level.append(node.val)
            if node.left:
                queue.append(node.left)
            if node.right:
                queue.append(node.right)
        
        result.append(current_level)
    
    return result

04. 二叉搜索树的后续遍历

思想：利用 BST 特性，递归进行后续遍历。
代码示例：

def postorderTraversal(root):
    if not root:
        return []
    
    left_subtree = postorderTraversal(root.left)
    right_subtree = postorderTraversal(root.right)
    
    return left_subtree + right_subtree + [root.val]

第三章：查找与排序

05. 数组中数字出现的次数

思想：利用哈希表存储数字及其出现次数。
代码示例：

def countNumbers(nums):
    num_counts = {}
    
    for num in nums:
        if num not in num_counts:
            num_counts[num] = 0
        num_counts[num] += 1
    
    return num_counts

06. 旋转数组

思想：巧妙算法，将数组分成两部分进行交换。
代码示例：

def rotateArray(nums, k):
    n = len(nums)
    k %= n
    
    reverse(nums, 0, n - 1)
    reverse(nums, 0, k - 1)
    reverse(nums, k, n - 1)

第四章：回溯算法

07. 复原 IP 地址

思想：回溯法，枚举所有可能的 IP 地址片段。
代码示例：

def restoreIpAddresses(s):
    def backtrack(start, dots, path):
        if dots == 0 and start == len(s):
            result.append('.'.join(path))
            return
        
        if len(s) - start > (4 - dots) * 3:
            return
        
        for i in range(1, 4):
            if start + i <= len(s):
                segment = s[start:start + i]
                if (i == 1 or segment[0] != '0') and int(segment) <= 255:
                    path.append(segment)
                    backtrack(start + i, dots - 1, path)
                    path.pop()
    
    result = []
    backtrack(0, 3, [])
    return result

08. 组合总和

思想：回溯法，枚举所有可能的组合。
代码示例：

def combinationSum(candidates, target):
    result = []
    
    def backtrack(start, target, combination):
        if target == 0:
            result.append(combination.copy())
            return
        
        if target < 0 or start >= len(candidates):
            return
        
        combination.append(candidates[start])
        backtrack(start, target - candidates[start], combination)
        combination.pop()
        backtrack(start + 1, target, combination)
    
    backtrack(0, target, [])
    return result