易语言实现所有基本类型数组的查询并防重复加入成员 (返回整数型)

CNWTEPRG

1. 
   
2. .版本 2
   
3. .支持库 spec
   
4. 
   
5. .程序集 程序集1
   
6. 
   
7. .子程序 _启动子程序, 整数型, , 请在本子程序中放置易模块初始化代码
   
8. 
   
9. 
   
10. _临时子程序 ()  ' 在初始化代码执行完毕后调用测试代码
    
11. 返回 (0)  ' 可以根据您的需要返回任意数值
    
12. 
    
13. .子程序 _临时子程序
    
14. .局部变量 A, 字节型, , "0"
    
15. .局部变量 B, 短整数型, , "0"
    
16. 
    
17. .计次循环首 (5000, )
    
18.     字节型数组_查询并加入成员_防重复 (A, 取随机数 (, ))
    
19. .计次循环尾 ()
    
20. .计次循环首 (50000, )
    
21.     短整数型数组_查询并加入成员_防重复 (B, 取随机数 (, ) × 取随机数 (, ))
    
22. .计次循环尾 ()
    
23. 
    
24. 调试输出 (A)
    
25. 调试输出 (B)
    
26. 
    
27. .子程序 字节型数组_查询并加入成员_防重复, 整数型, 公开
    
28. .参数 欲加入成员的数组变量, 字节型, 参考 数组
    
29. .参数 欲加入的成员数据, 字节型
    
30. .局部变量 索引, 整数型
    
31. 
    
32. .计次循环首 (取数组成员数 (欲加入成员的数组变量), 索引)
    
33.     .如果真 (欲加入成员的数组变量 [索引] ＝ 欲加入的成员数据)
    
34.         返回 (索引)
    
35.     .如果真结束
    
36. 
    
37. .计次循环尾 ()
    
38. 加入成员 (欲加入成员的数组变量, 欲加入的成员数据)
    
39. 返回 (索引)
    
40. 
    
41. 
    
42. .子程序 整数型数组_查询并加入成员_防重复, 整数型, 公开
    
43. .参数 欲加入成员的数组变量, 整数型, 参考 数组
    
44. .参数 欲加入的成员数据, 整数型
    
45. .局部变量 索引, 整数型
    
46. 
    
47. .计次循环首 (取数组成员数 (欲加入成员的数组变量), 索引)
    
48.     .如果真 (欲加入成员的数组变量 [索引] ＝ 欲加入的成员数据)
    
49.         返回 (索引)
    
50.     .如果真结束
    
51. 
    
52. .计次循环尾 ()
    
53. 加入成员 (欲加入成员的数组变量, 欲加入的成员数据)
    
54. 返回 (索引)
    
55. 
    
56. .子程序 小数型数组_查询并加入成员_防重复, 整数型, 公开
    
57. .参数 欲加入成员的数组变量, 小数型, 参考 数组
    
58. .参数 欲加入的成员数据, 小数型
    
59. .局部变量 索引, 整数型
    
60. 
    
61. .计次循环首 (取数组成员数 (欲加入成员的数组变量), 索引)
    
62.     .如果真 (欲加入成员的数组变量 [索引] ＝ 欲加入的成员数据)
    
63.         返回 (索引)
    
64.     .如果真结束
    
65. 
    
66. .计次循环尾 ()
    
67. 加入成员 (欲加入成员的数组变量, 欲加入的成员数据)
    
68. 返回 (索引)
    
69. 
    
70. .子程序 逻辑型数组_查询并加入成员_防重复, 整数型, 公开
    
71. .参数 欲加入成员的数组变量, 逻辑型, 参考 数组
    
72. .参数 欲加入的成员数据, 逻辑型
    
73. .局部变量 索引, 整数型
    
74. 
    
75. .计次循环首 (取数组成员数 (欲加入成员的数组变量), 索引)
    
76.     .如果真 (欲加入成员的数组变量 [索引] ＝ 欲加入的成员数据)
    
77.         返回 (索引)
    
78.     .如果真结束
    
79. 
    
80. .计次循环尾 ()
    
81. 加入成员 (欲加入成员的数组变量, 欲加入的成员数据)
    
82. 返回 (索引)
    
83. 
    
84. .子程序 文本型数组_查询并加入成员_防重复, 整数型, 公开
    
85. .参数 欲加入成员的数组变量, 文本型, 参考 数组
    
86. .参数 欲加入的成员数据, 文本型
    
87. .局部变量 索引, 整数型
    
88. 
    
89. .计次循环首 (取数组成员数 (欲加入成员的数组变量), 索引)
    
90.     .如果真 (欲加入成员的数组变量 [索引] ＝ 欲加入的成员数据)
    
91.         返回 (索引)
    
92.     .如果真结束
    
93. 
    
94. .计次循环尾 ()
    
95. 加入成员 (欲加入成员的数组变量, 欲加入的成员数据)
    
96. 返回 (索引)
    
97. 
    
98. .子程序 字节集数组_查询并加入成员_防重复, 整数型, 公开
    
99. .参数 欲加入成员的数组变量, 字节集, 参考 数组
    
100. .参数 欲加入的成员数据, 字节集
     
101. .局部变量 索引, 整数型
     
102. 
     
103. .计次循环首 (取数组成员数 (欲加入成员的数组变量), 索引)
     
104.     .如果真 (欲加入成员的数组变量 [索引] ＝ 欲加入的成员数据)
     
105.         返回 (索引)
     
106.     .如果真结束
     
107. 
     
108. .计次循环尾 ()
     
109. 加入成员 (欲加入成员的数组变量, 欲加入的成员数据)
     
110. 返回 (索引)
     
111. 
     
112. .子程序 短整数型数组_查询并加入成员_防重复, 整数型, 公开
     
113. .参数 欲加入成员的数组变量, 短整数型, 参考 数组
     
114. .参数 欲加入的成员数据, 短整数型
     
115. .局部变量 索引, 整数型
     
116. 
     
117. .计次循环首 (取数组成员数 (欲加入成员的数组变量), 索引)
     
118.     .如果真 (欲加入成员的数组变量 [索引] ＝ 欲加入的成员数据)
     
119.         返回 (索引)
     
120.     .如果真结束
     
121. 
     
122. .计次循环尾 ()
     
123. 加入成员 (欲加入成员的数组变量, 欲加入的成员数据)
     
124. 返回 (索引)
     
125. 
     
126. .子程序 长整数型数组_查询并加入成员_防重复, 整数型, 公开
     
127. .参数 欲加入成员的数组变量, 长整数型, 参考 数组
     
128. .参数 欲加入的成员数据, 长整数型
     
129. .局部变量 索引, 整数型
     
130. 
     
131. .计次循环首 (取数组成员数 (欲加入成员的数组变量), 索引)
     
132.     .如果真 (欲加入成员的数组变量 [索引] ＝ 欲加入的成员数据)
     
133.         返回 (索引)
     
134.     .如果真结束
     
135. 
     
136. .计次循环尾 ()
     
137. 加入成员 (欲加入成员的数组变量, 欲加入的成员数据)
     
138. 返回 (索引)
     
139. 
     
140. .子程序 日期时间型数组_查询并加入成员_防重复, 整数型, 公开
     
141. .参数 欲加入成员的数组变量, 日期时间型, 参考 数组
     
142. .参数 欲加入的成员数据, 日期时间型
     
143. .局部变量 索引, 整数型
     
144. 
     
145. .计次循环首 (取数组成员数 (欲加入成员的数组变量), 索引)
     
146.     .如果真 (欲加入成员的数组变量 [索引] ＝ 欲加入的成员数据)
     
147.         返回 (索引)
     
148.     .如果真结束
     
149. 
     
150. .计次循环尾 ()
     
151. 加入成员 (欲加入成员的数组变量, 欲加入的成员数据)
     
152. 返回 (索引)
     
153. 
     
154. .子程序 子程序指针数组_查询并加入成员_防重复, 整数型, 公开
     
155. .参数 欲加入成员的数组变量, 子程序指针, 参考 数组
     
156. .参数 欲加入的成员数据, 子程序指针
     
157. .局部变量 索引, 整数型
     
158. 
     
159. .计次循环首 (取数组成员数 (欲加入成员的数组变量), 索引)
     
160.     .如果真 (欲加入成员的数组变量 [索引] ＝ 欲加入的成员数据)
     
161.         返回 (索引)
     
162.     .如果真结束
     
163. 
     
164. .计次循环尾 ()
     
165. 加入成员 (欲加入成员的数组变量, 欲加入的成员数据)
     
166. 返回 (索引)
     
167. 
     
168. .子程序 双精度小数型数组_查询并加入成员_防重复, 整数型, 公开
     
169. .参数 欲加入成员的数组变量, 双精度小数型, 参考 数组
     
170. .参数 欲加入的成员数据, 双精度小数型
     
171. .局部变量 索引, 整数型
     
172. 
     
173. .计次循环首 (取数组成员数 (欲加入成员的数组变量), 索引)
     
174.     .如果真 (欲加入成员的数组变量 [索引] ＝ 欲加入的成员数据)
     
175.         返回 (索引)
     
176.     .如果真结束
     
177. 
     
178. .计次循环尾 ()
     
179. 加入成员 (欲加入成员的数组变量, 欲加入的成员数据)
     
180. 返回 (索引)
     

复制代码