数组_排序 增加数字逻辑判断以及数组反序的改进

jr21066

就象系统对 文件1 文件10 文件2 这种排序的改进一样.

  

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

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

' 初始化数组，防止有内容
重定义数组 (参_文本数组, 假, 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], 要排序的数组 [成员数量], 区分大小写)
判断 (比较结果 ≥ 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	整数型

' 如果是一样的文本就直接返回0
如果真 (文本比较 (参_文本1, 参_文本2, 区别大小写) ＝ 0)
返回 (0)
' 使用静态数组防止重复分配变量，所以要初始化
重定义数组 (比较数组1, 假, 0)
重定义数组 (比较数组2, 假, 0)
' 生成分割的数组
文本数字分割_ (参_文本1, 比较数组1)
文本数字分割_ (参_文本2, 比较数组2)
计次循环首 (取数组成员数 (比较数组1), 计数器)
' 文本2大于文本1，返回1
如果真 (计数器 ＞ 取数组成员数 (比较数组2))
返回 (1)
整数1 ＝ 到整数 (比较数组1 [计数器])
整数2 ＝ 到整数 (比较数组2 [计数器])
' 如果是整数成员，进行数值比较，否则进行文本比较
如果 (整数1 ≠ 0 且 整数2 ≠ 0)
如果 (整数1 ＜ 整数2)
返回值 ＝ -1
返回值 ＝ 1

返回值 ＝ 文本比较 (比较数组1 [计数器], 比较数组2 [计数器], 区别大小写)
' 如果同组数组成员相同，进入下一轮循环
如果真 (返回值 ＝ 0)
到循环尾 ()
' 成员比较不同，返回比较值
返回 (返回值)
计次循环尾 ()
' 文本1大于文本2，返回-1
返回 (-1)

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

变量名	类 型	静态	数组	备 注
成员数量	整数型
计数器	整数型

成员数量 ＝ 取数组成员数 (反转的数组)
计次循环首 (成员数量 ＼ 2, 计数器)
交换变量 (反转的数组 [计数器], 反转的数组 [成员数量 － 计数器 ＋ 1])
计次循环尾 ()

.版本 2<br /> <br /> .子程序 文本数字分割_, , , 连续数字为一组,汉字数字字母单独为一组<br /> .参数 参_文本, 文本型<br /> .参数 参_文本数组, 文本型, 数组<br /> .局部变量 偏移, 整数型<br /> .局部变量 指针, 整数型<br /> .局部变量 文本, 文本型<br /> <br /> ' 初始化数组，防止有内容<br /> 重定义数组 (参_文本数组, 假, 0)<br /> 指针 ＝ 1<br /> .判断循环首 (指针 ≤ 取文本长度 (参_文本))<br />     文本 ＝ “”<br />     .如果真 (取代码 (参_文本, 指针) ＜ 0)<br />         ' 如果是汉字，一次取两个字符<br />         加入成员 (参_文本数组, 取文本中间 (参_文本, 指针, 2))<br />         指针 ＝ 指针 ＋ 2<br />         到循环尾 ()<br />     .如果真结束<br /> <br />     .判断循环首 (取代码 (参_文本, 指针) ＞ 47 且 取代码 (参_文本, 指针) ＜ 58)<br />         ' 如果是数字，一次取出相邻所有数字<br />         文本 ＝ 文本 ＋ 取文本中间 (参_文本, 指针, 1)<br />         指针 ＝ 指针 ＋ 1<br />     .判断循环尾 ()<br />     .如果真 (文本 ≠ “”)<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 />         比较结果 ＝ 多列比较 (排序数组 [N], 要排序的数组 [成员数量], 区分大小写)<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 /> ' 如果是一样的文本就直接返回0<br /> .如果真 (文本比较 (参_文本1, 参_文本2, 区别大小写) ＝ 0)<br />     返回 (0)<br /> .如果真结束<br /> ' 使用静态数组防止重复分配变量，所以要初始化<br /> 重定义数组 (比较数组1, 假, 0)<br /> 重定义数组 (比较数组2, 假, 0)<br /> ' 生成分割的数组<br /> 文本数字分割_ (参_文本1, 比较数组1)<br /> 文本数字分割_ (参_文本2, 比较数组2)<br /> .计次循环首 (取数组成员数 (比较数组1), 计数器)<br />     ' 文本2大于文本1，返回1<br />     .如果真 (计数器 ＞ 取数组成员数 (比较数组2))<br />         返回 (1)<br />     .如果真结束<br />     整数1 ＝ 到整数 (比较数组1 [计数器])<br />     整数2 ＝ 到整数 (比较数组2 [计数器])<br />     ' 如果是整数成员，进行数值比较，否则进行文本比较<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 /> .计次循环尾 ()<br /> ' 文本1大于文本2，返回-1<br /> 返回 (-1)<br /> <br /> .子程序 数组_反转_, , 公开, 数组倒序。数组的第一个成员与最后一个成员互换，第二个和倒数第二个互换，以此类推<br /> .参数 反转的数组, 文本型, 参考 数组<br /> .局部变量 成员数量, 整数型<br /> .局部变量 计数器, 整数型<br /> <br /> 成员数量 ＝ 取数组成员数 (反转的数组)<br /> .计次循环首 (成员数量 ＼ 2, 计数器)<br />     交换变量 (反转的数组 [计数器], 反转的数组 [成员数量 － 计数器 ＋ 1])<br /> .计次循环尾 ()

jr21066

对文本分割进行了改进.使用指针读写内存.能快不少.

  

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

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

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

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


高位 ＝ 成员数量
低位 ＝ 1
中间位 ＝ (高位 ＋ 低位) ＼ 2
' ; lstrcmp 通过比较ASCII码进行文本的排序,速度快,但存在问题
比较结果 ＝ 多列比较 (排序数组 [新添加成员], 要排序的数组 [成员数量], 区分大小写)
如果 (比较结果 ≥ 0)
插入成员 (要排序的数组, 成员数量 ＋ 1, 排序数组 [新添加成员])
如果 (多列比较 (排序数组 [新添加成员], 要排序的数组 [1], 区分大小写) ≤ 0)
插入成员 (要排序的数组, 1, 排序数组 [新添加成员])
判断循环首 (高位 － 低位 ＞ 1)
如果真 (排序数组 [新添加成员] ＝ 要排序的数组 [中间位])
跳出循环 ()
如果 (多列比较 (排序数组 [新添加成员], 要排序的数组 [中间位], 区分大小写) ＜ 0)
高位 ＝ 中间位
低位 ＝ 中间位
中间位 ＝ (高位 ＋ 低位) ＼ 2
判断循环尾 ()
如果 (多列比较 (排序数组 [新添加成员], 要排序的数组 [中间位], 区分大小写) ≤ 0)
插入成员 (要排序的数组, 中间位, 排序数组 [新添加成员])
插入成员 (要排序的数组, 中间位 ＋ 1, 排序数组 [新添加成员])



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

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

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

' 如果是一样的文本就直接返回0
如果真 (文本比较 (参_文本1, 参_文本2, 区别大小写) ＝ 0)
返回 (0)
' 使用静态数组防止重复分配变量，所以要初始化
重定义数组 (比较数组1, 假, 0)
重定义数组 (比较数组2, 假, 0)
' 生成分割的数组
文本属性分割 (参_文本1, 比较数组1)
文本属性分割 (参_文本2, 比较数组2)
计次循环首 (取数组成员数 (比较数组1), 计数器)
' 文本2大于文本1，返回1
如果真 (计数器 ＞ 取数组成员数 (比较数组2))
返回 (1)
整数1 ＝ 到整数 (比较数组1 [计数器])
整数2 ＝ 到整数 (比较数组2 [计数器])
' 如果是整数成员，进行数值比较，否则进行文本比较
如果 (整数1 ≠ 0 且 整数2 ≠ 0)
如果 (整数1 ＜ 整数2)
返回值 ＝ -1
返回值 ＝ 1

返回值 ＝ 文本比较 (比较数组1 [计数器], 比较数组2 [计数器], 区别大小写)
' 如果同组数组成员相同，进入下一轮循环
如果真 (返回值 ＝ 0)
到循环尾 ()
' 成员比较不同，返回比较值
返回 (返回值)
计次循环尾 ()
' 文本1大于文本2，返回-1
返回 (-1)

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

变量名	类 型	静态	数组	备 注
成员数量	整数型
计数器	整数型

成员数量 ＝ 取数组成员数 (反转的数组)
计次循环首 (成员数量 ＼ 2, 计数器)
交换变量 (反转的数组 [计数器], 反转的数组 [成员数量 － 计数器 ＋ 1])
计次循环尾 ()

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

变量名	类 型	静态	数组	备 注
局_内容指针	整数型
局_内存句柄	整数型
局_内容地址	整数型
局_数字位数	整数型

' 初始化数组，防止有内容
重定义数组 (参_文本数组, 假, 0)
局_内容地址 ＝ 取变量数据地址 (参_文本)
局_内容指针 ＝ 0
局_内存句柄 ＝ 申请内存 (取文本长度 (参_文本), )
判断循环首 (局_内容指针 ＜ 取文本长度 (参_文本))
局_数字位数 ＝ 0
如果真 (指针到字节 (局_内容地址 ＋ 局_内容指针) ＞ 127)
' 如果是汉字，一次取两个字符
写到内存 (指针到字节集 (局_内容地址 ＋ 局_内容指针, 2) ＋ { 0 }, 局_内存句柄, 3)
加入成员 (参_文本数组, 指针到文本 (局_内存句柄))
局_内容指针 ＝ 局_内容指针 ＋ 2
到循环尾 ()

判断循环首 (指针到字节 (局_内容地址 ＋ 局_内容指针) ＞ 47 且 指针到字节 (局_内容地址 ＋ 局_内容指针) ＜ 58)
' 如果是数字，一次取出相邻所有数字
写到内存 (指针到字节集 (局_内容地址 ＋ 局_内容指针, 1), 局_内存句柄 ＋ 局_数字位数, 1)
局_数字位数 ＝ 局_数字位数 ＋ 1
局_内容指针 ＝ 局_内容指针 ＋ 1
判断循环尾 ()
如果真 (局_数字位数 ＞ 0)
' 将一组数字加入数组
写到内存 ({ 0 }, 局_内存句柄 ＋ 局_数字位数, 1)
加入成员 (参_文本数组, 指针到文本 (局_内存句柄))
到循环尾 ()
' 加入字母
写到内存 (指针到字节集 (局_内容地址 ＋ 局_内容指针, 1) ＋ { 0 }, 局_内存句柄, 2)
加入成员 (参_文本数组, 指针到文本 (局_内存句柄))
局_内容指针 ＝ 局_内容指针 ＋ 1
判断循环尾 ()
释放内存 (局_内存句柄)

子程序名	返回值类型	公开	备 注
指针到字节	字节型
参数名	类 型	参考	可空	数组	备 注
指针	整数型

置入代码 ({ 139, 69, 8, 139, 0, 201, 194, 4, 0 })
返回 (0)

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

.版本 2<br /> .支持库 spec<br /> <br /> .子程序 数组_排序_多列, , 公开, 二分法排序.只能对文本数组进行排序,整数数组请用核心支持库的.<br /> .参数 要排序的数组, 文本型, 数组<br /> .参数 排序方式, 字节型, 可空, 可空,默认为0  0=升序排序 1=降序排序<br /> .参数 区分大小写, 逻辑型, 可空, 可空,默认“真”。真=区分大小写，假=不区分<br /> .局部变量 新添加成员, 整数型<br /> .局部变量 排序数组, 文本型, , "0"<br /> .局部变量 成员数量, 整数型<br /> .局部变量 高位, 整数型<br /> .局部变量 低位, 整数型<br /> .局部变量 中间位, 整数型<br /> .局部变量 比较结果, 整数型, , , 感谢会员 落雪 提供代码<br /> <br /> 复制数组 (排序数组, 要排序的数组)<br /> 清除数组 (要排序的数组)<br /> .如果真 (是否为空 (区分大小写) ＝ 真)<br />     区分大小写 ＝ 真<br /> .如果真结束<br /> <br /> .计次循环首 (取数组成员数 (排序数组), 新添加成员)<br />     .判断开始 (成员数量 ＝ 0)<br />         插入成员 (要排序的数组, 1, 排序数组 [新添加成员])<br />     .默认<br /> <br />         高位 ＝ 成员数量<br />         低位 ＝ 1<br />         中间位 ＝ (高位 ＋ 低位) ＼ 2<br />         ' ; lstrcmp 通过比较ASCII码进行文本的排序,速度快,但存在问题<br />         比较结果 ＝ 多列比较 (排序数组 [新添加成员], 要排序的数组 [成员数量], 区分大小写)<br />         .如果 (比较结果 ≥ 0)<br />             插入成员 (要排序的数组, 成员数量 ＋ 1, 排序数组 [新添加成员])<br />         .否则<br />             .如果 (多列比较 (排序数组 [新添加成员], 要排序的数组 [1], 区分大小写) ≤ 0)<br />                 插入成员 (要排序的数组, 1, 排序数组 [新添加成员])<br />             .否则<br />                 .判断循环首 (高位 － 低位 ＞ 1)<br />                     .如果真 (排序数组 [新添加成员] ＝ 要排序的数组 [中间位])<br />                         跳出循环 ()<br />                     .如果真结束<br />                     .如果 (多列比较 (排序数组 [新添加成员], 要排序的数组 [中间位], 区分大小写) ＜ 0)<br />                         高位 ＝ 中间位<br />                     .否则<br />                         低位 ＝ 中间位<br />                     .如果结束<br />                     中间位 ＝ (高位 ＋ 低位) ＼ 2<br />                 .判断循环尾 ()<br />                 .如果 (多列比较 (排序数组 [新添加成员], 要排序的数组 [中间位], 区分大小写) ≤ 0)<br />                     插入成员 (要排序的数组, 中间位, 排序数组 [新添加成员])<br />                 .否则<br />                     插入成员 (要排序的数组, 中间位 ＋ 1, 排序数组 [新添加成员])<br />                 .如果结束<br /> <br />             .如果结束<br /> <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 /> ' 如果是一样的文本就直接返回0<br /> .如果真 (文本比较 (参_文本1, 参_文本2, 区别大小写) ＝ 0)<br />     返回 (0)<br /> .如果真结束<br /> ' 使用静态数组防止重复分配变量，所以要初始化<br /> 重定义数组 (比较数组1, 假, 0)<br /> 重定义数组 (比较数组2, 假, 0)<br /> ' 生成分割的数组<br /> 文本属性分割 (参_文本1, 比较数组1)<br /> 文本属性分割 (参_文本2, 比较数组2)<br /> .计次循环首 (取数组成员数 (比较数组1), 计数器)<br />     ' 文本2大于文本1，返回1<br />     .如果真 (计数器 ＞ 取数组成员数 (比较数组2))<br />         返回 (1)<br />     .如果真结束<br />     整数1 ＝ 到整数 (比较数组1 [计数器])<br />     整数2 ＝ 到整数 (比较数组2 [计数器])<br />     ' 如果是整数成员，进行数值比较，否则进行文本比较<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 /> .计次循环尾 ()<br /> ' 文本1大于文本2，返回-1<br /> 返回 (-1)<br /> <br /> .子程序 数组_反转_, , 公开, 数组倒序。数组的第一个成员与最后一个成员互换，第二个和倒数第二个互换，以此类推<br /> .参数 反转的数组, 文本型, 数组<br /> .局部变量 成员数量, 整数型<br /> .局部变量 计数器, 整数型<br /> <br /> 成员数量 ＝ 取数组成员数 (反转的数组)<br /> .计次循环首 (成员数量 ＼ 2, 计数器)<br />     交换变量 (反转的数组 [计数器], 反转的数组 [成员数量 － 计数器 ＋ 1])<br /> .计次循环尾 ()<br /> <br /> .子程序 文本属性分割, , , 连续数字为一组,汉字数字字母单独为一组<br /> .参数 参_文本, 文本型<br /> .参数 参_文本数组, 文本型, 数组<br /> .局部变量 局_内容指针, 整数型<br /> .局部变量 局_内存句柄, 整数型<br /> .局部变量 局_内容地址, 整数型<br /> .局部变量 局_数字位数, 整数型<br /> <br /> ' 初始化数组，防止有内容<br /> 重定义数组 (参_文本数组, 假, 0)<br /> 局_内容地址 ＝ 取变量数据地址 (参_文本)<br /> 局_内容指针 ＝ 0<br /> 局_内存句柄 ＝ 申请内存 (取文本长度 (参_文本), )<br /> .判断循环首 (局_内容指针 ＜ 取文本长度 (参_文本))<br />     局_数字位数 ＝ 0<br />     .如果真 (指针到字节 (局_内容地址 ＋ 局_内容指针) ＞ 127)<br />         ' 如果是汉字，一次取两个字符<br />         写到内存 (指针到字节集 (局_内容地址 ＋ 局_内容指针, 2) ＋ { 0 }, 局_内存句柄, 3)<br />         加入成员 (参_文本数组, 指针到文本 (局_内存句柄))<br />         局_内容指针 ＝ 局_内容指针 ＋ 2<br />         到循环尾 ()<br />     .如果真结束<br /> <br />     .判断循环首 (指针到字节 (局_内容地址 ＋ 局_内容指针) ＞ 47 且 指针到字节 (局_内容地址 ＋ 局_内容指针) ＜ 58)<br />         ' 如果是数字，一次取出相邻所有数字<br />         写到内存 (指针到字节集 (局_内容地址 ＋ 局_内容指针, 1), 局_内存句柄 ＋ 局_数字位数, 1)<br />         局_数字位数 ＝ 局_数字位数 ＋ 1<br />         局_内容指针 ＝ 局_内容指针 ＋ 1<br />     .判断循环尾 ()<br />     .如果真 (局_数字位数 ＞ 0)<br />         ' 将一组数字加入数组<br />         写到内存 ({ 0 }, 局_内存句柄 ＋ 局_数字位数, 1)<br />         加入成员 (参_文本数组, 指针到文本 (局_内存句柄))<br />         到循环尾 ()<br />     .如果真结束<br />     ' 加入字母<br />     写到内存 (指针到字节集 (局_内容地址 ＋ 局_内容指针, 1) ＋ { 0 }, 局_内存句柄, 2)<br />     加入成员 (参_文本数组, 指针到文本 (局_内存句柄))<br />     局_内容指针 ＝ 局_内容指针 ＋ 1<br /> .判断循环尾 ()<br /> 释放内存 (局_内存句柄)<br /> <br /> .子程序 指针到字节, 字节型, 公开<br /> .参数 指针, 整数型<br /> <br /> 置入代码 ({ 139, 69, 8, 139, 0, 201, 194, 4, 0 })<br /> 返回 (0)

w131321

会写软件的吗大神