API tools faq
paste
Advertisement
tomasfdel

Estructuras I Práctica 5

tomasfdel
Jun 8th, 2017
442
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C 17.95 KB | None | 0 0
raw download clone embed print report
  1. ///EJERCICIO 2
  2.  
  3. #include <stdio.h>
  4. #include <stdlib.h>
  5.  
  6. typedef unsigned (*FuncionHash)(void* clave);
  7. typedef int (*FuncionIgualdad)(void *, void *);
  8.  
  9. typedef struct {
  10.   void* clave;
  11.   void* dato;
  12. } CasillaHash;
  13.  
  14. typedef struct {
  15.   CasillaHash* tabla;
  16.   unsigned numElems;
  17.   unsigned capacidad;
  18.   FuncionHash hash;
  19.   FuncionIgualdad igualdad;
  20. } TablaHash;
  21.  
  22.  
  23. TablaHash* tablahash_crear(unsigned capacidad, FuncionHash hash, FuncionIgualdad igualdad) {
  24.   // Pedimos memoria para la estructura principal y las casillas.
  25.   TablaHash* tabla = malloc(sizeof(TablaHash));
  26.   tabla->hash = hash;
  27.   tabla->capacidad = capacidad;
  28.   tabla->igualdad = igualdad;
  29.   tabla->tabla = malloc(sizeof(CasillaHash) * capacidad);
  30.   tabla->numElems = 0;
  31.  
  32.   // Inicializamos las casillas con datos nulos.
  33.   for (unsigned idx = 0; idx < capacidad; ++idx) {
  34.     tabla->tabla[idx].clave = NULL;
  35.     tabla->tabla[idx].dato = NULL;
  36.   }
  37.  
  38.   return tabla;
  39. }
  40.  
  41. void tablahash_insertar(TablaHash* tabla, void* clave, void* dato) {
  42.   // Calculamos la posición de la clave dada, de acuerdo a la función hash.
  43.   unsigned idx = tabla->hash(clave);
  44.   idx = idx % tabla->capacidad;
  45.  
  46.   // Si el lugar estaba vacío, incrementamos el número de elementos.
  47.   if (tabla->tabla[idx].dato == NULL)
  48.     tabla->numElems++;
  49.  
  50.   // Almacenamos los datos ingresados.
  51.   tabla->tabla[idx].clave = clave;
  52.   tabla->tabla[idx].dato = dato;
  53. }
  54.  
  55. void* tablahash_buscar(TablaHash* tabla, void* clave) {
  56.   // Calculamos la posición de la clave dada, de acuerdo a la función hash.
  57.   unsigned idx = tabla->hash(clave);
  58.   idx = idx % tabla->capacidad;
  59.  
  60.   // Si el lugar esta vacío, retornamos un puntero nulo.
  61.   if ( !tabla->igualdad(tabla->tabla[idx].clave,clave) )
  62.     return NULL;
  63.  
  64.   return tabla->tabla[idx].dato;
  65. }
  66.  
  67. void tablahash_eliminar(TablaHash* tabla, void* clave) {
  68.   // Calculamos la posición de la clave dada, de acuerdo a la función hash.
  69.   unsigned idx = tabla->hash(clave);
  70.   idx = idx % tabla->capacidad;
  71.  
  72.   // Si el lugar estaba ocupado, decrementamos el número de elementos.
  73.   if (tabla->tabla[idx].clave != NULL)
  74.     tabla->numElems--;
  75.  
  76.   // Vaciamos la casilla.
  77.   tabla->tabla[idx].clave = NULL;
  78.   tabla->tabla[idx].dato = NULL;
  79. }
  80.  
  81. void tablahash_destruir(TablaHash* tabla) {
  82.   free(tabla->tabla);
  83.   free(tabla);
  84. }
  85.  
  86. unsigned hash(void* clave) {
  87.   int* p = clave;
  88.   return *p;
  89. }
  90.  
  91. int iguales(void* p1, void* p2){
  92.     int *pi1 = p1, *pi2 = p2;
  93.     return *pi1 == *pi2;
  94.     }
  95.  
  96. int main(void) {
  97.   int x = 42, y = 42, z = 3;
  98.   TablaHash *th = tablahash_crear(10, hash, iguales);
  99.  
  100.   tablahash_insertar(th, &x, &z);
  101.  
  102.   printf("z : %d\n", *((int *)tablahash_buscar(th, &x)));
  103.   printf("z : %d\n", *((int *)tablahash_buscar(th, &y)));
  104.  
  105.   tablahash_eliminar(th, &x);
  106.  
  107.   tablahash_destruir(th);
  108.  
  109.   return 0;
  110. }
  111.  
  112.  
  113.  
  114. ///EJERCICIO 3
  115.  
  116. #include <stdio.h>
  117. #include <stdlib.h>
  118.  
  119. typedef unsigned (*FuncionHash)(void* clave);
  120. typedef int (*FuncionIgualdad)(void *, void *);
  121.  
  122. typedef struct {
  123.   void* clave;
  124.   void* dato;
  125. } CasillaHash;
  126.  
  127. typedef struct {
  128.   CasillaHash* tabla;
  129.   unsigned numElems;
  130.   unsigned capacidad;
  131.   FuncionHash hash;
  132.   FuncionIgualdad igualdad;
  133. } TablaHash;
  134.  
  135.  
  136. TablaHash* tablahash_crear(unsigned capacidad, FuncionHash hash, FuncionIgualdad igualdad) {
  137.   // Pedimos memoria para la estructura principal y las casillas.
  138.   TablaHash* tabla = malloc(sizeof(TablaHash));
  139.   tabla->hash = hash;
  140.   tabla->capacidad = capacidad;
  141.   tabla->igualdad = igualdad;
  142.   tabla->tabla = malloc(sizeof(CasillaHash) * capacidad);
  143.   tabla->numElems = 0;
  144.  
  145.   // Inicializamos las casillas con datos nulos.
  146.   for (unsigned idx = 0; idx < capacidad; ++idx) {
  147.     tabla->tabla[idx].clave = NULL;
  148.     tabla->tabla[idx].dato = NULL;
  149.   }
  150.  
  151.   return tabla;
  152. }
  153.  
  154. void tablahash_insertar(TablaHash* tabla, void* clave, void* dato) {
  155.   // Calculamos la posición de la clave dada, de acuerdo a la función hash.
  156.     unsigned idx = tabla->hash(clave);
  157.     idx = idx % tabla->capacidad;
  158.     int i = 0, aux;
  159.    
  160.     for(i = 0; i < tabla -> capacidad; i++){
  161.         aux = (idx + i)%tabla->capacidad;
  162.         if(tabla->tabla[aux].dato == NULL){
  163.             tabla->numElems++;
  164.             tabla->tabla[aux].clave = clave;
  165.             tabla->tabla[aux].dato = dato;
  166.             break;
  167.             }  
  168.     }
  169. }
  170.  
  171. void* tablahash_buscar(TablaHash* tabla, void* clave) {
  172.   // Calculamos la posición de la clave dada, de acuerdo a la función hash.
  173.     unsigned idx = tabla->hash(clave);
  174.     idx = idx % tabla->capacidad;
  175.     int i=0, aux;
  176.    
  177.     for(i = 0; i < tabla -> capacidad; i++){
  178.         aux = (idx + i)%tabla->capacidad;
  179.         if(tabla->tabla[aux].clave == NULL)
  180.             break;
  181.         if(tabla->tabla[aux].dato != NULL && tabla->igualdad(tabla->tabla[aux].clave,clave))
  182.             return tabla->tabla[aux].dato;
  183.     }
  184.     return NULL;
  185. }
  186.  
  187. ///Si encontramos algo a eliminar, dejamos la clave y ponemos el dato en NULL.
  188. void tablahash_eliminar(TablaHash* tabla, void* clave) {
  189.   // Calculamos la posición de la clave dada, de acuerdo a la función hash.
  190.     unsigned idx = tabla->hash(clave);
  191.     idx = idx % tabla->capacidad;
  192.     int i=0, aux;
  193.    
  194.     for(i = 0; i < tabla -> capacidad; i++){
  195.         aux = (idx + i)%tabla->capacidad;
  196.         if(tabla->tabla[aux].clave == NULL)
  197.             break;
  198.         if(tabla->tabla[aux].dato != NULL && tabla->igualdad(tabla->tabla[aux].clave,clave)) {
  199.             tabla->numElems--;
  200.             tabla->tabla[aux].dato = NULL;
  201.             break;
  202.             }
  203.     }
  204. }
  205.  
  206. void tablahash_destruir(TablaHash* tabla) {
  207.   free(tabla->tabla);
  208.   free(tabla);
  209. }
  210.  
  211.  
  212. unsigned hash(void* clave) {
  213.   int* p = clave;
  214.   return *p;
  215. }
  216.  
  217. int iguales(void* p1, void* p2){
  218.     int *pi1 = p1, *pi2 = p2;
  219.     return *pi1 == *pi2;
  220.     }
  221.  
  222. int main(void) {
  223.     int x = 42, y = 42, z = 3;
  224.     TablaHash *th = tablahash_crear(10, hash, iguales);
  225.  
  226.     (tablahash_buscar(th, &x) == NULL) ? printf("No lo encontre antes de agregar. Todo bien.\n") : printf("ERROR.\n");
  227.     tablahash_insertar(th, &x, &z);
  228.     tablahash_insertar(th, &x, &z);
  229.     tablahash_eliminar(th, &x);
  230.     printf("z : %d\n", *((int *)tablahash_buscar(th, &x)));
  231.     tablahash_eliminar(th, &x);
  232.     (tablahash_buscar(th, &x) == NULL) ? printf("No lo encontre. Todo bien.\n") : printf("ERROR.\n");
  233.        
  234.     tablahash_destruir(th);
  235.  
  236.   return 0;
  237. }
  238.  
  239.  
  240.  
  241. ///EJERCICIO 4
  242.  
  243. #include <stdio.h>
  244. #include <stdlib.h>
  245.  
  246. typedef unsigned (*FuncionHash)(void* clave);
  247. typedef unsigned (*FuncionHash2)(void* clave, unsigned m);
  248. typedef int (*FuncionIgualdad)(void *, void *);
  249.  
  250. typedef struct {
  251.   void* clave;
  252.   void* dato;
  253. } CasillaHash;
  254.  
  255. typedef struct {
  256.   CasillaHash* tabla;
  257.   unsigned numElems;
  258.   unsigned capacidad;
  259.   FuncionHash hash;
  260.   FuncionHash2 hash2;
  261.   FuncionIgualdad igualdad;
  262. } TablaHash;
  263.  
  264.  
  265. TablaHash* tablahash_crear(unsigned capacidad, FuncionHash hash, FuncionHash2 hash2, FuncionIgualdad igualdad) {
  266.   // Pedimos memoria para la estructura principal y las casillas.
  267.   TablaHash* tabla = malloc(sizeof(TablaHash));
  268.   tabla->hash = hash;
  269.   tabla->hash2 = hash2;
  270.   tabla->capacidad = capacidad;
  271.   tabla->igualdad = igualdad;
  272.   tabla->tabla = malloc(sizeof(CasillaHash) * capacidad);
  273.   tabla->numElems = 0;
  274.  
  275.   // Inicializamos las casillas con datos nulos.
  276.   for (unsigned idx = 0; idx < capacidad; ++idx) {
  277.     tabla->tabla[idx].clave = NULL;
  278.     tabla->tabla[idx].dato = NULL;
  279.   }
  280.  
  281.   return tabla;
  282. }
  283.  
  284. void tablahash_insertar(TablaHash* tabla, void* clave, void* dato) {
  285.   // Calculamos la posición de la clave dada, de acuerdo a la función hash.
  286.     unsigned idx = tabla->hash(clave);
  287.     idx = idx % tabla->capacidad;
  288.     int i = 0, aux;
  289.    
  290.     for(i = 0; i < tabla -> capacidad; i++){
  291.         aux = (idx + i * tabla->hash2(clave, tabla->capacidad)) % tabla->capacidad ;
  292.         if(tabla->tabla[aux].dato == NULL){
  293.             tabla->numElems++;
  294.             tabla->tabla[aux].clave = clave;
  295.             tabla->tabla[aux].dato = dato;
  296.             break;
  297.             }  
  298.     }
  299. }
  300.  
  301. void* tablahash_buscar(TablaHash* tabla, void* clave) {
  302.   // Calculamos la posición de la clave dada, de acuerdo a la función hash.
  303.     unsigned idx = tabla->hash(clave);
  304.     idx = idx % tabla->capacidad;
  305.     int i=0, aux;
  306.    
  307.     for(i = 0; i < tabla -> capacidad; i++){
  308.         aux = (idx + i * tabla->hash2(clave, tabla->capacidad)) % tabla->capacidad ;
  309.         if(tabla->tabla[aux].clave == NULL)
  310.             break;
  311.         if(tabla->tabla[aux].dato != NULL && tabla->igualdad(tabla->tabla[aux].clave,clave))
  312.             return tabla->tabla[aux].dato;
  313.     }
  314.     return NULL;
  315. }
  316.  
  317. ///Si encontramos algo a eliminar, dejamos la clave y ponemos el dato en NULL.
  318. void tablahash_eliminar(TablaHash* tabla, void* clave) {
  319.   // Calculamos la posición de la clave dada, de acuerdo a la función hash.
  320.     unsigned idx = tabla->hash(clave);
  321.     idx = idx % tabla->capacidad;
  322.     int i=0, aux;
  323.    
  324.     for(i = 0; i < tabla -> capacidad; i++){
  325.         aux = (idx + i * tabla->hash2(clave, tabla->capacidad)) % tabla->capacidad ;
  326.         if(tabla->tabla[aux].clave == NULL)
  327.             break;
  328.         if(tabla->tabla[aux].dato != NULL && tabla->igualdad(tabla->tabla[aux].clave,clave)) {
  329.             tabla->numElems--;
  330.             tabla->tabla[aux].dato = NULL;
  331.             break;
  332.             }
  333.     }
  334. }
  335.  
  336. void tablahash_destruir(TablaHash* tabla) {
  337.   free(tabla->tabla);
  338.   free(tabla);
  339. }
  340.  
  341.  
  342. unsigned hash(void* clave) {
  343.   int* p = clave;
  344.   return *p;
  345. }
  346.  
  347. unsigned hash2(void* clave, unsigned m) {
  348.     int *p = clave;
  349.     return 1 + *p % (m - 1);
  350. }
  351.  
  352. int iguales(void* p1, void* p2){
  353.     int *pi1 = p1, *pi2 = p2;
  354.     return *pi1 == *pi2;
  355.     }
  356.  
  357. int main(void) {
  358.     int x = 42, y = 42, z = 3;
  359.     TablaHash *th = tablahash_crear(10, hash, hash2, iguales);
  360.  
  361.     (tablahash_buscar(th, &x) == NULL) ? printf("No lo encontre antes de agregar. Todo bien.\n") : printf("ERROR.\n");
  362.     tablahash_insertar(th, &x, &z);
  363.     tablahash_insertar(th, &x, &z);
  364.     tablahash_eliminar(th, &x);
  365.     printf("z : %d\n", *((int *)tablahash_buscar(th, &x)));
  366.     tablahash_eliminar(th, &x);
  367.     (tablahash_buscar(th, &x) == NULL) ? printf("No lo encontre. Todo bien.\n") : printf("ERROR.\n");
  368.        
  369.     tablahash_destruir(th);
  370.  
  371.   return 0;
  372. }
  373.  
  374.  
  375.  
  376. ///EJERCICIO 5
  377.  
  378. #include <stdio.h>
  379. #include <stdlib.h>
  380.  
  381. typedef unsigned (*FuncionHash)(void* clave);
  382. typedef unsigned (*FuncionHash2)(void* clave, unsigned m);
  383. typedef int (*FuncionIgualdad)(void *, void *);
  384.  
  385. typedef struct {
  386.   void* clave;
  387.   void* dato;
  388. } CasillaHash;
  389.  
  390. typedef struct {
  391.   CasillaHash* tabla;
  392.   unsigned numElems;
  393.   unsigned capacidad;
  394.   FuncionHash hash;
  395.   FuncionHash2 hash2;
  396.   FuncionIgualdad igualdad;
  397. } TablaHash;
  398.  
  399.  
  400. TablaHash* tablahash_crear(unsigned capacidad, FuncionHash hash, FuncionHash2 hash2, FuncionIgualdad igualdad) {
  401.   // Pedimos memoria para la estructura principal y las casillas.
  402.   TablaHash* tabla = malloc(sizeof(TablaHash));
  403.   tabla->hash = hash;
  404.   tabla->hash2 = hash2;
  405.   tabla->capacidad = capacidad;
  406.   tabla->igualdad = igualdad;
  407.   tabla->tabla = malloc(sizeof(CasillaHash) * capacidad);
  408.   tabla->numElems = 0;
  409.  
  410.   // Inicializamos las casillas con datos nulos.
  411.   for (unsigned idx = 0; idx < capacidad; ++idx) {
  412.     tabla->tabla[idx].clave = NULL;
  413.     tabla->tabla[idx].dato = NULL;
  414.   }
  415.  
  416.   return tabla;
  417. }
  418.  
  419. void tablahash_insertar(TablaHash* tabla, void* clave, void* dato) {
  420.   // Calculamos la posición de la clave dada, de acuerdo a la función hash.
  421.     unsigned idx = tabla->hash(clave);
  422.     idx = idx % tabla->capacidad;
  423.     int i = 0, aux;
  424.    
  425.     for(i = 0; i < tabla -> capacidad; i++){
  426.         aux = (idx + i * tabla->hash2(clave, tabla->capacidad)) % tabla->capacidad ;
  427.         if(tabla->tabla[aux].dato == NULL){
  428.             tabla->numElems++;
  429.             tabla->tabla[aux].clave = clave;
  430.             tabla->tabla[aux].dato = dato;
  431.             break;
  432.             }  
  433.     }
  434. }
  435.  
  436. void* tablahash_buscar(TablaHash* tabla, void* clave) {
  437.   // Calculamos la posición de la clave dada, de acuerdo a la función hash.
  438.     unsigned idx = tabla->hash(clave);
  439.     idx = idx % tabla->capacidad;
  440.     int i=0, aux, posicionAux, flag = 0;
  441.     void* punteroSwap;
  442.    
  443.     for(i = 0; i < tabla -> capacidad; i++){
  444.         aux = (idx + i * tabla->hash2(clave, tabla->capacidad)) % tabla->capacidad ;
  445.         if(tabla->tabla[aux].clave == NULL)
  446.             break;
  447.         if (tabla -> tabla[aux].dato == NULL && flag == 0){
  448.             flag++; posicionAux = aux;
  449.         }
  450.            
  451.         if(tabla->tabla[aux].dato != NULL && tabla->igualdad(tabla->tabla[aux].clave,clave)) {
  452.             if(flag){
  453.                 punteroSwap = tabla -> tabla[posicionAux].dato;
  454.                 tabla -> tabla[posicionAux].dato = tabla -> tabla[aux].dato;
  455.                 tabla -> tabla[aux].dato = punteroSwap;
  456.                
  457.                 punteroSwap = tabla -> tabla[posicionAux].clave;
  458.                 tabla -> tabla[posicionAux].clave = tabla -> tabla[aux].clave;
  459.                 tabla -> tabla[aux].clave = punteroSwap;
  460.                
  461.                 return tabla->tabla[posicionAux].dato;
  462.                 }
  463.            
  464.             return tabla->tabla[aux].dato;
  465.             }
  466.     }
  467.     return NULL;
  468. }
  469.  
  470. ///Si encontramos algo a eliminar, dejamos la clave y ponemos el dato en NULL.
  471. void tablahash_eliminar(TablaHash* tabla, void* clave) {
  472.   // Calculamos la posición de la clave dada, de acuerdo a la función hash.
  473.     unsigned idx = tabla->hash(clave);
  474.     idx = idx % tabla->capacidad;
  475.     int i=0, aux;
  476.    
  477.     for(i = 0; i < tabla -> capacidad; i++){
  478.         aux = (idx + i * tabla->hash2(clave, tabla->capacidad)) % tabla->capacidad ;
  479.         if(tabla->tabla[aux].clave == NULL)
  480.             break;
  481.         if(tabla->tabla[aux].dato != NULL && tabla->igualdad(tabla->tabla[aux].clave,clave)) {
  482.             tabla->numElems--;
  483.             tabla->tabla[aux].dato = NULL;
  484.             break;
  485.             }
  486.     }
  487. }
  488.  
  489. void tablahash_destruir(TablaHash* tabla) {
  490.   free(tabla->tabla);
  491.   free(tabla);
  492. }
  493.  
  494.  
  495. unsigned hash(void* clave) {
  496.   int* p = clave;
  497.   return *p;
  498. }
  499.  
  500. unsigned hash2(void* clave, unsigned m) {
  501.     int *p = clave;
  502.     return 1 + *p % (m - 1);
  503. }
  504.  
  505. int iguales(void* p1, void* p2){
  506.     int *pi1 = p1, *pi2 = p2;
  507.     return *pi1 == *pi2;
  508.     }
  509.  
  510. int main(void) {
  511.     int x = 42, y = 42, z = 3;
  512.     TablaHash *th = tablahash_crear(10, hash, hash2, iguales);
  513.  
  514.     (tablahash_buscar(th, &x) == NULL) ? printf("No lo encontre antes de agregar. Todo bien.\n") : printf("ERROR.\n");
  515.     tablahash_insertar(th, &x, &z);
  516.     tablahash_insertar(th, &x, &z);
  517.     tablahash_eliminar(th, &x);
  518.     printf("z : %d\n", *((int *)tablahash_buscar(th, &x)));
  519.     tablahash_eliminar(th, &x);
  520.     (tablahash_buscar(th, &x) == NULL) ? printf("No lo encontre. Todo bien.\n") : printf("ERROR.\n");
  521.        
  522.     tablahash_destruir(th);
  523.  
  524.   return 0;
  525. }
  526.  
  527.  
  528. ///EJERCICIO 6
  529.  
  530. #include <stdio.h>
  531. #include <stdlib.h>
  532.  
  533. typedef unsigned (*FuncionHash)(void* clave);
  534. typedef int (*FuncionIgualdad)(void *, void *);
  535.  
  536. typedef struct _DatoHash{
  537.   void* clave;
  538.   void* dato;
  539.   struct _DatoHash* sig;
  540. } *DatoHash;
  541.  
  542. typedef struct {
  543.   DatoHash* tabla;
  544.   unsigned numElems;
  545.   unsigned capacidad;
  546.   FuncionHash hash;
  547.   FuncionIgualdad igualdad;
  548. } TablaHash;
  549.  
  550.  
  551. TablaHash* tablahash_crear(unsigned capacidad, FuncionHash hash, FuncionIgualdad igualdad) {
  552.     TablaHash* NuevaTabla = malloc(sizeof(TablaHash));
  553.     NuevaTabla -> tabla = malloc(sizeof(DatoHash) * capacidad);
  554.     NuevaTabla -> numElems = 0;
  555.     NuevaTabla -> capacidad = capacidad;
  556.     NuevaTabla -> hash = hash;
  557.     NuevaTabla -> igualdad = igualdad;
  558.  
  559.     for(int i = 0; i < capacidad; i++)
  560.         NuevaTabla -> tabla[i] = NULL;
  561.  
  562.     return NuevaTabla;
  563. }
  564.  
  565. void tablahash_insertar(TablaHash* tabla, void* clave, void* dato) {
  566.         tabla -> numElems ++;
  567.         DatoHash nuevaCelda = malloc(sizeof(struct _DatoHash));
  568.         nuevaCelda -> clave = clave;
  569.         nuevaCelda -> dato = dato;
  570.         nuevaCelda -> sig = NULL;
  571.  
  572.         unsigned idx = tabla -> hash(clave) % tabla -> capacidad;
  573.  
  574.         if(tabla -> tabla[idx] == NULL)
  575.             tabla -> tabla[idx] = nuevaCelda;
  576.         else{
  577.             DatoHash punteroAux = tabla -> tabla[idx];
  578.             for(; punteroAux -> sig != NULL; punteroAux = punteroAux -> sig);
  579.             punteroAux -> sig = nuevaCelda;
  580.         }
  581.  
  582. }
  583.  
  584. void* tablahash_buscar(TablaHash* tabla, void* clave) {
  585.     unsigned idx = tabla -> hash(clave) % tabla -> capacidad;
  586.     if(tabla -> tabla[idx] == NULL)
  587.         return NULL;
  588.  
  589.     DatoHash punteroAux = tabla -> tabla[idx];
  590.     for(; punteroAux != NULL && !tabla->igualdad(clave, punteroAux -> clave); punteroAux = punteroAux -> sig);
  591.  
  592.     return (punteroAux == NULL)? NULL : punteroAux ->dato;
  593. }
  594.  
  595. void tablahash_eliminar(TablaHash* tabla, void* clave){
  596.     unsigned idx = tabla -> hash(clave) % tabla -> capacidad;
  597.     if(tabla -> tabla[idx] != NULL){
  598.         if(tabla-> igualdad(tabla -> tabla[idx] -> clave, clave) ){
  599.             DatoHash punteroAux = tabla -> tabla[idx];
  600.             tabla -> tabla[idx] = tabla -> tabla[idx] -> sig;
  601.             free(punteroAux);
  602.             tabla -> numElems --;
  603.         }
  604.  
  605.         DatoHash punteroAux = tabla -> tabla[idx] -> sig, punteroAnterior = tabla ->tabla[idx];
  606.         for(; punteroAux -> sig != NULL && !tabla -> igualdad(punteroAux -> clave, clave); punteroAux = punteroAux -> sig, punteroAnterior = punteroAnterior -> sig);
  607.  
  608.         if(tabla -> igualdad(punteroAux -> clave, clave)){
  609.             punteroAnterior -> sig = punteroAux -> sig;
  610.             free(punteroAux);
  611.             tabla -> numElems --;
  612.         }
  613.     }
  614. }
  615.  
  616. void tablahash_destruir(TablaHash* tabla) {
  617.     DatoHash punteroAux, punteroAux2;
  618.     for(int i = 0; i < tabla -> capacidad; i++)
  619.         for(punteroAux = punteroAux2 = tabla -> tabla[i]; punteroAux != NULL; punteroAux2 = punteroAux){
  620.             punteroAux = punteroAux -> sig;
  621.             free(punteroAux2);
  622.         }
  623.   free(tabla->tabla);
  624.   free(tabla);
  625. }
  626.  
  627. unsigned hash(void* clave) {
  628.   int* p = clave;
  629.   return *p;
  630. }
  631.  
  632. int iguales(void* p1, void* p2){
  633.     int *pi1 = p1, *pi2 = p2;
  634.     return *pi1 == *pi2;
  635.     }
  636.  
  637. int main() {
  638.     int a = 42, b = 2, c = 7;
  639.     TablaHash* tabla = tablahash_crear(10, hash, iguales);
  640.     (tablahash_buscar(tabla, &a) == NULL)? printf("No encuentra nada, todo bien.\n") : printf("OhNo.mp3\n");
  641.     tablahash_insertar(tabla, &a, &a);
  642.     (tablahash_buscar(tabla, &b) == NULL)? printf("No encuentra nada, todo bien.\n") : printf("OhNo.mp3\n");
  643.     tablahash_insertar(tabla, &b, &b);
  644.     tablahash_insertar(tabla, &c, &c);
  645.     (tablahash_buscar(tabla, &b) != NULL)? printf("Encuentra algo, todo bien.\n") : printf("OhNo.mp3\n");
  646.     tablahash_eliminar(tabla, &b);
  647.     (tablahash_buscar(tabla, &b) == NULL)? printf("No encuentra nada, todo bien.\n") : printf("OhNo.mp3\n");
  648.  
  649.     tablahash_destruir(tabla);
  650.     return 0;
  651. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!