精易模块【文本_去重复文本】优化建议

禁回忆

先说结论，今天我现写的这个文本去重，效率大约是现有的开源免费的最新版本的精易模块中【文本_去重复文本】的三倍左右。
在测试中，万字的速度提升尤为明显，稍微不到精易模块的四倍，十万字稍不到三倍，百万字三倍速度。
当然，这是随机字符的测试结果，再极特殊的情况下，现写的这个子程序理论上耗时也会比精易模块的【文本_去重复文本】少40%左右，具体是多少我这懒得算了。
这个优化主要优化在检测文本是否存在和分割文本上。类比冒泡排序和冒泡排序的优化版。
精易模块对分割后的文本与其他文本段都进行了对比，而已知当前文本段是重复的文本时是不需要再去对比的。

就现在来看，效率还能进一步提升。

优化后的代码先贴出来，具体测试结果请往后看
测试源代码：
使用模块【精易模块】
文本重复测试.e (870.07 KB, 下载次数: 24)

2020-12-29 16:40 上传

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

优化版本

  

子程序名	返回值类型	公开	备 注
文本_去重复文本3	文本型
参数名	类 型	参考	可空	数组	备 注
原文本	文本型
分割符	文本型				原文本单个内容间的分隔符，例如：---  留空为：逐字分割

变量名	类 型	静态	数组	备 注
局_数组	文本型		0
局_计次	整数型
局_次数	整数型
局_临时数组	文本型		0
局_计次1	整数型
局_次数1	整数型
局_文本	文本型

如果 (是否为空 (分割符))
文本_逐字分割_汇编 (原文本, 局_数组)
局_数组 ＝ 分割文本 (原文本, 分割符, )

局_次数 ＝ 取数组成员数 (局_数组)
计次循环首 (局_次数, 局_计次)
局_次数1 ＝ 取数组成员数 (局_临时数组)
计次循环首 (局_次数1, 局_计次1)
' 如果相同，则不循环，直接跳出
如果真 (局_数组 [局_计次] ＝ 局_临时数组 [局_计次1])
跳出循环 ()
' 如果是最后一个，还没有重复的，则加入
如果真 (局_计次1 ＝ 局_次数1)
加入成员 (局_临时数组, 局_数组 [局_计次])
局_文本 ＝ 局_文本 ＋ 局_数组 [局_计次] ＋ 分割符

计次循环尾 ()
计次循环尾 ()
局_文本 ＝ 取文本左边 (局_文本, 取文本长度 (局_文本) － 取文本长度 (分割符))
返回 (局_文本)

.版本 2<br /> <br /> .子程序 文本_去重复文本3, 文本型<br /> .参数 原文本, 文本型<br /> .参数 分割符, 文本型, 可空, 原文本单个内容间的分隔符，例如：---  留空为：逐字分割<br /> .局部变量 局_数组, 文本型, , "0"<br /> .局部变量 局_计次, 整数型<br /> .局部变量 局_次数, 整数型<br /> .局部变量 局_临时数组, 文本型, , "0"<br /> .局部变量 局_计次1, 整数型<br /> .局部变量 局_次数1, 整数型<br /> .局部变量 局_文本, 文本型<br /> <br /> .如果 (是否为空 (分割符))<br />     文本_逐字分割_汇编 (原文本, 局_数组)<br /> .否则<br />     局_数组 ＝ 分割文本 (原文本, 分割符, )<br /> .如果结束<br /> <br /> 局_次数 ＝ 取数组成员数 (局_数组)<br /> .计次循环首 (局_次数, 局_计次)<br /> <br />     局_次数1 ＝ 取数组成员数 (局_临时数组)<br /> <br />     .计次循环首 (局_次数1, 局_计次1)<br />         ' 如果相同，则不循环，直接跳出<br />         .如果真 (局_数组 [局_计次] ＝ 局_临时数组 [局_计次1])<br />             跳出循环 ()<br />         .如果真结束<br />         ' 如果是最后一个，还没有重复的，则加入<br />         .如果真 (局_计次1 ＝ 局_次数1)<br />             加入成员 (局_临时数组, 局_数组 [局_计次])<br />             局_文本 ＝ 局_文本 ＋ 局_数组 [局_计次] ＋ 分割符<br />         .如果真结束<br /> <br />     .计次循环尾 ()<br /> <br /> .计次循环尾 ()<br /> <br /> 局_文本 ＝ 取文本左边 (局_文本, 取文本长度 (局_文本) － 取文本长度 (分割符))<br /> 返回 (局_文本)

缘由：
今天在问答区看到了一个帖子新手路过，取出不重复的数字!
可以在评论区看到，有说加入HASH表的，有说用精易模块的文本_去重复文本 (, )命令的。用户@wei615 提供的解决方法我看了一下（未经测试），效率并不高，而且浪费空间，强迫症。
HASH表是一个好选择，但是易语言操作HASH表过于麻烦（还是我大Java香）
想到精易模块已经是一个成熟的模块了，就去下载看了一下精易模块的相关源代码。

你已经是一个成熟的模块了.jpg

  

子程序名	返回值类型	公开	备 注
文本_去重复文本	文本型		去除原文本中重复的文本
参数名	类 型	参考	可空	数组	备 注
原文本	文本型
分割符	文本型				原文本单个内容间的分隔符，例如：---  留空为：逐字分割

变量名	类 型	静态	数组	备 注
局_数组	文本型		0
局_数组1	文本型		0
局_计次	整数型
局_文本	文本型

如果 (是否为空 (分割符))
文本_逐字分割 (原文本, 局_数组)
局_数组 ＝ 分割文本 (原文本, 分割符, )

计次循环首 (取数组成员数 (局_数组), 局_计次)
如果真 (内部_数组成员是否存在_文本 (局_数组1, 局_数组 [局_计次]) ＝ -1)
加入成员 (局_数组1, 局_数组 [局_计次])
局_文本 ＝ 局_文本 ＋ 局_数组 [局_计次] ＋ 分割符

计次循环尾 ()
局_文本 ＝ 取文本左边 (局_文本, 取文本长度 (局_文本) － 取文本长度 (分割符))
返回 (局_文本)

.版本 2<br /> <br /> .子程序 文本_去重复文本, 文本型, 公开, 去除原文本中重复的文本<br /> .参数 原文本, 文本型<br /> .参数 分割符, 文本型, 可空, 原文本单个内容间的分隔符，例如：---  留空为：逐字分割<br /> .局部变量 局_数组, 文本型, , "0"<br /> .局部变量 局_数组1, 文本型, , "0"<br /> .局部变量 局_计次, 整数型<br /> .局部变量 局_文本, 文本型<br /> <br /> .如果 (是否为空 (分割符))<br />     文本_逐字分割 (原文本, 局_数组)<br /> .否则<br />     局_数组 ＝ 分割文本 (原文本, 分割符, )<br /> .如果结束<br /> <br /> <br /> .计次循环首 (取数组成员数 (局_数组), 局_计次)<br />     .如果真 (内部_数组成员是否存在_文本 (局_数组1, 局_数组 [局_计次]) ＝ -1)<br />         加入成员 (局_数组1, 局_数组 [局_计次])<br />         局_文本 ＝ 局_文本 ＋ 局_数组 [局_计次] ＋ 分割符<br />     .如果真结束<br /> <br /> .计次循环尾 ()<br /> 局_文本 ＝ 取文本左边 (局_文本, 取文本长度 (局_文本) － 取文本长度 (分割符))<br /> 返回 (局_文本)

这是精易模块的【文本_去重复文本】子程序，可以很清楚的看到使用了【内部_数组成员是否存在_文本】，我对其性能有一点点担心。
并且在模块中发现了【文本_逐字分割】和【文本_逐字分割_汇编】，这担心的心情逐渐加重。





测试：

我对几个子程序的组合进行了搭配，并和我自己现写的文本去重进行了对比。

  

子程序名	返回值类型	公开	备 注
文本_去重复文本2	文本型		去除原文本中重复的文本
参数名	类 型	参考	可空	数组	备 注
原文本	文本型
分割符	文本型				原文本单个内容间的分隔符，例如：--- 留空为：逐字分割

变量名	类 型	静态	数组	备 注
局_数组	文本型		0
局_数组1	文本型		0
局_计次	整数型
局_文本	文本型

如果 (是否为空 (分割符))
文本_逐字分割_汇编 (原文本, 局_数组)
局_数组 ＝ 分割文本 (原文本, 分割符, )

计次循环首 (取数组成员数 (局_数组), 局_计次)
如果真 (内部_数组成员是否存在_文本 (局_数组1, 局_数组 [局_计次]) ＝ -1)
加入成员 (局_数组1, 局_数组 [局_计次])
局_文本 ＝ 局_文本 ＋ 局_数组 [局_计次] ＋ 分割符

计次循环尾 ()
局_文本 ＝ 取文本左边 (局_文本, 取文本长度 (局_文本) － 取文本长度 (分割符))
返回 (局_文本)

子程序名	返回值类型	公开	备 注
文本_去重复文本3	文本型
参数名	类 型	参考	可空	数组	备 注
原文本	文本型
分割符	文本型				原文本单个内容间的分隔符，例如：--- 留空为：逐字分割

变量名	类 型	静态	数组	备 注
局_数组	文本型		0
局_计次	整数型
局_次数	整数型
局_临时数组	文本型		0
局_计次1	整数型
局_次数1	整数型
局_文本	文本型

如果 (是否为空 (分割符))
文本_逐字分割_汇编 (原文本, 局_数组)
局_数组 ＝ 分割文本 (原文本, 分割符, )

局_次数 ＝ 取数组成员数 (局_数组)
计次循环首 (局_次数, 局_计次)
局_次数1 ＝ 取数组成员数 (局_临时数组)
计次循环首 (局_次数1, 局_计次1)
' 如果相同，则不循环，直接跳出
如果真 (局_数组 [局_计次] ＝ 局_临时数组 [局_计次1])
跳出循环 ()
' 如果是最后一个，还没有重复的，则加入
如果真 (局_计次1 ＝ 局_次数1)
加入成员 (局_临时数组, 局_数组 [局_计次])
局_文本 ＝ 局_文本 ＋ 局_数组 [局_计次] ＋ 分割符

计次循环尾 ()
计次循环尾 ()
局_文本 ＝ 取文本左边 (局_文本, 取文本长度 (局_文本) － 取文本长度 (分割符))
返回 (局_文本)

.版本 2<br /> <br /> .子程序 文本_去重复文本2, 文本型, 公开, 去除原文本中重复的文本<br /> .参数 原文本, 文本型<br /> .参数 分割符, 文本型, 可空, 原文本单个内容间的分隔符，例如：--- 留空为：逐字分割<br /> .局部变量 局_数组, 文本型, , "0"<br /> .局部变量 局_数组1, 文本型, , "0"<br /> .局部变量 局_计次, 整数型<br /> .局部变量 局_文本, 文本型<br /> <br /> .如果 (是否为空 (分割符))<br /> 文本_逐字分割_汇编 (原文本, 局_数组)<br /> .否则<br /> 局_数组 ＝ 分割文本 (原文本, 分割符, )<br /> .如果结束<br /> <br /> <br /> .计次循环首 (取数组成员数 (局_数组), 局_计次)<br /> .如果真 (内部_数组成员是否存在_文本 (局_数组1, 局_数组 [局_计次]) ＝ -1)<br /> 加入成员 (局_数组1, 局_数组 [局_计次])<br /> 局_文本 ＝ 局_文本 ＋ 局_数组 [局_计次] ＋ 分割符<br /> .如果真结束<br /> <br /> .计次循环尾 ()<br /> 局_文本 ＝ 取文本左边 (局_文本, 取文本长度 (局_文本) － 取文本长度 (分割符))<br /> 返回 (局_文本)<br /> <br /> <br /> .版本 2<br /> <br /> .子程序 文本_去重复文本3, 文本型<br /> .参数 原文本, 文本型<br /> .参数 分割符, 文本型, 可空, 原文本单个内容间的分隔符，例如：--- 留空为：逐字分割<br /> .局部变量 局_数组, 文本型, , "0"<br /> .局部变量 局_计次, 整数型<br /> .局部变量 局_次数, 整数型<br /> .局部变量 局_临时数组, 文本型, , "0"<br /> .局部变量 局_计次1, 整数型<br /> .局部变量 局_次数1, 整数型<br /> .局部变量 局_文本, 文本型<br /> <br /> .如果 (是否为空 (分割符))<br /> 文本_逐字分割_汇编 (原文本, 局_数组)<br /> .否则<br /> 局_数组 ＝ 分割文本 (原文本, 分割符, )<br /> .如果结束<br /> <br /> 局_次数 ＝ 取数组成员数 (局_数组)<br /> .计次循环首 (局_次数, 局_计次)<br /> <br /> 局_次数1 ＝ 取数组成员数 (局_临时数组)<br /> <br /> .计次循环首 (局_次数1, 局_计次1)<br /> ' 如果相同，则不循环，直接跳出<br /> .如果真 (局_数组 [局_计次] ＝ 局_临时数组 [局_计次1])<br /> 跳出循环 ()<br /> .如果真结束<br /> ' 如果是最后一个，还没有重复的，则加入<br /> .如果真 (局_计次1 ＝ 局_次数1)<br /> 加入成员 (局_临时数组, 局_数组 [局_计次])<br /> 局_文本 ＝ 局_文本 ＋ 局_数组 [局_计次] ＋ 分割符<br /> .如果真结束<br /> <br /> .计次循环尾 ()<br /> <br /> .计次循环尾 ()<br /> <br /> 局_文本 ＝ 取文本左边 (局_文本, 取文本长度 (局_文本) － 取文本长度 (分割符))<br /> 返回 (局_文本)

其上，2是根据精易模块进行优化的版本，3是现场写的版本。

测试结果如下：文本_去重复文本_汇编分割_优化————文本_去重复文本3
文本_去重复文本_汇编分割————文本_去重复文本2
数组_去重复(汇编分割)————使用【文本_逐字分割_汇编】命令分割，再使用【数组_去重复】
数组_去重复 ————使用【文本_逐字分割】命令分割，再使用【数组_去重复】
文本_去重复文本————精易模块自身的命令

1. 百万字测试
   
2. 
   
3. * “随机文本生成完毕，生成启动时间 ：1494421656”
   
4. * “文本_去重复文本_汇编分割_优化 : 27000”
   
5. * “文本_去重复文本_汇编分割 : 62782”
   
6. * “文本_去重复文本 : 91968”
   
7. * “数组_去重复 : 90297”
   
8. * “数组_去重复(汇编分割) : 58891”
   
9. * “随机文本生成完毕，生成启动时间 ：1494753828”
   
10. * “文本_去重复文本_汇编分割_优化 : 29531”
    
11. * “文本_去重复文本_汇编分割 : 59344”
    
12. * “文本_去重复文本 : 88000”
    
13. * “数组_去重复 : 87843”
    
14. * “数组_去重复(汇编分割) : 57657”
    
15. * “随机文本生成完毕，生成启动时间 ：1495077468”
    
16. * “文本_去重复文本_汇编分割_优化 : 29750”
    
17. * “文本_去重复文本_汇编分割 : 60984”
    
18. * “文本_去重复文本 : 88516”
    
19. * “数组_去重复 : 89406”
    
20. * “数组_去重复(汇编分割) : 59344”
    
21. * “随机文本生成完毕，生成启动时间 ：1495407062”
    
22. * “文本_去重复文本_汇编分割_优化 : 30625”
    
23. * “文本_去重复文本_汇编分割 : 61438”
    
24. * “文本_去重复文本 : 90516”
    
25. * “数组_去重复 : 91656”
    
26. * “数组_去重复(汇编分割) : 59797”
    
27. 
    
28. 
    
29. 万字，十次
    
30. 
    
31. ---------------------
    
32. 随机文本生成完毕
    
33. 文本_去重复文本_汇编分割_优化 : 94
    
34. 文本_去重复文本_汇编分割 : 156
    
35. 文本_去重复文本 : 94
    
36. 数组_去重复 : 281
    
37. 数组_去重复(汇编分割) : 266
    
38. ---------------------
    
39. ---------------------
    
40. 随机文本生成完毕
    
41. 文本_去重复文本_汇编分割_优化 : 62
    
42. 文本_去重复文本_汇编分割 : 172
    
43. 文本_去重复文本 : 235
    
44. 数组_去重复 : 234
    
45. 数组_去重复(汇编分割) : 172
    
46. ---------------------
    
47. ---------------------
    
48. 随机文本生成完毕
    
49. 文本_去重复文本_汇编分割_优化 : 63
    
50. 文本_去重复文本_汇编分割 : 156
    
51. 文本_去重复文本 : 234
    
52. 数组_去重复 : 234
    
53. 数组_去重复(汇编分割) : 156
    
54. ---------------------
    
55. ---------------------
    
56. 随机文本生成完毕
    
57. 文本_去重复文本_汇编分割_优化 : 63
    
58. 文本_去重复文本_汇编分割 : 140
    
59. 文本_去重复文本 : 235
    
60. 数组_去重复 : 250
    
61. 数组_去重复(汇编分割) : 156
    
62. ---------------------
    
63. ---------------------
    
64. 随机文本生成完毕
    
65. 文本_去重复文本_汇编分割_优化 : 63
    
66. 文本_去重复文本_汇编分割 : 156
    
67. 文本_去重复文本 : 234
    
68. 数组_去重复 : 266
    
69. 数组_去重复(汇编分割) : 141
    
70. ---------------------
    
71. ---------------------
    
72. 随机文本生成完毕
    
73. 文本_去重复文本_汇编分割_优化 : 62
    
74. 文本_去重复文本_汇编分割 : 141
    
75. 文本_去重复文本 : 218
    
76. 数组_去重复 : 266
    
77. 数组_去重复(汇编分割) : 156
    
78. ---------------------
    
79. ---------------------
    
80. 随机文本生成完毕
    
81. 文本_去重复文本_汇编分割_优化 : 62
    
82. 文本_去重复文本_汇编分割 : 141
    
83. 文本_去重复文本 : 234
    
84. 数组_去重复 : 250
    
85. 数组_去重复(汇编分割) : 156
    
86. ---------------------
    
87. ---------------------
    
88. 随机文本生成完毕
    
89. 文本_去重复文本_汇编分割_优化 : 47
    
90. 文本_去重复文本_汇编分割 : 140
    
91. 文本_去重复文本 : 219
    
92. 数组_去重复 : 250
    
93. 数组_去重复(汇编分割) : 141
    
94. ---------------------
    
95. ---------------------
    
96. 随机文本生成完毕
    
97. 文本_去重复文本_汇编分割_优化 : 62
    
98. 文本_去重复文本_汇编分割 : 125
    
99. 文本_去重复文本 : 234
    
100. 数组_去重复 : 250
     
101. 数组_去重复(汇编分割) : 172
     
102. ---------------------
     
103. ---------------------
     
104. 随机文本生成完毕
     
105. 文本_去重复文本_汇编分割_优化 : 78
     
106. 文本_去重复文本_汇编分割 : 140
     
107. 文本_去重复文本 : 219
     
108. 数组_去重复 : 250
     
109. 数组_去重复(汇编分割) : 172
     
110. ---------------------
     
111. 
     
112. 
     
113. 
     
114. 十万字
     
115. 
     
116. 
     
117. ---------------------
     
118. 随机文本生成完毕
     
119. 文本_去重复文本_汇编分割_优化 : 2265
     
120. 文本_去重复文本_汇编分割 : 4250
     
121. 文本_去重复文本 : 5203
     
122. 数组_去重复 : 5625
     
123. 数组_去重复(汇编分割) : 3953
     
124. ---------------------
     
125. ---------------------
     
126. 随机文本生成完毕
     
127. 文本_去重复文本_汇编分割_优化 : 1843
     
128. 文本_去重复文本_汇编分割 : 3875
     
129. 文本_去重复文本 : 5125
     
130. 数组_去重复 : 5594
     
131. 数组_去重复(汇编分割) : 3969
     
132. ---------------------
     
133. ---------------------
     
134. 随机文本生成完毕
     
135. 文本_去重复文本_汇编分割_优化 : 1813
     
136. 文本_去重复文本_汇编分割 : 3765
     
137. 文本_去重复文本 : 5141
     
138. 数组_去重复 : 5719
     
139. 数组_去重复(汇编分割) : 4140
     
140. ---------------------
     
141. ---------------------
     
142. 随机文本生成完毕
     
143. 文本_去重复文本_汇编分割_优化 : 1829
     
144. 文本_去重复文本_汇编分割 : 3750
     
145. 文本_去重复文本 : 5078
     
146. 数组_去重复 : 5422
     
147. 数组_去重复(汇编分割) : 3938
     
148. ---------------------
     
149. ---------------------
     
150. 随机文本生成完毕
     
151. 文本_去重复文本_汇编分割_优化 : 1750
     
152. 文本_去重复文本_汇编分割 : 3672
     
153. 文本_去重复文本 : 5219
     
154. 数组_去重复 : 5453
     
155. 数组_去重复(汇编分割) : 3750
     
156. ---------------------
     
157. ---------------------
     
158. 随机文本生成完毕
     
159. 文本_去重复文本_汇编分割_优化 : 1828
     
160. 文本_去重复文本_汇编分割 : 3750
     
161. 文本_去重复文本 : 5250
     
162. 数组_去重复 : 5484
     
163. 数组_去重复(汇编分割) : 3875
     
164. ---------------------
     
165. ---------------------
     
166. 随机文本生成完毕
     
167. 文本_去重复文本_汇编分割_优化 : 1813
     
168. 文本_去重复文本_汇编分割 : 3766
     
169. 文本_去重复文本 : 5078
     
170. 数组_去重复 : 5406
     
171. 数组_去重复(汇编分割) : 3797
     
172. ---------------------
     
173. ---------------------
     
174. 随机文本生成完毕
     
175. 文本_去重复文本_汇编分割_优化 : 1828
     
176. 文本_去重复文本_汇编分割 : 3750
     
177. 文本_去重复文本 : 5016
     
178. 数组_去重复 : 5328
     
179. 数组_去重复(汇编分割) : 3797
     
180. ---------------------
     
181. ---------------------
     
182. 随机文本生成完毕
     
183. 文本_去重复文本_汇编分割_优化 : 1813
     
184. 文本_去重复文本_汇编分割 : 3766
     
185. 文本_去重复文本 : 5125
     
186. 数组_去重复 : 5500
     
187. 数组_去重复(汇编分割) : 3718
     
188. ---------------------
     
189. ---------------------
     
190. 随机文本生成完毕
     
191. 文本_去重复文本_汇编分割_优化 : 1829
     
192. 文本_去重复文本_汇编分割 : 3828
     
193. 文本_去重复文本 : 4984
     
194. 数组_去重复 : 5469
     
195. 数组_去重复(汇编分割) : 3750
     
196. ---------------------
     

复制代码

wk9427

我看的一脸懵

禁回忆

禁回忆 发表于 2020-12-30 12:07
那就请先修改分割后的文本数组的遍历方式，模块中所用的【内部_数组成员是否存在_文本】子程序每次遍历都全 ...

@项目部004

禁回忆

那就请先修改分割后的文本数组的遍历方式，模块中所用的【内部_数组成员是否存在_文本】子程序每次遍历都全部遍历一遍，时间复杂度位O（n²）@项目部004

shituo

汇编的东西不能用太多 不然什么BUG 都照不出来

shituo

优化还不够啊 再优化下吧

hellohexiang

百万行文本用哈希表大概也就两三秒吧

禁回忆

wei615 发表于 2020-12-29 16:50
能解决问题就是好的咯

强迫症，没办法，实现同样的问题，我肯定追求效率高的，何况是这种一眼就能看出来效率问题的

616

禁回忆 发表于 2020-12-29 16:49
没啥，就是看到问答区那个帖子后，去看了一下精易论坛的【文本_去重复文本】命令，他写的效率太低了，他 ...

能解决问题就是好的咯

禁回忆

wei615 发表于 2020-12-29 16:40
我看的一脸懵  哈哈哈 支持咯

没啥，就是看到问答区那个帖子后，去看了一下精易论坛的【文本_去重复文本】命令，他写的效率太低了，他自己都已经写了更高效的文本分割，结果没用，有可能是考虑到其他因素。但是这个遍历循环我实在是忍不了