CLASE 4

CURSO: PROGRAMACIÓN III

M.A. Carlos Armando Escobar Garza

PILA
Colección homogénea de datos en la que el acceso se realiza
siguiendo un criterio LIFO (Last In First Out, último en entrar
primero en salir.

Se accede a los datos en orden inverso al que fueron

insertados.

Ejemplos de pilas:

Bandejas en autoservicio
Hojas de papel en bandeja de impresora
Etc
IMPLEMENTAR UNA PILA
La estructura de datos pila en java. Clase Stack del api java

STACK
La clase Stack es una clase de las llamadas de tipo LIFO (Last In - First Out, o último en entrar -
primero en salir). Esta clase hereda de la clase que ya hemos estudiado anteriormente en el
curso Vector y con 5 operaciones permite tratar un vector a modo de pila o stack.
Las operaciones básicas son push (que introduce un elemento en la pila), pop (que saca un
elemento de la pila), peek (consulta el primer elemento de la cima de la pila), empty (que
comprueba si la pila está vacía) y search (que busca un determinado elemento dentro de la pila y
devuelve su posición dentro de ella).
Esta clase es muy sencilla y al crear un objeto de tipo Stack con el constructor básico
evidentemente no contendrá ningún elemento.
Un conjunto mucho más completo y consistente para operaciones de stack LIFO es
proporcionado en la interface Deque y sus implementaciones, pero nosotros de momento vamos
a limitarnos al estudio de la clase Stack.
package pilas;
import java.util.Stack;
public class Pilas {

public static void main(String[] args) {

Stack<Libro> pila = new Stack<Libro>();

Libro 11 = new Libro("Título 1", "Autor 1");

Libro 12 = new Libro("Título 2", "Autor 2");
Libro 13 = new Libro("Título 3", "Autor 3");

pila.push(l1); // adiciona un libro a la pila

pila.push(l2);
pila.push(l3);
System.out.println("ultimo dato adicionado a la pila");
System.out.println(pila.peek().getTitulo()); // el último elemento adicionado
System.out.println("\npila:");
while (!pila.isEmpty()) { // mostrar pila completa
System.out.println(pila.pop().getTitulo()); // extrae un elemento de la pila
}
}

}
package pilas; public String getTitulo() {
return titulo;
public class Libro { }
private String titulo;
private String autor; public void setTitulo(String
titulo) {
public Libro() { this.titulo = titulo;
this.titulo = ""; }
this.autor = "";
} public String getAutor() {
return autor;
public Libro(String titulo, }
String autor) {
this.titulo = titulo; public void setAutor(String
this.autor = autor; autor) {
} this.autor = autor;
}
}
COLA
Colección homogénea de datos en la que el acceso se realiza
siguiendo un criterio FIFO (First In First Out, primero en entrar
primero en salir.

Se accede a los datos en el mismo orden al que fueron

insertados.

Ejemplos de colas:

Cola en banco
Cola trabajo impresión
etc
Implementación de una cola
Colas en Java con Queue
En Java podemos encontrar variadas formas de crear Colas en pocas lineas
de código, un ejemplo es una de sus Interfaces que tiene como nombre
“Queue”
Métodos de Queue para manejo de Colas en Java
con la cual podemos crear Colas y que contiene los siguientes métodos
para el uso de las mismas.
Para Insertar:
– add(e)
– offer(e)
Para Extraer:
– remove()
– poll()
Para Consultar el Frente:
– element()
– peek()
package colas;

import java.util.LinkedList;
import java.util.Queue;
public class Colas {
public static void main(String[] args) {
/*Creamos la Cola Indicando el tipo de dato*/
Queue<Integer> cola=new LinkedList();
/*Insertamos datos*/
cola.offer(3);
cola.add(14);
cola.offer(12);
cola.add(7);
cola.offer(10);
/*Impresion de la Cola llena con los datos*/
System.out.println("Cola llena: " + cola);
/*Estructura repetitiva para desencolar*/
while(cola.poll()!=null){//Desencolamos y el valor se compara con null
System.out.println(cola.peek());//Muestra el nuevo Frente
}
/*Muestra null debido a que la cola ya esta vacia*/
System.out.println(cola.peek());
}

}
Si en este programa mostrado, hacemos un cambio como el siguiente:

while(cola.remove()!=null){
System.out.println(cola.peek());
}
Nos toparemos con un error cuando se desencole el último elemento, puesto que la excepción que lanza en ese caso el
método remove() no está siendo considerado.

Al igual al modificar el último método utilizado en el ejemplo:

System.out.println(cola.element());

Ya que, está siendo utilizado cuando la cola se encuentra vacía, al igual que el método remove() nos lanzará una excepción
que no esta siendo tratada en el ejemplo.

Creando la cola con la interfaz “Queue” nos limitamos a tener elementos de 1 solo tipo de dato, en cambio, podemos
crearla con la clase llamada “LinkedList”, en ella podemos utilizar los mismos métodos que creandola con la interfaz
“Queue” y a parte podemos insertar elementos de diferentes tipos de datos en la misma Cola
package colasv2;

import java.util.LinkedList;
public class Colasv2 {

public static void main(String[] args) {

LinkedList cola=new LinkedList();//Usamos LinkedList
cola.offer(3);
cola.add(14);
cola.offer(12);
cola.add(7);
cola.offer(10);
cola.add(10.5);
cola.add("cadena");

System.out.println("Cola llena: " + cola);

while(cola.poll()!=null){
System.out.println(cola.peek());
}
System.out.println(cola.peek());

}
Listas enlazadas.
Una lista enlazada o estructura ligada, es una estructura lineal que almacena una
colección de elementos generalmente llamados nodos, en donde cada nodo puede
almacenar datos y ligas a otros nodos. De esta manera los nodos pueden localizarse
en cualquier parte de la memoria, utilizando la referencia que lo relaciona con otro
nodo dentro de la estructura.
Las listas enlazadas son estructuras dinámicas que se utilizan para almacenar datos
que están cambiando constante mente. A diferencia de los vectores, las estructuras
dinámicas se expanden y se contraen haciéndolas más flexibles a la hora de añadir
o eliminar información.

Las listas enlazadas permiten almacenar información en posiciones de memoria que

no sean contiguas; para almacenar la información contienen elementos llamados
nodos. Estos nodos poseen dos campos uno para almacenar la información o valor
del elemento y otro para el enlace que determina la posición del siguiente elemento o
nodo de la lista.
Lo más recomendable y flexible para la creación de un nodo es utilizar un objeto por cada nodo, para ello debe comprender
cuatro conceptos fundamentales que son:

- Clase auto-referenciada,
- Nodo,
- Campo de enlace y
- Enlace

Una clase auto-referenciada es una clase con al menos un campo cuyo tipo de referencia es el nombre de la misma clase.

public clase Nodo

{
Object elemento;
Nodo siguiente;
//métodos
}

El código anterior es una clase auto-referenciada porque su campo siguiente tiene el tipo Nodo.
El nodo es un objeto creado a partir de una clase auto-referenciada.
El campo de enlace es la variable de instancia que contiene el tipo que corresponde con el nombre de la clase (para el caso
anterior variable siguiente).
El enlace es el contenido del campo de enlace, que hace referencia (guarda la dirección) a otro nodo.
Las listas enlazadas se dividen en:
- Listas enlazadas simples (con una sola dirección) y
- Listas enlazadas dobles (con dos direcciones).

Simples.
Una lista enlazada simple es una colección de nodos que tienen una sola dirección y que en conjunto forman una
estructura de datos lineal. Cada nodo es un objeto compuesto que guarda una referencia a un elemento (dato) y una
referencia a otro nodo (dirección).
La referencia que guarda un nodo a otro nodo se puede considerar un enlace o un puntero hacia el segundo nodo y
el salto que los relaciona recibe el nombre de salto de enlace o salto de puntero. El primer nodo de una lista recibe el
nombre de cabeza, cabecera o primero y el último es llamado final, cola o último (es el único nodo con la referencia a
otro objeto como nula).
Un nodo de una lista enlazada simple puede determinar quien se encuentra después de él pero no puede determinar
quien se encuentra antes, ya que solo cuenta con la dirección del nodo siguiente pero no del anterior.

Cabeza final

Dato (contiene
la información)

Apunta a otro El último valor

nodo apunta a null
Los elementos cabeza y final de la figura son referencia creadas a partir de la clase que se crean los nodos.
Operaciones básicas:

agregar (valor): agrega el valor al final de la lista.

•insertar (referencia, valor): inserta el valor después del valor de
referencia en la lista.
•remover (referencia): elimina el nodo con el valor que coincida con la
referencia.
•editar (referencia): actualiza el valor de nodo con el valor que
coincida con la referencia.
•esVacia (): retorna true si la lista está vacía, false en caso contrario.
•buscar (valor): retorna la true si el elemento existe en la lista, false
caso contrario.
•eliminar(): elimina la lista
•listar (): imprime en pantalla los elementos de la lista.
•(ver ejemplo java listas simples)