改编精易模块中的数组_排序,支持多列和数字顺序

jr21066

使用了N多代码简单的实现了文本中有数字时,数字排序不准确的情况, 使得 2会排序在10前边.
从精易模块中的数组排序改编的,只是加入了文本分割功能和整数比较.目测效率不高.以后看有没有能力改进了.

  

子程序名	返回值类型	公开	备 注
文本数字分割_			连续数字为一组,汉字数字字母单独为一组
参数名	类 型	参考	可空	数组	备 注
参_文本	文本型
参_文本数组	文本型

变量名	类 型	静态	数组	备 注
偏移	整数型
指针	整数型
文本	文本型

重定义数组 (参_文本数组, 假, 0)
指针 ＝ 1
判断循环首 (指针 ≤ 取文本长度 (参_文本))
文本 ＝ “”
如果真 (取代码 (参_文本, 指针) ＜ 0)
加入成员 (参_文本数组, 取文本中间 (参_文本, 指针, 2))
指针 ＝ 指针 ＋ 2
到循环尾 ()

判断循环首 (取代码 (参_文本, 指针) ＞ 47 且 取代码 (参_文本, 指针) ＜ 58)
文本 ＝ 文本 ＋ 取文本中间 (参_文本, 指针, 1)
指针 ＝ 指针 ＋ 1
判断循环尾 ()
如果真 (文本 ≠ “”)
加入成员 (参_文本数组, 文本)
到循环尾 ()
加入成员 (参_文本数组, 取文本中间 (参_文本, 指针, 1))
指针 ＝ 指针 ＋ 1
判断循环尾 ()

子程序名	返回值类型	公开	备 注
数组_排序_多列			二分法排序.只能对文本数组进行排序,整数数组请用核心支持库的.
参数名	类 型	参考	可空	数组	备 注
要排序的数组	文本型
排序方式	字节型				可空,默认为0  0=升序排序 1=降序排序
区分大小写	逻辑型				可空,默认“真”。真=区分大小写，假=不区分

变量名	类 型	静态	数组	备 注
N	整数型
排序数组	文本型		0
成员数量	整数型
高位	整数型
低位	整数型
中间位	整数型
比较结果	整数型			感谢会员 落雪 提供代码

复制数组 (排序数组, 要排序的数组)
清除数组 (要排序的数组)
如果真 (是否为空 (区分大小写) ＝ 真)
区分大小写 ＝ 真

计次循环首 (取数组成员数 (排序数组), N)
判断 (成员数量 ＝ 0)
插入成员 (要排序的数组, 1, 排序数组 [N])


高位 ＝ 成员数量
低位 ＝ 1
中间位 ＝ (高位 ＋ 低位) ＼ 2
' ; lstrcmp 通过比较ASCII码进行文本的排序,速度快,但存在问题
判断 (区分大小写 ＝ 假)
比较结果 ＝ 多列比较 (到大写 (排序数组 [N]), 到大写 (要排序的数组 [成员数量]), 真)  ' 不区分就都算大写好了.因为在ACSII码中,大小写字母都是挨着的,所以不会出现"夹"在中间的字符.
比较结果 ＝ 多列比较 (排序数组 [N], 要排序的数组 [成员数量], 真)
判断 (比较结果 ≥ 0)
插入成员 (要排序的数组, 成员数量 ＋ 1, 排序数组 [N])
判断 (多列比较 (排序数组 [N], 要排序的数组 [1], 真) ≤ 0)
插入成员 (要排序的数组, 1, 排序数组 [N])
判断循环首 (高位 － 低位 ＞ 1)
如果真 (排序数组 [N] ＝ 要排序的数组 [中间位])
跳出循环 ()
如果 (多列比较 (排序数组 [N], 要排序的数组 [中间位], 真) ＜ 0)
高位 ＝ 中间位
低位 ＝ 中间位
中间位 ＝ (高位 ＋ 低位) ＼ 2
判断循环尾 ()
判断 (多列比较 (排序数组 [N], 要排序的数组 [中间位], 真) ≤ 0)
插入成员 (要排序的数组, 中间位, 排序数组 [N])
插入成员 (要排序的数组, 中间位 ＋ 1, 排序数组 [N])

成员数量 ＝ 取数组成员数 (要排序的数组)
计次循环尾 ()
如果真 (排序方式 ＝ 1)
数组_反转 (要排序的数组)

子程序名	返回值类型	公开	备 注
多列比较	整数型		按数组顺序进行文本比较
参数名	类 型	参考	可空	数组	备 注
参_文本1	文本型
参_文本2	文本型
区别大小写	逻辑型

变量名	类 型	静态	数组	备 注
比较数组1	文本型		0
比较数组2	文本型		0
计数器	整数型
返回值	整数型
整数1	整数型
整数2	整数型

如果真 (文本比较 (参_文本1, 参_文本2, 区别大小写) ＝ 0)
返回 (0)
文本数字分割_ (参_文本1, 比较数组1)
文本数字分割_ (参_文本2, 比较数组2)
计次循环首 (取数组成员数 (比较数组1), 计数器)
如果真 (计数器 ＞ 取数组成员数 (比较数组2))
返回 (1)
整数1 ＝ 到整数 (比较数组1 [计数器])
整数2 ＝ 到整数 (比较数组2 [计数器])
如果 (整数1 ≠ 0 且 整数2 ≠ 0)
如果 (整数1 ＜ 整数2)
返回值 ＝ -1
返回值 ＝ 1

返回值 ＝ 文本比较 (比较数组1 [计数器], 比较数组2 [计数器], 区别大小写)

如果真 (返回值 ＝ 0)
到循环尾 ()
返回 (返回值)
计次循环尾 ()
返回 (-1)

子程序名	返回值类型	公开	备 注
数组_反转			数组倒序。数组的第一个成员与最后一个成员互换，第二个和倒数第二个互换，以此类推
参数名	类 型	参考	可空	数组	备 注
反转的数组	文本型

变量名	类 型	静态	数组	备 注
成员数量	整数型
折中数量	整数型
临时成员	文本型
N	整数型

成员数量 ＝ 取数组成员数 (反转的数组)
折中数量 ＝ 成员数量 ÷ 2
计次循环首 (折中数量, N)
临时成员 ＝ 反转的数组 [N]
反转的数组 [N] ＝ 反转的数组 [成员数量]
反转的数组 [成员数量] ＝ 临时成员
成员数量 ＝ 成员数量 － 1
计次循环尾 ()

.版本 2<br /> <br /> .子程序 文本数字分割_, , , 连续数字为一组,汉字数字字母单独为一组<br /> .参数 参_文本, 文本型<br /> .参数 参_文本数组, 文本型, 数组<br /> .局部变量 偏移, 整数型<br /> .局部变量 指针, 整数型<br /> .局部变量 文本, 文本型<br /> <br /> 重定义数组 (参_文本数组, 假, 0)<br /> 指针 ＝ 1<br /> .判断循环首 (指针 ≤ 取文本长度 (参_文本))<br />     文本 ＝ “”<br />     .如果真 (取代码 (参_文本, 指针) ＜ 0)<br />         加入成员 (参_文本数组, 取文本中间 (参_文本, 指针, 2))<br />         指针 ＝ 指针 ＋ 2<br />         到循环尾 ()<br />     .如果真结束<br /> <br />     .判断循环首 (取代码 (参_文本, 指针) ＞ 47 且 取代码 (参_文本, 指针) ＜ 58)<br />         文本 ＝ 文本 ＋ 取文本中间 (参_文本, 指针, 1)<br />         指针 ＝ 指针 ＋ 1<br />     .判断循环尾 ()<br />     .如果真 (文本 ≠ “”)<br />         加入成员 (参_文本数组, 文本)<br />         到循环尾 ()<br />     .如果真结束<br />     加入成员 (参_文本数组, 取文本中间 (参_文本, 指针, 1))<br />     指针 ＝ 指针 ＋ 1<br /> .判断循环尾 ()<br /> <br /> .子程序 数组_排序_多列, , 公开, 二分法排序.只能对文本数组进行排序,整数数组请用核心支持库的.<br /> .参数 要排序的数组, 文本型, 参考 数组<br /> .参数 排序方式, 字节型, 可空, 可空,默认为0  0=升序排序 1=降序排序<br /> .参数 区分大小写, 逻辑型, 可空, 可空,默认“真”。真=区分大小写，假=不区分<br /> .局部变量 N, 整数型<br /> .局部变量 排序数组, 文本型, , "0"<br /> .局部变量 成员数量, 整数型<br /> .局部变量 高位, 整数型<br /> .局部变量 低位, 整数型<br /> .局部变量 中间位, 整数型<br /> .局部变量 比较结果, 整数型, , , 感谢会员 落雪 提供代码<br /> <br /> 复制数组 (排序数组, 要排序的数组)<br /> 清除数组 (要排序的数组)<br /> .如果真 (是否为空 (区分大小写) ＝ 真)<br />     区分大小写 ＝ 真<br /> .如果真结束<br /> <br /> .计次循环首 (取数组成员数 (排序数组), N)<br />     .判断开始 (成员数量 ＝ 0)<br />         插入成员 (要排序的数组, 1, 排序数组 [N])<br />     .默认<br /> <br />         高位 ＝ 成员数量<br />         低位 ＝ 1<br />         中间位 ＝ (高位 ＋ 低位) ＼ 2<br />         ' ; lstrcmp 通过比较ASCII码进行文本的排序,速度快,但存在问题<br />         .判断开始 (区分大小写 ＝ 假)<br />             比较结果 ＝ 多列比较 (到大写 (排序数组 [N]), 到大写 (要排序的数组 [成员数量]), 真)  ' 不区分就都算大写好了.因为在ACSII码中,大小写字母都是挨着的,所以不会出现"夹"在中间的字符.<br />         .默认<br />             比较结果 ＝ 多列比较 (排序数组 [N], 要排序的数组 [成员数量], 真)<br />         .判断结束<br />         .判断开始 (比较结果 ≥ 0)<br />             插入成员 (要排序的数组, 成员数量 ＋ 1, 排序数组 [N])<br />         .判断 (多列比较 (排序数组 [N], 要排序的数组 [1], 真) ≤ 0)<br />             插入成员 (要排序的数组, 1, 排序数组 [N])<br />         .默认<br />             .判断循环首 (高位 － 低位 ＞ 1)<br />                 .如果真 (排序数组 [N] ＝ 要排序的数组 [中间位])<br />                     跳出循环 ()<br />                 .如果真结束<br />                 .如果 (多列比较 (排序数组 [N], 要排序的数组 [中间位], 真) ＜ 0)<br />                     高位 ＝ 中间位<br />                 .否则<br />                     低位 ＝ 中间位<br />                 .如果结束<br />                 中间位 ＝ (高位 ＋ 低位) ＼ 2<br />             .判断循环尾 ()<br />             .判断开始 (多列比较 (排序数组 [N], 要排序的数组 [中间位], 真) ≤ 0)<br />                 插入成员 (要排序的数组, 中间位, 排序数组 [N])<br />             .默认<br />                 插入成员 (要排序的数组, 中间位 ＋ 1, 排序数组 [N])<br />             .判断结束<br /> <br />         .判断结束<br /> <br />     .判断结束<br />     成员数量 ＝ 取数组成员数 (要排序的数组)<br /> .计次循环尾 ()<br /> .如果真 (排序方式 ＝ 1)<br />     数组_反转 (要排序的数组)<br /> .如果真结束<br /> <br /> <br /> .子程序 多列比较, 整数型, , 按数组顺序进行文本比较<br /> .参数 参_文本1, 文本型<br /> .参数 参_文本2, 文本型<br /> .参数 区别大小写, 逻辑型<br /> .局部变量 比较数组1, 文本型, , "0"<br /> .局部变量 比较数组2, 文本型, , "0"<br /> .局部变量 计数器, 整数型<br /> .局部变量 返回值, 整数型<br /> .局部变量 整数1, 整数型<br /> .局部变量 整数2, 整数型<br /> <br /> .如果真 (文本比较 (参_文本1, 参_文本2, 区别大小写) ＝ 0)<br />     返回 (0)<br /> .如果真结束<br /> 文本数字分割_ (参_文本1, 比较数组1)<br /> 文本数字分割_ (参_文本2, 比较数组2)<br /> .计次循环首 (取数组成员数 (比较数组1), 计数器)<br />     .如果真 (计数器 ＞ 取数组成员数 (比较数组2))<br />         返回 (1)<br />     .如果真结束<br />     整数1 ＝ 到整数 (比较数组1 [计数器])<br />     整数2 ＝ 到整数 (比较数组2 [计数器])<br />     .如果 (整数1 ≠ 0 且 整数2 ≠ 0)<br />         .如果 (整数1 ＜ 整数2)<br />             返回值 ＝ -1<br />         .否则<br />             返回值 ＝ 1<br />         .如果结束<br /> <br />     .否则<br />         返回值 ＝ 文本比较 (比较数组1 [计数器], 比较数组2 [计数器], 区别大小写)<br />     .如果结束<br /> <br />     .如果真 (返回值 ＝ 0)<br />         到循环尾 ()<br />     .如果真结束<br />     返回 (返回值)<br /> .计次循环尾 ()<br /> 返回 (-1)<br /> <br /> .子程序 数组_反转, , , 数组倒序。数组的第一个成员与最后一个成员互换，第二个和倒数第二个互换，以此类推<br /> .参数 反转的数组, 文本型, 参考 数组<br /> .局部变量 成员数量, 整数型<br /> .局部变量 折中数量, 整数型<br /> .局部变量 临时成员, 文本型<br /> .局部变量 N, 整数型<br /> <br /> 成员数量 ＝ 取数组成员数 (反转的数组)<br /> 折中数量 ＝ 成员数量 ÷ 2<br /> .计次循环首 (折中数量, N)<br />     临时成员 ＝ 反转的数组 [N]<br />     反转的数组 [N] ＝ 反转的数组 [成员数量]<br />     反转的数组 [成员数量] ＝ 临时成员<br />     成员数量 ＝ 成员数量 － 1<br /> .计次循环尾 ()

初学者1

真的实现了多列，谢谢分享

lm88818

真的实现了多列，谢谢分享

杨明煜

学习学习.............

unit10000

改编精易模块中的数组_排序,支持多列和数字顺序

噢噢

支持开源~！感谢分享

李泽勇2

刚测试下，真的实现了多列，谢谢分享。

列明

對於多列排序的邏輯我現在還是糊涂的。

atao1999

        感谢分享，很给力！~

2067190499

卧槽无情