易语言MASM置入代码实现升序线性数组表二分折半与顺序查找索引搜索算法 (返回整数型)

EAX

* “正在初始化数组...”
* “正在二分查找...”
* 88888888 | -1214262654 | “每条查询耗时45.2ns”
* “正在顺序查找...”
* 88888888 | -1214262654 | “每条查询耗时550.68ms”
被调试易程序运行完毕

1. 
   
2. .版本 2
   
3. .支持库 spec
   
4. 
   
5. .程序集 程序集1
   
6. 
   
7. .子程序 _启动子程序, 整数型, , 请在本子程序中放置易模块初始化代码
   
8. 
   
9. 置随机数种子 ()
   
10. _临时子程序 ()  ' 在初始化代码执行完毕后调用测试代码
    
11. 返回 (0)  ' 可以根据您的需要返回任意数值
    
12. 
    
13. .子程序 _临时子程序
    
14. .局部变量 数组, 整数型, , "100000000"
    
15. .局部变量 计数, 整数型
    
16. .局部变量 索引, 整数型
    
17. .局部变量 时间, 整数型
    
18. .局部变量 数字, 整数型
    
19. .局部变量 值, 整数型
    
20. 
    
21. 调试输出 (“正在初始化数组...”)
    
22. 数字 ＝ -2147483648
    
23. .计次循环首 (100000000, 计数)
    
24.     数组 [计数] ＝ 数字
    
25.     数字 ＝ 数字 ＋ 取随机数 (1, 20)
    
26. .计次循环尾 ()
    
27. 调试输出 (“正在二分查找...”)
    
28. 时间 ＝ 取启动时间 ()
    
29. 值 ＝ 数组 [88888888]
    
30. .计次循环首 (1000000, )
    
31.     索引 ＝ 二分查找 (数组, 值)
    
32. .计次循环尾 ()
    
33. 调试输出 (索引, 数组 [索引], “每条查询耗时” ＋ 到文本 ((取启动时间 () － 时间) ÷ 10000000 × 1000 × 1000) ＋ “ns”)
    
34. 调试输出 (“正在顺序查找...”)
    
35. 时间 ＝ 取启动时间 ()
    
36. .计次循环首 (100, )
    
37.     索引 ＝ 顺序查找 (数组, 值)
    
38. .计次循环尾 ()
    
39. 调试输出 (索引, 数组 [索引], “每条查询耗时” ＋ 到文本 ((取启动时间 () － 时间) ÷ 100) ＋ “ms”)
    
40. 
    
41. 
    
42. 
    
43. .子程序 二分查找, 整数型, 公开, 未找到返回0，找到返回索引
    
44. .参数 数组, 整数型, 数组, 数组必须从小到大，否则将出错
    
45. .参数 值, 整数型
    
46. 
    
47. 置入代码 ({ 83, 81, 82, 86, 87, 85, 187, 1, 0, 0, 0, 139, 125, 8, 139, 117, 12, 139, 63, 185, 1, 0, 0, 0, 139, 79, 4, 131, 199, 8, 232, 56, 0, 0, 0, 235, 30, 74, 139, 44, 151, 66, 59, 245, 124, 13, 59, 245, 117, 4, 139, 194, 235, 27, 141, 90, 1, 235, 3, 141, 74, 255, 232, 24, 0, 0, 0, 59, 217, 126, 222, 59, 217, 127, 4, 139, 194, 235, 2, 51, 192, 93, 95, 94, 90, 89, 91, 201, 194, 8, 0, 141, 20, 25, 209, 234, 195 })
    
48. ' push ebx
    
49. ' push ecx
    
50. ' push edx
    
51. ' push esi
    
52. ' push edi
    
53. ' push ebp
    
54. ' mov ebx,1
    
55. ' mov edi,[ebp+8]
    
56. ' mov esi,[ebp+12]
    
57. ' mov edi,[edi]
    
58. ' mov ecx,1
    
59. ' mov ecx,[edi+4]
    
60. ' add edi,8
    
61. ' call HALVE
    
62. ' .while SDWORD PTR ebx <= ecx
    
63. ' dec edx
    
64. ' mov ebp,[edi+edx*4]
    
65. ' inc edx
    
66. ' .if SDWORD PTR esi >= ebp
    
67. ' .if esi == ebp
    
68. ' mov eax,edx
    
69. ' jmp ASM_END
    
70. ' .endif
    
71. ' lea ebx,[edx+1]
    
72. ' .else
    
73. ' lea ecx,[edx-1]
    
74. ' .endif
    
75. ' call HALVE
    
76. ' .endw
    
77. ' .if SDWORD PTR ebx <= ecx
    
78. ' mov eax,edx
    
79. ' .elseif
    
80. ' xor eax,eax
    
81. ' .endif
    
82. ' ASM_END:
    
83. ' pop ebp
    
84. ' pop edi
    
85. ' pop esi
    
86. ' pop edx
    
87. ' pop ecx
    
88. ' pop ebx
    
89. ' leave
    
90. ' retn 8
    
91. ' HALVE:
    
92. ' lea edx,[ebx+ecx]
    
93. ' shr edx,1
    
94. ' ret
    
95. 
    
96. 返回 (0)
    
97. 
    
98. 
    
99. .子程序 顺序查找, 整数型, 公开
    
100. .参数 数组, 整数型, 数组, 允许无序数组
     
101. .参数 值, 整数型
     
102. 
     
103. 置入代码 ({ 83, 81, 82, 86, 51, 192, 139, 93, 8, 139, 117, 12, 139, 27, 139, 83, 4, 131, 195, 8, 51, 201, 235, 11, 59, 52, 139, 117, 5, 139, 193, 64, 235, 5, 65, 59, 202, 114, 241, 94, 90, 89, 91, 201, 194, 8, 0 })
     
104. ' push ebx
     
105. ' push ecx
     
106. ' push edx
     
107. ' push esi
     
108. ' xor eax,eax
     
109. ' mov ebx,[ebp+8]
     
110. ' mov esi,[ebp+12]
     
111. ' mov ebx,[ebx]
     
112. ' mov edx,[ebx+4]
     
113. ' add ebx,8
     
114. ' xor ecx,ecx
     
115. ' .while ecx<edx
     
116. ' .if esi == [ecx*4+ebx]
     
117. ' mov eax,ecx
     
118. ' inc eax
     
119. ' jmp ASM_END
     
120. ' .endif
     
121. ' inc ecx
     
122. ' .endw
     
123. ' ASM_END:
     
124. ' pop esi
     
125. ' pop edx
     
126. ' pop ecx
     
127. ' pop ebx
     
128. ' leave
     
129. ' retn 8
     
130. ' end
     
131. 
     
132. 返回 (0)
     
133. 
     
134. .子程序 二分查找_易源码, 整数型
     
135. .参数 数组, 整数型, 数组
     
136. .参数 值, 整数型
     
137. .局部变量 首, 整数型, , , ebx
     
138. .局部变量 末, 整数型, , , ecx
     
139. .局部变量 中, 整数型, , , edx
     
140. 
     
141. 首 ＝ 1
     
142. 末 ＝ 取数组成员数 (数组)
     
143. 中 ＝ 右移 (首 ＋ 末, 1)
     
144. .判断循环首 (首 ≤ 末)
     
145.     .如果 (值 ≥ 数组 [中])
     
146.         .如果真 (值 ＝ 数组 [中])
     
147.             返回 (中)
     
148.         .如果真结束
     
149.         首 ＝ 中 ＋ 1
     
150.     .否则
     
151.         末 ＝ 中 － 1
     
152.     .如果结束
     
153.     中 ＝ 右移 (首 ＋ 末, 1)
     
154. .判断循环尾 ()
     
155. .如果真 (首 ≤ 末)
     
156.     返回 (中)
     
157. .如果真结束
     
158. 返回 (0)
     
159. 
     
160. 
     
161. 
     
162. .子程序 顺序查找_易源码, 整数型
     
163. .参数 数组, 整数型, 数组
     
164. .参数 值, 整数型
     
165. .局部变量 计数, 整数型
     
166. 
     
167. .计次循环首 (取数组成员数 (数组), 计数)
     
168.     .如果真 (数组 [计数] ＝ 值)
     
169.         返回 (计数)
     
170.     .如果真结束
     
171. 
     
172. .计次循环尾 ()
     
173. 返回 (0)
     

复制代码

花心大萝卜

看看是啥玩意

小小白

我也来看看