文本型数字串如何快速排序？

算法艺术家

  

子程序名	返回值类型	公开	备 注
整数文本排序	文本型
参数名	类 型	参考	可空	数组	备 注
整数文本字符串	文本型
排序方向	逻辑型				如果参数值为真，排序将从小到大；如果为假，则为从大到小。如果本参数被省略，将默认为真

变量名	类 型	静态	数组	备 注
交换	逻辑型
未比数据	整数型
i	整数型
局方向	逻辑型
数组	文本型		0

如果真 (是否为空 (排序方向) ＝ 真)
排序方向 ＝ 真
文本_逐字分割_汇编 (整数文本字符串, 数组)
交换 ＝ 真
未比数据 ＝ 取数组成员数 (数组)
判断循环首 (交换 ＝ 真)
交换 ＝ 假
变量循环首 (1, 未比数据 － 1, 1, i)
判断 (排序方向 ＝ 真)
判断 (到整数 (数组 [i ＋ 1]) ＞ 到整数 (数组 [i]))
局方向 ＝ 假
局方向 ＝ 真



判断 (到整数 (数组 [i ＋ 1]) ＜ 到整数 (数组 [i]))
局方向 ＝ 假
局方向 ＝ 真


如果真 (局方向 ＝ 真)
交换变量 (数组 [i], 数组 [i ＋ 1])
交换 ＝ 真

变量循环尾 ()
未比数据 ＝ 未比数据 － 1
判断循环尾 ()
返回 (数组_合并_快速 (数组))

.版本 2<br /> <br /> .子程序 整数文本排序, 文本型, 公开<br /> .参数 整数文本字符串, 文本型<br /> .参数 排序方向, 逻辑型, 可空, 如果参数值为真，排序将从小到大；如果为假，则为从大到小。如果本参数被省略，将默认为真<br /> .局部变量 交换, 逻辑型<br /> .局部变量 未比数据, 整数型<br /> .局部变量 i, 整数型<br /> .局部变量 局方向, 逻辑型<br /> .局部变量 数组, 文本型, , "0"<br /> <br /> .如果真 (是否为空 (排序方向) ＝ 真)<br />     排序方向 ＝ 真<br /> .如果真结束<br /> 文本_逐字分割_汇编 (整数文本字符串, 数组)<br /> 交换 ＝ 真<br /> 未比数据 ＝ 取数组成员数 (数组)<br /> .判断循环首 (交换 ＝ 真)<br />     交换 ＝ 假<br />     .变量循环首 (1, 未比数据 － 1, 1, i)<br /> <br />         .判断开始 (排序方向 ＝ 真)<br />             .判断开始 (到整数 (数组 [i ＋ 1]) ＞ 到整数 (数组 <i>))<br />                 局方向 ＝ 假<br />             .默认<br />                 局方向 ＝ 真<br />             .判断结束<br /> <br />         .默认<br /> <br />             .判断开始 (到整数 (数组 [i ＋ 1]) ＜ 到整数 (数组 <i>))<br />                 局方向 ＝ 假<br />             .默认<br />                 局方向 ＝ 真<br />             .判断结束<br /> <br />         .判断结束<br /> <br />         .如果真 (局方向 ＝ 真)<br />             交换变量 (数组 <i>, 数组 [i ＋ 1])<br />             交换 ＝ 真<br />         .如果真结束<br /> <br />     .变量循环尾 ()<br />     未比数据 ＝ 未比数据 － 1<br /> .判断循环尾 ()<br /> 返回 (数组_合并_快速 (数组))

补充内容 (2025-2-10 15:45):
比大佬的也就慢了几十倍，还有很大的优化空间

算法艺术家

这次可以超越了

  

子程序名	返回值类型	公开	备 注
整数文本排序	文本型
参数名	类 型	参考	可空	数组	备 注
整数文本字符串	文本型
排序方向	逻辑型				如果参数值为真，排序将从小到大；如果为假，则为从大到小。如果本参数被省略，将默认为真

变量名	类 型	静态	数组	备 注
交换	逻辑型
未比数据	整数型
i	整数型
局方向	逻辑型
数组	文本型		0

如果真 (是否为空 (排序方向) ＝ 真)
排序方向 ＝ 真
文本_逐字分割_汇编 (整数文本字符串, 数组)
' 文本_逐字分割 (整数文本字符串, 数组)
交换 ＝ 真
未比数据 ＝ 取数组成员数 (数组)
判断循环首 (交换 ＝ 真)
交换 ＝ 假
变量循环首 (1, 未比数据 － 1, 1, i)
判断 (排序方向 ＝ 真)
判断 (数组 [i ＋ 1] ＞ 数组 [i])
局方向 ＝ 假
局方向 ＝ 真



判断 (数组 [i ＋ 1] ＜ 数组 [i])
局方向 ＝ 假
局方向 ＝ 真


如果真 (局方向 ＝ 真)
交换变量 (数组 [i], 数组 [i ＋ 1])
交换 ＝ 真

变量循环尾 ()
未比数据 ＝ 未比数据 － 1
判断循环尾 ()
返回 (数组_合并_快速 (数组))

.版本 2<br /> <br /> .子程序 整数文本排序, 文本型, 公开<br /> .参数 整数文本字符串, 文本型<br /> .参数 排序方向, 逻辑型, 可空, 如果参数值为真，排序将从小到大；如果为假，则为从大到小。如果本参数被省略，将默认为真<br /> .局部变量 交换, 逻辑型<br /> .局部变量 未比数据, 整数型<br /> .局部变量 i, 整数型<br /> .局部变量 局方向, 逻辑型<br /> .局部变量 数组, 文本型, , "0"<br /> <br /> <br /> .如果真 (是否为空 (排序方向) ＝ 真)<br />     排序方向 ＝ 真<br /> .如果真结束<br /> 文本_逐字分割_汇编 (整数文本字符串, 数组)<br /> ' 文本_逐字分割 (整数文本字符串, 数组)<br /> <br /> <br /> <br /> 交换 ＝ 真<br /> 未比数据 ＝ 取数组成员数 (数组)<br /> .判断循环首 (交换 ＝ 真)<br />     交换 ＝ 假<br />     .变量循环首 (1, 未比数据 － 1, 1, i)<br /> <br />         .判断开始 (排序方向 ＝ 真)<br />             .判断开始 (数组 [i ＋ 1] ＞ 数组 <i>)<br />                 局方向 ＝ 假<br />             .默认<br />                 局方向 ＝ 真<br />             .判断结束<br /> <br />         .默认<br /> <br />             .判断开始 (数组 [i ＋ 1] ＜ 数组 <i>)<br />                 局方向 ＝ 假<br />             .默认<br />                 局方向 ＝ 真<br />             .判断结束<br /> <br />         .判断结束<br /> <br />         .如果真 (局方向 ＝ 真)<br />             交换变量 (数组 <i>, 数组 [i ＋ 1])<br />             交换 ＝ 真<br />         .如果真结束<br /> <br />     .变量循环尾 ()<br />     未比数据 ＝ 未比数据 － 1<br /> .判断循环尾 ()<br /> 返回 (数组_合并_快速 (数组))

sunfly

算法艺术家 发表于 2025-2-10 16:10
这次可以超越了
[e=3].版本 2

测试随机位数，短长度的和长长度的效率重复10000次排序差不多，
而且弊端是调用了大量的精易命令代码量多了很多
感觉核心库写速度比这个快。
谢谢您的分享帮助

算法艺术家

sunfly 发表于 2025-2-10 16:37
测试随机位数，短长度的和长长度的效率重复10000次排序差不多，
而且弊端是调用了大量的精易命令代码量多 ...

别着急 等等有可能还有隐藏大佬来奉献

大漠小鸟

  

子程序名	返回值类型	公开	备 注
文本数字排序_汇编			就地对文本进行ASCII冒泡排序，汇编版
参数名	类 型	参考	可空	数组	备 注
文本数字	文本型

置入代码 ({ 139, 69, 8, 139, 0, 133, 192, 116, 91, 137, 199, 141, 80, 3, 139, 24, 131, 192, 4, 141, 139, 255, 254, 254, 254, 247, 211, 33, 217, 129, 225, 128, 128, 128, 128, 116, 233, 247, 193, 128, 128, 0, 0, 117, 6, 193, 233, 16, 131, 192, 2, 208, 225, 25, 208, 137, 193, 73, 137, 248, 131, 249, 0, 126, 35, 49, 219, 49, 246, 138, 20, 31, 138, 116, 31, 1, 56, 242, 141, 91, 1, 126, 9, 137, 222, 136, 116, 55, 255, 136, 20, 55, 57, 203, 124, 229, 137, 241, 235, 216 })
' mov eax,dword [ebp+8]
' mov eax,dword [eax]
' test eax,eax
' jz 结束
' mov edi,eax
' ;取出文本的长度
' lea edx,[eax+3]
' 读入四字节:
' mov ebx,[eax]
' add eax,4
' lea ecx,[ebx-01010101h]
' not ebx
' and ecx,ebx
' and ecx,80808080h
' jz 读入四字节
' test ecx,00008080h
' jnz 计算长度
' shr ecx,16
' add eax,2
' 计算长度:
' shl cl,1
' sbb eax,edx
' mov ecx,eax ;长度
' dec ecx
' mov eax,edi ;起始
' ;开始冒泡排序
' 判断循环首:
' cmp ecx,0
' jle 结束
' xor ebx,ebx
' xor esi,esi
' 变量循环首:
' mov dl,byte[edi+ebx]
' mov dh,byte [edi+ebx+1]
' cmp dl,dh
' lea ebx,dword [ebx+1]
' jng 变量循环尾
' mov esi,ebx
' mov byte [edi+esi-1],dh
' mov byte [edi+esi],dl
' 变量循环尾:
' cmp ebx,ecx
' jl 变量循环首
' mov ecx,esi
' jmp 判断循环首
' 结束:

子程序名	返回值类型	公开	备 注
文本数字排序_常规			对上面汇编代码的过程翻译，低效率
参数名	类 型	参考	可空	数组	备 注
文本数字	文本型

变量名	类 型	静态	数组	备 注
长度	整数型
i	整数型
剩余长度	整数型
c1	字节型
c2	字节型
文本地址	整数型

长度 ＝ 取文本长度 (文本数字)
文本地址 ＝ 取变量数据地址 (文本数字)
判断循环首 (长度 ＞ 0)
剩余长度 ＝ 0
变量循环首 (1, 长度 － 1, 1, i)
c1 ＝ 取代码 (文本数字, i)
c2 ＝ 取代码 (文本数字, i ＋ 1)
如果真 (c1 ＞ c2)
' 交换两个值
写到内存 (c1, 文本地址 ＋ i, )
写到内存 (c2, 文本地址 ＋ i － 1, )
' 记录最后一次交换的位置
剩余长度 ＝ i

变量循环尾 ()
长度 ＝ 剩余长度
判断循环尾 ()

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

.版本 2<br /> .支持库 spec<br /> <br /> .子程序 文本数字排序_汇编, , , 就地对文本进行ASCII冒泡排序，汇编版<br /> .参数 文本数字, 文本型, 参考<br /> <br /> 置入代码 ({ 139, 69, 8, 139, 0, 133, 192, 116, 91, 137, 199, 141, 80, 3, 139, 24, 131, 192, 4, 141, 139, 255, 254, 254, 254, 247, 211, 33, 217, 129, 225, 128, 128, 128, 128, 116, 233, 247, 193, 128, 128, 0, 0, 117, 6, 193, 233, 16, 131, 192, 2, 208, 225, 25, 208, 137, 193, 73, 137, 248, 131, 249, 0, 126, 35, 49, 219, 49, 246, 138, 20, 31, 138, 116, 31, 1, 56, 242, 141, 91, 1, 126, 9, 137, 222, 136, 116, 55, 255, 136, 20, 55, 57, 203, 124, 229, 137, 241, 235, 216 })<br /> <br /> <br /> <br /> ' mov eax,dword [ebp+8]<br /> ' mov eax,dword [eax]<br /> ' test eax,eax<br /> ' jz 结束<br /> ' mov edi,eax<br /> <br /> ' ;取出文本的长度<br /> ' lea edx,[eax+3]<br /> ' 读入四字节:<br /> ' mov ebx,[eax]<br /> ' add eax,4<br /> ' lea ecx,[ebx-01010101h]<br /> ' not ebx<br /> ' and ecx,ebx<br /> ' and ecx,80808080h<br /> ' jz 读入四字节<br /> ' test ecx,00008080h<br /> ' jnz 计算长度<br /> ' shr ecx,16<br /> ' add eax,2<br /> ' 计算长度:<br /> ' shl cl,1<br /> ' sbb eax,edx<br /> ' mov ecx,eax ;长度<br /> ' dec ecx<br /> ' mov eax,edi ;起始<br /> <br /> ' ;开始冒泡排序<br /> ' 判断循环首:<br /> ' cmp ecx,0<br /> ' jle 结束<br /> <br /> <br /> ' xor ebx,ebx<br /> ' xor esi,esi<br /> ' 变量循环首:<br /> ' mov dl,byte[edi+ebx]<br /> ' mov dh,byte [edi+ebx+1]<br /> ' cmp dl,dh<br /> ' lea ebx,dword [ebx+1]<br /> ' jng 变量循环尾<br /> ' mov esi,ebx<br /> ' mov byte [edi+esi-1],dh<br /> ' mov byte [edi+esi],dl<br /> ' 变量循环尾:<br /> ' cmp ebx,ecx<br /> ' jl 变量循环首<br /> <br /> ' mov ecx,esi<br /> ' jmp 判断循环首<br /> <br /> ' 结束:<br /> <br /> <br /> <br /> <br /> .子程序 文本数字排序_常规, , , 对上面汇编代码的过程翻译，低效率<br /> .参数 文本数字, 文本型, 参考<br /> .局部变量 长度, 整数型<br /> .局部变量 i, 整数型<br /> .局部变量 剩余长度, 整数型<br /> .局部变量 c1, 字节型<br /> .局部变量 c2, 字节型<br /> .局部变量 文本地址, 整数型<br /> <br /> 长度 ＝ 取文本长度 (文本数字)<br /> 文本地址 ＝ 取变量数据地址 (文本数字)<br /> .判断循环首 (长度 ＞ 0)<br />     剩余长度 ＝ 0<br />     .变量循环首 (1, 长度 － 1, 1, i)<br />         c1 ＝ 取代码 (文本数字, i)<br />         c2 ＝ 取代码 (文本数字, i ＋ 1)<br />         .如果真 (c1 ＞ c2)<br />             ' 交换两个值<br />             写到内存 (c1, 文本地址 ＋ i, )<br />             写到内存 (c2, 文本地址 ＋ i － 1, )<br />             ' 记录最后一次交换的位置<br />             剩余长度 ＝ i<br />         .如果真结束<br /> <br />     .变量循环尾 ()<br />     长度 ＝ 剩余长度<br /> .判断循环尾 ()

补充内容 (2025-2-10 17:38):
a="987654321"
文本数字排序_汇编(a)'注意，参数只能提供变量，不能提供常量，否则编译后崩溃
调试输出(a)'123456789

算法艺术家

  

另一个写法

子程序名	返回值类型	公开	备 注
文本串排序	文本型		逐字排序
参数名	类 型	参考	可空	数组	备 注
整数文本字符串	文本型
排序方向	逻辑型				如果参数值为真，排序将从小到大；如果为假，则为从大到小。如果本参数被省略，将默认为真

变量名	类 型	静态	数组	备 注
数量	整数型
i	整数型
局方向	逻辑型
数组	文本型		0
结果	文本型
最大值	文本型
n	整数型

如果真 (是否为空 (排序方向) ＝ 真)
排序方向 ＝ 真

文本_逐字分割_汇编 (整数文本字符串, 数组)
数量 ＝ 取数组成员数 (数组)
判断 (排序方向 ＝ 真)
计次循环首 (数量, )
最大值 ＝ 数组 [1]
n ＝ 1
计次循环首 (取数组成员数 (数组), i)
如果真 (数组 [i] ＜ 最大值)
最大值 ＝ 数组 [i]
n ＝ i

计次循环尾 ()
删除成员 (数组, n, )
结果 ＝ 结果 ＋ 最大值
计次循环尾 ()



计次循环首 (数量, )
最大值 ＝ 数组 [1]
n ＝ 1
计次循环首 (取数组成员数 (数组), i)
如果真 (数组 [i] ＞ 最大值)
最大值 ＝ 数组 [i]
n ＝ i

计次循环尾 ()
删除成员 (数组, n, )
结果 ＝ 结果 ＋ 最大值
计次循环尾 ()

返回 (结果)

另一个写法<br /> .版本 2<br /> <br /> .子程序 文本串排序, 文本型, 公开, 逐字排序<br /> .参数 整数文本字符串, 文本型<br /> .参数 排序方向, 逻辑型, 可空, 如果参数值为真，排序将从小到大；如果为假，则为从大到小。如果本参数被省略，将默认为真<br /> .局部变量 数量, 整数型<br /> .局部变量 i, 整数型<br /> .局部变量 局方向, 逻辑型<br /> .局部变量 数组, 文本型, , "0"<br /> .局部变量 结果, 文本型<br /> .局部变量 最大值, 文本型<br /> .局部变量 n, 整数型<br /> <br /> <br /> .如果真 (是否为空 (排序方向) ＝ 真)<br />     排序方向 ＝ 真<br /> .如果真结束<br /> <br /> 文本_逐字分割_汇编 (整数文本字符串, 数组)<br /> 数量 ＝ 取数组成员数 (数组)<br /> <br /> .判断开始 (排序方向 ＝ 真)<br />     .计次循环首 (数量, )<br />         最大值 ＝ 数组 [1]<br />         n ＝ 1<br />         .计次循环首 (取数组成员数 (数组), i)<br />             .如果真 (数组 <i> ＜ 最大值)<br />                 最大值 ＝ 数组 <i><br />                 n ＝ i<br />             .如果真结束<br /> <br />         .计次循环尾 ()<br />         删除成员 (数组, n, )<br />         结果 ＝ 结果 ＋ 最大值<br />     .计次循环尾 ()<br /> <br /> .默认<br /> <br />     .计次循环首 (数量, )<br />         最大值 ＝ 数组 [1]<br />         n ＝ 1<br />         .计次循环首 (取数组成员数 (数组), i)<br />             .如果真 (数组 <i> ＞ 最大值)<br />                 最大值 ＝ 数组 <i><br />                 n ＝ i<br />             .如果真结束<br /> <br />         .计次循环尾 ()<br />         删除成员 (数组, n, )<br />         结果 ＝ 结果 ＋ 最大值<br />     .计次循环尾 ()<br /> .判断结束<br /> <br /> 返回 (结果)

大漠小鸟

算法艺术家 发表于 2025-2-10 15:41
[e=3].版本 2

.子程序 整数文本排序, 文本型, 公开

将交换=真 改成交换=i
判断循环首判断剩余的交换次数，冒泡次数会大幅度减少

算法艺术家

大漠小鸟 发表于 2025-2-10 17:59
将交换=真 改成交换=i
判断循环首判断剩余的交换次数，冒泡次数会大幅度减少 ...

感谢大佬

梦幻1096

  

子程序名	返回值类型	公开	备 注
数字文本排序
参数名	类 型	参考	可空	数组	备 注
数字文本	文本型				参数必须是变量，因为是在原文本上面排的序

置入代码 ({ 139, 117, 8, 139, 54, 137, 240, 141, 80, 3, 139, 56, 131, 192, 4, 141, 143, 255, 254, 254, 254, 247, 215, 33, 249, 129, 225, 128, 128, 128, 128, 116, 233, 247, 193, 128, 128, 0, 0, 117, 6, 193, 233, 16, 131, 192, 2, 208, 225, 25, 208, 137, 194, 137, 247, 49, 201, 86, 65, 57, 209, 116, 29, 137, 211, 41, 203, 49, 255, 71, 57, 223, 119, 15, 138, 6, 58, 70, 1, 118, 5, 134, 70, 1, 136, 6, 70, 235, 236, 94, 235, 221 })

.版本 2<br /> <br /> .子程序 数字文本排序<br /> .参数 数字文本, 文本型, , 参数必须是变量，因为是在原文本上面排的序<br /> <br /> 置入代码 ({ 139, 117, 8, 139, 54, 137, 240, 141, 80, 3, 139, 56, 131, 192, 4, 141, 143, 255, 254, 254, 254, 247, 215, 33, 249, 129, 225, 128, 128, 128, 128, 116, 233, 247, 193, 128, 128, 0, 0, 117, 6, 193, 233, 16, 131, 192, 2, 208, 225, 25, 208, 137, 194, 137, 247, 49, 201, 86, 65, 57, 209, 116, 29, 137, 211, 41, 203, 49, 255, 71, 57, 223, 119, 15, 138, 6, 58, 70, 1, 118, 5, 134, 70, 1, 136, 6, 70, 235, 236, 94, 235, 221 })

用汇编写了一个，试试！

算法艺术家

这一个问题 炸出一堆汇编大佬