LeetCode 912排序数组：算法选型与优化实践

1. 理解题目：排序数组的核心要求

LeetCode 912题"排序数组"是一个看似简单却暗藏玄机的基础算法题。题目要求给定一个整数数组nums，将其按升序排列后返回。表面上看这只是一个排序问题，但深入分析会发现它考察的是对不同排序算法特性的理解。

这道题的输入规模暗示了我们需要选择最优算法：数组长度最多可达5×10^4，这意味着O(n²)的简单排序算法（如冒泡排序）会超出时间限制。在实际测试中，使用Python内置的sorted()函数可以直接通过，但面试官显然期望我们展示对不同排序算法的掌握程度。

关键提示：虽然题目允许使用语言内置排序函数，但在面试场景下，面试官通常会要求手写实现，并分析时间/空间复杂度。

2. 排序算法选型与复杂度分析

2.1 合格解：快速排序的实现与优化

快速排序是这道题最自然的解法之一，平均时间复杂度为O(n log n)。基础版本的快排实现如下：

python复制def sortArray(nums):
    def quick_sort(arr, l, r):
        if l >= r: return
        pivot = arr[r]
        pos = l
        for i in range(l, r):
            if arr[i] < pivot:
                arr[pos], arr[i] = arr[i], arr[pos]
                pos += 1
        arr[pos], arr[r] = arr[r], arr[pos]
        quick_sort(arr, l, pos-1)
        quick_sort(arr, pos+1, r)
    
    quick_sort(nums, 0, len(nums)-1)
    return nums

但这个实现有两个潜在问题：

1. 最坏情况下（如数组已排序）时间复杂度退化为O(n²)
2. 递归深度可能导致栈溢出

优化方案：

• 随机选择pivot：pivot = arr[random.randint(l, r)]
• 使用三向切分处理大量重复元素
• 对小数组切换为插入排序

2.2 更优解：归并排序的稳定实现

归并排序在任何情况下都能保证O(n log n)的时间复杂度，且是稳定的排序算法。以下是典型实现：

python复制def sortArray(nums):
    def merge_sort(arr):
        if len(arr) <= 1:
            return arr
        mid = len(arr) // 2
        left = merge_sort(arr[:mid])
        right = merge_sort(arr[mid:])
        return merge(left, right)
    
    def merge(l, r):
        res = []
        i = j = 0
        while i < len(l) and j < len(r):
            if l[i] <= r[j]:
                res.append(l[i])
                i += 1
            else:
                res.append(r[j])
                j += 1
        res.extend(l[i:])
        res.extend(r[j:])
        return res
    
    return merge_sort(nums)

空间复杂度为O(n)，可以通过原地归并优化到O(1)，但实现会复杂很多。

2.3 特殊场景：计数排序的线性时间解法

当数组元素范围有限时（如题目提示-5×10^4 ≤ nums[i] ≤ 5×10^4），计数排序可以达到O(n)时间复杂度：

python复制def sortArray(nums):
    min_val, max_val = min(nums), max(nums)
    count = [0] * (max_val - min_val + 1)
    for num in nums:
        count[num - min_val] += 1
    
    res = []
    for i in range(len(count)):
        res.extend([i + min_val] * count[i])
    return res

3. 不同语言实现的注意事项

3.1 Python实现的陷阱

Python的递归深度限制（默认约1000）会影响递归实现的排序算法。对于大型数组，建议：

• 使用迭代版本的快速排序/归并排序
• 设置更高的递归限制：sys.setrecursionlimit(100000)

3.2 Java/C++的内存管理

在这些语言中实现时需注意：

• 避免不必要的数组拷贝
• 合理处理数组索引边界
• 对于Java，ArrayList的扩容会影响性能

4. 性能对比与实测数据

我在LeetCode测试平台上对不同方法进行了实测（数组长度5×10^4，随机数据）：

实测发现：虽然计数排序理论复杂度最优，但由于Python列表操作的额外开销，实际优势并不明显。工程中通常直接使用内置排序。

5. 面试中的扩展问题

面试官可能会基于此题提出以下变种问题：

1. 如何在不使用额外空间的情况下实现归并排序？
2. 如果内存有限，如何对超大型数组进行排序？
3. 如何设计一个多线程的排序算法？
4. 如何处理包含浮点数和非数字元素的数组？

6. 刷题策略建议

对于排序类题目，我的个人经验是：

1. 先掌握每种经典排序的手写实现
2. 理解它们的时间/空间复杂度及稳定性
3. 记住各算法的适用场景（如小数组用插入排序）
4. 对于特殊约束（如链表排序）要灵活应变

在LeetCode周赛中，排序常作为其他问题的预处理步骤。例如第430场周赛的第二题就需要先对数组排序才能应用双指针技巧。