Estructuras en Java

Construcción de Software II
Guía 26 – Estructuras en Java
150
REPRESENTACION GRAFICA DE ESTRUCTURAS PILA
Observe
Pilas
LI
FO
REPRESENTACION GRAFICA DE ESTRUCTURAS COLA
Colas
FI
FO
LIFO == Last In First Out == Ultimo en entrar – Primero en salir
FIFO == First In First Out == Primero en entrar – Primero en salir
www.dariolara.com
Guía 26 – Estructuras en Java
Construcción de Software II
143
Estructuras en Java
Introducción
Los tipos de estructuras mas conocidos son Listas, Pilas y Colas y obedecen al
manejo que se dan a las estructuras ordenadas llamadas arreglos (Array)
Recursividad
Ordenacion
Busquedas
Listas
Pilas
Colas
Recursividad
Se dice que algo es recursivo si se define en función de sí mismo o a sí mismo.
También se dice que nunca se debe incluir la misma palabra en la definición de
ésta. El caso es que las definiciones recursivas aparecen con frecuencia en
matemáticas, e incluso en la vida real.
Ejemplo
Basta con apuntar una cámara al monitor que muestra la imagen que muestra esa
cámara.
Práctica 143
Dado un array constituido de números enteros y que contiene N elementos
siendo N >= 1, devolver el elemento mayor.
int mayor(int numeros[], int posicion) {
int aux;
if (posicion == 0)
return numeros[posicion];
else {
aux = mayor(numeros, posicion-1);
if (numeros[posicion] > aux)
return numeros[posicion];
else
return aux;
} }
...
int numeros[5] = {2,4,1,-3,-1};
int N = 5;
printf("%d\n", mayor(numeros, 4));
Ordenación
Su finalidad es organizar ciertos datos (normalmente arrays o ficheros) en un orden
creciente o decreciente mediante una regla prefijada (numérica, alfabética)
Ordenación interna Los datos se encuentran en memoria (ya sean arrays, listas, etc) y
son de acceso aleatorio o directo (se puede acceder a un determinado campo sin
pasar por los anteriores).
Ordenación externa Los datos están en un dispositivo de almacenamiento externo
(ficheros) y su ordenación es más lenta que la interna.
www.dariolara.com
Construcción de Software II
Guía 26 – Estructuras en Java
144
Los principales algoritmos de ordenación interna son:
Selección
Este método consiste en buscar el elemento más pequeño del array y ponerlo
en primera posición; luego, entre los restantes, se busca el elemento más
pequeño y se coloca en segudo lugar, y así sucesivamente hasta colocar el
último elemento.
Práctica 144
int array[N];
int i,j,menor,aux; // Dar valores a los elementos del array
for(i=0;i<N-1;i++) {
for(j=i+1,menor=i;j<N;j++)
if(array[j]<array[menor]) // Si el elemento j es menor que el menor:
menor=j; // el menor pasa a ser el elemento j.
aux=array[i]; // Se intercambian los elementos
array[i]=array[menor]; // de las posiciones i y menor
array[menor]=aux; // usando una variable auxiliar. }
Metodo de la Burbuja
Consiste en comparar pares de elementos adyacentes e intercambiarlos entre
sí hasta que estén todos ordenados. Con el array anterior, {40,21,4,9,10,35}:
Primera pasada:
{21,40,4,9,10,35} <-- Se cambia el 21 por el 40.
{21,4,40,9,10,35} <-- Se cambia el 40 por el 4.
{21,4,9,40,10,35} <-- Se cambia el 9 por el 40.
{21,4,9,10,40,35} <-- Se cambia el 40 por el 10.
{21,4,9,10,35,40} <-- Se cambia el 35 por el 40.
Segunda pasada:
{4,21,9,10,35,40} <-- Se cambia el 21 por el 4.
{4,9,21,10,35,40} <-- Se cambia el 9 por el 21.
{4,9,10,21,35,40} <-- Se cambia el 21 por el 10.
Ya están ordenados, pero para comprobarlo habría que acabar esta segunda
comprobación y hacer una tercera.
Práctica 145
int array[N];
int i,j,aux;
// Dar valores a los elementos del array
for(i=0;i<N-1;i++) // Hacer N-1 pasadas.
{ for(j=0;j<N-i-1;j++) // Mirar los N-i-1 pares.
{ if(array[j+1]<array[j]) // Si el elemento j+1 es menor que el
elemento j:
{
aux=array[j+1]; // Se intercambian los elementos
array[j+1]=array[j]; // de las posiciones j y j+1
array[j]=aux; // usando una variable auxiliar.
}
} }
www.dariolara.com
Guía 26 – Estructuras en Java
Construcción de Software II
149
Práctica 150
ListaMult.java
/**
* @(#)ListaMult.java
*
*
* @author dario lara
* @version 1.00 2007/10/19
*/
import java.awt.*;
import java.applet.Applet;
public class ListaMult extends Applet {
List lm = new List( 6,true );
public void init() {
Button boton = new Button( "Aceptar" );
lm.addItem( "Mercurio" );
lm.addItem( "Venus" );
lm.addItem( "Tierra" );
lm.addItem( "Marte" );
lm.addItem( "Jupiter" );
lm.addItem( "Saturno" );
lm.addItem( "Neptuno" );
lm.addItem( "Urano" );
lm.addItem( "Pluton" );
add( lm );
add( boton );
}
public boolean action( Event evt,Object obj ) {
if( evt.target instanceof Button )
{
if( "Aceptar".equals( obj ) )
{
String seleccion[];
seleccion = lm.getSelectedItems();
for( int i=0; i < seleccion.length; i++ )
System.out.println( seleccion[i] );
}
}
return true;
}
}
www.dariolara.com
Construcción de Software II
148
Práctica 148
Guía 26 – Estructuras en Java
Lista.java
/**
* @(#)Lista.java
* @author dario lara
* @version 1.00 2007/10/19
*/
import java.awt.*;
import java.applet.Applet;
public class Lista extends Applet {
public void init() {
List l = new List( 4,false );
l.addItem( "Mercurio" );
l.addItem( "Venus" );
l.addItem( "Tierra" );
l.addItem( "Marte" );
l.addItem( "Jupiter" );
l.addItem( "Saturno" );
l.addItem( "Neptuno" );
l.addItem( "Urano" );
l.addItem( "Pluton" );
add( l );
}
public boolean action( Event evt,Object obj ) {
if( evt.target instanceof List )
System.out.println( "Entrada de la Lista: " + obj );
return true;
}
}
Práctica 149
Lista.html
<HTML>
<APPLET
CODE="Lista.class"
WIDTH="500"
HEIGHT="500">
</APPLET>
</HTML>
En el applet siguiente, ListaMult.java, se permite al usuario seleccionar varios elementos
de los que constituyen la lista.
www.dariolara.com
Guía 26 – Estructuras en Java
Construcción de Software II
145
Busquedas
Cuestiones generales
La búsqueda de un elemento dentro de un array es una de las operaciones más
importantes en el procesamiento de la información, y permite la recuperación
de datos previamente almacenados. El tipo de búsqueda se puede clasificar
como interna o externa, según el lugar en el que esté almacenada la
información (en memoria o en dispositivos externos). Todos los algoritmos de
búsqueda tienen dos finalidades:

Determinar si el elemento buscado se encuentra en el conjunto en el que
se busca.

- Si el elemento está en el conjunto, hallar la posición en la que se
encuentra.
En este apartado nos centramos en la búsqueda interna. Como principales
algoritmos de búsqueda en arrays tenemos la búsqueda secuencial, la binaria y
la búsqueda utilizando tablas de hash.
Búsqueda secuencial
Consiste en recorrer y examinar cada uno de los elementos del array hasta
encontrar el o los elementos buscados, o hasta que se han mirado todos los
elementos del array.
Práctica 146
for(i=j=0;i<N;i++)
if(array[i]==elemento) {
solucion[j]=i;
j++; }
Este algoritmo se puede optimizar cuando el array está ordenado, en cuyo
caso la condición de salida cambiaría a:
for(i=j=0;array[i]<=elemento;i++)
o cuando sólo interesa conocer la primera ocurrencia del elemento en el array:
for(i=0;i<N;i++)
if(array[i]==elemento)
break;
En este último caso, cuando sólo interesa la primera posición, se puede utilizar
un centinela, esto es, dar a la posición siguiente al último elemento de array el
valor del elemento, para estar seguro de que se encuentra el elemento, y no
tener que comprobar a cada paso si seguimos buscando dentro de los límites
del array:
array[N]=elemento;
for(i=0;;i++)
if(array[i]==elemento)
break;
Si al acabar el bucle, i vale N es que no se encontraba el elemento. El número
medio de comparaciones que hay que hacer antes de encontrar el elemento
buscado es de (N+1)/2.
www.dariolara.com
Construcción de Software II
Guía 26 – Estructuras en Java
146
Búsqueda binaria o dicotómica
Para utilizar este algoritmo, el array debe estar ordenado. La búsqueda binaria
consiste en dividir el array por su elemento medio en dos subarrays más
pequeños, y comparar el elemento con el del centro. Si coinciden, la búsqueda
se termina. Si el elemento es menor, debe estar (si está) en el primer subarray,
y si es mayor está en el segundo. Ej: buscar el elemento 3 en el array
{1,2,3,4,5,6,7,8,9} se realizarían los siguientes pasos:
Se toma el elemento central y se divide el array en dos:
{1,2,3,4}-5-{6,7,8,9}
Como el elemento buscado (3) es menor que el central (5), debe
estar en el primer subarray: {1,2,3,4}
Se vuelve a dividir el array en dos:
{1}-2-{3,4}
Como el elemento buscado es mayor que el central, debe estar en el
segundo subarray: {3,4}
Se vuelve a dividir en dos:
{}-3-{4}
El elemento buscado coincide con el central, lo hemos encontrado.
Si al final de la búsqueda todavía no lo hemos encontrado, y el subarray a
dividir está vacio {}, el elemento no se encuentra en el array.
Práctica 147
int desde,hasta,medio,elemento,posicion;
// desde y
// hasta indican los límites del array que se está mirando.
int array[N];
// Dar valor a elemento.
for(desde=0,hasta=N-1;desde<=hasta;) {
if(desde==hasta) // si el array sólo tiene un elemento:
{
if(array[desde]==elemento) // si es la solución:
posicion=desde; // darle el valor.
else // si no es el valor:
posicion=-1; // no está en el array.
break; // Salir del bucle.
}
medio=(desde+hasta)/2; // Divide el array en dos.
if(array[medio]==elemento) // Si coincide con el central:
{
posicion=medio; // ese es la solución
break; // y sale del bucle.
}
else if(array[medio]>elemento) // si es menor:
hasta=medio-1; // elige el array izquierda.
else // y si es mayor:
desde=medio+1; // elige el array de la derecha. }
www.dariolara.com
Guía 26 – Estructuras en Java
Construcción de Software II
147
Listas
Las listas (List) aparecen en los interfaces de usuario para facilitar a los
operadores la manipulación de muchos elementos. Se crean utilizando
métodos similares a los de los botones
La lista es visible todo el tiempo, utilizándose una barra de desplazamiento
para visualizar los elementos que no caben en el área que aparece en la
pantalla.
El ejemplo siguiente, Lista.java, crea una lista que muestra cuatro líneas a la
vez y no permite selección múltiple
Lo compilamos para generar la clase bytecode Lista.class pero un applet se
ejecuta por medio de un codigo .html que lo llama con la instrucción CODE y
con un navegador como Internet Explorer.
Lista (estructura de datos)
La forma más simple de estructura dinámica es la lista enlazada (lista abierta o
lista ligada). En esta forma los nodos se organizan de modo que cada uno
apunta al siguiente, y el último no apunta a nada, el puntero del nodo
siguiente del último nodo toma el valor nulo (NULL).
En las listas abiertas existe un nodo especial: el primero. Esa referencia al
primer nodo es muy importante ya que mediante ella podemos acceder a toda
la lista.
Mediante asignación dinámica de memoria podemos hacer que la lista varíe de
tamaño, aumentando o disminuyendo, según las necesidades del programa
que la utilice con la única restricción de que haya memoria disponible.
Inicialmente, cuando una lista aún no dispone de ningún nodo, o cuando se
borran todos los nodos de los que dispone, diremos que la lista esta vacía, en
ese caso la referencia al primer nodo tendrá un valor nulo (puntero a NULL).
Tipos de listas
Lista lineal: En la cual el último nodo apunta a NULL.
Lista circular: El último nodo apunta al primero.
Lista doblemente enlazada: Los nodos, aparte de tener un nodo
siguiente, tiene un nodo llamado anterior el cual apunta al anterior
nodo.
www.dariolara.com