有更快的吗? 100万数组排序100次耗时不到500毫秒

你不丑

  

子程序名	返回值类型	公开	备 注
汇编_基数排序_L1缓存穿透版	整数型		Radix-256 + 4通道计数融合。哈希表仅4KB，100%钉死在L1缓存，彻底击穿缓存墙！
参数名	类 型	参考	可空	数组	备 注
参_源数组	整数型				待排序的原始数据集合（本参数在内部为只读，绝不破坏原数据）.强烈建议保留“参考”打勾！虽然在易语言中，取消“参考”确实不会影响最终的排序结果（因为我们只是读取它），但在底层性能上有着天壤之别。如果不打勾（传值）： 易语言会在调用子程序时，在内存中把这十几万个成员完整复制一份。这不仅白白浪费内存，更会消耗大量的 CPU 时钟周期去执行内存拷贝（）。如果打勾（传址）： 程序仅仅传递了一个 4 字节的**内存地址（指针）**给汇编引擎。没有任何多余的拷贝动作，瞬间直达数据腹地。对于有“性能强迫症”的开发者来说，这是绝对不能妥协的底线。
参_结果数组	整数型				接收排序后的数组
参_排序方式	整数型				1正向(升序默认)，2倒向(降序)

变量名	类 型	静态	数组	备 注
局_成员数	整数型			[ebp-4]
局_临时内存	整数型			[ebp-8]
局_计数内存	整数型			[ebp-12]
局_结束指针	整数型			[ebp-16]
局_静_临时内存	整数型			必须勾选静态
局_静_计数内存	整数型			必须勾选静态
局_静_内存容量	整数型			必须勾选静态

局_成员数 ＝ 取数组成员数 (参_源数组)
如果真 (取数组成员数 (参_结果数组) ≠ 局_成员数)
重定义数组 (参_结果数组, 假, 局_成员数)
如果真 (局_成员数 ≤ 1)
如果真 (局_成员数 ＝ 1)
参_结果数组 [1] ＝ 参_源数组 [1]
返回 (局_成员数)
如果真 (局_静_内存容量 ＜ 局_成员数 × 4)
如果真 (局_静_临时内存 ≠ 0)
释放内存 (局_静_临时内存)
局_静_临时内存 ＝ 申请内存 (局_成员数 × 4, 真)
局_静_内存容量 ＝ 局_成员数 × 4
如果真 (局_静_计数内存 ＝ 0)
局_静_计数内存 ＝ 申请内存 (4096, 真)
局_临时内存 ＝ 局_静_临时内存
局_计数内存 ＝ 局_静_计数内存
置入代码 ({ 83, 86, 87, 139, 125, 244, 49, 192, 185, 0, 4, 0, 0, 243, 171, 139, 117, 8, 139, 54, 141, 118, 8, 139, 69, 252, 193, 224, 2, 1, 240, 137, 69, 240, 139, 93, 244, 139, 6, 15, 182, 208, 255, 4, 147, 137, 194, 193, 234, 8, 15, 182, 210, 255, 132, 147, 0, 4, 0, 0, 137, 194, 193, 234, 16, 15, 182, 210, 255, 132, 147, 0, 8, 0, 0, 193, 232, 24, 255, 132, 131, 0, 12, 0, 0, 131, 198, 4, 59, 117, 240, 124, 200, 191, 0, 0, 0, 0, 49, 192, 139, 93, 244, 1, 251, 131, 125, 16, 2, 116, 21, 49, 201, 139, 20, 139, 137, 4, 139, 1, 208, 65, 129, 249, 0, 1, 0, 0, 124, 239, 235, 16, 185, 255, 0, 0, 0, 139, 20, 139, 137, 4, 139, 1, 208, 73, 125, 245, 129, 199, 0, 4, 0, 0, 129, 255, 0, 16, 0, 0, 124, 192, 139, 117, 8, 139, 54, 141, 118, 8, 139, 125, 248, 139, 93, 244, 139, 6, 15, 182, 208, 139, 12, 147, 255, 4, 147, 137, 4, 143, 131, 198, 4, 59, 117, 240, 124, 234, 139, 117, 248, 139, 69, 12, 139, 0, 141, 120, 8, 139, 93, 244, 129, 195, 0, 4, 0, 0, 139, 69, 252, 193, 224, 2, 1, 240, 137, 69, 240, 139, 6, 137, 194, 193, 234, 8, 15, 182, 210, 139, 12, 147, 255, 4, 147, 137, 4, 143, 131, 198, 4, 59, 117, 240, 124, 229, 139, 69, 12, 139, 0, 141, 112, 8, 139, 125, 248, 139, 93, 244, 129, 195, 0, 8, 0, 0, 139, 69, 252, 193, 224, 2, 1, 240, 137, 69, 240, 139, 6, 137, 194, 193, 234, 16, 15, 182, 210, 139, 12, 147, 255, 4, 147, 137, 4, 143, 131, 198, 4, 59, 117, 240, 124, 229, 139, 117, 248, 139, 69, 12, 139, 0, 141, 120, 8, 139, 93, 244, 129, 195, 0, 12, 0, 0, 139, 69, 252, 193, 224, 2, 1, 240, 137, 69, 240, 139, 6, 137, 194, 193, 234, 24, 139, 12, 147, 255, 4, 147, 137, 4, 143, 131, 198, 4, 59, 117, 240, 124, 232, 95, 94, 91 })
返回 (局_成员数)

子程序名	返回值类型	公开	备 注
__按钮_获取版本_被单击5_被单击

变量名	类 型	静态	数组	备 注
i	整数型
源数组	整数型		1000000
返回数组	整数型		0

计次循环首 (1000000, i)
源数组 [i] ＝ 取随机数_ (100000000, 999999999)
计次循环尾 ()
调试输出 (“======================================”)
开始计时 ()
计次循环首 (100, )
汇编_基数排序_L1缓存穿透版 (源数组, 返回数组, 1)
' 调试输出 (返回数组)
' 数组_乱序_ (源数组)
计次循环尾 ()
调试输出 (“汇编_基数排序_L1缓存穿透版15万数组循环100次耗时：：”)
调试计时结果 ()

i支持库列表	支持库注释
spec	特殊功能支持库
YYDS	(未知支持库)

.版本 2<br /> .支持库 spec<br /> .支持库 YYDS<br /> <br /> .子程序 汇编_基数排序_L1缓存穿透版, 整数型, 公开, Radix-256 + 4通道计数融合。哈希表仅4KB，100%钉死在L1缓存，彻底击穿缓存墙！<br /> .参数 参_源数组, 整数型, 参考 数组, 待排序的原始数据集合（本参数在内部为只读，绝不破坏原数据）.强烈建议保留“参考”打勾！虽然在易语言中，取消“参考”确实不会影响最终的排序结果（因为我们只是读取它），但在底层性能上有着天壤之别。如果不打勾（传值）： 易语言会在调用子程序时，在内存中把这十几万个成员完整复制一份。这不仅白白浪费内存，更会消耗大量的 CPU 时钟周期去执行内存拷贝（）。如果打勾（传址）： 程序仅仅传递了一个 4 字节的**内存地址（指针）**给汇编引擎。没有任何多余的拷贝动作，瞬间直达数据腹地。对于有“性能强迫症”的开发者来说，这是绝对不能妥协的底线。<br /> .参数 参_结果数组, 整数型, 参考 数组, 接收排序后的数组<br /> .参数 参_排序方式, 整数型, 可空, 1正向(升序默认)，2倒向(降序)<br /> .局部变量 局_成员数, 整数型, , , [ebp-4]<br /> .局部变量 局_临时内存, 整数型, , , [ebp-8]<br /> .局部变量 局_计数内存, 整数型, , , [ebp-12]<br /> .局部变量 局_结束指针, 整数型, , , [ebp-16]<br /> .局部变量 局_静_临时内存, 整数型, 静态, , 必须勾选静态<br /> .局部变量 局_静_计数内存, 整数型, 静态, , 必须勾选静态<br /> .局部变量 局_静_内存容量, 整数型, 静态, , 必须勾选静态<br /> <br /> 局_成员数 ＝ 取数组成员数 (参_源数组)<br /> .如果真 (取数组成员数 (参_结果数组) ≠ 局_成员数)<br />     重定义数组 (参_结果数组, 假, 局_成员数)<br /> .如果真结束<br /> .如果真 (局_成员数 ≤ 1)<br />     .如果真 (局_成员数 ＝ 1)<br />         参_结果数组 [1] ＝ 参_源数组 [1]<br />     .如果真结束<br />     返回 (局_成员数)<br /> .如果真结束<br /> .如果真 (局_静_内存容量 ＜ 局_成员数 × 4)<br />     .如果真 (局_静_临时内存 ≠ 0)<br />         释放内存 (局_静_临时内存)<br />     .如果真结束<br />     局_静_临时内存 ＝ 申请内存 (局_成员数 × 4, 真)<br />     局_静_内存容量 ＝ 局_成员数 × 4<br /> .如果真结束<br /> .如果真 (局_静_计数内存 ＝ 0)<br />     局_静_计数内存 ＝ 申请内存 (4096, 真)<br /> .如果真结束<br /> 局_临时内存 ＝ 局_静_临时内存<br /> 局_计数内存 ＝ 局_静_计数内存<br /> 置入代码 ({ 83, 86, 87, 139, 125, 244, 49, 192, 185, 0, 4, 0, 0, 243, 171, 139, 117, 8, 139, 54, 141, 118, 8, 139, 69, 252, 193, 224, 2, 1, 240, 137, 69, 240, 139, 93, 244, 139, 6, 15, 182, 208, 255, 4, 147, 137, 194, 193, 234, 8, 15, 182, 210, 255, 132, 147, 0, 4, 0, 0, 137, 194, 193, 234, 16, 15, 182, 210, 255, 132, 147, 0, 8, 0, 0, 193, 232, 24, 255, 132, 131, 0, 12, 0, 0, 131, 198, 4, 59, 117, 240, 124, 200, 191, 0, 0, 0, 0, 49, 192, 139, 93, 244, 1, 251, 131, 125, 16, 2, 116, 21, 49, 201, 139, 20, 139, 137, 4, 139, 1, 208, 65, 129, 249, 0, 1, 0, 0, 124, 239, 235, 16, 185, 255, 0, 0, 0, 139, 20, 139, 137, 4, 139, 1, 208, 73, 125, 245, 129, 199, 0, 4, 0, 0, 129, 255, 0, 16, 0, 0, 124, 192, 139, 117, 8, 139, 54, 141, 118, 8, 139, 125, 248, 139, 93, 244, 139, 6, 15, 182, 208, 139, 12, 147, 255, 4, 147, 137, 4, 143, 131, 198, 4, 59, 117, 240, 124, 234, 139, 117, 248, 139, 69, 12, 139, 0, 141, 120, 8, 139, 93, 244, 129, 195, 0, 4, 0, 0, 139, 69, 252, 193, 224, 2, 1, 240, 137, 69, 240, 139, 6, 137, 194, 193, 234, 8, 15, 182, 210, 139, 12, 147, 255, 4, 147, 137, 4, 143, 131, 198, 4, 59, 117, 240, 124, 229, 139, 69, 12, 139, 0, 141, 112, 8, 139, 125, 248, 139, 93, 244, 129, 195, 0, 8, 0, 0, 139, 69, 252, 193, 224, 2, 1, 240, 137, 69, 240, 139, 6, 137, 194, 193, 234, 16, 15, 182, 210, 139, 12, 147, 255, 4, 147, 137, 4, 143, 131, 198, 4, 59, 117, 240, 124, 229, 139, 117, 248, 139, 69, 12, 139, 0, 141, 120, 8, 139, 93, 244, 129, 195, 0, 12, 0, 0, 139, 69, 252, 193, 224, 2, 1, 240, 137, 69, 240, 139, 6, 137, 194, 193, 234, 24, 139, 12, 147, 255, 4, 147, 137, 4, 143, 131, 198, 4, 59, 117, 240, 124, 232, 95, 94, 91 })<br /> 返回 (局_成员数)<br /> <br /> .子程序 __按钮_获取版本_被单击5_被单击<br /> .局部变量 i, 整数型<br /> .局部变量 源数组, 整数型, , "1000000"<br /> .局部变量 返回数组, 整数型, , "0"<br /> <br /> <br /> .计次循环首 (1000000, i)<br />     源数组 <i> ＝ 取随机数_ (100000000, 999999999)<br /> .计次循环尾 ()<br /> 调试输出 (“======================================”)<br /> 开始计时 ()<br /> .计次循环首 (100, )<br />     汇编_基数排序_L1缓存穿透版 (源数组, 返回数组, 1)<br />     ' 调试输出 (返回数组)<br />     ' 数组_乱序_ (源数组)<br /> .计次循环尾 ()<br /> 调试输出 (“汇编_基数排序_L1缓存穿透版15万数组循环100次耗时：：”)<br /> 调试计时结果 ()

萧楚楠

比比白银大佬的呢

嫂子

你不丑 发表于 2026-3-7 21:01
就是只针对整数排序啊 是AI配合写的 哈哈 目前没有对手

没对手是局限在32位 易语言。

X64就可以随便超过了。在激进一点 用opencl  跑GPU运算就可以秒杀

你不丑

嫂子 发表于 2026-3-7 20:38
32位系统的话 这个算法 的确是最稳定且速度比较快的了。其他的MSD或Ska Sort 在某些时候会快 但是不如这个 ...

就是只针对整数排序啊 是AI配合写的 哈哈 目前没有对手

嫂子

32位系统的话 这个算法 的确是最稳定且速度比较快的了。其他的MSD或Ska Sort 在某些时候会快 但是不如这个稳定另外这个汇编不是你写的吧
另外 此算法 只针对了 32位整数 是有效的。其他类型不行

1101469226

递归500W数据1秒排完

我的yyy123

学习学习

不苦小和尚

试试看看效果

jaicke123

感谢分享

你不丑

帅气与大侠 发表于 2026-3-7 11:06
这个静态变量多线程下有冲突吧

不会的 静态哪里当作是静态内存池再用 取决于数组的大小 30万数组临时数组大概几百 KB + 计数表 4KB的占用 但是省去了连申请内存消耗的时间