我用 Python 写了个排序库，一亿数据量下比 C 级 np.sort() 快 7 倍

> `pip install beyond-sort`，一行代码，自动选最优排序策略。

先看结果

一亿（100,000,000）个整数排序，32 核 CPU：

| 场景 | np.sort()（C级） | beyond-sort | 加速 |

|------|-----------------|-------------|------|

| 完全随机 | 1731 ms | **1205 ms** | **1.4x** |

| 近乎有序 | 1765 ms | **1090 ms** | **1.6x** |

| 完全逆序 | 1726 ms | **240 ms** | **7.2x** |

| 少量唯一值 | 491 ms | **459 ms** | **1.1x** |

| 管风琴（先升后降） | 1911 ms | **1008 ms** | **1.9x** |

| 锯齿波 | 1584 ms | **932 ms** | **1.7x** |

6 个场景，**全部超越 C 级实现**。

对比 Python 内置 `sorted()`？随机数据快 **16 倍**。

为什么能赢？

`np.sort()` 对所有数据走同一条路------C 级 introsort，不看数据长什么样。

beyond-sort 的核心思路是**先看再排**：

```python

import beyond_sort

result = beyond_sort.sort(data) # 自动选策略

detail = beyond_sort.probe_detail(data) # 查看数据分析结果

```

内部分四层：

第一层：符号层------熵探针

一次扫描，O(n) 时间，同时提取：

**有序度 τ**：升序 run 数量 / 总长度
**最长升序/降序 run**：判断是否整体有序或逆序
**值域范围**：决定能不能用计数排序

这一步相当于给数据做了一次"体检"。

第二层：语法层------Numba JIT

所有核心函数用 `@nb.njit` 编译成 LLVM 原生机器码。不是 Python 解释器在跑，是你 CPU 的原生指令在跑。零解释器开销。

第三层：指令层------向量化

计数排序的直方图用分段并行计数 + 前缀和 + 并行 scatter 实现，每一步都是缓存友好的连续内存访问。

第四层：并行层------值域分桶

这是最关键的设计。不是把数组按位置切成几段分别排------那样排完还要归并。

而是**按值域切**。比如数据范围 0-100 万，切成 16 个桶：0-6.25万、6.25万-12.5万...每个桶的值域不重叠。排完直接拼接，**零归并开销**。

16 个桶分配到多个 CPU 核心并行排序。数据量越大，并行收益越大。

策略路由表

|----------|---------|-----------|----------|

| 小数据量 | n < 50000 | 单线程 JIT 基数排序 | O(n·d) |

每种数据结构走专属最优路径，不走通用路。

规模越大，优势越大

| 场景 | 10万 | 100万 | 1000万 | 1亿 |

|------|------|-------|--------|-----|

| 随机 | 1.06x | 0.98x | **0.90x** | **0.72x** |

| 逆序 | **0.12x** | **0.15x** | **0.16x** | **0.14x** |

| 管风琴 | **0.22x** | **0.65x** | **0.70x** | **0.52x** |

（x < 1 表示 beyond-sort 更快）

10 万数据量时并行开销占比大，优势不明显。到千万、亿级，并行分桶的物理优势全面释放。

30 秒上手

复制下面这段到你的终端，直接跑，亲眼看结果：

```bash

pip install beyond-sort

```

```python

import beyond_sort

import numpy as np

import time

data = np.random.randint(0, 10_000_000, size=1_000_000, dtype=np.int64)

beyond_sort.warmup() # 首次预热 JIT

np.sort

t0 = time.perf_counter()

r1 = np.sort(data.copy())

t_np = (time.perf_counter() - t0) * 1000

beyond-sort

t0 = time.perf_counter()

r2 = beyond_sort.sort(data)

t_bs = (time.perf_counter() - t0) * 1000

print(f"np.sort: {t_np:.1f} ms")

print(f"beyond-sort: {t_bs:.1f} ms")

print(f"加速: {t_np/t_bs:.1f}x")

print(f"策略: {beyond_sort.probe(data)}")

print(f"结果正确: {np.array_equal(r1, r2)}")

```

依赖：Python 3.10+、NumPy、Numba。都是 pip 自动装的。

适用场景

大规模整数排序（日志时间戳、用户 ID、传感器数据）
数据管道中排序是瓶颈的环节
已知数据有结构特征（近有序、少量唯一值、周期性）
想在不换语言的前提下压榨极致性能

不适用

浮点数排序（当前只支持整数）
数据量 < 1000（内置 sorted 已经够快）
需要自定义比较函数的场景

开源协议

Apache-2.0。可以商用，可以修改，保留署名即可。

**直接安装**: `pip install beyond-sort`

**PyPI 主页**: https://pypi.org/project/beyond-sort/

*"不是算法比别人强，是把三个层打通了。"*