Conjuntos implementacion

#include <stdlib.h>
#include <stdio.h>
#include "lista.h"

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

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

void Insertar(TLista *L, TElemento nuevoElem) {
    //Ete es el insertar en orden
    TNodo *ptrNuevo;
    ptrNuevo = malloc(sizeof (TNodo));
    //La diferencia esta en que aquí no volveremos a agregar los elem
    //que ya están en el conjunto
    if (ptrNuevo && !Miembro(*L,nuevoElem)) {
        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)++;
    }
}
void Remover(TLista *L, TElemento e){
    if (!Conjunto_EstaVacio(*L)){
        TNodo *crtNodo = L->inicio;
        TNodo *nodoAnt = NULL;
        while (crtNodo!=NULL){
            if (crtNodo->elem == e)
                break;
            nodoAnt=crtNodo;
            crtNodo=crtNodo->sig;
        }
        if (crtNodo!=NULL){
            if (nodoAnt == NULL){
                L->inicio= L->inicio->sig;
            }
            if (crtNodo->sig == NULL){
                L->fin = nodoAnt;
                nodoAnt->sig= NULL;
            }
            else{
                if (nodoAnt != NULL)
                    nodoAnt->sig=crtNodo->sig;
            }
            free(crtNodo);
            (L->numElem)--;
        }
    }
}

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

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

void Interseccion(TConjunto A,TConjunto B,TConjunto *C){
    TNodo *crtNodoA=A.inicio;
    TNodo *crtNodoB=B.inicio;

    while(crtNodoA!=NULL && crtNodoB!=NULL){
        if (crtNodoA->elem==crtNodoB->elem){
            Insertar(C,crtNodoA->elem);
            crtNodoA=crtNodoA->sig;
            crtNodoB=crtNodoB->sig;
        }
        else{
            if (crtNodoA->elem>crtNodoB->elem){
                crtNodoB=crtNodoB->sig;
            }
            else{
                crtNodoA=crtNodoA->sig;
            }
        }
    }

}
void Union(TConjunto A,TConjunto B,TConjunto *C){
    TNodo *crtNodoA=A.inicio;
    TNodo *crtNodoB=B.inicio;

    while(crtNodoA!=NULL && crtNodoB!=NULL){
        if (crtNodoA->elem==crtNodoB->elem){
            Insertar(C,crtNodoA->elem);
            crtNodoA=crtNodoA->sig;
            crtNodoB=crtNodoB->sig;
        }
        else{
            if (crtNodoA->elem>crtNodoB->elem){
                Insertar(C,crtNodoB->elem);
                crtNodoB=crtNodoB->sig;
            }
            else{
                Insertar(C,crtNodoA->elem);
                crtNodoA=crtNodoA->sig;
            }
        }
    }
    if (crtNodoA==NULL && crtNodoB!=NULL){
        while(crtNodoB!=NULL){
            Insertar(C,crtNodoB->elem);
            crtNodoB=crtNodoB->sig;
        }
    }
    if (crtNodoA!=NULL && crtNodoB==NULL){
        while(crtNodoA!=NULL){
            Insertar(C,crtNodoA->elem);
            crtNodoA=crtNodoA->sig;
        }
    }

}

void Diferencia(TConjunto A,TConjunto B,TConjunto *C){
    TNodo *crtNodoA=A.inicio;
    TNodo *crtNodoB=B.inicio;

    while(crtNodoA!=NULL && crtNodoB!=NULL){
        if (crtNodoA->elem==crtNodoB->elem){
            crtNodoA=crtNodoA->sig;
            crtNodoB=crtNodoB->sig;
        }
        else{
            if (crtNodoA->elem>crtNodoB->elem){
                crtNodoB=crtNodoB->sig;
            }
            else{
                Insertar(C,crtNodoA->elem);
                crtNodoA=crtNodoA->sig;
            }
        }
    }
    if (crtNodoB==NULL){
        while(crtNodoA!=NULL){
            Insertar(C,crtNodoA->elem);
            crtNodoA=crtNodoA->sig;
        }
    }

}

int Min(TConjunto A){
    TNodo *crtNodo=A.inicio;
    int min;
    while(crtNodo!=NULL){
        if (crtNodo==A.inicio){
            min=crtNodo->elem;
        }
        else{
            if (crtNodo->elem<min)
                min=crtNodo->elem;
        }
        crtNodo=crtNodo->sig;
    }
    return min;
}

int Max(TConjunto A){
    TNodo *crtNodo=A.inicio;
    int max;
    while(crtNodo!=NULL){
        if (crtNodo==A.inicio){
            max=crtNodo->elem;
        }
        else{
            if (crtNodo->elem>max)
                max=crtNodo->elem;
        }
        crtNodo=crtNodo->sig;
    }
    return max;

}

int Igual(TConjunto A,TConjunto B){
    TNodo *crtNodoA=A.inicio;
    TNodo *crtNodoB=B.inicio;

    while(crtNodoA!=NULL && crtNodoB!=NULL){
        if (crtNodoA->elem!=crtNodoB->elem)
            return 0;
        crtNodoA=crtNodoA->sig;
        crtNodoB=crtNodoB->sig;
    }
    if (crtNodoA==NULL && crtNodoB==NULL)
        return 1;
    return 0;
}