Reinvent the wheel to implement a hash table.

First, I want to write it in a sink. But at the end of the article, the system was dizzy. No way. Use C ++ to verify your ideas. The Code is as follows.

 

2. Chashmap: chashmap ()
3. {
4. M_size = 100;
5. M_count = 0;
6. M_nodes = (pcnode) malloc (sizeof (cNode) * 100 );
7. Zeromemory (m_nodes, sizeof (cNode) * 100 );
8. }
10. Chashmap ::~ Chashmap ()
11. {
12. For (INT I = 0; I <m_size; I ++)
13. {
14. Pcnode cur_node = m_nodes + I;
15. If (cur_node-> left)
16. _ Del_x (cur_node-> left );
17. If (cur_node-> right)
18. _ Del_x (cur_node-> right );
19. }
20. Free (m_nodes );
21. }
23. Bool chashmap: Set (DWORD key, DWORD Value)
24. {
25. If (m_count/m_size >=0.72)
26. {
27. // The size of the rebuilt hash table is double that of the original hash table.
28. DWORD new_size = m_size * 2;
29. Pcnode new_nodes = (pcnode) malloc (sizeof (cNode) * new_size );
30. Zeromemory (new_nodes, sizeof (cNode) * new_size );
31. For (INT I = 0; I <m_size; I ++)
32. {
33. Pcnode cur_node = m_nodes + I;
34. If (cur_node-> key)
35. {
36. // Add the current node.
37. Pcnode add_node = _ getaddress_x (new_nodes, new_size, cur_node-> key );
38. If (add_node) add_node-> value = cur_node-> value;
40. // Traverse the child node and delete the old one.
41. If (cur_node-> right)
42. _ Setanddel_x (new_nodes, new_size, cur_node-> right );
43. If (cur_node-> left)
44. _ Setanddel_x (new_nodes, new_size, cur_node-> left );
45. }
46. }
47. // Delete the old one.
48. Free (m_nodes );
49. M_nodes = new_nodes;
50. M_size = new_size;
51. }
53. Pcnode node;
54. If (node = _ getaddress_x (m_nodes, m_size, key ))
55. {
56. Node-> value = value;
57. M_count ++;
58. Return true;
59. }
60. Return false;
61. }
63. DWORD chashmap: Get (DWORD key)
64. {
65. // Locate the data first. Compare the key value to find the node. Finally, return the required value.
66. DWORD Pos = Key % m_size;
67. Pcnode node = m_nodes + Pos;
68. While (node ){
69. If (Key> node-> key)
70. Node = node-> right;
71. Else if (Key <node-> key)
72. Node = node-> left;
73. Else
74. Return node-> value;
75. }
76. Return NULL;
77. }
79. Bool chashmap: exists (DWORD key)
80. {
81. DWORD Pos = Key % m_size;
82. Pcnode node = m_nodes + Pos;
83. While (node ){
84. If (Key> node-> key)
85. Node = node-> right;
86. Else if (Key <node-> key)
87. Return true;
88. Else
89. Return node-> value;
90. }
91. Return false;
92. }
93. Bool chashmap: del (DWORD key)
94. {
95. DWORD Pos = Key % m_size;
96. Pcnode par_node = NULL, cur_node, node = m_nodes + Pos;
97. If (null = node-> key) return false;
98. While (node ){
100. If (Key> node-> key ){
101. Par_node = node;
102. Node = node-> right;
103. } Else if (Key <node-> key ){
104. Par_node = node;
105. Node = node-> left;
106. } Else {
107. Cur_node = node;
108. Break;
109. }
110. }
111. If (! Node) return false; // no result is returned.
113. If (! Par_node) // Root Node
114. {
115. If (cur_node-> right)
116. {
117. Pcnode left_node = cur_node-> left;
118. * Cur_node = * cur_node-> right;
119. If (left_node ){
120. // Mount it to the leftmost.
121. While (cur_node-> left ){
122. Cur_node = cur_node-> left;
123. }
124. Cur_node-> left = left_node;
125. }
126. } Else if (cur_node-> left)
127. {
128. // If no right node exists.
129. * Cur_node = * cur_node-> left;
130. } Else {
131. // Nothing
132. Cur_node-> value = cur_node-> key = 0;
133. Cur_node-> left = cur_node-> right = NULL;
134. }
135. Return true;
136. }
137. /* Release cur_node if it is not the root node */
138. If (cur_node-> right ){
139. Par_node-> right = cur_node-> right;
140. // The left node is mounted to the far left of the right.
141. If (cur_node-> left ){
142. Node = cur_node;
143. While (node-> left) {node = node-> left ;}
144. Node-> left = cur_node-> left;
145. }
146. } Else if (cur_node-> left ){
147. // The right side does not exist.
148. Par_node-> left = cur_node-> left;
149. } Else
150. {
151. If (par_node-> left = cur_node)
152. Par_node-> left = NULL;
153. Else
154. Par_node-> right = NULL;
155. }
156. Free (cur_node );
157. Return true;
158. }
160. // This is a static method. Copy a new node and delete it.
161. Void chashmap: _ setanddel_x (pcnode arg_nodes, DWORD arg_size, pcnode arg_node)
162. {
163. Pcnode add_node = _ getaddress_x (arg_nodes, arg_size, arg_node-> key );
164. If (add_node) add_node-> value = arg_node-> value;
166. If (arg_node-> right)
167. _ Setanddel_x (arg_nodes, arg_size, arg_node-> right );
168. If (arg_node-> left)
169. _ Setanddel_x (arg_nodes, arg_size, arg_node-> left );
170. Free (arg_node );
171. }
173. Void chashmap: _ del_x (pcnode arg_node)
174. {
176. If (arg_node-> right)
177. _ Del_x (arg_node );
178. If (arg_node-> left)
179. _ Del_x (arg_node );
180. Free (arg_node );
181. }
182. /*
183. If data with the same key value exists, null is returned.
184. This method is static.
185. If it exists, it will give me a space. If not. It allocates a new address.
186. */
187. Pcnode chashmap: _ getaddress_x (pcnode arg_node, DWORD arg_size, DWORD key)
188. {
189. DWORD Pos = Key % arg_size;
190. Pcnode t_node, node = arg_node + Pos;
191. If (node-> key = 0 ){
192. Node-> key = key;
193. Return node;
194. }
195. While (node)
196. {
197. T_node = node;
198. If (Key> node-> key)
199. Node = node-> right;
200. Else if (Key = node-> key)
201. Return NULL;
202. Else
203. Node = node-> left;
204. }
205. Node = (pcnode) malloc (sizeof (cNode ));
206. Node-> key = key; node-> left = node-> right = NULL;
207. If (Key> t_node-> key)
208. T_node-> right = node;
209. Else
210. T_node-> left = node;
211. Return node;
212. }

Header file:

 

1. Class chashmap
2. {
3. Public:
4. Chashmap ();
5. Bool set (DWORD key, DWORD Value); // sets data
6. DWORD size () {return m_size;} // take the capacity size
7. DWORD count () {return m_count;} // Number of Retrieved Data
8. DWORD get (DWORD key); // retrieves data
9. Bool del (DWORD key); // delete data
10. Bool exists (DWORD key); // whether the data exists
11. Virtual ~ Chashmap ();
13. PRIVATE:
14. Static pcnode _ getaddress_x (pcnode arg_node, DWORD arg_size, DWORD key );
15. Static void _ setanddel_x (pcnode arg_nodes, DWORD arg_size, pcnode arg_node );
16. Void _ del_x (pcnode arg_node );
17. Protected:
18. DWORD m_size;
19. DWORD m_count;
20. Pcnode m_nodes;
21. };