数组_去重复_整数型 改进 提升36倍！

明天自然醒

今日翻翻模块源码发现这个函数有改进空间。原贴。
https://bbs.125.la/thread-14402954-1-1.html

对于大数据（100万以上）有显著提升。


测试数据：
数组1：取值范围-10000到+10000，长度100万

原函数：耗时547ms，改进后：耗时32毫秒，提升16倍


数组2：取值范围-10000到+10000，长度500万


原函数：耗时8828ms，改进后：耗时235毫秒，提升36倍


数组3：取值范围-10000到+10000，长度1000万

原函数：耗时17578ms，改进后：耗时469毫秒，提升36倍


取值范围-10w到+10w也有测试，也差不多这个样子。具体去重结果也一样


改进函数：

  

子程序名	返回值类型	公开	备 注
数组_去重复_整数型2	整数型		返回剩余不重复数组的成员数量
参数名	类 型	参考	可空	数组	备 注
整数数组	整数型				要去重复的 整数数组

变量名	类 型	静态	数组	备 注
i	整数型
局_参考空间	整数型		0	空间
局_最大值	整数型
局_最小值	整数型
数组长度	整数型
a	整数型
参数1	双精度小数型

' 不需要用长整数，易语言数组容量应该超不过整数型极限2147483648
如果真 (取数组成员数 (整数数组) ＝ 0)
返回 (0)

连续赋值 (整数数组 [1], 局_最大值, 局_最小值)
变量循环首 (2, 取数组成员数 (整数数组), 1, i)
如果 (整数数组 [i] ＞ 局_最大值)
局_最大值 ＝ 整数数组 [i]
如果真 (整数数组 [i] ＜ 局_最小值)
局_最小值 ＝ 整数数组 [i]


变量循环尾 ()
数组长度 ＝ 局_最大值 － 局_最小值 ＋ 1
参数1 ＝ 局_最小值 － 1
' 开辟空间
重定义数组 (局_参考空间, 假, 数组长度)
计次循环首 (取数组成员数 (整数数组), i)
局_参考空间 [整数数组 [i] － 参数1] ＝ 1
计次循环尾 ()
计次循环首 (取数组成员数 (局_参考空间), i)
如果真 (局_参考空间 [i] ＝ 1)
a ＝ a ＋ 1
整数数组 [a] ＝ i ＋ 参数1

计次循环尾 ()
重定义数组 (整数数组, 真, a)
返回 (取数组成员数 (整数数组))

.版本 2<br /> <br /> .子程序 数组_去重复_整数型2, 整数型, 公开, 返回剩余不重复数组的成员数量<br /> .参数 整数数组, 整数型, 数组, 要去重复的 整数数组<br /> .局部变量 i, 整数型<br /> .局部变量 局_参考空间, 整数型, , "0", 空间<br /> .局部变量 局_最大值, 整数型<br /> .局部变量 局_最小值, 整数型<br /> .局部变量 数组长度, 整数型<br /> .局部变量 a, 整数型<br /> .局部变量 参数1, 双精度小数型<br /> <br /> ' 不需要用长整数，易语言数组容量应该超不过整数型极限2147483648<br /> .如果真 (取数组成员数 (整数数组) ＝ 0)<br />     返回 (0)<br /> .如果真结束<br /> <br /> 连续赋值 (整数数组 [1], 局_最大值, 局_最小值)<br /> .变量循环首 (2, 取数组成员数 (整数数组), 1, i)<br />     .如果 (整数数组 <i> ＞ 局_最大值)<br />         局_最大值 ＝ 整数数组 <i><br />     .否则<br />         .如果真 (整数数组 <i> ＜ 局_最小值)<br />             局_最小值 ＝ 整数数组 <i><br />         .如果真结束<br /> <br />     .如果结束<br /> <br /> .变量循环尾 ()<br /> 数组长度 ＝ 局_最大值 － 局_最小值 ＋ 1<br /> 参数1 ＝ 局_最小值 － 1<br /> ' 开辟空间<br /> 重定义数组 (局_参考空间, 假, 数组长度)<br /> .计次循环首 (取数组成员数 (整数数组), i)<br />     局_参考空间 [整数数组 <i> － 参数1] ＝ 1<br /> .计次循环尾 ()<br /> <br /> .计次循环首 (取数组成员数 (局_参考空间), i)<br />     .如果真 (局_参考空间 <i> ＝ 1)<br />         a ＝ a ＋ 1<br />         整数数组 [a] ＝ i ＋ 参数1<br />     .如果真结束<br /> <br /> .计次循环尾 ()<br /> 重定义数组 (整数数组, 真, a)<br /> 返回 (取数组成员数 (整数数组))

测试附件：
数组_去重复_整数型.e (6.13 KB, 下载次数: 22)

2023-1-30 21:14 上传

点击文件名下载附件

明天自然醒

  

子程序名	返回值类型	公开	备 注
数组_去重复_非负整数8	整数型		返回剩余不重复数组的成员数量
参数名	类 型	参考	可空	数组	备 注
整数数组	整数型				要去重复的 整数数组

变量名	类 型	静态	数组	备 注
i	整数型
局_参考空间	字节型		0	空间
局_最大值	整数型
局_最小值	整数型
数组长度	整数型
a	整数型
len	整数型

' 不需要用长整数，易语言数组容量应该超不过整数型极限2147483648
如果真 (取数组成员数 (整数数组) ＝ 0)
返回 (0)

局_最大值 ＝ 整数数组 [1]
' 连续赋值 (整数数组 [1], 局_最大值)
变量循环首 (2, 取数组成员数 (整数数组), 1, i)
如果真 (整数数组 [i] ＞ 局_最大值)
局_最大值 ＝ 整数数组 [i]

变量循环尾 ()
数组长度 ＝ 局_最大值 ＋ 1
' 开辟空间
len ＝ 取数组成员数 (整数数组)
如果真 (len ＜ 1000000)
返回 (数组_去重复_整数型_bitmap (整数数组))
如果真 (数组长度 ＞ 1100000000)
返回 (数组_去重复_整数型_bitmap (整数数组))

重定义数组 (局_参考空间, 假, 数组长度)
计次循环首 (len, i)
如果真 (局_参考空间 [ASM_加 (整数数组 [i], 1)] ＝ 0)
局_参考空间 [ASM_加 (整数数组 [i], 1)] ＝ 1
a ＝ ASM_加 (a, 1)
整数数组 [a] ＝ 整数数组 [i]

计次循环尾 ()
重定义数组 (整数数组, 真, a)
返回 (a)

子程序名	返回值类型	公开	备 注
数组_去重复_整数型8	整数型		返回剩余不重复数组的成员数量
参数名	类 型	参考	可空	数组	备 注
整数数组	整数型				要去重复的 整数数组

变量名	类 型	静态	数组	备 注
i	整数型
局_参考空间	字节型		0	空间
局_最大值	整数型
局_最小值	整数型
数组长度	整数型
a	整数型
参数1	双精度小数型
len	整数型

' 不需要用长整数，易语言数组容量应该超不过整数型极限2147483648
如果真 (取数组成员数 (整数数组) ＝ 0)
返回 (0)

连续赋值 (整数数组 [1], 局_最大值, 局_最小值)
变量循环首 (2, 取数组成员数 (整数数组), 1, i)
如果 (整数数组 [i] ＞ 局_最大值)
局_最大值 ＝ 整数数组 [i]
如果真 (整数数组 [i] ＜ 局_最小值)
局_最小值 ＝ 整数数组 [i]


变量循环尾 ()
数组长度 ＝ 局_最大值 － 局_最小值 ＋ 1
参数1 ＝ 局_最小值 － 1
' 开辟空间
len ＝ 取数组成员数 (整数数组)
如果真 (len ＜ 1000000)
返回 (数组_去重复_整数型_bitmap (整数数组))
如果真 (数组长度 ＞ 1100000000)
返回 (数组_去重复_整数型_bitmap (整数数组))
重定义数组 (局_参考空间, 假, 数组长度)
计次循环首 (len, i)
如果真 (局_参考空间 [ASM_减 (整数数组 [i], 参数1)] ＝ 0)
局_参考空间 [ASM_减 (整数数组 [i], 参数1)] ＝ 1
a ＝ ASM_加 (a, 1)
整数数组 [a] ＝ 整数数组 [i]

计次循环尾 ()
重定义数组 (整数数组, 真, a)
返回 (a)

子程序名	返回值类型	公开	备 注
数组_去重复_正整数8	整数型		返回剩余不重复数组的成员数量
参数名	类 型	参考	可空	数组	备 注
整数数组	整数型				要去重复的 整数数组

变量名	类 型	静态	数组	备 注
i	整数型
局_参考空间	字节型		0	空间
局_最大值	整数型
局_最小值	整数型
数组长度	整数型
a	整数型
len	整数型

' 不需要用长整数，易语言数组容量应该超不过整数型极限2147483648
如果真 (取数组成员数 (整数数组) ＝ 0)
返回 (0)

局_最大值 ＝ 整数数组 [1]
' 连续赋值 (整数数组 [1], 局_最大值)
变量循环首 (2, 取数组成员数 (整数数组), 1, i)
如果真 (整数数组 [i] ＞ 局_最大值)
局_最大值 ＝ 整数数组 [i]

变量循环尾 ()
len ＝ 取数组成员数 (整数数组)
如果真 (len ＜ 1000000)
返回 (数组_去重复_整数型_bitmap (整数数组))
如果真 (数组长度 ＞ 1100000000)
返回 (数组_去重复_整数型_bitmap (整数数组))

' 开辟空间
重定义数组 (局_参考空间, 假, 局_最大值)
计次循环首 (len, i)
如果真 (局_参考空间 [整数数组 [i]] ＝ 0)
局_参考空间 [整数数组 [i]] ＝ 1
a ＝ ASM_加 (a, 1)
整数数组 [a] ＝ 整数数组 [i]

计次循环尾 ()
重定义数组 (整数数组, 真, a)
返回 (a)

子程序名	返回值类型	公开	备 注
数组_去重复_整数型_bitmap	整数型
参数名	类 型	参考	可空	数组	备 注
原数组	整数型

变量名	类 型	静态	数组	备 注
映射数组	整数型		0
i	整数型
k	整数型
下标	整数型
余数	字节型
数据量	整数型
s	整数型
局_最大值	整数型
局_最小值	整数型
数组长度	整数型
参数1	整数型
变化后	整数型

' 加入成员 (原数组, 2147483647)
' 当有最大整数2147483647的时候为最差情况，需要250MB空间
连续赋值 (原数组 [1], 局_最大值, 局_最小值)
变量循环首 (2, 取数组成员数 (原数组), 1, i)
如果 (原数组 [i] ＞ 局_最大值)
局_最大值 ＝ 原数组 [i]
如果真 (原数组 [i] ＜ 局_最小值)
局_最小值 ＝ 原数组 [i]


变量循环尾 ()
数组长度 ＝ 局_最大值 － 局_最小值 ＋ 1
参数1 ＝ 局_最小值 － 1
重定义数组 (映射数组, 假, 数组长度 ÷ 32 ＋ 1)
数据量 ＝ 取数组成员数 (原数组)
计次循环首 (数据量, k)
变化后 ＝ ASM_减 (原数组 [k], 参数1)
余数 ＝ 求余数_整数型 (变化后, 32)
如果 (余数 ＝ 0)
下标 ＝ 除法_整数型 (变化后, 32)
如果真 (__query_bit (映射数组 [下标], 31) ＝ 假)
映射数组 [下标] ＝ __set_bit_on (映射数组 [下标], 31)
s ＝ ASM_加 (s, 1)
原数组 [s] ＝ 原数组 [k]

下标 ＝ 除法_整数型 (变化后, 32) ＋ 1
如果真 (__query_bit (映射数组 [下标], 余数 － 1) ＝ 假)
映射数组 [下标] ＝ __set_bit_on (映射数组 [下标], 余数 － 1)
s ＝ ASM_加 (s, 1)
原数组 [s] ＝ 原数组 [k]


计次循环尾 ()
重定义数组 (原数组, 真, s)
返回 (s)

子程序名	返回值类型	公开	备 注
ASM_加	整数型		返回两个整数的相加值
参数名	类 型	参考	可空	数组	备 注
加数1	整数型
加数2	整数型

置入代码 ({ 139, 69, 8, 3, 69, 12, 201, 194, 8, 0 })
返回 (0)

子程序名	返回值类型	公开	备 注
ASM_减	整数型		返回两个整数的相减值,
参数名	类 型	参考	可空	数组	备 注
被减数	整数型
减数	整数型

置入代码 ({ 139, 69, 8, 43, 69, 12, 201, 194, 8, 0 })
返回 (0)

子程序名	返回值类型	公开	备 注
求余数_整数型	整数型
参数名	类 型	参考	可空	数组	备 注
a	整数型
b	整数型

置入代码 ({ 139, 69, 8, 51, 210, 247, 117, 12, 139, 194, 93, 194, 8, 0 })
' mov         eax,dword ptr [ebp+8]
' xor         edx,edx
' div         eax,dword ptr [ebp+0Ch]
' mov         eax,edx
' pop         ebp
' ret         8
返回 (0)

子程序名	返回值类型	公开	备 注
除法_整数型	整数型
参数名	类 型	参考	可空	数组	备 注
a	整数型
b	整数型

置入代码 ({ 139, 69, 8, 51, 210, 247, 117, 12, 93, 194, 8, 0 })
' mov         eax,dword ptr [ebp+8]
' xor         edx,edx
' div         eax,dword ptr [ebp+0Ch]
' pop         ebp
' ret         8
返回 (0)

子程序名	返回值类型	公开	备 注
数组_排序I_ASM			整数数组排序(快速排序)
参数名	类 型	参考	可空	数组	备 注
参_整数数组	整数型				只支持一维数组
参_方向	逻辑型				真=从小到大排序 假=从大到小排序，默认值为真。

判断 (参_方向 或 是否为空 (参_方向))
' 从小到大
置入代码 ({ 139, 77, 8, 139, 9, 227, 24, 131, 57, 1, 117, 19, 139, 81, 4, 133, 210, 116, 12, 131, 193, 8, 74, 82, 51, 210, 232, 4, 0, 0, 0, 201, 194, 12, 0, 86, 87, 83, 85, 86, 139, 233, 139, 68, 36, 24, 139, 216, 235, 2, 139, 214, 139, 242, 141, 4, 19, 209, 232, 139, 251, 139, 68, 133, 0, 59, 211, 119, 64, 137, 20, 36, 139, 84, 181, 0, 59, 208, 125, 9, 70, 139, 84, 181, 0, 59, 208, 124, 247, 133, 255, 116, 67, 59, 68, 189, 0, 125, 55, 79, 117, 247, 59, 247, 119, 24, 139, 76, 189, 0, 137, 76, 181, 0, 70, 137, 84, 189, 0, 51, 210, 59, 215, 131, 223, 0, 59, 247, 118, 198, 139, 20, 36, 141, 126, 255, 59, 215, 115, 8, 139, 205, 87, 232, 143, 255, 255, 255, 59, 243, 114, 154, 235, 12, 59, 247, 118, 204, 235, 226, 59, 247, 118, 198, 235, 220, 89, 93, 91, 95, 94, 194, 4, 0 })


' 从大到小
置入代码 ({ 139, 77, 8, 139, 9, 227, 24, 131, 57, 1, 117, 19, 139, 81, 4, 133, 210, 116, 12, 131, 193, 8, 74, 82, 51, 210, 232, 4, 0, 0, 0, 201, 194, 12, 0, 86, 87, 83, 85, 86, 139, 233, 139, 68, 36, 24, 139, 216, 235, 2, 139, 214, 139, 242, 141, 4, 19, 209, 232, 139, 251, 139, 68, 133, 0, 59, 211, 119, 64, 137, 20, 36, 139, 84, 181, 0, 59, 208, 126, 9, 70, 139, 84, 181, 0, 59, 208, 127, 247, 133, 255, 116, 67, 59, 68, 189, 0, 126, 55, 79, 117, 247, 59, 247, 119, 24, 139, 76, 189, 0, 137, 76, 181, 0, 70, 137, 84, 189, 0, 51, 210, 59, 215, 131, 223, 0, 59, 247, 118, 198, 139, 20, 36, 141, 126, 255, 59, 215, 115, 8, 139, 205, 87, 232, 143, 255, 255, 255, 59, 243, 114, 154, 235, 12, 59, 247, 118, 204, 235, 226, 59, 247, 118, 198, 235, 220, 89, 93, 91, 95, 94, 194, 4, 0 })

子程序名	返回值类型	公开	备 注
__query_bit	逻辑型		cha询一个整数 32位中的某一位是否为 1  @福仔
参数名	类 型	参考	可空	数组	备 注
num	整数型
bit	字节型				只支持 0 - 31, 越界返回假

置入代码 ({ 138, 77, 12, 51, 192, 128, 249, 32, 115, 14, 139, 69, 8, 133, 192, 116, 7, 51, 219, 67, 211, 227, 35, 195, 201, 194, 8, 0 })
' mov cl, [ebp+12]
' xor eax,eax
' cmp cl, 32
' jae exit    ; 位数大于等于32则返回
' mov eax, [ebp+8]
' test eax,eax
' jz exit     ; 参数1位0返回0
' mov ebx, 1
' shl ebx, cl
' and eax, ebx
' exit:
' leave
' ret 8
' 返回 (位与 (a, 左移 (1, offset)) ≠ 0)' 与上面的汇编效果差不多
返回 (假)

子程序名	返回值类型	公开	备 注
__set_bit_on	整数型		设置一个整数 32位中的某一位为1, 返回设置后的值  @福仔
参数名	类 型	参考	可空	数组	备 注
num	整数型
bit	字节型				只支持 0 - 31, 越界返回0

置入代码 ({ 138, 77, 12, 51, 192, 128, 249, 32, 115, 10, 139, 69, 8, 51, 219, 67, 211, 227, 11, 195, 201, 194, 8, 0 })
' mov cl,[ebp+12]
' xor eax, eax
' cmp cl, 32
' jae exit
' mov eax,[ebp+8]
' xor ebx,ebx
' inc ebx
' shl ebx, cl
' or eax, ebx
' exit:
' leave
' ret 8
返回 (0)

.版本 2<br /> <br /> .子程序 数组_去重复_非负整数8, 整数型, 公开, 返回剩余不重复数组的成员数量<br /> .参数 整数数组, 整数型, 数组, 要去重复的 整数数组<br /> .局部变量 i, 整数型<br /> .局部变量 局_参考空间, 字节型, , "0", 空间<br /> .局部变量 局_最大值, 整数型<br /> .局部变量 局_最小值, 整数型<br /> .局部变量 数组长度, 整数型<br /> .局部变量 a, 整数型<br /> .局部变量 len, 整数型<br /> <br /> ' 不需要用长整数，易语言数组容量应该超不过整数型极限2147483648<br /> .如果真 (取数组成员数 (整数数组) ＝ 0)<br />     返回 (0)<br /> .如果真结束<br /> <br /> 局_最大值 ＝ 整数数组 [1]<br /> ' 连续赋值 (整数数组 [1], 局_最大值)<br /> .变量循环首 (2, 取数组成员数 (整数数组), 1, i)<br />     .如果真 (整数数组 <i> ＞ 局_最大值)<br />         局_最大值 ＝ 整数数组 <i><br />     .如果真结束<br /> <br /> .变量循环尾 ()<br /> 数组长度 ＝ 局_最大值 ＋ 1<br /> ' 开辟空间<br /> len ＝ 取数组成员数 (整数数组)<br /> .如果真 (len ＜ 1000000)<br />     返回 (数组_去重复_整数型_bitmap (整数数组))<br /> .如果真结束<br /> .如果真 (数组长度 ＞ 1100000000)<br />     返回 (数组_去重复_整数型_bitmap (整数数组))<br /> .如果真结束<br /> <br /> 重定义数组 (局_参考空间, 假, 数组长度)<br /> <br /> .计次循环首 (len, i)<br />     .如果真 (局_参考空间 [ASM_加 (整数数组 <i>, 1)] ＝ 0)<br />         局_参考空间 [ASM_加 (整数数组 <i>, 1)] ＝ 1<br />         a ＝ ASM_加 (a, 1)<br />         整数数组 [a] ＝ 整数数组 <i><br />     .如果真结束<br /> <br /> .计次循环尾 ()<br /> 重定义数组 (整数数组, 真, a)<br /> 返回 (a)<br /> <br /> .子程序 数组_去重复_整数型8, 整数型, 公开, 返回剩余不重复数组的成员数量<br /> .参数 整数数组, 整数型, 数组, 要去重复的 整数数组<br /> .局部变量 i, 整数型<br /> .局部变量 局_参考空间, 字节型, , "0", 空间<br /> .局部变量 局_最大值, 整数型<br /> .局部变量 局_最小值, 整数型<br /> .局部变量 数组长度, 整数型<br /> .局部变量 a, 整数型<br /> .局部变量 参数1, 双精度小数型<br /> .局部变量 len, 整数型<br /> <br /> ' 不需要用长整数，易语言数组容量应该超不过整数型极限2147483648<br /> .如果真 (取数组成员数 (整数数组) ＝ 0)<br />     返回 (0)<br /> .如果真结束<br /> <br /> 连续赋值 (整数数组 [1], 局_最大值, 局_最小值)<br /> .变量循环首 (2, 取数组成员数 (整数数组), 1, i)<br />     .如果 (整数数组 <i> ＞ 局_最大值)<br />         局_最大值 ＝ 整数数组 <i><br />     .否则<br />         .如果真 (整数数组 <i> ＜ 局_最小值)<br />             局_最小值 ＝ 整数数组 <i><br />         .如果真结束<br /> <br />     .如果结束<br /> <br /> .变量循环尾 ()<br /> 数组长度 ＝ 局_最大值 － 局_最小值 ＋ 1<br /> 参数1 ＝ 局_最小值 － 1<br /> ' 开辟空间<br /> <br /> len ＝ 取数组成员数 (整数数组)<br /> .如果真 (len ＜ 1000000)<br />     返回 (数组_去重复_整数型_bitmap (整数数组))<br /> .如果真结束<br /> .如果真 (数组长度 ＞ 1100000000)<br />     返回 (数组_去重复_整数型_bitmap (整数数组))<br /> .如果真结束<br /> 重定义数组 (局_参考空间, 假, 数组长度)<br /> <br /> .计次循环首 (len, i)<br />     .如果真 (局_参考空间 [ASM_减 (整数数组 <i>, 参数1)] ＝ 0)<br />         局_参考空间 [ASM_减 (整数数组 <i>, 参数1)] ＝ 1<br />         a ＝ ASM_加 (a, 1)<br />         整数数组 [a] ＝ 整数数组 <i><br />     .如果真结束<br /> <br /> .计次循环尾 ()<br /> 重定义数组 (整数数组, 真, a)<br /> 返回 (a)<br /> <br /> .子程序 数组_去重复_正整数8, 整数型, 公开, 返回剩余不重复数组的成员数量<br /> .参数 整数数组, 整数型, 数组, 要去重复的 整数数组<br /> .局部变量 i, 整数型<br /> .局部变量 局_参考空间, 字节型, , "0", 空间<br /> .局部变量 局_最大值, 整数型<br /> .局部变量 局_最小值, 整数型<br /> .局部变量 数组长度, 整数型<br /> .局部变量 a, 整数型<br /> .局部变量 len, 整数型<br /> <br /> ' 不需要用长整数，易语言数组容量应该超不过整数型极限2147483648<br /> .如果真 (取数组成员数 (整数数组) ＝ 0)<br />     返回 (0)<br /> .如果真结束<br /> <br /> 局_最大值 ＝ 整数数组 [1]<br /> ' 连续赋值 (整数数组 [1], 局_最大值)<br /> .变量循环首 (2, 取数组成员数 (整数数组), 1, i)<br />     .如果真 (整数数组 <i> ＞ 局_最大值)<br />         局_最大值 ＝ 整数数组 <i><br />     .如果真结束<br /> <br /> .变量循环尾 ()<br /> <br /> len ＝ 取数组成员数 (整数数组)<br /> .如果真 (len ＜ 1000000)<br />     返回 (数组_去重复_整数型_bitmap (整数数组))<br /> .如果真结束<br /> .如果真 (数组长度 ＞ 1100000000)<br />     返回 (数组_去重复_整数型_bitmap (整数数组))<br /> .如果真结束<br /> <br /> ' 开辟空间<br /> 重定义数组 (局_参考空间, 假, 局_最大值)<br /> .计次循环首 (len, i)<br />     .如果真 (局_参考空间 [整数数组 <i>] ＝ 0)<br />         局_参考空间 [整数数组 <i>] ＝ 1<br />         a ＝ ASM_加 (a, 1)<br />         整数数组 [a] ＝ 整数数组 <i><br />     .如果真结束<br /> <br /> .计次循环尾 ()<br /> 重定义数组 (整数数组, 真, a)<br /> 返回 (a)<br /> <br /> .子程序 数组_去重复_整数型_bitmap, 整数型, 公开<br /> .参数 原数组, 整数型, 参考 数组<br /> .局部变量 映射数组, 整数型, , "0"<br /> .局部变量 i, 整数型<br /> .局部变量 k, 整数型<br /> .局部变量 下标, 整数型<br /> .局部变量 余数, 字节型<br /> .局部变量 数据量, 整数型<br /> .局部变量 s, 整数型<br /> .局部变量 局_最大值, 整数型<br /> .局部变量 局_最小值, 整数型<br /> .局部变量 数组长度, 整数型<br /> .局部变量 参数1, 整数型<br /> .局部变量 变化后, 整数型<br /> <br /> ' 加入成员 (原数组, 2147483647)<br /> ' 当有最大整数2147483647的时候为最差情况，需要250MB空间<br /> <br /> 连续赋值 (原数组 [1], 局_最大值, 局_最小值)<br /> <br /> .变量循环首 (2, 取数组成员数 (原数组), 1, i)<br />     .如果 (原数组 <i> ＞ 局_最大值)<br />         局_最大值 ＝ 原数组 <i><br />     .否则<br />         .如果真 (原数组 <i> ＜ 局_最小值)<br />             局_最小值 ＝ 原数组 <i><br />         .如果真结束<br /> <br />     .如果结束<br /> <br /> .变量循环尾 ()<br /> 数组长度 ＝ 局_最大值 － 局_最小值 ＋ 1<br /> 参数1 ＝ 局_最小值 － 1<br /> <br /> 重定义数组 (映射数组, 假, 数组长度 ÷ 32 ＋ 1)<br /> 数据量 ＝ 取数组成员数 (原数组)<br /> <br /> .计次循环首 (数据量, k)<br />     变化后 ＝ ASM_减 (原数组 [k], 参数1)<br />     余数 ＝ 求余数_整数型 (变化后, 32)<br />     .如果 (余数 ＝ 0)<br />         下标 ＝ 除法_整数型 (变化后, 32)<br />         .如果真 (__query_bit (映射数组 [下标], 31) ＝ 假)<br />             映射数组 [下标] ＝ __set_bit_on (映射数组 [下标], 31)<br />             s ＝ ASM_加 (s, 1)<br />             原数组 <strike> ＝ 原数组 [k]<br />         .如果真结束<br /> <br />     .否则<br />         下标 ＝ 除法_整数型 (变化后, 32) ＋ 1<br />         .如果真 (__query_bit (映射数组 [下标], 余数 － 1) ＝ 假)<br />             映射数组 [下标] ＝ __set_bit_on (映射数组 [下标], 余数 － 1)<br />             s ＝ ASM_加 (s, 1)<br />             原数组 <strike> ＝ 原数组 [k]<br />         .如果真结束<br /> <br />     .如果结束<br /> <br /> .计次循环尾 ()<br /> <br /> 重定义数组 (原数组, 真, s)<br /> <br /> 返回 (s)<br /> <br /> .子程序 ASM_加, 整数型, , 返回两个整数的相加值<br /> .参数 加数1, 整数型<br /> .参数 加数2, 整数型<br /> <br /> 置入代码 ({ 139, 69, 8, 3, 69, 12, 201, 194, 8, 0 })<br /> 返回 (0)<br /> <br /> .子程序 ASM_减, 整数型, , 返回两个整数的相减值,<br /> .参数 被减数, 整数型<br /> .参数 减数, 整数型<br /> <br /> 置入代码 ({ 139, 69, 8, 43, 69, 12, 201, 194, 8, 0 })<br /> 返回 (0)<br /> <br /> .子程序 求余数_整数型, 整数型<br /> .参数 a, 整数型<br /> .参数 b, 整数型<br /> <br /> 置入代码 ({ 139, 69, 8, 51, 210, 247, 117, 12, 139, 194, 93, 194, 8, 0 })<br /> ' mov         eax,dword ptr [ebp+8]<br /> ' xor         edx,edx<br /> ' div         eax,dword ptr [ebp+0Ch]<br /> ' mov         eax,edx<br /> ' pop         ebp<br /> ' ret         8<br /> 返回 (0)<br /> <br /> .子程序 除法_整数型, 整数型<br /> .参数 a, 整数型<br /> .参数 b, 整数型<br /> <br /> 置入代码 ({ 139, 69, 8, 51, 210, 247, 117, 12, 93, 194, 8, 0 })<br /> ' mov         eax,dword ptr [ebp+8]<br /> ' xor         edx,edx<br /> ' div         eax,dword ptr [ebp+0Ch]<br /> ' pop         ebp<br /> ' ret         8<br /> 返回 (0)<br /> <br /> .子程序 数组_排序I_ASM, , , 整数数组排序(快速排序)<br /> .参数 参_整数数组, 整数型, 参考 数组, 只支持一维数组<br /> .参数 参_方向, 逻辑型, 可空, 真=从小到大排序 假=从大到小排序，默认值为真。<br /> <br /> .判断开始 (参_方向 或 是否为空 (参_方向))<br />     ' 从小到大<br />     置入代码 ({ 139, 77, 8, 139, 9, 227, 24, 131, 57, 1, 117, 19, 139, 81, 4, 133, 210, 116, 12, 131, 193, 8, 74, 82, 51, 210, 232, 4, 0, 0, 0, 201, 194, 12, 0, 86, 87, 83, 85, 86, 139, 233, 139, 68, 36, 24, 139, 216, 235, 2, 139, 214, 139, 242, 141, 4, 19, 209, 232, 139, 251, 139, 68, 133, 0, 59, 211, 119, 64, 137, 20, 36, 139, 84, 181, 0, 59, 208, 125, 9, 70, 139, 84, 181, 0, 59, 208, 124, 247, 133, 255, 116, 67, 59, 68, 189, 0, 125, 55, 79, 117, 247, 59, 247, 119, 24, 139, 76, 189, 0, 137, 76, 181, 0, 70, 137, 84, 189, 0, 51, 210, 59, 215, 131, 223, 0, 59, 247, 118, 198, 139, 20, 36, 141, 126, 255, 59, 215, 115, 8, 139, 205, 87, 232, 143, 255, 255, 255, 59, 243, 114, 154, 235, 12, 59, 247, 118, 204, 235, 226, 59, 247, 118, 198, 235, 220, 89, 93, 91, 95, 94, 194, 4, 0 })<br /> .默认<br /> <br />     ' 从大到小<br />     置入代码 ({ 139, 77, 8, 139, 9, 227, 24, 131, 57, 1, 117, 19, 139, 81, 4, 133, 210, 116, 12, 131, 193, 8, 74, 82, 51, 210, 232, 4, 0, 0, 0, 201, 194, 12, 0, 86, 87, 83, 85, 86, 139, 233, 139, 68, 36, 24, 139, 216, 235, 2, 139, 214, 139, 242, 141, 4, 19, 209, 232, 139, 251, 139, 68, 133, 0, 59, 211, 119, 64, 137, 20, 36, 139, 84, 181, 0, 59, 208, 126, 9, 70, 139, 84, 181, 0, 59, 208, 127, 247, 133, 255, 116, 67, 59, 68, 189, 0, 126, 55, 79, 117, 247, 59, 247, 119, 24, 139, 76, 189, 0, 137, 76, 181, 0, 70, 137, 84, 189, 0, 51, 210, 59, 215, 131, 223, 0, 59, 247, 118, 198, 139, 20, 36, 141, 126, 255, 59, 215, 115, 8, 139, 205, 87, 232, 143, 255, 255, 255, 59, 243, 114, 154, 235, 12, 59, 247, 118, 204, 235, 226, 59, 247, 118, 198, 235, 220, 89, 93, 91, 95, 94, 194, 4, 0 })<br /> .判断结束<br /> <br /> <br /> .子程序 __query_bit, 逻辑型, 公开, cha询一个整数 32位中的某一位是否为 1  @福仔<br /> .参数 num, 整数型<br /> .参数 bit, 字节型, , 只支持 0 - 31, 越界返回假<br /> <br /> 置入代码 ({ 138, 77, 12, 51, 192, 128, 249, 32, 115, 14, 139, 69, 8, 133, 192, 116, 7, 51, 219, 67, 211, 227, 35, 195, 201, 194, 8, 0 })<br /> ' mov cl, [ebp+12]<br /> ' xor eax,eax<br /> ' cmp cl, 32<br /> ' jae exit    ; 位数大于等于32则返回<br /> ' mov eax, [ebp+8]<br /> ' test eax,eax<br /> ' jz exit     ; 参数1位0返回0<br /> ' mov ebx, 1<br /> ' shl ebx, cl<br /> ' and eax, ebx<br /> ' exit:<br /> ' leave<br /> ' ret 8<br /> <br /> ' 返回 (位与 (a, 左移 (1, offset)) ≠ 0)' 与上面的汇编效果差不多<br /> 返回 (假)<br /> <br /> .子程序 __set_bit_on, 整数型, 公开, 设置一个整数 32位中的某一位为1, 返回设置后的值  @福仔<br /> .参数 num, 整数型<br /> .参数 bit, 字节型, , 只支持 0 - 31, 越界返回0<br /> <br /> 置入代码 ({ 138, 77, 12, 51, 192, 128, 249, 32, 115, 10, 139, 69, 8, 51, 219, 67, 211, 227, 11, 195, 201, 194, 8, 0 })<br /> ' mov cl,[ebp+12]<br /> ' xor eax, eax<br /> ' cmp cl, 32<br /> ' jae exit<br /> ' mov eax,[ebp+8]<br /> ' xor ebx,ebx<br /> ' inc ebx<br /> ' shl ebx, cl<br /> ' or eax, ebx<br /> ' exit:<br /> ' leave<br /> ' ret 8<br /> 返回 (0)

新提 bitmap.e (18.66 KB, 下载次数: 6)

2023-2-1 23:41 上传

点击文件名下载附件

明天自然醒

项目部004 发表于 2023-2-1 17:10
https://bbs.125.la/forum.php?mod=redirect&goto=findpost&ptid=0&pid=25166458

有时间看看！

加个限制吧，代码在置顶帖

项目部004

https://bbs.125.la/forum.php?mod ... =0&pid=25166458

有时间看看！

明天自然醒

明天自然醒 发表于 2023-1-31 20:39
[e=1].版本 2

.子程序 ASM_加, 整数型, , 返回两个整数的相加值

@项目部004 更新了更新了，老哥

福仔

要不试试c++stl里的去重复?
翻译一下到易语言, 看上去代码量不是特别多, 好几个函数都是获取到指针而已
#include <algorithm> 算法头文件

明天自然醒

  

子程序名	返回值类型	公开	备 注
数组_去重复_整数型3	整数型		返回剩余不重复数组的成员数量
参数名	类 型	参考	可空	数组	备 注
整数数组	整数型				要去重复的 整数数组

变量名	类 型	静态	数组	备 注
i	整数型
局_参考空间	整数型		0	空间
局_最大值	整数型
局_最小值	整数型
数组长度	整数型
a	整数型
参数1	双精度小数型

' 不需要用长整数，易语言数组容量应该超不过整数型极限2147483648
如果真 (取数组成员数 (整数数组) ＝ 0)
返回 (0)

连续赋值 (整数数组 [1], 局_最大值, 局_最小值)
变量循环首 (2, 取数组成员数 (整数数组), 1, i)
如果 (整数数组 [i] ＞ 局_最大值)
局_最大值 ＝ 整数数组 [i]
如果真 (整数数组 [i] ＜ 局_最小值)
局_最小值 ＝ 整数数组 [i]


变量循环尾 ()
数组长度 ＝ 局_最大值 － 局_最小值 ＋ 1
参数1 ＝ 局_最小值 － 1
' 开辟空间
重定义数组 (局_参考空间, 假, 数组长度)
计次循环首 (取数组成员数 (整数数组), i)
如果真 (局_参考空间 [整数数组 [i] － 参数1] ＝ 0)
局_参考空间 [整数数组 [i] － 参数1] ＝ 1

计次循环尾 ()
计次循环首 (取数组成员数 (局_参考空间), i)
如果真 (局_参考空间 [i] ＝ 1)
a ＝ a ＋ 1
整数数组 [a] ＝ i ＋ 参数1

计次循环尾 ()
重定义数组 (整数数组, 真, a)
返回 (取数组成员数 (整数数组))

.版本 2<br /> <br /> .子程序 数组_去重复_整数型3, 整数型, 公开, 返回剩余不重复数组的成员数量<br /> .参数 整数数组, 整数型, 数组, 要去重复的 整数数组<br /> .局部变量 i, 整数型<br /> .局部变量 局_参考空间, 整数型, , "0", 空间<br /> .局部变量 局_最大值, 整数型<br /> .局部变量 局_最小值, 整数型<br /> .局部变量 数组长度, 整数型<br /> .局部变量 a, 整数型<br /> .局部变量 参数1, 双精度小数型<br /> <br /> ' 不需要用长整数，易语言数组容量应该超不过整数型极限2147483648<br /> .如果真 (取数组成员数 (整数数组) ＝ 0)<br />     返回 (0)<br /> .如果真结束<br /> <br /> 连续赋值 (整数数组 [1], 局_最大值, 局_最小值)<br /> .变量循环首 (2, 取数组成员数 (整数数组), 1, i)<br />     .如果 (整数数组 <i> ＞ 局_最大值)<br />         局_最大值 ＝ 整数数组 <i><br />     .否则<br />         .如果真 (整数数组 <i> ＜ 局_最小值)<br />             局_最小值 ＝ 整数数组 <i><br />         .如果真结束<br /> <br />     .如果结束<br /> <br /> .变量循环尾 ()<br /> 数组长度 ＝ 局_最大值 － 局_最小值 ＋ 1<br /> 参数1 ＝ 局_最小值 － 1<br /> ' 开辟空间<br /> 重定义数组 (局_参考空间, 假, 数组长度)<br /> .计次循环首 (取数组成员数 (整数数组), i)<br />     .如果真 (局_参考空间 [整数数组 <i> － 参数1] ＝ 0)<br />         局_参考空间 [整数数组 <i> － 参数1] ＝ 1<br />     .如果真结束<br /> <br /> .计次循环尾 ()<br /> <br /> .计次循环首 (取数组成员数 (局_参考空间), i)<br />     .如果真 (局_参考空间 <i> ＝ 1)<br />         a ＝ a ＋ 1<br />         整数数组 [a] ＝ i ＋ 参数1<br />     .如果真结束<br /> <br /> .计次循环尾 ()<br /> 重定义数组 (整数数组, 真, a)<br /> 返回 (取数组成员数 (整数数组))

梦寻简单

最小值和最大值相差过大时，将耗费大量的内存。