分治法实战:用Python手把手教你找出数组中的众数
最近在刷算法题,或者处理一些数据分析任务时,经常会遇到一个经典问题:如何高效地找到一个数组中出现次数最多的元素,也就是所谓的“众数”?你可能第一时间会想到用哈希表(字典)来统计频率,这确实是最直观、最常用的方法,时间复杂度是O(n)。但今天,我想带你换个思路,用一种更“优雅”的算法思想来解决这个问题——分治法。
分治法听起来可能有点“学院派”,感觉是算法课上的理论,离实际开发有点远。但事实上,理解分治思想,不仅能帮你解决众数问题,更能让你在面对复杂问题时,拥有一种“化繁为简”的思维武器。对于初学者而言,从排序遍历到哈希表,再到分治法,一步步深入,是理解算法设计精髓的绝佳路径。而对于有一定经验的开发者,重温分治策略,或许能让你在优化某些特定场景(比如数据流、分布式计算)下的统计问题时,找到新的灵感。
这篇文章,我将抛开那些晦涩的伪代码和C语言实现,完全用Python来手把手拆解如何用分治法寻找众数。我们会从最基础的概念讲起,一步步推导出递归函数,处理各种边界情况,并用丰富的测试案例来验证我们的代码。你会发现,用Python实现分治算法,代码可以非常简洁和清晰。
1. 问题重述与基础概念:什么是众数与分治?
在开始写代码之前,我们必须把问题定义清楚。给定一个包含 n 个元素的多重集合(可以理解为允许重复元素的数组)S,我们的目标是找到其中的众数及其重数。
- 众数:在集合
S中出现次数最多的那个元素。 - 重数:众数出现的次数。
这里有几个关键点需要注意:
- 可能存在多个众数。例如,数组
[1, 1, 2, 2, 3]中,1和2都出现了两次,那么它们都是众数,重数都是2。 - 可能没有众数。当所有元素出现次数都相同时(如
[1, 2, 3, 4]),按照严格定义,可以说没有众数,或者说每个元素都是众数(但重数只有1)。在实际应用中,我们通常约定返回其中一个元素及其计数,或者指明无众数。本文将实现返回其中一个出现次数最多的元素及其计数,如果存在多个,则返回最先被算法确认的那个。
那么,分治法又是什么呢?它的核心思想可以概括为“分而治之”:
- 分:将原问题分解成若干个规模较小的子问题,这些子问题与原问题形式相同,只是规模更小。
- 治:递归地求解这些子问题。如果子问题的规模已经足够小,就直接求解。
- 合:将子问题的解合并起来,得到原问题的解。
对于寻找众数这个问题,一个朴素的分治思路是:把数组分成左右两半,分别找出左半部分的众数、右半部分的众数,以及跨越中点的“候选众数”,然后在这三者中选出重数最大的那个。这个“跨越中点”的候选者,通常需要扫描整个区间来统计某个特定值的出现次数。
2. 算法核心思路与递归设计
我们直接切入最核心的部分:如何为寻找众数设计一个分治递归函数。
假设我们有一个函数 find_mode(arr, left, right),它的目标是找到数组 arr 在索引 [left, right] 这个闭区间内的众数及其重数。函数将返回一个元组 (mode, count)。
递归的基石:终止条件 这是任何递归函数的第一步。什么时候问题简单到不需要再“分”了?
- 当区间内只有一个元素时(
left == right),这个元素自己就是众数,重数为1。 - 当区间为空时(
left > right),这是一个无效情况,在我们的设计中通常不会遇到,但为了健壮性,可以返回一个表示无效的值(如(None, 0))。不过,更常见的做法是,我们的递归划分保证不会产生空区间。
分治的步骤:分解与合并
- 分解:找到区间的中点
mid = (left + right) // 2。这样,我们就把原问题[left, right]分解为两个子问题:- 左子问题:
[left, mid] - 右子问题:
[mid + 1, right]
- 左子问题:
- 递归求解:分别调用
find_mode(arr, left, mid)和find_mode(arr, mid+1, right),得到左半部分的众数left_mode及其重数left_count,以及右半部分的right_mode和right_count。 - 处理“跨越”候选者:别忘了,真正的众数可能横跨左右两个子区间。例如,数组
[1, 2, 2, 3, 3, 3],中点是2(索引2),左子区间众数可能是2(重数2),右子区间众数可能是3(重数2),但整个区间的众数是3(重数3)。这个3的分布跨越了中点。因此,我们必须统计中点元素arr[mid]在整个当前区间[left, right]内出现的次数,作为第三个候选者mid_candidate和mid_count。 - 合并:比较
left_count,right_count,mid_count。返回重数最大的那个(mode, count)。如果出现重数相同的情况,我们可以定义一个规则,比如优先返回左子区间的结果,或者优先返回mid_candidate。在下面的实现中,我们会采用一种清晰的比较逻辑。
这个思路清晰,但有一个明显的效率问题:在第3步,为了统计 arr[mid] 在整个区间的出现次数,我们可能需要线性扫描整个区间,这会使每次合并操作的时间复杂度为 O(n)。如果递归树深度为 O(log n),那么总的时间复杂度将是 O(n log n)。这和我们先排序再线性扫描的经典方法时间复杂度相同。那么分治法的优势在哪里?
- 理论价值:它展示了如何将分治思想应用于非排序类问题。
- 潜在优势:在某些特定场景或并行计算框架下,分治策略更容易被并行化。左子问题和右子问题的求解可以同时进行。
- 思维训练:这是理解递归和分治合并步骤的经典案例。
为了更直观地对比不同候选者的产生方式,我们用一个表格来梳理:
| 候选者来源 | 如何获得 | 关键操作 | 时间复杂度 (单次合并) |
|---|---|---|---|
| 左子区间众数 | 递归调用 find_mode(left, mid) | 递归分解 | 依赖于子问题规模 |
| 右子区间众数 | 递归调用 find_mode(mid+1, right) | 递归分解 | 依赖于子问题规模 |
| 中点候选者 | 统计 arr[mid] 在 [left, right] 的出现次数 | 线性扫描 | O(n) |
提示:在实现统计
arr[mid]出现次数的函数时,由于数组未排序,我们必须遍历整个区间。一个小的优化是,因为我们已经知道中点索引mid,可以从mid开始向左右两边扩展计数,但最坏情况(该元素遍布整个区间)仍需 O(n)。
3. Python代码实现与逐行解析
理论说得再多,不如一行代码。我们现在就来实现这个分治法的众数查找。我会先给出完整的、可运行的函数,然后对关键部分进行详细解析。
def count_in_range(arr, target, left, right):
"""
辅助函数:统计目标值 target 在数组 arr 的 [left, right] 区间内出现的次数。
"""
count = 0
for i in range(left, right + 1):
if arr[i] == target:
count += 1
return count
def find_mode_divide_conquer(arr, left, right):
"""
分治法寻找众数的主递归函数。
返回一个元组 (众数, 重数)。
"""
# 终止条件1:区间只有一个元素
if left == right:
return arr[left], 1
# 分解:计算中点
mid = (left + right) // 2
# 治:递归求解左右子问题
left_mode, left_count = find_mode_divide_conquer(arr, left, mid)
right_mode, right_count = find_mode_divide_conquer(arr, mid + 1, right)
# 合:处理中点候选者
mid_candidate = arr[mid]
mid_count = count_in_range(arr, mid_candidate, left, right)
# 合并策略:选择重数最大的候选者
# 先假设左子区间的结果是最终的
best_mode, best_count = left_mode, left_count
# 如果右子区间的重数更大,则更新为右子区间的结果
if right_count > best_count:
best_mode, best_count = right_mode, right_count
# 如果中点候选者的重数更大,则更新为中点候选者
if mid_count > best_count:
best_mode, best_count = mid_candidate, mid_count
return best_mode, best_count
def find_mode(arr):
"""
对外的接口函数,处理空数组等边界情况,并调用递归函数。
"""
if not arr: # 处理空数组
return None, 0
return find_mode_divide_conquer(arr, 0, len(arr) - 1)
# 测试函数
def test_find_mode():
test_cases = [
([1, 2, 2, 3, 4], (2, 2)), # 简单情况,众数是2
([1, 1, 2, 2, 3], (1, 2)), # 多个众数,返回第一个遇到的(左子区间优先)
([5], (5, 1)), # 单个元素
([], (None, 0)), # 空数组
([1, 2, 3, 4, 5], (1, 1)), # 所有元素出现一次,返回第一个
([2, 2, 2, 1, 5, 3, 5, 7, 5, 5, 5], (5, 5)), # 复杂情况,众数是5
([3, 3, 3, 2, 2, 2], (3, 3)), # 左右众数不同,需要比较中点候选者
]
print("测试分治法求众数:")
for i, (input_arr, expected) in enumerate(test_cases):
result = find_mode(input_arr)
status = "通过" if result == expected else "失败"
print(f"测试用例 {i+1}: {input_arr} -> 期望 {expected}, 得到 {result} [{status}]")
if __name__ == "__main__":
test_find_mode()
代码关键点解析:
-
辅助函数
count_in_range:这个函数是算法效率的关键瓶颈之一。它执行了一次线性扫描。在实际应用中,如果数组是已排序的,我们可以用二分查找找到target的左右边界,将统计次数的时间复杂度降到 O(log n),从而让整个分治算法在有序数组上的复杂度优于 O(n log n)。但作为通用算法,我们假设输入是未排序的。 -
递归终止条件
if left == right::这是递归的“叶子节点”。当区间缩小到只有一个元素时,它自己就是众数,重数为1。这是递归能够正确返回的基础。 -
递归调用
find_mode_divide_conquer(arr, left, mid)和find_mode_divide_conquer(arr, mid+1, right):这里体现了“分”的思想。函数不断地自我调用,将大问题分解成小问题。理解递归的关键是信任:我们相信这个函数能正确解决子问题。 -
合并策略:这是“治”和“合”的体现。我们得到了三个候选答案:
(left_mode, left_count)(right_mode, right_count)(mid_candidate, mid_count)合并的逻辑非常简单:用一个“打擂台”的方式,比较它们的count,保留重数最大的那个。这里的比较顺序(先左、再右、最后中)决定了当重数相同时返回哪个众数。你可以根据需要调整这个优先级。
-
对外接口
find_mode(arr):这是一个包装函数,提供了更干净的接口。它首先处理了空数组的边界情况,然后调用递归函数从整个数组范围[0, len(arr)-1]开始计算。
运行上面的测试代码,你会看到所有测试用例都应该通过。这验证了我们算法实现的正确性。
4. 复杂度分析、对比与优化思考
现在,我们来理性地分析一下这个分治算法的性能,并与其他方法进行对比。
时间复杂度分析
设数组长度为 n。
-
递归的深度:每次都将区间大致分为两半,所以递归树的高度是 O(log n)。
-
每层递归的工作量:关键在于合并步骤中的
count_in_range函数,它需要线性扫描当前区间。但是请注意,在递归树的每一层,所有节点处理的子区间加起来,正好覆盖了整个原始数组,且没有重叠(在合并步骤的统计中,count_in_range是针对每个递归调用自己的区间进行的扫描,这些区间在递归树的同一层是互不相交的)。然而,更精确的分析是,每个递归调用都会执行一次count_in_range,而该函数的时间复杂度与当前处理的区间长度成正比。 我们可以通过递归式来近似分析:T(n) = 2T(n/2) + O(n)。根据主定理(Master Theorem),这个递归式的解是 O(n log n)。这与快速排序、归并排序等经典分治算法的时间复杂度相同。
空间复杂度分析
- 递归调用需要栈空间。递归深度为 O(log n),因此空间复杂度是 O(log n)。这比需要额外 O(n) 空间的哈希表法(在最坏情况下)要节省。
与其他方法的对比
| 方法 | 时间复杂度 | 空间复杂度 | 优点 | 缺点 |
|---|---|---|---|---|
| 哈希表法 | O(n) | O(n) | 时间复杂度最优,实现简单直观,适用于绝大多数场景。 | 需要额外的哈希表空间,在数据量极大时可能受内存限制。 |
| 排序遍历法 | O(n log n) | O(1) 或 O(n) | 空间效率高(如果可原地排序),逻辑简单。 | 时间复杂度较高,且修改了原数组(如果非原地排序则需要空间)。 |
| 分治法 | O(n log n) | O(log n) | 空间复杂度优于哈希表,是展示分治思想的经典案例,易于并行化。 | 时间复杂度不如哈希表,实现相对复杂,常数因子可能较大。 |
| Boyer-Moore 投票算法 | O(n) | O(1) | 时间和空间都是最优,适用于存在绝对众数(出现次数 > n/2)的场景。 | 仅适用于存在绝对众数的情况,是特化算法。 |
注意:Boyer-Moore 投票算法是一个特例,它能在 O(n) 时间和 O(1) 空间内找到绝对众数(出现次数超过一半的元素)。但它不适用于寻找普通的众数(可能不止一个,或者出现次数不超过一半)。我们的分治法和哈希表法则适用于通用情况。
优化思考
我们的基础实现中,count_in_range 是性能瓶颈。如果输入数组是已排序的,我们可以进行大幅优化:
def count_in_range_sorted(arr, target, left, right):
"""
优化版:针对已排序数组,使用二分查找找到左右边界,从而 O(log n) 时间内统计次数。
假设 arr 在 [left, right] 区间内是升序排列的。
"""
# 找到第一个等于 target 的位置
def find_first(target):
l, r = left, right
first = right + 1
while l <= r:
m = (l + r) // 2
if arr[m] >= target:
if arr[m] == target:
first = m
r = m - 1
else:
l = m + 1
return first
# 找到最后一个等于 target 的位置
def find_last(target):
l, r = left, right
last = left - 1
while l <= r:
m = (l + r) // 2
if arr[m] <= target:
if arr[m] == target:
last = m
l = m + 1
else:
r = m - 1
return last
first_pos = find_first(target)
last_pos = find_last(target)
if first_pos <= last_pos:
return last_pos - first_pos + 1
else:
return 0
如果我们在调用主函数前先对数组排序(代价是 O(n log n)),然后在递归中使用 count_in_range_sorted,那么每次合并操作的成本就从 O(n) 降到了 O(log n)。此时递归式变为 T(n) = 2T(n/2) + O(log n),根据主定理,整体时间复杂度仍然是 O(n)?这里需要仔细分析:排序花费 O(n log n),之后的分治过程花费 O(n)(因为每个元素在递归树中只被处理常数次,且每次合并的二分查找是 O(log n),但递归树有 O(n) 个节点?)。实际上,经过排序后,整个分治过程可以更高效,但排序本身已经是 O(n log n) 了,所以总复杂度不会低于 O(n log n)。然而,如果数组本来已排序,那么这个优化版的分治算法可以达到接近 O(n) 的性能,这在实际应用中很有价值。
5. 实战演练与边界案例深度剖析
理论分析和代码实现之后,我们需要用更复杂的例子来检验算法的健壮性,并深入理解其运行过程。让我们跟踪一个具体例子的执行流程。
案例:arr = [2, 2, 1, 3, 2, 3, 3, 3]
首先,为了清晰,我们给数组加上索引:[2(0), 2(1), 1(2), 3(3), 2(4), 3(5), 3(6), 3(7)]。长度 n=8。
调用 find_mode(arr, 0, 7)。
-
第一层递归:
left=0, right=7, mid=3。中点元素是arr[3]=3。- 递归左半部分
[0, 3]。 - 递归右半部分
[4, 7]。 - 统计中点候选者
3在整个区间[0,7]的出现次数。遍历数组,发现3出现在索引 3,5,6,7,共4次。所以mid_candidate=3, mid_count=4。
- 递归左半部分
-
深入左半部分
[0,3]:left=0, right=3, mid=1。中点元素arr[1]=2。- 递归左左
[0,1]。 - 递归左右
[2,3]。 - 统计
2在[0,3]的出现次数:索引0,1,4(注意,4不在当前区间[0,3]内!错误!)。这里是一个关键点:count_in_range只统计当前递归区间[left, right]内的次数。所以在[0,3]区间内,2出现在索引0和1,共2次。所以mid_candidate=2, mid_count=2。
- 递归左左
-
处理左左部分
[0,1]:left=0, right=1, mid=0。- 递归
[0,0]:返回(2, 1)。 - 递归
[1,1]:返回(2, 1)。 - 统计中点
arr[0]=2在[0,1]的出现次数:2次。 - 合并:比较
(2,1),(2,1),(2,2)。胜出者是(2,2)。所以[0,1]区间返回(2,2)。
- 递归
-
处理左右部分
[2,3]:left=2, right=3, mid=2。- 递归
[2,2]:返回(1,1)。 - 递归
[3,3]:返回(3,1)。 - 统计中点
arr[2]=1在[2,3]的出现次数:1次。 - 合并:比较
(1,1),(3,1),(1,1)。重数相同,根据我们的合并逻辑(先左后右最后中),返回左子区间的结果(1,1)。所以[2,3]区间返回(1,1)。
- 递归
-
回到左半部分
[0,3]的合并:现在我们有:- 左子结果(来自
[0,1]):(2, 2) - 右子结果(来自
[2,3]):(1, 1) - 中点候选者:
(2, 2)(统计自区间[0,3]) - 合并比较:
(2,2),(1,1),(2,2)。返回(2,2)。所以左半部分最终认为众数是2,重数为2。
- 左子结果(来自
-
同理分析右半部分
[4,7](过程略),最终会返回(3, 3)(因为3在[4,7]区间出现了3次)。 -
回到最顶层
[0,7]的合并:现在我们有:- 左子结果:
(2, 2) - 右子结果:
(3, 3) - 中点候选者:
(3, 4)(我们第一步统计的) - 合并比较:
(2,2),(3,3),(3,4)。重数最大的是(3,4)。 - 最终结果:返回
(3, 4)。正确!
- 左子结果:
通过这个跟踪过程,你可以清晰地看到:
- 递归如何将大问题分解。
count_in_range如何确保统计的准确性(只在当前递归区间内统计)。- 合并步骤如何从子解和中点候选者中选出全局最优解。
边界与特殊情况处理
我们的代码已经处理了空数组和单元素数组。还需要考虑:
- 所有元素频率相同:如
[1,2,3,4]。算法会返回第一个元素1及其计数1。这符合我们“返回其中一个”的约定。如果你需要特别指出“无众数”,可以在最终结果判断best_count == 1且数组长度大于1时进行处理。 - 多个众数且重数相同:如
[1,1,2,2]。根据我们的合并优先级(左子区间优先),会返回1。如果你需要返回所有众数,则需要修改返回结构(例如返回一个列表)和合并逻辑。
最后,我想说的是,分治法求众数更像是一次精彩的思维体操,它可能不是解决这个问题最高效的通用工具(哈希表通常是),但它深刻地揭示了递归、分治和合并策略的威力。当你下次遇到更复杂的问题,比如寻找“主元素”(出现超过一半)、统计流数据中的高频项,或者需要在分布式环境下进行统计时,这次手把手的实践所锻炼出来的分治思维,或许就能派上大用场。编程的魅力,往往就在于这种从多个角度审视和解决同一个问题的过程中。
1025



被折叠的 条评论
为什么被折叠?



