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

APPLEUFO

https://bbs.125.la/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 /> 返回 (真)

tonc

大神，请收下我的膝盖，膜拜你，真的很厉害！

一指温柔

感谢分享

APPLEUFO

笨来无一悟 发表于 2025-6-24 04:01
整数 要看范围 小范围 比如最大值不超一千万的 用位图最快

我昨天试了一下  
还没写出来。就遇到几个问题
怀疑就算写出来了未必比桶排序快。省内存是没问题的
问题是现在的电脑不缺内存，宝贵的是时间  


我能想到这个位图算法费时间的点就是：他没办法以二进制存在数组长整数或字节里。所以是字节型数存储的.还是一个整数   

那么我修改未排序的 320   5    888  20    70，这几个位图地址的时候，那么  例如 5   和  20  

就得先读取第一格  1-64格的数组值。 然后修改第5格的二进制，然后保存
到了20 的时候，还得再读取第一个整数值，找到20格修改，再保存
就算5和20是相邻的。也没办法读取一次  修改一次，保存一次

1读取整数，2转换二进制，3修改二进制，4转换成十进制   
每修改一格的0和1，就得来上面4步，这样一次
肯定得耗费大量时间

APPLEUFO

你不丑 发表于 2025-6-24 15:17
哦哦 那可能不是精易模块的吧 我记错了 不好意思

一楼整数去重，桶排序的那个代码，我测试已经比精益模块的代码更快了，你可以试试看  按自己需要测试下速度怎么样

查过

感谢楼主分享！

豆豆灰常开心

全都是大佬~

该死dē蚊子

这个好，要的就是一个字：快

wjswzj0

感谢分享，很给力！~

18074941457

感谢分享，很给力！~

独孤求胜

纯易代码，不嵌入汇编还是太慢