1. /* 2. Name: TablaHash.h 3. Author: Shiguihara Jurez Pedro 4. Author: Valverde Rebaza Jorge 5.

Description: Implementacin de una Tabla Hash 6. */ 7. 8. #include<stdio.h> 9. 10. /* Declaracion de la tabla Hash */ 11. class TablaHash{ 12. public: 13. TablaHash(); 14. TablaHash(int ); 15. TablaHash(int ,char *); 16. ~TablaHash(); 17. void reportar(); 18. bool insertar(char *); 19. bool insertar2(char *); 20. int getDominio(); 21. int hash (char *); 22. int hash2(char *); 23. private: 24. NodoT *celdas; 25. int numeroNodos; 26. char *defecto; 27. 28. double secsPrimario; 29. double secsSecundario; 30. }; 31. 32. 33. // Constructor 1 34. // @nElementos: la dimension de la tabla para generarse en memoria 35. TablaHash::TablaHash(int nElementos) 36. { 37. int i=0; 38. celdas = new NodoT[nElementos]; 39. numeroNodos = nElementos; 40. defecto = "nada"; 41. for(i=0; i <numeroNodos; i++ ) 42. celdas[i] = NodoT(defecto); 43. //printf("\nEspacio creado satisfactoriamente...\n"); 44. secsPrimario=0.0; 45. secsSecundario=0.0; 46. } 47. 48. //Constructor 2 49. // @defec: Cadena con la que se inicializan todas las 50. //celdas indicando que esta vacia 51. TablaHash::TablaHash(int nElementos, char *defec) 52. { 53. int i=0; 54. celdas = new NodoT[nElementos]; 55. numeroNodos = nElementos; 56. defecto = defec; 57. for(i=0; i <numeroNodos; i++) 58. celdas[i] = NodoT(defecto); 59. //printf("\nEspacio creado satisfactoriamente...\n"); 60. secsPrimario=0.0;

61. 62. 63. 64. 65. 66. 67. 68. 69. 70. 71. 72. 73. 74. 75. 76. 77.

secsSecundario=0.0; }

//Destructor TablaHash::~TablaHash() { //delete[] celdas; //delete celdas; NodoT *aux; NodoT *aux2; int i=0; int cantidadPrimario=0; int cantidadSecundario=0; //printf("\nIniciando destruccion\n"); for(i=0; i<numeroNodos; i++) { //Primero verificamos que la celda este vacia para borrarla 78. //directamente de memoria 79. //apuntaCelda = apuntaCelda + i; 80. if(stricmp(celdas[i].valor,defecto)!=0 ) 81. { 82. aux = celdas; 83. aux = aux + i; 84. aux2 = aux->siguiente; 85. while(aux2) 86. { 87. cantidadSecundario++; 88. aux = aux2; 89. aux2 = aux2->siguiente; 90. delete aux; 91. aux = NULL; 92. } 93. cantidadPrimario++; 94. } 95. } 96. printf("\nAccesos primarios: %i",cantidadPrimario); 97. printf("\nAccesos secundarios: %i",cantidadSecundario); 98. printf("\nTiempo: Insercion directa Hash: %.16g ms", 99. secsPrimario * 1000.0); 100. printf("\nTiempo: Insercion por colision Hash: %.16g ms\n", 101. secsSecundario * 1000.0); 102. aux = NULL; 103. aux2 = NULL; 104. delete[] celdas; 105. delete celdas; 106. } 107. 108. 109. //devuelve el dominio de la tabla hash 110. int TablaHash::getDominio() 111. { 112. return numeroNodos; 113. } 114. 115. 116. //Reporte de todas las celdas 117. void TablaHash::reportar() 118. { 119. printf("\nReporte de tabla hash\n");

120. printf("----------------------------------------------------\n"); 121. 122. int i=0; 123. 124. for(i=0; i <numeroNodos; i++) 125. printf("\nT [%i] = %s",i , celdas[i].valor); 126. } 127. 128. 129. bool TablaHash::insertar2(char *v) 130. { 131. int idNuevo = hash2(v); 132. bool cortarBucle = false; 133. NodoT *aux; 134. //printf("\nID HASH: %i",idNuevo); 135. //secsPrimario=0.0; 136. //secsSecundario=0.0; 137. LARGE_INTEGER t_iniPrim, t_finPrim; 138. LARGE_INTEGER t_iniSec, t_finSec; 139. double secs=0.0; 140. double secs2=0.0; 141. if(stricmp(celdas[idNuevo].valor, defecto)==0) 142. { 143. QueryPerformanceCounter(&t_iniPrim); 144. celdas[idNuevo].modificarValor(v); 145. QueryPerformanceCounter(&t_finPrim); 146. secs = performancecounter_diff(&t_finPrim, &t_iniPrim); 147. secsPrimario = secsPrimario + secs; 148. return true; 149. } 150. else if(stricmp(celdas[idNuevo].valor, v)!=0) 151. { 152. QueryPerformanceCounter(&t_iniSec); 153. //printf("\nHubo colisin en la posicin %i",idNuevo); 154. aux = celdas; 155. aux = aux + idNuevo; 156. //printf("\nPuntero avanzo: %s",aux->valor); 157. cortarBucle = false; 158. while( aux->siguiente && cortarBucle == false) 159. { 160. if(stricmp(aux->siguiente->valor, v)==0) 161. cortarBucle = true; 162. aux = aux->siguiente; 163. } 164. if(cortarBucle == false) 165. { 166. aux->siguiente = new NodoT(v); 167. aux = NULL; 168. QueryPerformanceCounter(&t_finSec); 169. secs2 = performancecounter_diff(&t_finSec, &t_iniSec); 170. secsSecundario = secsSecundario + secs2; 171. return true; 172. } 173. QueryPerformanceCounter(&t_finSec); 174. secs2 = performancecounter_diff(&t_finSec, &t_iniSec); 175. secsSecundario = secsSecundario + secs2; 176. //printf("La palabra ya existe en secundario: %s",v); 177. aux = NULL; 178. return false;

179. 180. 181. 182. 183. 184. 185. 186. 187. 188. 189. 190. 191. 192. 193. 194. 195. 196. 197. 198. 199. 200. 201. 202. 203. 204. 205. 206. 207. 208. 209. 210. 211. 212. 213. 214. 215. 216. 217. 218. 219. 220. 221. 222. 223. 224. 225. 226. 227. 228. 229. 230. 231. 232. 233. 234.

} else { //printf("La palabra ya existe en primario: %s",v); return false; } }

bool TablaHash::insertar(char *v) { int idNuevo = hash2(v); if(stricmp(celdas[idNuevo].valor, defecto)==0) { celdas[idNuevo].modificarValor(v); return true; } else return false;

// Funcion hash que calcula una posicion de la tabla dado //un valor ingresado como parametro int TablaHash::hash(char *v) { int contador = 0; int n = strlen(v); int i=0; for(i=0; i<n; i++) contador = contador + v[i]*i; contador = contador % numeroNodos; return contador;

// Funcion hash que calcula una posicion de la tabla dado un //valor ingresado como parametro int TablaHash::hash2(char *v) { // int primo = 1009; // int primo = 500009; // int primo = 50021; //int primo = 500009; int primo = 200003; int n = strlen(v); const char *d = v; int h = 0; for(int i=0; i<n; i++,d++ h = (h<<2)+ *d; } )

return ((h >= 0) ? (h % primo) : (-h % primo));