1. 从“练气”到“算法”一个程序员的修炼隐喻最近在整理自己的算法学习笔记发现一个挺有意思的现象很多刚入行的朋友一提到“算法”两个字要么觉得是面试时才需要突击的“八股文”要么觉得是只有顶尖大厂大神才需要钻研的“屠龙之术”。这种心态往往导致学习过程要么是痛苦的死记硬背要么是浅尝辄止最终在遇到实际问题时脑子里依然是一片空白无法将知识转化为解决问题的能力。这让我想起了以前看过的修仙小说里“练气期”的设定。主角从一个毫无根基的凡人开始首先要做的就是引气入体打通经脉夯实最基础的身体素质。这个过程枯燥、缓慢甚至看不到立竿见影的效果但它决定了未来能走多远、能承载多强的力量。算法学习尤其是入门和基础巩固阶段何其相似。我们不是在追求立刻写出惊世骇俗的代码而是在构建一种最底层的、关于“如何高效解决问题”的思维结构和代码直觉。这就是我理解的“算法修炼之练气篇”。“练气三层”这个说法是我给自己设定的一个阶段性目标拆解。它不代表算法的三个固定知识点而是代表了认知和能力的三个递进层次第一层“感知气感”对应的是能看懂基础代码逻辑知道算法在干什么第二层“运转周天”对应的是能独立分析问题选择合适的算法工具并正确实现它第三层“气贯经脉”对应的是能将算法思想内化灵活变通解决更复杂的实际问题并开始关注时间与空间的平衡。今天我就以一个从业多年的“过来人”身份结合几个最经典的场景聊聊我是如何理解并实践这个“练气三层”的。无论你是正在准备面试的学生还是希望提升工程能力的初级开发者希望这篇“修炼心得”能给你提供一个不一样的、更体系化的视角。2. 练气第一层感知气感——从“能看懂”到“理解意图”很多人学算法的第一步是直接去刷LeetCode看题解。这就像还没学会扎马步就去练招式结果往往是花拳绣腿根基不稳。练气第一层核心是“感知”。你需要感知的不是题目本身而是算法代码背后那种“解决问题的气息”。2.1 经典场景数组遍历与查找我们从一个最简单的操作开始在一个无序数组中查找某个特定值。最直观的做法凡人视角def find_target_naive(arr, target): for i in range(len(arr)): if arr[i] target: return i return -1这段代码谁都能看懂就是从头到尾一个个比较。它的“气感”是什么是一种线性的、无差别的探索。无论数据分布如何它都一视同仁地检查每一个元素。它的“气息”是稳定但笨拙的。进阶做法引入“气感”假设数组已经排序这是很多算法生效的前提就像修炼需要特定的环境。def binary_search(arr, target): left, right 0, len(arr) - 1 while left right: mid left (right - left) // 2 # 防止溢出的小技巧 if arr[mid] target: return mid elif arr[mid] target: left mid 1 else: right mid - 1 return -1现在感知这段代码的“气感”。它不再是盲目遍历而是每次都排除掉一半不可能的区域。它的“气息”是果断的、有方向的、指数级高效的。left和right指针的移动就像修炼中引导气息在经脉中运行每一次循环都让搜索空间收敛。第一层修炼要点不要满足于“代码能跑”。对于每一段核心算法代码问自己三个问题1. 它的核心策略是什么是遍历、是分治、还是贪心2. 它利用了数据的什么特性有序可哈希3. 它的“终止条件”是什么循环结束、指针相遇、递归到底 把代码当成有“生命”的流程去感知而不仅仅是符号的集合。2.2 从“看”到“画”可视化你的理解“感知气感”一个非常有效的方法就是动手画图。比如对于上面的二分查找在纸上画一个数组[1, 3, 5, 7, 9, 11]查找7。初始left0 (值1) right5 (值11)。mid2 (值5)。5 7所以排除左半边left3。第二轮left3 (值7) right5 (值11)。mid4 (值9)。9 7所以排除右半边right3。第三轮left3, right3。mid3 (值7)。找到。这个过程就是把代码中left、right、mid指针的跳动以及数组区间的收缩可视化出来。当你能清晰地画出这个过程你就真正“感知”到了二分查找的“气息”——它是一种区间不断对折的搜索。对于更复杂的递归算法如二叉树遍历、归并排序画递归树或栈帧变化图是突破“看不懂递归”魔咒的必经之路。3. 练气第二层运转周天——独立分析与实现感知到气感后下一步是引导这股气息在体内问题空间按照特定路径算法逻辑运转起来并最终达成目标解决问题。这就是第二层给定一个问题你能独立分析设计出解决方案的“运转路径”并把它写成健壮的代码。3.1 场景实战力扣经典题“两数之和”题目给定一个整数数组nums和一个整数目标值target请你在该数组中找出和为目标值target的那两个整数并返回它们的数组下标。第一步问题分析与“气息”引导选择功法暴力法双循环气息路径是“遍历所有两两组合”。时间复杂度O(n²)空间O(1)。这是最直接的“蛮力”运转适用于极小数据量但气息运转效率太低容易“内力不济”超时。哈希表法这是更高效的“周天运转”路径。核心气息是一边遍历一边记录。气息起点创建一个空的哈希表字典用于存储“数值”到“其索引”的映射。运转过程遍历数组对于当前数字num计算其“伴侣”complement target - num。气息判断检查complement是否已经在哈希表中。如果在说明找到了配对两股气息两个数汇合直接返回结果。气息存储如果不在则将当前num及其索引存入哈希表作为后续数字可能的“伴侣”备选。气息终点遍历结束若无结果则返回空。第二步代码实现与“经脉”打通编写代码def two_sum(nums, target): 使用哈希表解决两数之和问题。 时间复杂度O(n)我们只遍历了一次列表。 空间复杂度O(n)最坏情况下需要存储n-1个元素到哈希表。 num_map {} # 值 - 索引 的映射 for i, num in enumerate(nums): complement target - num if complement in num_map: # 关键判断伴侣是否已存在 return [num_map[complement], i] # 找到返回两个索引 num_map[num] i # 未找到存储当前值供后续查找 return [] # 根据题目要求这里也可以返回None或抛出异常第三步边界与异常处理稳固经脉一个健壮的“周天运转”必须考虑边界情况空数组或单元素数组直接返回无结果。无解题目通常保证有解但实际工程中需考虑。重复元素上述哈希表法天然处理因为后出现的会覆盖先出现的索引但查找时用的是先出现的索引逻辑正确。大数据量哈希表法的O(n)时间复杂度和O(n)空间复杂度在此场景下是较优选择这就是“气息运转高效”的体现。第二层修炼要点拿到问题不要急于编码。先花几分钟进行“气息推演”1. 这个问题最笨的方法怎么做建立基线2. 数据有什么特点能否利用如有序、范围有限3. 是否有已知的高效“功法”算法范式可以套用或改编如哈希表用于快速查找、双指针用于有序数组4. 画出简单的流程图或写出伪代码。这个过程就是你在设计“气息运转路径”。4. 练气第三层气贯经脉——内化思想与灵活变通前两层更多是在学习和应用“标准功法”。第三层则要求你能将这些功法的“核心思想”气息本质抽离出来应用到未曾见过的、更复杂的问题上甚至进行组合与变通。这就是“气贯经脉”让算法思想成为你思维的一部分。4.1 思想迁移从“两数之和”到“三数之和”问题找出数组中所有和为0的三元组且不重复。第一反应能不能用三层循环O(n³)的复杂度几乎不可接受。那么哈希表法呢可以固定一个数a然后问题转化为在剩余数组中寻找target-a的“两数之和”。这依然是O(n²)的复杂度但需要处理去重比较麻烦。更优雅的“气息运转”排序 双指针这是“两数之和”双指针法的升维应用核心思想是固定一个转化问题利用有序性排除无效解。排序先将数组排序。排序本身是O(n log n)但为后续的高效操作奠定了基础。排序后相同的数字会挨在一起便于去重。遍历固定第一个数遍历数组下标为i固定nums[i]作为三元组的第一个数。去重剪枝如果nums[i] 0因为数组已升序后面都是正数和不可能为0直接结束整个循环。气息提前终止避免无用功如果i 0 且 nums[i] nums[i-1]说明这个数字作为第一个数的情况已经考虑过了跳过避免重复解。双指针寻找后两个数问题转化为在i之后的子数组中寻找两数之和为-nums[i]。设置左指针left i 1右指针right len(nums) - 1。计算sum nums[i] nums[left] nums[right]。如果sum 0找到一组解。然后需要移动left和right并跳过所有重复值。如果sum 0说明总和太小left右移增大值。如果sum 0说明总和太大right左移减小值。 这个过程利用了数组有序的特性将寻找两数之和的复杂度从O(n)降到了O(n)因为指针移动是单向的。def three_sum(nums): nums.sort() res [] n len(nums) for i in range(n - 2): # 留出两个位置给 left 和 right # 剪枝1第一个数大于0后续无解 if nums[i] 0: break # 去重1避免重复的固定数 if i 0 and nums[i] nums[i - 1]: continue left, right i 1, n - 1 while left right: total nums[i] nums[left] nums[right] if total 0: res.append([nums[i], nums[left], nums[right]]) # 去重2找到解后跳过所有重复的 left 和 right while left right and nums[left] nums[left 1]: left 1 while left right and nums[right] nums[right - 1]: right - 1 # 移动指针寻找下一组可能解 left 1 right - 1 elif total 0: left 1 # 总和太小增大左值 else: right - 1 # 总和太大减小右值 return res这个解法完美体现了“气贯经脉”思想融合融合了排序、遍历、双指针、去重剪枝多种技巧。效率意识通过排序和双指针将复杂度控制在O(n²)并通过提前剪枝避免了大量无效计算。细节把控去重的逻辑i的去重、left/right的去重是解决此类问题的关键也是容易出错的地方需要气息运转时格外小心。4.2 复杂度分析感知算法的“消耗”与“瓶颈”到了第三层你必须对你写的代码的“消耗”有清晰的感知。这就是时间复杂度和空间复杂度分析。它不是面试的八股而是你选择“功法”和进行“优化”的根本依据。时间复杂度衡量你的“气息”需要运转多少“周天”基本操作次数才能解决问题。常见的有O(1), O(log n), O(n), O(n log n), O(n²), O(2^n)等。上面“三数之和”的解法外层循环O(n)内层双指针遍历O(n)所以是O(n²)。排序是O(n log n)但被O(n²)主导。空间复杂度衡量你的“功法”需要开辟多少额外的“丹田气海”内存空间来辅助运转。除了存储结果的空间要关注你使用的额外数据结构。哈希表法通常带来O(n)的空间开销而双指针法通常只需要O(1)或O(log n)排序的递归栈开销。一个简单的判断原则在时间复杂度相同的情况下优先选择空间复杂度更低的算法当数据规模极大时任何O(n²)的算法都可能成为瓶颈必须想方设法优化到O(n log n)或更低。第三层修炼要点尝试“一题多解”和“多题一解”。对于同一个问题如“两数之和”分别用暴力、哈希表、双指针如果有序实现并对比其优劣。对于不同问题如“三数之和”、“最接近的三数之和”、“四数之和”寻找它们背后共通的“双指针排序”或“哈希表转化”的思想。这个归纳总结的过程就是算法思想内化的过程。5. 实战淬炼一个综合场景的完整“练气”过程让我们用一个稍微复杂但非常经典的场景——实现一个LRU最近最少使用缓存来完整走一遍“练气三层”的修炼过程。这个问题完美结合了数据结构设计和算法思想。问题描述设计并实现一个满足LRU缓存约束的数据结构。它应该支持get(key)和put(key, value)操作时间复杂度为O(1)。当缓存容量达到上限时它应该在写入新数据之前淘汰最久未使用的数据。5.1 第一层感知理解需求与核心“气息”首先抛开代码理解这个数据结构需要什么样的“气息流动”快速访问给定key能O(1)时间找到对应的value。这指向了哈希表字典。顺序维护需要知道哪个数据是“最近使用”的哪个是“最久未使用”的。并且这个顺序要能随着get和put动态变化。这指向了链表因为插入和删除节点是O(1)。更具体地说我们需要一个能快速将某个节点移动到头部表示最近使用并在尾部删除节点淘汰最久未用的链表。这正好是双向链表的特性。两者结合哈希表负责快速定位节点双向链表负责维护使用顺序。这就是“气息”交汇点。5.2 第二层运转设计数据结构与操作路径现在我们设计具体的“周天运转路径”。数据结构设计一个哈希表cachekey - Node的映射。一个双向链表Node包含key,value,prev,next。两个哨兵节点head和tail方便处理边界条件让链表操作更统一。核心操作路径设计_add_to_head(node)将节点添加到链表头部表示最新使用。_remove_node(node)从链表中移除一个节点。_move_to_head(node)组合上面两个操作先移除再添加到头部。_pop_tail()移除并返回链表尾部的节点即最久未使用的节点。get(key)操作路径气息探查在cache中查找key。气息判断若不存在返回-1或抛异常。气息运转若存在获取对应节点调用_move_to_head(node)更新其为最近使用。气息归元返回节点的value。put(key, value)操作路径气息探查在cache中查找key。分支一存在更新节点的value。调用_move_to_head(node)。分支二不存在气息凝聚创建新节点。气息存储将key: node加入cache。气息连接调用_add_to_head(node)将节点加入链表头部。气息净化容量检查如果cache大小超过容量capacity调用_pop_tail()得到待删除的尾节点。从cache中删除该尾节点对应的key。断开尾节点与链表的连接在_pop_tail中已完成。5.3 第三层贯通代码实现与复杂度内化将上述设计转化为代码并深刻理解其O(1)复杂度的来源。class DLinkedNode: def __init__(self, key0, value0): self.key key self.value value self.prev None self.next None class LRUCache: def __init__(self, capacity: int): self.capacity capacity self.size 0 self.cache {} # 哈希表用于O(1)查找 # 使用伪头部和伪尾部节点简化边界条件处理 self.head DLinkedNode() self.tail DLinkedNode() self.head.next self.tail self.tail.prev self.head def _add_to_head(self, node): 将节点添加到链表头部最近使用 node.prev self.head node.next self.head.next self.head.next.prev node self.head.next node def _remove_node(self, node): 从链表中移除一个节点 node.prev.next node.next node.next.prev node.prev def _move_to_head(self, node): 将节点移动到头部先删后加 self._remove_node(node) self._add_to_head(node) def _pop_tail(self): 弹出链表尾部节点最久未使用 node self.tail.prev self._remove_node(node) return node def get(self, key: int) - int: if key not in self.cache: return -1 node self.cache[key] # 使用过移至头部 self._move_to_head(node) return node.value def put(self, key: int, value: int) - None: if key in self.cache: # key存在更新值并移至头部 node self.cache[key] node.value value self._move_to_head(node) else: # key不存在创建新节点 new_node DLinkedNode(key, value) self.cache[key] new_node self._add_to_head(new_node) self.size 1 # 如果超出容量移除尾部节点 if self.size self.capacity: tail_node self._pop_tail() del self.cache[tail_node.key] # 从哈希表中也删除 self.size - 1复杂度内化分析get和put操作之所以是O(1)是因为哈希表提供了O(1)的查找。双向链表的插入头部、删除任意节点、移动先删后插都是O(1)的指针操作。所有核心子操作_add_to_head,_remove_node,_move_to_head,_pop_tail都只涉及常数次指针赋值没有循环。“气贯经脉”的体现这个问题没有直接调用任何标准库的复杂数据结构如OrderedDict而是用最基本的哈希表和双向链表通过精妙的组合实现了符合LRU语义的复杂行为。这要求你对这两种基础数据结构的特性有深刻理解并能将它们“贯通”起来解决新问题。通过这个完整的LRU缓存实现你应该能感受到算法修炼不是背诵模板而是理解数据流动气息的逻辑设计高效的数据结构经脉来承载它并用简洁可靠的代码功法将其实现出来。每一层修炼都是对这个问题更深入一层的理解和掌控。
