Conjunto_Pilas_TAD

#include <stdio.h>
#include <stdlib.h>
typedef int TElemento;

typedef struct nodo {
        TElemento info;
        struct nodo *sig;
} TNodo;

typedef struct pila{
        TNodo *top;
        int tamano;
} TPila;

typedef struct pilas{
    TPila * Pilinicio;
    struct pilas*pilassig;
}TPilas;

typedef struct{
    TPilas *Pilacima;
}TConjuntoPilas;

void Pila_crear(TPila**);
void Pila_push(TPila**, TElemento);
void Pila_pop(TPila**);
int Pila_estaVacia(TPila *);
void Pila_finalizar(TPila *);
void Pila_super_crear(TConjuntoPilas**);
void Pila_super_push(TConjuntoPilas**,int,int);
void Pila_super_pop(TConjuntoPilas**);
void Pila_crear(TPila **P){
    TPila*P1=*P;
    P1->top = NULL;
    P1->tamano=0;
    *P=P1;
}
void Pila_push(TPila **P, TElemento nuevoElem){
    TNodo *ptr_nuevoElem;
    TPila*P1=*P;
    ptr_nuevoElem = (TNodo*)malloc(sizeof(TNodo));

    if (ptr_nuevoElem){
        ptr_nuevoElem->info = nuevoElem;
        ptr_nuevoElem->sig = P1->top;
        P1->top = ptr_nuevoElem;
        (P1->tamano)++;
        *P=P1;
    }
}

void Pila_pop(TPila **P){
    TElemento top_info; TNodo *ptr_top;TPila*P1=*P;
    if (!Pila_estaVacia(P1)){
        ptr_top = P1->top;
        top_info = ptr_top->info;
        P1->top = P1->top->sig;
        free(ptr_top);
        (P1->tamano)--;
        *P=P1;
    }
}

int Pila_estaVacia(TPila *P){
    return (P->top == NULL);
}

void Pila_finalizar(TPila *P){
    while (!Pila_estaVacia(P))
        Pila_pop(&P);
}
void Pila_super_crear(TConjuntoPilas**P){
     TConjuntoPilas*P1=*P;
    P1->Pilacima=NULL;
    *P=P1;
}
void Pila_super_push(TConjuntoPilas**P,int e,int max){
    TPila *P1;TPilas*Pilas;
    P1=(TPila*)malloc(sizeof(TPila));
    TConjuntoPilas *Pt1=*P;//pt1 es un conjunto de pilas auxiliar
    TPilas*Pilasaux =Pt1->Pilacima;
    if (Pt1->Pilacima==NULL){
        Pila_crear(&P1);//creo pila
        Pila_push(&P1,e);//Agrego elemento a la pila
        Pilas=(TPilas*)malloc(sizeof(TPilas));//reservo
        Pilas->Pilinicio=P1;//inicializo pila inical
        Pilas->pilassig=NULL;//no hay mas pilas
        Pt1->Pilacima=Pilas;//guardo puntero

    }else{
        if(Pt1->Pilacima->Pilinicio->tamano+1<=max){
            P1=Pilasaux->Pilinicio;//Busco en la pila actual
            Pila_push(&P1,e);
            Pilasaux->Pilinicio=P1;
            Pt1->Pilacima=Pilasaux;
        }else{//si ya se sobrepaso la capacidad
            Pila_crear(&P1);//creo nueva pila
            Pila_push(&P1,e);//Agrego elemento a la pila
            TPilas* aux=(TPilas*)malloc(sizeof(TPilas));//reservo
            aux->Pilinicio=P1;
            aux->pilassig=Pilasaux;
            Pt1->Pilacima=aux;

        }
    }
    *P=Pt1;
}
void Pila_super_pop(TConjuntoPilas**P){
    TConjuntoPilas *Pt1=*P;//pt1 es un conjunto de pilas auxiliar
    if (Pt1->Pilacima==NULL){
        printf("No hay nada que desapilar ,baka!\n");
    }else{//si la pila de la cima no es vacia
        TPilas*Pilasaux =Pt1->Pilacima;
        TPila *P1=Pilasaux->Pilinicio;//saco la pila de inicio
        Pila_pop(&P1);//desapilo
        //verifico que el tamaño de la pila no sea 0
        if(P1->tamano!=0){
            Pilasaux->Pilinicio=P1;//apunto a la pila que se desapilo
            Pt1->Pilacima=Pilasaux;//sigue siendo la misma pila
        }else{//la pila termino estando vacia
            Pila_finalizar(P1);//Eliminamos pila vacia
            Pilasaux=Pilasaux->pilassig;//pasamos a la siguiente pila
            Pt1->Pilacima=Pilasaux;//la siguiente pila es ahora la cima
        }
    }
}
int main(){
    int max;
    TConjuntoPilas *P;
    P=(TConjuntoPilas*)malloc(sizeof(TConjuntoPilas));//reservo
    Pila_super_crear(&P);
    printf("Ingrese el maximo de elementos que quiere que tenga su pila\n");
    scanf("%d",&max);
    Pila_super_push(&P,1,max);
    Pila_super_push(&P,2,max);
    Pila_super_push(&P,3,max);
    Pila_super_push(&P,4,max);
    Pila_super_push(&P,5,max);
    Pila_super_push(&P,6,max);
    Pila_super_push(&P,7,max);
    Pila_super_push(&P,8,max);
    Pila_super_push(&P,9,max);
    Pila_super_push(&P,10,max);
    Pila_super_pop(&P);
    Pila_super_pop(&P);
    Pila_super_pop(&P);
    return 0;
}