文本_哈希去重独立版，1000万条只需5秒

admin

1. .版本 2
   
2. .支持库 spec
   
3. 
   
4. .子程序 文本_哈希去重, 整数型, 公开, 如果测试速度，请编译后测试，调试的话申请释放内存会很慢，太大的数据可能直接卡死  by梦幻1096 Q:1096194951
   
5. .参数 文本数组, 文本型, 数组
   
6. .局部变量 链表地址, 整数型
   
7. .局部变量 链表长度, 整数型
   
8. .局部变量 键数量, 整数型
   
9. .局部变量 预设内存大小, 整数型
   
10. .局部变量 预设内存指针, 整数型
    
11. .局部变量 申请内存记录, 整数型, , "0"
    
12. .局部变量 扩容触发点, 整数型
    
13. .局部变量 表位置, 整数型
    
14. .局部变量 链表节点, 整数型
    
15. .局部变量 节点地址, 整数型
    
16. .局部变量 文本地址, 整数型
    
17. .局部变量 文本长度, 整数型
    
18. .局部变量 哈希值, 整数型
    
19. .局部变量 是否重复, 逻辑型
    
20. .局部变量 a, 整数型
    
21. .局部变量 b, 整数型
    
22. .局部变量 c, 整数型
    
23. .局部变量 d, 整数型
    
24. .局部变量 e, 整数型
    
25. .局部变量 f, 整数型
    
26. .局部变量 i, 整数型
    
27. .局部变量 j, 整数型
    
28. 
    
29. ' 完全采用易代码写的哈希表去重方式，未使用任何模块，效率还可以
    
30. 
    
31. 
    
32. .如果真 (取数组成员数 (文本数组) ≤ 1)
    
33.     返回 (取数组成员数 (文本数组))
    
34. .如果真结束
    
35. ' 定义表初始长度
    
36. 链表长度 ＝ 16
    
37. ' 申请表的起始地址内存
    
38. 链表地址 ＝ 申请内存 (左移 (链表长度, 2), 真)
    
39. 
    
40. ' 如果数组很大的话，比如10000+，预先申请一片内存区域，这里默认给了10000，不要设置太小就行了，10000内本来就很快
    
41. .如果真 (取数组成员数 (文本数组) ＞ 10000)
    
42.     预设内存大小 ＝ 取数组成员数 (文本数组) × 4
    
43.     加入成员 (申请内存记录, 申请内存 (预设内存大小, 真))
    
44.     预设内存指针 ＝ 申请内存记录 [1]
    
45. .如果真结束
    
46. 
    
47. ' 定义扩容触发点，负载因子为0.75自动扩容
    
48. 扩容触发点 ＝ 链表长度 × 0.75
    
49. ' 循环添加文本键
    
50. .计次循环首 (取数组成员数 (文本数组), i)
    
51.     ' 取文本长度如果有更快的版本，可自行替换
    
52.     文本地址 ＝ 取变量数据地址 (文本数组 <i>)
    
53.     .如果真 (文本地址 ＝ 0)
    
54.         到循环尾 ()
    
55.     .如果真结束
    
56.     文本长度 ＝ 取文本长度 (文本数组 <i>)
    
57. 
    
58.     ' 取哈希值
    
59.     c ＝ 文本长度 ＼ 4
    
60.     d ＝ 文本长度 ％ 4
    
61.     a ＝ 十六进制 (“811c9dc5”)
    
62.     b ＝ 十六进制 (“01000193”)
    
63.     e ＝ 文本地址
    
64.     .如果真 (c ≠ 0)
    
65.         .计次循环首 (c, j)
    
66.             f ＝ 指针到整数 (e)
    
67.             a ＝ 位异或 (a, f) × b
    
68.             e ＝ e ＋ 4
    
69.         .计次循环尾 ()
    
70.     .如果真结束
    
71.     .如果真 (d ≠ 0)
    
72.         f ＝ 左移 (指针到整数 (e), (4 － d) × 8)
    
73.         a ＝ 位异或 (a, f) × b
    
74.     .如果真结束
    
75.     哈希值 ＝ 取绝对值 (a)
    
76. 
    
77. 
    
78.     ' 取哈希值的余数获取表位置
    
79.     表位置 ＝ 哈希值 ％ (链表长度 － 1) ＋ 1
    
80. 
    
81.     ' 起始地址+表位置*4 为哈希值获取到的位置，从当前位置获取节点地址
    
82.     链表节点 ＝ 链表地址 ＋ 左移 (表位置, 2)
    
83.     节点地址 ＝ 指针到整数 (链表节点)
    
84. 
    
85.     ' 获取到节点地址开始遍历节点
    
86.     .判断循环首 (节点地址 ≠ 0)
    
87.         .如果真 (哈希值 ＝ 指针到整数 (节点地址))  ' 节点首地址为哈希值 如果哈希值相同则继续判断长度
    
88.             .如果真 (文本长度 ＝ 指针到整数 (节点地址 ＋ 8))  ' 节点地址+8 为长度 如果长度相同，则对比数据
    
89.                 .如果真 (文本数组 <i> ＝ 文本数组 [指针到整数 (节点地址 ＋ 12)])  ' 节点地址+12 为文本下标，如果速度更快的对比方式可自行替换
    
90.                     是否重复 ＝ 真
    
91.                     跳出循环 ()
    
92.                     ' 对比结果如果完全相同，则表示数据重复，直接跳出去循环下一条
    
93.                 .如果真结束
    
94. 
    
95.             .如果真结束
    
96. 
    
97.         .如果真结束
    
98.         链表节点 ＝ 节点地址 ＋ 4  ' 节点地址+4为下一节点地址存放处
    
99.         节点地址 ＝ 指针到整数 (链表节点)  ' 读下一节点地址，继续循环，直到节点地址=0
    
100.     .判断循环尾 ()
     
101.     .如果真 (是否重复 ＝ 真)
     
102.         是否重复 ＝ 假
     
103.         到循环尾 ()
     
104.     .如果真结束
     
105. 
     
106.     ' 经过上面对比，节点地址肯定=0 所以申请一个新地址为节点地址
     
107.     .如果 (预设内存指针 ＝ 0)
     
108.         节点地址 ＝ 申请内存 (16, 真)  ' 节点为16字节长度
     
109.         加入成员 (申请内存记录, 节点地址)  ' 将申请的指针保存起来，以便后面释放
     
110.     .否则
     
111. 
     
112.         ' 如果在程序开始预设了内存，则这里分配之前申请好的内存并更新指针
     
113.         .如果真 (预设内存大小 ＜ 16)
     
114.             预设内存大小 ＝ 取数组成员数 (文本数组) × 4
     
115.             加入成员 (申请内存记录, 申请内存 (预设内存大小, 真))
     
116.             预设内存指针 ＝ 申请内存记录 [取数组成员数 (申请内存记录)]
     
117.         .如果真结束
     
118.         节点地址 ＝ 预设内存指针
     
119.         预设内存指针 ＝ 预设内存指针 ＋ 16
     
120.         预设内存大小 ＝ 预设内存大小 － 16
     
121.     .如果结束
     
122. 
     
123.     写到内存 (节点地址, 链表节点, )  ' 将新申请的地址与上一节点连接上
     
124. 
     
125.     ' 以下为链表结构
     
126.     ' 0 哈希值
     
127.     ' 4 下一节点指针,由于是新申请的，所以没有下一节点，留空
     
128.     ' 8 保存长度，以便于后面对比
     
129.     ' 12 保存下标，用作后面对比
     
130.     写到内存 (哈希值, 节点地址, )
     
131.     写到内存 (文本长度, 节点地址 ＋ 8, )
     
132. 
     
133.     ' 将键数量递增，以便触发扩容
     
134.     键数量 ＝ 键数量 ＋ 1
     
135.     .如果真 (键数量 ≠ i)
     
136.         ' 将未重复的数组指针交换到当前键数量下标，就是把他放到前面去
     
137.         交换变量 (文本数组 [键数量], 文本数组 <i>)
     
138.     .如果真结束
     
139.     写到内存 (键数量, 节点地址 ＋ 12, )
     
140.     ' 下面为扩容程序
     
141.     .如果真 (键数量 ≥ 扩容触发点)
     
142.         j ＝ 左移 (链表长度, 1)
     
143.         f ＝ 申请内存 (左移 (j, 2), 真)
     
144.         .变量循环首 (链表地址, 链表地址 ＋ 左移 (链表长度 － 1, 2), 4, c)
     
145.             e ＝ 指针到整数 (c)
     
146.             .判断循环首 (e ≠ 0)
     
147.                 哈希值 ＝ 指针到整数 (e)
     
148.                 表位置 ＝ 哈希值 ％ (j － 1) ＋ 1
     
149.                 a ＝ f ＋ 左移 (表位置, 2)
     
150.                 b ＝ 指针到整数 (a)
     
151.                 .判断循环首 (b ≠ 0)
     
152.                     a ＝ b ＋ 4
     
153.                     b ＝ 指针到整数 (a)
     
154.                 .判断循环尾 ()
     
155.                 写到内存 (e, a, )
     
156.                 c ＝ e ＋ 4
     
157.                 e ＝ 指针到整数 (c)
     
158.                 写到内存 (0, c, )
     
159.             .判断循环尾 ()
     
160.         .变量循环尾 ()
     
161.         ' 释放旧链表
     
162.         释放内存 (链表地址)
     
163.         链表地址 ＝ f
     
164.         链表长度 ＝ j
     
165.         扩容触发点 ＝ 链表长度 × 0.75
     
166.     .如果真结束
     
167. 
     
168. .计次循环尾 ()
     
169. 
     
170. ' 搞定，释放之前申请的全部内存
     
171. .计次循环首 (取数组成员数 (申请内存记录), i)
     
172.     释放内存 (申请内存记录 <i>)
     
173. .计次循环尾 ()
     
174. ' 最后释放链表地址
     
175. 释放内存 (链表地址)
     
176. 
     
177. ' 由于之前把不重复的都放到了数组前面，这里直接重定义数组为键数量就行了
     
178. 重定义数组 (文本数组, 真, 键数量)
     
179. 返回 (键数量)

复制代码

纯的不能再纯的源码，完全用的易语言代码的方式写的，效率挺高的，1000万只需5秒，不过说是这么说，但是单条文本太长的话就要慢一些，总之比一般的去重都要快很多吧，而且这个是独立为1个子程序的，不需要什么模块 DLL啥的，写了我几个小时，免费分享给你们吧！有啥问题bug啥的评论区留言！
将保存文本数据改成了保存文本指针，减少了内存开销！，修复了文本指针为0（也就是数组里面存在空文本的情况）又又又更新了一下，将保存文本指针改成保存文本下标，效率又可以提升不少！