数组去重复，再比原来快一倍，数组排序用了归并算法

APPLEUFO

https://125.confly.eu.org/forum.php?mod=viewthread&tid=14712534&extra=  
前面那帖子，排序后去重复

原来是文本的快速排序后，再循环对比

现在弄出文本的归并排序后，再循环对比了

文本的归并排序比 快速排序，快了3-5倍吧，速度也就又提起来了

  

子程序名	返回值类型	公开	备 注
数组模块_去重复7_排序后对比			排序过的   （1122334）（1234），也是非常快的，不输给去重复6。
参数名	类 型	参考	可空	数组	备 注
参数_文本	文本型
参数_重复数组	文本型

变量名	类 型	静态	数组	备 注
局变_原始文本开始的下标	整数型			跳转到下回开始对比的下标
n1	整数型			循环用
m1	整数型			重复数组的下标

如果真 (取数组成员数 (参数_文本) ＜ 2)    参数_重复数组 ＝ 参数_文本
返回 ()

' 数组模块_快速排序_文本 (参数_文本, 真)
排序模块_归并排序_迭代版_文本 (参数_文本, 真)
重定义数组 (参数_重复数组, 假, 取数组成员数 (参数_文本))
局变_原始文本开始的下标 ＝ 1
循环判断首 ()
变量循环首 (局变_原始文本开始的下标, 取数组成员数 (参数_文本) － 1, 1, n1)  ' 假定他现在前面几个都是重复的，开局就用变量循环
如果 (参数_文本 [n1] ＝ 参数_文本 [n1 ＋ 1])
' 调试输出 (参数_文本 [n1], 参数_文本 [n1 ＋ 1], “===”)
' 相等  无动作


' 调试输出 (参数_文本 [n1], 参数_文本 [n1 ＋ 1], “=!==!”)
m1 ＝ m1 ＋ 1
参数_重复数组 [m1] ＝ 参数_文本 [n1]  ' 不相等的上一个加入去重复
局变_原始文本开始的下标 ＝ n1 ＋ 1  ' 不相等的下一个 跳转进去。把变量循环的开始值设置成它
' 调试输出 (m1, 局变_原始文本开始的下标, 参数_文本 [n1], “-------------------”)
跳出循环 ()

变量循环尾 ()
' 调试输出 (n1, “=============================”)
如果真 (n1 ＝ 取数组成员数 (参数_文本))  ' 下标等于最后一个，它没办法和下一个比较了。就添加到去重复数组了
' 调试输出 (n1, 局变_原始文本开始的下标, , , 666)
m1 ＝ m1 ＋ 1
参数_重复数组 [m1] ＝ 参数_文本 [局变_原始文本开始的下标]  ' 局变_原始文本开始的下标  最后两种情况，相邻的两个相等或者不相等
跳出循环 ()

循环判断尾 (真)
重定义数组 (参数_重复数组, 真, m1)
' 不明白的是明明比6更紧凑，用的变量也少。还是不能大幅跑赢6///2025.6.19

.版本 2<br /> <br /> .子程序 数组模块_去重复7_排序后对比, , 公开, 排序过的   （1122334）（1234），也是非常快的，不输给去重复6。<br /> .参数 参数_文本, 文本型, 数组<br /> .参数 参数_重复数组, 文本型, 数组<br /> .局部变量 局变_原始文本开始的下标, 整数型, , , 跳转到下回开始对比的下标<br /> .局部变量 n1, 整数型, , , 循环用<br /> .局部变量 m1, 整数型, , , 重复数组的下标<br /> <br /> .如果真 (取数组成员数 (参数_文本) ＜ 2)    参数_重复数组 ＝ 参数_文本<br />     返回 ()<br /> .如果真结束<br /> <br /> ' 数组模块_快速排序_文本 (参数_文本, 真)<br /> 排序模块_归并排序_迭代版_文本 (参数_文本, 真)<br /> <br /> 重定义数组 (参数_重复数组, 假, 取数组成员数 (参数_文本))<br /> <br /> 局变_原始文本开始的下标 ＝ 1<br /> .循环判断首 ()<br /> <br />     .变量循环首 (局变_原始文本开始的下标, 取数组成员数 (参数_文本) － 1, 1, n1)  ' 假定他现在前面几个都是重复的，开局就用变量循环<br /> <br />         .如果 (参数_文本 [n1] ＝ 参数_文本 [n1 ＋ 1])<br />             ' 调试输出 (参数_文本 [n1], 参数_文本 [n1 ＋ 1], “===”)<br />             ' 相等  无动作<br />         .否则<br /> <br />             ' 调试输出 (参数_文本 [n1], 参数_文本 [n1 ＋ 1], “=!==!”)<br />             m1 ＝ m1 ＋ 1<br />             参数_重复数组 [m1] ＝ 参数_文本 [n1]  ' 不相等的上一个加入去重复<br /> <br />             局变_原始文本开始的下标 ＝ n1 ＋ 1  ' 不相等的下一个 跳转进去。把变量循环的开始值设置成它<br />             ' 调试输出 (m1, 局变_原始文本开始的下标, 参数_文本 [n1], “-------------------”)<br />             跳出循环 ()<br />         .如果结束<br /> <br />     .变量循环尾 ()<br />     ' 调试输出 (n1, “=============================”)<br /> <br />     .如果真 (n1 ＝ 取数组成员数 (参数_文本))  ' 下标等于最后一个，它没办法和下一个比较了。就添加到去重复数组了<br />         ' 调试输出 (n1, 局变_原始文本开始的下标, , , 666)<br />         m1 ＝ m1 ＋ 1<br />         参数_重复数组 [m1] ＝ 参数_文本 [局变_原始文本开始的下标]  ' 局变_原始文本开始的下标  最后两种情况，相邻的两个相等或者不相等<br />         跳出循环 ()<br />     .如果真结束<br /> <br /> .循环判断尾 (真)<br /> 重定义数组 (参数_重复数组, 真, m1)<br /> ' 不明白的是明明比6更紧凑，用的变量也少。还是不能大幅跑赢6///2025.6.19

至于整数型的去重复，直接用桶排序，测试速度比精益现在内置的的更快了

  

子程序名	返回值类型	公开	备 注
数组模块_去重复桶排序_整数型			因为是桶排序，所以极限是1-整数型最大（长整数型也行）
参数名	类 型	参考	可空	数组	备 注
参数_原始数组	整数型
参数_结果数组	整数型

变量名	类 型	静态	数组	备 注
局变_最大数	整数型
局变_桶子	整数型		0	根据 局变_最大数  定义需要 多少个桶子、、
n1	整数型
m1	整数型

计次循环首 (取数组成员数 (参数_原始数组), n1)  ' 找数组里面最大的数
如果真 (局变_最大数 ＜ 参数_原始数组 [n1])
局变_最大数 ＝ 参数_原始数组 [n1]

计次循环尾 ()
' 调试输出 (局变_最大数, “局变_最大数”)
重定义数组 (局变_桶子, 假, 局变_最大数)  ' 从 1 --- 最大值
计次循环首 (取数组成员数 (参数_原始数组), n1)
' 局变_临时 ＝ 参数_原始数组 [n1]
局变_桶子 [参数_原始数组 [n1]] ＝ 1
计次循环尾 ()
重定义数组 (参数_结果数组, 假, 取数组成员数 (参数_原始数组))
计次循环首 (取数组成员数 (局变_桶子), n1)
如果 (局变_桶子 [n1] ＝ 0)



m1 ＝ m1 ＋ 1
参数_结果数组 [m1] ＝ n1

计次循环尾 ()
重定义数组 (参数_结果数组, 真, m1)

子程序名	返回值类型	公开	备 注
数组模块_验证是否有重复_整数	逻辑型		有返回假 否则真   没有重复返回真
参数名	类 型	参考	可空	数组	备 注
参数_整数数组	整数型

变量名	类 型	静态	数组	备 注
n1	整数型
m1	整数型

数组排序 (参数_整数数组, 真)
计次循环首 (取数组成员数 (参数_整数数组) － 1, n1)
' 调试输出 (参数_整数数组 [n1], 参数_整数数组 [n1 ＋ 1], 666)
如果 (参数_整数数组 [n1] ＝ 参数_整数数组 [n1 ＋ 1])
返回 (假)


' 继续无动作

计次循环尾 ()
返回 (真)

.版本 2<br /> <br /> .子程序 数组模块_去重复桶排序_整数型, , 公开, 因为是桶排序，所以极限是1-整数型最大（长整数型也行）<br /> .参数 参数_原始数组, 整数型, 数组<br /> .参数 参数_结果数组, 整数型, 数组<br /> .局部变量 局变_最大数, 整数型<br /> .局部变量 局变_桶子, 整数型, , "0", 根据 局变_最大数  定义需要 多少个桶子、、  <br /> .局部变量 n1, 整数型<br /> .局部变量 m1, 整数型<br /> <br /> .计次循环首 (取数组成员数 (参数_原始数组), n1)  ' 找数组里面最大的数<br />     .如果真 (局变_最大数 ＜ 参数_原始数组 [n1])<br />         局变_最大数 ＝ 参数_原始数组 [n1]<br />     .如果真结束<br /> <br /> .计次循环尾 ()<br /> ' 调试输出 (局变_最大数, “局变_最大数”)<br /> <br /> 重定义数组 (局变_桶子, 假, 局变_最大数)  ' 从 1 --- 最大值<br /> <br /> .计次循环首 (取数组成员数 (参数_原始数组), n1)<br />     ' 局变_临时 ＝ 参数_原始数组 [n1]<br />     局变_桶子 [参数_原始数组 [n1]] ＝ 1<br /> .计次循环尾 ()<br /> <br /> 重定义数组 (参数_结果数组, 假, 取数组成员数 (参数_原始数组))<br /> <br /> .计次循环首 (取数组成员数 (局变_桶子), n1)<br /> <br />     .如果 (局变_桶子 [n1] ＝ 0)<br /> <br />     .否则<br /> <br />         m1 ＝ m1 ＋ 1<br />         参数_结果数组 [m1] ＝ n1<br />     .如果结束<br /> <br /> .计次循环尾 ()<br /> 重定义数组 (参数_结果数组, 真, m1)<br /> <br /> <br /> <br /> <br /> .子程序 数组模块_验证是否有重复_整数, 逻辑型, 公开, 有返回假 否则真   没有重复返回真<br /> .参数 参数_整数数组, 整数型, 数组<br /> .局部变量 n1, 整数型<br /> .局部变量 m1, 整数型<br /> <br /> 数组排序 (参数_整数数组, 真)<br /> <br /> .计次循环首 (取数组成员数 (参数_整数数组) － 1, n1)<br /> <br />     ' 调试输出 (参数_整数数组 [n1], 参数_整数数组 [n1 ＋ 1], 666)<br /> <br />     .如果 (参数_整数数组 [n1] ＝ 参数_整数数组 [n1 ＋ 1])<br />         返回 (假)<br />     .否则<br /> <br />         ' 继续无动作<br />     .如果结束<br /> <br /> .计次循环尾 ()<br /> <br /> 返回 (真)

股老传奇

非常不错！！！

今时以至遂渐开

感谢分享，很给力！~

APPLEUFO

黑咖啡 发表于 2025-6-27 10:48
那个校验类似生成哈希值，但是只会输出0-65535，易语言下标从1开始，所以0替换成65536。
如果校验的值一 ...

哦 原来如此   。我觉得你那个65535的类数组  和校验函数 也可以考虑一下  封装进去重复类里面。更简洁完美一些。在类外面就不用暴露设定太多

黑咖啡

APPLEUFO 发表于 2025-6-27 10:01
.版本 2

' * “7 秒 484 毫秒 ”

那个校验类似生成哈希值，但是只会输出0-65535，易语言下标从1开始，所以0替换成65536。
如果校验的值一样，那他们就在同一个类里进行比较，用的循环比较，当然也可以用其他更快的方法。
你也可以另外研究其他校验换算方法，只要能把文本型尽量的换算成相对均匀的整数分配到桶里也行的。比如除法缩放法，越简洁效率越高。
相当于提前预制足够多的桶，这样就能更少的比较，类似二分法吧，先粗略的分类一次，第二次数据量少了在精准比较。
当然了能根据成员数量，成员长度等，动态分配桶数量那就更高效了，前提是生成的哈希值要足够均匀把桶利用起来，不然大量都分在一个桶里也是慢的。

pipicool

学习一下

APPLEUFO

黑咖啡 发表于 2025-6-26 10:49
再给你发个

.版本 2

' * “7 秒 484 毫秒 ”
' * “子程序1===============” | 500000
' * “36 秒 234 毫秒 ”
' * “去重复7===============” | 500000





36秒太长，我有点怀疑   两次测试的顺序颠倒一下就这样了
你的测试不标准，数据污染或者数组未清空。导致后面第二组的测试时间很长

第二轮测试还是得拷贝个一模一样的新变量来测试  

拷贝1个BBB的数组就好  ，全新变量，未被排序污染的原始数组数据



你写的算法  速度还是很快的，能比07方法快了一倍！
是啥原理说说看  去重的类  ，  是类似哈希值的算法么


上面测试是数组里大量不重复类型的。
下面图测试的是数组里 大量重复类型的。的确是很快啊。比我那个快了10倍   。服了

  

调试输出 (“======================================================”)
调试模块_创建整数型数组_有重复 (zzz, 100000 × 10, 1, 1000)  ' 1000000
转换模块_整数型数组转文本型数组 (zzz, aaa)
bbb ＝ aaa
' ccc ＝ aaa
调试输出 (“开始 ---------- ”)
计时器启动 ()
数组模块_去重复7_排序后对比 (aaa, aaa_结果)
计时器结束 ()
调试输出 (“===============”, 取数组成员数 (aaa_结果))
计时器启动 ()
子程序1 (bbb, bbb_结果)
计时器结束 ()
调试输出 (“===============”, 取数组成员数 (bbb_结果))
' 调试输出 (数组模块_判断文本数组是否完全相等 (aaa, bbb))
' 调试输出 (数组模块_判断文本数组是否完全相等 (aaa, bbb))
' 调试输出 (数组模块_判断文本数组是否完全相等 (aaa, ccc))
调试输出 (“======================================================”)
鸣叫 ()
鸣叫 ()
结束 ()

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

.版本 2<br /> .支持库 spec<br /> <br /> 调试输出 (“======================================================”)<br /> <br /> 调试模块_创建整数型数组_有重复 (zzz, 100000 × 10, 1, 1000)  ' 1000000<br /> 转换模块_整数型数组转文本型数组 (zzz, aaa)<br /> bbb ＝ aaa<br /> ' ccc ＝ aaa<br /> 调试输出 (“开始 ---------- ”)<br /> <br /> 计时器启动 ()<br /> 数组模块_去重复7_排序后对比 (aaa, aaa_结果)<br /> <br /> 计时器结束 ()<br /> 调试输出 (“===============”, 取数组成员数 (aaa_结果))<br /> <br /> 计时器启动 ()<br /> 子程序1 (bbb, bbb_结果)<br /> 计时器结束 ()<br /> 调试输出 (“===============”, 取数组成员数 (bbb_结果))<br /> <br /> <br /> ' 调试输出 (数组模块_判断文本数组是否完全相等 (aaa, bbb))<br /> ' 调试输出 (数组模块_判断文本数组是否完全相等 (aaa, bbb))<br /> ' 调试输出 (数组模块_判断文本数组是否完全相等 (aaa, ccc))<br /> 调试输出 (“======================================================”)<br /> <br /> 鸣叫 ()<br /> 鸣叫 ()<br /> 结束 ()

另外的问题就是  为啥是65536？
备注里写 待完善，缺少清空。创建和销毁很慢因为数组65536太大

你是一下创建65536个类，如果要计算的数据太大，甚至65536个数组都不够用，计算出的校验值里出现冲突。  ，那么就会出现重复了吧？

下面这个是 ？

  

子程序名	返回值类型	公开	备 注
CRC16_MODBUS校验	整数型
参数名	类 型	参考	可空	数组	备 注
输入值	文本型

变量名	类 型	静态	数组	备 注
局_输入字节集	字节集
CRC寄存器	整数型
m	整数型

局_输入字节集 ＝ 到字节集 (输入值)
CRC寄存器 ＝ 65535
计次循环首 (取字节集长度 (局_输入字节集), m)
CRC寄存器 ＝ 位异或 (CRC寄存器, 局_输入字节集 [m])
计次循环首 (8, )
判断 (位与 (CRC寄存器, 1) ＝ 0)
CRC寄存器 ＝ 右移 (CRC寄存器, 1)
CRC寄存器 ＝ 右移 (CRC寄存器, 1)
CRC寄存器 ＝ 位异或 (CRC寄存器, 十六进制 (“A001”))

计次循环尾 ()
计次循环尾 ()
判断 (0 ＜ CRC寄存器 且 CRC寄存器 ＜ 65536)
返回 (CRC寄存器)
返回 (65536)

.版本 2<br /> <br /> .子程序 CRC16_MODBUS校验, 整数型<br /> .参数 输入值, 文本型<br /> .局部变量 局_输入字节集, 字节集<br /> .局部变量 CRC寄存器, 整数型<br /> .局部变量 m, 整数型<br /> <br /> 局_输入字节集 ＝ 到字节集 (输入值)<br /> CRC寄存器 ＝ 65535<br /> .计次循环首 (取字节集长度 (局_输入字节集), m)<br />     CRC寄存器 ＝ 位异或 (CRC寄存器, 局_输入字节集 [m])<br />     .计次循环首 (8, )<br />         .判断开始 (位与 (CRC寄存器, 1) ＝ 0)<br />             CRC寄存器 ＝ 右移 (CRC寄存器, 1)<br />         .默认<br />             CRC寄存器 ＝ 右移 (CRC寄存器, 1)<br />             CRC寄存器 ＝ 位异或 (CRC寄存器, 十六进制 (“A001”))<br />         .判断结束<br /> <br />     .计次循环尾 ()<br /> .计次循环尾 ()<br /> .判断开始 (0 ＜ CRC寄存器 且 CRC寄存器 ＜ 65536)<br />     返回 (CRC寄存器)<br /> .默认<br />     返回 (65536)

please

感谢分享，支持开源！！！

黑咖啡

再给你发个

小虎来了

感谢分享，很给力！~

查过

全都是大佬~