通用排序 流程设计完毕

笨来无一悟

通用排序 流程设计完毕具体的排序算法过程可以自己设计 也可以引用现成的 比如落大佬的数组操作ASM 这样设计感觉合理多了 可惜第三个参数还得手动填写 不能自动判断 用户不小心没核对第二个和第三个参数的成员名 就极有可能导致出错 这里不够完美@Suky  @7ian @呵呵仙 @小白弟弟 @神女软件定制 @凌哥 @qck易语言

https://xzt168.lanzouj.com/ij9sR23via8d

↑ 通用型 必须从源码文件里面复制的才能用 只能传文件 里面是具体的引用示例 ↑

  

子程序名	返回值类型	公开	备 注
通用排序	逻辑型		通用排序 ( 变量名 , 变量名[1].成员名 , 取运行时数据类型( 变量名[1].成员名 ) , 真 / 假 )
参数名	类 型	参考	可空	数组	备 注
待排数组	通用型				变量名
数据成员	通用型				变量名[1].成员名
数据类型	整数型				取运行时数据类型 ( 变量名[1].成员名 )
真升假降	逻辑型				真 = 升序 ( 从小到大 ) 假 = 降序 ( 从大到小 )

变量名	类 型	静态	数组	备 注
局_地址	整数型			赋值0 不可省略 不可更改顺序 局部变量初始化 [ebp-4]
局_偏移	整数型			赋值0 不可省略 不可更改顺序 局部变量初始化 [ebp-8]

局_地址 ＝ 0
局_偏移 ＝ 0
置入代码 ({ 139, 69, 8, 137, 69, 252, 139, 0, 131, 192, 8, 139, 0, 139, 93, 12, 41, 195, 137, 93, 248 })  ' 地址 偏移 赋值
判断 (数据类型 ＝ 十六进制 (“00000000”))  ' 空类型
返回 (假)
判断 (数据类型 ＝ 十六进制 (“80000000”))  ' 通用型
返回 (假)
判断 (数据类型 ＝ 十六进制 (“80000101”))  ' 字节型
判断 (数据类型 ＝ 十六进制 (“80000201”))  ' 短整数
判断 (数据类型 ＝ 十六进制 (“80000301”))  ' 整数型
判断 (数据类型 ＝ 十六进制 (“80000401”))  ' 长整数
判断 (数据类型 ＝ 十六进制 (“80000501”))  ' 小数型
判断 (数据类型 ＝ 十六进制 (“80000601”))  ' 双精度
判断 (数据类型 ＝ 十六进制 (“80000001”))  ' 数值型
返回 (假)
判断 (数据类型 ＝ 十六进制 (“80000002”))  ' 逻辑型
返回 (假)
判断 (数据类型 ＝ 十六进制 (“80000003”))  ' 时间型
判断 (数据类型 ＝ 十六进制 (“80000004”))  ' 文本型
判断 (数据类型 ＝ 十六进制 (“80000005”))  ' 字节集
返回 (假)
判断 (数据类型 ＝ 十六进制 (“80000006”))  ' 子程序
返回 (假)
判断 (数据类型 ＝ 十六进制 (“80000007”))  ' 参考型
返回 (假)
返回 (假)

.版本 2<br /> <br /> .子程序 通用排序, 逻辑型, 公开, 通用排序 ( 变量名 , 变量名[1].成员名 , 取运行时数据类型( 变量名[1].成员名 ) , 真 / 假 )<br /> .参数 待排数组, 通用型, 数组, 变量名<br /> .参数 数据成员, 通用型, 参考, 变量名[1].成员名<br /> .参数 数据类型, 整数型, , 取运行时数据类型 ( 变量名[1].成员名 )<br /> .参数 真升假降, 逻辑型, , 真 = 升序 ( 从小到大 ) 假 = 降序 ( 从大到小 )<br /> .局部变量 局_地址, 整数型, , , 赋值0 不可省略 不可更改顺序 局部变量初始化 [ebp-4]<br /> .局部变量 局_偏移, 整数型, , , 赋值0 不可省略 不可更改顺序 局部变量初始化 [ebp-8]<br /> <br /> 局_地址 ＝ 0<br /> 局_偏移 ＝ 0<br /> 置入代码 ({ 139, 69, 8, 137, 69, 252, 139, 0, 131, 192, 8, 139, 0, 139, 93, 12, 41, 195, 137, 93, 248 })  ' 地址 偏移 赋值<br /> .判断开始 (数据类型 ＝ 十六进制 (“00000000”))  ' 空类型<br />     返回 (假)<br /> .判断 (数据类型 ＝ 十六进制 (“80000000”))  ' 通用型<br />     返回 (假)<br /> .判断 (数据类型 ＝ 十六进制 (“80000101”))  ' 字节型<br /> <br /> .判断 (数据类型 ＝ 十六进制 (“80000201”))  ' 短整数<br /> <br /> .判断 (数据类型 ＝ 十六进制 (“80000301”))  ' 整数型<br /> <br /> .判断 (数据类型 ＝ 十六进制 (“80000401”))  ' 长整数<br /> <br /> .判断 (数据类型 ＝ 十六进制 (“80000501”))  ' 小数型<br /> <br /> .判断 (数据类型 ＝ 十六进制 (“80000601”))  ' 双精度<br /> <br /> .判断 (数据类型 ＝ 十六进制 (“80000001”))  ' 数值型<br />     返回 (假)<br /> .判断 (数据类型 ＝ 十六进制 (“80000002”))  ' 逻辑型<br />     返回 (假)<br /> .判断 (数据类型 ＝ 十六进制 (“80000003”))  ' 时间型<br /> <br /> .判断 (数据类型 ＝ 十六进制 (“80000004”))  ' 文本型<br /> <br /> .判断 (数据类型 ＝ 十六进制 (“80000005”))  ' 字节集<br />     返回 (假)<br /> .判断 (数据类型 ＝ 十六进制 (“80000006”))  ' 子程序<br />     返回 (假)<br /> .判断 (数据类型 ＝ 十六进制 (“80000007”))  ' 参考型<br />     返回 (假)<br /> .默认<br />     返回 (假)<br /> .判断结束

来自群组: 热心网友

笨来无一悟

排序模版 引用 具体实现过程 的 示例 ↓ 只能看看 别复制 复制到易语言也跑不起来的通用型要易语言自己生成的或者易源码里面复制的才跑的起来

  

窗口程序集名	保 留	保 留	备 注
窗口程序集_启动窗口
变量名	类 型	数组	备 注
猪圈	大肥猪	10

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

变量名	类 型	静态	数组	备 注
计次	整数型

置随机数种子 ()
计次循环首 (取数组成员数 (猪圈), 计次)
猪圈 [计次].体重 ＝ 取随机数 (10, 100)
计次循环尾 ()
计次循环首 (取数组成员数 (猪圈), 计次)
调试输出 (猪圈 [计次].体重, “排序前”)
计次循环尾 ()
调试输出 (“分割符”)
通用排序 (猪圈, 猪圈 [1].体重, 取运行时数据类型 (猪圈 [1].体重), 真)
计次循环首 (取数组成员数 (猪圈), 计次)
调试输出 (猪圈 [计次].体重, “排序后”)
计次循环尾 ()

子程序名	返回值类型	公开	备 注
通用排序	逻辑型		通用排序 ( 变量名 , 变量名[1].成员名 , 取运行时数据类型( 变量名[1].成员名 ) , 真 / 假 )
参数名	类 型	参考	可空	数组	备 注
待排数组	通用型				变量名
数据成员	通用型				变量名[1].成员名
数据类型	整数型				取运行时数据类型 ( 变量名[1].成员名 )
真升假降	逻辑型				真 = 升序 ( 从小到大 ) 假 = 降序 ( 从大到小 )

变量名	类 型	静态	数组	备 注
局_地址	整数型			赋值0 不可省略 不可更改顺序 局部变量初始化 [ebp-4]
局_偏移	整数型			赋值0 不可省略 不可更改顺序 局部变量初始化 [ebp-8]

局_地址 ＝ 0
局_偏移 ＝ 0
置入代码 ({ 139, 69, 8, 137, 69, 252, 139, 0, 131, 192, 8, 139, 0, 139, 93, 12, 41, 195, 137, 93, 248 })  ' 地址 偏移 赋值
判断 (数据类型 ＝ 十六进制 (“00000000”))  ' 空类型
返回 (假)
判断 (数据类型 ＝ 十六进制 (“80000000”))  ' 通用型
返回 (假)
判断 (数据类型 ＝ 十六进制 (“80000101”))  ' 字节型
判断 (数据类型 ＝ 十六进制 (“80000201”))  ' 短整数
判断 (数据类型 ＝ 十六进制 (“80000301”))  ' 整数型
' 数组_排序I_自定义_ASM (待排数组, 局_偏移, 真升假降)  ' 其他的类型也这样引用
数组_排序I_自定义_ASM_传地址 (局_地址, 局_偏移, 真升假降)
' 返回 (排序_整数型 (局_地址, 局_偏移, 真升假降))
判断 (数据类型 ＝ 十六进制 (“80000401”))  ' 长整数
判断 (数据类型 ＝ 十六进制 (“80000501”))  ' 小数型
判断 (数据类型 ＝ 十六进制 (“80000601”))  ' 双精度
判断 (数据类型 ＝ 十六进制 (“80000001”))  ' 数值型
返回 (假)
判断 (数据类型 ＝ 十六进制 (“80000002”))  ' 逻辑型
返回 (假)
判断 (数据类型 ＝ 十六进制 (“80000003”))  ' 时间型
判断 (数据类型 ＝ 十六进制 (“80000004”))  ' 文本型
判断 (数据类型 ＝ 十六进制 (“80000005”))  ' 字节集
返回 (假)
判断 (数据类型 ＝ 十六进制 (“80000006”))  ' 子程序
返回 (假)
判断 (数据类型 ＝ 十六进制 (“80000007”))  ' 参考型
返回 (假)
返回 (假)
返回 (假)  ' 排序成功 返回(真) 不支持排序 或者 已废弃的类型 一律 返回(假) 这行是拿来骗编译器的 等每个分支都写好代码了 可删

子程序名	返回值类型	公开	备 注
排序_整数型	逻辑型		模版
参数名	类 型	参考	可空	数组	备 注
参_地址	整数型				地址 + 4 = 成员数 地址 + 8 = 数组[1].第一个成员
参_偏移	整数型
参_升降	逻辑型

' 可以自己写排序过程 也可以调用 落 的 数组操作_ASM_1.5.e
' 听说个别情况 数组相对有序的时候 快速排序会朝着冒泡排序的速度退化 看看能不能搞的好归并的写法
' 本模版 和 数组_排序I_自定义_ASM_传地址( ) 参数填写调用方式相同 例 : 排序_整数型 (局_地址, 局_偏移, 真升假降)
返回 (真)

子程序名	返回值类型	公开	备 注
数组_排序I_自定义_ASM			自定义数组整数排序(快速排序)
参数名	类 型	参考	可空	数组	备 注
参_自定义数据数组	通用型				只支持一维数组
参_数据偏移	整数型				第一个数据类型偏移为0，后面偏移根据前一个数据类型的长度递增
参_方向	逻辑型				真=从小到大排序 假=从大到小排序，默认值为真。

' 特别说明自定义数据内，任何类型都至少占4字节，即字节型、短整数型，要按4偏移算
判断 (参_方向 或 是否为空 (参_方向))
' 从小到大
置入代码 ({ 139, 77, 8, 139, 9, 227, 27, 131, 57, 1, 117, 22, 139, 81, 4, 133, 210, 116, 15, 131, 193, 8, 74, 255, 117, 12, 82, 51, 210, 232, 4, 0, 0, 0, 201, 194, 16, 0, 86, 87, 83, 85, 131, 236, 8, 139, 233, 139, 68, 36, 32, 139, 216, 139, 116, 36, 28, 235, 2, 139, 215, 139, 250, 141, 12, 22, 209, 233, 139, 198, 139, 76, 141, 0, 59, 214, 119, 84, 137, 20, 36, 139, 116, 189, 0, 139, 20, 25, 59, 20, 30, 126, 10, 71, 139, 116, 189, 0, 59, 20, 30, 127, 246, 133, 192, 116, 87, 137, 124, 36, 4, 139, 124, 133, 0, 59, 20, 31, 125, 64, 72, 117, 244, 139, 124, 36, 4, 59, 248, 119, 24, 139, 84, 133, 0, 137, 84, 189, 0, 71, 137, 116, 133, 0, 51, 246, 59, 240, 131, 216, 0, 59, 248, 118, 182, 139, 116, 36, 28, 139, 20, 36, 141, 71, 255, 59, 208, 115, 9, 83, 139, 205, 80, 232, 116, 255, 255, 255, 59, 254, 114, 133, 235, 16, 139, 124, 36, 4, 59, 248, 118, 195, 235, 217, 59, 248, 118, 189, 235, 211, 131, 196, 8, 93, 91, 95, 94, 194, 8, 0 })
' 从大到小
置入代码 ({ 139, 77, 8, 139, 9, 227, 27, 131, 57, 1, 117, 22, 139, 81, 4, 133, 210, 116, 15, 131, 193, 8, 74, 255, 117, 12, 82, 51, 210, 232, 4, 0, 0, 0, 201, 194, 16, 0, 86, 87, 83, 85, 131, 236, 8, 139, 233, 139, 68, 36, 32, 139, 216, 139, 116, 36, 28, 235, 2, 139, 215, 139, 250, 141, 12, 22, 209, 233, 139, 198, 139, 76, 141, 0, 59, 214, 119, 84, 137, 20, 36, 139, 116, 189, 0, 139, 20, 25, 59, 20, 30, 125, 10, 71, 139, 116, 189, 0, 59, 20, 30, 124, 246, 133, 192, 116, 87, 137, 124, 36, 4, 139, 124, 133, 0, 59, 20, 31, 126, 64, 72, 117, 244, 139, 124, 36, 4, 59, 248, 119, 24, 139, 84, 133, 0, 137, 84, 189, 0, 71, 137, 116, 133, 0, 51, 246, 59, 240, 131, 216, 0, 59, 248, 118, 182, 139, 116, 36, 28, 139, 20, 36, 141, 71, 255, 59, 208, 115, 9, 83, 139, 205, 80, 232, 116, 255, 255, 255, 59, 254, 114, 133, 235, 16, 139, 124, 36, 4, 59, 248, 118, 195, 235, 217, 59, 248, 118, 189, 235, 211, 131, 196, 8, 93, 91, 95, 94, 194, 8, 0 })
' (原版引用方式) 出自 数组操作_ASM_1.5 作者:落

子程序名	返回值类型	公开	备 注
数组_排序I_自定义_ASM_传地址			自定义数组整数排序(快速排序)
参数名	类 型	参考	可空	数组	备 注
参_自定义数据数组	整数型				只支持一维数组
参_数据偏移	整数型				第一个数据类型偏移为0，后面偏移根据前一个数据类型的长度递增
参_方向	逻辑型				真=从小到大排序 假=从大到小排序，默认值为真。

' 特别说明自定义数据内，任何类型都至少占4字节，即字节型、短整数型，要按4偏移算
判断 (参_方向 或 是否为空 (参_方向))
' 从小到大
置入代码 ({ 139, 77, 8, 139, 9, 227, 27, 131, 57, 1, 117, 22, 139, 81, 4, 133, 210, 116, 15, 131, 193, 8, 74, 255, 117, 12, 82, 51, 210, 232, 4, 0, 0, 0, 201, 194, 16, 0, 86, 87, 83, 85, 131, 236, 8, 139, 233, 139, 68, 36, 32, 139, 216, 139, 116, 36, 28, 235, 2, 139, 215, 139, 250, 141, 12, 22, 209, 233, 139, 198, 139, 76, 141, 0, 59, 214, 119, 84, 137, 20, 36, 139, 116, 189, 0, 139, 20, 25, 59, 20, 30, 126, 10, 71, 139, 116, 189, 0, 59, 20, 30, 127, 246, 133, 192, 116, 87, 137, 124, 36, 4, 139, 124, 133, 0, 59, 20, 31, 125, 64, 72, 117, 244, 139, 124, 36, 4, 59, 248, 119, 24, 139, 84, 133, 0, 137, 84, 189, 0, 71, 137, 116, 133, 0, 51, 246, 59, 240, 131, 216, 0, 59, 248, 118, 182, 139, 116, 36, 28, 139, 20, 36, 141, 71, 255, 59, 208, 115, 9, 83, 139, 205, 80, 232, 116, 255, 255, 255, 59, 254, 114, 133, 235, 16, 139, 124, 36, 4, 59, 248, 118, 195, 235, 217, 59, 248, 118, 189, 235, 211, 131, 196, 8, 93, 91, 95, 94, 194, 8, 0 })
' 从大到小
置入代码 ({ 139, 77, 8, 139, 9, 227, 27, 131, 57, 1, 117, 22, 139, 81, 4, 133, 210, 116, 15, 131, 193, 8, 74, 255, 117, 12, 82, 51, 210, 232, 4, 0, 0, 0, 201, 194, 16, 0, 86, 87, 83, 85, 131, 236, 8, 139, 233, 139, 68, 36, 32, 139, 216, 139, 116, 36, 28, 235, 2, 139, 215, 139, 250, 141, 12, 22, 209, 233, 139, 198, 139, 76, 141, 0, 59, 214, 119, 84, 137, 20, 36, 139, 116, 189, 0, 139, 20, 25, 59, 20, 30, 125, 10, 71, 139, 116, 189, 0, 59, 20, 30, 124, 246, 133, 192, 116, 87, 137, 124, 36, 4, 139, 124, 133, 0, 59, 20, 31, 126, 64, 72, 117, 244, 139, 124, 36, 4, 59, 248, 119, 24, 139, 84, 133, 0, 137, 84, 189, 0, 71, 137, 116, 133, 0, 51, 246, 59, 240, 131, 216, 0, 59, 248, 118, 182, 139, 116, 36, 28, 139, 20, 36, 141, 71, 255, 59, 208, 115, 9, 83, 139, 205, 80, 232, 116, 255, 255, 255, 59, 254, 114, 133, 235, 16, 139, 124, 36, 4, 59, 248, 118, 195, 235, 217, 59, 248, 118, 189, 235, 211, 131, 196, 8, 93, 91, 95, 94, 194, 8, 0 })
' (改版引用方式) 出自 数组操作_ASM_1.5 作者:落 勾选数组或者参考的时候默认就是传址 第一个参数 通用型改整数型(不改也行) 上层调用之前 把地址存到局部整数变量 直接传值就和传址一个效果了

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

.版本 2<br /> .支持库 spec<br /> <br /> .程序集 窗口程序集_启动窗口<br /> .程序集变量 猪圈, 大肥猪, , "10"<br /> <br /> .子程序 __启动窗口_创建完毕<br /> .局部变量 计次, 整数型<br /> <br /> 置随机数种子 ()<br /> .计次循环首 (取数组成员数 (猪圈), 计次)<br />     猪圈 [计次].体重 ＝ 取随机数 (10, 100)<br /> .计次循环尾 ()<br /> <br /> .计次循环首 (取数组成员数 (猪圈), 计次)<br />     调试输出 (猪圈 [计次].体重, “排序前”)<br /> .计次循环尾 ()<br /> <br /> 调试输出 (“分割符”)<br /> <br /> 通用排序 (猪圈, 猪圈 [1].体重, 取运行时数据类型 (猪圈 [1].体重), 真)<br /> <br /> .计次循环首 (取数组成员数 (猪圈), 计次)<br />     调试输出 (猪圈 [计次].体重, “排序后”)<br /> .计次循环尾 ()<br /> <br /> .子程序 通用排序, 逻辑型, 公开, 通用排序 ( 变量名 , 变量名[1].成员名 , 取运行时数据类型( 变量名[1].成员名 ) , 真 / 假 )<br /> .参数 待排数组, 通用型, 数组, 变量名<br /> .参数 数据成员, 通用型, 参考, 变量名[1].成员名<br /> .参数 数据类型, 整数型, , 取运行时数据类型 ( 变量名[1].成员名 )<br /> .参数 真升假降, 逻辑型, , 真 = 升序 ( 从小到大 ) 假 = 降序 ( 从大到小 )<br /> .局部变量 局_地址, 整数型, , , 赋值0 不可省略 不可更改顺序 局部变量初始化 [ebp-4]<br /> .局部变量 局_偏移, 整数型, , , 赋值0 不可省略 不可更改顺序 局部变量初始化 [ebp-8]<br /> <br /> 局_地址 ＝ 0<br /> 局_偏移 ＝ 0<br /> 置入代码 ({ 139, 69, 8, 137, 69, 252, 139, 0, 131, 192, 8, 139, 0, 139, 93, 12, 41, 195, 137, 93, 248 })  ' 地址 偏移 赋值<br /> .判断开始 (数据类型 ＝ 十六进制 (“00000000”))  ' 空类型<br />     返回 (假)<br /> .判断 (数据类型 ＝ 十六进制 (“80000000”))  ' 通用型<br />     返回 (假)<br /> .判断 (数据类型 ＝ 十六进制 (“80000101”))  ' 字节型<br /> <br /> .判断 (数据类型 ＝ 十六进制 (“80000201”))  ' 短整数<br /> <br /> .判断 (数据类型 ＝ 十六进制 (“80000301”))  ' 整数型<br /> <br />     ' 数组_排序I_自定义_ASM (待排数组, 局_偏移, 真升假降)  ' 其他的类型也这样引用<br /> <br />     数组_排序I_自定义_ASM_传地址 (局_地址, 局_偏移, 真升假降)<br /> <br />     ' 返回 (排序_整数型 (局_地址, 局_偏移, 真升假降))<br /> <br /> .判断 (数据类型 ＝ 十六进制 (“80000401”))  ' 长整数<br /> <br /> .判断 (数据类型 ＝ 十六进制 (“80000501”))  ' 小数型<br /> <br /> .判断 (数据类型 ＝ 十六进制 (“80000601”))  ' 双精度<br /> <br /> .判断 (数据类型 ＝ 十六进制 (“80000001”))  ' 数值型<br />     返回 (假)<br /> .判断 (数据类型 ＝ 十六进制 (“80000002”))  ' 逻辑型<br />     返回 (假)<br /> .判断 (数据类型 ＝ 十六进制 (“80000003”))  ' 时间型<br /> <br /> .判断 (数据类型 ＝ 十六进制 (“80000004”))  ' 文本型<br /> <br /> .判断 (数据类型 ＝ 十六进制 (“80000005”))  ' 字节集<br />     返回 (假)<br /> .判断 (数据类型 ＝ 十六进制 (“80000006”))  ' 子程序<br />     返回 (假)<br /> .判断 (数据类型 ＝ 十六进制 (“80000007”))  ' 参考型<br />     返回 (假)<br /> .默认<br />     返回 (假)<br /> .判断结束<br /> 返回 (假)  ' 排序成功 返回(真) 不支持排序 或者 已废弃的类型 一律 返回(假) 这行是拿来骗编译器的 等每个分支都写好代码了 可删<br /> <br /> .子程序 排序_整数型, 逻辑型, , 模版<br /> .参数 参_地址, 整数型, , 地址 + 4 = 成员数 地址 + 8 = 数组[1].第一个成员<br /> .参数 参_偏移, 整数型<br /> .参数 参_升降, 逻辑型<br /> <br /> ' 可以自己写排序过程 也可以调用 落 的 数组操作_ASM_1.5.e<br /> ' 听说个别情况 数组相对有序的时候 快速排序会朝着冒泡排序的速度退化 看看能不能搞的好归并的写法<br /> ' 本模版 和 数组_排序I_自定义_ASM_传地址( ) 参数填写调用方式相同 例 : 排序_整数型 (局_地址, 局_偏移, 真升假降)<br /> 返回 (真)<br /> <br /> .子程序 数组_排序I_自定义_ASM, , , 自定义数组整数排序(快速排序)<br /> .参数 参_自定义数据数组, 通用型, 参考 数组, 只支持一维数组<br /> .参数 参_数据偏移, 整数型, , 第一个数据类型偏移为0，后面偏移根据前一个数据类型的长度递增<br /> .参数 参_方向, 逻辑型, 可空, 真=从小到大排序 假=从大到小排序，默认值为真。<br /> <br /> ' 特别说明自定义数据内，任何类型都至少占4字节，即字节型、短整数型，要按4偏移算<br /> .判断开始 (参_方向 或 是否为空 (参_方向))<br />     ' 从小到大<br />     置入代码 ({ 139, 77, 8, 139, 9, 227, 27, 131, 57, 1, 117, 22, 139, 81, 4, 133, 210, 116, 15, 131, 193, 8, 74, 255, 117, 12, 82, 51, 210, 232, 4, 0, 0, 0, 201, 194, 16, 0, 86, 87, 83, 85, 131, 236, 8, 139, 233, 139, 68, 36, 32, 139, 216, 139, 116, 36, 28, 235, 2, 139, 215, 139, 250, 141, 12, 22, 209, 233, 139, 198, 139, 76, 141, 0, 59, 214, 119, 84, 137, 20, 36, 139, 116, 189, 0, 139, 20, 25, 59, 20, 30, 126, 10, 71, 139, 116, 189, 0, 59, 20, 30, 127, 246, 133, 192, 116, 87, 137, 124, 36, 4, 139, 124, 133, 0, 59, 20, 31, 125, 64, 72, 117, 244, 139, 124, 36, 4, 59, 248, 119, 24, 139, 84, 133, 0, 137, 84, 189, 0, 71, 137, 116, 133, 0, 51, 246, 59, 240, 131, 216, 0, 59, 248, 118, 182, 139, 116, 36, 28, 139, 20, 36, 141, 71, 255, 59, 208, 115, 9, 83, 139, 205, 80, 232, 116, 255, 255, 255, 59, 254, 114, 133, 235, 16, 139, 124, 36, 4, 59, 248, 118, 195, 235, 217, 59, 248, 118, 189, 235, 211, 131, 196, 8, 93, 91, 95, 94, 194, 8, 0 })<br /> .默认<br />     ' 从大到小<br />     置入代码 ({ 139, 77, 8, 139, 9, 227, 27, 131, 57, 1, 117, 22, 139, 81, 4, 133, 210, 116, 15, 131, 193, 8, 74, 255, 117, 12, 82, 51, 210, 232, 4, 0, 0, 0, 201, 194, 16, 0, 86, 87, 83, 85, 131, 236, 8, 139, 233, 139, 68, 36, 32, 139, 216, 139, 116, 36, 28, 235, 2, 139, 215, 139, 250, 141, 12, 22, 209, 233, 139, 198, 139, 76, 141, 0, 59, 214, 119, 84, 137, 20, 36, 139, 116, 189, 0, 139, 20, 25, 59, 20, 30, 125, 10, 71, 139, 116, 189, 0, 59, 20, 30, 124, 246, 133, 192, 116, 87, 137, 124, 36, 4, 139, 124, 133, 0, 59, 20, 31, 126, 64, 72, 117, 244, 139, 124, 36, 4, 59, 248, 119, 24, 139, 84, 133, 0, 137, 84, 189, 0, 71, 137, 116, 133, 0, 51, 246, 59, 240, 131, 216, 0, 59, 248, 118, 182, 139, 116, 36, 28, 139, 20, 36, 141, 71, 255, 59, 208, 115, 9, 83, 139, 205, 80, 232, 116, 255, 255, 255, 59, 254, 114, 133, 235, 16, 139, 124, 36, 4, 59, 248, 118, 195, 235, 217, 59, 248, 118, 189, 235, 211, 131, 196, 8, 93, 91, 95, 94, 194, 8, 0 })<br /> .判断结束<br /> ' (原版引用方式) 出自 数组操作_ASM_1.5 作者:落<br /> <br /> .子程序 数组_排序I_自定义_ASM_传地址, , , 自定义数组整数排序(快速排序)<br /> .参数 参_自定义数据数组, 整数型, , 只支持一维数组<br /> .参数 参_数据偏移, 整数型, , 第一个数据类型偏移为0，后面偏移根据前一个数据类型的长度递增<br /> .参数 参_方向, 逻辑型, 可空, 真=从小到大排序 假=从大到小排序，默认值为真。<br /> <br /> ' 特别说明自定义数据内，任何类型都至少占4字节，即字节型、短整数型，要按4偏移算<br /> .判断开始 (参_方向 或 是否为空 (参_方向))<br />     ' 从小到大<br />     置入代码 ({ 139, 77, 8, 139, 9, 227, 27, 131, 57, 1, 117, 22, 139, 81, 4, 133, 210, 116, 15, 131, 193, 8, 74, 255, 117, 12, 82, 51, 210, 232, 4, 0, 0, 0, 201, 194, 16, 0, 86, 87, 83, 85, 131, 236, 8, 139, 233, 139, 68, 36, 32, 139, 216, 139, 116, 36, 28, 235, 2, 139, 215, 139, 250, 141, 12, 22, 209, 233, 139, 198, 139, 76, 141, 0, 59, 214, 119, 84, 137, 20, 36, 139, 116, 189, 0, 139, 20, 25, 59, 20, 30, 126, 10, 71, 139, 116, 189, 0, 59, 20, 30, 127, 246, 133, 192, 116, 87, 137, 124, 36, 4, 139, 124, 133, 0, 59, 20, 31, 125, 64, 72, 117, 244, 139, 124, 36, 4, 59, 248, 119, 24, 139, 84, 133, 0, 137, 84, 189, 0, 71, 137, 116, 133, 0, 51, 246, 59, 240, 131, 216, 0, 59, 248, 118, 182, 139, 116, 36, 28, 139, 20, 36, 141, 71, 255, 59, 208, 115, 9, 83, 139, 205, 80, 232, 116, 255, 255, 255, 59, 254, 114, 133, 235, 16, 139, 124, 36, 4, 59, 248, 118, 195, 235, 217, 59, 248, 118, 189, 235, 211, 131, 196, 8, 93, 91, 95, 94, 194, 8, 0 })<br /> .默认<br />     ' 从大到小<br />     置入代码 ({ 139, 77, 8, 139, 9, 227, 27, 131, 57, 1, 117, 22, 139, 81, 4, 133, 210, 116, 15, 131, 193, 8, 74, 255, 117, 12, 82, 51, 210, 232, 4, 0, 0, 0, 201, 194, 16, 0, 86, 87, 83, 85, 131, 236, 8, 139, 233, 139, 68, 36, 32, 139, 216, 139, 116, 36, 28, 235, 2, 139, 215, 139, 250, 141, 12, 22, 209, 233, 139, 198, 139, 76, 141, 0, 59, 214, 119, 84, 137, 20, 36, 139, 116, 189, 0, 139, 20, 25, 59, 20, 30, 125, 10, 71, 139, 116, 189, 0, 59, 20, 30, 124, 246, 133, 192, 116, 87, 137, 124, 36, 4, 139, 124, 133, 0, 59, 20, 31, 126, 64, 72, 117, 244, 139, 124, 36, 4, 59, 248, 119, 24, 139, 84, 133, 0, 137, 84, 189, 0, 71, 137, 116, 133, 0, 51, 246, 59, 240, 131, 216, 0, 59, 248, 118, 182, 139, 116, 36, 28, 139, 20, 36, 141, 71, 255, 59, 208, 115, 9, 83, 139, 205, 80, 232, 116, 255, 255, 255, 59, 254, 114, 133, 235, 16, 139, 124, 36, 4, 59, 248, 118, 195, 235, 217, 59, 248, 118, 189, 235, 211, 131, 196, 8, 93, 91, 95, 94, 194, 8, 0 })<br /> .判断结束<br /> ' (改版引用方式) 出自 数组操作_ASM_1.5 作者:落 勾选数组或者参考的时候默认就是传址 第一个参数 通用型改整数型(不改也行) 上层调用之前 把地址存到局部整数变量 直接传值就和传址一个效果了

  

数据类型名	公开	备 注
大肥猪
成员名	类 型	传址	数组	备 注
腰围	小数型
体重	整数型
身高	小数型

.版本 2<br /> <br /> .数据类型 大肥猪<br />     .成员 腰围, 小数型<br />     .成员 体重, 整数型<br />     .成员 身高, 小数型

笨来无一悟

shituo 发表于 2024-7-8 16:07
你这个 空间返回值都少了几个吧

通用排序模版 又小改了一下 自己会写排序算法的可以自己写 不会的也可以直接参考示例 引用落大佬的 数组操作_ASM_1.5个人感觉还能再快一点点 打算多测试几种写法 选一个平均时间表现最好的非常确定还能更快 不过具体能快多少 不知道了测试完毕再发个正式版本

  

' 类型不支持 返回 ( 假 ) 排序成功 返回 ( 真 )
' 排序前 如果真 ( 取数组成员数 ( 变量名 ) ＞ 0 )
' 数据成员 与 数据类型 变量名[1].成员名 需要 保持一致 否则也许不会返回假↓
' 更可怕的是 → 读取 空指针 导致 软件闪退 所以请 严格检查 第二个 和 第三个 参数

子程序名	返回值类型	公开	备 注
通用排序	逻辑型		通用排序 ( 变量名 , 变量名[1].成员名 , 取运行时数据类型( 变量名[1].成员名 ) , 真 / 假 )
参数名	类 型	参考	可空	数组	备 注
待排数组	通用型				变量名
数据成员	通用型				变量名[1].成员名
数据类型	整数型				取运行时数据类型 ( 变量名[1].成员名 )
真升假降	逻辑型				真 = 升序 ( 从小到大 ) 假 = 降序 ( 从大到小 )

变量名	类 型	静态	数组	备 注
局_地址	整数型			赋值0 不可省略 不可更改顺序 局部变量初始化 [ebp-4]
局_偏移	整数型			赋值0 不可省略 不可更改顺序 局部变量初始化 [ebp-8]
局_失败	逻辑型

局_地址 ＝ 0
局_偏移 ＝ 0
局_失败 ＝ 假  ' 默认就是假 强迫症患者 为了确保 万无一失
置入代码 ({ 139, 69, 8, 137, 69, 252, 139, 0, 131, 192, 8, 139, 0, 139, 93, 12, 41, 195, 137, 93, 248 })  ' 地址 偏移 赋值
判断 (数据类型 ＝ 十六进制 (“80000101”))  ' 字节型
排序_字节型 (局_地址, 局_偏移, 真升假降)
判断 (数据类型 ＝ 十六进制 (“80000201”))  ' 短整数
排序_短整数 (局_地址, 局_偏移, 真升假降)
判断 (数据类型 ＝ 十六进制 (“80000301”))  ' 整数型
排序_整数型 (局_地址, 局_偏移, 真升假降)
判断 (数据类型 ＝ 十六进制 (“80000401”))  ' 长整数
排序_长整数 (局_地址, 局_偏移, 真升假降)
判断 (数据类型 ＝ 十六进制 (“80000501”))  ' 小数型
排序_小数型 (局_地址, 局_偏移, 真升假降)
判断 (数据类型 ＝ 十六进制 (“80000601”))  ' 双精度
排序_双精度 (局_地址, 局_偏移, 真升假降)
判断 (数据类型 ＝ 十六进制 (“80000003”))  ' 时间型
排序_时间型 (局_地址, 局_偏移, 真升假降)
判断 (数据类型 ＝ 十六进制 (“80000004”))  ' 文本型
排序_文本型 (局_地址, 局_偏移, 真升假降)
局_失败 ＝ 真
返回 (取反 (局_失败))

子程序名	返回值类型	公开	备 注
排序_字节型			80000101
参数名	类 型	参考	可空	数组	备 注
参_地址	整数型
参_偏移	整数型
参_升降	逻辑型

判断 (参_升降)

子程序名	返回值类型	公开	备 注
排序_短整数			80000201
参数名	类 型	参考	可空	数组	备 注
参_地址	整数型
参_偏移	整数型
参_升降	逻辑型

判断 (参_升降)

子程序名	返回值类型	公开	备 注
排序_整数型			80000301
参数名	类 型	参考	可空	数组	备 注
参_地址	整数型
参_偏移	整数型
参_升降	逻辑型

判断 (参_升降)

子程序名	返回值类型	公开	备 注
排序_长整数			80000401
参数名	类 型	参考	可空	数组	备 注
参_地址	整数型
参_偏移	整数型
参_升降	逻辑型

判断 (参_升降)

子程序名	返回值类型	公开	备 注
排序_小数型			80000501
参数名	类 型	参考	可空	数组	备 注
参_地址	整数型
参_偏移	整数型
参_升降	逻辑型

判断 (参_升降)

子程序名	返回值类型	公开	备 注
排序_双精度			80000601
参数名	类 型	参考	可空	数组	备 注
参_地址	整数型
参_偏移	整数型
参_升降	逻辑型

判断 (参_升降)

子程序名	返回值类型	公开	备 注
排序_时间型			80000003
参数名	类 型	参考	可空	数组	备 注
参_地址	整数型
参_偏移	整数型
参_升降	逻辑型

判断 (参_升降)

子程序名	返回值类型	公开	备 注
排序_文本型			80000004
参数名	类 型	参考	可空	数组	备 注
参_地址	整数型
参_偏移	整数型
参_升降	逻辑型

判断 (参_升降)

.版本 2<br /> <br /> <br /> ' 类型不支持 返回 ( 假 ) 排序成功 返回 ( 真 )<br /> <br /> ' 排序前 如果真 ( 取数组成员数 ( 变量名 ) ＞ 0 )<br /> <br /> ' 数据成员 与 数据类型 变量名[1].成员名 需要 保持一致 否则也许不会返回假↓<br /> <br /> ' 更可怕的是 → 读取 空指针 导致 软件闪退 所以请 严格检查 第二个 和 第三个 参数<br /> <br /> <br /> .子程序 通用排序, 逻辑型, 公开, 通用排序 ( 变量名 , 变量名[1].成员名 , 取运行时数据类型( 变量名[1].成员名 ) , 真 / 假 )<br /> .参数 待排数组, 通用型, 数组, 变量名<br /> .参数 数据成员, 通用型, 参考, 变量名[1].成员名<br /> .参数 数据类型, 整数型, , 取运行时数据类型 ( 变量名[1].成员名 )<br /> .参数 真升假降, 逻辑型, , 真 = 升序 ( 从小到大 ) 假 = 降序 ( 从大到小 )<br /> .局部变量 局_地址, 整数型, , , 赋值0 不可省略 不可更改顺序 局部变量初始化 [ebp-4]<br /> .局部变量 局_偏移, 整数型, , , 赋值0 不可省略 不可更改顺序 局部变量初始化 [ebp-8]<br /> .局部变量 局_失败, 逻辑型<br /> <br /> 局_地址 ＝ 0<br /> 局_偏移 ＝ 0<br /> 局_失败 ＝ 假  ' 默认就是假 强迫症患者 为了确保 万无一失<br /> 置入代码 ({ 139, 69, 8, 137, 69, 252, 139, 0, 131, 192, 8, 139, 0, 139, 93, 12, 41, 195, 137, 93, 248 })  ' 地址 偏移 赋值<br /> .判断开始 (数据类型 ＝ 十六进制 (“80000101”))  ' 字节型<br />     排序_字节型 (局_地址, 局_偏移, 真升假降)<br /> .判断 (数据类型 ＝ 十六进制 (“80000201”))  ' 短整数<br />     排序_短整数 (局_地址, 局_偏移, 真升假降)<br /> .判断 (数据类型 ＝ 十六进制 (“80000301”))  ' 整数型<br />     排序_整数型 (局_地址, 局_偏移, 真升假降)<br /> .判断 (数据类型 ＝ 十六进制 (“80000401”))  ' 长整数<br />     排序_长整数 (局_地址, 局_偏移, 真升假降)<br /> .判断 (数据类型 ＝ 十六进制 (“80000501”))  ' 小数型<br />     排序_小数型 (局_地址, 局_偏移, 真升假降)<br /> .判断 (数据类型 ＝ 十六进制 (“80000601”))  ' 双精度<br />     排序_双精度 (局_地址, 局_偏移, 真升假降)<br /> .判断 (数据类型 ＝ 十六进制 (“80000003”))  ' 时间型<br />     排序_时间型 (局_地址, 局_偏移, 真升假降)<br /> .判断 (数据类型 ＝ 十六进制 (“80000004”))  ' 文本型<br />     排序_文本型 (局_地址, 局_偏移, 真升假降)<br /> .默认<br />     局_失败 ＝ 真<br /> .判断结束<br /> 返回 (取反 (局_失败))<br /> <br /> .子程序 排序_字节型, , , 80000101<br /> .参数 参_地址, 整数型<br /> .参数 参_偏移, 整数型<br /> .参数 参_升降, 逻辑型<br /> <br /> .判断开始 (参_升降)<br /> <br /> .默认<br /> <br /> .判断结束<br /> <br /> <br /> .子程序 排序_短整数, , , 80000201<br /> .参数 参_地址, 整数型<br /> .参数 参_偏移, 整数型<br /> .参数 参_升降, 逻辑型<br /> <br /> .判断开始 (参_升降)<br /> <br /> .默认<br /> <br /> .判断结束<br /> <br /> <br /> .子程序 排序_整数型, , , 80000301<br /> .参数 参_地址, 整数型<br /> .参数 参_偏移, 整数型<br /> .参数 参_升降, 逻辑型<br /> <br /> .判断开始 (参_升降)<br /> <br /> .默认<br /> <br /> .判断结束<br /> <br /> <br /> .子程序 排序_长整数, , , 80000401<br /> .参数 参_地址, 整数型<br /> .参数 参_偏移, 整数型<br /> .参数 参_升降, 逻辑型<br /> <br /> .判断开始 (参_升降)<br /> <br /> .默认<br /> <br /> .判断结束<br /> <br /> <br /> .子程序 排序_小数型, , , 80000501<br /> .参数 参_地址, 整数型<br /> .参数 参_偏移, 整数型<br /> .参数 参_升降, 逻辑型<br /> <br /> .判断开始 (参_升降)<br /> <br /> .默认<br /> <br /> .判断结束<br /> <br /> <br /> .子程序 排序_双精度, , , 80000601<br /> .参数 参_地址, 整数型<br /> .参数 参_偏移, 整数型<br /> .参数 参_升降, 逻辑型<br /> <br /> .判断开始 (参_升降)<br /> <br /> .默认<br /> <br /> .判断结束<br /> <br /> <br /> .子程序 排序_时间型, , , 80000003<br /> .参数 参_地址, 整数型<br /> .参数 参_偏移, 整数型<br /> .参数 参_升降, 逻辑型<br /> <br /> .判断开始 (参_升降)<br /> <br /> .默认<br /> <br /> .判断结束<br /> <br /> <br /> .子程序 排序_文本型, , , 80000004<br /> .参数 参_地址, 整数型<br /> .参数 参_偏移, 整数型<br /> .参数 参_升降, 逻辑型<br /> <br /> .判断开始 (参_升降)<br /> <br /> .默认<br /> <br /> .判断结束

pipicool

学习一下

shituo

你这个 空间返回值都少了几个吧

Suky