PilaConListaEnlazada

#include <stdio.h>
#include <stdlib.h> // malloc()

// Implementacion Pila infinita con listas enlazadas simples de valores enteros
// Dos opciones:
// 1.- Pop() obtiene el valor y destruye el nodo.
// 2.- Pop() obtiene el valor pero no destruye el nodo, al finalizar destruimos la Pila completa.
// Utilizamos opcion 1.-

typedef struct Nodo{
    int data;
    struct Nodo *sig;
}Nodo;
//Nodo *sp = NULL;  // puntero de pila a cada Nodo

void Push(Nodo **sp,int valor);     // modificamos el puntero de Pila, Apila
int Pop(Nodo **sp);                 // modificamos el puntero de Pila, Desapila
void freeNodoStack(Nodo ***sp);     // Metodo solo utilizable desde Pop() para liberar el nodo
int ShowStack(Nodo *sp);            // no necesitamos modificar el puntero sp, Muestra Pila y retorna el numero de nodos de la Pila
void DestroyStack(Nodo **sp);
int isEmpty(Nodo *sp);
int nNodos(void);
// eraseNodo(Nodo *sp, int valor);
//searchNodo(Nodo *sp, int valor);
//maxNodo(Nodo *sp);
//minNodo(Nodo *sp);
//avergePila(Nodo *sp);
//

static int numNodos;                // variable global que entrega el numero datos en la pila

int main(void){

    Nodo *sp_nodo = NULL;                   //  apunta al actual nodo de la pila, i.e. no hay nada aun

    printf("###########################################\n\n");
    printf("<<<Apilamos algunos valores en la Pila>>>\n\n");
    Push(&sp_nodo,1);                       // apilamos
    Push(&sp_nodo,2);
    Push(&sp_nodo,3);
    Push(&sp_nodo,4);
    Push(&sp_nodo,5);
    Push(&sp_nodo,6);
    Push(&sp_nodo,7);
    Push(&sp_nodo,8);
    Push(&sp_nodo,9);
    Push(&sp_nodo,10);
    Push(&sp_nodo,11);
    printf("###########################################\n\n");

    printf("<<<Mostramos la pila creada>>>\n\n");
    ShowStack(sp_nodo);                     // Mostramos toda la pila
    printf("\n###########################################\n");
    printf("\n<<<Desapilamos algunos valore de la Pila>>>\n\n");
    printf("\t\t|%d|\n",Pop(&sp_nodo));     // Desapilamos
    printf("\t\t|%d|\n",Pop(&sp_nodo));
    printf("\t\t|%d|\n",Pop(&sp_nodo));
    printf("\t\t|%d|\n",Pop(&sp_nodo));
    printf("\t\t|%d|\n",Pop(&sp_nodo));
    printf("\t\t|%d|\n",Pop(&sp_nodo));
    printf("\t\t|%d|\n",Pop(&sp_nodo));
    printf("\n###########################################\n\n");
    //Push(&sp_nodo,55);                    // apilamos un nuevo valor
    //printf("%d\n",Pop(&sp_nodo));
    printf("<<<Mostramos la pila que ha quedado>>>\n\n");
    ShowStack(sp_nodo);                     // Mostramos nueva Pila
    printf("\n###########################################\n");
    printf("Cantidad de nodos de la Pila: %d\n",nNodos());
    printf("<<<Operacion de Destruir Pila>>>\n");
    DestroyStack(&sp_nodo);
    printf("Cantidad de nodos de la Pila: %d\n",nNodos());
    ShowStack(sp_nodo);
    DestroyStack(&sp_nodo);


    printf("\n<<<Fin>>>\n");
    return 0;

}
//+---------------------------------------------------------------------------------+
void Push(Nodo **sp,int valor){

    Nodo * nuevo = (Nodo *)malloc(sizeof(Nodo));
    numNodos++;
    if(*sp==NULL){              // si pila vacia
        *sp =  nuevo;           // *sp es puntero que apunta al nuevo nodo de la pila
        nuevo->data = valor;
        nuevo->sig =NULL;
    }
    else{
        nuevo->sig = *sp;
        *sp = nuevo;
        nuevo->data = valor;
    }
}
//+---------------------------------------------------------------------------------+
int Pop(Nodo **sp){
    int pop = -1;
    Nodo *aux;
    if(*sp == NULL)
        printf("Error: Pila vacia, Pop no se puede ejecutar.-\n");
    else{
        pop = (*sp)->data;      // obtiene dato
        aux = (*sp)->sig;       // puntero a nodo por debajo de tope
        free(*sp);
        //freeNodoStack(&sp);   // liberamos lo apuntado por puntero(*sp) del tope
        *sp = aux;              // puntero de pila apunta al nodo que queda de nuevo tope
        numNodos--;
    }
    return pop;
}
//+---------------------------------------------------------------------------------+
// sp es puntero que apunta a un puntero a puntero (triple puntero)
// *sp es el puntero a puntero  (doble puntero)
// **sp es el puntero
void freeNodoStack(Nodo ***sp){
    if((**sp)!=NULL)
        free(**sp);
    else
        printf("Error: La pila esta vacia, no puede liberar ningun nodo\n");
}
//+---------------------------------------------------------------------------------+
int ShowStack(Nodo *sp){
    int primero = 1;
    int numnodos =0;
    Nodo *sp_aux = sp;
    if(sp_aux!=NULL){
        printf("Tope de Pila--> |");
        while(sp_aux!=NULL){
            if(!primero)
                printf("\t\t|");
            else primero--;
            printf("%d|\n",sp_aux->data);
            sp_aux = sp_aux->sig;
            numnodos++;
        }
    //printf("Base de Pila:\n");
    }
    else printf("Error: Pila vacia, no es posible mostrar la Pila.-\n");

    return numnodos;
    //printf("\n");
}
//+---------------------------------------------------------------------------------+

void DestroyStack(Nodo **sp){

Nodo *sp_aux = NULL;        // copiamos el puntero de pila

    if(!isEmpty(*sp)){
        while(*sp!=NULL){
            sp_aux = (*sp)->sig;
            free(*sp);
            *sp = sp_aux;
        }
    printf("Pila Destruida\n");
    numNodos = 0;
    }
    else
        printf("Error: Para destruir primero debe crear una Pila.-\n");
}
//+----------------------------------------------------------------------------------+
int isEmpty(Nodo *sp){return sp !=NULL?0:1;}
//+----------------------------------------------------------------------------------+
int nNodos(void){return numNodos;}
//+----------------------------------------------------------------------------------+