1 Guía 16 - Estructuras en Java

Estructuras en Java

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. Un ejemplo: basta con apuntar una cámara al monitor que muestra la
imagen que muestra esa cámara.
Ejemplo
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));

Algoritmos de 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
puede ser:
- 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.
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.
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

27/04/2011
2 Guía 16 - Estructuras en Java
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.
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.
} } }

27/04/2011
3 Guía 16 - Estructuras en Java
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.

Archivo 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;
}
}

Archivo Lista.html

<HTML>

27/04/2011
4 Guía 16 - Estructuras en Java
<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.

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

27/04/2011
5 Guía 16 - Estructuras en Java
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;
}
}

Archivo ListaMult.html

<HTML>
<APPLET
CODE="ListaMult.class"
WIDTH="500"
HEIGHT="500">
</APPLET>
</HTML>

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, es decir, el puntero del nodo siguiente del último nodo toma el valor nulo (NULL).
En las listas abiertas existe un nodo especial: el primero, ese nodo deberá poder ser referenciado directamente en cualquier momento (normalmente con una
variable de tipo puntero). Esa referencia al primer nodo es muy importante ya que mediante ella podemos acceder a toda la lista.

27/04/2011
6 Guía 16 - Estructuras en Java

Lista ligada con tres valores enteros

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).
Es muy importante que nuestro programa nunca pierda el valor de la referencia al primer elemento, ya que sino existe ninguna copia de ese valor, y se
pierde, será imposible acceder al primer nodo y por tanto al resto de la lista y no se podrá liberar el espacio de memoria que ocupa.

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.
Pilas
Una pila es una estructura de datos en la cual el acceso está limitado al elemento más recientemente insertado y solamente puede crecer y decrecer por uno
de sus extremos.
Las pilas se denominan también estructuras LIFO (Last-In-First-Out), porque su característica principal es que el último elemento en llegar es el primero en
salir.
En todo momento, el único elemento visible de la estructura es el último que se colocó.
Se define el tope de la pila como el punto donde se encuentra dicho elemento.
En una pila, las tres operaciones naturales de insertar, eliminar y obtener el dato, se renombran por push, pop e info.
Interface
Como existen diferentes formas de implementar una Pila ( vectores, listas enlazadas ) la primera parte del diseño está constituida por la declaración de una
interface, con las operaciones básicas.

27/04/2011
7 Guía 16 - Estructuras en Java

REPRESENTACION GRAFICA DE ESTRUCTURAS LISTA

Listas

REPRESENTACION GRAFICA DE ESTRUCTURAS PILA

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

27/04/2011
8 Guía 16 - Estructuras en Java

Archivo: Pila.java
Interface Pila {
void push(Object x);
void pop( ) throws Exception;
Object info( ) throws Exception;
boolean esVacia( );
void vaciar( );
}
Métodos
push( x ) --> Inserta x
pop( ) --> Elimina el último elemento insertado
info( ) --> Retorna el último elemento insertado
esVacia( ) --> Retorna true si no existen elementos ;
false en caso contrario
vaciar( ) --> Elimina todos los elementos
Implementación con Lista Enlazada
Archivo: Nodo.java
class Nodo {
public Object dato;
public Nodo siguiente;
public Nodo(Object elemento, Nodo sgte) {
this.dato = elemento;
this.siguiente = sgte; }
public Nodo(Object elemento) {
this(elemento,null); } }
Archivo: PilaLi.java
class PilaLi implements Pila {
private Nodo tope;
public PilaLi( ) {
tope = null; }
public boolean esVacia( ) {
return tope == null; }
public void vaciar( ) {
tope = null; }
public void push(Object x) {
tope = new Nodo(x,tope); }
public Object info( ) throws Exception {

27/04/2011
9 Guía 16 - Estructuras en Java
if ( esVacia( ) )
throw new Exception("info");
return tope.dato; }
public void pop( ) throws Exception {
if ( esVacia( ) )
throw new Exception("pop");
tope = tope.siguiente; }
}

Ejercicios resueltos
Estos ejercicios requieren de la compilación de las clases anteriores

Archivo: testPila.java
class testPila {
public static void main(String arg[ ]) {
Pila p = new PilaLi( );
for(int i = 0; i < 10; i++)
p.push( new Integer(i+1) );
System.out.print("\n\tContenido : ");
Try {
for( ; ; ) {
System.out.print(" " + p.info( ) );
p.pop( ); } }
catch(Exception e){ }
System.out.println( );
}
}

Implementar un método que imprima un número en cualquier base, usando un método que use pilas.
Solución

Archivo: test2.java
import java.io.*;
class test2 {
public static void convertirBase(int numero , int base) {
Pila p = new PilaLi( );
while(numero != 0) {
p.push(new Integer( numero % base ) );
numero /= base; }
try {
for(;;) {
System.out.print(p.info( ) );
27/04/2011
10 Guía 16 - Estructuras en Java
p.pop( ); } }
catch(Exception e) { } }
public static void main(String arg[ ]) {
BufferedReader in = new BufferedReader(new
InputStreamReader(System.in));
int num,base;
boolean seguir = true;
while(seguir) {
try {
System.out.print("\n\tIngrese un numero : ");
num = Integer.parseInt(in.readLine( ) );
System.out.print("\tIngrese la nueva base : ");
base = Integer.parseInt(in.readLine( ) );
System.out.print("\tEl numero " + num + " en base " + base + " es : ");
convertirBase(num,base);
System.out.print("\n\tQuiere seguir : s/n : ");
String resp = in.readLine( );
if (resp.charAt(0) == 's') seguir = true;
else seguir = false; }
catch (Exception e) {
System.out.println("\tError de entrada : " + e);
}
}
}
}

Archivo: Listas.java
package lasClases;
import java.io.*;
public class Listas {
public static class ClaseListas { // Declaracion de la clase de Listas
static char dato[]=new char[100]; //Declara arreglo para los datos de tipo char
static int sn[]=new int[100]; //Declara arreglo para el indicador del sig. nodo
static int apui, top; // Apuntador inicial y Cantidad de datos en la Lista
ClaseListas() { // Constructor de la ClaseListas
apui=-1;
top=0;
System.out.println("Lista enlazada inicializada !!!");
System.out.println("apui="+apui);
System.out.println("top ="+top); }
public static void Mostrar() {
int i=0;

27/04/2011
11 Guía 16 - Estructuras en Java
System.out.println("\n\n<<< MOSTRAR ESTRUCTURA >>>");
if(apui==-1) System.out.println("\nLista enlazada vacia !!!\n");
System.out.println("posicion dato sn");
System.out.println("---------------------------");
for(i=0;i<top;i++) {
System.out.println(i+" | "+dato[i]+" | "+sn[i]);
}
System.out.println("\napui="+apui);
System.out.println("top="+top);
}
public static void Insertar(char elemento) {
int i=0, ant=0;
if(apui==-1) { //Alta en Lista vacia
System.out.println("Insertar dato en lista vacia ...");
apui=top;
dato[top]=elemento;
sn[top]=-1;
top++;
return;
}
i=apui;
do {
if(dato[i]==elemento) { System.out.println("Duplicado !!!");
return;
}
if(elemento<dato[i]) {
if(i==apui) { //Alta al principio
System.out.println("Insertando el dato menor de todos ...");
dato[top]=elemento;
sn[top]=apui;
apui=top;
top++;
return;
}
else {
System.out.println("Alta intermedia ...");
dato[top]=elemento;
sn[top]=sn[ant];
sn[ant]=top;
top++;
return;
}
}
27/04/2011
12 Guía 16 - Estructuras en Java
ant=i;
i=sn[i];
}
while(i!=-1);
System.out.println("Alta al final ...");
dato[top]=elemento;
sn[top]=-1;
sn[ant]=top;
top++;
return;
}
}
// Declaracion del objeto Lista
static ClaseListas Lista=new ClaseListas();
//Funcion principal
public static void main(String args[]) throws IOException {
int op=0;
do {
System.out.println("\n\n<<< LISTAS ENLAZADAS >>>");
System.out.println("1.- Altas");
System.out.println("2.- Mostrar estructura");
System.out.println("0.- Salir");
System.out.print("Opcion? ---> ");
op=getInt();
switch(op) {
case 1 : Altas(); break;
case 2 : Lista.Mostrar(); break;
}
}
while(op!=0);
}
public static void Altas() throws IOException {
char dato;
System.out.println("\n\n<<< ALTAS >>>");
System.out.print("Dato a insertar ---> ");
dato=getChar();
Lista.Insertar(dato); //Invocar el metodo Insertar del objeto Lista
}

//Funcion para capturar una cadena desde el teclado

public static String getString() throws IOException {
InputStreamReader isr = new InputStreamReader(System.in);
27/04/2011
13 Guía 16 - Estructuras en Java
BufferedReader br = new BufferedReader(isr);
String s = br.readLine();
return s;
}
// Funcion para capturar un entero desde el teclado
public static int getInt() throws IOException {
String s = getString();
return Integer.parseInt(s);
}
//Funcion para capturar un caracter desde el teclado
public static char getChar() throws IOException {
String s=getString();
return s.charAt(0);
}
}

Archivo: Pilas.java
package lasClases;
import java.io.*;
public class Pilas {
public static class ClasePila { // Declaracion de la clase de la Pila
private int max=10; // Tamano maximo de la pila
private int pila[] = new int [max]; // Arreglo para almacenar la pila
private int top; // Indica la cantidad de datos en la pila
public ClasePila() { // Constructor
top=0;
System.out.println("Pila creada !!!");
}
public void Push(int dato) {
if(top==max) // Esta llena la Pila?
{
System.out.println("Pila llena !!!");
return;
}
for(int i=0; i<top; i++) {
if(pila[i]==dato) { // Ya existe el dato?
System.out.println("Duplicado !!!");
return;
}
if(dato<pila[i]) { // Alta al principio o intermedia
for(int j=top;j>i;j--)
pila[j]=pila[j-1];

27/04/2011
14 Guía 16 - Estructuras en Java
pila[i]=dato;
top++;
System.out.println("Dato insertado al principio o intermedio !!!");
return;
}
}
pila[top++]=dato; // Alta al final
System.out.println("Dato insertado al final !!!");
return;
}
public void Pop(int dato) {
if(top==0) { // Esta vacia la Pila?
System.out.println("Pila vacia !!!");
return;
}
for(int i=0;i<top;i++) {
if(pila[i]==dato) {
for(int j=i; j<top-1; j++)
pila[j]=pila[j+1];
top--;
System.out.println("Dato eliminado !!!");
return;
}
}
System.out.println("Dato inexistente !!!");
}
public void Mostrar() {
System.out.println("\n\n<<< MOSTRAR LA PILA >>>");
if(top==0) System.out.println("Pila vacia !!!");
for(int i=0;i<top;i++)
System.out.println("pila["+i+"]="+pila[i]);
System.out.println("top="+top);
System.out.println("max="+max);
}
}
static ClasePila Pila=new ClasePila(); // Declaracion del objeto Pila
// Funcion principal
public static void main(String args[]) throws IOException {
int op=0;
do {
op=0;
System.out.println("\n\n<<< PILAS >>>");
System.out.println("1.-Push");
27/04/2011
15 Guía 16 - Estructuras en Java
System.out.println("2.-Pop");
System.out.println("3.-Mostrar Pila");
System.out.println("0.-Salir");
//op=Integer.parseInt(JOptionPane.showInputDialog("Opcion? "));
System.out.print("Opcion? ---> ");
op=getInt();
switch(op) {
case 1 : Altas(); break;
case 2 : Bajas(); break;
case 3 : Pila.Mostrar(); break;
}
}
while(op!=0);
}
public static void Altas() throws IOException {
int dato=0;
System.out.println("\n\n<<< ALTAS >>>");
System.out.print("\nAnote el dato que desea insertar ---> ");
dato=getInt();
Pila.Push(dato); // Invocar el metodo Push del objeto Pila
}
public static void Bajas() throws IOException {
int dato=0;
System.out.println("\n\n<<< BAJAS >>>");
System.out.print("\nAnote el dato que desea eliminar ---> ");
dato=getInt();
Pila.Pop(dato); // Invocar el metodo Pop del objeto Pila
}
// Funcion para capturar una cadena desde el teclado
public static String getString() throws IOException {
InputStreamReader isr = new InputStreamReader(System.in);
BufferedReader br = new BufferedReader(isr);
String s = br.readLine();
return s;
}
// Funcion para capturar un entero desde el teclado
public static int getInt() throws IOException {
String s = getString();
return Integer.parseInt(s); }
}
Colas
Como el primer elemento insertado es el primero en ser recuperado, los desarrolladores se refieren a estas colas como estructuras FIFO (first-in, first-out).

27/04/2011
16 Guía 16 - Estructuras en Java
Archivo: Colas.java
package lasClases;
import java.io.*;
public class Colas {
public static class ClaseColas { // Declaracion de la clase de Colas
static int max=10; // Tamano maximo de la Cola
static int cola[]= new int[max]; // Declaracion del arreglo
static int frente, fin; // Indicadores de inicio y fin de la Cola
ClaseColas() { // Constructor que inicializa el frente y el final de la Cola
frente=0; fin=0;
System.out.println("Cola inicializada !!!");
}
public static void Insertar(int dato) {
if(fin==max) { // Esta llena la Cola?
System.out.println("\nCola llena !!!");
return;
}
cola[fin++]=dato;
System.out.println("Dato insertado !!!");
}
public static void Eliminar() {
System.out.println("\n\n<<< ELIMINAR >>>");
if(frente==fin) { // Esta vacia la Cola?
System.out.println("\nCola vacia !!!");
return;
}
System.out.println("Elemento eliminado: "+cola[frente++]);
}
public static void Mostrar() {
int i=0;
System.out.println("\n\n<<< MOSTRAR >>>");
if(frente==fin) System.out.println("\nCola vacia !!!");
for(i=frente; i<fin; i++) {
System.out.println("cola["+i+"]="+" "+cola[i]);
}
System.out.println("\nFrente= "+frente);
System.out.println("Final = "+fin);
System.out.println("Max = "+max); } }
static ClaseColas Cola=new ClaseColas(); // Declaracion del objeto Cola
// Funcion principal
public static void main(String args[]) throws IOException {
int op=0;

27/04/2011
17 Guía 16 - Estructuras en Java
do {
System.out.println("\n\n<<< COLAS >>>");
System.out.println("1.- Altas");
System.out.println("2.- Eliminar");
System.out.println("3.- Mostrar");
System.out.println("0.- Salir");
System.out.print("Opcion? ---> ");
op=getInt();
switch(op) {
case 1 : Altas(); break;
case 2 : Cola.Eliminar(); break;
case 3 : Cola.Mostrar(); break;
}
}
while(op!=0);
}
public static void Altas() throws IOException {
int elemento=0;
System.out.println("\n\n<<< ALTAS >>>");
System.out.print("Elemento a insertar? ---> ");
elemento=getInt();
Cola.Insertar(elemento); // Invocar el metodo Insertar del objeto Cola
}

// Funcion para capturar una cadena desde el teclado

public static String getString() throws IOException {
InputStreamReader isr = new InputStreamReader(System.in);
BufferedReader br = new BufferedReader(isr);
String s = br.readLine();
return s;
}

// Funcion para capturar un entero desde el teclado

public static int getInt() throws IOException {
String s = getString();
return Integer.parseInt(s);
}
}

27/04/2011