Pilas y Colas

Constantes.
java
package tech.alvarez;
public class Constantes {
public static final int SIN_ESPECIALIDAD = 0;

public static final int ESPECIALIDAD_ODONTOLOGIA = 1;
public static final int ESPECIALIDAD_NEUROLOGIA = 2;
public static final int ESPECIALIDAD_PEDIATRIA = 3;
}
Raw
Ficha.java
public class Ficha {
private int especialidad;

private int codigo;
public Ficha(int especialidad, int codigo) {

this.especialidad = especialidad;
this.codigo = codigo;
}
public int getEspecialidad() {

return especialidad;
}
public void setEspecialidad(int especialidad) {

this.especialidad = especialidad;
}
public int getCodigo() {
return codigo;
}
public void setCodigo(int codigo) {

this.codigo = codigo;
}
}
Raw
Main.java
import java.util.LinkedList;
import java.util.Queue;
import java.util.Stack;
public class Main {
public static void main(String[] args) {
Stack<Ficha> o = new Stack<Ficha>();

Stack<Ficha> n = new Stack<Ficha>();
Stack<Ficha> p = new Stack<Ficha>();
// llenar
for (int i = 1; i <= 20; i++) {

o.push(new Ficha(Constantes.ESPECIALIDAD_ODONTOLOGIA, i));
n.push(new Ficha(Constantes.ESPECIALIDAD_NEUROLOGIA, i));
p.push(new Ficha(Constantes.ESPECIALIDAD_PEDIATRIA, i));
}
System.out.println("ODONTOLOGIA");
mostrar(o);
System.out.println("NEUROLOGIA");
mostrar(n);
System.out.println("PEDIATRIA");
mostrar(p);
Queue<Paciente> pacientes = new LinkedList<Paciente>();
pacientes.add(new Paciente("Nombre1",
Constantes.ESPECIALIDAD_ODONTOLOGIA, Constantes.ESPECIALIDAD_PEDIATRIA));
Constantes.ESPECIALIDAD_PEDIATRIA, Constantes.SIN_ESPECIALIDAD));
Constantes.ESPECIALIDAD_NEUROLOGIA, Constantes.ESPECIALIDAD_ODONTOLOGIA));
Constantes.ESPECIALIDAD_ODONTOLOGIA, Constantes.SIN_ESPECIALIDAD));
Constantes.ESPECIALIDAD_ODONTOLOGIA, Constantes.SIN_ESPECIALIDAD));
Constantes.ESPECIALIDAD_PEDIATRIA, Constantes.SIN_ESPECIALIDAD));
Constantes.ESPECIALIDAD_NEUROLOGIA, Constantes.SIN_ESPECIALIDAD));
System.out.println("PACIENTES");
mostrar(pacientes);
// Solución 1
asignarFichas(o, n, p, pacientes);
System.out.println("ODONTOLOGIA");
mostrar(o);
System.out.println("NEUROLOGIA");
mostrar(n);
System.out.println("PEDIATRIA");
mostrar(p);
// Solución 2
// Calcular cual es la especialidad mas requerida
calcularEspecidadMasRequerida(o, n, p);
// Solución 3
// Realizar el metodo atender para devolver la ficha a su lugar
Paciente pa = pacientes.remove();
System.out.println("> paciente: " + pa.getNombre());
atender(pa, o, p, n);
private static void atender(Paciente pa, Stack<Ficha> o, Stack<Ficha>

p, Stack<Ficha> n) {
if (pa.getEspecialidad1() == Constantes.ESPECIALIDAD_ODONTOLOGIA) {
Ficha fi = pa.getFicha1();
o.push(fi);
// reseteo
pa.setFicha1(null);
pa.setEspecialidad1(Constantes.SIN_ESPECIALIDAD);
} else if (pa.getEspecialidad1() ==
Constantes.ESPECIALIDAD_NEUROLOGIA) {
n.push(fi);
// reseteo
pa.setFicha1(null);
n.push(fi);
// reseteo
pa.setFicha1(null);
}
if (pa.getEspecialidad2() != Constantes.SIN_ESPECIALIDAD) {
if (pa.getEspecialidad2() ==
Constantes.ESPECIALIDAD_ODONTOLOGIA) {
o.push(fi);
// reseteo
pa.setFicha2(null);
Constantes.ESPECIALIDAD_PEDIATRIA) {
p.push(fi);
// reseteo
pa.setFicha2(null);
n.push(fi);
// reseteo
pa.setFicha2(null);
}
}
}
private static void calcularEspecidadMasRequerida(Stack<Ficha> o,

Stack<Ficha> n, Stack<Ficha> p) {
int no = o.size();
int np = p.size();
int nn = n.size();
if (no < np && no < nn) {

System.out.println("Odontologia es más requerido");
}
if (np < no && np < nn) {
System.out.println("Pediatria es más requerido");
}
if (nn < no && nn < np) {
System.out.println("Neurologia es más requerido");
}
}
private static void asignarFichas(Stack<Ficha> o, Stack<Ficha> n,

Stack<Ficha> p, Queue<Paciente> pacientes) {
int m = pacientes.size();
for (int i = 0; i < m; i++) {
Paciente pa = pacientes.remove();
Ficha fi = n.pop();
pa.setFicha1(fi);
Ficha fi = o.pop();
pa.setFicha1(fi);
Ficha fi = p.pop();
pa.setFicha1(fi);
}
if (pa.getEspecialidad2() != Constantes.SIN_ESPECIALIDAD) {
Ficha fi = n.pop();
pa.setFicha2(fi);
Ficha fi = o.pop();
pa.setFicha2(fi);
Ficha fi = p.pop();
pa.setFicha2(fi);
}
}
pacientes.add(pa);
}
private static void mostrar(Stack<Ficha> o) {
Stack<Ficha> temp = new Stack<Ficha>();
while (!o.isEmpty()) {
Ficha fi = o.pop();
System.out.println(" Ficha: " + fi.getEspecialidad() + " " +
fi.getCodigo());
temp.push(fi);
}
while (!temp.isEmpty()) {
Ficha fi = temp.pop();
o.push(fi);
}
}
public static void mostrar(Queue<Paciente> cola) {

int n = cola.size();
for (int i = 0; i < n; i++) {
Paciente pa = cola.remove();
System.out.println(" Paciente: " + pa.getNombre() + "
Especialidades: " + pa.getEspecialidad1() + ", " + pa.getEspecialidad2());
cola.add(pa);
}
}
}
Raw
Paciente.java
public class Paciente {

private String nombre;
private Ficha ficha1;
private Ficha ficha2;
private int especialidad1;
private int especialidad2;
public Paciente(String nombre, int especialidad1, int especialidad2) {

this.nombre = nombre;
this.especialidad1 = especialidad1;
this.ficha1 = null;
this.ficha2 = null;
}
public String getNombre() {

return nombre;
}
public void setNombre(String nombre) {

this.nombre = nombre;
}
public Ficha getFicha1() {

return ficha1;
}
public void setFicha1(Ficha ficha1) {

this.ficha1 = ficha1;
}
public Ficha getFicha2() {

return ficha2;
}
public void setFicha2(Ficha ficha2) {

this.ficha2 = ficha2;
}
public int getEspecialidad1() {

return especialidad1;
}
public void setEspecialidad1(int especialidad1) {
}
public int getEspecialidad2() {

return especialidad2;
}
public void setEspecialidad2(int especialidad2) {

}
}
1.
2. Ejercicio Pila
En este ejemplo hemos creado la función verificaParentesis que nos devuelve un boolean
indicando si dada una cadena, esta está equilibrada y correcta en paréntesis, es decir verificar
que cada paréntesis que se abre en la cadena tenga su correspondiente cierre. Para ello se
hace uso internamente en este método de una pila o stack. Así el programa principal main
tan solo llama a esta función con una cadena de ejemplo (cadenano o cadenasi) para verificar
su equilibrado y corrección en paréntesis.
package proypilasejemplo;
import java.util.Stack;
public class ProyPilasEjemplo {
/**
* @param args the command line arguments
*/
public static void main(String arg[]) {
String cadenano = "(Cadena no equilibrada en paréntesis(()()()))))";
String cadenasi = "(Cadena equilibrada en parentesis())";
System.out.println("Verificación equilibrado en paréntesis para
cadenano:");
System.out.println(verificaParentesis(cadenano));
System.out.println("Verificación equilibrado en paréntesis para
cadenasi:");
System.out.println(verificaParentesis(cadenasi));
}
public static boolean verificaParentesis(String cadena) {
Stack<String> pila = new Stack<String>(); int i = 0;
while (i<cadena.length()) {
if(cadena.charAt(i)=='(') {pila.push("(");}
else if (cadena.charAt(i)==')') {
if (!pila.empty()){ pila.pop(); }
else { pila.push(")"); break; }
}
i++;
}
if(pila.empty()){ return true; } else { return false; }
}
}
Publicado hace 18th November 2015 por JuanPablo Salazar
0
Agregar un comentario
3.
NOV
17
Comparación entre Pilas y Colas
Pilas:
 En las Pilas se puede acceder a los elementos de la lista solo a través de la cima
de la misma.
 Se puede acceder a los elementos de la Pila solo a través del sistema LIFO.
 Se considera como una estructura de datos Las In Fist Out
 Solo se puede agregar elementos a la parte superior de la Pila.
Colas:
 Se pude acceder a los elementos de la lista desde cualquier extremo de la

misma, ya sea desde el comienzo o desde el final.
 Los elementos se eliminan de la Cola en el orden de llegada.
 Se considera como una estructura First In First Out.
 En las bi-colas se pueden agregar elementos desde ambos extremos de la lista,
ya sea desde el comienzo o desde el final.
Publicado hace 17th November 2015 por JuanPablo Salazar
0
Agregar un comentario
4.
NOV
16
Pilas y Colas en Java
Pilas en Java
La pila es una secuencia de elementos del mismo tipo en la que el acceso a la misma se realiza
por un único lugar denominado cima:
Vemos como el acceso a los elementos de la pila se realiza siempre sobre un único extremo.
Las operaciones que caracterizan la pila son las de introducir un nuevo elemento sobre la cima
(push) y la de extraer el elemento situado en la cima (pop). Una forma de ver esta estructura de
datos es como una pila de libros en la que sólo se puede coger el libro que está en la cima o
apilar más libros sobre la misma, pero los libros que sostienen la pila no son accesibles pues de
otro modo todo se desmoronaría.
De aqui que decimos que una lista se comporta como una pila, ya que las inserciones y las extracciones solo pueden hacerse
desde la parte superior de la pila. Esto se conoce también como LIFO (Last In First Out).
Las pilas son muy útiles en varios escenarios de programación. Dos de los más comunes
son:
 Pilas que contienen direcciones de retorno:

 Cuando el código llama a un método, la dirección de la primera instrucción que sigue a
la llamada se inserta en la parte superior de la pila de llamadas de métodos del thread
actual. Cuando el método llamado ejecuta la instrucción return, se saca la dirección
de la parte superior de la pila y la ejecución continúa en esa dirección. Si un método
llama a otro método, el comportamiento LIFO de la pila asegura que la
instrucción return del segundo método transfiere la ejecución al primer método, y la
del primer método transfiere la ejecución al código que sigue al código que llamó al
primer método. Como resultado una pila "recuerda" las direcciones de retorno de los
métodos llamados.
 Pilas que contienen todos los parámetros del método llamado y las variables
locales:
 Cuando se llama a un método, la JVM reserva memoria cerca de la dirección de retorno
y almacena todos los parámetros del método llamado y las variables locales de ese
método. Si el método es un método de ejemplar, uno de los parámetros que almacena
en la pila es la referencia this del objeto actual.
El interfaz en Java que define esta clase de objetos y sus métodos son los siguientes:
Pila.java
Veremos ahora dos implementaciones de pila, mediante arrays y listas enlazadas.
Implementación de pilas mediante arrays

Implementemos una Pila mediante un vector
PilaArray.java
La dimensión de la pila se establece al crear la pila, mediante el constructor. En el

siguiente ejemplo creamos una pila con capacidad para 125 elementos
PilaArray pila_de_ejemplo = new PilaArray(125);
Si hubieramos usado el constructor por defecto se hubiera establecido el tamaño de

la pila en 1000 elementos.
Definimos un campo privado top para conocer en todo momento cuál es la cima de
la pila. De esta forma, si queremos añadir un nuevo elemento a la pila (push) lo
haremos en la posición siguiente a la que nos indica este campo. Observe como sólo
se inserta un nuevo elemento sobre la cima cuando hay espacio suficiente, es decir
la longitud de la pila es menor que su capacidad. Primero se incrementa el valor del
campo top y después se inserta el elemento en la pila .
Para implementar las operaciones pop y primero se comprueba que la lista no es

vacía, en cuyo caso se devuelve un valor nulo (null). Para el caso de pop se
decrementa la variable top para eliminar el objeto de la cima, mientras que
para primero no, puesto que en este último sólo se está consultando la cima.
Implementación de pilas mediante listas enlazadas

Utilizaremos ahora la clase Nodo definida anteriormente para ver esta otra
implementación a la que llamaremos PilaEnlazada . Los campos que definiremos
para esta clase son top, que almacena el nodo que está en la cima de la pila y
la longitud de la misma.
PilaEnlazada.java
A continuación vemos como se insertan los nodos por la cima de la pila. Para ello se
crea un nuevo nodo y se le asigna como siguiente nodo la antigua cima de la pila. El
siguiente paso es actualizar la cima de la pila con el nuevo nodo creado.
El funcionamiento del pop es el siguiente. Si la lista esta vacía devuelve un valor nulo.
En caso contrario actualiza la cima al siguiente elemento por debajo del nodo situado
en la cima y devuelve el valor del nodo cima:
El mecanismo que sigue el método primero es similar al visto en el pop, aunque se
elimina la cima, únicamente se devuelve su valor:
Como programar una PILA en Java Netbeans o Eclipse (FILO - LIFO)
http://aprenderaprogramar.com/index.php?option=com_content&view=article&id=608:la-estructura-de-datos-
pila-en-java-clase-stack-del-api-java-ejemplo-simple-y-ejercicios-resueltos-cu00920c&catid=58:curso-
lenguaje-programacion-java-nivel-avanzado-i&Itemid=180
http://www.ciberaula.com/articulo/pilas_en_java/
Colas en Java
En una Cola los elementos se añaden desde la parte de atrás o la parte final de la
cola, sin embargo la información se extrae desde el frente, es decir, los elementos
que se añadieron primero serán los primeros en salir, esto se conoce como estructura
FIFO (First In First Out).
Los elementos de la cola se añaden y se eliminan de tal manera que el primero en
entrar es el primero en salir. La adición de elementos se realiza a través de una
operación llamada encolar (enqueue), mientras que la eliminación se denomina
desencolar (dequeue). La operación de encolar inserta elementos por un extremo
de la cola, mientras que la de desencolar los elimina por el otro.
El siguiente interfaz muestras las operaciones típicas para colas:
Cola.java
La siguiente es una posible implementación de colas mediante la clase Nodo:
ColaEnlazada.java
Vemos como la clase Cola contiene dos campos, cola y cabecera que apuntan al
principio y al final de la cola. La cabecera la utilizaremos para extraer elementos.
Para insertar utilizaremos la cola.
La operación encolar crea un nodo cuyo sucesor es nulo. Esto es porque añadimos al
final de la cola, es decir, donde apunta el campo cola. Si la cola es vacía la cabecera y
la cola apuntan al mismo objeto Nodo.
Para eliminar (desencolar) y para consultar (cabecera) se utiliza el campo cabecera.

Se extraen/consultan elementos de la cabeza de la cola.
Hacer una Cola en Java
http://www.ciberaula.com/articulo/colas_en_java/
http://es.slideshare.net/RoverOportunity2012/java-pilas-ycolas
 CODIGO FUENTE COLA
?
1 /**
2 *
* E-Mail : shamirdhc31@gmail.com
3
* Blog : http://javadhc.blogspot.com
4 *
5 */
6
7 import javax.swing.JOptionPane;
8
9 public class ColaArray
10 {
private int MAX;
11 private int[] COLA;
12 private int FRENTE;
13 private int FINAL;
14
15 public ColaArray()
{
16 this.MAX = 100;
17 this.FRENTE = 0;
18 this.FINAL = 0;
19 this.COLA = new int[this.MAX+1];
20 }
21
public ColaArray(int MAX)
22 {
23 this.MAX = MAX;
24 this.FRENTE = 0;
25 this.FINAL = 0;
26 this.COLA = new int[this.MAX+1];
}
27
28 public boolean IsColaLlena()
29 {
30 if(this.FINAL == this.MAX)
31 {
return true;
32 }
33 else
34 {
35 return false;
36 }
}
37
38 public boolean IsColaVacia()
39 {
40 if(this.FRENTE == this.FINAL)
41 {
42 return true;
}
43 else
44 {
45 return false;
46 }
}
47
48 public void InsertarCola()
49 {
50 if(this.IsColaLlena())
51 {
52 JOptionPane.showMessageDialog(null,"LA COLA ESTÁ LLENA");
}
53 else
54 {
55 int ITEM;
56
57 ITEM = Integer.parseInt(JOptionPane.showInputDialog(null,"INGRESE EL IT
58
59 this.FINAL++;
this.COLA[FINAL] = ITEM;
60
61 }
62 }
63
64 public void EliminarCola()
65 {
if(this.FRENTE == this.FINAL)
66 {
67 JOptionPane.showMessageDialog(null,"LA COLA ESTA VACIA");
68 }
69 else
70 {
for(int i=FRENTE;i < FINAL - 1;i++)
71 {
72 COLA[i] = COLA[i+1];
73 }
74
75 FINAL--;
76 }
}
77
78 public void MostrarCola()
79 {
80 if(this.IsColaVacia())
81 {
JOptionPane.showMessageDialog(null,"LA COLA ESTÁ VACIA\n NO HAY DATOS Q
82 }
83 else
84 {
85 String MOSTRAR = "";
86
87 for(int i=FRENTE+1;i<=FINAL;i++)
{
88 MOSTRAR = MOSTRAR + COLA[i]+"\n";
89 }
90
91 JOptionPane.showMessageDialog(null,"TOTAL ES : "+this.FINAL+"\n"+"LOS D
92 }
93 }
94
public void VaciarCola()
95 {
96 FRENTE = 0;
97 FINAL = 0;
98 }
99 }
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
 CODIGO FUENTE MAIN COLA
?
1 /**
*
2 * E-Mail : shamirdhc31@gmail.com
3 * Blog : http://javadhc.blogspot.com
4 *
5 */
6
import javax.swing.JOptionPane;
7
8 public class MainColaArray
9 {
10 public static ColaArray Cola;
11
12 public static void main(String[] ARGUMENTOS)
13 {
int MAX;
14
15 MAX = Integer.parseInt(JOptionPane.showInputDialog(null,"INGRESE EL TAMAÑO D
16 Cola = new ColaArray(MAX);
17
18 MenuCola();
19 }
20
public static void MenuCola()
21
{
22 int Opcion;
23
24 do
25 {
26 Opcion = Integer.parseInt(JOptionPane.showInputDialog(null,
"1. INGRESAR DATOS\n"+
27 "2. ELIMINAR DATOS\n"+
28 "3. OBSERVAR DATOS\n"+
29 "4. VACIAR COLA\n"+
30 "5. SALIR\n"+
31 "--------------------------------------------------------\n"+
"INGRESE LA OPCION [1 - 5]","MENU COLA",JOptionPane.QUESTION_MES
32
33 switch(Opcion)
34 {
35 case 1: Cola.InsertarCola();break;
36 case 2: Cola.EliminarCola();break;
37 case 3: Cola.MostrarCola();break;
case 4: Cola.VaciarCola();break;
38 case 5: System.exit(0);break;
39 default: JOptionPane.showMessageDialog(null,"INGRESE UNA OPCION VALI
40 }
41 }
while(true); //-- SEGUIRA HASTA QUE OPCION SEA IGUAL A 5
42 }
43}
44
45
46
47
48
49
50
51

Pilas y Colas

Cargado por

Información del documento

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Pilas y Colas

Cargado por

Copyright:

Formatos disponibles

Constantes.

public class Constantes {

public static final int SIN_ESPECIALIDAD = 0;

public class Ficha {

private int especialidad;

public Ficha(int especialidad, int codigo) {

public int getEspecialidad() {

public void setEspecialidad(int especialidad) {

public void setCodigo(int codigo) {

public class Main {

public static void main(String[] args) {

Stack<Ficha> o = new Stack<Ficha>();

for (int i = 1; i <= 20; i++) {

Queue<Paciente> pacientes = new LinkedList<Paciente>();

private static void atender(Paciente pa, Stack<Ficha> o, Stack<Ficha>

private static void calcularEspecidadMasRequerida(Stack<Ficha> o,

if (no < np && no < nn) {

private static void asignarFichas(Stack<Ficha> o, Stack<Ficha> n,

private static void mostrar(Stack<Ficha> o) {

Stack<Ficha> temp = new Stack<Ficha>();

public static void mostrar(Queue<Paciente> cola) {

public class Paciente {

public Paciente(String nombre, int especialidad1, int especialidad2) {

public String getNombre() {

public void setNombre(String nombre) {

public Ficha getFicha1() {

public void setFicha1(Ficha ficha1) {

public Ficha getFicha2() {

public void setFicha2(Ficha ficha2) {

public int getEspecialidad1() {

public int getEspecialidad2() {

public void setEspecialidad2(int especialidad2) {

public class ProyPilasEjemplo {

Comparación entre Pilas y Colas

 Se pude acceder a los elementos de la lista desde cualquier extremo de la

Publicado hace 17th November 2015 por JuanPablo Salazar

Pilas y Colas en Java

 Pilas que contienen direcciones de retorno:

Veremos ahora dos implementaciones de pila, mediante arrays y listas enlazadas.

Implementación de pilas mediante arrays

La dimensión de la pila se establece al crear la pila, mediante el constructor. En el

PilaArray pila_de_ejemplo = new PilaArray(125);

Si hubieramos usado el constructor por defecto se hubiera establecido el tamaño de

Para implementar las operaciones pop y primero se comprueba que la lista no es

Implementación de pilas mediante listas enlazadas

Como programar una PILA en Java Netbeans o Eclipse (FILO - LIFO)

Para eliminar (desencolar) y para consultar (cabecera) se utiliza el campo cabecera.

 CODIGO FUENTE COLA

 CODIGO FUENTE MAIN COLA

También podría gustarte