Programación III. Guía 5.

1
1
Facultad: Ingeniería
Escuela: Computación
Asignatura: Programación III

Tema: “PILAS”.

Objetivos Específicos
• Diseñar una clase pila que permita verificar su funcionamiento y aplicación.
• Implemente una pila utilizando los objetos de colección de Visual C# .NET.
• Reforzar habilidades en el entorno gráfico de C#

Introducción Teórica

PILA
Una pila (stack) es una lista ordenada de elementos en la que todas las inserciones y
supresiones se realizan por un mismo extremo de la lista. A una pila se le pueden añadir y
retirar nuevos nodos únicamente de su parte superior, la cima de la pila. Por esta razón, se
conoce una pila como una estructura de datos LIFO por last-in, firstout, es decir último en entrar
primero en salir.

Cuando se dice que la pila está ordenada, se quiere decir que hay un elemento al que se puede
acceder primero (el que está encima de la pila), otro elemento al que se puede acceder en
segundo lugar (justo el elemento que está debajo de la cima), un tercero, etc. No se requiere
que las entradas se puedan comparar utilizando el operador “menor que” y pueden ser de
cualquier tipo.

Se referencia una pila mediante un apuntador al elemento superior de la misma. El miembro

de enlace en el último nodo de la pila se define a NULL, para indicar que se trata de la parte
inferior de la pila misma.

Gráficamente una Pila puede representarse de la siguiente manera:

 Programación III. Guía 5. 2
2
Las operaciones típicas de la pila incluyen: Crear pila, verificar si está vacía, sacar un elemento
de la pila, meter un elemento de la pila.

Materiales y Equipo

• Guía de Laboratorio Nº 5.
• Computadora con programa:
o Visual Studio C#
• Dispositivo de Almacenamiento (USB).

Procedimiento

EJERCICIO 1
Cree un proyecto modo consola en Visual C# y agregue el siguiente código dentro de la
clase program.

class nodo
{
public char info;
//sgte es un objeto que simula el puntero
public nodo sgte;
}

class pila
{
public nodo tope;
public pila()
{
tope = null;
}

public void Push(char valor)

{
nodo aux = new nodo();
aux.info = valor;
//si no hay nada en la pila
if (tope == null)
{
//se asigna el aux como el único nodo
tope = aux;
//como solo hay un dato en la pila el puntero se dirige a null
aux.sgte = null;
}
else
 Programación III. Guía 5. 3
3
{
//si la pila no está vacía el dato se inserta arriba de la pila
//es decir en el tope
aux.sgte = tope;
tope = aux;
}
}
public void mostrar()
{
nodo puntero;
puntero = tope;
Console.WriteLine("{0}", puntero.info);
//se recorre el puntero del tope a el fondo
while (puntero.sgte != null)
{
puntero = puntero.sgte;
Console.WriteLine("{0}", puntero.info);
}
}

public char Pop()

{
char valor = ' ';
if (tope == null)
Console.WriteLine("Lista vacia");
else
{
//se elimina el último en entrar y se retorna el valor que se
elimina
valor = tope.info;
tope = tope.sgte;
}
return valor;
}
}

static void Main(string[] args)

{
string cadena, rpta;
char caracter;
pila mipila = new pila();
pila pilafrase = new pila();

//PARTE 1 //SE INGRESAN CARACTERES DE MANERA INDIVIDUAL A LA PILA

Y LUEGO SE
MUESTRAN
 Programación III. Guía 5. 4
4
Console.WriteLine("\t\t---PARTE I---");
//ingresamos elementos a la pila
mipila.Push('p');
mipila.Push('b');
mipila.Push('z');
mipila.Push('s');
//mostramos el contenido de la pila
mipila.mostrar();
Console.ReadLine();
//sacamos un elemento de la pila
mipila.Pop();
mipila.mostrar();
Console.ReadLine();

//PARTE 2
//SE INGRESA UNA CADENA Y SE INGRESAN TODOS LOS
//CARACTERES DE DICHA CADENA
Console.WriteLine("\t\t---PARTE II---");
Console.Write("Ingrese la palabra: ");
cadena = Console.ReadLine();

for (int i = 0; i < cadena.Length; i++)

{
//extrae una caracter de la cadena y lo convierte en char
caracter = char.Parse(cadena.Substring(i, 1));
pilafrase.Push(caracter);
} //imprimir el contenido de la pila
pilafrase.mostrar();
Console.ReadLine();
}

EJERCICIO 2.
En este ejercicio se utilizaran funciones de pilas ya creadas en Visual C# pero se utilizan objetos
por lo que habrá que hacer las conversiones necesarias.

- Cree un nuevo proyecto en Visual C# en modo consola.

- Agregue al inicio el nombre de espacio Collections de la siguiente manera: using
System.Collections;

• Dentro del método static void Main(string[] args) ingrese el siguiente código:

Stack miPila = new Stack();

int opcion;//opcion del menu

 Programación III. Guía 5. 5
5

do{
Console.Clear();//se limpia consola

opcion = menu();//muestra menu y espera opción

switch (opcion)
{
case 1:
agregar(ref miPila);
break;
case 2:
eliminar(ref miPila);
break;
case 3:
limpiar( ref miPila);
break;
case 4:
imprimir(miPila);
break;
case 5: break; //salir
default:
mensaje("ERROR: la opción no es valida. Intente de nuevo.");
break;
}

}
while(opcion!=5);

mensaje("El programa ha finalizado.");

}

/** añade un nuevo elemento a la pila */

static void agregar( ref Stack pila )
{
Console.Write("\n>Ingrese valor: ");
try
{
int valor = Convert.ToInt32(Console.ReadLine());
if (valor > 99 || valor <= 0)
{
mensaje("Solo números del 1 al 99");
}
else
{
pila.Push(valor);
imprimir(pila);
}
}
catch {
mensaje("Error: Solo números del 1 al 99");
}

/** Elimina todo los elementos de la pila */

static void limpiar( ref Stack pila )
{
 Programación III. Guía 5. 6
6
pila.Clear();
imprimir(pila);
}

/** Elimina elemento de la pila */

static void eliminar( ref Stack pila)
{
if (pila.Count > 0)
{
int valor = (int)pila.Pop();
mensaje("Elemento " + valor + " eliminado");
}
else {
imprimir(pila);
}

/** muestra menu y retorna opción */

static int menu()
{
//Console.Clear();
Console.WriteLine("\n Stack Menu\n");
Console.WriteLine(" 1.- Agregar elemento");
Console.WriteLine(" 2.- Eliminar elemento");
Console.WriteLine(" 3.- Vaciar Pila");
Console.WriteLine(" 4.- Ver pila");
Console.WriteLine(" 5.- Termina programa");
Console.Write(" > Ingresa tu opción: ");
try
{
int valor = Convert.ToInt32( Console.ReadLine() );
return valor;
}
catch {
return 0;
}
}

/** Muestra mensaje del programa al usuario */

static void mensaje( String texto )
{
if (texto.Length > 0)
{
Console.WriteLine("\n ===============================================");
Console.WriteLine(" > {0}",texto);
Console.WriteLine(" =================================================");
Console.WriteLine("\n >Presione cualquier tecla para continuar...");
Console.ReadKey();
}
}

/** Imprime pila */

static void imprimir(Stack pila)
{
if (pila.Count > 0)
{
Console.WriteLine("");
 Programación III. Guía 5. 7
7
foreach (int dato in pila)
{
Console.WriteLine(" | |");
if( dato <10)
Console.WriteLine(" | 0{0} |", dato);
else
Console.WriteLine(" | {0} |", dato);
Console.WriteLine(" |______|");
}
Console.WriteLine("\nPresione cualquier tecla para continuar...");
Console.ReadKey();
}
else
{
mensaje("La Pila esta vacia");

EJERCICIO 3.
En este ejercicio se verá una representación gráfica de cómo funcionan las pilas, sin embargo
realmente no se llegan a implementar propiamente las pilas, pues cada nodo (representado
por los textbox) es independiente de los otros. La idea principal de las pilas es que pueda
conocerse qué nodo está después del nuestro para poder realizar sus recorridos.

Abra un proyecto de Windows Form y cree una pantalla similar a la de la imagen

Elementos
2 botones ---agregar y eliminar
6 textbox --- 5 para simular los nodos y
1 para contabilizar elementos
1 label – para indicar mensaje de total
elementos

Consideraciones
a. El form debe llamarse Pila para que su constructor pueda ser nombrado de la misma
forma
 Programación III. Guía 5. 8
8
b. No olvidar cambiar propiedad de nombre a los textbox y a los button acordes a lo que se
requiera (en este caso se ha usado txt1, txt2, txt3, txt4,txt5,txt6 y btnagragrar,
btneliminar)
c. En la propiedad de Visible de los textbox se ha establecido en FALSE para que no
aparezcan a inicio de la simulación
d. Los valores de texto establecidos al inicio son de 0 para los seis textbox
e. Modifique los colores de la forma en que le parezca más conveniente.
f. Debe respetar el orden de los textbox de forma que el txt2 quedé hasta la parte inferior
de la pantalla, el txt2 sobre este, txt3 sobre txt 2 y así sucesivamente. Se ha dejado una
distancia de 50 entre cada textbox en eje y y la misma posición en el eje x.

Dentro del código digite lo siguiente: (no olvide dar doble click a los botones para activar sus
eventos)

En la clase pila digite lo siguiente:

int total = 0; //lleva conteo de elementos en pila

Random numero = new Random(); //es para asignar números aleatorios que serán
mostrados en los "nodos"

En el botón agregar haremos lo siguiente:

private void btnagregar_Click(object sender, EventArgs e)
{
if (total == 5) //esto es porque solo tenemos 5 textbox en simulación
{ MessageBox.Show("La pila está llena");
}
else
{
total++; //incrementa el conteo de elementos
txt6.Text = Convert.ToString(total);

if (total == 1) // si hay un elemento

{
txt1.Text = Convert.ToString(numero.Next(1, 99)); //que convierta en
texto el número random dado
txt1.Visible = true; //hacemos que el textbox sea visible
}
if (total == 2) //si hay dos elementos
{
txt2.Text = Convert.ToString(numero.Next(1, 99)); //que convierta en
texto el número random dado
txt2.Visible = true;
}
if (total == 3) //si hay tres elementos
{
txt3.Text = Convert.ToString(numero.Next(1, 99)); //que convierta en
texto el número random dado
txt3.Visible = true;
}
if (total == 4) //si hay cuatro elementos
{
txt4.Text = Convert.ToString(numero.Next(1, 99));//que convierta en
texto el número random dado
 Programación III. Guía 5. 9
9
txt4.Visible = true;
}
if (total == 5) //si hay cinco elementos
{
txt5.Text = Convert.ToString(numero.Next(1, 99));//que convierta en
texto el número random dado
txt5.Visible = true;
}
}
}

Para el botón eliminar se realiza lo siguiente:

private void btneliminar_Click(object sender, EventArgs e)

{
if (total == 0) //no hay ningún elemento agregado
{
MessageBox.Show("No hay elementos para eliminar");
}
else
{
if (total == 1) //si solo hay uno escondemos el txt1
{
txt1.Visible = false; //esconde textbox
}
if (total == 2) //si actualmente hay dos escondemos el txt2
{
txt2.Visible = false;
}
if (total == 3) //si actualmente hay tres escondemos el txt3
{
txt3.Visible = false;
}
if (total == 4) //si actualmente hay cuatro escondemos el txt4
{
txt4.Visible = false;
}
if (total == 5) //si actualmente hay cinco escondemos el txt5
{
txt5.Visible = false;
}

total--; //decrementamos cantidad

txt6.Text = Convert.ToString(total); //mostramos el nuevo total

}
}
 Programación III. Guía 5. 10
10

Análisis de Resultados
Utilizando pilas

• Ejercicio 1. Crear un programa que solicite una expresión matemática y que revise si
los paréntesis están balanceados

Ejemplo: (a+b-2) Paréntesis balanceado

(a+b-2)) Paréntesis desbalanceado

• Ejercicio 2. Crear un programa que lea una palabra e imprima un mensaje indicando si
es palíndromo o no. Una palabra es palíndromo cuando se lee igual hacia adelante que
hacia atrás. Ejemplo: oso, radar, reconocer, rotor, seres, somos, etc.

Investigación complementaria.

Ejercicio 1.
Modifique el ejemplo 3 de forma que trabaje con un timer y cuando agregue un nodo se
desplace desde la parte superior de la pantalla hasta llegar a la posición que le corresponde.

Ejercicio 2.
Investigue de qué forma podría realizarse una representación gráfica que incluya realmente
una pila en la cual sus nodos pueden ir conectados y que cumpla con todo lo necesario para
simular un TAD.

Ejercicio 3.
Un almacén tiene capacidad para apilar n contenedores. Cada contenedor tiene un número
de identificación. Cuando se desea retirar un contenedor específico, deben retirarse primero
los contenedores que están encima de él y colocarlos en otra pila, efectuar el retiro y
regresarlos.

Almacén

5
4
3
 Programación III. Guía 5. 11
11

2
1

Se desea retirar el contenedor 3

Paso 1. Se retiran los contenedores que están encima de él y se colocan en otra pila
Pila 1 pila 2
3 4
2 5
1

Paso 2. Se efectúa el retiro

Pila 1 Pila 2

Pila 1
Paso 3. Regresarlos
Pila 1 pila 2
2 4
5
1