hashing casimiro

#include <stdio.h>
#include <stdlib.h>
#include "todo.h"
//Cola
void C_init(TCola *C){
    C->inicio=NULL;
    C->fin=NULL;
}
void C_enqueue(TCola *C, TElemento nuevoElem){
    TNodo *ptr_nuevoNodo;

    ptr_nuevoNodo = (TNodo*)malloc(sizeof(TNodo));

    if (ptr_nuevoNodo != NULL){
        ptr_nuevoNodo->elem = nuevoElem;
        ptr_nuevoNodo->sig = NULL;
        if (C->inicio == NULL)
            C->inicio = ptr_nuevoNodo;
        else
            C->fin->sig = ptr_nuevoNodo;

        C->fin = ptr_nuevoNodo;
    }
}

TElemento C_dequeue(TCola *C){
    if (!C_isEmpty(C)){
        TElemento head_info; TNodo *ptr_head;
        ptr_head = C->inicio;
        head_info = ptr_head->elem;
        C->inicio = C->inicio->sig;
        free(ptr_head);
        return head_info;
    }
    return '\n';
}
int C_isEmpty(TCola *C){
    return (C->inicio == NULL);
}
void C_finalize(TCola *C){
    while(!C_isEmpty(C)){
        C_dequeue(C);
    }
}

//Pila
void Stack_Create(TPila *P){
    P->top=NULL;
}
void Stack_Push(TPila *P, TElemento nuevoElem){
    TNodo *ptr_nuevoElem;

    ptr_nuevoElem = malloc(sizeof(TNodo));

    if (ptr_nuevoElem){
        ptr_nuevoElem->elem = nuevoElem;
        ptr_nuevoElem->sig = P->top;
        P->top = ptr_nuevoElem;
    }
}

TElemento Stack_Pop(TPila *P){
    TElemento top_info; TNodo *ptr_top;
    if (!Stack_IsEmpty(*P)){
        ptr_top = P->top;
        top_info = ptr_top->elem;
        P->top = P->top->sig;
        free(ptr_top);
        return top_info;
    }
    return '0';
}

int Stack_IsEmpty(TPila P){
    return (P.top==NULL);
}
TElemento Stack_Top(TPila P){
    return P.top->elem;
}

//Lista

void Lista_Crear(TLista *L){
    L->inicio = NULL;
    L->fin = NULL;
    L->numElem = 0;
}

void Lista_Finalizar(TLista *L){
    while (!Lista_EstaVacia(*L)){
        Lista_Eliminar(L,L->inicio->elem);
    }
}

int Lista_EstaVacia(TLista L){
    return (L.numElem==0);
}

void Lista_Insertar(TLista *L, char nombre[20],char numero[20]){
    if (!Lista_EstaEnLista(*L,e)){
        TNodo *nodo = malloc(sizeof(TNodo));
        nodo->key=nombre;
        nodo->valor=numero;
        nodo->sig=NULL;
        if (Lista_EstaVacia(*L)){
            L->inicio = nodo;
        }
        else{
            L->fin->sig = nodo;
        }
        L->fin = nodo;
        (L->numElem)++;
    }
}

int Lista_Insertar2(TLista *L, TElemento e,int tipo){
    if (!Lista_EstaEnLista(*L,e)){
        TNodo *nodo = malloc(sizeof(TNodo));
        nodo->elem=e;
        nodo->tipo=tipo;
        nodo->sig=NULL;
        if (Lista_EstaVacia(*L)){
            L->inicio = nodo;
        }
        else{
            L->fin->sig = nodo;
        }
        L->fin = nodo;
        (L->numElem)++;
        return 1;
    }

    TNodo *crtNodo= L->inicio;
    while(crtNodo!=NULL && crtNodo->elem != e)
        crtNodo=crtNodo->sig;
    return (crtNodo->tipo==tipo);

}

void Lista_Eliminar(TLista *L, TElemento e){
        if (!Lista_EstaVacia(*L)){
        TNodo *ptrActual = L->inicio;
        TNodo *ptrAnt = NULL;
        while (ptrActual != NULL ){
            if (ptrActual->elem == e)
                break;
            ptrAnt = ptrActual;
            ptrActual = ptrActual->sig;
        }
        if (ptrActual != NULL){// Lo encontró
            // Es el primer elemento de la lista
            if (ptrAnt == NULL){ // ptrActual == L->inicio
                L->inicio = L->inicio->sig;
            }
            // Es el último elemento
            if (ptrActual->sig == NULL){ // ptrActual == L->fin
                if (ptrAnt != NULL) ptrAnt->sig = NULL;
                L->fin = ptrAnt;
            }else{
            // Es un elemento del medio
                if (ptrAnt != NULL) ptrAnt->sig = ptrActual->sig;
            }
            free(ptrActual);
            (L->numElem)--;
        }
    }
}

int Lista_Tamanho(TLista L){
    return (L.numElem);
}
int Lista_EstaEnLista(TLista L, TElemento e){
    TNodo *crtNodo= L.inicio;
    while(crtNodo!=NULL && crtNodo->elem != e)
        crtNodo=crtNodo->sig;
    return (crtNodo!=NULL);
}

void Lista_Imprimir(TLista L){
    if (!Lista_EstaVacia(L)){
        TNodo *crtNodo=L.inicio;
        while (crtNodo!=NULL){
            printf("%d %d ",crtNodo->elem,crtNodo->tipo);
            crtNodo=crtNodo->sig;
        }
        printf("\n");

    }
}

void Lista_insertarEnOrden(TLista *L, TElemento nuevoElem) {
    TNodo *ptrNuevo;
    ptrNuevo = malloc(sizeof (TNodo));

    if (ptrNuevo) {
        ptrNuevo->elem = nuevoElem;
        ptrNuevo->sig = NULL;

        TNodo* ptrRec, *ptrAnt;
        ptrAnt = NULL;
        ptrRec = L->inicio;
        // Buscar la posición en la cual debo insertar
        while (ptrRec && ptrRec->elem < nuevoElem) {
            ptrAnt = ptrRec;
            ptrRec = ptrRec->sig;
        }
        if (ptrAnt == NULL)
            L->inicio = ptrNuevo;
        else {
            ptrAnt->sig = ptrNuevo;
            if (ptrAnt == L->fin) L->fin = ptrNuevo;
        }
        ptrNuevo->sig = ptrRec;
        (L->numElem)++;
    }
}
//Grafos
void grafo_init(TGrafo *grafo){
    grafo->nvertices=0;
    grafo->ini=NULL;
    grafo->fin=NULL;
}

int grafo_empty(TGrafo *grafo){
    return (grafo->nvertices==0);
}
int grafo_existeV(TGrafo *grafo,TElemento vert){
    TVertice *ptrRec=grafo->ini;
    while(ptrRec){
        if (ptrRec->info==vert){
            return 1;
        }
        ptrRec=ptrRec->sig;
    }
    return 0;
}

void grafo_insertV(TGrafo *grafo,TElemento vert){
    if (!grafo_existeV(grafo,vert)){
        TVertice *nuevo=malloc(sizeof(TVertice));
        nuevo->info=vert;
        Lista_Crear(&nuevo->lstAdyacentes);

        nuevo->sig=NULL;
        if (grafo->nvertices==0)
            grafo->ini=nuevo;
        else
            grafo->fin->sig=nuevo;
        grafo->fin=nuevo;
        (grafo->nvertices)++;
    }
}
void grafo_insertA(TGrafo *grafo,TElemento ini,TElemento fin){
    if (grafo_existeV(grafo,ini) && grafo_existeV(grafo,fin)){
        TVertice *ptrRec=grafo->ini;
        while(ptrRec){
            if (ptrRec->info==ini){
                if (!Lista_EstaEnLista(ptrRec->lstAdyacentes,fin))
                    Lista_insertarEnOrden(&ptrRec->lstAdyacentes,fin);
            }
            ptrRec=ptrRec->sig;
        }
        //Digrafo
        ptrRec=grafo->ini;
        while(ptrRec){
            if (ptrRec->info==fin){
                if (!Lista_EstaEnLista(ptrRec->lstAdyacentes,ini))
                    Lista_insertarEnOrden(&ptrRec->lstAdyacentes,ini);
            }
            ptrRec=ptrRec->sig;
        }
    }
}
void grafo_deleteV(TGrafo *grafo,TElemento vert){
    if (grafo_existeV(grafo,vert)){
        TVertice *ptrActual = grafo->ini;
        TVertice *ptrAnt = NULL;
        while (ptrActual != NULL ){
            Lista_Eliminar(&ptrActual->lstAdyacentes,vert);
            if (ptrActual->info == vert){
                break;
            }
            ptrAnt = ptrActual;
            ptrActual = ptrActual->sig;
        }

        if (ptrAnt == NULL){ // ptrActual == L->inicio
            grafo->ini = grafo->ini->sig;
        }
        if (ptrActual->sig == NULL){ // ptrActual == L->fin
            if (ptrAnt != NULL) ptrAnt->sig = NULL;
            grafo->fin = ptrAnt;
        }else{
            if (ptrAnt != NULL) ptrAnt->sig = ptrActual->sig;
        }
        ptrAnt=ptrActual->sig;
        free(ptrActual);
        (grafo->nvertices)--;
        //Terminamos de eliminar rastro del vertice
        while (ptrAnt != NULL){
            Lista_Eliminar(&ptrAnt->lstAdyacentes,vert);
            ptrAnt=ptrAnt->sig;
        }
    }

}
void grafo_deleteA(TGrafo *grafo,TElemento ini,TElemento fin){
    if (grafo_existeV(grafo,ini) && grafo_existeV(grafo,fin)){

        TVertice *ptrRec=grafo->ini;
        while(ptrRec){
            if (ptrRec->info==ini){
                Lista_Eliminar(&ptrRec->lstAdyacentes,fin);
                break;
            }
            ptrRec=ptrRec->sig;
        }
        //Digrafo
        ptrRec=grafo->ini;
        while(ptrRec){
            if (ptrRec->info==fin){
                if (Lista_EstaEnLista(ptrRec->lstAdyacentes,ini))
                    Lista_Eliminar(&ptrRec->lstAdyacentes,ini);
            break;
            }
            ptrRec=ptrRec->sig;
        }
    }

}
void grafo_print(TGrafo *grafo){
    TVertice *ptrRec=grafo->ini;
        while(ptrRec){
            printf("%c: ",ptrRec->info);
            Lista_Imprimir(ptrRec->lstAdyacentes);
            ptrRec=ptrRec->sig;
        }
}
void grafo_finalize(TGrafo *grafo){
    while (grafo->ini){
        grafo_deleteV(grafo,grafo->ini->info);
    }
}