1.1 插入的本质：维护一个动态的有序世界
插入排序的核心思想，是始终将待排序的序列在逻辑上划分为两个泾渭分明的部分：
- 左侧的“已排序”子数组 (Sorted Subarray)：这个部分在算法的每一步都保持着完美的内部有序。它像一个秩序井然的俱乐部，从最初只包含一个成员（列表的第一个元素）开始，不断地接纳新成员。
- 右侧的“未排序”子数组 (Unsorted Subarray)：这是等待被审视和接纳的外部世界。算法的每一次迭代，都会从这个区域的最左侧，挑选出一位“候选人”。
插入排序的每一个宏观步骤，都是一个优雅的“接纳仪式”：
- 挑选（Pick）：从“未排序”区域的边界（即紧挨着“已排序”区域的第一个元素）挑选出“候选人”元素。我们称之为
key或current_element。 - 寻找（Find Position）：将这个
key与“已排序”区域的成员，从右向左，逐一进行比较。这个过程的目的是为key找到它在这个有序俱乐部中的确切位置。 - 移位（Shift）：在寻找位置的过程中，所有比
key大的“老成员”，都需要礼貌地向右移动一个位置，为key的到来腾出空间。这个“移位”操作是插入排序区别于选择排序的关键力学行为，它不是一次性的远距离交换，而是一连串的、小碎步式的“涟漪”效应。 - 插入（Insert）：当为
key腾出的空位出现后（即找到了一个比key小或等于的成员，或已经比较完了所有成员），就将key安放在这个空位上。
这个过程不断重复，未排序区域的候选人被逐一接纳，已排序的区域不断向右扩张，直至吞噬整个列表。
这种“拿出一个，插入一串”的模式，与我们人类在整理扑克牌时的直觉行为高度相似。当你手中已经有一副排好序的牌，再从牌堆里摸一张新牌时，你会自然地从右到左审视你手中的牌，找到新牌应该插入的位置，然后把它放进去。这种内在的、符合直觉的逻辑，使得插入排序成为最容易理解的排序算法之一。
1.2 循环不变量：算法正确性的逻辑钢印
与选择排序一样，我们可以使用循环不变量来为插入排序的正确性提供坚实的数学证明。对于插入排序的外层循环（由索引 i 控制，从1开始），其循环不变量可以定义如下：
不变量：在外层循环的第 i 次迭代开始之前，子数组 nums[0...i-1] 包含了原始数组 nums[0...i-1] 中的所有元素，但它们是经过排序的。
我们来验证这个不变量的生命周期：
-
初始化（Initialization）：
- 在第一次迭代（
i=1）开始之前，子数组nums[0...0]只包含一个元素。一个只含单个元素的子数组，其本身必然是有序的。不变量成立。
- 在第一次迭代（
-
保持（Maintenance）：
- 假设：在第
i次迭代开始之前，不变量为真，即nums[0...i-1]是一个有序的子数组。 - 迭代过程：在第
i次迭代中，算法将nums[i]作为key。然后，它通过内层循环，将key与nums[0...i-1]中的元素从右到左进行比较和移位。这个过程会为key在nums[0...i-1]中找到一个正确的位置，并将其插入。 - 结果：插入操作完成后，新的子数组
nums[0...i]包含了原始的nums[0...i]中的所有元素，并且由于key被插入到了正确的位置，这个新的、更长的子数组也保持了有序状态。 - 因此，在下一次迭代（第
i+1次）开始之前，不变量依然为真。
- 假设：在第
-
终止（Termination）：
- 外层循环在
i遍历完n-1后结束，此时i的值为n。 - 根据不变量，在循环终止时（即第
n次迭代“开始”前），子数组nums[0...n-1]（也就是整个数组）包含了原始数组nums[0...n-1]的所有元素，并且它们是有序的。 - 算法正确性得证。
- 外层循环在
1.3 纤毫毕现的视觉化追踪：移位与插入的舞蹈
让我们通过一个具体的例子 nums = [5, 2, 4, 6, 1, 3]，来显微镜般地观察插入排序的每一个动作。
初始状态:
已排序分区: [5]
未排序分区: [2, 4, 6, 1, 3]
第 1 轮 (i = 1):
- 挑选:
key = nums[1]，即2。 - 寻找与移位:
j = 0。while j >= 0 and key(2) < nums[j](5)? 是。- 执行移位：
nums[j+1] = nums[j]，即nums[1] = nums[0]。数组变为[5, 5, 4, 6, 1, 3]。 j减一，j = -1。while循环条件j >= 0不满足，循环结束。
- 插入:
nums[j+1] = key，即nums[0] = 2。 - 本轮结果:
- 数组状态:
[2, 5, 4, 6, 1, 3] 已排序分区: [2, 5]未排序分区: [4, 6, 1, 3]
- 数组状态:
第 2 轮 (i = 2):
- 挑选:
key = nums[2]，即4。 - 寻找与移位:
j = 1。while j >= 0 and key(4) < nums[j](5)? 是。- 执行移位：
nums[j+1] = nums[j]，即nums[2] = nums[1]。数组变为[2, 5, 5, 6, 1, 3]。 j减一，j = 0。while j >= 0 and key(4) < nums[j](2)? 否。循环结束。
- 插入:
nums[j+1] = key，即nums[1] = 4。 - 本轮结果:
- 数组状态:
[2, 4, 5, 6, 1, 3] 已排序分区: [2, 4, 5]未排序分区: [6, 1, 3]
- 数组状态:
第 3 轮 (i = 3):
- 挑选:
key = nums[3]，即6。 - 寻找与移位:
j = 2。while j >= 0 and key(6) < nums[j](5)? 否。循环立即结束。
- 插入:
nums[j+1] = key，即nums[3] = 6。元素没有移动，但逻辑上执行了插入。 - 本轮结果:
- 数组状态:
[2, 4, 5, 6, 1, 3] 已排序分区: [2, 4, 5, 6]未排序分区: [1, 3]
- 数组状态:
第 4 轮 (i = 4):
- 挑选:
key = nums[4]，即1。 - 寻找与移位:
j = 3。while j >= 0 and key(1) < nums[j](6)? 是。移位后数组:[2, 4, 5, 6, 6, 3]。j变为2。while j >= 0 and key(1) < nums[j](5)? 是。移位后数组:[2, 4, 5, 5, 6, 3]。j变为1。while j >= 0 and key(1) < nums[j](4)? 是。移位后数组:[2, 4, 4, 5, 6, 3]。j变为0。while j >= 0 and key(1) < nums[j](2)? 是。移位后数组:[2, 2, 4, 5, 6, 3]。j变为-1。- 循环结束。
- 插入:
nums[j+1] = key，即nums[0] = 1。 - 本轮结果:
- 数组状态:
[1, 2, 4, 5, 6, 3] 已排序分区: [1, 2, 4, 5, 6]未排序分区: [3]
- 数组状态:
第 5 轮 (i = 5):
- 挑选:
key = nums[5]，即3。 - 寻找与移位:
j = 4。while j >= 0 and key(3) < nums[j](6)? 是。移位后数组:[1, 2, 4, 5, 6, 6]。j变为3。while j >= 0 and key(3) < nums[j](5)? 是。移位后数组:[1, 2, 4, 5, 5, 6]。j变为2。while j >= 0 and key(3) < nums[j](4)? 是。移位后数组:[1, 2, 4, 4, 5, 6]。j变为1。while j >= 0 and key(3) < nums[j](2)? 否。循环结束。
- 插入:
nums[j+1] = key，即nums[2] = 3。 - 本轮结果:
- 数组状态:
[1, 2, 3, 4, 5, 6] 已排序分区: [1, 2, 3, 4, 5, 6]未排序分区: []
- 数组状态:
算法终止: 外层循环结束。整个数组已有序。
1.4 基础Python实现及其微观剖析
现在，我们将这个精巧的“移位-插入”舞蹈翻译成Python代码，并对每一行代码的意图进行深度解构。
def insertion_sort_basic(nums):
"""
对一个列表进行插入排序的基础实现。
参数:
nums (list): 一个由可比较元素（如数字）组成的列表。
"""
n = len(nums) # 计算列表的长度，以备后续循环使用，避免重复计算。
# 外层循环：负责从左到右扩大“已排序”区域。
# 它从索引 1 开始，因为单个元素 nums[0] 本身就是已排序的。
# i 指向的是每一轮中，那个即将被挑选出来插入到前面有序区的“候选人”。
for i in range(1, n):
# 挑选“候选人”：将当前待插入的元素值保存在一个临时变量 key 中。
# 这样做是必要的，因为在后续的移位操作中，nums[i] 的原始位置可能会被覆盖。
key = nums[i]
# 初始化一个指针 j，它指向已排序子数组的最右边的元素。
# 我们将用这个指针从右向左扫描已排序区。
j = i - 1
# 内层循环：这是算法的核心，负责“寻找位置”和“移位”。
# 循环的条件有两个，必须同时满足：
# 1. j >= 0: 保证我们的扫描指针不会越出列表的左边界。
# 2. key < nums[j]: 只要“候选人”key 比当前扫描到的有序区元素 nums[j] 要小，
# 就说明还没找到 key 的最终位置，需要继续向左寻找。
while j >= 0 and key < nums[j]:
# 执行“移位”操作：将比 key 大的元素 nums[j] 向右移动一格，到 j+1 的位置。
# 这个操作为 key 腾出了它左边的空间。
nums[j + 1] = nums[j]
# 将扫描指针向左移动一位，以便在下一轮循环中比较前一个元素。
j -= 1
# 插入操作：当 while 循环结束时，意味着我们找到了 key 的正确插入位置。
# 这个位置就是 j 指针当前所在位置的右边一格，即 j+1。
# 循环结束的原因要么是 j 变成了 -1 (说明 key 是当前最小的)，
# 要么是遇到了一个小于或等于 key 的元素 (nums[j] <= key)。
nums[j + 1] = key
# --- 示例代码 ---
# data_to_sort_insert = [5, 2, 4, 6, 1, 3] # 定义一个待排序的列表
# print(f"原始列表: {data_to_sort_insert}") # 打印排序前的列表状态
# insertion_sort_basic(data_to_sort_insert) # 调用插入排序函数，此函数是原地排序
# print(f"插入排序后: {data_to_sort_insert}") # 打印排序后的结果
代码的深度解读:
for i in range(1, n): 这个循环的起点1蕴含了算法的初始假设——nums[0]自己构成了第一个微小的有序世界。key = nums[i]: 这是对“候选人”的“保护”。如果不把nums[i]的值存起来，当nums[i-1]向右移动到nums[i]的位置时，它的原始值就丢失了。j = i - 1:j是一个向历史回溯的指针，它在已建立的秩序中为新人寻找位置。while j >= 0 and key < nums[j]: 这行代码是插入排序的灵魂。它完美地融合了边界检查（j >= 0）和排序逻辑（key < nums[j]）。这种将两个条件用and连接的写法，利用了Python的“短路求值”（short-circuit evaluation）特性：如果j >= 0为假，Python甚至不会去检查key < nums[j]，从而自然地避免了nums[-1]这样的无效索引错误。nums[j + 1] = nums[j]: 这不是交换，而是覆盖。它描绘了一幅元素“向右挪动，腾出空间”的生动画面。nums[j + 1] = key: 这是点睛之笔。在经历了一系列向右的“涟漪”之后，key被精准地安放在了最终的空隙中。j+1这个索引的计算是精髓，无论循环因何种原因结束，它都指向了正确的插入点。
第二章：复杂度的双面性与算法的核心特质
插入排序的性能表现出一种迷人的“双面性”。它不像选择排序那样，无论输入如何都“一根筋”地执行 O(n²) 的操作。相反，插入排序的性能与其输入数据的“有序程度”高度相关，这种特性我们称之为**“自适应性”（Adaptive）**。
2.1 时间复杂度的三种面孔
2.1.1 最佳情况：当世界早已和平 (O(n))
- 场景: 输入的数组已经完全排好序。例如
[10, 20, 30, 40, 50]。 - 行为分析:
- 外层
for循环仍然会执行n-1次，从i=1到n-1。 - 在每一次迭代中，当执行到内层
while j >= 0 and key < nums[j]时，key(即nums[i]) 永远不会小于它左边的元素nums[j](即nums[i-1])。 - 因此，内层
while循环的条件永远为假，其循环体（移位操作）将永远不会被执行。
- 外层
- 计算成本:
- 比较次数：外层循环每次只执行一次比较（
while循环的条件判断），总共n-1次比较。 - 移动（赋值）次数：外层循环每次执行两次赋值（
key = nums[i]和nums[j+1] = key），总共2 * (n-1)次。没有元素移位。
- 比较次数：外层循环每次只执行一次比较（
- 复杂度: 算法的总操作数与
n成线性关系。因此，插入排序的最佳时间复杂度是 O(n)。
这种 O(n) 的最佳情况性能，是插入排序相比选择排序和冒泡排序（基础版）的一个巨大优势。它意味着，如果给我们一个“几乎”排好序的数组，插入排序可以非常、非常快地完成工作。
2.1.2 最坏情况：当世界完全颠倒 (O(n²))
- 场景: 输入的数组是完全逆序的。例如
[50, 40, 30, 20, 10]。 - 行为分析:
- 外层
for循环执行n-1次。 - 在每一次迭代中，
key(即nums[i]) 都是当前已排序子数组中最小的元素。 - 因此，
key必须与已排序子数组中的每一个元素进行比较，并导致每一个元素都向右移动一位。
- 外层
- 计算成本:
- 当
i=1时，内层循环比较/移动 1 次。 - 当
i=2时，内层循环比较/移动 2 次。 - …
- 当
i=n-1时，内层循环比较/移动n-1次。 - 总的比较/移动次数是
1 + 2 + 3 + ... + (n-1)。这是一个等差数列，其和为n * (n-1) / 2。
- 当
- 复杂度: 算法的总操作数与
n²成正比（0.5n² - 0.5n）。因此，插入排序的最坏时间复杂度是 O(n²)。
2.1.3 平均情况：混沌中的普遍性 (O(n²))
- 场景: 输入的数组是随机排列的。
- 行为分析:
- 在平均情况下，我们可以预期“候选人”
key需要被插入到已排序子数组nums[0...i-1]的中间位置。 - 这意味着，对于一个长度为
i的已排序子数组，key平均需要与i/2个元素进行比较和移位。
- 在平均情况下，我们可以预期“候选人”
- 计算成本:
- 总的比较/移动次数大约是
1/2 + 2/2 + 3/2 + ... + (n-1)/2，即(1/2) * (1 + 2 + ... + n-1)。 - 这等于
(1/2) * (n * (n-1) / 2) = n * (n-1) / 4。
- 总的比较/移动次数大约是
- 复杂度: 总操作数仍然与
n²成正比（0.25n² - 0.25n）。因此，插入排序的平均时间复杂度也是 O(n²)。
自适应性的深刻内涵: 插入排序的性能与其输入的“无序度”直接相关。我们可以用“逆序对”（Inversion Pair）的数量来更精确地衡量无序度。一个逆序对指的是数组中 i < j 但 nums[i] > nums[j] 的一对元素。插入排序的交换（移位）次数恰好等于数组中逆序对的数量。当逆序对很少时（接近有序），算法性能接近 O(n)；当逆序对很多时（接近逆序），算法性能接近 O(n²)。
2.2 空间复杂度的朴素：O(1)
与选择排序一样，插入排序也是一个原地排序算法（In-place Algorithm），其空间复杂度为 O(1)。
它所需要的额外辅助空间只有：
n: 存储列表长度。i: 外层循环计数器。key: 存储当前待插入的元素值。j: 内层循环的扫描指针。
无论输入数组的规模 n有多大，这些辅助变量所占用的空间都是一个固定的常数，不随 n 的增长而增长。
2.3 稳定性的坚守：一种宝贵的品质
稳定性是排序算法的一个关键特性，它保证了值相等的元素的原始相对顺序在排序后不会改变。
插入排序是稳定的（Stable）。
证明与分析:
稳定性的关键，在于内层 while 循环的比较条件：key < nums[j]。
我们使用的是严格的“小于”比较，而不是“小于或等于”。
让我们来分析当 key 与一个和它值相等的元素 nums[j] (即 key == nums[j]) 相遇时会发生什么：
while循环的条件key < nums[j]将会为假。- 循环会立即终止。
key将被插入到nums[j]的右边（j+1的位置）。
这意味着，待插入的元素 key 永远不会“越过”一个在它前面、且与它值相等的元素。它会被安放在所有与它相等的元素的后面，从而完美地保持了它们的原始相对顺序。
一个直观的例子:
data_stability = [(5, 'a'), (2, 'b'), (5, 'c')]，我们希望按数字排序。
- 初始，
已排序区: [(5, 'a')],未排序区: [(2, 'b'), (5, 'c')]。 - 插入
(2, 'b')，结果:[(2, 'b'), (5, 'a')]。 - 接下来，挑选
key = (5, 'c')。 j=1，key与nums[1](即(5, 'a')) 比较。key的键5不小于nums[j]的键5。while循环不执行。key被插入到j+1(即2) 的位置。- 最终结果:
[(2, 'b'), (5, 'a'), (5, 'c')]。
(5, 'a')和(5, 'c')的原始顺序被完美保留。
这种稳定性使得插入排序在某些特定场景下（例如，需要多级排序的场景）比不稳定的选择排序或堆排序更有价值。Timsort算法之所以选择插入排序来处理小的“run”，其稳定性也是一个重要的考量因素。
第三章：突破瓶颈：插入排序的优化与变体
插入排序 O(n²) 的平均和最坏时间复杂度，源于其两个核心操作的累积成本：
- 寻找插入位置：在已排序的子数组中，通过逐个线性比较来找到正确的位置。
- 移位插入：通过逐个元素向右移动来为新元素腾出空间。
对于一个长度为 k 的有序子数组，这两步操作在最坏情况下都需要 O(k) 的时间。任何对插入排序的实质性优化，都必须从减少这两个操作的成本入手。本章，我们将探索两种截然不同的优化路径：一种是通过更高效的查找算法来加速“寻找”过程，另一种是通过重塑算法结构来减少“移位”的总距离。
3.1 加速“寻找”：二分插入排序 (Binary Insertion Sort)
线性查找的效率是低下的。当我们面对的是一个已经排好序的子数组时，一个自然而然的想法涌上心头：为什么不使用更高效的**二分查找（Binary Search）**来确定插入位置呢？
这就是**二分插入排序（Binary Insertion Sort）**的核心思想。它将插入排序的“寻找”阶段，从 O(k) 的线性扫描，优化到了 O(log k) 的对数时间复杂度。
算法的精细化改造:
二分插入排序的每一轮迭代（i 从 1 到 n-1）被分解为三个清晰的步骤：
- 挑选与暂存: 和标准插入排序一样，挑选
key = nums[i]并将其暂存。 - 二分查找位置: 在已排序的子数组
nums[0...i-1]中，使用二分查找算法，找到key应该被插入的确切位置pos。这个位置pos的含义是，key应该被放在nums[pos]上，而原来从nums[pos]到nums[i-1]的所有元素都应该向右移动。 - 批量移位与插入: 将子数组
nums[pos...i-1]的所有元素，整体向右移动一个位置，形成nums[pos+1...i]。然后，将暂存的key放入nums[pos]。
二分查找的实现细节:
在排序的上下文中，我们需要实现的二分查找，其目标并非是“找到一个值”，而是“找到一个插入点”。即使 key 在有序子数组中不存在，二分查找也必须返回一个明确的索引，指示 key 应该被插入的位置。bisect 模块中的 bisect_left 或 bisect_right 函数完美地实现了这个功能。为了教学目的，我们将自己实现这个逻辑。
Python 实现与深度注释:
def binary_insertion_sort(nums):
"""
对列表进行二分插入排序。
通过二分查找来加速插入位置的确定。
参数:
nums (list): 待排序的列表。
"""
n = len(nums) # 获取列表长度
# 外层循环，与标准插入排序相同，从第二个元素开始处理
for i in range(1, n):
key = nums[i] # 挑选并暂存当前待插入的“候选人”
# --- 步骤2：在已排序子数组 nums[0...i-1] 中二分查找插入位置 ---
# 定义二分查找的边界
low = 0
high = i - 1
insert_pos = i # 默认插入位置为当前位置之后，如果 key 是最大的
# 标准的二分查找循环
while low <= high:
mid = (low + high) // 2 # 计算中间位置
if nums[mid] == key:
# 如果找到相等的元素，为了保持稳定性，我们选择在其右边插入
# 所以将查找范围缩小到右半部分，试图找到更右边的插入点
low = mid + 1
elif nums[mid] < key:
# 如果中间元素小于 key，说明 key 应该在右半部分
low = mid + 1
else: # nums[mid] > key
# 如果中间元素大于 key，说明 key 可能的插入点在 mid 或者其左边
# 我们记录下这个可能的位置，并继续在左半部分寻找更精确（更左）的位置
insert_pos = mid
high = mid - 1
# 循环结束后，insert_pos 就是 key 应该被插入的最终位置
# --- 步骤3：批量移位与插入 ---
# 将从 insert_pos 到 i-1 的所有元素整体向右移动一格。
# 这个操作比逐个移位在概念上更清晰，但在Python中，
# 无论是循环移位还是切片赋值，其底层仍然是逐个元素的移动。
# 我们这里用循环来清晰地展示这个过程。
j = i - 1
while j >= insert_pos:
nums[j + 1] = nums[j] # 元素向右移动
j -= 1
# 将暂存的 key 放入计算出的正确位置
nums[insert_pos] = key
# --- 使用 Python 的 bisect 模块简化实现 ---
import bisect
def binary_insertion_sort_with_bisect(nums):
"""
使用 Python 内置的 bisect 模块来实现二分插入排序，代码更简洁。
参数:
nums (list): 待排序的列表。
"""
n = len(nums)
for i in range(1, n):
key = nums[i]
# 使用 bisect_left 可以在 O(log i) 时间内找到 key 在 nums[0...i-1] 中的插入点。
# bisect_left 返回的索引能保证稳定性：
# 如果 key 已存在，它会返回最左边那个 key 的索引。
# 我们插入到这个位置，会将原来的元素向右推，保持了顺序。
# 为了插入到已排序部分的末尾，我们需要在子数组上操作。
# 但直接对整个 nums 操作更麻烦，因为 bisect 会看到未排序部分。
# 一个技巧是先弹出元素，再插入。
# 一个更直接的实现方式是仍然手动移位
insert_pos = bisect.bisect_left(nums, key, hi=i) # 在 nums[0...i-1] 范围内查找
# 移位操作
j = i - 1
while j >= insert_pos:
nums[j + 1] = nums[j]
j -= 1
nums[insert_pos] = key
# --- 示例代码 ---
# data_binary_insert = [37, 23, 0, 17, 12, 72, 31, 46, 100, 88, 54]
# print(f"原始数据: {data_binary_insert}")
# binary_insertion_sort(data_binary_insert.copy()) # 传入副本
# print(f"二分插入排序后: {data_binary_insert}") # 验证自定义实现
# data_bisect = [37, 23, 0, 17, 12, 72, 31, 46, 100, 88, 54]
# binary_insertion_sort_with_bisect(data_bisect) # 在原地修改
# print(f"使用 bisect 模块排序后: {data_bisect}")
深度分析与性能评估:
-
时间复杂度:
- 比较次数: 外层循环
n-1次。内层“寻找”阶段的比较次数由二分查找决定，第i轮的比较次数约为log(i)。总比较次数约为log(1) + log(2) + ... + log(n-1)。根据斯特林公式近似，log(n!)约等于n log n。所以，总的比较次数被显著优化到了 O(n log n)。 - 移动（交换）次数: 这是二分插入排序的阿喀琉斯之踵。尽管我们能快速“知道”元素应该去哪里，但我们仍然需要通过逐个移动元素来“把”它放过去。在最坏情况下（例如，逆序数组），第
i轮仍然需要O(i)次移动。总的移动次数仍然是1 + 2 + ... + (n-1)，即 O(n²)。 - 总体时间复杂度:
T(n) = O(n log n) (比较) + O(n²) (移动)。在复杂度分析中，高阶项会“淹没”低阶项。因此，二分插入排序的最终时间复杂度仍然是 O(n²)。
- 比较次数: 外层循环
-
二分插入排序的真实价值:
既然最终时间复杂度没有改变，那么这个优化有意义吗？有，在特定场景下意义重大。- 当“比较”成本远高于“移动”成本时：
- 想象一下，我们排序的不是简单的数字，而是需要通过复杂的计算或网络请求才能确定其大小关系的复杂对象。例如，比较两个字符串可能需要几十个CPU周期，而移动一个整数（或其引用）可能只需要几个周期。
- 在这种“比较昂贵”的模型下，将比较次数从
O(n²)降低到O(n log n)会带来巨大的实际性能提升，即使移动次数仍然是O(n²)。
- 教学与思想价值:
- 它清晰地展示了算法优化中的一个重要思想：解构与重组。我们将一个操作（找到并插入）分解为两个独立的子问题（寻找、移位），然后针对性地优化其中一个。
- 它也揭示了算法的瓶颈所在，让我们明白，仅仅优化一个部分，如果不能解决最核心的瓶颈（移动操作），是无法实现数量级上的性能突破的。
- 当“比较”成本远高于“移动”成本时：
-
稳定性:
- 二分插入排序可以是稳定的，但这取决于二分查找的具体实现。
- 如果我们使用的二分查找，在遇到与
key相等的元素时，总是选择在其右侧继续查找（或者像bisect_left那样返回最左边的插入点，然后我们执行移位），就能保证key不会越过在它之前、且与它值相等的元素。 - 我们的
binary_insertion_sort实现中low
最低0.47元/天 解锁文章
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
