超级列表框排序问题

aipca

上传个附件吧

大熊猫玩编程

望采纳。。。

  

子程序名	返回值类型	公开	备 注
排序时间

变量名	类 型	静态	数组	备 注
i	整数型
时间参数	文本型
临时数组	文本型		0
j	整数型
最后位置	整数型
未比数据数量	整数型
位置变量	整数型
临时数组1	文本型		0
表项	整数型
时间数组	文本型		0
交换变量	文本型
位置变量1	整数型
未比数据数量1	整数型

计次循环首 (超级列表框1.取表项数 (), i)
时间参数 ＝ 超级列表框1.取标题 (i － 1, 1)
如果真 (时间参数 ＝ “”)
到循环尾 ()
调试输出 (时间参数, i)
加入成员 (时间数组, 时间参数)
计次循环尾 ()
未比数据数量 ＝ 取数组成员数 (时间数组)
未比数据数量1 ＝ 未比数据数量
调试输出 (“未比数据数量:”, 未比数据数量)
判断循环首 (未比数据数量 ＞ 0)
最后位置 ＝ 0
变量循环首 (1, 未比数据数量 － 1, 1, 位置变量)
文本_分割文本 (时间数组 [位置变量], “:”, , 临时数组)
文本_分割文本 (时间数组 [位置变量 ＋ 1], “:”, , 临时数组1)
调试输出 (“位置变量:”, 位置变量, 临时数组 [1])
如果真 (到整数 (临时数组 [1]) ＞ 到整数 (临时数组1 [1]))
交换变量 ＝ 时间数组 [位置变量]  ' 数据组可以是变量、文件、数据库（这里用的是变量）
时间数组 [位置变量] ＝ 时间数组 [位置变量 ＋ 1]
时间数组 [位置变量 ＋ 1] ＝ 交换变量  ' 以上3行代码是交换用的
最后位置 ＝ 位置变量

变量循环尾 ()
未比数据数量 ＝ 最后位置  ' 下一行排序从第一个数开始到上次排序的最后被改变的位数
判断循环尾 ()
判断循环首 (未比数据数量1 ＞ 0)
最后位置 ＝ 0
变量循环首 (1, 未比数据数量1 － 1, 1, 位置变量1)
文本_分割文本 (时间数组 [位置变量1], “:”, , 临时数组)
文本_分割文本 (时间数组 [位置变量1 ＋ 1], “:”, , 临时数组1)
调试输出 (“位置变量:”, 位置变量1, 临时数组 [2])
如果真 (到整数 (临时数组 [2]) ＞ 到整数 (临时数组1 [2]) 且 到整数 (临时数组 [1]) ＝ 到整数 (临时数组1 [1]))
交换变量 ＝ 时间数组 [位置变量1]  ' 数据组可以是变量、文件、数据库（这里用的是变量）
时间数组 [位置变量1] ＝ 时间数组 [位置变量1 ＋ 1]
时间数组 [位置变量1 ＋ 1] ＝ 交换变量  ' 以上3行代码是交换用的
最后位置 ＝ 位置变量1

变量循环尾 ()
未比数据数量1 ＝ 最后位置  ' 下一行排序从第一个数开始到上次排序的最后被改变的位数
判断循环尾 ()
超级列表框1.全部删除 ()
计次循环首 (取数组成员数 (时间数组), j)
调试输出 (时间数组 [j])
表项 ＝ 超级列表框1.插入表项 (, , , , , )
超级列表框1.置标题 (表项, 0, 到文本 (j ＋ 1))
超级列表框1.置标题 (表项, 1, 时间数组 [j])
计次循环尾 ()

i支持库列表	支持库注释
iext	扩展界面支持库一
spec	特殊功能支持库

.版本 2<br /> .支持库 iext<br /> .支持库 spec<br /> <br /> .子程序 排序时间<br /> .局部变量 i, 整数型<br /> .局部变量 时间参数, 文本型<br /> .局部变量 临时数组, 文本型, , "0"<br /> .局部变量 j, 整数型<br /> .局部变量 最后位置, 整数型<br /> .局部变量 未比数据数量, 整数型<br /> .局部变量 位置变量, 整数型<br /> .局部变量 临时数组1, 文本型, , "0"<br /> .局部变量 表项, 整数型<br /> .局部变量 时间数组, 文本型, , "0"<br /> .局部变量 交换变量, 文本型<br /> .局部变量 位置变量1, 整数型<br /> .局部变量 未比数据数量1, 整数型<br /> <br /> .计次循环首 (超级列表框1.取表项数 (), i)<br />     时间参数 ＝ 超级列表框1.取标题 (i － 1, 1)<br />     .如果真 (时间参数 ＝ “”)<br />         到循环尾 ()<br />     .如果真结束<br />     调试输出 (时间参数, i)<br />     加入成员 (时间数组, 时间参数)<br /> .计次循环尾 ()<br /> 未比数据数量 ＝ 取数组成员数 (时间数组)<br /> 未比数据数量1 ＝ 未比数据数量<br /> 调试输出 (“未比数据数量:”, 未比数据数量)<br /> .判断循环首 (未比数据数量 ＞ 0)<br />     最后位置 ＝ 0<br />     .变量循环首 (1, 未比数据数量 － 1, 1, 位置变量)<br />         文本_分割文本 (时间数组 [位置变量], “:”, , 临时数组)<br />         文本_分割文本 (时间数组 [位置变量 ＋ 1], “:”, , 临时数组1)<br />         调试输出 (“位置变量:”, 位置变量, 临时数组 [1])<br />         .如果真 (到整数 (临时数组 [1]) ＞ 到整数 (临时数组1 [1]))<br />             交换变量 ＝ 时间数组 [位置变量]  ' 数据组可以是变量、文件、数据库（这里用的是变量）<br />             时间数组 [位置变量] ＝ 时间数组 [位置变量 ＋ 1]<br />             时间数组 [位置变量 ＋ 1] ＝ 交换变量  ' 以上3行代码是交换用的<br />             最后位置 ＝ 位置变量<br />         .如果真结束<br /> <br />     .变量循环尾 ()<br />     未比数据数量 ＝ 最后位置  ' 下一行排序从第一个数开始到上次排序的最后被改变的位数<br /> .判断循环尾 ()<br /> .判断循环首 (未比数据数量1 ＞ 0)<br />     最后位置 ＝ 0<br />     .变量循环首 (1, 未比数据数量1 － 1, 1, 位置变量1)<br />         文本_分割文本 (时间数组 [位置变量1], “:”, , 临时数组)<br />         文本_分割文本 (时间数组 [位置变量1 ＋ 1], “:”, , 临时数组1)<br />         调试输出 (“位置变量:”, 位置变量1, 临时数组 [2])<br />         .如果真 (到整数 (临时数组 [2]) ＞ 到整数 (临时数组1 [2]) 且 到整数 (临时数组 [1]) ＝ 到整数 (临时数组1 [1]))<br />             交换变量 ＝ 时间数组 [位置变量1]  ' 数据组可以是变量、文件、数据库（这里用的是变量）<br />             时间数组 [位置变量1] ＝ 时间数组 [位置变量1 ＋ 1]<br />             时间数组 [位置变量1 ＋ 1] ＝ 交换变量  ' 以上3行代码是交换用的<br />             最后位置 ＝ 位置变量1<br />         .如果真结束<br /> <br />     .变量循环尾 ()<br />     未比数据数量1 ＝ 最后位置  ' 下一行排序从第一个数开始到上次排序的最后被改变的位数<br /> .判断循环尾 ()<br /> 超级列表框1.全部删除 ()<br /> .计次循环首 (取数组成员数 (时间数组), j)<br />     调试输出 (时间数组 [j])<br />     表项 ＝ 超级列表框1.插入表项 (, , , , , )<br />     超级列表框1.置标题 (表项, 0, 到文本 (j ＋ 1))<br />     超级列表框1.置标题 (表项, 1, 时间数组 [j])<br /> .计次循环尾 ()

壹吧

https://125.confly.eu.org/forum.php?mod ... 45&pid=30292736


人家发的可用啊，可以排序喔， 你咋想的。

走一回

如果后面出现14、23，估计你的排序方法还会出错的。可以考虑全部转化成秒来用整数进行排序。

1752328925

没什么问题，日期小的在前面

熬夜

给你个思路  比如 时间2000年 2000-1-1 0：0:0

你把你要排序的都加上
2000-1-1 0:16:17
2000-1-1 1:16:17

然后时间差 相减   进行结果对比大小 就可以 知道时间大小了

算法艺术家

  

子程序名	返回值类型	公开	备 注
超级列表框排序	整数型		返回排序时间,选中后排序还选中，必须项目数值不为0 没有默认为1
参数名	类 型	参考	可空	数组	备 注
对象	超级列表框
列索引	整数型				索引值从 0 开始。
实际数据	文本型				格式 {“今天:0”,“明天:1”}    # iiiou添加该参数
类型	整数型				0=数值;1=文本;2=日期时间;3=逻辑;4=图片索引   # iiiou添加类型4
区分大小写	逻辑型				真为区分,默认为真
排序方式	逻辑型				真为小到大,默认为真

变量名	类 型	静态	数组	备 注
排序时间	整数型
排序变量	文本型		0
序号数组	整数型		0
表项数值	整数型		0
图片数组	整数型		0	# iiiou添加
状态图片	整数型		0	# iiiou添加
变量	整数型
数据	文本型
列数	整数型
行数	整数型
单元数	整数型
选中项	整数型
i				# iiiou添加

排序时间 ＝ 取启动时间 ()
类型 ＝ 选择 (类型 ≥ 0 且 类型 ≤ 4, 类型, 1)
区分大小写 ＝ 选择 (是否为空 (区分大小写), 真, 区分大小写)
排序方式 ＝ 选择 (是否为空 (排序方式), 真, 排序方式)
如果真 (对象.现行选中项 ≠ -1)
如果真 (对象.取表项数值 (对象.现行选中项) ＝ 0)
对象.置表项数值 (对象.现行选中项, 1)
选中项 ＝ 对象.取表项数值 (对象.现行选中项)
计次循环首 (对象.取表项数 (), 变量)
如果 (类型 ＝ 4)  ' # iiiou添加
数据 ＝ 到文本 (对象.取图片 (变量 － 1, 列索引))
数据 ＝ 删首尾空 (对象.取标题 (变量 － 1, 列索引))
计次循环首 (取数组成员数 (实际数据), i)  ' # iiiou添加
如果真 (取文本左边 (实际数据 [i], 取文本长度 (数据) ＋ 1) ＝ 数据 ＋ “:”)
数据 ＝ 子文本替换 (实际数据 [i], 数据 ＋ “:”, “”, , , 真)
跳出循环 ()

计次循环尾 ()
如果 (类型 ≠ 3)
如果 (类型 ＝ 4)  ' # iiiou添加
单元数 ＝ 运算_二分查找 (排序变量, 数据, 0, 区分大小写)
单元数 ＝ 运算_二分查找 (排序变量, 数据, 类型, 区分大小写)
插入成员 (排序变量, 单元数, 数据)
插入成员 (序号数组, 单元数, 变量 － 1)
插入成员 (表项数值, 单元数, 对象.取表项数值 (变量 － 1))
插入成员 (状态图片, 单元数, 对象.取当前状态图片 (变量 － 1))  ' # iiiou添加
插入成员 (序号数组, 选择 (数据 ＝ “假”, 变量, 1), 变量 － 1)
插入成员 (表项数值, 选择 (数据 ＝ “假”, 变量, 1), 对象.取表项数值 (变量 － 1))
插入成员 (状态图片, 选择 (数据 ＝ “假”, 变量, 1), 对象.取当前状态图片 (变量 － 1))  ' # iiiou添加

计次循环尾 ()
列数 ＝ 对象.取列数 ()
行数 ＝ 取数组成员数 (序号数组)
单元数 ＝ 行数 × 列数
重定义数组 (排序变量, 假, 单元数)
重定义数组 (图片数组, 假, 单元数)  ' # iiiou添加
计次循环首 (单元数, 变量)
排序变量 [变量] ＝ 对象.取标题 (序号数组 [取绝对值 (选择 (排序方式, -1, 行数) ��� (变量 － 1) ＼ 列数)], (变量 － 1) ％ 列数)
图片数组 [变量] ＝ 对象.取图片 (序号数组 [取绝对值 (选择 (排序方式, -1, 行数) ��� (变量 － 1) ＼ 列数)], (变量 － 1) ％ 列数)  ' # iiiou添加
计次循环尾 ()
计次循环首 (单元数, 变量)
对象.置标题 ( (变量 － 1) ＼ 列数, (变量 － 1) ％ 列数, 排序变量 [变量])
对象.置表项数值 ( (变量 － 1) ＼ 列数, 表项数值 [取绝对值 (选择 (排序方式, -1, 行数) ��� (变量 － 1) ＼ 列数)])  ' 本来加个判断的,算啦,为了提高速度,多重复置表项数值几次吧:)
如果真 (图片数组 [变量] ≠ -1)
对象.置图片 ( (变量 － 1) ＼ 列数, (变量 － 1) ％ 列数, 图片数组 [变量])  ' # iiiou添加
如果真 (状态图片 [取绝对值 (选择 (排序方式, -1, 行数) ��� (变量 － 1) ＼ 列数)] ≠ -1)
对象.置状态图片 ( (变量 － 1) ＼ 列数, 状态图片 [取绝对值 (选择 (排序方式, -1, 行数) ��� (变量 － 1) ＼ 列数)])  ' # iiiou添加

计次循环尾 ()
如果真 (选中项 ≠ 0)
计次循环首 (对象.取表项数 (), 变量)
如果真 (对象.取表项数值 (变量 － 1) ＝ 选中项)
对象.现行选中项 ＝ 变量 － 1
对象.保证显示 (变量 － 1)
跳出循环 ()

计次循环尾 ()
返回 (取启动时间 () － 排序时间)

i支持库列表	支持库注释
iext	扩展界面支持库一

.版本 2<br /> .支持库 iext<br /> <br /> .子程序 超级列表框排序, 整数型, 公开, 返回排序时间,选中后排序还选中，必须项目数值不为0 没有默认为1<br /> .参数 对象, 超级列表框<br /> .参数 列索引, 整数型, , 索引值从 0 开始。<br /> .参数 实际数据, 文本型, 可空 数组, 格式 {“今天:0”,“明天:1”}    # iiiou添加该参数<br /> .参数 类型, 整数型, 可空, 0=数值;1=文本;2=日期时间;3=逻辑;4=图片索引   # iiiou添加类型4<br /> .参数 区分大小写, 逻辑型, 可空, 真为区分,默认为真<br /> .参数 排序方式, 逻辑型, 可空, 真为小到大,默认为真<br /> .局部变量 排序时间, 整数型<br /> .局部变量 排序变量, 文本型, , "0"<br /> .局部变量 序号数组, 整数型, , "0"<br /> .局部变量 表项数值, 整数型, , "0"<br /> .局部变量 图片数组, 整数型, , "0", # iiiou添加<br /> .局部变量 状态图片, 整数型, , "0", # iiiou添加<br /> .局部变量 变量, 整数型<br /> .局部变量 数据, 文本型<br /> .局部变量 列数, 整数型<br /> .局部变量 行数, 整数型<br /> .局部变量 单元数, 整数型<br /> .局部变量 选中项, 整数型<br /> .局部变量 i, , , , # iiiou添加<br /> <br /> 排序时间 ＝ 取启动时间 ()<br /> 类型 ＝ 选择 (类型 ≥ 0 且 类型 ≤ 4, 类型, 1)<br /> 区分大小写 ＝ 选择 (是否为空 (区分大小写), 真, 区分大小写)<br /> 排序方式 ＝ 选择 (是否为空 (排序方式), 真, 排序方式)<br /> .如果真 (对象.现行选中项 ≠ -1)<br />     .如果真 (对象.取表项数值 (对象.现行选中项) ＝ 0)<br />         对象.置表项数值 (对象.现行选中项, 1)<br />     .如果真结束<br />     选中项 ＝ 对象.取表项数值 (对象.现行选中项)<br /> .如果真结束<br /> .计次循环首 (对象.取表项数 (), 变量)<br />     .如果 (类型 ＝ 4)  ' # iiiou添加<br />         数据 ＝ 到文本 (对象.取图片 (变量 － 1, 列索引))<br />     .否则<br />         数据 ＝ 删首尾空 (对象.取标题 (变量 － 1, 列索引))<br />     .如果结束<br />     .计次循环首 (取数组成员数 (实际数据), i)  ' # iiiou添加<br />         .如果真 (取文本左边 (实际数据 <i>, 取文本长度 (数据) ＋ 1) ＝ 数据 ＋ “:”)<br />             数据 ＝ 子文本替换 (实际数据 <i>, 数据 ＋ “:”, “”, , , 真)<br />             跳出循环 ()<br />         .如果真结束<br /> <br />     .计次循环尾 ()<br />     .如果 (类型 ≠ 3)<br />         .如果 (类型 ＝ 4)  ' # iiiou添加<br />             单元数 ＝ 运算_二分查找 (排序变量, 数据, 0, 区分大小写)<br />         .否则<br />             单元数 ＝ 运算_二分查找 (排序变量, 数据, 类型, 区分大小写)<br />         .如果结束<br />         插入成员 (排序变量, 单元数, 数据)<br />         插入成员 (序号数组, 单元数, 变量 － 1)<br />         插入成员 (表项数值, 单元数, 对象.取表项数值 (变量 － 1))<br />         插入成员 (状态图片, 单元数, 对象.取当前状态图片 (变量 － 1))  ' # iiiou添加<br />     .否则<br />         插入成员 (序号数组, 选择 (数据 ＝ “假”, 变量, 1), 变量 － 1)<br />         插入成员 (表项数值, 选择 (数据 ＝ “假”, 变量, 1), 对象.取表项数值 (变量 － 1))<br />         插入成员 (状态图片, 选择 (数据 ＝ “假”, 变量, 1), 对象.取当前状态图片 (变量 － 1))  ' # iiiou添加<br />     .如果结束<br /> <br /> .计次循环尾 ()<br /> 列数 ＝ 对象.取列数 ()<br /> 行数 ＝ 取数组成员数 (序号数组)<br /> 单元数 ＝ 行数 × 列数<br /> 重定义数组 (排序变量, 假, 单元数)<br /> 重定义数组 (图片数组, 假, 单元数)  ' # iiiou添加<br /> .计次循环首 (单元数, 变量)<br />     排序变量 [变量] ＝ 对象.取标题 (序号数组 [取绝对值 (选择 (排序方式, -1, 行数) － (变量 － 1) ＼ 列数)], (变量 － 1) ％ 列数)<br />     图片数组 [变量] ＝ 对象.取图片 (序号数组 [取绝对值 (选择 (排序方式, -1, 行数) － (变量 － 1) ＼ 列数)], (变量 － 1) ％ 列数)  ' # iiiou添加<br /> .计次循环尾 ()<br /> .计次循环首 (单元数, 变量)<br />     对象.置标题 ((变量 － 1) ＼ 列数, (变量 － 1) ％ 列数, 排序变量 [变量])<br />     对象.置表项数值 ((变量 － 1) ＼ 列数, 表项数值 [取绝对值 (选择 (排序方式, -1, 行数) － (变量 － 1) ＼ 列数)])  ' 本来加个判断的,算啦,为了提高速度,多重复置表项数值几次吧:)<br />     .如果真 (图片数组 [变量] ≠ -1)<br />         对象.置图片 ((变量 － 1) ＼ 列数, (变量 － 1) ％ 列数, 图片数组 [变量])  ' # iiiou添加<br />     .如果真结束<br />     .如果真 (状态图片 [取绝对值 (选择 (排序方式, -1, 行数) － (变量 － 1) ＼ 列数)] ≠ -1)<br />         对象.置状态图片 ((变量 － 1) ＼ 列数, 状态图片 [取绝对值 (选择 (排序方式, -1, 行数) － (变量 － 1) ＼ 列数)])  ' # iiiou添加<br />     .如果真结束<br /> <br /> .计次循环尾 ()<br /> .如果真 (选中项 ≠ 0)<br />     .计次循环首 (对象.取表项数 (), 变量)<br />         .如果真 (对象.取表项数值 (变量 － 1) ＝ 选中项)<br />             对象.现行选中项 ＝ 变量 － 1<br />             对象.保证显示 (变量 － 1)<br />             跳出循环 ()<br />         .如果真结束<br /> <br />     .计次循环尾 ()<br /> <br /> .如果真结束<br /> 返回 (取启动时间 () － 排序时间)