Estructura de Datos y Algoritmos LAB-131 Gestión II-2022 Aux.

Sergio Ramirez Castro

Universidad Mayor de San Andrés

Facultad de Ciencias Puras y Naturales
Carrera de Informática

ESTRUCTURA DE DATOS Y ALGORITMOS

LAB-131
Gestión II-2022
PILAS - COLAS
PILA
Definición:
Una pila (Stack en inglés) es una lista ordinal o estructura de datos en la que el modo
de acceso a sus elementos es de tipo LIFO (del inglés Last In First Out, último en
entrar, primero en salir) que permite almacenar y recuperar datos
Elementos:

max Define la capacidad máxima del vector.

tope Denota el extremo por donde se opera la pila.
v[] Vector donde se almacena los elementos de la pila.
Código Java

import java.util.Scanner;
public class Pila {
private int tope, max;
Object[] v = new Object[100];
Pila(int ca) {
max = ca;
tope = 0;
}
Estructura de Datos y Algoritmos LAB-131 Gestión II-2022 Aux. Sergio Ramirez Castro

boolean esLlena() {
if (tope == max)
return true;
else
return false;
}

boolean esVacia () {
if (tope == 0)
return true;
else
return false;
}

int nElem() {
return tope;
}

void adicionar(Object item) {

if (!esLlena()) {
tope++;
v[tope] = item;
} else
System.out.println("Pila llena");
}

Object eliminar() {
Object item = null;
if (esVacia ())
System.out.println("Pila vacia");
else {
item = v[tope];
tope--;
}
return item;
}

void vaciar(Pila B) {
while (!B. esVacia ())
adicionar(B.eliminar());
}
Estructura de Datos y Algoritmos LAB-131 Gestión II-2022 Aux. Sergio Ramirez Castro

void mostrar() {
Object item;
Pila aux = new Pila(max);
while (!esVacia())
aux.adicionar(eliminar());
while (!aux.esVacia()) {
item = aux.eliminar();
System.out.println(item);
adicionar(item);
}
}

void llenar(int n) {
int i;
Scanner lee = new Scanner(System.in);
for (i = 1; i <= n; i++) {
Object dato = lee.nextInt();
adicionar(dato);
}
}
}
Implementación:

public class principal {

public static void main(String[] args) {
Pila p = new Pila(30);
p.adicionar(1);
p.adicionar(2);
p.adicionar(3);
p.adicionar(4);

System.out.println("Pila:");
p.mostrar();
}
}
Estructura de Datos y Algoritmos LAB-131 Gestión II-2022 Aux. Sergio Ramirez Castro

Ejercicio 1:
Sea una pila de números se pide mostrar a los números pares
Desarrollo lógico:
Se crea la Pila, se adicionan 7 números y se procede a ejecutar el método
“mostrarPares” donde creamos una Pila auxiliar (aux), sacamos uno a uno los
elementos de la Pila original (p) consultando si son números pares o no y
guardando la información en la Pila auxiliar para al final realizar el vaciado
correspondiente.

public class principal {

public static void main(String[] args) {
Pila p = new Pila(30);
p.adicionar(1);
p.adicionar(2);
p.adicionar(3);
p.adicionar(4);
p.adicionar(5);
p.adicionar(6);
p.adicionar(7);

System.out.println("Pila:");
p.mostrar();
System.out.println("\nPares:");
mostrarPares(p);
}

public static void mostrarPares(Pila p) {

Object elem;
Pila aux = new Pila(30);
while (!p.esVacia()) {
elem = p.eliminar();
aux.adicionar(elem);
if ((int) elem % 2 == 0)
System.out.println(elem);
}
p.vaciar(aux);
}
}
Estructura de Datos y Algoritmos LAB-131 Gestión II-2022 Aux. Sergio Ramirez Castro

Ejercicio 2:
Sea una pila de números se pide mostrar cuantas veces se repite el número x

import java.util.Scanner;

public class principal {

public static void main(String[] args) { Desarrollo lógico:
Pila p = new Pila(30);
p.adicionar(1); En el método
p.adicionar(4); “buscarX” recorremos
p.adicionar(4); la pila de números
p.adicionar(6); buscando los valores
p.adicionar(2); que coincidan con “x”,
p.adicionar(3); si los encontramos
p.adicionar(4);
aumentamos el valor
System.out.println("Pila:"); del contador.
p.mostrar();
System.out.println("\nIntro x:");
Scanner lee = new Scanner(System.in);
Object x = lee.nextInt();
System.out.print("Se repite: ");
System.out.println(buscarX(p,x)+" veces");
}

public static int buscarX(Pila p, Object x) {

Object elem;
Pila aux = new Pila(30);
int cont = 0;
while (!p.esVacia()) {
elem = p.eliminar();
aux.adicionar(elem);
if (elem == x)
cont++;
}
p.vaciar(aux);
return cont;
}
}
Estructura de Datos y Algoritmos LAB-131 Gestión II-2022 Aux. Sergio Ramirez Castro

Ejercicio 3:
Dada una pila de números enteros positivos se pide eliminar al número mayor si
este es par (puede haber repetidos)

public static void main(String[] args) { Desarrollo lógico (main):

Pila p = new Pila(30);
p.adicionar(4); Para el ejercicio
p.adicionar(5); adicionaremos 8 números
p.adicionar(9); a la pila original, el
p.adicionar(2); método “buscar” nos
p.adicionar(14); regresara el mayor
p.adicionar(14); número en la Pila y si este
p.adicionar(13); es un número par
p.adicionar(11); llamamos al método
System.out.println("Pila:");
“eliminar Mayor” y
p.mostrar();
int mayor = buscarMayor(p); mostramos el resultado
System.out.println("\nEl mayor es: "+mayor);
System.out.println("Solucion:");
if (mayor % 2 == 0) {
eliminarMayor(p, mayor);
p.mostrar();
}
else
System.out.println("El numero mayor es impar");
}
Desarrollo lógico (buscar):
public static int buscar(Pila p) {
Pila aux = new Pila(30); El método recibirá la pila
int mayor = 0; de números original, crea
int elem; una pila auxiliar y una
while (!p.esVacia()) {
variable “mayor” que
elem = (int) p.eliminar();
if (elem >= mayor) inicialmente inicia en
mayor = elem; cero. Sacará uno a uno
aux.adicionar(elem); todos los datos y de
} cumplir la condición ira
p.vaciar(aux); actualizando la variable
return mayor; mayor.
}
Estructura de Datos y Algoritmos LAB-131 Gestión II-2022 Aux. Sergio Ramirez Castro

public static void eliminarMayor(Pila p, int mayor) {

Pila aux = new Pila(30);
int elem;
while (!p.esVacia()) {
elem = (int) p.eliminar();
if (elem != mayor)
aux.adicionar(elem);
}
p.vaciar(aux);
}
 Estructura de Datos y Algoritmos LAB-131 Gestión II-2022 Aux. Sergio Ramirez Castro

Ejercicio 4:
Dada una cadena x, con ayuda de la estructura pila verificar si es un
palíndromo.

public static void main(String[] args) {

Scanner lee = new Scanner(System.in);
System.out.println("Intro cadena x:");
String cadena=lee.nextLine();
int tam=cadena.length()-1;
Pila p = new Pila(30);
while(tam>=0) {
p.adicionar(cadena.charAt(tam));
tam--;
}
System.out.println("Pila:");
p.mostrar();
// reconstruimos la cadena
String cadenaNueva="";
while(!p.esVacia()) {
cadenaNueva=p.eliminar()+cadenaNueva;
}
if (cadena.equals(cadenaNueva))
System.out.println("Si es un palíndromo");
else
System.out.println("No es un palíndromo ");
}

Desarrollo lógico (buscar):

Introducimos la cadena x desde teclado, guardamos uno a uno sus caracteres
de derecha a izquierda en la estructura pila, recorremos la pila y
reconstruimos la cadena, si la cadena original y la cadena nueva son las
iguales, tenemos un palíndromo.
 Estructura de Datos y Algoritmos LAB-131 Gestión II-2022 Aux. Sergio Ramirez Castro

Ejercicio 5:
Sea una pila de nombres se pide llevar al final todas las cadenas que Inician
con una vocal

import java.util.Scanner;

public class principal {

public static void main(String[] args) {
Pila p = new Pila(30);
p.adicionar("Jose");
p.adicionar("Ana");
p.adicionar("Oscar");
p.adicionar("Marlen");
p.adicionar("Miguel");
p.adicionar("Rocio");
p.adicionar("Alan");
p.adicionar("Mario");

System.out.println("Pila:");
p.mostrar();
System.out.println("\nSolucion:");
llevarFinal(p);
p.mostrar();
}
public static void llevarFinal(Pila p) {
Pila aux = new Pila(30);
Pila auxVocales = new Pila(30);
String elem;
String vocales = "aeiouAEIOU";
while (!p.esVacia()) {
elem = (String) p.eliminar();
if (vocales.contains(elem.charAt(0) + ""))
auxVocales.adicionar(elem);
else
aux.adicionar(elem);
}
p.vaciar(aux);
p.vaciar(auxVocales);
}
}
 Estructura de Datos y Algoritmos LAB-131 Gestión II-2022 Aux. Sergio Ramirez Castro

COLA SIMPLE
Definición:
Una cola es una estructura de datos donde el primer elemento en entrar es el primero
en salir. Una cola es una estructura de datos, caracterizada por ser una secuencia de
elementos en la que la operación de inserción push se realiza por un extremo y la
operación de extracción pop por el otro, también reciben el nombre de estructuras
FIFO (del inglés First Input First Output, primero en entrar, primero en salir).
Elementos:

Código Java

import java.util.Scanner;
public class ColaSimple {
private int ini, fin, max;
private Object v[] = new Object[100];
ColaSimple(int tam) {
ini = 0;
fin = 0;
max = tam;
}

boolean esVacia() {
if (ini == 0)
return true;
else
return false;
}
Estructura de Datos y Algoritmos LAB-131 Gestión II-2022 Aux. Sergio Ramirez Castro

boolean esLlena() {
if (fin == max)
return true;
return false;
}

void adicionar(Object x) {
if (!esLlena()) {
if (esVacia())
ini = 1;
fin++;
v[fin] = x;
} else
System.out.print("Cola llena");
}

Object eliminar() {
Object x = null;
if (!esVacia()) {
x = v[ini];
ini++;
if (ini > fin) {
ini = 0;
fin = 0;
}
} else
System.out.println("Cola vacia...");
return (x);
}

int nElem() {
if (!esVacia())
return (fin - ini + 1);
else
return (0);
}

int getMax() {
return max;
}
Estructura de Datos y Algoritmos LAB-131 Gestión II-2022 Aux. Sergio Ramirez Castro

void mostrar() {
ColaSimple aux = new ColaSimple(max);
Object x;
if (!esVacia()) {
while (!esVacia()) {
x = eliminar();
System.out.print(x + "\t");
aux.adicionar(x);
}
vaciar(aux);
} else
System.out.println("Cola vacia...");
}

void vaciar(ColaSimple B) {
while (!B.esVacia())
adicionar(B.eliminar());
}

void llenaEnteros(int n) {
int i;
Scanner lee = new Scanner(System.in);
for (i = 1; i <= n; i++) {
Object dato = lee.nextInt();
adicionar(dato);
}
}
}
public class principal {
public static void main(String[] args) {
ColaSimple c=new ColaSimple(20);
c.adicionar(1);
c.adicionar(2);
c.adicionar(3);
c.adicionar(4);
System.out.println("Datos de la Cola:");
c.mostrar();
}
}
 Estructura de Datos y Algoritmos LAB-131 Gestión II-2022 Aux. Sergio Ramirez Castro

COLA CIRCULAR
Definición:
Una cola circular es una estructura de datos en la que los elementos están
de forma circular. Son estructuras que nos permiten utilizar los espacios de
memoria de manera más eficiente que una cola simple normal.
Elementos:

Adicionar un elemento. - Este proceso se ejecuta por el final haciendo

avanzar el puntero fin y luego agregando el dato especificado.
Eliminar un elemento. - Consiste en extraer el primer elemento de la cola,
esto se logra haciendo que el puntero ini avance una posición más de su
posición actual de modo que se alcance al primer elemento de la cola
Código Java

public class ColaCircular {

private int ini, fin, max;
private Object v[] = new Object[100];

ColaCircular(int tam) {
ini = 0;
fin = 0;
max = tam;
}
boolean esVacia() {
if (nElem() == 0)
return true;
return false;
}
Estructura de Datos y Algoritmos LAB-131 Gestión II-2022 Aux. Sergio Ramirez Castro

boolean esLlena() {
if (nElem() == (max - 1))
return true;
else
return false;
}
void adicionar(Object x) {
if (!esLlena()) {
fin = (fin + 1) % max;
v[fin] = x;
} else
System.out.println("Cola llena...");
}
Object eliminar() {
Object x = null;
if (!esVacia()) {
ini = (ini + 1) % max;
x = v[ini];
} else
System.out.println("Cola vacia...");
return x;
}

int nElem() {
return ((fin - ini + max) % max);
}
void mostrar() {
Object x;
int n = nElem();
if (!esVacia()) {
while (n > 0) {
x = eliminar();
n--;
System.out.print(x + "\t");
adicionar(x);
}
} else
System.out.println("Cola vacia...");
}
Estructura de Datos y Algoritmos LAB-131 Gestión II-2022 Aux. Sergio Ramirez Castro

void vaciar(ColaCircular B) {
while (!B.esVacia())
adicionar(B.eliminar());
}

void llenaEnteros(int n) {
int i;
Scanner lee = new Scanner(System.in);
for (i = 1; i <= n; i++) {
Object dato = lee.nextInt();
adicionar(dato);
}
}

public class principal {

public static void main(String[] args) {
System.out.println("Datos de la Cola:");
ColaCircular c = new ColaCircular(20);
c.adicionar(1);
c.adicionar(2);
c.adicionar(3);
c.adicionar(4);
c.mostrar();
}
}
 Estructura de Datos y Algoritmos LAB-131 Gestión II-2022 Aux. Sergio Ramirez Castro

Ejercicio 1:
Dada una cola simple de enteros (1s y 0s) obtener su equivalente en base
decimal.

public class principal {

public static void main(String[] args) {
System.out.println("Datos de la Cola:");
ColaSimple c = new ColaSimple(20);
c.adicionar(1);
c.adicionar(0);
c.adicionar(1);
c.adicionar(0);
c.mostrar();
System.out.println("Numero decimal:"+baseDecimal(c));
}

static int baseDecimal(ColaSimple c) {

int dec = 0, dato = 0, exp = 0;
ColaSimple aux = new ColaSimple(50);
while (!c.esVacia()) {
dato = (int) c.eliminar();
aux.adicionar(dato);
exp = c.nElem();
dec += dato * (Math.pow(2, exp));
}
c.vaciar(aux);
return dec;
}
}
Estructura de Datos y Algoritmos LAB-131 Gestión II-2022 Aux. Sergio Ramirez Castro

Ejercicio 2:
Dada una cola simple de enteros eliminar los números múltiplos de 3

package pila;

public class principal {

public static void main(String[] args) {
System.out.println("Datos de la Cola:");
ColaSimple c = new ColaSimple(20);
c.adicionar(1);
c.adicionar(6);
c.adicionar(8);
c.adicionar(15);
c.adicionar(17);
c.adicionar(21);
c.adicionar(5);
c.mostrar();
System.out.println("Solucion:");
eliminarMultiplos3(c);
System.out.println("Resultado:");
c.mostrar();
}

static void eliminarMultiplos3(ColaSimple c) {

int elem;
ColaSimple aux = new ColaSimple(50);
while (!c.esVacia()) {
elem = (int) c.eliminar();
if (elem % 3 == 0)
System.out.println(elem + " --eliminado");
else
aux.adicionar(elem);
}
c.vaciar(aux);
}

}
Estructura de Datos y Algoritmos LAB-131 Gestión II-2022 Aux. Sergio Ramirez Castro

Ejercicio 3:
Dada una cola Circular de enteros eliminar los números pares sin usar
estructuras auxiliares.

public class principal {

public static void main(String[] args) {
System.out.println("Datos de la Cola:");
ColaCircular c = new ColaCircular(50);
c.adicionar(1);
c.adicionar(2);
c.adicionar(3);
c.adicionar(4);
c.adicionar(5);
c.adicionar(6);
c.adicionar(7);
c.mostrar();
System.out.println("Solucion:");
eliminarPares(c);
System.out.println("Resultado:");
c.mostrar();
}

static void eliminarPares(ColaCircular c) {

int elem;
int n = c.nElem();
for (int i = 1; i <= n; i++) {
elem = (int) c.eliminar();
if (elem % 2 != 0)
c.adicionar(elem);
}
}

}
 Estructura de Datos y Algoritmos LAB-131 Gestión II-2022 Aux. Sergio Ramirez Castro

Ejercicio 4:
Dada una cola circular de cadenas duplicar todas las que tengan menos de
5 caracteres sin usar estructuras auxiliares.

public class principal {

public static void main(String[] args) {
System.out.println("Datos de la Cola:");
ColaCircular c = new ColaCircular(50);
c.adicionar("Ana");
c.adicionar("Rosario");
c.adicionar("Carlos");
c.adicionar("Vianca");
c.adicionar("Sol");
c.adicionar("Alan");
c.adicionar("Jim");
c.mostrar();
System.out.println("Solucion:");
duplicarCadenas(c);
System.out.println("Resultado:");
c.mostrar();
}
static void duplicarCadenas(ColaCircular c) {
String elem;
int n = c.nElem();
for (int i = 1; i <= n; i++) {
elem = (String) c.eliminar();
if (elem.length() < 5) {
c.adicionar(elem);
}
c.adicionar(elem);
}
}
}
Estructura de Datos y Algoritmos LAB-131 Gestión II-2022 Aux. Sergio Ramirez Castro

Ejercicios propuestos:
1. Dada una pila con 10 números que representan las calificaciones de un
aula se pide redondear a 51 las notas que estén en el rango de 45 y 50.
2. Dada una oración verificar si es un palíndromo. Ejemplo:

3. En una pila que contiene cadenas se pide eliminar aquellas cadenas que
contengan más de 3 vocales
4. Dada una pila de enteros se pide ordenar ascendentemente. Ejemplo:

5. Sea una pila de caracteres, llevar a todas las vocales al principio de la pila y
las consonantes al final de la pila.
6. Dada una pila de números, eliminar a todos los números que se repitan.
7. En una pila ordenada de números Insertar un número en la i-esima
posición
8. Dada una Cola Circular de objetos Película< Titulo, Género, Duración>, se
pide Ordenar según su duración
9. Sea una cola simple de alimentos<nombre, precio> mostrar el(los)
alimentos con mayor precio
10.Sea una cola simple de números mover el k-esimo elemento al principio si
existe
11.Se tienen dos colas que contienen los dígitos, respectivamente. Se pide:
a. Sumar los números
b. Multiplicar los números
12.Dada una cola de que almacena objetos Persona<ci, nombre, apellidoP,
apellidoM, fechaNac(dd/mm/aaaa)>
a. Mostrar las personas que tengan C.I. igual a x.
b. Mostrar a las personas que sean mayores de edad.