ESTRUCTURA DE DATOS

FELIX GONZALO SERRANO OCHOA

DOCENTE: JAIDER. F.RODRIGUEZ

UNICIENCIA
INGENIERIA DE SISTEMAS
BUCARAMANGA, SANTANDER.
2018.
 Listas en Java
Una lista es una secuencia de elementos dispuesto en un cierto orden, en la que cada
elemento tiene como mucho un predecesor y un sucesor. El número de elementos de
la lista no suele estar fijado, ni suele estar limitado por anticipado.

La estructura de datos deberá permitirnos determinar cuál es el primer elemento y el

último de la estructura, cuál es su predecesor y su sucesor (si existen de cualquier
elemento dado). Cada uno de los elementos de información suele denominarse nodo.

La lista también puede representarse de forma simbólica escribiendo sus elementos

separados por comas y encerrados entre corchetes. Por ejemplo:

["rojo","verde","azul","amarillo"]

Las listas admiten ciertas operaciones como son insertar un nodo adicional, borrar un
nodo, etc. En función de la forma de insertar nuevos elementos y acceder a los
existentes tendremos distintos tipos de listas. Veamos ahora qué operaciones básicas
se puedes realizar sobre las listas. Se tratarán aquí las operaciones que permiten
insertar y borrar elementos únicamente al principio de la misma, por lo que las
operaciones de acceso, inserción y supresión de elementos en cualquier posición de la
lista no se consideran básicas pero podrán ser tratadas mediante recursión.

Las operaciones básicas sobre una lista son:

 EsVacia Averiguar si la lista está vacía.

 Insertar Añade un elemento al principio de la lista.
 Primero Obtener el valor del primer elemento de la lista, también llamado
cabeza.
 Resto Devuelve el trozo de lista resultado de eliminar el primer elemento de la
lista.
 Borrar Borrar el primer elemento de la lista.

Las listas pueden ser circulares, con el último elemento apuntando al primero, o
pueden tener un campo que contenga el número de nodos que hay en la lista.

Las listas se pueden definir de muchas formas. Podríamos definirlas a partir de

un vector teniendo un acceso rápido aunque con un número de elementos limitado
por la dimensión del vector.

Otra forma de definir una lista es de forma recursiva. Resulta menos eficiente que
definirla a partir de un vector sin embargo no nos impone restricciones en cuanto a su
longitud. Veamos cómo se define en Java cada uno de los elementos de la lista:
Observe como esta estructura se corresponde con las cajas que se habían visto en la
representación de listas. Vemos que tiene dos atributos, el elemento que se almacena
en cada nodo y el Nodo siguiente en el orden de la lista. A continuación se
implementan los métodos de la clase para manipular los nodos:

Nodo.java

El constructor crea un nodo a partir de un objeto y el siguiente nodo al que va a estar

enlazado. Las operaciones cambiarElemento y cambiarSiguiente cambian los valores
de los campos del objeto. Por último Siguiente y Elemento devuelven el contenido del
nodo.

A partir de esta clase implementaríamos la lista como una cadena de nodos:

ListaEnlazada.java

Fíjese como el constructor inicializa la lista a null. Este va a ser también el final de la
lista. De forma que cuanto el principio y final de la lista coincidan la lista estará vacía.

Veremos a continuación algunas implementaciones distintas de listas. Se debe prestar

especial interés a los mecanismos de implementación, pues las distintas operaciones
pueden cambiar de una implementación a otra sin embargo la forma no.
 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.

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);

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 es 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:

Colas en Java
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.

Árboles en Java
La estructura de datos árbol al contrario que las listas es una estructura de datos no
lineal. Las listas tienen un orden impuesto en sus elementos teniendo como mucho un
predecesor y un sucesor. Los árboles pueden tener dos o más sucesores.

Un árbol consiste en un conjunto de nodos o vértices y un conjunto

de aristas o arcos que satisface unos requisitos:

 Existe una jerarquía de nodos, de forma que a cada nodo hijo le llega una arista
de otro nodo padre. De esta forma se establece la relación padre-hijo: p es
padre de h, h es un hijo de p.
 El nodo donde comienza la jerarquía se llama nodo raíz. A este nodo no llegan
arcos de ningún otro nodo, en otras palabras, no es hijo de ningún nodo padre.
 Existe un camino único entre la raíz y cualquiera de los nodos del árbol
Veremos ahora un poco de terminología relacionada con los árboles. En primer lugar
estudiaremos qué tipos de nodos nos podremos encontrar en un árbol. Hemos visto
que existe un nodo especial, el nodo raiz que no tiene padres. El caso de los nodos que
no tienen hijos es el de los nodos externos o nodos hoja. El resto de nodos
son internos, cuando tiene descendientes. Diremos que un nodo es descendiente de
otro, si es hijo de él ó descendiente de sus hijos. Los descendientes nos determinan
un subárbol con raíz el nodo descendiente.

Veremos ahora aquellos conceptos que nos dan una idea sobre la topología del árbol.
Son los conceptos de camino, longitud y profundidad:

 El camino existente entre dos nodos, es la secuencia de "arcos" que nos llevan,
siguiéndolas de forma consecutiva del primero al segundo. La longitud es el
número de aristas que contiene.

 Profundidad de un nodo es la longitud del camino de la raíz a ese nodo.

 Altura de un árbol es la profundidad máxima entre todos los nodos extremos
del árbol. Es decir, "la profundidad del nodo más profundo".

Por simplificar el estudio de los árboles veremos el caso de los árboles binarios. Un
árbol binario es un árbol en el que cada nodo tiene 0 ó 2 hijos (el hijo izquierdo y el
derecho). Este árbol podrá ser ordenado si para cada nodo existe un orden lineal para
todos su hijos, es decir, si tenemos el orden "menor que", un árbol será ordenado si
para cada nodo sus hijos son menores que el padre.

Al igual que las listas la forma de definir los árboles es de manera recursiva.
Definiremos inicialmente una clase Nodo que represente cada uno de los nodos del
árbol:
Cada uno de los objetos de tipo NodoBinario representa una estructura de datos
compuesta por el elemento que se almacena en cada nodo y dos nodos que
llamaremos nodoizqy nododcha. Puesto que los nodos binario pueden tener 0 ó 2
hijos, se han definido dos tipos de constructores para cubrir los dos casos. El resto de
métodos son para manipular la clase nodo de forma transparente. A partir de esta
clase NodoBinariose define la clase ArbolBinario como sigue:

Notesé que un ArbolBinario como máximo puede tener un hijo, si es el caso usaremos
el constructor con un solo parámetro si no es así utilizaremos el constructor por
defecto, es decir, el constructor sin parámetros.

Un ArbolBinario no es más que un NodoBinario llamado raiz. Vemos en el siguiente

esquema cómo sería gráficamente la estructura del árbol:
Vamos a ver cómo se calcularía el tamaño del árbol a partir de esta definición:

Definimos una función auxiliar que calcula el tamaño de un subárbol bajo un nodo.
Este método calcula una longitud 0 si el Nodo es nulo. En otro caso, la longitud será la
suma de los tamaños de los nodos hijos más uno, correspondiente al nodo actual. El
método tamaño llama al método tam_aux con el nodo raiz.
 BIBLIOGRAFÍA

http://www.ciberaula.com/