排序键数组，换成易代码，最好是汇编，有哪位帮忙弄下？

SSS777 · 发表于 2025-11-29 07:28:10

哈希表不适合高速循环使用，容易闪退，我想把它换成易代码，最好是汇编的，有哪位大佬帮助弄下？
思路如下：只排序键数组（从小到大排序），值跟键永远绑定在一起的。
键排序思路.png

帅气与大侠 · 发表于 2025-11-29 07:28:11

你的场景可能更合适冒泡排序，虽然冒泡排序速度较慢，但是它不需要额外的内存，开销更小，合适少量数据，直接对数组进行原地排序。

还有其它更多的排序算法，速度都比冒泡排序快很多，但是都要几乎都要额外的内存开销(申请、释放内存)

子程序名	返回值类型	公开	备注
子程序1

变量名	类型	静态	数组	备注
键名	整数型		0
键值	整数型		0

键名＝ { 4, 1, 3, 2 }
键值＝ { 7777, 5555, 8888, 6666 }

计次循环首 (10000000, )

' 测试使用，这样初始化数组更快，少去申请、释放内存过程

键名 [1] ＝ 4

键名 [2] ＝ 1

键名 [3] ＝ 3

键名 [4] ＝ 2

键值 [1] ＝ 7777

键值 [2] ＝ 5555

键值 [3] ＝ 8888

键值 [4] ＝ 6666

排序键_冒泡ASM (键名, 键值) ' 236ms

' 排序键_冒泡 (键名, 键值) ' 1339ms

计次循环尾 ()
调试输出 (键名, 键值)

子程序名	返回值类型	公开	备注
排序键_冒泡			比汇编慢4-5倍左右
参数名	类型	参考	可空	数组	备注
键名	整数型
键值	整数型

变量名	类型	静态	数组	备注
成员数	整数型
最后位置	整数型
I	整数型

成员数＝取数组成员数 (键名)

判断循环首 (成员数＞ 0)

最后位置＝ 0

变量循环首 (1, 成员数－ 1, 1, I)

如果真 (键名 [I] ＞键名 [I ＋ 1])

交换变量 (键名 [I], 键名 [I ＋ 1])

交换变量 (键值 [I], 键值 [I ＋ 1])

最后位置＝ I

变量循环尾 ()

成员数＝最后位置

判断循环尾 ()

子程序名	返回值类型	公开	备注
排序键_冒泡ASM
参数名	类型	参考	可空	数组	备注
键名	整数型
键值	整数型

置入代码 ({ 85, 139, 117, 8, 139, 54, 141, 118, 8, 139, 125, 12, 139, 63, 141, 127, 8, 139, 78, 252, 131, 249, 2, 124, 68, 59, 79, 252, 117, 63, 193, 225, 2, 131, 233, 4, 131, 249, 0, 126, 52, 49, 237, 49, 219, 57, 203, 125, 40, 131, 195, 4, 139, 68, 30, 252, 59, 4, 30, 126, 240, 139, 20, 30, 137, 4, 30, 137, 84, 30, 252, 139, 68, 31, 252, 139, 20, 31, 137, 4, 31, 137, 84, 31, 252, 137, 221, 235, 212, 137, 233, 235, 199, 93 })
' __asm{
' ; push ebp
' ; ;键名[1]地址
' ; mov esi,dword [ebp+8]
' ; mov esi,dword [esi]
' ; lea esi,dword [esi+8]
' ; ;键值[1]地址
' ; mov edi,dword [ebp+12]
' ; mov edi,dword [edi]
' ; lea edi,dword [edi+8]
' ; ;ecx = 取数组成员数(键名)
' ; mov ecx,dword [esi-4]
' ; cmp ecx,2
' ; jl 结束
' ; cmp ecx,dword [edi-4]
' ; jne 结束
' ; shl ecx,2
' ; sub ecx,4
' ; 判断循环首:
' ; cmp ecx,0
' ; jle 结束
' ; xor ebp,ebp
' ; ;------------
' ; xor ebx,ebx
' ; 变量循环首:
' ; cmp ebx,ecx
' ; jge 变量循环尾
' ; add ebx,4
' ; mov eax,dword [esi+ebx-4]
' ; cmp eax,dword [esi+ebx]
' ; jng 变量循环首
' ; ;交换键名
' ; mov edx,dword [esi+ebx]
' ; mov dword [esi+ebx],eax
' ; mov dword [esi+ebx-4],edx
' ; ;交换键值
' ; mov eax,dword [edi+ebx-4]
' ; mov edx,dword [edi+ebx]
' ; mov dword [edi+ebx],eax
' ; mov dword [edi+ebx-4],edx
' ; mov ebp,ebx
' ; jmp 变量循环首
' ; 变量循环尾:
' ; mov ecx,ebp
' ; jmp 判断循环首
' ; 结束:
' ; pop ebp
' }

i支持库列表	支持库注释
spec	特殊功能支持库

.版本 2<br />
.支持库 spec<br />
<br />
.子程序 子程序1<br />
.局部变量 键名, 整数型, , "0"<br />
.局部变量 键值, 整数型, , "0"<br />
<br />
键名 ＝ { 4, 1, 3, 2 }<br />
键值 ＝ { 7777, 5555, 8888, 6666 }<br />
.计次循环首 (10000000, )<br />
    ' 测试使用，这样初始化数组更快，少去申请、释放内存过程<br />
    键名 [1] ＝ 4<br />
    键名 [2] ＝ 1<br />
    键名 [3] ＝ 3<br />
    键名 [4] ＝ 2<br />
    键值 [1] ＝ 7777<br />
    键值 [2] ＝ 5555<br />
    键值 [3] ＝ 8888<br />
    键值 [4] ＝ 6666<br />
<br />
    排序键_冒泡ASM (键名, 键值)  ' 236ms<br />
    ' 排序键_冒泡 (键名, 键值)  ' 1339ms<br />
.计次循环尾 ()<br />
调试输出 (键名, 键值)<br />
<br />
<br />
.子程序 排序键_冒泡, , , 比汇编慢4-5倍左右<br />
.参数 键名, 整数型, 数组<br />
.参数 键值, 整数型, 数组<br />
.局部变量 成员数, 整数型<br />
.局部变量 最后位置, 整数型<br />
.局部变量 I, 整数型<br />
<br />
成员数 ＝ 取数组成员数 (键名)<br />
.判断循环首 (成员数 ＞ 0)<br />
    最后位置 ＝ 0<br />
    .变量循环首 (1, 成员数 － 1, 1, I)<br />
        .如果真 (键名 [I] ＞ 键名 [I ＋ 1])<br />
            交换变量 (键名 [I], 键名 [I ＋ 1])<br />
            交换变量 (键值 [I], 键值 [I ＋ 1])<br />
            最后位置 ＝ I<br />
        .如果真结束<br />
<br />
    .变量循环尾 ()<br />
    成员数 ＝ 最后位置<br />
.判断循环尾 ()<br />
<br />
.子程序 排序键_冒泡ASM<br />
.参数 键名, 整数型, 数组<br />
.参数 键值, 整数型, 数组<br />
<br />
置入代码 ({ 85, 139, 117, 8, 139, 54, 141, 118, 8, 139, 125, 12, 139, 63, 141, 127, 8, 139, 78, 252, 131, 249, 2, 124, 68, 59, 79, 252, 117, 63, 193, 225, 2, 131, 233, 4, 131, 249, 0, 126, 52, 49, 237, 49, 219, 57, 203, 125, 40, 131, 195, 4, 139, 68, 30, 252, 59, 4, 30, 126, 240, 139, 20, 30, 137, 4, 30, 137, 84, 30, 252, 139, 68, 31, 252, 139, 20, 31, 137, 4, 31, 137, 84, 31, 252, 137, 221, 235, 212, 137, 233, 235, 199, 93 })<br />
<br />
' __asm{<br />
' ; push ebp<br />
' ; ;键名[1]地址<br />
' ; mov esi,dword [ebp+8]<br />
' ; mov esi,dword [esi]<br />
' ; lea esi,dword [esi+8]<br />
' ; ;键值[1]地址<br />
' ; mov edi,dword [ebp+12]<br />
' ; mov edi,dword [edi]<br />
' ; lea edi,dword [edi+8]<br />
<br />
' ; ;ecx = 取数组成员数(键名)<br />
' ; mov ecx,dword [esi-4]<br />
' ; cmp ecx,2<br />
' ; jl 结束<br />
' ; cmp ecx,dword [edi-4]<br />
' ; jne 结束<br />
' ; shl ecx,2<br />
' ; sub ecx,4<br />
<br />
' ; 判断循环首:<br />
' ; cmp ecx,0<br />
' ; jle 结束<br />
' ; xor ebp,ebp<br />
' ; ;------------<br />
' ;    xor ebx,ebx<br />
' ;    变量循环首:<br />
' ;    cmp ebx,ecx<br />
' ;    jge 变量循环尾<br />
' ;    add ebx,4<br />
' ;    mov eax,dword [esi+ebx-4]<br />
' ;    cmp eax,dword [esi+ebx]<br />
' ;    jng 变量循环首<br />
' ;    ;交换键名<br />
' ;    mov edx,dword [esi+ebx]<br />
' ;    mov dword [esi+ebx],eax<br />
' ;    mov dword [esi+ebx-4],edx<br />
' ;    ;交换键值<br />
' ;    mov eax,dword [edi+ebx-4]<br />
' ;    mov edx,dword [edi+ebx]<br />
' ;    mov dword [edi+ebx],eax<br />
' ;    mov dword [edi+ebx-4],edx<br />
<br />
' ;    mov ebp,ebx<br />
' ;    jmp 变量循环首<br />
<br />
<br />
' ;    变量循环尾:<br />
' ; mov ecx,ebp<br />
' ; jmp 判断循环首<br />
<br />
' ; 结束:<br />
' ; pop ebp<br />
' }

zzoo1314 · 发表于 2025-11-29 07:43:05

不是编汇的我可以先占楼

zzoo1314 · 发表于 2025-11-29 07:46:06

模块呢~~~~

zzoo1314 · 发表于 2025-11-29 07:57:39

窗口程序集名	保留	保留	备注
窗口程序集_启动窗口

子程序名	返回值类型	公开	备注
__启动窗口_创建完毕

排序键 ({ 4, 1, 3, 2 }, { 7777, 5555, 8888, 6666 })

子程序名	返回值类型	公开	备注
排序键			键组和值组的成员数一致
参数名	类型	参考	可空	数组	备注
键数组	整数型				要排序的键，到小到大排序
值数组	整数型				值跟键永远绑定在一起的

变量名	类型	静态	数组	备注
i	整数型
新键数组	整数型		0
引导数组	整数型		0

ZxcArray排序z (键数组, , 新键数组, 引导数组, )

计次循环首 (取数组成员数 (新键数组), i)

调试输出 (“键 ” ＋到文本 (新键数组 [i]) ＋ “ 值 ” ＋到文本 (值数组 [到整数 (引导数组 [i])]))

计次循环尾 ()
' 哈希表.创建 (#整数型, #整数型, , , , , 真, )
' 调试输出 (“----------排序键前----------”)
' 调试输出 (“键：”, 键数组)
' 调试输出 (“值：”, 值数组)
. ' 计次循环首 (取数组成员数 (键数组), i)
' 哈希表.有序_添加 (键数组 [i], 值数组 [i], , )
. ' 计次循环尾 ()
' 哈希表.有序_排序键 ()
' 哈希表.取所有键值 (键数组, 值数组, )
' 调试输出 (“----------排序键后----------”)
' 调试输出 (“键：”, 键数组)
' 调试输出 (“值：”, 值数组)

子程序名	返回值类型	公开	备注
ZxcArray排序z			参数1 参数2 二选一都有值优先参数1 主要返回参数4
参数名	类型	参考	可空	数组	备注
整数型_数组	整数型
文本型数字_数组	文本型
返回整数型_数组值_不能与参1同	整数型
返回整数型_数组排序用	整数型
大到小_默认小到大	逻辑型

变量名	类型	静态	数组	备注
i	整数型
cys	整数型
原数组	整数型		0
计次	整数型
ii	整数型
对比次数	整数型

清除数组 (返回整数型_数组值_不能与参1同)
清除数组 (返回整数型_数组排序用)

如果真 (是否为空 (整数型_数组) ＝真且是否为空 (文本型数字_数组) ＝真)

信息框 (“原数组二选一”, 0, , )

返回 ()
cys ＝取数组成员数 (整数型_数组)

如果 (cys ＞ 0)

原数组＝整数型_数组

cys ＝取数组成员数 (文本型数字_数组)

如果真 (cys ＞ 0)

清除数组 (原数组)

计次循环首 (cys, i)

加入成员 (原数组, 到整数 (文本型数字_数组 [i]))

计次循环尾 ()

如果 (大到小_默认小到大＝假) ' ====================== 从小到大
计次＝ 0
对比次数＝ 0

循环判断首 ()

计次＝计次＋ 1

计次循环首 (cys, i)

计次循环首 (cys, ii)

如果真 (原数组 [i] ＜原数组 [ii])

对比次数＝对比次数＋ 1

计次循环尾 ()

如果真 (对比次数＝ cys －计次)

加入成员 (返回整数型_数组值_不能与参1同, 原数组 [i])

加入成员 (返回整数型_数组排序用, i)

对比次数＝ 0

计次循环尾 ()

循环判断尾 (取数组成员数 (返回整数型_数组值_不能与参1同) ＜ cys)返回 ()

计次＝ 0

对比次数＝ 0

循环判断首 ()

计次＝计次＋ 1

计次循环首 (cys, i)

计次循环首 (cys, ii)

如果真 (原数组 [i] ＞原数组 [ii])

对比次数＝对比次数＋ 1

计次循环尾 ()

如果真 (对比次数＝ cys －计次)

加入成员 (返回整数型_数组值_不能与参1同, 原数组 [i])

加入成员 (返回整数型_数组排序用, i)

对比次数＝ 0

计次循环尾 ()

循环判断尾 (取数组成员数 (返回整数型_数组值_不能与参1同) ＜ cys)

返回 ()

i支持库列表	支持库注释
spec	特殊功能支持库

.版本 2<br />
.支持库 spec<br />
<br />
.程序集 窗口程序集_启动窗口<br />
<br />
.子程序 __启动窗口_创建完毕<br />
<br />
排序键 ({ 4, 1, 3, 2 }, { 7777, 5555, 8888, 6666 })<br />
<br />
.子程序 排序键, , , 键组和值组的成员数一致<br />
.参数 键数组, 整数型, 数组, 要排序的键，到小到大排序<br />
.参数 值数组, 整数型, 数组, 值跟键永远绑定在一起的<br />
.局部变量 i, 整数型<br />
.局部变量 新键数组, 整数型, , "0"<br />
.局部变量 引导数组, 整数型, , "0"<br />
<br />
ZxcArray排序z (键数组, , 新键数组, 引导数组, )<br />
.计次循环首 (取数组成员数 (新键数组), i)<br />
    调试输出 (“键 ” ＋ 到文本 (新键数组 <i>) ＋ “ 值 ” ＋ 到文本 (值数组 [到整数 (引导数组 <i>)]))<br />
.计次循环尾 ()<br />
<br />
' 哈希表.创建 (#整数型, #整数型, , , , , 真, )<br />
<br />
' 调试输出 (“----------排序键前----------”)<br />
' 调试输出 (“键：”, 键数组)<br />
' 调试输出 (“值：”, 值数组)<br />
<br />
.' 计次循环首 (取数组成员数 (键数组), i)<br />
    ' 哈希表.有序_添加 (键数组 <i>, 值数组 <i>, , )<br />
.' 计次循环尾 ()<br />
' 哈希表.有序_排序键 ()<br />
' 哈希表.取所有键值 (键数组, 值数组, )<br />
<br />
' 调试输出 (“----------排序键后----------”)<br />
' 调试输出 (“键：”, 键数组)<br />
' 调试输出 (“值：”, 值数组)<br />
<br />
<br />
.子程序 ZxcArray排序z, , 公开, 参数1 参数2 二选一 都有值优先 参数1 主要返回 参数4 <br />
.参数 整数型_数组, 整数型, 可空 数组<br />
.参数 文本型数字_数组, 文本型, 可空 数组<br />
.参数 返回整数型_数组值_不能与参1同, 整数型, 参考 可空 数组<br />
.参数 返回整数型_数组排序用, 整数型, 参考 可空 数组<br />
.参数 大到小_默认小到大, 逻辑型, 可空<br />
.局部变量 i, 整数型<br />
.局部变量 cys, 整数型<br />
.局部变量 原数组, 整数型, , "0"<br />
.局部变量 计次, 整数型<br />
.局部变量 ii, 整数型<br />
.局部变量 对比次数, 整数型<br />
<br />
清除数组 (返回整数型_数组值_不能与参1同)<br />
清除数组 (返回整数型_数组排序用)<br />
.如果真 (是否为空 (整数型_数组) ＝ 真 且 是否为空 (文本型数字_数组) ＝ 真)<br />
    信息框 (“原数组 二选一”, 0, , )<br />
    返回 ()<br />
.如果真结束<br />
cys ＝ 取数组成员数 (整数型_数组)<br />
.如果 (cys ＞ 0)<br />
    原数组 ＝ 整数型_数组<br />
.否则<br />
    cys ＝ 取数组成员数 (文本型数字_数组)<br />
    .如果真 (cys ＞ 0)<br />
        清除数组 (原数组)<br />
        .计次循环首 (cys, i)<br />
            加入成员 (原数组, 到整数 (文本型数字_数组 <i>))<br />
        .计次循环尾 ()<br />
    .如果真结束<br />
<br />
.如果结束<br />
.如果 (大到小_默认小到大 ＝ 假)  ' ====================== 从小到大<br />
    计次 ＝ 0<br />
    对比次数 ＝ 0<br />
    .循环判断首 ()<br />
        计次 ＝ 计次 ＋ 1<br />
        .计次循环首 (cys, i)<br />
            .计次循环首 (cys, ii)<br />
                .如果真 (原数组 <i> ＜ 原数组 [ii])<br />
                    对比次数 ＝ 对比次数 ＋ 1<br />
                .如果真结束<br />
<br />
            .计次循环尾 ()<br />
            .如果真 (对比次数 ＝ cys － 计次)<br />
                加入成员 (返回整数型_数组值_不能与参1同, 原数组 <i>)<br />
                加入成员 (返回整数型_数组排序用, i)<br />
            .如果真结束<br />
            对比次数 ＝ 0<br />
        .计次循环尾 ()<br />
    .循环判断尾 (取数组成员数 (返回整数型_数组值_不能与参1同) ＜ cys)<br />
    返回 ()<br />
.否则<br />
    计次 ＝ 0<br />
    对比次数 ＝ 0<br />
    .循环判断首 ()<br />
        计次 ＝ 计次 ＋ 1<br />
        .计次循环首 (cys, i)<br />
            .计次循环首 (cys, ii)<br />
                .如果真 (原数组 <i> ＞ 原数组 [ii])<br />
                    对比次数 ＝ 对比次数 ＋ 1<br />
                .如果真结束<br />
<br />
            .计次循环尾 ()<br />
            .如果真 (对比次数 ＝ cys － 计次)<br />
                加入成员 (返回整数型_数组值_不能与参1同, 原数组 <i>)<br />
                加入成员 (返回整数型_数组排序用, i)<br />
            .如果真结束<br />
            对比次数 ＝ 0<br />
        .计次循环尾 ()<br />
    .循环判断尾 (取数组成员数 (返回整数型_数组值_不能与参1同) ＜ cys)<br />
    返回 ()<br />
.如果结束

zainex · 发表于 2025-11-29 13:29:27

排序的性能取决于算法, 而不是写法, 跟是否使用汇编, 关系不大.非要用汇编, 可以参考下面的方法:
使用缩小增量法改善 “数组_排序1” 的性能_精易论坛

数据类型名	公开	备注
排序对象
成员名	类型	传址	数组	备注
键	整数型
值	整数型

窗口程序集名	保留	保留	备注
窗口程序集_启动窗口

子程序名	返回值类型	公开	备注
希尔排序
参数名	类型	参考	可空	数组	备注
数组	排序对象

置入代码 ({ 139, 69, 8, 139, 8, 139, 65, 4, 137, 69, 236, 184, 1, 0, 0, 0, 57, 69, 236, 124, 14, 141, 4, 64, 64, 235, 245, 187, 3, 0, 0, 0, 153, 247, 251, 133, 192, 126, 94, 107, 208, 252, 137, 85, 224, 137, 194, 57, 85, 236, 126, 231, 141, 60, 145, 139, 92, 145, 8, 137, 125, 240, 137, 93, 228, 137, 211, 57, 216, 126, 10, 139, 117, 228, 66, 137, 116, 153, 8, 235, 222, 137, 223, 139, 117, 240, 41, 199, 137, 125, 220, 139, 125, 224, 139, 124, 62, 8, 137, 125, 232, 139, 125, 228, 139, 117, 232, 139, 54, 57, 55, 125, 214, 139, 93, 240, 139, 117, 232, 137, 115, 8, 139, 93, 224, 1, 93, 240, 139, 93, 220, 235, 190, 201, 194, 4, 0 })
' mov eax, DWORD PTR [ebp+8]
' mov ecx, DWORD PTR [eax]
' mov eax, DWORD PTR [ecx+4]
' mov DWORD PTR [ebp-20], eax
' mov eax, 1
' L2:
' cmp DWORD PTR [ebp-20], eax
' jl L4
' lea eax, [eax+eax*2]
' inc eax
' jmp L2
' L14:
' mov ebx, 3
' cdq
' idiv ebx
' L4:
' test eax, eax
' jle L1
' imul edx, eax, -4
' mov DWORD PTR [ebp-32], edx
' mov edx, eax
' L7:
' cmp DWORD PTR [ebp-20], edx
' jle L14
' lea edi, [ecx+edx*4]
' mov ebx, DWORD PTR [ecx+8+edx*4]
' mov DWORD PTR [ebp-16], edi
' mov DWORD PTR [ebp-28], ebx
' mov ebx, edx
' L5:
' cmp eax, ebx
' jle L6
' L9:
' mov esi, DWORD PTR [ebp-28]
' inc edx
' mov DWORD PTR [ecx+8+ebx*4], esi
' jmp L7
' L6:
' mov edi, ebx
' mov esi, DWORD PTR [ebp-16]
' sub edi, eax
' mov DWORD PTR [ebp-36], edi
' mov edi, DWORD PTR [ebp-32]
' mov edi, DWORD PTR [esi+8+edi]
' mov DWORD PTR [ebp-24], edi
' mov edi, DWORD PTR [ebp-28]
' mov esi, DWORD PTR [ebp-24]
' mov esi, DWORD PTR [esi]
' cmp DWORD PTR [edi], esi
' jge L9
' mov ebx, DWORD PTR [ebp-16]
' mov esi, DWORD PTR [ebp-24]
' mov DWORD PTR [ebx+8], esi
' mov ebx, DWORD PTR [ebp-32]
' add DWORD PTR [ebp-16], ebx
' mov ebx, DWORD PTR [ebp-36]
' jmp L5
' L1:
' leave
' ret 4

子程序名	返回值类型	公开	备注
__启动窗口_创建完毕

变量名	类型	静态	数组	备注
键数组	整数型		0	要排序的键，到小到大排序
值数组	整数型		0	值跟键永远绑定在一起的
排序数组	排序对象		0
数	整数型

键数组＝ { 4, 1, 3, 2 }
值数组＝ { 7777, 5555, 8888, 6666 }
重定义数组 (排序数组, 假, 取数组成员数 (键数组))

计次循环首 (取数组成员数 (排序数组), 数)

排序数组 [数].键＝键数组 [数]

排序数组 [数].值＝值数组 [数]

调试输出 (排序数组 [数].键, 排序数组 [数].值)

计次循环尾 ()
调试输出 (“------”)
希尔排序 (排序数组)

计次循环首 (取数组成员数 (排序数组), 数)

调试输出 (排序数组 [数].键, 排序数组 [数].值)

计次循环尾 ()

i支持库列表	支持库注释
spec	特殊功能支持库

.版本 2<br />
.支持库 spec<br />
<br />
.程序集 窗口程序集_启动窗口<br />
<br />
.子程序 希尔排序<br />
.参数 数组, 排序对象, 数组<br />
<br />
置入代码 ({ 139, 69, 8, 139, 8, 139, 65, 4, 137, 69, 236, 184, 1, 0, 0, 0, 57, 69, 236, 124, 14, 141, 4, 64, 64, 235, 245, 187, 3, 0, 0, 0, 153, 247, 251, 133, 192, 126, 94, 107, 208, 252, 137, 85, 224, 137, 194, 57, 85, 236, 126, 231, 141, 60, 145, 139, 92, 145, 8, 137, 125, 240, 137, 93, 228, 137, 211, 57, 216, 126, 10, 139, 117, 228, 66, 137, 116, 153, 8, 235, 222, 137, 223, 139, 117, 240, 41, 199, 137, 125, 220, 139, 125, 224, 139, 124, 62, 8, 137, 125, 232, 139, 125, 228, 139, 117, 232, 139, 54, 57, 55, 125, 214, 139, 93, 240, 139, 117, 232, 137, 115, 8, 139, 93, 224, 1, 93, 240, 139, 93, 220, 235, 190, 201, 194, 4, 0 })<br />
' mov eax, DWORD PTR [ebp+8]<br />
' mov ecx, DWORD PTR [eax]<br />
' mov eax, DWORD PTR [ecx+4]<br />
' mov DWORD PTR [ebp-20], eax<br />
' mov eax, 1<br />
' L2:<br />
' cmp DWORD PTR [ebp-20], eax<br />
' jl L4<br />
' lea eax, [eax+eax*2]<br />
' inc eax<br />
' jmp L2<br />
' L14:<br />
' mov ebx, 3<br />
' cdq<br />
' idiv ebx<br />
' L4:<br />
' test eax, eax<br />
' jle L1<br />
' imul edx, eax, -4<br />
' mov DWORD PTR [ebp-32], edx<br />
' mov edx, eax<br />
' L7:<br />
' cmp DWORD PTR [ebp-20], edx<br />
' jle L14<br />
' lea edi, [ecx+edx*4]<br />
' mov ebx, DWORD PTR [ecx+8+edx*4]<br />
' mov DWORD PTR [ebp-16], edi<br />
' mov DWORD PTR [ebp-28], ebx<br />
' mov ebx, edx<br />
' L5:<br />
' cmp eax, ebx<br />
' jle L6<br />
' L9:<br />
' mov esi, DWORD PTR [ebp-28]<br />
' inc edx<br />
' mov DWORD PTR [ecx+8+ebx*4], esi<br />
' jmp L7<br />
' L6:<br />
' mov edi, ebx<br />
' mov esi, DWORD PTR [ebp-16]<br />
' sub edi, eax<br />
' mov DWORD PTR [ebp-36], edi<br />
' mov edi, DWORD PTR [ebp-32]<br />
' mov edi, DWORD PTR [esi+8+edi]<br />
' mov DWORD PTR [ebp-24], edi<br />
' mov edi, DWORD PTR [ebp-28]<br />
' mov esi, DWORD PTR [ebp-24]<br />
' mov esi, DWORD PTR [esi]<br />
' cmp DWORD PTR [edi], esi<br />
' jge L9<br />
' mov ebx, DWORD PTR [ebp-16]<br />
' mov esi, DWORD PTR [ebp-24]<br />
' mov DWORD PTR [ebx+8], esi<br />
' mov ebx, DWORD PTR [ebp-32]<br />
' add DWORD PTR [ebp-16], ebx<br />
' mov ebx, DWORD PTR [ebp-36]<br />
' jmp L5<br />
' L1:<br />
' leave<br />
' ret 4<br />
<br />
<br />
.子程序 __启动窗口_创建完毕<br />
.局部变量 键数组, 整数型, , "0", 要排序的键，到小到大排序<br />
.局部变量 值数组, 整数型, , "0", 值跟键永远绑定在一起的<br />
.局部变量 排序数组, 排序对象, , "0"<br />
.局部变量 数, 整数型<br />
<br />
键数组 ＝ { 4, 1, 3, 2 }<br />
值数组 ＝ { 7777, 5555, 8888, 6666 }<br />
重定义数组 (排序数组, 假, 取数组成员数 (键数组))<br />
.计次循环首 (取数组成员数 (排序数组), 数)<br />
    排序数组 [数].键 ＝ 键数组 [数]<br />
    排序数组 [数].值 ＝ 值数组 [数]<br />
    调试输出 (排序数组 [数].键, 排序数组 [数].值)<br />
.计次循环尾 ()<br />
调试输出 (“------”)<br />
希尔排序 (排序数组)<br />
.计次循环首 (取数组成员数 (排序数组), 数)<br />
    调试输出 (排序数组 [数].键, 排序数组 [数].值)<br />
.计次循环尾 ()

开始运行被调试程序
* 4 | 7777
* 1 | 5555
* 3 | 8888
* 2 | 6666
* “------”
* 1 | 5555
* 2 | 6666
* 3 | 8888
* 4 | 7777
被调试易程序运行完毕

例子.zip (2.27 KB, 下载次数: 4)

RainCharm · 发表于 2025-11-29 13:34:00

子程序名	返回值类型	公开	备注
__启动窗口_创建完毕

排序键 ({ 4, 1, 3, 2 }, { 7777, 5555, 8888, 6666 })

子程序名	返回值类型	公开	备注
排序键			键组和值组的成员数一致
参数名	类型	参考	可空	数组	备注
键数组	整数型				要排序的键，到小到大排序
值数组	整数型				值跟键永远绑定在一起的

变量名	类型	静态	数组	备注
键数组1	整数型		0
值数组1	整数型		0

键数组1 ＝键数组
值数组1 ＝值数组
数组排序 (键数组1, 真)
数组排序 (值数组1, 真)
调试输出 (“——————排序前——————”)
调试输出 (键数组, 值数组)
调试输出 (“——————排序后——————”)
调试输出 (键数组1, 值数组1)
开始运行被调试程序
* “——————排序前——————”
* 数组:4{4,1,3,2} | 数组:4{7777,5555,8888,6666}
* “——————排序后——————”
* 数组:4{1,2,3,4} | 数组:4{5555,6666,7777,8888}
被调试易程序运行完毕

i支持库列表	支持库注释
spec	特殊功能支持库

这个原生易语言命令，速度极快，最主要的是简单易懂

RainCharm · 发表于 2025-11-29 13:40:22

测试后这个命令应该属于汇编类型的，原生命令看不到代码

SSS777 · 发表于 2025-11-29 17:33:58

循环1000万次测速：
ZxcArray排序键,耗时：23613
Hasn排序键,耗时：4329
排序键_冒泡ASM,耗时：149
希尔排序,耗时：919

SSS777 · 发表于 2025-11-29 17:34:39

zzoo1314 发表于 2025-11-29 07:57
[e=2].版本 2
.支持库 spec

还是感谢您的热情！

		自动登录	找回密码
密码			注册

[已解决] 排序键数组，换成易代码，最好是汇编，有哪位帮忙弄下？

最佳答案

评分