归并排序巧解数组右侧小于当前元素统计问题

1. 问题背景与核心挑战

在算法面试和编程竞赛中，"计算右侧小于当前元素的个数"是一道经典的数组处理题目。题目要求我们为数组中的每个元素统计其右侧比它小的元素数量，最终返回一个统计结果数组。这道题看似简单，但直接使用暴力解法（双重循环）的时间复杂度高达O(n²)，在数据量较大时（比如n=10⁵）会严重超时。

举个例子，对于输入数组[5,2,6,1]，正确的输出应该是[2,1,1,0]。因为：

• 数字5右侧有2和1两个比它小的数
• 数字2右侧只有1比它小
• 数字6右侧有1比它小
• 数字1右侧没有元素

2. 解题思路与算法选择

2.1 暴力解法的局限性

最直观的解法是使用双重循环：

cpp复制vector<int> countSmaller(vector<int>& nums) {
    vector<int> res(nums.size(), 0);
    for(int i = 0; i < nums.size(); i++) {
        for(int j = i+1; j < nums.size(); j++) {
            if(nums[j] < nums[i]) res[i]++;
        }
    }
    return res;
}

这种解法虽然简单，但时间复杂度为O(n²)，当n=10⁵时需要执行约100亿次比较，显然无法接受。

2.2 归并排序的巧妙应用

我们可以利用归并排序的特性来优化这个统计过程。归并排序的时间复杂度为O(nlogn)，非常适合处理大规模数据。关键在于如何在排序过程中统计"右侧较小元素"的数量。

核心思路是：

1. 在归并排序的合并阶段，当左半部分的元素大于右半部分的元素时
2. 由于左右两部分都已经有序，可以立即知道右半部分有多少元素比当前左半部分元素小
3. 将这些数量累加到对应元素的统计结果中

2.3 下标追踪的关键技巧

由于归并排序会打乱元素的原始位置，我们需要一个额外的索引数组来跟踪每个元素的原始位置。这样在统计时才能将结果累加到正确的位置上。

3. 详细实现与代码解析

3.1 数据结构设计

我们需要准备以下数据结构：

• tmpNums：临时存储合并过程中的元素值
• tmpIndex：临时存储合并过程中元素的原始索引
• v：最终的结果数组，记录每个元素右侧比它小的数量
• index：记录每个元素的原始索引

cpp复制class Solution {
    int tmpNums[500005];  // 临时数组存储元素值
    int tmpIndex[500005]; // 临时数组存储原始索引
    vector<int> v;        // 结果数组
    vector<int> index;    // 原始索引数组
};

3.2 主函数实现

主函数负责初始化数据结构并启动归并排序：

cpp复制vector<int> countSmaller(vector<int>& nums) {
    int n = nums.size();
    v.resize(n, 0);      // 初始化结果数组为0
    index.resize(n);
    for(int i = 0; i < n; i++) {
        index[i] = i;    // 初始化索引数组
    }
    mergeSort(nums, 0, n-1);  // 开始归并排序
    return v;
}

3.3 归并排序实现

归并排序采用分治策略：

cpp复制void mergeSort(vector<int>& nums, int left, int right) {
    if(left >= right) return;  // 递归终止条件
    
    int mid = left + (right - left)/2;  // 计算中点
    mergeSort(nums, left, mid);         // 递归排序左半部分
    mergeSort(nums, mid+1, right);      // 递归排序右半部分
    
    // 合并两个有序区间
    merge(nums, left, mid, right);
}

3.4 合并过程的实现

合并过程是算法的核心，这里采用降序合并：

cpp复制void merge(vector<int>& nums, int left, int mid, int right) {
    int cur1 = left, cur2 = mid + 1, i = 0;
    
    while(cur1 <= mid && cur2 <= right) {
        if(nums[cur1] <= nums[cur2]) {
            tmpNums[i] = nums[cur2];
            tmpIndex[i++] = index[cur2++];
        } else {
            v[index[cur1]] += right - cur2 + 1;  // 关键统计步骤
            tmpNums[i] = nums[cur1];
            tmpIndex[i++] = index[cur1++];
        }
    }
    
    // 处理剩余元素
    while(cur1 <= mid) {
        tmpNums[i] = nums[cur1];
        tmpIndex[i++] = index[cur1++];
    }
    while(cur2 <= right) {
        tmpNums[i] = nums[cur2];
        tmpIndex[i++] = index[cur2++];
    }
    
    // 将临时数组拷贝回原数组
    for(int j = left; j <= right; j++) {
        nums[j] = tmpNums[j - left];
        index[j] = tmpIndex[j - left];
    }
}

4. 关键步骤解析

4.1 统计时机的选择

在合并过程中，当发现左半部分的当前元素nums[cur1]大于右半部分的当前元素nums[cur2]时：

1. 由于右半部分已经是有序的（降序）
2. nums[cur2]是右半部分剩余元素中最大的
3. 因此所有右半部分剩余元素（从cur2到right）都比nums[cur1]小
4. 可以直接将right - cur2 + 1累加到结果中

4.2 索引跟踪的重要性

由于归并排序会改变元素的原始位置，我们必须通过index数组来跟踪每个元素的原始位置。这样在统计时才能将结果累加到正确的位置上。

4.3 降序合并的优势

采用降序合并（而非升序）可以让我们在发现nums[cur1] > nums[cur2]时，立即知道右半部分剩余的所有元素都比nums[cur1]小，从而简化统计过程。

5. 复杂度分析与优化

5.1 时间复杂度

• 归并排序的时间复杂度为O(nlogn)
• 合并过程中的统计操作是O(1)的
• 因此整体时间复杂度为O(nlogn)

5.2 空间复杂度

• 需要额外的O(n)空间存储临时数组和索引数组
• 递归调用栈的深度为O(logn)
• 因此整体空间复杂度为O(n)

5.3 可能的优化方向

1. 使用迭代而非递归实现归并排序，减少栈空间使用
2. 对于小规模数据可以切换到插入排序等简单算法
3. 可以使用更紧凑的数据结构来存储索引信息

6. 常见问题与调试技巧

6.1 结果不正确的情况

如果发现统计结果不正确，可以检查：

1. 索引数组是否正确跟踪了元素的原始位置
2. 统计时是否正确地累加了right - cur2 + 1
3. 合并过程中是否正确地处理了剩余元素

6.2 边界条件处理

特别注意以下边界情况：

1. 空数组输入
2. 所有元素相同的情况
3. 已经有序（升序或降序）的数组

6.3 调试建议

可以在合并过程中打印中间结果：

cpp复制cout << "Merging [" << left << "," << mid << "] and [" << mid+1 << "," << right << "]" << endl;
cout << "Current v: ";
for(auto x : v) cout << x << " ";
cout << endl;

7. 扩展与应用

7.1 类似问题

这种基于归并排序的统计方法还可以解决：

1. 计算数组中的逆序对总数
2. 计算每个元素左侧比它大的元素个数
3. 计算区间和的排序问题

7.2 实际应用场景

1. 排名系统：计算每个用户的得分超过多少其他用户
2. 数据分析：统计每个数据点比后面多少数据点大/小
3. 推荐系统：基于用户行为的相似度计算

7.3 其他解法对比

除了归并排序，还可以使用：

1. 二叉搜索树：每个节点记录子树大小，时间复杂度也是O(nlogn)
2. 树状数组或线段树：适合动态统计问题
3. 块状链表：适合在线处理场景

在实际应用中，归并排序解法通常是最优选择，因为它既高效又相对容易实现。