pila.h

#ifndef PILACICULAR_PILA_H
#define PILACICULAR_PILA_H

typedef int t_dato;

typedef struct s_nodo{
    t_dato dato;
    struct s_nodo * psig;
}t_nodo;

typedef t_nodo * t_pila;

void crear_pila_circular(t_pila * pp);
int poner_en_pila_circular(t_pila * pp, const t_dato * pd);
int sacar_en_pila_circular(t_pila * pp, t_dato * pd);
void vaciar_pila_circular(t_pila * pp);
void ver_tope_pila_circular(const t_pila * pp,t_dato * pd);
int pila_llena(const t_pila * pp);
int pila_vacia(const t_pila * pp);




#endif //PILACICULAR_PILA_H

pila.c

#include "pila.h";
#include <stdlib.h>

void crear_pila_circular(t_pila * pp){
    *pp = NULL;
}
int poner_en_pila_circular(t_pila * pp, const t_dato * pd){
    t_nodo * pnue = (t_nodo *)malloc(sizeof(t_nodo));
    if(!pnue) return 0;
    pnue->dato = *pd;
    if(*pp){
        pnue->psig = (*pp)->psig;
        (*pp)->psig = pnue;
    }else{
        (*pp)->psig = pnue;
        *pp = pnue;
    }
    return 1;
}
int sacar_en_pila_circular(t_pila * pp, t_dato * pd){
    t_nodo * pelim;
    if(!*pp) return 0;
    pelim = (*pp)->psig;
    *pd = pelim->dato;
    (*pp)->psig = pelim->psig;
    if(pelim->psig == *pp)
        *pp = NULL;
    free(pelim);
    return 1;
}
void vaciar_pila_circular(t_pila * pp){
    t_nodo * pelim;
    while(*pp){
        pelim = (*pp)->psig;
        (*pp)->psig = pelim->psig;
        if(pelim->psig == *pp)
            *pp = NULL;
        free(pelim);
    }
}

void ver_tope_pila_circular(const t_pila * pp,t_dato * pd){
    *pd = (*pp)->psig->dato;
}

int pila_llena(const t_pila * pp){
    t_nodo * pnue = (t_nodo *) malloc(sizeof(t_nodo));
    free(pnue);
    return pnue == NULL;
}

int pila_vacia(const t_pila * pp){
    return *pp == NULL;
}


cola.h

#ifndef PILACICULAR_COLA_H
#define PILACICULAR_COLA_H

typedef int t_dato;

typedef struct s_nodo{
    t_dato dato;
    struct s_nodo * psig;
}t_nodo;

typedef t_nodo * t_cola;

void crear_cola_circular(t_cola * pp);
int poner_en_cola_circular(t_cola * pp, const t_dato * cd);
int sacar_en_cola_circular(t_cola * pp, t_dato * cd);
void vaciar_cola_circular(t_cola * pp);
void ver_frente_cola_circular(const t_cola * pc,t_dato * cd);
void ver_fondo_cola_circular(const t_cola * pc,t_dato * cd);
int cola_llena(const t_cola * pc);
int cola_vacia(const t_cola * pc);


#endif //PILACICULAR_COLA_H

cola.c

#include "cola.h"
#include <stdlib.h>

void crear_cola_circular(t_cola * pc){
    *pc = NULL;
}
int poner_en_cola_circular(t_cola * pc, const t_dato * cd){
    t_nodo * pnue = (t_nodo *)malloc(sizeof(t_nodo));
    if(!pnue) return 0;
    pnue->dato = *cd;
    if(*pc){
        pnue->psig = (*pc)->psig;
        (*pc)->psig = pnue;
    }else{
       *pc = pnue;
       pnue->psig = pnue;
    }
    *pc = pnue;
    return 1;
}
int sacar_en_cola_circular(t_cola * pc, t_dato * cd){
    t_nodo * pelim;
    if(!*pc) return 0;
    pelim = (*pc)->psig;
    *cd = pelim->dato;
    if((*pc)->psig == *pc )
        *pc = NULL;
    else
        (*pc)->psig = pelim->psig;
    free(pelim);
    return 1;
}

void vaciar_cola_circular(t_cola * pc){
    t_nodo * pelim;
    while(*pc){
        pelim = (*pc)->psig;
        if((*pc)->psig == *pc )
            *pc = NULL;
        else
            (*pc)->psig = pelim->psig;
        free(pelim);
    }

}

void ver_frente_cola_circular(const t_cola * pc,t_dato * cd){
    *cd = (*pc)->psig->dato;
}

void ver_fondo_cola_circular(const t_cola * pc,t_dato * cd){
    *cd = (*pc)->dato;
}

int cola_llena(const t_cola * pc){
    t_nodo * pnue = (t_nodo *)malloc(sizeof(t_nodo));
    free(pnue);
    return pnue == NULL;
}
int cola_vacia(const t_cola * pc){
    return *pc == NULL;
}

lista.h

#ifndef LISTADOBLE_LISTA_H
#define LISTADOBLE_LISTA_H

typedef int t_dato;

typedef struct s_nodo{
    t_dato dato;
    struct s_nodo *sig,*ant;
}t_nodo;

typedef t_nodo * t_lista;

void crear_lista_doble(t_lista * pl);
int insertar_lista_doble(t_lista *pl,const t_dato * ld,int(*cmp)(const  t_dato *,const t_dato * ));
int eliminar_lista_doble(t_lista *pl, t_dato * ld,int(*cmp)(const  t_dato * ,const t_dato *));
void vaciar_lista_doble(t_lista * pl);


#endif //LISTADOBLE_LISTA_H

lista.c

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

void crear_lista_doble(t_lista * pl){
    *pl = NULL;
}

int insertar_lista_doble(t_lista *pl,const t_dato * ld,int(*cmp)(const  t_dato *,const t_dato *)){
    t_nodo * pnue = (t_nodo *) malloc(sizeof(t_nodo));
    t_nodo *sig,*ant = NULL;
    int comp;
    if(!pnue) return 0;
    sig = *pl;
    if(sig) ant = sig->ant;
    while(ant && (comp=cmp(&ant->dato,ld)) > 0){
        sig = ant;
        ant = ant->ant;
    }
    if(ant && !comp) return 0;

    while(sig && (comp=cmp(&sig->dato,ld)) < 0){
        ant = sig;
        sig = sig->sig;
    }

    if(sig && !comp) return 0;

    pnue->dato = *ld;
    pnue->ant = ant;
    pnue->sig = sig;
    if(ant)
        ant->sig = pnue;
    if(sig)
        sig->ant = pnue;
    *pl = pnue;

    return 1;

}
int eliminar_lista_doble(t_lista *pl, t_dato * ld,int(*cmp)(const  t_dato *,const t_dato *)){
    t_nodo * pelim;
    int comp;
    if(!*pl) return 0;
    pelim = *pl;
    while(pelim && (comp=cmp(&pelim->dato,ld)) > 0){
        pelim = pelim->ant;
    }

    while(pelim && (comp=cmp(&pelim->dato,ld)) < 0){
        pelim = pelim->sig;
    }

    if(!pelim || comp) return 0;
    if(pelim->ant)
        pelim->ant->sig = pelim->sig;
    if(pelim->sig)
        pelim->sig->ant = pelim->ant;
    if(*pl == pelim)
        *pl = pelim->sig ?: pelim->ant;
    free(pelim);
    return 1;

}
void vaciar_lista_doble(t_lista * pl){
    t_nodo * pelim;
    while(*pl){
        pelim = *pl;
        if(pelim->ant)
            pelim->ant->sig = pelim->sig;
        if(pelim->sig)
            pelim->sig->ant = pelim->ant;
        *pl = pelim->sig ?: pelim->ant;
        free(pelim);
    }

}