易语言实现基本数据类型数组快速去除重复的方法 采用吃尾算法实现

a1a2dnp

1. 
   
2. .版本 2
   
3. 
   
4. .程序集 数组去重, , , 将数组中重复的成员批量删除
   
5. 
   
6. .子程序 数组去重_字节型, , 公开
   
7. .参数 欲去重的数组, 字节型, 参考 数组
   
8. .局部变量 外循环, 整数型
   
9. .局部变量 内循环, 整数型
   
10. 
    
11. .计次循环首 (取数组成员数 (欲去重的数组), 外循环)
    
12.     .变量循环首 (取数组成员数 (欲去重的数组), 外循环 ＋ 1, -1, 内循环)
    
13.         .如果真 (欲去重的数组 [外循环] ＝ 欲去重的数组 [内循环])
    
14.             删除成员 (欲去重的数组, 内循环, )
    
15. 
    
16.         .如果真结束
    
17. 
    
18.     .变量循环尾 ()
    
19. .计次循环尾 ()
    
20. 
    
21. .子程序 数组去重_整数型, , 公开
    
22. .参数 欲去重的数组, 整数型, 参考 数组
    
23. .局部变量 外循环, 整数型
    
24. .局部变量 内循环, 整数型
    
25. 
    
26. .计次循环首 (取数组成员数 (欲去重的数组), 外循环)
    
27.     .变量循环首 (取数组成员数 (欲去重的数组), 外循环 ＋ 1, -1, 内循环)
    
28.         .如果真 (欲去重的数组 [外循环] ＝ 欲去重的数组 [内循环])
    
29.             删除成员 (欲去重的数组, 内循环, )
    
30. 
    
31.         .如果真结束
    
32. 
    
33.     .变量循环尾 ()
    
34. .计次循环尾 ()
    
35. 
    
36. .子程序 数组去重_小数型, , 公开
    
37. .参数 欲去重的数组, 小数型, 参考 数组
    
38. .局部变量 外循环, 整数型
    
39. .局部变量 内循环, 整数型
    
40. 
    
41. .计次循环首 (取数组成员数 (欲去重的数组), 外循环)
    
42.     .变量循环首 (取数组成员数 (欲去重的数组), 外循环 ＋ 1, -1, 内循环)
    
43.         .如果真 (欲去重的数组 [外循环] ＝ 欲去重的数组 [内循环])
    
44.             删除成员 (欲去重的数组, 内循环, )
    
45. 
    
46.         .如果真结束
    
47. 
    
48.     .变量循环尾 ()
    
49. .计次循环尾 ()
    
50. 
    
51. 
    
52. .子程序 数组去重_逻辑型, , 公开
    
53. .参数 欲去重的数组, 逻辑型, 参考 数组
    
54. .局部变量 计数, 整数型
    
55. .局部变量 数组2, 逻辑型, , "0"
    
56. .局部变量 存在真, 逻辑型
    
57. .局部变量 存在假, 逻辑型
    
58. 
    
59. .计次循环首 (取数组成员数 (欲去重的数组), 计数)
    
60.     .如果 (欲去重的数组 [计数])
    
61.         .如果真 (存在真 ＝ 假)
    
62.             加入成员 (数组2, 真)
    
63.             存在真 ＝ 真
    
64.         .如果真结束
    
65. 
    
66.     .否则
    
67.         .如果真 (存在假 ＝ 假)
    
68.             加入成员 (数组2, 假)
    
69.             存在假 ＝ 真
    
70.         .如果真结束
    
71. 
    
72.     .如果结束
    
73.     .如果真 (存在真 且 存在假)
    
74.         跳出循环 ()
    
75.     .如果真结束
    
76. 
    
77. .计次循环尾 ()
    
78. 欲去重的数组 ＝ 数组2
    
79. 
    
80. .子程序 数组去重_文本型, , 公开
    
81. .参数 欲去重的数组, 文本型, 参考 数组
    
82. .局部变量 外循环, 整数型
    
83. .局部变量 内循环, 整数型
    
84. 
    
85. .计次循环首 (取数组成员数 (欲去重的数组), 外循环)
    
86.     .变量循环首 (取数组成员数 (欲去重的数组), 外循环 ＋ 1, -1, 内循环)
    
87.         .如果真 (欲去重的数组 [外循环] ＝ 欲去重的数组 [内循环])
    
88.             删除成员 (欲去重的数组, 内循环, )
    
89. 
    
90.         .如果真结束
    
91. 
    
92.     .变量循环尾 ()
    
93. .计次循环尾 ()
    
94. 
    
95. 
    
96. .子程序 数组去重_字节集, , 公开
    
97. .参数 欲去重的数组, 字节集, 参考 数组
    
98. .局部变量 外循环, 整数型
    
99. .局部变量 内循环, 整数型
    
100. 
     
101. .计次循环首 (取数组成员数 (欲去重的数组), 外循环)
     
102.     .变量循环首 (取数组成员数 (欲去重的数组), 外循环 ＋ 1, -1, 内循环)
     
103.         .如果真 (欲去重的数组 [外循环] ＝ 欲去重的数组 [内循环])
     
104.             删除成员 (欲去重的数组, 内循环, )
     
105. 
     
106.         .如果真结束
     
107. 
     
108.     .变量循环尾 ()
     
109. .计次循环尾 ()
     
110. 
     
111. 
     
112. .子程序 数组去重_短整数型, , 公开
     
113. .参数 欲去重的数组, 短整数型, 参考 数组
     
114. .局部变量 外循环, 整数型
     
115. .局部变量 内循环, 整数型
     
116. 
     
117. .计次循环首 (取数组成员数 (欲去重的数组), 外循环)
     
118.     .变量循环首 (取数组成员数 (欲去重的数组), 外循环 ＋ 1, -1, 内循环)
     
119.         .如果真 (欲去重的数组 [外循环] ＝ 欲去重的数组 [内循环])
     
120.             删除成员 (欲去重的数组, 内循环, )
     
121. 
     
122.         .如果真结束
     
123. 
     
124.     .变量循环尾 ()
     
125. .计次循环尾 ()
     
126. 
     
127. 
     
128. .子程序 数组去重_长整数型, , 公开
     
129. .参数 欲去重的数组, 长整数型, 参考 数组
     
130. .局部变量 外循环, 整数型
     
131. .局部变量 内循环, 整数型
     
132. 
     
133. .计次循环首 (取数组成员数 (欲去重的数组), 外循环)
     
134.     .变量循环首 (取数组成员数 (欲去重的数组), 外循环 ＋ 1, -1, 内循环)
     
135.         .如果真 (欲去重的数组 [外循环] ＝ 欲去重的数组 [内循环])
     
136.             删除成员 (欲去重的数组, 内循环, )
     
137. 
     
138.         .如果真结束
     
139. 
     
140.     .变量循环尾 ()
     
141. .计次循环尾 ()
     
142. 
     
143. 
     
144. .子程序 数组去重_日期时间型, , 公开
     
145. .参数 欲去重的数组, 日期时间型, 参考 数组
     
146. .局部变量 外循环, 整数型
     
147. .局部变量 内循环, 整数型
     
148. 
     
149. .计次循环首 (取数组成员数 (欲去重的数组), 外循环)
     
150.     .变量循环首 (取数组成员数 (欲去重的数组), 外循环 ＋ 1, -1, 内循环)
     
151.         .如果真 (欲去重的数组 [外循环] ＝ 欲去重的数组 [内循环])
     
152.             删除成员 (欲去重的数组, 内循环, )
     
153. 
     
154.         .如果真结束
     
155. 
     
156.     .变量循环尾 ()
     
157. .计次循环尾 ()
     
158. 
     
159. 
     
160. .子程序 数组去重_子程序指针, , 公开
     
161. .参数 欲去重的数组, 子程序指针, 参考 数组
     
162. .局部变量 外循环, 整数型
     
163. .局部变量 内循环, 整数型
     
164. 
     
165. .计次循环首 (取数组成员数 (欲去重的数组), 外循环)
     
166.     .变量循环首 (取数组成员数 (欲去重的数组), 外循环 ＋ 1, -1, 内循环)
     
167.         .如果真 (欲去重的数组 [外循环] ＝ 欲去重的数组 [内循环])
     
168.             删除成员 (欲去重的数组, 内循环, )
     
169. 
     
170.         .如果真结束
     
171. 
     
172.     .变量循环尾 ()
     
173. .计次循环尾 ()
     
174. 
     
175. 
     
176. .子程序 数组去重_双精度小数型, , 公开
     
177. .参数 欲去重的数组, 双精度小数型, 参考 数组
     
178. .局部变量 外循环, 整数型
     
179. .局部变量 内循环, 整数型
     
180. 
     
181. .计次循环首 (取数组成员数 (欲去重的数组), 外循环)
     
182.     .变量循环首 (取数组成员数 (欲去重的数组), 外循环 ＋ 1, -1, 内循环)
     
183.         .如果真 (欲去重的数组 [外循环] ＝ 欲去重的数组 [内循环])
     
184.             删除成员 (欲去重的数组, 内循环, )
     
185. 
     
186.         .如果真结束
     
187. 
     
188.     .变量循环尾 ()
     
189. .计次循环尾 ()
     
190. 
     

复制代码

Cute

逻辑型的去完了结果真的很，我帮你改改....

GPIO

老司机老司机

fun

看看咋吃的

66大顺

Cute 发表于 2018-9-12 21:32
逻辑型的去完了结果真的很，我帮你改改....

改的真6....