/*_____________________________________________PILA
La pila (o stack) es una estructura de datos lineal y dinámica, en la cual el elemento
obtenido a través de la operación ELIMINAR está predefinido, debido a que implementa
la política Last-In, First-Out (LIFO), esto es, el último elemento que se agregó es el primer
que se elimina
Para poder diseñar un algoritmo que defina el comportamiento de una pila se deben
considerar 3 casos para ambas operaciones (push y pop):
? Estructura vacía (caso extremo).
? Estructura llena (caso extremo).
? Estructura con elemento(s) (caso base).*/
// Directivas
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
//Creamos una estructura */
struct stackNode{
char data[2]; // Miembros de la estructura
struct stackNode *nextPtr; // Strcut autoreferenciada
};
typedef struct stackNode STACKNODE; // Damos un sobre nombre a la estrcutura
typedef STACKNODE *STACKNODEPTR; // Creamos un sobre nombre con apuntador
// Prototipo de las funciones utilizas
void push(STACKNODEPTR*,char info[2]); // push para poner un elemento
char *pop(STACKNODEPTR *); // pop para extraer un elemento
int isEmpty(STACKNODEPTR); // IsEmpty verifica si la pila esta vacia
void printStack(STACKNODEPTR); // Funcion para imprimir
void instructions(void); // Funcion para imprimir las funciones
// Funcion principal
int main (){
STACKNODEPTR stackPtr = NULL; //stackptr apunta a NULL
int choice;
char value[2];
instructions();
printf(" ?"); //El usuario seleciona la opcion
scanf("%d",&choice);
while(choice != 3) // Entra en un while para evaluar si es 3 u otro numero dentro del rango de las isntrucciones
{
switch (choice) //Selecciona el caso que el usuario requiere
{
//CASO 1
case 1:
printf("Dame un numero para agregarlo a la pila");
scanf("%s",&value); //Gurda el valor que dio el usuario
push(&stackPtr, value); // agrega un elemento a la pila
printStack(stackPtr); // Imprime lo que tiene la pila
break;
//CASO 2
case 2:
if(!isEmpty(stackPtr)) // Evalua si la pila esta vacia
printf("El dato de la cima fue extraido con exito \n", pop(&stackPtr)); //Saca el ultimo valor que ingreso
printStack(stackPtr); // Imprime la pila
break; //Damos por terminado el caso
default:
printf("Dato invalido. \n\n"); //Imprime que es una opcion invalida
instructions(); //Reimpirme el menu
break;
}
printf("?"); //Vuevlve a preguntar
scanf("%d",&choice); //guarda la nueva opcion
}
return 0; //Retorna 0
}
// FUNCION INSTRUCCIONES
void instructions(void) //No devuelve nada
{
printf("Ingresa la opcion marcada \n 1. PUSH: Agregar datos \n 2.POP:Sacar datos\n 3.Salir ");
}
// FUNCION INGRESAR DATOS A LA PILA
void push(STACKNODEPTR *topPtr, char info[2]) //apunta a la cima
{
STACKNODEPTR newPtr; //apunta al siguente elemento
newPtr = malloc(sizeof(STACKNODE)); //Reserva memoria en newptr
if(newPtr!=NULL) //Entra a la funcion siempre y cuando newptr sea diferente de NULL
{
strcpy(newPtr->data,info); // Hace una copía de la informacion que tiene info en data mientras que newPtr esta apuntando a data
newPtr->nextPtr=*topPtr; // newPtr apunta a nexPtr tiene la informacion que guarda el apuntador topPtr
*topPtr=newPtr; //El apuntador topPtr contiene la informacion de newPtr
}
else
printf("%s %s not inserted. No memory available. \n",info[0],info[1]); // Imprime mensaje en caso de que no haya memoria
}
// FUNCION SACAR DATOS DE LA PILA
char *pop(STACKNODEPTR *topPtr)
{
STACKNODEPTR tempPtr; // Define una variable de tipo apuntador y estructura
char *popValue; // Defiene un apuntador tipo char
tempPtr= *topPtr; // tempPtr contiene el contenido del apuntador topPtr
popValue=(*topPtr)->data; //Saca el valor ultimo valor que ingresa el usuario que esta almacenado en topPtr el cual apunta a data
*topPtr=(*topPtr)->nextPtr; // El apuntador topPtr contiene la info que tiene topPtr el cual apunta a nexPtr
free(tempPtr); // limpia al apuntador temPtr
return popValue;
}
// FUNCION IMPRIME PILA
void printStack(STACKNODEPTR currentPtr)
{
if(currentPtr==NULL) //Entra a una condicional
printf("La pila esta vacia. \n\n"); // Imprime si la pila esta basia
else{
printf("La pila es: \n"); // Imprime si la pila
while(currentPtr!=NULL){ //Saca los valores de la pila
printf("%s --> ",currentPtr->data); //Imprime la pila
currentPtr=currentPtr->nextPtr; // CurrentPtr va tomando el valor de nextPtr
}
printf("NULL\n\n");
}
}
//FUNCION PARA VERIFICAR SI ESTA VACIA LA PILA
int isEmpty(STACKNODEPTR currentPtr)
{
return currentPtr == NULL;
}
Comentarios
Publicar un comentario