从分治到递归：图解众数问题的两种解法与时间复杂度分析

从分治到递归：图解众数问题的两种解法与时间复杂度分析

在算法学习的道路上，我们常常会遇到一些看似简单、实则蕴含深刻思想的问题。众数问题就是其中之一——给定一个集合，找出出现次数最多的那个元素。这听起来像是一个只需要一次遍历和哈希表就能解决的“简单题”，但如果我们换个角度，将其视为一个探索分治与递归思想精髓的绝佳沙盒，就会发现一片全新的天地。这篇文章不是对经典教材的复述，而是想和你一起，像拆解一个精密的机械钟表那样，层层剖析两种基于分治递归的众数求解策略。我们将绕过那些枯燥的公式堆砌，用图解和实战代码，直观地感受算法是如何“思考”的，并最终理解其效率背后的数学逻辑。无论你是正在啃《算法导论》的学生，还是希望巩固基础、提升思维深度的开发者，相信这次探索都能给你带来不一样的启发。

1. 众数问题：不止于计数，更是分治思想的试金石

当我们谈论“众数”时，首先得跳出“统计频率”的直觉。是的，用一个哈希表（或者叫字典、映射）记录每个元素出现的次数，最后找出最大值，时间复杂度是 O(n)，空间复杂度也是 O(n)。这非常高效，也是工程实践中的首选。但这里我们按下这个“标准答案”不表，因为我们的目标不是寻找最快的解法，而是理解分治这一核心算法范式如何应用于此类问题。

分治法的精髓，简而言之就是“分而治之”：将一个大问题分解成若干个规模较小但结构相似的子问题，递归地解决这些子问题，然后再合并其结果，从而得到原问题的解。经典的例子如归并排序、快速排序。那么，一个寻找“出现次数最多元素”的问题，如何与“分解-解决-合并”扯上关系呢？

关键在于洞察问题的结构。在一个无序的数组中，众数似乎散落各处，难以直接分割。但如果我们先将其排序，相同的元素就会聚集在一起。此时，数组的“中位数”就成为一个非常有力的分割点。因为中位数本身就是一个出现频率的“候选者”，并且排序后，整个数组关于中位数呈现出一种天然的划分：左边都小于等于它，右边都大于等于它。这为我们递归地探索左右两半，同时利用中位数的信息进行剪枝，提供了可能。

另一种思路则更加“原教旨主义”：不进行预排序，直接在原始数组上模仿快速排序的 partition 操作，动态地选择一个基准数（pivot），并将数组划分为小于等于基准数和大于等于基准数的两部分。在这个过程中，我们同样可以统计基准数的出现次数。这个思路巧妙地将“寻找众数”和“划分数组”两个过程合二为一。

这两种方法，一种依赖预处理（排序），一种在递归过程中动态划分，它们最终都达到了 O(n log n) 的时间复杂度。但更重要的是，它们为我们提供了两个审视分治递归的绝佳视角。接下来，我们就用图解和代码，让这两种思路变得清晰可见。

2. 方法一：排序先行，中位数引领的递归探索

我们先来看第一种方法，它的逻辑非常清晰，也更容易用图形化方式理解。其核心步骤可以概括为：排序 -> 找中位数及其重数 -> 根据重数剪枝并递归探索左右子数组。

2.1 算法核心步骤拆解

假设我们有一个输入数组 [3, 2, 2, 1, 2, 5, 2]。

1. 全局排序：首先，我们调用 sort() 函数对数组进行排序。排序后，数组变为 [1, 2, 2, 2, 2, 3, 5]。这一步的目的是让相同的元素相邻，这是后续所有操作的基础。
2. 定位中位数与计算重数：对于一个排序后的数组，我们取其中间位置的元素作为“中位数”。在这个长度为7的数组中，索引为3（从0开始）的元素 2 就是中位数。接下来，我们需要找出这个中位数 2 在数组中出现的范围。
   • 向左扫描，找到第一个等于 2 的位置（索引1）。
   • 向右扫描，找到第一个不等于 2 的位置（索引5）。
   • 这样，我们就得到了中位数 2 的“势力范围”是索引区间 [1, 5)，其重数 cnt = 5 - 1 = 4。
3. 更新全局众数：我们将当前中位数的重数 4 与已知的最大重数 maxCnt（初始为0）比较。因为 4 > 0，所以我们更新众数为 2，maxCnt 更新为 4。
4. 递归剪枝与探索：这是算法最精妙的部分。我们不是盲目地递归处理左右两半，而是进行智能剪枝。
   • 左半部分：中位数左边的子数组是 [1]，长度为 1。当前 maxCnt = 4。如果左半部分的长度（1）小于等于 maxCnt（4），那么即使左半部分全部是同一个数，其重数也不可能超过4，因此没有必要对左半部分进行递归。本例中，左半部分长度1 < 4，故跳过。
   • 右半部分：中位数右边的子数组是 [3, 5]，长度为 2。同理，长度2 < 4，也跳过递归。

由于左右两部分都不满足递归条件，算法结束。我们找到了众数 2，重数为 4。

提示：剪枝条件是本算法效率的关键。它基于一个简单却强大的事实：如果一个子数组的长度小于当前已知的最大重数，那么这个子数组里绝对不可能存在重数更大的众数。

2.2 代码实现与图解

让我们用一段简化的 C++ 代码来展示核心的递归函数，并辅以注释说明。

// 在已排序数组 a 的区间 [0, n) 内寻找众数
// num: 返回众数在原始数组中的索引（相对于当前递归区间起点）
// maxcnt: 返回全局最大重数（传引用以便更新）
// a: 已排序的数组
// n: 当前递归区间长度
void findModeSorted(int &num, int &maxcnt, int a[], int n) {
    if (n <= 0) return; // 递归基：空区间

    int mid_index = n / 2; // 中位数索引
    int mid_value = a[mid_index]; // 中位数值

    // 步骤1: 找到中位数出现的左右边界 [l, r)
    int l = mid_index, r = mid_index + 1;
    while (l > 0 && a[l - 1] == mid_value) l--;
    while (r < n && a[r] == mid_value) r++;

    int current_cnt = r - l; // 当前中位数的重数

    // 步骤2: 更新全局最优解
    if (current_cnt > maxcnt) {
        maxcnt = current_cnt;
        // 注意：num 需要记录全局索引，这里假设a是全局数组指针
        // 更严谨的实现需要传递偏移量 offset
        num = l; // 简化处理，记录左边界作为众数位置
    }

    // 步骤3: 递归剪枝判断
    // 左半部分：区间 [0, l)，长度为 l
    if (l > maxcnt) {
        findModeSorted(num, maxcnt, a, l);
    }
    // 右半部分：区间 [r, n)，长度为 n - r
    if (n - r > maxcnt) {
        findModeSorted(num, maxcnt, a + r, n - r); // a+r 是右半部分的起始地址
    }
}

为了更直观，我们可以用下面这个表格来模拟一次递归调用过程（针对数组 [1, 2, 2, 2, 2, 3, 5]）：

从表格可以清晰看到，算法在第一次递归调用中就完成了任务，并且因为有效的剪枝，避免了对不可能产生更优解的子区间进行探索。

3. 方法二：不排序的快速选择式分治

第二种方法更有挑战性，也更能体现分治思想的灵活性。它不预先排序，而是在递归过程中，像快速排序的 partition 一样，动态地选择一个基准数（pivot）来划分数组，并同时统计该基准数的频率。

3.1 算法思路与“一趟扫描”的智慧

这个方法的核心是一个经过改造的 partition 函数。在经典的快速排序 partition 中，目标是围绕一个基准数，将数组划分为“小于基准数”和“大于基准数”的两部分。在这里，我们需要将其调整为“小于等于基准数”和“大于等于基准数”，并且在划分的过程中，就数清楚基准数到底出现了多少次。

我们来 walk through 一个例子：数组 [3, 2, 2, 1, 2, 5, 2]，选择第一个元素 3 作为基准数。

1. 初始化：设置两个指针 i（类似快排的 low）和 j（类似快排的 high），分别指向区间首尾。cnt = 1（基准数自身）。
2. 从右向左扫描：移动 j 指针，寻找第一个 小于 基准数 3 的元素。遇到 2（小于3），停止。在移动过程中，如果遇到等于 3 的元素，cnt 加1。本次扫描未遇到等于3的。
3. 交换：交换 a[i] (3) 和 a[j] (2)。数组变为 [2, 2, 2, 1, 3, 5, 2]。此时 i=0 位置是 2。
4. 从左向右扫描：移动 i 指针，寻找第一个 大于 基准数 3 的元素。在移动过程中，如果遇到等于 3 的元素，cnt 加1。i 移动到值 5（索引4）时停止，因为 5 > 3。在移动过程中，i 经过了多个 2，但它们都不等于 3，所以 cnt 不变。
5. 交换：交换 a[i] (5) 和 a[j] (3)。数组变为 [2, 2, 2, 1, 2, 3, 5]。此时 j=4 位置是 3。
6. 重复：此时 i (4) 仍然小于 j (4) 吗？不，i 和 j 相遇于索引4。循环结束。
7. 结果：我们完成了一趟划分。最终，基准数 3 被放置在了索引4的位置。数组被划分为：
   • 左半区 [0, 4)：[2, 2, 2, 1, 2]，所有元素 小于等于 3。
   • 基准数位置：索引4，值为3。
   • 右半区 [5, 7)：[3, 5]，所有元素 大于等于 3（注意，这里右半区包含了一个等于3的元素，这是与经典快排不同的地方，也是为了保证不遗漏）。
   • 我们统计到基准数 3 的 cnt = 2（初始1个 + 步骤4中找到的1个）。

这个过程不仅完成了划分，还得到了基准数 3 的重数 2。

3.2 代码实现的关键细节

下面是这个定制化 partition 函数和递归主函数的一个实现示例：

// 在数组 a 的区间 [low, high] 内进行划分，并返回基准数的最终位置及其重数
int partitionAndCount(int a[], int low, int high, int &count) {
    int pivot = a[low]; // 选择区间第一个元素作为基准
    count = 1; // 基准数自身出现一次
    int i = low, j = high;

    while (i < j) {
        // 从右向左找第一个小于 pivot 的元素
        while (i < j && a[j] >= pivot) {
            if (a[j] == pivot) count++; // 遇到相等的，计数
            j--;
        }
        if (i < j) a[i++] = a[j]; // 将其移到左边

        // 从左向右找第一个大于 pivot 的元素
        while (i < j && a[i] <= pivot) {
            if (a[i] == pivot) count++; // 遇到相等的，计数
            i++;
        }
        if (i < j) a[j--] = a[i]; // 将其移到右边
    }
    a[i] = pivot; // 基准数归位
    return i; // 返回基准数位置
}

// 在无序数组 a 的区间 [low, high] 内寻找众数
// 假设全局变量 global_num 和 global_maxcnt 用于记录结果
void findModeUnsorted(int a[], int low, int high) {
    if (low > high) return;

    int cnt;
    int pivot_pos = partitionAndCount(a, low, high, cnt);

    // 更新全局众数
    if (cnt > global_maxcnt) {
        global_maxcnt = cnt;
        global_num = a[pivot_pos]; // 记录众数值
    }

    // 递归剪枝：只有子区间长度可能包含更优解时才递归
    int left_len = pivot_pos - low;
    int right_len = high - pivot_pos;

    if (left_len > global_maxcnt) {
        findModeUnsorted(a, low, pivot_pos - 1);
    }
    if (right_len > global_maxcnt) {
        findModeUnsorted(a, pivot_pos + 1, high);
    }
}

这个实现有几个需要注意的细节：

• partitionAndCount 函数在移动指针时，对等于基准数的元素也进行了计数，并且这些元素可能被交换到任意一边（取决于扫描顺序），但这不影响最终基准数的重数统计。
• 递归剪枝的逻辑和第一种方法一致：如果子区间的长度小于等于当前已知的最大重数，就没有必要继续探索。
• 数组在递归过程中被部分地重新排列了，但这并不是为了排序，而是划分的副产品。算法结束时，数组并非完全有序。

4. 时间复杂度分析：为什么都是 O(n log n)？

两种方法最终都达到了 O(n log n) 的时间复杂度。我们来深入分析一下，这个结论是如何得出的，以及两种方法在常数因子和实际表现上可能有何差异。

4.1 方法一（先排序）的时间复杂度拆解

我们可以将算法分为几个阶段：

1. 排序阶段：使用标准的比较排序算法（如 std::sort，通常是内省排序，混合了快速排序、堆排序和插入排序），其平均和时间复杂度为 O(n log n)。这是主要的时间开销。
2. 递归查找阶段：这是分治的主体。在最好情况下，每次递归都能将问题规模减半（类似于快速排序的理想情况）。我们可以建立递归式：
   • T(n) = 2T(n/2) + O(n)
   • 其中 O(n) 是在每次递归调用中，为了找到中位数的左右边界而进行的线性扫描。
   • 根据主定理（Master Theorem），这个递归式的解是 O(n log n)。

因此，总时间复杂度为 O(n log n) + O(n log n) = O(n log n)。排序阶段和递归查找阶段是串行的，所以取高阶项。

注意：这里的“最好情况”假设众数分布均匀，每次都能大致平分数组。在最坏情况下，例如数组所有元素都相同，递归查找阶段的 partition（找边界）每次都需要扫描整个当前区间，递归树退化成链状，时间复杂度会变成 O(n²)。但结合先排序的步骤，这种情况不会发生，因为排序后找边界是确定性的 O(n)。递归查找阶段的最坏情况发生在众数非常极端，导致剪枝失效，但即便如此，由于每次都要扫描，递归式变为 T(n) = T(n-1) + O(n)，其解是 O(n²)。然而，在排序后的数组中，结合中位数分割，这种极端情况很难出现，平均性能依然是 O(n log n)。

4.2 方法二（不排序）的时间复杂度分析

方法二的递归过程与快速排序高度相似。

1. 递归查找与划分阶段：每次递归调用 partitionAndCount 需要遍历当前区间一次，时间复杂度为 O(当前区间长度)。递归的深度和划分的平衡性有关。

   • 最好/平均情况：如果每次选择的基准数都能将区间大致平衡地划分，递归式为 T(n) = 2T(n/2) + O(n)，解为 O(n log n)。
   • 最坏情况：如果每次选择的基准数都是当前区间的最小值或最大值（例如数组已排序且我们总是选第一个元素），那么每次划分只能将规模减少1，递归式变为 T(n) = T(n-1) + O(n)，解为 O(n²)。这与快速排序的最坏情况一致。

2. 与剪枝的关系：剪枝操作 (if (left_len > global_maxcnt)) 并不能改变时间复杂度的大 O 表示法，因为它不影响每次 partition 的 O(n) 操作，只是在某些情况下避免了递归调用。但在实际运行中，有效的剪枝能大幅减少递归调用次数，提升算法效率，尤其是在众数重数很大的情况下。

4.3 两种方法的对比与选择

为了更清晰地展示两种方法的异同，我们将其核心特点总结如下：

在实际应用中，方法一通常是更优的选择。原因在于：

• 现代编程语言的标准库排序函数（如 C++ 的 std::sort）高度优化，其 O(n log n) 的常数因子非常小。
• 方法一的最坏情况时间复杂度有保证，而方法二虽然平均性能也是 O(n log n)，但存在退化到 O(n²) 的风险，除非引入随机化选择基准数等优化。
• 方法一的逻辑更直观，代码更易于维护和调试。

然而，方法二的价值在于其教学意义。它完美展示了如何将一个非比较问题（找频率）通过巧妙的划分，转化为一个可以应用分治策略的问题。它是对“分治”思想更纯粹、更灵活的一种运用。

5. 从理论到实践：编码细节与边界处理

理解了算法思想和分析后，我们来看看在真正编码实现时，有哪些容易踩坑的细节。这些细节往往决定了你的程序是“正确运行”还是“在各种 corner case 下崩溃”。

5.1 递归基与边界条件

这是递归算法的生命线。处理不好，就是无限递归或访问非法内存。

• 对于方法一（排序后）：

  void findModeSorted(int a[], int n, int &mode, int &maxCnt, int offset) {
      if (n <= 0) return; // 关键！空区间直接返回
      // ... 其余逻辑 ...
      // 递归调用时，子区间长度计算必须准确
      findModeSorted(a, l, mode, maxCnt, offset); // 左区间 [0, l)
      findModeSorted(a + r, n - r, mode, maxCnt, offset + r); // 右区间 [r, n)，注意偏移量
  }
  

  确保 l 和 n - r 作为新的 n 参数传递时是非负的。offset 参数用于在递归中跟踪当前区间在原始数组中的起始位置，以便正确更新众数的索引。

• 对于方法二（不排序）：

  void findModeUnsorted(int a[], int low, int high) {
      if (low >= high) { // 递归基：区间内元素少于等于1个
          if (low == high) {
              // 可以处理单个元素的情况，例如更新计数
              // 但主要逻辑在 partition 里，这里通常只是返回
          }
          return;
      }
      // ... partition 和递归 ...
  }
  

  确保 low 和 high 的初始调用是正确的（例如 0 和 n-1），并且在递归调用时，pivot_pos - 1 和 pivot_pos + 1 不会导致 low > high。

5.2 全局状态与局部递归

我们的算法需要维护两个全局信息：当前找到的众数 mode 和其重数 maxCnt。在递归函数中，它们通常以引用的方式传递。

• 初始化：maxCnt 应初始化为 0（或 INT_MIN），mode 初始化为一个无效值。
• 线程安全：这种使用引用传递全局状态的方式不是线程安全的。如果要在并发环境中使用，需要考虑其他设计，例如将结果封装在结构体中并返回。

5.3 测试用例的设计

一个健壮的算法需要经过多种类型输入的测试：

1. 常规用例：[1, 2, 2, 3, 4]，众数是2。
2. 多个众数：[1, 1, 2, 2, 3]。算法通常返回最先找到的重数最大的那个（例如方法一可能返回1，方法二取决于 partition）。需要明确需求：是返回任意一个，还是返回所有？
3. 所有元素相同：[5, 5, 5, 5]。这是检验边界和剪枝的好例子。
4. 递增/递减序列：[1, 2, 3, 4, 5]。每个元素都是众数（重数为1）。方法二如果总是选择第一个元素作为基准，可能会面临最坏情况。
5. 空数组或单元素数组：必须正确处理。
6. 大数测试：用于检验递归深度是否可能导致栈溢出。对于方法二的最坏情况 O(n²)，大数据量可能会超时。

我在自己实现这两个算法时，就曾因为忘记处理 n <= 0 的递归基，导致在某个特定输入下发生了段错误。调试递归程序，画递归树和仔细跟踪每个递归调用的参数是非常有效的方法。另外，对于方法二，可以尝试随机选择基准数来避免最坏情况，这只需要在 partitionAndCount 开始时，随机交换 a[low] 和 a[random(low, high)] 即可，虽然不能绝对避免最坏情况，但可以将其概率降到极低。