[Exui]超级列表框排序，完美通用排序！！！

观音

排序源码我忘记哪里拿到的了，后面我改动了一下
支持：项目文本、项目附加数值、项目选择框、项目尺寸、项目字体色（支持每个表项每列字体不同）同步排序


使用二分查找进行排序，这个源码我忘了哪里下的了，我没有改动


调用代码截图：





排序代码截图：



回复直接查看源码，无需下载，直接复制代码即可调用

超级列表框通用排序.e (13.2 KB, 下载次数: 231)

2024-7-31 20:46 上传

点击文件名下载附件
下载积分: 精币 -2 枚

  

子程序名	返回值类型	公开	备 注
_ListBox_Crowd_项目左键单击	整数型		这里是调用代码，拷贝下面两个子程序即可进行排序
参数名	类 型	参考	可空	数组	备 注
项目索引	整数型
列索引	整数型
元素索引	整数型
事件来源	整数型

变量名	类 型	静态	数组	备 注
LastColumn	整数型
LastSortOrder	逻辑型

判断 (事件来源 ＝ 1)
如果 (LastColumn ＝ 列索引)
LastSortOrder ＝ 取反 (LastSortOrder)
LastSortOrder ＝ 真
LastColumn ＝ 列索引
判断 (列索引 ＝ 0 或 列索引 ＝ 3)
超级列表框排序 (ListBox_Crowd, 列索引, 0, 真, LastSortOrder)
判断 (列索引 ＝ 6)
超级列表框排序 (ListBox_Crowd, 列索引, 2, 真, LastSortOrder)
超级列表框排序 (ListBox_Crowd, 列索引, 1, 真, LastSortOrder)

子程序名	返回值类型	公开	备 注
超级列表框排序	整数型		返回排序时间,选中后排序还选中，必须项目数值不为0 没有默认为1
参数名	类 型	参考	可空	数组	备 注
对象	超级列表框EX
列索引	整数型				索引值从 0 开始。
类型	整数型				0=数值;1=文本;2=日期时间;3=逻辑
区分大小写	逻辑型				真为区分,默认为真
排序方式	逻辑型				真为小到大,默认为真
选择框列	整数型				留空或小于0则不处理，注意：如果表项未添加选择框一定不要设置

变量名	类 型	静态	数组	备 注
排序时间	整数型
排序变量	文本型		0
序号数组	整数型		0
表项数值	整数型		0
变量	整数型
数据	文本型
列数	整数型
行数	整数型
单元数	整数型
选中项	整数型
背景颜色	整数型		0
项目尺寸	整数型		0
选择框状态	整数型		0
组件句柄	整数型

如果 (是否为空 (选择框列))
选择框列 ＝ -1
组件句柄 ＝ 组件取窗口绑定组件 (对象.取窗口句柄 ())
排序时间 ＝ 取启动时间 ()
类型 ＝ 选择 (类型 ≥ 0 且 类型 ≤ 3, 类型, 1)
区分大小写 ＝ 选择 (是否为空 (区分大小写), 真, 区分大小写)
排序方式 ＝ 选择 (是否为空 (排序方式), 真, 排序方式)
如果真 (对象.现行选中项 ≠ -1)
如果真 (对象.取项目附加数值 (对象.现行选中项) ＝ 0)
对象.置项目附加数值 (对象.现行选中项, 1)
选中项 ＝ 对象.取项目附加数值 (对象.现行选中项)
计次循环首 (对象.取项目数量 (), 变量)
数据 ＝ 删首尾空 (对象.取项目文本 (变量 － 1, 列索引))
如果 (类型 ≠ 3)
单元数 ＝ 二分查找 (排序变量, 数据, 类型, 区分大小写)
插入成员 (排序变量, 单元数, 数据)
插入成员 (序号数组, 单元数, 变量 － 1)
插入成员 (表项数值, 单元数, 对象.取项目附加数值 (变量 － 1))
插入成员 (项目尺寸, 单元数, 对象.取项目尺寸 (变量 － 1))
如果真 (选择框列 ＞ -1)
插入成员 (选择框状态, 单元数, 组件取选择框元素数据 (组件句柄, #元素归属_超列项目, 变量 － 1, 选择框列, 0, 16))

插入成员 (序号数组, 选择 (数据 ＝ “假”, 变量, 1), 变量 － 1)
插入成员 (表项数值, 选择 (数据 ＝ “假”, 变量, 1), 对象.取项目附加数值 (变量 － 1))
插入成员 (项目尺寸, 选择 (数据 ＝ “假”, 变量, 1), 对象.取项目尺寸 (变量 － 1))
如果真 (选择框列 ＞ -1)
插入成员 (选择框状态, 选择 (数据 ＝ “假”, 变量, 1), 组件取选择框元素数据 (组件句柄, #元素归属_超列项目, 变量 － 1, 选择框列, 0, 16))


计次循环尾 ()
列数 ＝ 对象.取列数量 ()
行数 ＝ 取数组成员数 (序号数组)
单元数 ＝ 行数 × 列数
重定义数组 (排序变量, 假, 单元数)
重定义数组 (背景颜色, 假, 单元数)
计次循环首 (单元数, 变量)
排序变量 [变量] ＝ 对象.取项目文本 (序号数组 [取绝对值 (选择 (排序方式, -1, 行数) ��� (变量 － 1) ＼ 列数)], (变量 － 1) ％ 列数)
背景颜色 [变量] ＝ 对象.取字体色 (序号数组 [取绝对值 (选择 (排序方式, -1, 行数) ��� (变量 － 1) ＼ 列数)], (变量 － 1) ％ 列数)
计次循环尾 ()
计次循环首 (单元数, 变量)
对象.置项目文本 ( (变量 － 1) ＼ 列数, (变量 － 1) ％ 列数, 排序变量 [变量])
对象.置字体色 ( (变量 － 1) ＼ 列数, (变量 － 1) ％ 列数, 背景颜色 [变量])
对象.置项目附加数值 ( (变量 － 1) ＼ 列数, 表项数值 [取绝对值 (选择 (排序方式, -1, 行数) ��� (变量 － 1) ＼ 列数)])
对象.置项目尺寸 ( (变量 － 1) ＼ 列数, 项目尺寸 [取绝对值 (选择 (排序方式, -1, 行数) ��� (变量 － 1) ＼ 列数)])
如果真 (选择框列 ＞ -1)
组件置选择框元素数据 (组件句柄, #元素归属_超列项目, (变量 － 1) ＼ 列数, 选择框列, 0, 0, 1, 0, “”, 0, 选择框状态 [取绝对值 (选择 (排序方式, -1, 行数) ��� (变量 － 1) ＼ 列数)])

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

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

子程序名	返回值类型	公开	备 注
二分查找	整数型
参数名	类 型	参考	可空	数组	备 注
数组	文本型
待查	文本型
类型	整数型
区分大小写	逻辑型

变量名	类 型	静态	数组	备 注
K	整数型
M	整数型
J	整数型
数值A	双精度小数型
数值B	双精度小数型
文本	文本型

K ＝ 1
M ＝ 取数组成员数 (数组)
如果真 (M ＝ 0)
返回 (1)
判断 (类型 ＝ 0)
数值A ＝ 到数值 (待查)
如果真 (数值A ≥ 到数值 (数组 [M]))
返回 (M ＋ 1)
如果真 (数值A ≤ 到数值 (数组 [1]))
返回 (1)
判断循环首 (K ＜ M － 1)
J ＝ (K ＋ M) ＼ 2
数值B ＝ 到数值 (数组 [J])
如果真 (数值A ＝ 数值B)
K ＝ J
跳出循环 ()
如果 (数值A ＜ 数值B)
M ＝ J
K ＝ J

判断循环尾 ()
判断 (类型 ＝ 1)
如果真 (文本比较 (待查, 数组 [M], 区分大小写) ≥ 0)
返回 (M ＋ 1)
如果真 (文本比较 (待查, 数组 [1], 区分大小写) ≤ 0)
返回 (1)
判断循环首 (K ＜ M － 1)
J ＝ (K ＋ M) ＼ 2
如果真 (文本比较 (待查, 数组 [J], 区分大小写) ＝ 0)
K ＝ J
跳出循环 ()
如果 (文本比较 (待查, 数组 [J], 区分大小写) ＜ 0)
M ＝ J
K ＝ J

判断循环尾 ()
判断 (类型 ＝ 2)
数值A ＝ 取字节集数据 (到字节集 (到时间 (待查)), #双精度小数型, )
如果真 (数值A ≥ 取字节集数据 (到字节集 (到时间 (数组 [M])), #双精度小数型, ))
返回 (M ＋ 1)
如果真 (数值A ≤ 取字节集数据 (到字节集 (到时间 (数组 [1])), #双精度小数型, ))
返回 (1)
判断循环首 (K ＜ M － 1)
J ＝ (K ＋ M) ＼ 2
数值B ＝ 取字节集数据 (到字节集 (到时间 (数组 [J])), #双精度小数型, )
如果真 (数值A ＝ 数值B)
K ＝ J
跳出循环 ()
如果 (数值A ＜ 数值B)
M ＝ J
K ＝ J

判断循环尾 ()


返回 (K ＋ 1)

i支持库列表	支持库注释
ExuiKrnln	(未知支持库)

.版本 2<br /> .支持库 ExuiKrnln<br /> <br /> .子程序 _ListBox_Crowd_项目左键单击, 整数型, , 这里是调用代码，拷贝下面两个子程序即可进行排序<br /> .参数 项目索引, 整数型<br /> .参数 列索引, 整数型<br /> .参数 元素索引, 整数型<br /> .参数 事件来源, 整数型<br /> .局部变量 LastColumn, 整数型, 静态<br /> .局部变量 LastSortOrder, 逻辑型, 静态<br /> <br /> .判断开始 (事件来源 ＝ 1)<br />     .如果 (LastColumn ＝ 列索引)<br />         LastSortOrder ＝ 取反 (LastSortOrder)<br />     .否则<br />         LastSortOrder ＝ 真<br />     .如果结束<br />     LastColumn ＝ 列索引<br />     .判断开始 (列索引 ＝ 0 或 列索引 ＝ 3)<br />         超级列表框排序 (ListBox_Crowd, 列索引, 0, 真, LastSortOrder)<br />     .判断 (列索引 ＝ 6)<br />         超级列表框排序 (ListBox_Crowd, 列索引, 2, 真, LastSortOrder)<br />     .默认<br />         超级列表框排序 (ListBox_Crowd, 列索引, 1, 真, LastSortOrder)<br />     .判断结束<br /> <br /> .默认<br /> <br /> .判断结束<br /> <br /> <br /> .子程序 超级列表框排序, 整数型, 公开, 返回排序时间,选中后排序还选中，必须项目数值不为0 没有默认为1<br /> .参数 对象, 超级列表框EX<br /> .参数 列索引, 整数型, , 索引值从 0 开始。<br /> .参数 类型, 整数型, 可空, 0=数值;1=文本;2=日期时间;3=逻辑<br /> .参数 区分大小写, 逻辑型, 可空, 真为区分,默认为真<br /> .参数 排序方式, 逻辑型, 可空, 真为小到大,默认为真<br /> .参数 选择框列, 整数型, 可空, 留空或小于0则不处理，注意：如果表项未添加选择框一定不要设置<br /> .局部变量 排序时间, 整数型<br /> .局部变量 排序变量, 文本型, , "0"<br /> .局部变量 序号数组, 整数型, , "0"<br /> .局部变量 表项数值, 整数型, , "0"<br /> .局部变量 变量, 整数型<br /> .局部变量 数据, 文本型<br /> .局部变量 列数, 整数型<br /> .局部变量 行数, 整数型<br /> .局部变量 单元数, 整数型<br /> .局部变量 选中项, 整数型<br /> .局部变量 背景颜色, 整数型, , "0"<br /> .局部变量 项目尺寸, 整数型, , "0"<br /> .局部变量 选择框状态, 整数型, , "0"<br /> .局部变量 组件句柄, 整数型<br /> <br /> .如果 (是否为空 (选择框列))<br />     选择框列 ＝ -1<br /> .否则<br />     组件句柄 ＝ 组件取窗口绑定组件 (对象.取窗口句柄 ())<br /> .如果结束<br /> 排序时间 ＝ 取启动时间 ()<br /> 类型 ＝ 选择 (类型 ≥ 0 且 类型 ≤ 3, 类型, 1)<br /> 区分大小写 ＝ 选择 (是否为空 (区分大小写), 真, 区分大小写)<br /> 排序方式 ＝ 选择 (是否为空 (排序方式), 真, 排序方式)<br /> .如果真 (对象.现行选中项 ≠ -1)<br />     .如果真 (对象.取项目附加数值 (对象.现行选中项) ＝ 0)<br />         对象.置项目附加数值 (对象.现行选中项, 1)<br />     .如果真结束<br />     选中项 ＝ 对象.取项目附加数值 (对象.现行选中项)<br /> .如果真结束<br /> .计次循环首 (对象.取项目数量 (), 变量)<br />     数据 ＝ 删首尾空 (对象.取项目文本 (变量 － 1, 列索引))<br />     .如果 (类型 ≠ 3)<br />         单元数 ＝ 二分查找 (排序变量, 数据, 类型, 区分大小写)<br />         插入成员 (排序变量, 单元数, 数据)<br />         插入成员 (序号数组, 单元数, 变量 － 1)<br />         插入成员 (表项数值, 单元数, 对象.取项目附加数值 (变量 － 1))<br />         插入成员 (项目尺寸, 单元数, 对象.取项目尺寸 (变量 － 1))<br />         .如果真 (选择框列 ＞ -1)<br />             插入成员 (选择框状态, 单元数, 组件取选择框元素数据 (组件句柄, #元素归属_超列项目, 变量 － 1, 选择框列, 0, 16))<br />         .如果真结束<br /> <br />     .否则<br />         插入成员 (序号数组, 选择 (数据 ＝ “假”, 变量, 1), 变量 － 1)<br />         插入成员 (表项数值, 选择 (数据 ＝ “假”, 变量, 1), 对象.取项目附加数值 (变量 － 1))<br />         插入成员 (项目尺寸, 选择 (数据 ＝ “假”, 变量, 1), 对象.取项目尺寸 (变量 － 1))<br />         .如果真 (选择框列 ＞ -1)<br />             插入成员 (选择框状态, 选择 (数据 ＝ “假”, 变量, 1), 组件取选择框元素数据 (组件句柄, #元素归属_超列项目, 变量 － 1, 选择框列, 0, 16))<br />         .如果真结束<br /> <br />     .如果结束<br /> <br /> .计次循环尾 ()<br /> 列数 ＝ 对象.取列数量 ()<br /> 行数 ＝ 取数组成员数 (序号数组)<br /> 单元数 ＝ 行数 × 列数<br /> 重定义数组 (排序变量, 假, 单元数)<br /> 重定义数组 (背景颜色, 假, 单元数)<br /> .计次循环首 (单元数, 变量)<br />     排序变量 [变量] ＝ 对象.取项目文本 (序号数组 [取绝对值 (选择 (排序方式, -1, 行数) － (变量 － 1) ＼ 列数)], (变量 － 1) ％ 列数)<br />     背景颜色 [变量] ＝ 对象.取字体色 (序号数组 [取绝对值 (选择 (排序方式, -1, 行数) － (变量 － 1) ＼ 列数)], (变量 － 1) ％ 列数)<br /> .计次循环尾 ()<br /> .计次循环首 (单元数, 变量)<br />     对象.置项目文本 ((变量 － 1) ＼ 列数, (变量 － 1) ％ 列数, 排序变量 [变量])<br />     对象.置字体色 ((变量 － 1) ＼ 列数, (变量 － 1) ％ 列数, 背景颜色 [变量])<br />     对象.置项目附加数值 ((变量 － 1) ＼ 列数, 表项数值 [取绝对值 (选择 (排序方式, -1, 行数) － (变量 － 1) ＼ 列数)])<br />     对象.置项目尺寸 ((变量 － 1) ＼ 列数, 项目尺寸 [取绝对值 (选择 (排序方式, -1, 行数) － (变量 － 1) ＼ 列数)])<br />     .如果真 (选择框列 ＞ -1)<br />         组件置选择框元素数据 (组件句柄, #元素归属_超列项目, (变量 － 1) ＼ 列数, 选择框列, 0, 0, 1, 0, “”, 0, 选择框状态 [取绝对值 (选择 (排序方式, -1, 行数) － (变量 － 1) ＼ 列数)])<br />     .如果真结束<br /> <br /> .计次循环尾 ()<br /> .如果真 (选中项 ≠ 0)<br />     .计次循环首 (对象.取项目数量 (), 变量)<br />         .如果真 (对象.取项目附加数值 (变量 － 1) ＝ 选中项)<br />             对象.现行选中项 ＝ 变量 － 1<br />             对象.保证显示 (变量 － 1, , )<br />             跳出循环 ()<br />         .如果真结束<br /> <br />     .计次循环尾 ()<br /> .如果真结束<br /> 返回 (取启动时间 () － 排序时间)<br /> <br /> .子程序 二分查找, 整数型<br /> .参数 数组, 文本型, 数组<br /> .参数 待查, 文本型<br /> .参数 类型, 整数型<br /> .参数 区分大小写, 逻辑型<br /> .局部变量 K, 整数型<br /> .局部变量 M, 整数型<br /> .局部变量 J, 整数型<br /> .局部变量 数值A, 双精度小数型<br /> .局部变量 数值B, 双精度小数型<br /> .局部变量 文本, 文本型<br /> <br /> K ＝ 1<br /> M ＝ 取数组成员数 (数组)<br /> .如果真 (M ＝ 0)<br />     返回 (1)<br /> .如果真结束<br /> .判断开始 (类型 ＝ 0)<br />     数值A ＝ 到数值 (待查)<br />     .如果真 (数值A ≥ 到数值 (数组 [M]))<br />         返回 (M ＋ 1)<br />     .如果真结束<br />     .如果真 (数值A ≤ 到数值 (数组 [1]))<br />         返回 (1)<br />     .如果真结束<br />     .判断循环首 (K ＜ M － 1)<br />         J ＝ (K ＋ M) ＼ 2<br />         数值B ＝ 到数值 (数组 [J])<br />         .如果真 (数值A ＝ 数值B)<br />             K ＝ J<br />             跳出循环 ()<br />         .如果真结束<br />         .如果 (数值A ＜ 数值B)<br />             M ＝ J<br />         .否则<br />             K ＝ J<br />         .如果结束<br /> <br />     .判断循环尾 ()<br /> .判断 (类型 ＝ 1)<br />     .如果真 (文本比较 (待查, 数组 [M], 区分大小写) ≥ 0)<br />         返回 (M ＋ 1)<br />     .如果真结束<br />     .如果真 (文本比较 (待查, 数组 [1], 区分大小写) ≤ 0)<br />         返回 (1)<br />     .如果真结束<br />     .判断循环首 (K ＜ M － 1)<br />         J ＝ (K ＋ M) ＼ 2<br />         .如果真 (文本比较 (待查, 数组 [J], 区分大小写) ＝ 0)<br />             K ＝ J<br />             跳出循环 ()<br />         .如果真结束<br />         .如果 (文本比较 (待查, 数组 [J], 区分大小写) ＜ 0)<br />             M ＝ J<br />         .否则<br />             K ＝ J<br />         .如果结束<br /> <br />     .判断循环尾 ()<br /> .判断 (类型 ＝ 2)<br />     数值A ＝ 取字节集数据 (到字节集 (到时间 (待查)), #双精度小数型, )<br />     .如果真 (数值A ≥ 取字节集数据 (到字节集 (到时间 (数组 [M])), #双精度小数型, ))<br />         返回 (M ＋ 1)<br />     .如果真结束<br />     .如果真 (数值A ≤ 取字节集数据 (到字节集 (到时间 (数组 [1])), #双精度小数型, ))<br />         返回 (1)<br />     .如果真结束<br />     .判断循环首 (K ＜ M － 1)<br />         J ＝ (K ＋ M) ＼ 2<br />         数值B ＝ 取字节集数据 (到字节集 (到时间 (数组 [J])), #双精度小数型, )<br />         .如果真 (数值A ＝ 数值B)<br />             K ＝ J<br />             跳出循环 ()<br />         .如果真结束<br />         .如果 (数值A ＜ 数值B)<br />             M ＝ J<br />         .否则<br />             K ＝ J<br />         .如果结束<br /> <br />     .判断循环尾 ()<br /> .默认<br /> <br /> .判断结束<br /> 返回 (K ＋ 1)

zkijf

感谢分享，很给力！~

蓝色枫

好给力给力

小姐2

13.2 KB, 下载次数: 194

妖月红莲

感谢分享

iceking777

感谢分享，很给力！~

2027

支持一下

1183297959

感谢分享，很给力！~

zssm

.............

aslihai007

学习学习