UNIVERSIDAD TECNOLÓGICA DE SANTIAGO SISTEMA

CORPORATIVO UTESA
“Universidad del Conocimiento para toda la Vida”
UTESA VIRTUAL INF 214-03
ESTRUCTURA DE DATOS
PROFESOR: TORIBIO RODRIGUEZ
PEDRO MAIRONI TORIBIO 2-17-1983
PILAS
Una pila es un tipo especial de lista abierta en la que sólo se pueden insertar y eliminar
nodos en uno de los extremos de la lista. Estas operaciones se conocen como "push" y
"pop", respectivamente "empujar" y "tirar". Además, las escrituras de datos siempre
son inserciones de nodos, y las lecturas siempre eliminan el nodo leído.
Estas características implican un comportamiento de lista LIFO (Last In First Out), el
último en entrar es el primero en salir. El símil del que deriva el nombre de la
estructura es una pila de platos. Sólo es posible añadir platos en la parte superior de la
pila, y sólo pueden tomarse del mismo extremo.
Es evidente, que una pila es una lista abierta. Así que sigue siendo muy importante que
nuestro programa nunca pierda el valor del puntero al primer elemento, igual que pasa con las
listas abiertas. Teniendo en cuenta que las inserciones y borrados en una pila se hacen siempre
en un extremo, lo que consideramos como el primer elemento de la lista es en realidad el
último elemento de la pila.

Por analogía con objetos cotidianos, una operación apilar equivaldría a colocar un plato
sobre una pila de platos, y una operación retirar a retirarlo.

Las pilas suelen emplearse en los siguientes contextos:

• Evaluación de expresiones en notación postfija (notación polaca inversa).

• Reconocedores sintácticos de lenguajes independientes del contexto

• Implementación de recursividad.

Una pila cuenta con 2 operaciones imprescindibles: apilar y desapilar, a las que en las
implementaciones modernas de las pilas se suelen añadir más de uso habitual.

 Crear: se crea la pila vacía. (constructor)

 Tamaño: regresa el numero de elementos de la pila. (size)

 Apilar: se añade un elemento a la pila.(push)

 Desapilar: se elimina el elemento frontal de la pila.(pop)

 Cima: devuelve el elemento que esta en la cima de la pila. (top o peek)

 Vacía: devuelve cierto si la pila está vacía o falso en caso contrario (empty).

Arquitectura básica de una pila

Una pila típica es un área de la memoria de los computadores con un origen fijo y un tamaño
variable. Al principio, el tamaño de la pila es cero. Un puntero de pila, por lo general en forma
de un registro de hardware, apunta a la más reciente localización en la pila; cuando la pila
tiene un tamaño de cero, el puntero de pila de puntos en el origen de la pila.

Las dos operaciones aplicables a todas las pilas son:

• Una operación apilar, en el que un elemento de datos se coloca en el lugar apuntado

por el puntero de pila, y la dirección en el puntero de pila se ajusta por el tamaño de los datos
de partida.
• Una operación desapilar, un elemento de datos en la ubicación actual apuntado por
el puntero de pila es eliminado, y el puntero de pila se ajusta por el tamaño de los datos de
partida
 Algoritmo de la función "push":
Creamos un nodo para el valor que colocaremos en la pila.

Hacemos que nodo->siguiente apunte a Pila.

Hacemos que Pila apunte a nodo.

void Push(Pila *pila, int v)

pNodo nuevo;

/* Crear un nodo nuevo */

nuevo = (pNodo)malloc(sizeof(tipoNodo));

nuevo->valor = v;

/* Añadimos la pila a continuación del nuevo nodo */

nuevo->siguiente = *pila;

/* Ahora, el comienzo de nuestra pila es en nuevo nodo */

*pila = nuevo;

}
 Algoritmo de la función "pop":
Hacemos que nodo apunte al primer elemento de la pila, es decir a Pila.

Asignamos a Pila la dirección del segundo nodo de la pila: Pila->siguiente.

Guardamos el contenido del nodo para devolverlo como retorno, recuerda que la operación
pop equivale

a leer y borrar.

Liberamos la memoria asignada al primer nodo, el que queremos eliminar.

int Pop(Pila *pila)

pNodo nodo; /* variable auxiliar para manipular nodo */

int v; /* variable auxiliar para retorno */

/* Nodo apunta al primer elemento de la pila */

nodo = *pila;

if(!nodo)

return 0; /* Si no hay nodos en la pila retornamos 0 */

/* Asignamos a pila toda la pila menos el primer elemento */

*pila = nodo->siguiente;

/* Guardamos el valor de retorno */

v = nodo->valor;

/* Borrar el nodo */

26

ESTRUCTURAS DINÁMICAS DE DATOS EN LENGUAJE C

free(nodo);

return v;

}
 Algoritmo | Implementacion de Pilas(Ejemplo):

#include <stdio.h>

#include <stdlib.h>

#include <conio.h>

#include <iostream>

#include <string.h>

using namespace std;

struct Nodo {

string letra;

Nodo *siguiente;

};

void SacarPila(Nodo *&, string &);

void InsertarPila(Nodo *&, string );

Nodo* pila = NULL;

int main(){

string palind;

string palind2;

string letra;

string saca;

int opcion2;

char opcion;
do

system("cls");

printf("\t\t\t---MENU---");

printf("\n 1- Insertar palabra a evaluar");

printf("\n 2- Evaluar palabra");

printf("\n 3- Salir \n");

printf("\n Opcion -> ");

scanf("%d", &opcion2);

switch (opcion2)

case 1: system("cls");

do{

cout << "Ingrese una letra de la palabra \n";

cin >> letra;

InsertarPila(pila, letra);

palind += letra;

cout << "\n Ha terminado s- Si, n- No \n";

cin >> opcion;

}while(opcion == 'N' || opcion == 'n');

printf("\n\n Pulse cualquier tecla para continuar");

getch();

break;

case 2: system("cls");
 while(pila != NULL){

SacarPila(pila, saca);

palind2 += saca;

if(palind == palind2){

printf("\n La palabra es palindroma");

}else{

printf("\n La palabra no es palindroma");

printf("\n Pulse cualquier tecla para continuar");

getch();

break;

case 3: system("cls");

printf("\n\n Pulse cualquier tecla para salir");

getch();

break;

default: system("cls");

printf ("\n Opcion no valida");

printf("\n Pulse cualquier tecla para volver al menu");

getch();

}while(opcion2 != 3);

return 0;

}
void InsertarPila(Nodo *&pila, string letra){

Nodo* nuevo = new Nodo();

nuevo->letra = letra;

nuevo->siguiente = pila;

pila = nuevo;

void SacarPila(Nodo *&pila, string &letra){

Nodo* aux = pila;

letra = aux->letra;

pila = aux->siguiente;

free(aux);