Estructuras de Datos en Java

ESTRUCTURAS DE DATOS EN JAVA

1. ESTRUCTURAS DE DATOS.

Una estructura de datos es una agrupación de éstos que se trata como una unidad en su conjunto. Se construyen a partir de los tipos de datos simples. Las estructuras de datos pueden ser homogéneas (todos los datos son del mismo tipo) o heterogéneas (constituidas por datos de tipos diferentes).

1.1. Estructuras de datos dinámicas.

Se dice que una estructura de datos es dinámica cuando inicialmente (en el momento de la compilación) no tiene espacio asignado para almacenar información. Durante la ejecución del programa el sistema (en tiempo de ejecución, run time) asigna y libera espacio en memoria, en función de las necesidades.

Las listas, árboles y grafos describen distintos tipos de Estructuras de Datos Dinámicas. En algunos lenguajes de programación, para permitir la implementación de estructuras de datos dinámicas es necesario un tipo de datos especial, denominado puntero (pointer). El concepto de puntero (pointer) hace referencia a una variable cuyo contenido es la dirección de otra variable (nodo) que realmente contiene el propio dato que se emplea en el programa.

1.2. Estructuras de datos estáticas.

Una estructura estática se caracteriza porque su tamaño es conocido a priori (antes de la ejecución del programa). En consecuencia, en el código del programa se declaran variables de tipo estático y en la compilación se reserva en memoria el espacio necesario para ellas.

2. TIPOS ABSTRACTOS DE DATOS.

Como se entiende por Estructura de Datos una agrupación de datos, simples o compuestos, del mismo o diferente tipo, que constituyen una entidad en su conjunto (por ejemplo un vector o un registro). Evolucionando en el concepto de estructura de datos aparece el de Tipo Abstracto de Datos (TAD) que obedece a la técnica de abstracción de datos y sienta las bases para una adecuada compresión de la Programación Orientada a Objetos.

Una definición de TAD u Objeto sería: El conjunto constituido por la estructura de datos y las operaciones asociadas a la misma que permite modelar el comportamiento de una entidad real. Se trata de construir entidades (TAD’s, Objetos, etc.) que puedan ser posteriormente utilizadas por otros. Sus principales características son:

Ocultamiento. El TAD tiene un comportamiento de “caja negra” dado que quien lo usa sabe qué puede hacer pero no cómo lo hace.

Encapsulamiento (y, en consecuencia, Protección). El usuario de TAD’s no tiene acceso y, por tanto, no puede modificar sus características. No obstante, puede partir de él para construir otros TAD’s.

Compilación separada: El resultado de la compilación del TAD se pone a disposición de los usuarios en forma de unidades que pueden utilizarse como si estuvieran predefinidas en el lenguaje de programación.

Ing. Sandro Gutierrez Flores | 2015


El objetivo de emplear este tipo de mecanismos obedece a criterios de productividad en la Ingeniería del Software. De forma simplificada se trata de clasificar a los profesionales de la construcción de Software en dos categorías:

Constructores (y distribuidores) de TAD’s.

Utilizadores de TAD’s hechos por otros.

El usuario de un TAD sabe de su comportamiento a partir de las especificaciones tanto semánticas como sintácticas que le habrán sido proporcionadas por el creador del mismo. Veremos, a partir de unos sencillos ejemplos, la forma de usar TAD’s a partir de su interfaz (no necesitamos saber cómo están construidos internamente, se verá en temas posteriores). Se trata de dos Tipos Abstractos de Datos: Pilas y Colas que constituyen fenómenos observables con mucha frecuencia en el mundo real.

3. PILAS.

3.1. Concepto.

Una pila es una agrupación de elementos de determinada naturaleza o tipo (datos de personas, números, procesos informáticos, automóviles, etc.) entre los que existe definida una relación de orden (estructura de datos). En función del tiempo, algunos elementos de dicha naturaleza pueden llegar a la pila o salir de ella (operaciones/acciones). En consecuencia el estado de la pila varía. Una pila presenta el comportamiento LIFO (Last Input First Output) y el criterio de ordenación se establece en sentido inverso al orden de llegada. Así pues, el último elemento que llegó al conjunto será el primero en salir del mismo, y así sucesivamente.

3.2. Modelo gráfico.

Podríamos representar gráficamente una pila como una estructura de datos vertical, en la que los elementos se insertan y extraen por la parte superior.

3.3. Especificaciones.

A continuación se describen las operaciones que vamos a poder realizar sobre el TAD pila de enteros. Para ello, utilizaremos dos tipos de especificaciones:

Especificaciones sintácticas. Hacen referencia a los aspectos sintácticos de las distintas operaciones asociadas al TAD: nombre de la operación, parámetros, resultado devuelto por la operación, tipo de dicho resultado, etc.

Especificaciones semánticas. Indican el efecto producido por la operación, es decir, la definen desde el punto de vista de lo que hace.



3.4. Interfaz de la Pila.package tadPila;import java.io.*;public interface Pila { boolean pilaVacia (); void eliminarPila (); int cima () throws PilaVacia; void apilar (int x); int desapilar () throws PilaVacia; void decapitar () throws PilaVacia; void imprimirPila (); void leerPila () throws NumberFormatException, IOException; int numElemPila ();}

3.5. Nodo de la Pila.package tadPila;

public class NodoPila { NodoPila (int elemento, NodoPila n) { dato = elemento; siguiente = n; } int dato; NodoPila siguiente;}

3.6. Error en Pila Vacía.package tadPila;

public class PilaVacia extends Exception { private static final long serialVersionUID = 1L; public PilaVacia (final String msg) { super(msg); }}

3.7. Operaciones básicas con Pilas.package tadPila;

import java.io.*;

public class TadPila implements Pila {NodoPila pila;

public TadPila () { pila = null; } public boolean pilaVacia () { return pila == null; }

public void eliminarPila () { pila = null; } public int cima () throws PilaVacia { if (pilaVacia ()) throw new PilaVacia ("La pila está vacía"); return pila.dato; } public void apilar (int dato) { NodoPila aux; aux = new NodoPila (dato, pila); pila = aux; } public int desapilar () throws PilaVacia { int resultado; if (pilaVacia ()) { throw new PilaVacia ("Desapilar: La pila está vacía"); } resultado = pila.dato; pila = pila.siguiente; return resultado; }

public void decapitar () throws PilaVacia {



if (pilaVacia ()) { throw new PilaVacia ("Decapitar: La pila está vacía"); } pila = pila.siguiente; } public void imprimirPila () { NodoPila aux; System.out.print ("Estado de la pila: "); aux = pila; while (aux != null) { System.out.print (aux.dato + " "); aux = aux.siguiente; } System.out.println (); } public void leerPila () throws NumberFormatException, IOException { int cantidad, i, x; BufferedReader linea_entrada = new BufferedReader(new InputStreamReader(System.in)); pila = null; System.out.println ("Numero de elementos de la pila: "); cantidad = Integer.parseInt(linea_entrada.readLine()); for (i = 0; i < cantidad; i++) { x = Integer.parseInt(linea_entrada.readLine());; apilar (x); } } public int numElemPila () { NodoPila aux; int resul; aux = pila; resul = 0; while (aux != null) { ++resul; aux = aux.siguiente; } return resul;

}}

4. COLAS. 4.1. Concepto.

Una cola es una agrupación de elementos de determinada naturaleza o tipo (datos de personas, números, procesos informáticos, automóviles, etc.) entre los que existe definida una relación de orden (estructura de datos). En función del tiempo, algunos elementos pueden llegar a la cola o salir de ella (operaciones / acciones). En consecuencia el estado de la cola varía. Una cola presenta comportamiento FIFO (First Input First Output) y se respeta como criterio de ordenación el momento de la llegada: el primer elemento de la cola, será el que primero llegó a ella y, en consecuencia, el primero que saldrá, y así sucesivamente.

4.2. Modelo gráfico.

Podríamos representar gráficamente una cola como una estructura de datos horizontal, en la que los elementos se insertan por el extremo derecho, y se extraen por la parte izquierda.

4.3. Interfaz de la Cola.



package tadCola;import java.io.IOException;public interface Cola { boolean colaVacia (); void eliminarCola (); int primero () throws ColaVacia; void encolar (int x); int desencolar () throws ColaVacia; void quitarPrimero () throws ColaVacia; void mostrarEstadoCola (); void imprimirCola (); void leerCola () throws NumberFormatException, IOException;

int numElemCola (); void invertirCola () throws ColaVacia;}

4.4. Nodo de la Cola.package tadCola;class NodoCola {

NodoCola (int elemento, NodoCola n) { dato = elemento; siguiente = n; } int dato; NodoCola siguiente;}

4.5. Error en Cola Vacía.package tadCola;@SuppressWarnings("serial")public class ColaVacia extends Exception { public ColaVacia (final String msg) { super (msg); }}

4.6. Operaciones básicas con Colas.package tadCola;import java.io.BufferedReader;import java.io.IOException;import java.io.InputStreamReader;public class TadCola implements Cola { private NodoCola principio; private NodoCola fin; public TadCola () { principio = null; fin = null; } public boolean colaVacia () { return principio==null; } public void eliminarCola () { principio = null; fin = null; } public int primero () throws ColaVacia { if (colaVacia ())

throw new ColaVacia ("La cola está vacía"); return principio.dato; } public void encolar (int x) { NodoCola aux; aux = new NodoCola(x,null); if (principio == null) { principio = aux; fin = aux;

} else {



fin.siguiente = aux; fin = aux; } } public int desencolar () throws ColaVacia { int resultado; if (colaVacia ()) { throw new ColaVacia ("Desencolar: La cola está vacía"); } resultado = principio.dato; principio = principio.siguiente; if (principio == null) fin = null; return resultado; } public void quitarPrimero () throws ColaVacia { if (colaVacia ()) { throw new ColaVacia ("Quitar primero: La cola está vacía"); } principio = principio.siguiente; if (principio == null) fin = null; } public void mostrarEstadoCola () { System.out.println("Estado de la cola:"); System.out.println("Referencia al nodo (cola): "+principio+ ";

Clave: "+principio.dato+"; Referencia al siguiente: "+principio.siguiente); } public void imprimirCola () { NodoCola aux; System.out.print ("Estado de la cola: ");

aux = principio; while (aux != null) { System.out.print (aux.dato + " "); aux = aux.siguiente; } System.out.println (); } public void leerCola () throws NumberFormatException, IOException { int cantidad, i, x; BufferedReader linea_entrada = new BufferedReader(new InputStreamReader(System.in)); System.out.println ("Numero de elementos de la cola: "); cantidad = Integer.parseInt(linea_entrada.readLine()); for (i = 0; i < cantidad; i++) { x = Integer.parseInt(linea_entrada.readLine());; encolar (x); } } public int numElemCola () { NodoCola aux; int resul; aux = principio; resul = 0; while (aux != null) { ++resul; aux = aux.siguiente; } return resul; } public void invertirCola () throws ColaVacia { int elem; if (!colaVacia()) { elem = desencolar(); invertirCola(); encolar(elem); } }}


Estructuras de Datos en Java

Documents

Transcript of Estructuras de Datos en Java