Estructuras de Datos Con Java. Héctor Tejeda V PDF

Estructuras de Datos con Java
Héctor Tejeda V
Abril, 2010
Índice general
1. Introducción 7
1.1. Clases, tipos, y objetos . . . . . . . . . . . . . . . . . . . . . . 7
1.1.1. Tipos base . . . . . . . . . . . . . . . . . . . . . . . . . 10
1.1.2. Objetos . . . . . . . . . . . . . . . . . . . . . . . . . . 10
1.1.3. Tipo enum . . . . . . . . . . . . . . . . . . . . . . . . . 17
1.2. Métodos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17
1.3. Expresiones . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23
1.3.1. Literales . . . . . . . . . . . . . . . . . . . . . . . . . . 23
1.3.2. Operadores . . . . . . . . . . . . . . . . . . . . . . . . 24
1.3.3. Conversiones tipo base . . . . . . . . . . . . . . . . . . 28
1.4. Control de flujo . . . . . . . . . . . . . . . . . . . . . . . . . . 30
1.4.1. Sentencias if y switch . . . . . . . . . . . . . . . . . . 30
1.4.2. Ciclos . . . . . . . . . . . . . . . . . . . . . . . . . . . 32
1.4.3. Sentencias explı́citas de control de flujo . . . . . . . . . 35
1.5. Arreglos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37
1.5.1. Declaración de arreglos . . . . . . . . . . . . . . . . . . 39
1.5.2. Arreglos como objetos . . . . . . . . . . . . . . . . . . 40
1.6. Entrada y salida . . . . . . . . . . . . . . . . . . . . . . . . . 41
1.7. Clases anidadas y paquetes . . . . . . . . . . . . . . . . . . . . 45
2. Diseño orientado al objeto 47

2.1. Metas, principios, y patrones . . . . . . . . . . . . . . . . . . . 47
2.1.1. Metas del diseño orientado a objetos . . . . . . . . . . 47
2.1.2. Principios del diseño orientado al objeto . . . . . . . . 49
2.1.3. Patrones de diseño . . . . . . . . . . . . . . . . . . . . 51
2.2. Herencia y polimorfismo . . . . . . . . . . . . . . . . . . . . . 52
2.2.1. Herencia . . . . . . . . . . . . . . . . . . . . . . . . . . 52
2.2.2. Polimorfismo . . . . . . . . . . . . . . . . . . . . . . . 54
ÍNDICE GENERAL 3
2.2.3. Uso de herencia en Java . . . . . . . . . . . . . . . . . 55

2.3. Excepciones . . . . . . . . . . . . . . . . . . . . . . . . . . . . 63
2.3.1. Lanzamiento de excepciones . . . . . . . . . . . . . . . 63
2.3.2. Atrapar excepciones . . . . . . . . . . . . . . . . . . . 66
2.4. Interfaces y clases abstractas . . . . . . . . . . . . . . . . . . . 68
2.4.1. Implementación de interfaces . . . . . . . . . . . . . . 68
2.4.2. Herencia múltiple en interfaces . . . . . . . . . . . . . 70
2.4.3. Clases abstractas y tipado fuerte . . . . . . . . . . . . 72
2.5. Conversiones y genéricos . . . . . . . . . . . . . . . . . . . . . 73
2.5.1. Conversiones para objetos . . . . . . . . . . . . . . . . 73
2.5.2. Genéricos . . . . . . . . . . . . . . . . . . . . . . . . . 78
3. Arreglos, listas enlazadas y recurrencia 83

3.1. Que son las estructuras de datos . . . . . . . . . . . . . . . . . 83
3.1.1. Generalidades de las Estructuras de Datos . . . . . . . 83
3.2. Arreglos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 85
3.2.1. Guardar entradas de juego en un arreglo . . . . . . . . 85
3.2.2. Ordenar un arreglo . . . . . . . . . . . . . . . . . . . . 92
3.2.3. Métodos para arreglos y números aleatorios . . . . . . 95
3.2.4. Arreglos bidimensionales y juegos de posición . . . . . 101
3.3. Listas simples enlazadas . . . . . . . . . . . . . . . . . . . . . 106
3.3.1. Inserción en una lista simple enlazada . . . . . . . . . . 108
3.3.2. Quitar un elemento de una lista simple enlazada . . . . 110
3.4. Listas doblemente enlazadas . . . . . . . . . . . . . . . . . . . 111
3.4.1. Inserción en el centro de la LDE . . . . . . . . . . . . . 114
3.4.2. Remoción en el centro de la LDE . . . . . . . . . . . . 115
3.4.3. Una implementación . . . . . . . . . . . . . . . . . . . 116
3.5. Listas circulares y ordenamiento . . . . . . . . . . . . . . . . . 119
3.5.1. Lista circular enlazada . . . . . . . . . . . . . . . . . . 119
3.5.2. Ordenar una LDE . . . . . . . . . . . . . . . . . . . . . 124
3.6. Recurrencia . . . . . . . . . . . . . . . . . . . . . . . . . . . . 124
3.6.1. Recurrencia binaria . . . . . . . . . . . . . . . . . . . . 132
3.6.2. Recurrencia múltiple . . . . . . . . . . . . . . . . . . . 135
4. Herramientas de análisis 139

4.1. Funciones . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 139
4.1.1. La función constante . . . . . . . . . . . . . . . . . . . 139
4.1.2. La función logarı́tmica . . . . . . . . . . . . . . . . . . 140
4 ÍNDICE GENERAL
4.1.3. La función lineal . . . . . . . . . . . . . . . . . . . . . 141

4.1.4. La funcion N-Log-N . . . . . . . . . . . . . . . . . . . 141
4.1.5. La función cuadrática . . . . . . . . . . . . . . . . . . . 141
4.1.6. La función cúbica y otras polinomiales . . . . . . . . . 142
4.1.7. La función exponencial . . . . . . . . . . . . . . . . . . 144
4.1.8. Relaciones de crecimiento . . . . . . . . . . . . . . . . 146
4.2. Análisis de algoritmos . . . . . . . . . . . . . . . . . . . . . . 147
4.2.1. Estudios experimentales . . . . . . . . . . . . . . . . . 148
4.2.2. Operaciones primitivas . . . . . . . . . . . . . . . . . . 150
4.2.3. Notación asintótica . . . . . . . . . . . . . . . . . . . . 152
4.2.4. Análisis asintótico . . . . . . . . . . . . . . . . . . . . . 156
4.2.5. Uso de la notación O-grande . . . . . . . . . . . . . . . 158
4.2.6. Algoritmo recursivo para calcular potencias . . . . . . 162
5. Pilas y colas 165

5.1. Pilas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 165
5.1.1. El tipo de dato abstracto pila . . . . . . . . . . . . . . 165
5.1.2. Implementación de una pila usando un arreglo . . . . . 168
5.1.3. Implementación de una pila usando lista simple . . . . 173
5.1.4. Invertir un arreglo con una pila . . . . . . . . . . . . . 176
5.1.5. Aparear paréntesis y etiquetas HTML . . . . . . . . . . 177
5.2. Colas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 181
5.2.1. Tipo de dato abstracto cola . . . . . . . . . . . . . . . 182
5.2.2. Implementación simple de la cola con un arreglo . . . . 185
5.2.3. Implementación con una lista enlazada . . . . . . . . . 188
5.2.4. Planificador Round Robin . . . . . . . . . . . . . . . . 189
5.3. Colas con doble terminación . . . . . . . . . . . . . . . . . . . 191
5.3.1. Tipo de dato abstracto deque . . . . . . . . . . . . . . 191
5.3.2. Implementación de una deque . . . . . . . . . . . . . . 192
6. Listas e Iteradores 197

6.1. Lista arreglo . . . . . . . . . . . . . . . . . . . . . . . . . . . . 197
6.1.1. El tipo de dato abstracto lista arreglo . . . . . . . . . . 198
6.1.2. Patrón de diseño adaptador . . . . . . . . . . . . . . . 199
6.1.3. Implementación simple con un arreglo . . . . . . . . . 199
6.1.4. Interfaz ListaIndice y la clase java.util.ArrayList 202
6.1.5. Lista arreglo usando un arreglo extendible . . . . . . . 203
6.2. Listas nodo . . . . . . . . . . . . . . . . . . . . . . . . . . . . 207
ÍNDICE GENERAL 5
6.2.1. Operaciones basadas en nodos . . . . . . . . . . . . . . 208

6.2.2. Posiciones . . . . . . . . . . . . . . . . . . . . . . . . . 208
6.2.3. El tipo de dato abstracto lista nodo . . . . . . . . . . . 209
6.2.4. Implementación con lista doblemente enlazada . . . . . 213
6.3. Iteradores . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 221
6.3.1. Tipos de dato abstracto Iterador e Iterable . . . . . . . 221
6.3.2. El ciclo for-each . . . . . . . . . . . . . . . . . . . . . . 222
6.3.3. Implementación de los iteradores . . . . . . . . . . . . 224
6.3.4. Iteradores lista en Java . . . . . . . . . . . . . . . . . . 226
6.4. ADT listas y el marco de colecciones . . . . . . . . . . . . . . 227
6.4.1. Listas en el marco de colecciones Java . . . . . . . . . 228
6.4.2. Secuencias . . . . . . . . . . . . . . . . . . . . . . . . . 232
6.5. Ejemplo: Heurı́stica mover al frente . . . . . . . . . . . . . . . 235
6.5.1. Implementación con una lista ordenada y una clase
anidada . . . . . . . . . . . . . . . . . . . . . . . . . . 235
6.5.2. Lista con heurı́stica mover al frente . . . . . . . . . . . 237
7. Árboles 243
7.1. Árboles generales . . . . . . . . . . . . . . . . . . . . . . . . . 243
7.1.1. Definiciones de árboles y propiedades . . . . . . . . . . 243
7.1.2. El tipo de dato abstracto árbol . . . . . . . . . . . . . 247
7.1.3. Interfaz del ADT árbol . . . . . . . . . . . . . . . . . . 248
7.2. Algoritmos de recorrido para árboles . . . . . . . . . . . . . . 251
7.2.1. Profundidad y altura . . . . . . . . . . . . . . . . . . . 251
7.2.2. Recorrido en preorden . . . . . . . . . . . . . . . . . . 254
7.2.3. Recorrido en postorden . . . . . . . . . . . . . . . . . . 257
7.3. Árboles Binarios . . . . . . . . . . . . . . . . . . . . . . . . . 260
7.3.1. El ADT árbol binario . . . . . . . . . . . . . . . . . . . 262
7.3.2. Una interfaz árbol binario en Java . . . . . . . . . . . . 263
7.3.3. Propiedades del árbol binario . . . . . . . . . . . . . . 264
7.3.4. Una estructura enlazada para árboles binarios . . . . . 266
7.3.5. Árbol binario con lista arreglo . . . . . . . . . . . . . . 275
7.3.6. Recorrido de árboles binarios . . . . . . . . . . . . . . 278
7.3.7. Plantilla método patrón . . . . . . . . . . . . . . . . . 286
6 ÍNDICE GENERAL
Capı́tulo 1
Introducción
1.1. Clases, tipos, y objetos

Para la construcción de estructuras de datos y algoritmos se necesitan
dar instrucciones precisar a la computadora, lo cual se puede lograr usando
un lenguaje de computadora de alto nivel, como Java. Se presenta en este
capı́tulo un repaso breve de los elementos usados en Java y en el siguiente
capı́tulo se repasan los principios del diseño orientado al objeto. No se da
una descripción completa del lenguaje Java porque hay algunos aspectos
importantes que no son relevantes en el diseño de estructuras de datos.
Los programas en Java manipulan objetos. Los objetos guardan datos y
dan métodos para acceder y modificar sus datos. Cada objeto es una instancia
de una clase, la cual define el tipo del objeto, y las operaciones que realiza.
Los miembros importantes de una clase en Java son los siguientes:
Datos de objetos Java son guardados en variables de instancia, o

campos. Por lo tanto, si un objeto de alguna clase es para guardar
datos, entonces la clase debe especificar variables de instancia para
guardar. Las variables de instancia pueden ser tipos base, como enteros,
números punto flotante, o booleanos, o ser referencias a objeto de otras
clases.
Las operaciones que se pueden realizar con los datos son llamados
métodos. Estos consisten de constructores, procedimientos, y funciones.
Los cuales definen el comportamiento de los objetos de esa clase.
8 Introducción
Declaración de una clase
Un objeto es una combinación especı́fica de datos y métodos que pueden

procesar y comunicar esos datos. Las clases definen los tipos para los objetos:
por lo tanto, los objetos son en ocasiones referidos como instancias de su clase
definidora, porque toman el nombre de esa clase como su tipo.
Un ejemplo de la definición de una clase Java se muestra en el listado 1.1
con la clase Contador.
1 public class Contador {

2 private int cuenta ; // una variable entera de instancia
3 /* * El constructor por defecto para un objeto Contador */
4 Contador () { cuenta = 0; }
5 /* * Un m é todo accesor para obtener el valor actual */
6 public int getCuenta () { return cuenta ; }
7 /* * Un m é todo modificador para incrementar la cuenta */
8 public void i n c r e m e n t aC u e n t a () { ++ cuenta ; }
9 /* * Un m é todo modificador para decrementar la cuenta */
10 public void d e c r e m e n t a C u e n t a () { -- cuenta ; }
11 }
Listado 1.1: Clase Contador usada para llevar una cuenta simple, la cual puede ser
accesada, incrementada y decrementada
La definición de la clase está delimitada por llaves, se usa “{” para marcar
el inicio y “}” para marcar el final. Cualquier conjunto de sentencias entre
llaves definen un bloque de programa.
La clase Contador es una clase pública, por lo tanto cualquier otra clase
puede crear y usar un objeto Contador. La clase Contador tiene una variable
entera de instancia llamada cuenta. La variable es inicializada a cero en
el método constructor, Contador, el cual es llamado cuando se crea un
nuevo objeto Contador. La clase tiene un método accesor, getCuenta(),
el cual devuelve el valor actual del contador. También tiene dos métodos
actualizadores, incrementaCuenta() y decrementaCuenta(). Esta clase no
tiene método main() y por lo tanto no hace nada por sı́ misma.
El nombre de una clase, método, o variable en Java es llamado un identifi-
cador, el cual puede ser cualquier cadena de caracteres de tamaño arbitrario,
debiendo iniciar con una letra seguida de letras, números, y guiones bajos,
siendo letra y número de cualquier lenguaje escrito definido en el conjunto de
caracteres Unicode. La excepciones a la regla anterior son los identificadores
Java del cuadro 1.1.
1.1 Clases, tipos, y objetos 9
abstract default goto package this

assert do if private throws
boolean double implements protected throws
break else import public transient
byte enum instanceof return true
case extends int short try
catch false interface static void
char final long strictfp volatile
class finally native super while
const float new switch
continue for null synchronized
Cuadro 1.1: Lista de palabras reservadas en Java, por lo que no pueden ser usadas
como nombres de variables o métodos.
Modificadores de clase
Los modificadores de clase son palabras reservadas opcionales que
preceden a la palabra reservada class. Los diferentes modificadores de clase
y su significado son los siguientes:
abstract indica que una clase tiene métodos abstractos. Los métodos
abstractos son declarados con la palabra reservada abstract y están
vacı́os, es decir, no tienen un bloque definiendo un cuerpo de código
para el método. Una clase abstract usualmente tiene una combinación
de métodos abstractos y métodos concretos. Lo anterior se aborda en la
sección 2.4.
final indica una clase que no puede tener subclases o ser extendida.
public indica una clase que puede ser instanciada por cualquiera en
el mismo paquete, o por cualquiera que importe la clase. Las clases
públicas son declaradas en su propio archivo separado teniendo el mismo
nombre de la clase y terminación .java.
Cuando no se usa el modificador del clase public, la clase se considera
amigable. Esto significa que puede ser usada e instanciada por todas
las clases en el mismo paquete. Este es el modificador de clase por
defecto.
10 Introducción
1.1.1. Tipos base

Los tipos de los objetos están determinados por la clase de la cual vienen.
Para propósitos de eficiencia y simplicidad, Java también tiene los siguientes
tipos base, o tipos primitivos, los cuales no son objetos:
Tipo base Descripción
boolean Valor booleano: true o false
char Carácter Unicode de 2 bytes
byte Entero con signo en complemento a dos de 1 byte
short Entero con signo en complemento a dos de 2 bytes
int Entero con signo en complemento a dos de 4 bytes
long Entero con signo en complemento a dos de 8 bytes
float Número de punto flotante 4 bytes (IEEE 754-1985)
double Número de punto flotante 8 bytes (IEEE 754-1985)
Alguna variable teniendo uno de estos tipos guarda un valor de ese tipo, en
vez de una referencia a algún objeto. Las constantes enteras, como 18 o -255,
son de tipo int, a menos que vayan seguidos inmediatamente por una ‘L’ o ‘l’,
siendo en tal caso del tipo long. Constantes de punto flotante, como 3.1416 o
2.78e5, son de tipo double, a menos que vayan seguidos inmediatamente por
una ‘F’ o ‘f’, siendo en tal caso del tipo float. Se muestra en el listado 1.2
una clase sencilla, Base, que define tipos base como variables locales para el
método main().
Comentarios
Los comentarios son anotaciones para los lectores humanos y no son
procesados por el compilador Java. Java permite dos tipos de comentarios,
comentarios de bloque y comentarios en lı́nea, los cuales definen el texto
ignorado por el compilador. Un comentario de bloque inicia con “/*” y se
cierra con “*/”. Un comentario que inicia con “/**” es usado por el programa
javadoc, para generar la documentación del software.
Se usa también “//” para iniciar comentarios en lı́nea y se ignora todo
hasta el final de la lı́nea.
1.1.2. Objetos
Un nuevo objeto es creado usando el operador new. Este operador crea
un objeto nuevo de una clase especificada y devuelve una referencia a ese
1 public class Base {

2 public static void main ( String [] args ) {
3 boolean bandera = true ;
4 char c = ’z ’;
5 byte b = -127;
6 short s = 32000;
7 int i = 12345;
8 long l = 6789 L ;
9 float f = 3.1416 f ;
10 double d = 2.1232 e8 ;
11 System . out . println ( " bandera = " + bandera ); // + operador concatenaci ó n
12 System . out . println ( " c = " + c );
13 System . out . println ( " b = " + b );
14 System . out . println ( " s = " + s );
15 System . out . println ( " i = " + i );
16 System . out . println ( " l = " + l );
17 System . out . println ( " f = " + f );
18 System . out . println ( " d = " + d );
19 }
20 }
Listado 1.2: La clase Base muestra ejemplos de uso de tipos base.
objeto. Enseguida inmediatamente del operador new se pone una llamada al

constructor para ese tipo de objeto. Cualquier constructor que esté incluido
en la definición de la clase se puede usar. En las lı́neas 4 y 5 de la de la clase
Ejemplo, listado 1.3, se muestra el uso del operador new para crear objetos y
asignar la referencia a esos objetos a una variable.
1 public class Ejemplo {

3 Contador c ; // declaraci ó n de la variable c del tipo Contador
4 Contador d = new Contador (); // declaraci { on y creaci ó n
5 c = new Contador (); // se crea un objeto Contador , devolviendo una ref .
6 d = c ; // la referencia de c se asigna a d
7 }
8 }
Listado 1.3: Ejemplos de uso del operador new.
Al usar el operador new con algún tipo de clase, se suceden los siguientes
tres eventos:
Un nuevo objeto es asignado dinámicamente en memoria, y todas sus
variables de instancia son inicializadas a valores por defecto. El valor
por defecto para las variables objeto es null y para todos los tipos base
es cero, excepto las variables booleanas, puestas a false.
12 Introducción
El constructor para el nuevo objeto es llamado con los parámetros

indicados.
Después que el constructor termina, el operador new devuelve una

referencia, o dirección de memoria, para el objeto nuevo creado. Si la
expresión está en la forma de una sentencia de asignación, entonces su
dirección se guarda en la variable objeto, ası́ la variable objeto se refiere
al objeto nuevo creado.
Objetos número
Cuando se requiere guardar números como objetos, se pueden usar las
clases envoltura de Java. A estas se les conoce como clases número y hay
una clase número por cada tipo base.
El cuadro 1.2 muestra los tipos base numéricos y su correspondiente clase
numérica. Desde Java 5, una operación de creación es realizada automática-
mente en cualquier momento que se pasa un número base a un método que
espera un objeto. De igual forma, el método accesor correspondiente es usado
automáticamente cada vez que se quiere asignar el valor de objeto Number a
un tipo base numérico.
Tipo Nombre Ejemplo Ejemplo

base de la clase de creación de acceso
byte Byte n=new ((byte)1); n.byteValue()
short Short n=new ((short)1); n.shortValue()
int Integer n=new (1); n.intValue()
long Long n=new (1L); n.longValue()
float Float n=new Floate(3.9F); n.floatValue()
double Double n=new Double(3.9); n.doubleValue()
Cuadro 1.2: Clases número de Java. Cada clase está dada con su correspondiente
tipo base y ejemplos para crear y acceder tales objetos.
Objetos String
Una cadena es una secuencia de caracteres que provienen de algún alfa-
beto, el conjunto de todos los posibles caracteres. Cada carácter c que forma
una cadena s puede ser referenciado por su ı́ndice en la cadena, que es la

cantidad de caracteres que están antes de c en s, ası́ el primer carácter tiene
ı́ndice cero. El alfabeto usado para definir cadenas es el conjunto de caracteres
internacional Unicode, una codificación de caracteres de 2 bytes que cubre la
mayorı́a de los lenguajes escritos. Java define una clase especial incorporada
de objetos llamados objetos String. Las cadenas literales en Java debe ser
encerradas entre comillas dobles.
Concatenación
El procesamiento de cadenas requiere manejar cadenas. La operación
primaria para combinar cadenas es llamada concatenación, la cual toma
una cadena p y una cadena q y las combina en una nueva cadena, indicada por
p + q, la cual consiste de todos los caracteres de p seguidos de los caracteres
de q. En Java, la operación de concatenación funciona como se indica en la
descripción. Ası́ es legal en Java escribir una sentencia de asignación como
String s = "fut" + "bol";
La sentencia define una variable s que refiere un objeto de clase String,

y le asigna la cadena "futbol". En Java se asume que cada objeto tiene un
método incorporado toString() que devuelve una cadena asociada con el
objeto.
Referencias a objetos
Crear un nuevo objeto involucra el uso del operador new para asignar el
espacio de memoria del objeto y usar el constructor del objeto para inicializar
este espacio. La localidad, o dirección, de este espacio, generalmente, es luego
asignado a una variable referencia. Por lo tanto, una variable de referencia
puede ser vista como un “apuntador” a algún objeto. Es como si la variable
fuera un contenedor para un control remoto que puede ser usado para manejar
el objeto nuevo creado. La variable tiene una forma de apuntar al objeto y
pedir que haga cosas o de acceso a sus datos.
El operador punto
Cada variable referencia objeto deberá referirse a algún objeto, a menos
que esta sea null, en tal caso no apunta a nada.
14 Introducción
Puede haber varias referencias al mismo objeto, y cada referencia a un

objeto especı́fico puede ser usada para llamar métodos en ese objeto. Si se
usa una variable referencia objeto para cambiar el estado del objeto, entonces
su estado cambia para todas las referencias a este. Este comportamiento se
da por el hecho de que todas las referencias apuntan al mismo objeto.
Uno de los usos primarios de una variable referencia objeto es para acceder
los miembros de la clase para este objeto, una instancia de su clase. Esto es,
una variable referencia objeto es útil para acceder los métodos y las variables
instancias asociadas con un objeto. Este acceso es realizado con el operador
punto (“.”). Se llama a un método asociado con un objeto usando el nombre
de la variable referencia, seguida por el operador punto y luego el nombre del
método y sus parámetros.
Si hay varios métodos definidos con el mismo nombre para el objeto,
entonces el sistema de ejecución Java usa el que empate en la cantidad de
parámetros y esté más cercano a sus tipos respectivos. Un nombre de método
combinado con la cantidad y los tipos de sus parámetros es llamado la firma
del método. Cuando se hace la llamada a cierto método se usa la firma para
determinar el método actual a usar. Considerar los siguientes ejemplos:
estufa.cocinaCena();
estufa.cocinaCena(comida);
estufa.cocinaCena(comida,temporada);
Cada una de las llamadas a métodos se refiere a un método diferente

con el mismo nombre definido en la clase a la cual pertenece estufa. Sin
embargo, la firma de un método en Java no incluye el tipo que regresa el
método, ası́ Java no permite dos métodos con la misma firma para regresar
tipos diferentes.
Variables de instancia
Las clases de Java pueden definir variables de instancia, las cuales son
llamadas también campos. Estas variables representan los datos asociados
con los objetos de una clase. Las variables de instancia deberán tener un
tipo, el cual puede ser un tipo base, tal como int, long, double, o un tipo
referencia, esto es, una clase, tal como un String, una interfaz, o un arreglo.
Dada una variable referencia v, la cual apunta a un objeto o, se puede
acceder cualquier variable de instancia para o que las reglas de acceso lo
permitan. Por ejemplo, las variables de instancia public son accesibles para
todos. Usando el operador punto se puede acceder y poner el valor de tales

variables de instancia. Por ejemplo, si estudiante se refiere a un objeto
Estudiante que tiene variables de instancia públicas llamadas nombre y
edad, entonces las siguientes sentencias son permitidas:
estudiante.nombre = "Enrique";
estudiante.edad = 18;
Una referencia objeto no tiene que ser solamente una variable de referencia.
También puede ser cualquier expresión que devuelva una referencia objeto.
Modificadores de variables
Cuando se declara una variable de instancia se puede opcionalmente definir
un modificador de variable seguido por el tipo de la variable y el identificador
que será usado para la variable. Adicionalmente, se puede opcionalmente
asignar un valor inicial a la variable con el operador de asignación “=”. Las
reglas para un nombre de variable son las misma que para cualquier otro
identificador. El parámetro del tipo de la variable puede ser un tipo base,
indicando que guarda valores de ese tipo, o un nombre de clase, indicando
que guarda una referencia a un objeto de esa clase. El valor inicial opcional
que se podrı́a asignar a una variable de instancia deberá empatar el tipo de la
variable. La clase Duende tiene varias definiciones de variables de instancias,
mostrado en el listado 1.4. Las variables edad, magico, y estatura son tipos
base, la variable nombre es una referencia a una instancia de la clase String,
y la variable amigoDuende es una referencia a un objeto de la clase que se
define. Los valores constantes asociados con una clase deberán ser siempre
declarados como static y final, como lo es la “variable” ESTATURA MAX.
El alcance, o visibilidad, de variables de instancia puede ser cambiado
como se muestra en la siguiente tabla:
Niveles de acceso
Modificador Clase Paquete Subclase Resto
public S S S S
protected S S S N
sin modificador S S N N
private S N N N
Además de los modificadores de variable de alcance, también están los
siguientes modificadores:
16 Introducción
1 public class Duende {

2 // variables de instancia
3 public String nombre ;
4 public int edad ;
5 public Duende amigoDuende ;
6 private boolean magico = false ;
7 protected double estatura = 85;
8 public static final int ESTATURA_MAX = 100;
9 // constructores
10 Duende ( String n , int e , Duende a , double est ) { // parametrizado compl
11 nombre = n ;
12 edad = e ;
13 amigoDuende = a ;
14 estatura = est ;
15 }
16 Duende () { // constructor por defecto
17 nombre = " Puck " ;
18 edad = 128;
19 amigoDuende = null ;
20 estatura = 95;
21 }
22 // m é todos
23 public static void hacerRey ( Duende d ) {
24 d . nombre = " Rey " + d . getNombreReal ();
25 d . magico = true ;
26 }
27 public void hacerRey () {
28 nombre = " Rey " + getNombreReal ();
29 magico = true ;
30 }
31 public boolean esMagico () { return magico ; }
32 public void setEstatura ( int nvaEst ) { estatura = nvaEst ; }
33 public String getNombre () { return " ¡ No te lo dir é ! " ; }
34 public String getNombreReal () { return nombre ; }
35 public void renombrar ( String s ) { nombre = s ; }
36 }
Listado 1.4: La clase Duende

1.2 Métodos 17
1. static. Se usa para declarar que una variable que está asociada con la
clase, no con instancias individuales de esa clase. Las varibles static
son usadas para guardar información global de la clase y existen aún si
no se han creado instancias de la clase.
2. final. Una variable de instancia final es una a la que se le debe asignar

un valor inicial, y entonces nunca puede se puede asignar un nuevo
valor. Si esta es un tipo base, entonces es una constante. Si una variable
objeto es final, entonces siempre se referirá al mismo objeto (aún si el
objeto cambia su estado interno).
1.1.3. Tipo enum

Desde Java 5 se soportan tipos enumerados, llamados enum. Estos son
tipos a los cuales se les permite tomar solo valores dados de un conjunto
especificado de nombres. Estos pueden ser declarados dentro de una clase
como sigue:
[modificador] enum nombre { nombre valor0, nombre valor1, ...};
donde el modificador es opcional, o puede ser public, protected, o private.

El nombre es cualquier identificador legal de Java. Cada uno de los valores
identificadores es el nombre de un valor posible que variables de este tipo enum
puede tomar. Cada uno de estos nombre valor puede ser cualquier identificador
Java, pero por convención estos deberán ser palabras en mayúsculas.
El tipo enum definido se puede usar para definir otras variables, como si
fuera el nombre de una clase. Los tipos enum tiene unos cuantos métodos
incorporados, como el método valueOf() que devuelve el valor enum que
corresponde con la cadena dada. Se muestra en la clase DiaCurso, listado 1.5,
el uso de un tipo enum.
1.2. Métodos
Los métodos en Java son conceptualmente similares a funciones y procedi-
mientos en otro lenguajes de programación de alto nivel. Son lı́neas de código
que son llamadas para un objeto particular de alguna clase. Los métodos
pueden aceptar parámetros como argumentos y entonces el comportamiento
dependerá de estos y del objeto. Cada método es indicado en el cuerpo de
18 Introducción
1 public class DiaCurso {

2 public enum Dia { LUN , MAR , MIE , JUE , VIE , SAB , DOM };
4 Dia d = Dia . LUN ;
5 System . out . println ( " Inicialmente d es " + d );
6 d = Dia . VIE ;
7 System . out . println ( " Ahora es " + d );
8 Dia o = Dia . valueOf ( " VIE " );
9 System . out . println ( " ¿ Son d y t lo mismo ? " +( d == o ));
10 }
11 }
Listado 1.5: Un ejemplo del uso del tipo enum
alguna clase. La definición de un método tiene dos partes: la firma, la cual

define el nombre y los parámetros del método, y el cuerpo, el cual define lo
que el método hace.
Un método permite al programador mandar un mensaje a un objeto. La
firma del método indica como un mensaje deberá parecer y el cuerpo del
método indica que hará el objeto cuando reciba tal mensaje.
Declaración de métodos
La sintaxis para definir un método es:
[modificadores] tipo nombre(tipo0 parámetro0, tipo1 parámetro1, . . . ){
// cuerpo del método ...
}
Los modificadores incluyen los mismos tipos de los modificadores de alcance
usados para variables, como public, protected, y static, con significado
similar. El tipo de la declaración define el tipo devuelto por el método. El
nombre es cualquier identificador Java válido. La lista de parámetros y sus
tipos declaran variables locales que corresponden a valores que son pasados
como argumentos al método. Cada declaración tipo puede ser cualquier tipo
Java y cada parámetro es un identificador Java. La lista de parámetros y
sus tipos puede estar vacı́a, por lo cual no se pasan valores al método al ser
llamado. Las variables parámetro, al igual que las variables de instancia de la
clase, pueden ser usadas dentro del cuerpo del método. De igual forma, otros
métodos de esta clase pueden ser llamados desde el cuerpo de un método.
Cuando un método de una clase es llamado, se invoca con una instancia
particular de esa clase y puede cambiar el estado de ese objeto, excepto para
1.2 Métodos 19
un método static, el cual está asociado con la propia clase. Al invocar el

método renombrar() de la clase Duende, listado 1.4, cambia su nombre.
Modificadores de método
Al igual que las variables de instancia, los modificadores de método pueden
restringir el alcance de un método:
1. public. Cualquiera puede llamar al método.
2. protected. Sólo métodos del mismo paquete o de sus subclases pueden

llamar al método.
3. private. Sólo métodos de la misma clase pueden llamar.
4. Si ninguno de los anteriores modificadores es usado, el método es ami-

gable, por lo que puede ser llamado por objetos de clases en el mismo
paquete.
Los modificadores anteriores podrı́an ser seguidos por los modificadores

adicionales:
1. abstract. Un método declarado como abstracto no tiene código. La

firma de tal método está seguida por un punto y coma sin cuerpo del
método. Por ejemplo:
public abstract void setEstatura( double nvaEst );
Los métodos abstractos pueden aparecer sólo en clases abstractas. Se

revisa su utilidad en la sección 2.4.
2. final. El método no puede ser anulado por una subclase.
3. static. El método está asociado con la propia clase, y no con alguna

instancia particular de la clase. Estos métodos pueden ser usados para
cambiar el estado de variables estáticas asociadas a la clase, siempre y
cuando estas no sean final.
20 Introducción
Tipos devueltos
Una definición de método deberá indicar el tipo de valor que el método

regresará. Si el método no regresa un valor, entonces se debe usar la palabra
reservada void. Si el tipo devuelto es void, el método es llamado un procedi-
miento; de otra forma, es llamado una función. Para regresar un valor en Java,
un método deberá usar la palabra reservada return y una expresión, la cual
debe empatar con el tipo regresado por el método. En el método esMagico()
de la clase Duende, listado 1.4 se devuelve un valor usando return. Tan
pronto como return es ejecutado, el método termina.
Las funciones Java pueden devolver sólo un valor. Para regresar valores
múltiples se deberán combinar todos los valores que se quieran devolver en un
objeto compuesto, cuyas variables de instancia incluirán todos los valores
que se quieran devolver, y luego regresar una referencia al objeto compuesto.
Además, se puede cambiar el estado interno de un objeto que es pasado a un
método como otra forma de “devolver” resultados múltiples.
Parámetros
Los parámetros de un método están definidos en una lista separada por

comas y encerrada entre paréntesis después del nombre del método. Un
parámetro consiste de dos partes, el tipo y el nombre. Si un método no tiene
parámetros, entonces solo un par de paréntesis vacı́os es usado.
Todos los parámetros en Java son pasados por valor, es decir, cuando se
pasa un parámetro a un método, una copia de ese parámetro es hecha para
ser usada dentro del cuerpo del método. El método puede cambiar la copia
pero no el original. Si se pasa una referencia objeto como un parámetro a un
método, entonces la referencia también es copiada. Cambiando la referencia
interna dentro de un método no cambiará la referencia que fue pasada. Por
ejemplo si se pasa una referencia Duende x a un método que llame a este
parámetro d, entonces el método puede cambiar la referencia d para que
apunte a un objeto diferente, pero x seguirá refiriéndose al mismo objeto. Por
supuesto, el método puede usar la referencia d para cambiar el estado interno
del objeto, y esto también cambiará al objeto de x, ya que ambos apuntan al
mismo objeto. Esto último se hace en el método de clase hacerRey(Duende)
de la clase Duende, listado 1.4.
1.2 Métodos 21
Constructores
Un constructor es un tipo especial de método usado para inicializar
objetos nuevos creados. Java tiene una forma particular para declarar el
constructor y una forma especial para llamar al constructor. La sintaxis para
declarar un constructor es:
[modificadores] nombre(tipo0 parámetro0, tipo1 parámetro1, . . . ){

// cuerpo del constructor ...
}
La sintaxis es casi la misma que para el método, excepto que el nombre del
constructor deberá ser el mismo nombre de la clase que construye, y además no
se indica que tipo devuelve, ya que su tipo devuelto es implı́citamente el mismo
que su nombre. Los modificadores del constructor siguen las mismas reglas
que los métodos, excepto que abstract, static y final no se permiten.
El constructor para una clase Camaron podrı́a ser el siguiente:
public Camaron(int p, String n) {

peso = p;
nombre = n;
}
Definición del constructor e invocación

El cuerpo de un constructor es como el cuerpo de un método, con el
siguiente par de excepciones menores. Una es el encadenado del constructor y
la otra es la prohibición del uso de la sentencia return.
Los constructores son invocados en una forma única: deberán ser llamados
con el operador new. Cuando se invoca una nueva instancia de la clase es
automáticamente creada y entonces su constructor es llamado para inicializar
sus variables de instancia y realizar otras tareas de configuración. Por ejemplo
considerar la siguiente llamada al constructor y declaracion de la variable
miCamaron:
Camaron miCamaron = new Camaron(50,"Popeye");
Una clase puede tener varios constructores, pero cada uno deberá tener
una firma diferente, es decir, cada uno deberá distinguirse por el tipo y la
cantidad de parámetros que toma.
22 Introducción
Método main()
Algunas clases en Java son diseñadas para ser usadas por otras clases,
otras son programas independientes. Las clases que definen programas inde-
pendientes deberán contener un tipo especial de método, el método main().
Cuando se quiere ejecutar una programa Java independiente, se refiere el
nombre de la clase que define el programa precedido del siguiente comando:
java Acuario
En este caso, el sistema de ejecución Java busca una versión compilada de

la clase Acuario, y luego llama al método especial main en esa clase. Este
método se debe declarar como sigue:
public static void main(String[] args) {

// cuerpo del método main
}
Los argumentos pasados como los parámetros args al método main() son
los argumentos lı́nea de comandos dados cuando el programa es ejecutado.
La variable args es un arreglo de objetos String, es decir, una colección
de cadenas indizadas, con la primera cadena siendo args[0], la segunda
args[1], etc.
Bloques de sentencias y variables locales

El cuerpo de un método es un bloque de sentencias, el cual es una
secuencia de sentencias y declaraciones entre las llaves “{” y “}”. Los cuerpos
de los métodos y otros bloques de sentencias pueden tener bloques anidados
dentro de ellos. Los bloques de sentencias pueden contener declaraciones
de variables locales. Estas variables son declaradas dentro del cuerpo de
sentencias, generalmente al inicio, pero dentro de las llaves. Las variables
locales son similares a variables de instancia, pero sólo existen mientras el
bloque de sentencias está siendo ejecutado. Tan pronto como el flujo del
programa sale del bloque, todas las variables locales dentro de este no pueden
ser referenciadas más. Una variable local puede ser un tipo base, como int,
float, o double, o una referencia a una instancia de alguna clase. Las
sentencias y declaraciones son siempre terminadas con punto y coma.
Hay dos formas de declarar variables locales:
1.3 Expresiones 23
tipo nombre;
tipo nombre = valor inicial;
La primera declaración solo define el identificador, nombre, para ser de

tipo especificado. La segunda define el identificador, su tipo, e inicializa la
variable al valor inidicado. Enseguida están algunos ejemplos de declaraciones
de variables locales:
{
double r;
Punto p1 = new Punto(1, 2);
Punto p2 = new Punto(5, 6);
int i = 1024;
double e = 2.71828;
}
1.3. Expresiones
Las variables y constantes son usadas en expresiones para definir nuevos
valores y para modificar variables. Las expresiones involucran el uso de literales,
variables, y operadores.
1.3.1. Literales
Una literal es cualquier valor “constante” que puede ser usado en una
asignación u otra expresión. Java permite los siguientes tipos de literales:
La referencia objeto null. Es la única literal objeto y se permite usar

con cualquier tipo de referencia.
Las constantes booleanas true y false.
Entero. El tipo por defecto para un entero como 176, o -12 es int, el
cual es un entero de 4 bytes. Una literal entera long debe terminar con
“L” o “l”, como 176L, o -12l, y define un entero de 8 bytes.
Punto flotante. El tipo por defecto para un punto flotante, como 3.1416
y -432.1 es double. Para indicar una literal como float, esta debe
terminar con “F” o “f”. Literales punto flotante en notación cientı́fica
24 Introducción
también son permitidas, tal como 3.14E5 o -0.19e8. La “E” o “e” indica
por diez elevado a la potencia, del mismo modo que una calculadora.
Carácter. Las constantes carácter son tomadas del alfabeto Unicode.
Un carácter está definido como un sı́mbolo individual encerrado entre
comillas simples. Por ejemplo, ’a’ y ’?’ son caracteres constantes.
Además Java define las constantes carácter especial siguientes:
’\n’ nueva lı́nea ’\t’ tabulador

’\b’ retroceso ’\r’ retorno
’\f’ avance forma ’\\’ diagonal invertida
’\’’ comilla simple ’\”’ comilla doble
Cadena. Una cadena literal es una secuencia de caracteres encerrados

con comillas dobles. Por ejemplo, la siguiente es una literal de cadena:
"Monarcas permanecerá en primera división"
1.3.2. Operadores
Las expresiones Java involucran componer literales y variables con opera-
dores.
Operador de asignación
El operador de asignación es “=”. Es usado para asignar un valor, prin-
cipalmente, a una variable de instancia o variable local. Su sintaxis es la
siguiente:
variable = expresión;
donde variable refiere a una variable que es permitida ser referenciada por el
bloque conteniendo la expresión. El valor de una operación es el valor de la
expresión que fue asignada. Por ejemplo, si i y j son ambas declaradas del
tipo int, es correcto tener una sentencia de asignación como:
i = j = 25;
La asignación anterior funciona ya que los operadores de asignación son
evaluados de derecha a izquierda.
1.3 Expresiones 25
Operadores aritméticos
Los siguientes son los operadores aritméticos binarios en Java:
+ adición
− sustracción
∗ multiplicación
/ división
% módulo
El operador módulo también es conocido como el operador “residuo”,
porque es el residuo sobrante después de realizar la división entera.
Java también proporciona un menos unario (−), el cual puede ser colocado
antes de la expresión aritmética para invertir su signo. Los paréntesis pueden
ser usados en cualquier expresión para definir el orden de evaluación. Java usa
reglas de precedencia de operadores para determinar el orden de evaluación
cuando los paréntesis no son usados.
Java proporciona los operadores incremento en uno (++) y decremento
en uno (−−). Si los operadores son usados antes de la variable, entonces uno
es agregado, o sustraido de, la variable y su valor es leido en la expresión. Si
es usado después de una variable, entonces el valor es primero leido y luego la
variable es incrementada o decrementada en uno. Por ejemplo, el fragmento
de código
int i = 20;
int j = i++;
int k = ++i;
int m = i--;
int n = 9 + i++;
asigna 20 a j, 22 a k, 22 a m, 30 a n, y deja i con 22.
Operadores lógicos
Java permite los operadores de comparación estándar entre números:
< menor que
<= menor que o igual a
> mayor que
>= mayor que o igual a
== igual a
!= no igual a
26 Introducción
Los operadores == y != también pueden ser usados con referencias objetos.

El tipo del resultado de una comparación es un boolean.
Los operadores que pueden operar con valores booleanos son los siguientes:
! negación (prefijo)
&& condicional y
|| condicional o
Los operadores lógicos && y || no evaluarán el segundo operador en

su expresión si no es necesario determinar el valor de la expresión. Esta
caracterı́stica es útil para construir expresiones booleanas donde primero se
prueba que una cierta condición se cumpla, como que una referencia no sea
nula, y luega se prueba una condición que podrı́a haber generado de otra
forma una condición de error si la primera prueba no hubiera sucedido.
Operadores a nivel bit

Java proporciona los siguientes operadores a nivel bit (bitwise) para
enteros:
~ complemento (operador unario prefijo)
& y bitwise
| o bitwise
^ o-exclusivo bitwise
<< desplazamiento a la izquierda
>> desplazamiento a la derecha sin signo
>>> desplazamiento a la izquierda con signo
Operadores de asignación
Para expresiones del tipo
variable = variable operador expresión;
Java proporciona operadores de asignación que tienen efectos laterales de
operación. Estos operadores son de la forma
variable operador= expresión;
excepto si la variable contiene una expresión, como un ı́ndice arreglo, la
expresión es evaluada una sola vez. Ası́, el fragmento de código
1.3 Expresiones 27
a[5] = 20;
i = 5;
a[i++] += 3;
deja a[5] con el valor 23 e i con valor 6.
Concatenación de cadenas
Las cadenas pueden ser compuestas usando el operador de concatenación
(+).
Precedencia de operadores
Los operadores en Java tienen precedencia, la cual sirve para determinar
el orden en el cual las operaciones son hechas. Los operadores son evaluados
de acuerdo a la siguiente tabla si lo paréntesis no son usados para determinar
el orden de evaluación. Los operadores en la misma lı́nea son evaluados
de izquierda a derecha, excepto para la asignación y operaciones prefijas,
las cuales son evaluadas de derecha a izquierda, de acuerdo a la regla de
evaluación condicional para las operaciones lógicas Y y O. Sin paréntesis, los
operadores de mayor precedencia son evaluados antes que los operadores de
menor precedencia.
Tipo Sı́mbolos
Postfijo exp++ exp−−
Prefijo ++exp −−exp +exp −exp ˜exp !exp
Conversión (tipo)exp
Mult./div. ∗ / %
add./subs. +−
desplazamiento << >> >>>
comparación < <= > >= instanceof
igualdad == ! =
y bitwise &
xor bitwise ˆ
o bitwise |
y &&
o ||
condicional ? :
asignación = += -= /= %= >>= <<= >>>= &= ˆ= |=
28 Introducción
1.3.3. Conversiones tipo base

La conversión es una operación que permite cambiar el tipo de un valor.
Se puede tomar un valor de algún tipo y convertirlo en un valor equivalente de
otro tipo. Las conversiones son útiles para hacer ciertas operaciones númericas
y de entrada/salida.
La sintaxis para conversión de una expresión a un tipo deseado es:
(tipo) exp
donde tipo indica a que tipo se quiere convertir la expresión que se tiene. Hay
dos tipos fundamentales de conversiones que pueden ser hechas. Se puede
convertir respecto a tipos base numérica o con respecto a objetos. Se aborda
en este capı́tulo la conversión numérica y de cadenas, y la de objetos en la
sección 2.5.1.
Conversión ordinaria
Cuando se convierte de un tipo double a un int, se podrı́a perder precisión,
siendo el valor double truncado. Pero se puede convertir un int a un double
sin problema. Por ejemplo, considerar lo siguiente:
double d1 = 1.2;
double d2 = 3.9999;
int i1 = (int )d1; // i1 tiene valor 1
int i2 = (int )d2; // i2 tiene valor 3
double d3 = (double )i2; // d3 tiene valor 3.0
Conversión con operadores

Ciertas operaciones binarias, como la división, darán resultados diferentes
dependiendo de los tipos de variables usadas. Se debe asegurarse que las
operaciones realizadas con los valores de los tipos pretendidos son las deseadas.
Por ejemplo, cuando se usan enteros, la división no considera la parte fraccional,
pero si cuando se usan números punto flotante, como se muestra en el siguiente
ejemplo:
int i1 = 4;
int i2 = 8;
dResultado = (double )i1 / (double )i2; // dResultado <-- 0.5
dResultado = i1 / i2; // dResultado <-- 0.0
1.3 Expresiones 29
Cuando i1 e i2 fueron convertidos a dobles, se realizó una división para

números reales. Cuando no fueron convertidos, se realizó una división entera
y ası́ el resultado fue cero. Java no hace una conversión implı́cita para asignar
un valor int al resultado double.
Conversión implı́cita y autoempacado/desempacado

Hay casos donde Java realiza una conversión implı́cita, de acuerdo al
tipo de la variable de asignación, dado que no exista pérdida de precisión.
Por ejemplo:
int iResultado = 3;
double dResultado = 3.2;
dResultado = i/d; // dResultado <-- 0.9375. i convertido a double
iResultado = i/d; // pérdida de precisión -> error de compilación
iResultado = (int )i/d; // iResultado <-- 0, se pierde la fracción
Como Java no realiza conversiones implı́citas donde se pierda precisión, la

conversión explı́cita en la última lı́nea es requerida.
A partir de Java 5 hay un nuevo tipo de conversión explı́cita, para ir entre
objetos Number, como Integer y Float, a su tipo base relacionado, como
int y float. En cualquier momento que un objeto Number es esperado como
parámetro para un método, el correspondiente tipo base puede ser pasado. En
este caso, Java realizará una conversión implı́cita, llamada autoempacado,
la cual convertirá el tipo base a su correspondiente objeto Number. De igual
forma, cada vez que un tipo base es esperado en una expresión que involucra
una referencia Number, el objeto Number es cambiado al correspondiente tipo
base, en uno operación llamada desempacado. Se muestra enseguida código
que usa las nuevas conversiones explı́citas.
Integer a = 5; // autoempacado de un tipo base

int b = a + 3; // desempacado de un objeto Number
Una advertencia, del autoempacado y desempacado, es que si un referencia

Number es null, entonces intentando desempacar generará un error, llamado
NullPointerException. Otra advertencia, es con el operador ==, ya que es
usado para probar la igualdad de valores tipo base, ası́ como si dos referencias
Number están apuntando al mismo objeto. Ası́ que cuando se intenta probar
la igualdad, evitar las conversiones implı́citas hechas por el autoempacada
30 Introducción
y desempacado. Por último, las conversiones implı́citas, de cualquier tipo,

toman tiempo, por lo tanto se deben tratar de minimizar para no retardar la
ejecución del programa.
En cualquier momento que una cadena es concatenada con cualquier
objeto o tipo base, este es automáticamente convertido a cadena. Conversión
explı́cita de un objeto o tipo base a una cadena no está permitida. Por lo
tanto, las siguientes sentencias son incorrectas:
String s = (String) 4.5; // incorrecto

String t = "Valor = " + (String) 67; // incorrecto
String u = 22; // incorrecto
Para realizar una conversión a cadena, se deberá usar el método toString()

apropiado o realizar una conversión implı́cita usando la operación de concate-
nación, como se muestra en las siguientes sentencias:
String s = "" + 4.5; // correcto, pero estilo pobre

String t = "Valor = " + 67; // correcto
String u = Integer.toString(22); // correcto
1.4. Control de flujo

El control de flujo en Java es parecido al de otros lenguajes de alto nivel.
Se revisa la estructura básica y la sintaxis del control de flujo en esta sección,
incluyendo regreso del método, sentencia if, sentencia switch, ciclos, y formas
restringidas de saltos, sentencia break y continue.
1.4.1. Sentencias if y switch

Los condicionales dan una forma de evaluar una decisión y luego ejecutar
una sentencia o mas bloques de sentencias diferentes de acuerdo a la salida
de la decisión.
Sentencia if
La sintaxis de una sentencia if simple es:
if (expresión booleana)
sentencia true;
1.4 Control de flujo 31
else
sentencia false;
donde sentencia true y sentencia false tienen una sola sentencia, o bien, un
bloque de sentencias encerradas entre llaves. La parte else y su sentencia
asociada en una sentencia if es opcional. Se puede agrupar una cantidad de
pruebas booleanas, como sigue:
if (primera expresión booleana)

sentencia true;
else if (segunda expresión booleana)
segunda sentencia true;
else
sentencia false;
Si la primera expresión booleana es falsa, la segunda expresión boolena

será probada, y ası́ sucesivamente. Una sentencia if puede tener una cantidad
arbitraria de partes else if. Para estar seguro cuando se definan sentencias
if complicadas, usar llaves para encerrar todas las sentencias de los cuerpos.
Por ejemplo, la siguiente es una sentencia correcta if.
if (nivelAgua < 20) {

irAClase();
regresarACasa();
}
else if (nivelAgua < 50) {
salirEnLancha();
recogerTrampas();
}
else
quedarseEnCasa();
Sentencia switch
Java proporciona para control de flujo de valores múltiples la sentencia
switch, la cual es útil con tipos enum. El siguiente es un ejemplo la cual usa
una variable d del tipo enum Dia del listado 1.5 de la sección 1.1.3.
switch (d) {
case LUN:
32 Introducción
System.out.println("Exito");
break ;
case MAR:
System.out.println("Triunfo");
break ;
case MIE:
System.out.println("Fe");
break ;
case JUE:
System.out.println("Paz");
break ;
case VIE:
System.out.println("Amor");
break ;
default :
System.out.println("Salud");
}
La sentencia switch evalúa un entero o enum y hace que el control de

flujo salte a la localidad del código etiquetado con el valor de esta expresión.
Si no hay una etiqueta que empate, entonces del flujo del programa salta a la
localidad etiquetada como default. Este es el único salto explı́cito hecho por
la sentencia switch, sin embargo, el control de flujo “pasa” a otros casos si el
código para cada caso no es terminado con una sentencia break, la cual hace
que el control de flujo pase a la siguiente sentencia después de switch.
1.4.2. Ciclos
Otro mecanismo importante del control de flujo en un lenguaje de progra-
mación es la repetición. Java tiene tres tipos de ciclos.
Ciclos while
El tipo de ciclo más simple es el ciclo while. Este ciclo prueba que una
cierta condición se cumpla y realizará el cuerpo del ciclo cada vez que la
condición sea evaluada a true. La sintaxis para probar una condición antes
que el cuerpo del ciclo sea ejecutado es:
while (condición)
sentencia ciclo;
Al inicio de cada iteración, el ciclo prueba la expresión y luego ejecuta

el cuerpo del ciclo, sólo si la expresion booleana evalúa a true. La sentencia
del cuerpo del ciclo también puede ser un bloque de sentencias y la condición
deberá ser una expresión booleana.
Considerar por ejemplo, un duende que intenta regar todas sus zanahorias
en su huerta, lo cual él hará mientras su regadera no esté vacı́a. Como su
regadera podrı́a estar vacı́a, se podrı́a escribir el código que haga esta tarea
como:
public void regarZanahorias() {

Zanahoria actual = huerta.encontrarSigZanahoria();
while (!regadera.estáVacı́a()) {
regar(actual,regadera);
actual = huerta.encontrarSigZanahoria():
}
}
Ciclos for
Otro tipo de ciclo es el ciclo for. Los ciclos for, en su forma más simple,
proporciona repetición de código para una determinada cantidad de veces,
pero se pueden hacer otras tareas también. La funcionalidad de un ciclo for
es flexible, gracias a que está dividido en cuatro secciones: la inicialización, la
condición, el incremento, y el cuerpo.
La sintaxis para un ciclo for es:
for (inicialización; condición; incremento)

sentencia ciclo;
donde las secciones inicialización, condición, e incremento pueden estar vacı́as.

En la sección de inicialización, se puede declarar una variable ı́ndice que
sólo existe en el alcance del ciclo for. Por ejemplo, si se quiere un ciclo que
indice en un contador, y no se tiene necesidad de la variable contador fuera
del ciclo for, entonces declarando algo como lo siguiente
for (int contador=0; condición; incremento)

sentencia ciclo;
34 Introducción
declarará una variable contador cuyo alcance es sólo el cuerpo del ciclo.
En la sección condición, se indica la condición para repetir el ciclo. Esta
deberá ser una expresión booleana. El cuerpo del ciclo for será ejecutado
cada vez que la condición sea true cuando sea evaluado al inicio de una
iteración posible. Tan pronto como la condición evalúe a false, entonces el
cuerpo del ciclo ya no es ejecutado, y la ejecución del programa continúa con
la siguiente sentencia después del ciclo for.
En la sección incremento, se declara la sentencia de incremento para el
ciclo. Esta deberá ser cualquier sentencia legal permitida para flexibilidad en
la codificación. La sintaxis de un ciclo for es equivalente a:
inicialización;
while (condición) {
sentencia ciclo;
incremento;
}
excepto que en Java, un ciclo while no puede tener una condición booleana
vacı́a, mientras en un ciclo for está permitido. El siguiente ejemplo muestra
un ciclo for
public void comerManzanas(Manzanas manzanas) {

int cantManzanas = manzanas.getCantidad();
for (int x=0; x<cantManzanas; ++x) {
comerManzana(manzanas.getManzana(x));
tirarCorazón();
}
}
En el ejemplo anterior, la variable de ciclo x fue declarada en int x =

0. Antes de cada iteración, el ciclo prueba la condición x<cantManzanas y
ejecuta el cuerpo del ciclo solo si esto es verdadero. Al final de cada iteración
el ciclo usa la sentencia ++x para incrementar la variable de ciclo antes de
probar nuevamente la condición.
Ciclos do...while
El ciclo do...while prueba una condición después del cuerpo del ciclo,
a diferencia de los ciclos anteriores, los cuales prueban una condición antes
de realizar una iteración en el cuerpo del ciclo. La sintaxis para el ciclo

do...while es:
do
sentencia ciclo;
while(expr booleana);
La sentencia del cuerpo del ciclo puede ser una sola sentencia o un bloque
de sentencias, y la condición debe ser una expresión booleana. En este ciclo
se repite el cuerpo del ciclo tanto como la condición sea verdadera cada vez
que es evaluada.
Por ejemplo, considerar que se quiere pedir al usuario una entrada y luego
hacer algo útil con esa entrada. Una condición posible, en este caso, para salir
del ciclo es cuando el usuario ingresa una cadena vacı́a. Sin embargo, aún en
este caso, se podrı́a querer manejar la entrada e informar al usuario que se
quiere salir. El siguiente ejemplo ilustra ese caso:
public void getEntradaUsuario() {
String entrada;
do {
entrada = getEntradaString();
manejarEntrada(entrada);
} while (entrada.length()>0);
}
Observar en el ejemplo anterior que la condición de salida es cuando la
condición es no verdadera.
1.4.3. Sentencias explı́citas de control de flujo

Java también proporciona sentencias que permiten explı́citamente el cam-
bio en el flujo de un programa.
Regresar de un método
Si un método está declarado con un tipo de retorno void, entonces el flujo
regresa cuando alcanza la última lı́nea de código en el método, o cuando se
encuentra una sentencia return sin argumento. Sin embargo, si un método
está declarado con un tipo de retorno, el método es una función y este
deberá salir regresando el valor de la función como un argumento a una
36 Introducción
sentencia return. El siguiente ejemplo correcto ilustra el regreso de una

función:
// Revisar por un cumplea~

nos particular
public boolean revisaCumple(int fecha) {
if (fecha == Cumples.CUMPLE JUAN) {
return true ;
}
return false ;
}
Se sigue que la sentencia return deberá ser la última sentencia ejecutada

en una función, ya que el resto del código nunca será ejecutado.
Observar que hay una diferencia significativa entre una sentencia que es
la última lı́nea de código ejecutada en un método y la última lı́nea de código
en el método. En el ejemplo anterior, la lı́nea return true; no es la última
lı́nea de código escrita en la función, pero podrı́a ser la última lı́nea que es
ejecutada cuando la condición involucrando a fecha sea true. Tal sentencia
explı́citamente interrumpe el flujo en el método.
Sentencia break
El uso tı́pico de la sentencia break tiene la siguiente sintaxis simple:
break;
Se usa break para salir del cuerpo de la sentencia switch, for, while,
o do...while más interna. Cuando es ejecutado break, el flujo pasa a la
siguiente sentencia después del cuerpo del ciclo o switch que contiene el
break.
La sentencia break también puede ser usada en una forma etiquetada
para salir del ciclo más externo o sentencia switch. La sintaxis es:
break etiqueta;
donde etiqueta es un identificador Java que es usado para etiquetar un ciclo

o sentencia switch. Tal etiqueta puede aparecer una sola vez al inicio de la
declaración de un ciclo.
Se muestra el uso de una etiqueta con una sentencia break en el siguiente
ejemplo:
1.5 Arreglos 37
public static boolean tieneEntradaCero( int [][] a) {

boolean banderaEnc = false ;
busquedaCero:
for (int i=0; i<a.length; ++i)
for (int j=0; j<a[i].length; ++j)
if (a[i][j] == 0) {
banderaEnc = true ;
break busquedaCero;
}
return banderaEnc;
}
Sentencia continue
La sentencia continue también cambia explı́citamente el flujo en un
programa, la cual tiene la siguiente sintaxis:
continue [etiqueta];
donde etiqueta es un identificador opcional Java que es usado para etiquetar

un ciclo. Esta sentencia sólo puede ser usada adentro de ciclos. La sentencia
continue causa que la ejecución salte sobre los pasos restantes del cuerpo del
ciclo en la iteración actual, pero el ciclo continúa si su condición es satisfecha.
1.5. Arreglos
Una tarea de programación común es manejar un grupo numerado de
objetos relacionados. Por ejemplo, se podrı́a querer que un videojuego maneje
las diez puntuaciones mejores del juego. En vez de usar diez variables diferentes
para esa tarea, se podrı́a preferir usar un sólo nombre para el grupo y usar
un ı́ndice numérico para referirse a cada unna de las puntucaciones. De igual
forma, se podrı́a querer que un sistema de información médico maneje los
pacientes asignados a camas en un cierto hospital. De nueva cuenta no se
tienen que introducir 200 variables sólo por que el hospital tenga 200 camas.
En situaciones como las anteriores, se puede ahorrar esfuerzo de programa-
ción usando un arreglo, el cual es una colección numerada de variables todas
ellas con el mismo nombre. Cada variable, o celda, en un arreglo tiene un
38 Introducción
ı́ndice, el cual se refiere de forma única al valor guardado en esa celda. Las
celdas del arreglo a están numeradas por 0, 1, 2, etc. Se muestra enseguida
un arreglo de las diez puntuaciones más altas para un vı́deo juego.
Puntuaciones mejores
987 876 765 654 543 432 321 210 109 98
0 1 2 3 4 5 6 7 8 9
ı́ndices
Esta organización es útil, ya que permite hacer cálculos interesantes. En
el siguiente ejemplo, listado 1.6, el método, de la clase DemoArreglos suma
todos los números en un arreglo de enteros:
1 /* * Agrega todos los n ú meros en un arreglo de enteros */

2 public static int suma ( int [] a ) {
3 int total = 0;
4 for ( int i =0; i < a . length ; ++ i )
5 total += a [ i ];
6 return total
7 }
Listado 1.6: Método para sumar todos los elementos de un arreglo de enteros
En este ejemplo se usa una caracterı́stica importante de Java para los

arreglos, el tamaño de celdas que un arreglo guarda, es decir, su tamaño
(length). En Java, un arreglo es un tipo especial de objeto donde el tamaño
del arreglo es guardado en una variable de instancia, length, la cual se accede
de la siguiente forma:
nombre arreglo.length
Las celdas de un arreglo a están numeradas como 0, 1, 2, y ası́ hasta
a.length-1.
Elementos y capacidades del arreglo

Cada objeto guardado en un arreglo es llamado un elemento del arreglo.
Elemento número 0 es a[0], elemento número 1 es a[1], y ası́ sucesivamente.
Como el tamaño de un arreglo determina la cantidad máxima de cosas que
pueden ser guardadas en el arreglo, en ocasiones se refiere el tamaño de un
arreglo como su capacidad. Enseguida se muestra otro uso simple de un
arreglo en el listado 1.7, clase DemoArreglos, el cual cuenta la cantidad de
veces que cierto número aparece en un arreglo:
1.5 Arreglos 39
1 /* * Cuenta la cantidad de veces que un entero est á en el arreglo . */

2 public static int e nc u en tr aC u en ta ( int [] a , int k ) {
3 int cuenta = 0;
4 for ( int i =0; i < a . length ; ++ i )
5 if ( a [ i ]== k ) // revisar si el elemento actual es igual a k
6 ++ cuenta ;
7 return cuenta ;
8 }
Listado 1.7: Método para contar las veces que se encuentra k en el arreglo.
Error fuera de los lı́mites

Es un descuido serio intentar indizar un arreglo a con un número fuera del
rango de 0 a a.length-1. Se dice que tal referencia está fuera de los lı́mites.
Las referencias fuera de los lı́mites han sido usadas numerosas ocasiones por
los hackers usando un método llamado el ataque de desbordamiento del búfer
para comprometer la seguridad del sistema de cómputo, escrito en lenguajes
que no son Java. Como medida de seguridad, los ı́ndices de los arreglos son
siempre revisados en Java para que no estén fuera de los lı́mites. En el caso
de que un ı́ndice se encuentre fuera de los lı́mites, el ambiente de ejecución
Java indica una condición de error, indicada por la clase ArrayIndexOutOf-
BoundsException. Mediante esta revisión Java evita problemas de seguridad
donde otros lenguajes deben hacer frente.
Se pueden evitar errores fuera de los lı́mites asegurándose que siempre
se indiza en un arreglo, a, usando un valor entero entre cero y a.length.
Una forma breve de lograrlo es usando cuidadosamente la caracterı́stica de
terminación temprana de los operadores lógicos de Java. Por ejemplo, una
sentencia como la siguiente nunca generará un error fuera de los lı́mites:
if ((i>=0) && (i<a.length) && (a[i]>2) )

x = a[i];
para la comparación a[i]>2 sólo será hecha si las primeras dos comparaciones
son exitosas.
1.5.1. Declaración de arreglos

Una forma para declarar e inicializar un arreglo es la siguiente:
tipo elemento[] nombre arreglo = {val 0, val 1, ...};

40 Introducción
El tipo elemento puede ser cualquier tipo base Java o nombre de clase, y
nombre arreglo es un identificador Java válido. Los valores iniciales deberán
ser del mismo tipo que el del arreglo. Por ejemplo, la siguiente declaración de
un arreglo que es inicializado con los primeros diez números primos:
int [] primos = {2,3,5,7,11,13,17,19,23,29};
Para declarar una variable arreglo sin inicializarlo, se hace como sigue:
tipo elemento[] nombre arreglo;
Una vez que se ha declarado un arreglo de la forma anterior, se puede
crear la colección de celdas para el arreglo usando la siguiente sintaxis:
new tipo elemento[tamaño]
donde tamaño es un entero positivo indicando el tamaño del arreglo creado.
Usualmente esta expresión aparece en una sentencia de asignación con el
nombre del arreglo en lado izquierdo del operador de asignación. Los arreglos
creados son inicializados con ceros si el tipo del arreglo es un tipo base
numérico. Los arreglos de objetos son inicializados a referencias null. En el
siguiente código se define una variable de arreglo llamada a, y después se le
asigna un arreglo de diez celdas, cada una de tipo double, siendo después los
elementos inicializados a 1.0:
double [] a;
a = new double [10];
for (int k=0; k<a.length; ++k)
a[k] = 1.0;
1.5.2. Arreglos como objetos

Los arreglos en Java son un tipo especial de objeto. Por esta razón se
puede usar el operador new para crear una nueva instancia de un arreglo. El
arreglo puede ser usado como cualquier otro objeto general, pero se tiene
una sintaxis especial, usando los corchetes, para referirse a sus miembros.
Como un arreglo sea un objeto, el nombre de un arreglo es una referencia
a la dirección en memoria donde está el arreglo guardado, de igual manera,
no hay nada especial en usar el operador punto y la variable de instancia,
length, para referirse al tamaño del arreglo.
Como los arreglos son objetos, entonces cuando se tiene una sentencia
como la siguiente, donde a y b son referencias a arreglos del mismo tipo
1.6 Entrada y salida 41
b = a;
significa que a y b se refieren al mismo objeto. Ası́ que cuando se tenga una
sentencia como
b[3] = 5;
entonces también se tiene que a[3] guarda un 5.
Clonación de un arreglo
Cuando se quiere crear una copia exacta del arreglo, a, y asignar ese
arreglo al arreglo variable, b, se podrı́a escribir
b = a.clone();
el cual copia el contenido de todas las celdas de a en un arreglo nuevo y lo
asigna b para que apunte a este. El método clone() es un método incorporado
de cada objeto Java. Si antes de la asignación b[3] = 5; se hubiera clonado
el arreglo a en b, entonces los elementos en a y b para el ı́ndice 3 podrı́an ser
diferentes, ya que cada referencia apunta a su propio arreglo.
Se debe observar que las celdas de un arreglo son copiadas cuando este es
clonado. Si las celdas son un tipo base, como int, sus valores son copiados.
Pero si las celdas son referencias objetos, entonces estas referencias son
copiadas. Esto significa que hay dos formas para referirse a un objeto.
1.6. Entrada y salida

Java tiene un conjunto de clases y métodos para la entrada y salida en
un programa. Hay clases para el diseño de interfaces gráficas de usuario, con
ventanas pop-up (emergentes) y menús, al igual que métodos para mostrar
e introducir texto y números. También hay métodos para manejar objetos
gráficos, imágenes, sonidos, páginas web, y eventos de ratón. Varios de estos
método de entrada y salida pueden ser usados en programas autónomos o en
applets.
La entrada y salida simple se da con la ventana consola Java. Dependiendo
del ambiente Java donde se esté usando, la ventana es una ventana emergente
especial que puede ser usada para mostrar e introducir texto, o una ventana
usada para introducir comandos al sistema operativo, estas ventanas son
referidas como ventanas shell, DOS o terminal.
42 Introducción
Métodos de salida simple

Java proporciona un objeto estático incorporado, llamado System.out,
que realiza salida al dispositivo de la “salida estándar”, siendo este la ventana
consola Java. El objeto System.out es una instancia de la clase java.io.-
PrintStream. Esta clase define métodos para un flujo de salida de memoria,
donde los caracteres son puestos en una localidad temporal, llamada buffer,
el cual después es vaciado cuando la ventana consola está lista para imprimir
los caracteres.
En particular, la clase java.io.PrintStream tiene los siguientes métodos
para realizar salida simple (se usa tipo base para referirse a cualquiera de los
tipos base posibles):
print(Object o) Imprime el objeto o usando su método
toString().
print(String s) Imprime la cadena s.
print(tipo base t) Imprime el valor del tipo base t.
println(String s) Imprime la cadena s, seguida del carácter
nueva lı́nea.
Cuando el siguiente fragmento de código:
System.out.print("Valores Java: ");

System.out.print(3.1416);
System.out.print(’,’);
System.out.print(15);
System.out.print(" (double,char,int).");
es ejecutado, mostrará lo siguiente en la ventana consola Java:
Valores Java: 3.1416,15 (double,char,int).
Entrada simple con la clase java.util.Scanner

Para realizar entrada desde la ventana consola Java se emplea el objeto
especial System.in. La entrda viene del dispositivo de “entrada estándar”,
el cual por defecto es el teclado de la computadora replicando sus teclas
presionadas en la consola. El objeto System.in está asociado con el dispositivo
de entrada estándar. Una forma simple de leer la entrada de este objeto es
usándolo para crear un objeto Scanner de la siguiente forma:
new Scanner(System.in)
1.6 Entrada y salida 43
La clase Scanner tiene un conjunto de métodos adecuados que leen desde

el flujo de entrada dado. En la clase EjemploEntrada, listado 1.8, se usa un
objeto Scanner para procesar la entrada:
1 import java . io . IOException ;

2 import java . util . Scanner ;
3 public class EjemploE ntrada {
4 public static void main ( String [] args ) throws IOException {
5 Scanner s = new Scanner ( System . in );
6 System . out . print ( " Ingresa tu edad en a ~n os : " );
7 int edad = s . nextInt ();
8 System . out . print ( " Ingresa la frecuencia card ı́ aca m á xima : " );
9 double frecuencia = s . nextDouble ();
10 double qg = ( frecuencia - edad )*0.65;
11 System . out . println ( " Su meta de ı́ ndice de quema de grasa es : " +
12 qg + " . " );
13 }
14 }
Listado 1.8: La clase EjemploEntrada.
Cuando se ejecuta, la aplicación podrı́a generar lo siguiente en la consola

Java:
Ingresa tu edad en a~nos: 48

Ingresa la frecuencia cardı́aca máxima: 170
Su meta de ı́ndice de quema de grasa es: 79.3.
Métodos de la clase java.util.Scanner
La clase Scanner lee el flujo de entrada y lo divide en tokens, los cuales

son cadenas de caracteres separados por delimitadores. Un delimitador es una
cadena de separación especial, y el delimitador por defecto es el espacio blanco.
De esta forma, los tokens son separados por cadenas de espacios, tabuladores,
y nuevas lı́neas, por defecto. Los tokens pueden ser leı́dos inmediatamente
como cadenas o un objeto Scanner puede convertir un token a un tipo base,
siempre que token esté con la sintaxis correcta. La clase Scanner incluye los
siguientes métodos para trabajar con tokens:
44 Introducción
hasNext() Devuelve true si y sólo si hay otro token

en el flujo de entrada.
next() Devuelve la siguiente cadena token en un
flujo de entrada; se genera un error si ya
no quedan más tokens.
hasNextTipo () Devuelve true si y solo si hay otro token
en el flujo de entrada y este puede ser inter-
pretado como el Tipo base correspondiente,
siendo tipo Boolean, Byte, Double, Float,
Int, Long, Short.
nextTipo () Devuelve el siguiente token en el flujo de
entrada, devuelto como el correspondiente
Tipo base; se genera un error si ya no que-
dan más tokens o si el siguiente token no
puede ser interpretado como un tipo base
correspondiente a Tipo.
Adicionalmente, los objetos Scanner pueden procesar la entrada lı́nea por
lı́nea, ignorando los delimitadores, y también buscar patrones dentro de lı́neas.
Los métodos para procesar la entrada de esta forma incluyen los siguientes:
hasNextLine() Devuelve true si y solo si el flujo de entrada
tiene otra lı́nea de texto.
nextLine() Avanza la entrada pasando al final de la
lı́nea actual y regresando la entrada que fue
saltada.
findInLine(String s) Intenta encontrar una cadena que empate
el patrón s en la lı́nea actual. Si el patrón es
encontrado, este se devuelve y se avanza al
primer carácter después del apareamiento.
Si el patrón no es encontrado, se devuelve
null y no se avanza.
Algunos de los métodos mencionados se podrı́an usar como se muestra
enseguida para lograr que el usuario ingrese un entero:
Scanner entrada = new Scanner(System.in);

System.out.print("Favor de ingresar un entero: ");
while (!entrada.hasNextInt()) {
input.nextLine();
System.out.print("No se ingreso un entero. ");
1.7 Clases anidadas y paquetes 45
System.out.print("Por favor ingrese un entero: ");

}
int i = entrada.nextInt();
1.7. Clases anidadas y paquetes

Java tiene una forma útil y general para la organización de clases en
programas. Cada clase pública autónoma definida en Java deberá estar en
archivo separado. El nombre del archivo es el nombre de la clase con la
extensión .java. Se describe enseguida dos maneras que Java tiene para
organizar múltiples clases en forma útil.
Clases anidadas
Java permite que definiciones de clases sean anidadas, o puestas, dentro
de las definiciones de otras clases. El principal uso para tales clases anidadas
es para definir una clase que está fuertemente afiliada con otra clase. Por
ejemplo, definir la clase cursor como clase anidada en la definición de la clase
editor de texto mantiene a estas dos clases altamente relacionadas en el mismo
archivo. Más aún, permite que cada una de ellas acceda a los métodos no
públicos de la otra. Un punto técnico respecto a las clases anidadas es que
la clase anidada debe ser declarada como static. Esta declaración implica
que la clase anidada está asociada con la clase externa, no una instancia de
la clase externa, que es, un objeto especı́fico.
Paquetes
Un conjunto de clases, todas definidas en un subdirectorio común, pueden
ser un paquete Java. Cada archivo en un paquete inician con la lı́nea:
package nombre paquete;
El subdirectorio conteniendo el paquete deberá ser nombrado igual que el
paquete. Se puede también definir un paquete en sólo archivo que contenga
varias definiciones de clases, pero cuando este es compilado, todas las clases
serán compiladas en archivos separados en el mismo subdirectorio.
En Java, se pueden usar clases que están definidos en otros paquetes
prefijando los nombres de las clases con puntos que correspondan a las
estructuras de directorios de otros paquetes.
46 Introducción
public boolean temperatura(

TA.Medidas.Termometro termometro, int temp) {
//...
}
En la firma del método temperatura se usa una clase Termometro como

parámetro. Termometro está definido en el paquete TA en un subpaquete
llamado Medidas. Los puntos en TA.Medidas.Termometro corresponden di-
rectamente a la estructura de directorios en el paquete TA.
Para evitar todo el tecleado extra para referirse a una clase foránea del
paquete actual, en Java se puede usar la palabra reservada import para
incluir clases externas o paquetes enteros en el archivo actual. Para importar
clases individuales de un paquete particular, se pone lo siguiente al inicio del
archivo:
import nombrePaquete.nombreClase;
Por ejemplo, se podrı́a teclear
package Proyecto;
import TA.Medidas.Termometro;
import TA.Medidas.Escala;
al inicio de una clase del paquete Proyecto, para indicar que se están impor-
tando las clases llamadas TA.Medidas.Termometro y TA.Medidas.Escala.
También se puede importar un paquete entero, con la siguiente sintaxis:
import nombrePaquete.*;
Cualquiera de las dos formas de importación usadas permiten códigos más

breves, ası́ el método Temperatura() se podrı́a reescribir como:
import TA.Medidas.*;
public boolean temperatura(Termometro termometro, int temp) {
//...
}
En resumen, la estructura de un programa Java, permite tener variables

de instancia y métodos dentro de una clase, y clases dentro de un paquete.
Capı́tulo 2
Diseño orientado al objeto
2.1. Metas, principios, y patrones

Los “actores” principales en el paradigma del diseño orientado al objetos
son llamados objetos. Un objeto viene de una clase, la cual es una especifica-
ción de los campos de datos, también llamados variables de instancia, que el
objeto contiene, al igual los métodos u operaciones que el objeto puede ejecu-
tar. Cada clase presenta al mundo exterior una vista concisa y consistente de
los objetos que son instancias de esta clase, sin requerir ir en muchos detalles
innecesarios o dando otros accesos a las tareas internas de los objetos. Esta
vista computacional intenta llenar varias metas e incorporar varios principios
de diseño.
2.1.1. Metas del diseño orientado a objetos

Las implementaciones de software deben lograr robustez, adaptabilidad, y
reutilización.
Robustez
Como buen programador se quiere desarrollar software que sea correcto,
es decir, que un programa dé la salida correcta para todas las entradas
anticipadas. Además, se quiere que el software sea robusto, esto es, capaz de
manejar entradas no esperadas las cuales no están explı́citamente definidas
para la aplicación. Por ejemplo, si un programa está esperando un número
punto flotante positivo, ya que representa el precio de un artı́culo, y en vez de
48 Diseño orientado al objeto
esto se da un valor negativo, entonces el programa se debe poder recuperar

de este error. En aplicaciones de seguridad crı́tica, donde un error de software
puede llevar a una lesión, o la pérdida de la vida, el software que no es robusto
podrı́a ser mortal. Un caso de este tipo se presentó entre 1985 y 1987 en
accidentes que involucraron a la máquina de radioterapia therac-25, donde
al menos seis pacientes recibieron sobredosis de radiación, y tres de estos
murieron como consecuencia directa. Una comisión investigadora concluyó que
la razón primaria deberı́a ser atribuida al mal diseño de software y malas
prácticas de desarrollo, y no explı́citamente a varios errores de codificación
que fueron encontradas.
Adaptabilidad
Las aplicaciones actuales de software, como los navegadores Web y los

motores de búsqueda de Internet, generalmente involucran programas grandes
que son usados por muchos años. Por lo tanto el software necesita ser capaz de
evolucionar en el tiempo en respuesta a condiciones cambiantes en su ambiente.
Ası́, otra meta importante de calidad del software es la adaptabilidad o
evolucionabilidad. Relacionado a este concepto es la portabilidad, la cual
es la habilidad del software para ejecutarse con cambios mı́nimos en hardware
y plataformas de sistemas operativos diferentes. El software escrito en Java
es portable.
Reutilización
Otra capacidad deseable del software es la reutilización, es decir, el mismo

código deberı́a ser utilizable como un componente de diferentes sistemas
para varias aplicaciones. El desarrollo de software de calidad puede ser una
actividad costosa, y su costo se puede recuperar si el software es diseñado de
manera que sea fácilmente reutilizado en aplicaciones futuras. La reutilización
deberá hacerse con cuidado, sin embargo, una de las mayores fuentes de errores
de software en la therac-25 se debió por el reuso inadecuado del software de
la therac-20, la cual no estaba orientada al objeto y no estaba diseñada para
la plataforma de hardware de la therac-25.
2.1 Metas, principios, y patrones 49
2.1.2. Principios del diseño orientado al objeto

Para lograr las metas indicadas previamente se puede hacer con los princi-
pios de la aproximación orientada al objeto, los cuales son:
Abstracción
Encapsulación
Modularidad
Abstracción
La noción de abstracción es extraer de un sistema complejo sus partes
más fundamentales y describirlas de una forma precisa y simple. Describir
las partes de un sistema involucra nombrarlas y explicar su funcionalidad.
Aplicando el paradigma de abstracción al diseño de estructuras de datos da
lugar a tipos de datos abstractos o ADT (abstract data type). Un ADT
es un modelo matemático de una estructura de datos que especifica el tipo de
dato guardado, las operaciones soportadas, y los tipos de parámetros de las
operaciones. Un ADT indica qué puede realizar cada operación, pero no cómo
se hace. En Java, un ADT puede ser expresado por una interfaz, la cual es
una lista de declaraciones de métodos, donde cada método tiene un cuerpo
vacı́o. En la sección 2.4 se abordan las interfaces.
Un ADT es realizado por una estructura de datos concreta, la cual está mo-
delada en Java por una clase. Una clase define los datos que son guardados y
las operaciones soportadas por los objetos que son instancias de la clase. Di-
ferente a las interfaces, las clases indican cómo las operaciones son realizadas
en el cuerpo de cada método. Implementar una interfaz, por una clase,
es cuando la clase incluye todos los métodos declarados en la interfaz, dando
un cuerpo para estos. Sin embargo, una clase puede tener mas métodos que
los de la interfaz.
Encapsulación
El concepto de encapsulación es otro principio importante en el diseño
orientado al objeto, el cual establece que los diferentes componentes de un
sistema de software no deberán mostrar los detalles internos de sus respectivas
implementaciones. Una de las ventajas principales de la encapsulación es
que esta da libertad al programador para implementar los detalles de un
sistema. La única restricción para el programador es que mantenga la interfaz

abstracta que los externos ven.
Modularidad
Otro principio fundamental del diseño orientado al objeto es la modu-

laridad. Los sistemas actuales de software generalmente consisten de varios
componentes diferentes que deben interactuar correctamente en orden para
que el sistema completo trabaje correctamente. Mantener estas interacciones
en orden requiere que estos componentes diferentes estén bien organizados.
En el diseño orientado al objeto, este enfoque de estructuración del código
se logra con el concepto de modularidad. La modularidad se refiere a un
principio de organización para el código, en el cual diferentes componentes de
un sistema de software son divididos en unidades funcionales separadas.
Organización jerárquica
La estructura impuesta por la modularidad ayuda a permitir la reutili-

zación del software. Si los módulos de software son escritos en una forma
abstracta para resolver problemas generales, entonces los módulos pueden ser
reusados con instancias de estos mismos problemas generales que surgen en
otros contextos.
Por ejemplo, la definición estructural de un muro es la misma para cualquier
casa, siendo definido generalmente por cantidad de soportes, espaciamiento de
los soportes, etc. De esta forma, un constructor puede reusar su definiciones de
muro de una casa a otra. En la reutilización, algunas partes podrı́an requerir
ajustes, por ejemplo un muro en un edificio comercial podrı́a ser similar al de
una casa, pero el sistema eléctrico y el soporte podrı́an ser diferentes.
Una forma natural de organizar varios componentes estructurales de un
paquete de software es de modo jerárquico, la cual agrupa definiciones
abstractas similares por nivel, yendo de lo más especı́fico a lo más general
conforme se recorre hacia arriba la jerarquı́a. Un uso común de tales jerarquı́as
es con una gráfica organizacional, donde cada enlace hacia arriba puede
leerse como “es un”, como en “un rancho es una casa, y una casa es una
construcción”. Este tipo de jerarquı́a es útil en el diseño de software, porque
agrupa la funcionalidad común en el nivel más general, y vistas especializadas
del comportamiento como una extensión de la vista general.
2.1 Metas, principios, y patrones 51
2.1.3. Patrones de diseño

Investigadores y profesionales de la computación han desarrollado una
variedad de conceptos organizacionales y metodologı́as para diseñar software
de calidad orientado al objeto para que sea conciso, correcto, y reutilizable.
El concepto de patrón de diseño es importante en el material tratado
en estas notas, ya que describe una solución para un problema de diseño
de software tı́pico. Un patrón es un modelo general para una solución que
puede ser aplicada en varias situaciones diferentes. Este describe los elementos
principales de una solución en una forma abstracta que puede ser especializada
para un problema particular. El patrón tiene un nombre para identificación,
un contexto para describir los escenarios donde puede ser aplicado, un modelo
para indicar como el modelo es aplicado, y un resultado que describe y analiza
lo que el patrón produce.
Se revisan varios patrones de diseño en este material, y se muestra como
pueden ser aplicados consistentemente a implementaciones de estructuras de
datos y algoritmos. Los patrones de diseño caen en dos grupos, patrones para
resolver problemas de diseño de algoritmos y para problemas de ingenierı́a de
software. Algunos de los patrones de diseño de algoritmos son:
Recursión
Amortización
Divide y vencerás
Recortar y buscar o, divide y vencerás
Fuerza bruta
Método voraz
Programación dinámica
Algunos de los patrones de diseño de ingenierı́a de software que serán

revisados son:
Posición
Adaptador
Iterador
Método modelo
Composición
Comparador
Decorador
2.2. Herencia y polimorfismo

Para poder emplear las relaciones jerárquicas, las cuales son comunes en
proyectos de software, la aproximación de diseño orientada al objeto da varias
formas de reusar código.
2.2.1. Herencia
El paradigma orientado al objeto da una estructura organizacional modular
y jerárquica para reusar código, mediante la técnica de herencia. Esta técnica
permite el diseño de clases generales que pueden ser especializadas a clases
más particulares, con las clases especializadas reutilizando el código de la clase
general. La clase general, la cual también es conocida como una clase base o
superclase, puede definir variables de instancia y métodos generales que son
aplicables la mayorı́a de las veces. Una clase que especializa, o extiende o
hereda de, una superclase no necesita dar nuevas implementaciones para los
métodos generales, para eso los hereda. Sólo deberı́a definir aquellos métodos
que son especializados para la subclase particular.
Ejemplo. Considerar una clase S que define objetos con un campo, x
entero, y tres métodos, a(), b(), y c() devolviendo diferentes tipos. Suponer
que se define una clase T que extiende a S e incluye un campo adicional, y
entero, y dos métodos, d() y e() devolviendo diferentes tipos. La clase T
hereda los miembros de la clase S. Se ilustra la relación entre la clase S y T en
un diagrama de Lenguaje Unificado de Modelado o UML (Unified Modeling
Language) en la figura 2.1. Cada rectángulo en el diagrama indica una clase,
poniendo en subrectángulos el nombre, los campos, y los métodos.
2.2 Herencia y polimorfismo 53
S
-x : int
+a : int
+b : int
+c (int n) : void
~
w
w
w
w
T
-y : int
+d : int
+e (int n) : void
Figura 2.1: Diagrama UML de la relación entre las clases S y T.
Creación y referencia de objetos

Cuando un objeto o es creado, memoria es asignada para sus campos de
datos, y estos campos son inicializados a valores especı́ficos. Generalmente,
se asocia un objeto nuevo o con una variable, la cual sirve como un “enlace”
al objeto o, y se dice que referencia o. Para acceder al objeto o se puede
solicitar la ejecución de algunos de los métodos de o, o mirar uno de los
campos de o. La forma primaria como un objeto p interactúa con otro objeto
o es mandando un “mensaje” a o usando alguno de los métodos de o. La
segunda forma como p puede interactuar con o es accediendo alguno de los
campos de o directamente, siempre y cuando o dé los permisos para ello.
Enlazado dinámico
Cuando un programa desea llamar un cierto método a() de algún objeto
o, este manda un mensaje a o, el cual se denota, usando la sintaxis operador
punto, como o.a(). Cuando se ejecuta la versión compilada del programa se le
indica al ambiente de ejecución que revise la clase T de o para indicar si la clase
T soporta un método a(), y si es ası́, lo ejecute. En la revisión, primero, se ve
si la clase T define un método a() para ejecutarlo, si no lo define, entonces se
revisa la superclase S de T. Si S lo define, entonces se ejecuta. Si S tampoco
define a(), entonces se repite la búsqueda en la superclase de S. La búsqueda
continúa hacia arriba en la jerarquı́a de clases hasta que se encuentra el método

a() y lo ejecuta, o hasta que se alcanza la clase raı́z, la clase Object, sin un
método a(), lo cual genera un error en tiempo de ejecución. El algoritmo que
procesa el mensaje o.a() para encontrar el método especı́fico invocado es
llamado el algoritmo de enlazado dinámico, o envı́o dinámico, el cual da
un mecanismo efectivo para encontar software reutilizable. También permite
otra técnica poderosa de la programación orientada al objeto, polimorfismo.
2.2.2. Polimorfismo
Polimorfismo significa varias formas. En el contexto del diseño orientado
al objeto, se refiere a la habilidad de una variable objeto de tomar diferentes
formas. Java direcciona objetos usando variables referencia. La variable refe-
rencia o deberá definir cual clase de objetos se le permite referir, en términos
de alguna clase S. Pero esto implica que o pueda también referirse a cualquier
objeto perteneciente a una clase T que extienda S. Ahora suponer lo que
sucede cuando S define un método a() al igual que T. El algoritmo de enlazado
dinámico para la invocación del método siempre inicia su búsqueda desde
la clase más restrictiva que aplique. Cuando o refiere a un objeto de clase T,
entonces usará el método a de T cuando se pida por o.a(), y no el de S. Se
dice, en este caso, que T anula el método a() de S. Por otra parte, cuando
o se refiere a un objeto de clase S , se ejecutará el método a() de S para
o.a(). El polimorfismo es útil porque la llamada o.a() no necesita saber si
el objeto o se refiere a una instancia de T o S para lograr que el método a()
se ejecute correctamente. Ası́, la variable objeto o puede ser polimórfica,
dependiendo de la clase especı́fica de los objetos que sean referenciados. Con
esta funcionalidad se permite que una clase especializada T que extiende una
clase S, herede los métodos estándar de S, y redefina otros métodos de S para
considerar las propiedad particulares de objetos de T.
Java también permite una técnica útil relacionada al polimorfismo, llamada
sobrecarga de métodos. La sobrecarga se da cuando una clase T tiene métodos
múltiples con el mismo nombre, y cada uno con firma diferente. La firma de
un método es la combinación del nombre y el tipo y la cantidad de argumentos
que le son pasados. No importa que varios métodos en una clase tengan el
mismo nombre, ya que pueden diferenciarse por el compilador, dado que
estos tienen firmas diferentes. En los lenguajes que permiten sobrecarga de
métodos, el ambiente de ejecución determina cual método actual llamar para
un método especı́fico buscando hacia arriba en la jerarquı́a de clases para
encontrar el primer método con una firma que empate con el método llamado.
Por ejemplo, para una clase T, la cual define un método a() y extiende a
la clase U, qua a su vez define un método a(x,y). Si un objeto o de clase T
recibe el mensaje o.a(x,y), entonces esta es la versión de U del método a()
que es llamada. El polimorfismo verdadero aplica solo a métodos que tengan
la misma firma, pero que están definidos en clases diferentes.
Herencia, polimorfismo, y sobrecarga de métodos soportan el desarrollo de
sofware reutilizable. Se pueden definir clases que hereden variables y métodos
de instancia y luego se pueden definir variables y métodos de instancia nuevos
que traten los aspectos especiales de objetos de la nueva clase.
2.2.3. Uso de herencia en Java

Hay dos formas básicas de usar herencia de clases en Java, la especiali-
zación y la extensión.
Especialización
Se realiza cuando se especializa una clase general a subclases particulares.
Tales subclases tienen una relación “es un(a)” a su superclase. Una subclase
hereda todos los métodos de la superclase. Para cada método heredado, si
ese método funciona correctamente no importando si está funcionando para
una especialización, no se requiere trabajo adicional. Por otra parte, si un
método general de la superclase no trabaja correctamente en la subclase,
entonces se podrı́a anular el método para lograr la funcionalidad correcta en
la subclase. Por ejemplo, se podrı́a tener una clase general, Perro, la cual
tiene métodos beber() y olfatear(). Especializando esta clase a Sabueso
quizás no requiera anular el método beber(), pero podrı́a requerirse anular
el método olfatear(), ya que un sabueso tiene más desarrollado su olfato.
Ası́, la clase Sabueso especializa los métodos de su superclase, Perro.
Extensión
En la extensión se usa herencia para reutilizar el código escrito para
métodos de la superclase, pero luego se agregan nuevos métodos en la subclase
para extender su funcionalidad. Por ejemplo, para la clase Perro, se podrı́a
crear una subclase, Xolo, la cual hereda los métodos de la superclase, paro
luego agregar un metodo nuevo, curiosidad(), ya que estos tienen un instinto
curioso que no está presente en los perros en general. Cuando se agrega el

método nuevo, se está extendiendo la funcionalidad del perro en general.
En Java, cada clase puede extender a una sola classe. Aún si una definición
de clase no hace uso explı́cito de la cláusula extends, esta todavı́a hereda
de la clase java.lang.Object. Por lo anterior, se dice que Java solo permite
herencia única entre clases.
Formas de anulación de métodos

En la declaración de una nueva clase, Java usa dos formas de anulación
de métodos, refinamiento y reemplazo. En el reemplazo, un método com-
pletamente sustituye el método de la superclase que está anulando. En Java,
todos los métodos regulares utilizan esta forma.
Sin embargo, en el refinamiento un método no reemplaza el método de su
superclase, pero en su lugar agrega código adicional al de la superclase. En
Java, todos los constructores utilizan la forma de refinamiento, un esquema
llamado, encadenamiento constructor. Es decir, un constructor inicia su
ejecución llamando un constructor de la superclase. Esta llamada puede ser
hecha explı́citamente o implı́citamente. Para llamar un constructor de la
superclase explı́citamente, se usa la palabra reservada super para referirse a
la superclase. Por ejemplo, super() llama el constructor de la superclase sin
argumentos. Sin embargo, si no se hace una llamada explı́cita en el cuerpo del
constructor, el compilador inserta automáticamente, como la primera lı́nea
del constructor, una llamada a super(). En resumen, los constructores usan
la forma refinamiento mientras los métodos usan reemplazo.
Palabra reservada this

En ocasiones, en una clase Java es conveniente referirse a la instancia
actual de esa clase. Java proporciona la palabra reservada, this, para tal
referencia. La referencia this es útil, por ejemplo, si se quisiera pasar el
objeto actual como parámetro a un método. Otra aplicación de this es para
referenciar un campo dentro del objeto actual que tenga un nombre que
colisione con el nombre del parámetro de una clase, o la variable definida en
el bloque actual, como se muestra en la clase ProbadorThis, listado 2.1.
Cuando ProbadorThis es ejecutado, se muestra lo siguiente:
La variable local perro = 8
El campo perro = 1
1 public class ProbadorThis {

2 public int perro = 1; // variable de instancia
3 public static void main ( String args []) {
4 ProbadorThis t = new ProbadorThis ();
5 t . golpear ();
6 }
7 public void golpear () {
8 int perro = 8; // ¡ un perro diferente !
9 System . out . println ( " La variable local perro = " + perro );
10 System . out . println ( " El campo perro = " + this . perro );
11 }
12 }
Listado 2.1: Programa de ejemplo que muestra el uso de la referencia this para
resolver la ambigüedad entre un campo del objeto actual y la variable local con el
mismo nombre
Ejemplo de herencia
Se consideran los siguientes ejemplos simples para mostrar los conceptos
previos de herencia y polimorfismo revisados previamente.
Se considera un conjunto de varias clases para generar y mostrar progresio-
nes numéricas. Una progresión numérica es una secuencia de números, donde
cada uno depende de uno, o de más números previos. En una progresión
aritmética se determina el siguiente número por adición y en una progre-
sión geométrica se determina el siguiente número por multiplicación. En
cualquier caso, una progresión requiere una forma para definir su primer valor
y también para identificar el valor actual.
Se inicia definiendo una clase, Progresion, mostrada en el listado 2.2, la
cual define los campos estándares y los métodos de una progresión numérica.
En particular, se definen los siguientes dos campos entero largo:
primero. Primer valor de la progresión;
actual. Valor actual de la progresión;
y los siguientes tres métodos:
primerValor(). Reinicia la progresión al primer valor y devuelve este.
siguienteValor(). Avanza la progresión al siguiente valor y lo devuel-

ve.
mostrarProgresion(). Reinicia la progresión e imprime los primeros

n valores de la progresión.
El método mostrarProgresion() no tiene “salida” en el sentido de que no
regresa ningún valor, mientras ambos métodos primerValor() y siguiente-
Valor() devuelven enteros largos. Entonces, primerValor() y siguiente-
Valor() son funciones, y mostrarProgresion() es un procedimiento.
La clase Progresion también incluye un método Progresion(), el cual es
un constructor. Los constructores configuran todas las variables de instancia
al momento que un objeto de esta clase es creado. El objetivo de la clase
Progresion es ser una superclase desde la cual las clases especializadas
hereden, ası́ el constructor está codificado por lo que será incluido en los
constructores de cada clase que extienda la clase Progresion.
1 public class Progresion {
2 /* * Primer valor de la progresi ó n . */
3 protected long primero ;
4 /* * Valor actual de la progresi ó n . */
5 protected long actual ;
6 /* * Constructor por defecto . */
7 Progresion () {
8 actual = primero = 0;
9 }
10 /* * Reinciar la progresi ó n al primer valor .
11 *
12 * @return primer valor
13 */
14 protected long primerValor () {
15 actual = primero ;
16 return actual ;
17 }
18 /* * Avanzar la progresi ó n al siguiente valor .
19 *
20 * @return siguiente valor de la progresi ó n
21 */
22 protected long si guienteV alor () {
23 return ++ actual ; // siguiente valor por defecto
24 }
25 /* * Imprimir los primeros n valores de la progresi ó n
26 *
27 * @param n n ú mero de valores a imprimir
28 */
29 public void m o s t r a r P r o g r e s i o n ( int n ) {
30 System . out . print ( primerValor ());
31 for ( int i = 2; i <= n ; i ++)
32 System . out . print ( " " + sigui enteValo r ());
33 System . out . println (); // salto del l ı́ nea
34 }
35 }
Listado 2.2: Clase progresión numérica general.

Una clase de progresión aritmética
Se considera ahora el diseño de la clase ProgresionAritmetica, la cual se

muestra en el listado 2.3. Esta clase define una progresión aritmética, donde
el siguiente valor es determinado agregando un incremento constante, inc, al
valor previo. ProgresionAritmetica hereda los campos primero y actual y
los métodos primerValor() y mostrarProgresion() de la clase Progresion.
Además esta agrega un campo nuevo, inc, para guardar el incremento, y dos
constructores para configurar el incremento. ProgresionAritmetica anula
el método siguienteValor() para calcular el siguiente valor de acuerdo a
una progresión aritmética.
El polimorfismo es usado en las clases señaladas previamente. Cuando una
referencia Progresion está apuntando a un objeto ProgresionAritmetica,
entonces los constructores y siguienteValor() de ProgresionAritmetica
serán usados. El polimorfismo está también disponible dentro de la ver-
sión heredada de mostrarProgresion(), ya que las llamadas a los métodos
primerValor() y siguienteValor() están implı́citas para el objeto actual,
siendo de la clase Progresion y de la clase ProgresionAritmetica respecti-
vamente.
1 class P r o g r e s i o n A r i t m e t i c a extends Progresion {
2 /* * Incremento . */
3 protected long inc ;
4 // Se heredan las variables primero y actual de Progresion .
5 /* * Constructor por defecto que fija un incremento unitario . */
6 P r o g r e s i o n A r i t m e t i c a () {
7 this (1);
8 }
9 /* * Constructor parametrizado que proporciona el incremento . */
10 P r o g r e s i o n A r i t m e t i c a ( long incremento ) {
11 inc = incremento ;
12 }
13 /* * Avanza la progresi ó n agregando el incremento al valor actual .
14 *
15 * @return valor siguiente de la progresi ó n .
16 */
17 protected long si guiente Valor () {
18 actual += inc ;
19 return actual ;
20 }
21 // Se heredan los m é todos primerValor () y m o s t r a r P r o g r e s i o n ( int ).
22 }
Listado 2.3: Clase para progresiones aritméticas que extiende a la clase Progresión
(listado 2.2).
Ejemplo de constructores y this
En la definición de la clase ProgresionAritmetica, se agregaron dos

constructores, uno por defecto, el cual no toma parámetros, y el otro con
un parámetro, el cual toma un parámetro entero como el incremento de la
progresión. El constructor por defecto llama al de un parámetro, usando
this y pasando un uno como el parámetro incremento. Los dos constructores
muestran sobrecarga de método, ya que un método es especificado por su
nombre, la clase del objeto que llama, y los tipos de argumentos que son
pasados a este. En este caso, la sobrecarga es para los constructores, un
constructor por defecto y un constructor parametrizado.
La llamada this(1), lı́nea 13, listado 2.3, al constructor parametrizado

como la primera sentencia del constructor por defecto lanza una excepción
a la regla encadenamiento constructor general revisada en la sección 2.2.3.
Es decir, siempre que la primera sentencia de un constructor C 0 llama otro
constructor C 00 de la misma clase usando la referencia this, el constructor de la
superclase no es implı́citamente llamado por C 0 . Observar que el constructor de
la superclase será eventualmente llamado en la cadena, ya sea explı́citamente
o implı́citamente.
Una clase de progresión geométrica
La clase ProgresionGeometrica, listado 2.4, incrementa y muestra una

progresión geométrica, donde el siguiente valor se calcula multiplicando el
valor previo por una base fija, base. Una progresión geométrica es parecida a
una progresión general, excepto en la forma como se determina el siguiente
valor. Por lo anterior, ProgresionGeometrica es declarada como una sub-
clase de la clase Progresion. ProgresionGeometrica hereda los campos
primero y actual, y los métodos primerValor() y mostrarProgresion()
de Progresion.
1 /* *
2 * Progresi ó n geom é trica
3 */
4 class P r o g r e s i o n G e o m e t r i c a extends Progresion {
5 /* * Base . */
6 protected long base ;
7 // Se heredan las variables primero y actual
8 /* * Constructor por defecto poniendo base 2. */
9 P r o g r e s i o n G e o m e t r i c a () {
10 this (2);
11 }
12 /* * Constructror parametrizado que proporciona la base .
13 *
14 * @param b base de la progresi ó n .
15 */
16 P r o g r e s i o n G e o m e t r i c a ( long b ) {
17 base = b ;
18 primero = 1;
19 actual = primero ;
20 }
21 /* * Avanza la progresi ó n multiplicando la base con el valor actual .
22 *
23 * @return siguiente valor de la progresi ó n
24 */
25 protected long si guiente Valor () {
26 actual *= base ;
27 return actual ;
28 }
29 // Se heredan los m é todos primerValor () e i m p r i m i r P r o g r e s i o n ( int ).
30 }
Listado 2.4: Clase para progresiones geométricas.
Una clase de progresión Fibonacci

Se define la clase ProgresionFibonacci, listado 2.5, que representa la
progresión Fibonacci, donde el siguiente valor es la suma del valor actual
y del previo. Se usa un constructor parametrizado en la clase Progresion-
Fibonacci para dar una forma diferente de iniciar la progresión.
1 /* *
2 * Progresi ó n de Fibonacci
3 */
4 class P r o g r e s i o n F i b o n a c c i extends Progresion {
5 /* * Valor previo . */
6 long prev ;
7 // Se heredan las variables primero y actual
8 /* * Constructor por defecto poniendo 0 y 1 como los primeros dos valores . */
9 P r o g r e s i o n F i b o n a c c i () {
10 this (0 , 1);
11 }
12 /* * Constructor param é trizado dando el primer valor y el segundo .
13 *
14 * @param valor1 primer valor .
15 * @param valor2 segundo valor .
16 */
17 P r o g r e s i o n F i b o n a c c i ( long valor1 , long valor2 ) {
18 primero = valor1 ;
19 prev = valor2 - valor1 ; // valor ficticio precediendo al primero
20 }
21 /* * Avanza la progresi ó n agregando el valor previo al valor actual .
22 *
23 * @return valor siguiente de la progresi ó n
24 */
25 protected long si guienteV alor () {
26 long temp = prev ;
27 prev = actual ;
28 actual += temp ;
29 return actual ;
30 }
31 // Se heredan los m é todos primerValor () e i m p r i m i r P r o g r e s i o n ( int ).
32 }
Listado 2.5: Clase para la progresione Fibonacci.

La clase ProbarProgresion, listado 2.6, realiza una prueba simple de
cada una de las tres subclases anteriores. La variable prog es polimórfica
porque se asignan referencias objeto de la subclases Progresion.
1 /* * Aplicaci ó n para las clases progresion */
2 class P r o b a r P r o g r e s i o n {
4 Progresion prog ;
5 // probar P r o g r e s i o n A r i t m e t i c a
6 System . out . println ( " La progresi ó n aritm é tica con el incremento por defecto : " );
7 prog = new P r o g r e s i o n A r i t m e t i c a ();
8 prog . m o s t r a r P r o g r e s i o n (10);
9 System . out . println ( " Progresi ó n aritm é tica con incremento 5: " );
10 prog = new P r o g r e s i o n A r i t m e t i c a (5);
12 // probar P r o g r e s i o n G e o m e t r i c a
13 System . out . println ( " Progresi ó n geom é trica con base por defecto : " );
14 prog = new P r o g r e s i o n G e o m e t r i c a ();
16 System . out . println ( " Progresi ó n geom é trica con base 3: " );
17 prog = new P r o g r e s i o n G e o m e t r i c a (3);
19 // probar P r o g r e s i o n F i b o n a c c i
20 System . out . println ( " Progresi ó n de Fibonacci con valores de inicio por defecto : " );
21 prog = new P r o g r e s i o n F i b o n a c c i ();
23 System . out . println ( " Progresion de Fibonacci iniciando con valores 4 y 6: " );
24 prog = new P r o g r e s i o n F i b o n a c c i (4 ,6);
26 }
27 }
Listado 2.6: Aplicación para probar las clases progresión.

2.3 Excepciones 63
Al ejecutar la aplicación ProbarProgresion genera la siguiente salida:

La progresión aritmética con el incremento por defecto:
0 1 2 3 4 5 6 7 8 9
Progresión aritmética con incremento 5:
0 5 10 15 20 25 30 35 40 45
Progresión geométrica con base por defecto:
1 2 4 8 16 32 64 128 256 512
Progresión geométrica con base 3:
1 3 9 27 81 243 729 2187 6561 19683
Progresión de Fibonacci con valores de inicio por defecto:
0 1 1 2 3 5 8 13 21 34
Progresion de Fibonacci iniciando con valores 4 y 6:
4 6 10 16 26 42 68 110 178 288
La clase Progresion, sus subclases, y el programa de prueba tienen una
cantidad de fallas. Un problema se presenta con la progresión geométrica y la
de Fibonacci porque crecen rápidamente, y no se realiza algo para manejar el
sobreflujo inevitable de los enteros largos involucrados. Por ejemplo, como
340 > 263 , una progresión geométrica con base tres desbordará un entero largo
después de 40 iteraciones. De igual modo, el 94o (nonagésimo cuarto) número
de Fibonacci es mayor que 264 ; ası́, la progresión de Fibonacci desbordará un
entero largo después de 94 iteraciones. Otro problema es que no se deberı́a
permitir iniciar una progresión Fibonacci con valores arbitrarios. Manejar
errores de entrada o de condición que suceden en la ejecución de un programa
Java requiere de un mecanismo que lo maneje. Este se comenta en la siguiente
sección.
2.3. Excepciones
Las excepciones son eventos no esperados que ocurren en la ejecución
de un programa. Una excepción se puede deber a una condición de error o
una entrada no anticipada. Las excepciones, en Java, pueden ser vistas como
objetos.
2.3.1. Lanzamiento de excepciones

Las excepciones son objetos que son lanzados por el código que encuentra
algún tipo de condición no esperada. También pueden ser lanzadas por el
ambiente de ejecución cuando se encuentra una condición no esperada, como

ejecución fuera de memoria. Una excepción lanzada es atrapada por otro
código que “maneja” la excepción de algún modo, o el programa es terminado
inesperadamente.
Las excepciones se originan cuando una pieza de código Java encuentra
algún tipo de problema durante la ejecución y lanza un objeto excepción. Es
conveniente dar un nombre descriptivo a la clase del objeto excepción. Por
ejemplo, si se intenta borrar el décimo elemento de una secuencia que tiene sólo
cinco elementos, el código podrı́a lanzar una ExcepcionViolacionLimites.
Esta acción podrı́a hacerse usando el siguiente fragmento de código:
if (indice >= A.length)

throw new
ExcepcionViolacionLimites("Índice "+indice+" inválido.");
Es conveniente instanciar un objeto excepción al momento que la excepción

tiene que ser lanzada. Ası́, una sentencia throw se usa como sigue:
throw new tipo excepción(param 0, param 1,. . . );
donde tipo excepción es el tipo de la excepción y los param i forman la

lista de parámetros para un constructor de este tipo de excepción.
Las excepciones son también lanzadas por el propio ambiente de ejecución
Java. Por ejemplo, si se tiene un arreglo de seis elementos y se pide el
noveno elemento, entonces la excepción ArrayIndexOutOfBoundsException
es lanzada por el sistema de ejecución Java.
La cláusula throws
Al declarar un método es apropiado indicar las excepciones que podrı́a
lanzar, debido a que tiene un propósito funcional y de cortesı́a. Le permite al
usuario saber que esperar y le indica al compilador las excepciones a las que
se debe preparar. Enseguida se muestra un ejemplo de tal definición en un
método:
public void irCompras() throws

ExcepcionListaComprasCorta, ExcepcionSinDinero {
// cuerpo del método ...
}
2.3 Excepciones 65
Indicando todas las excepciones que podrı́an ser lanzadas por un método,
se prepara a otros para que puedan manejar todos los casos excepcionales que
podrı́an surgir por usar este método. Otro beneficio de declarar excepciones es
que no se necesitan atrapar estas excepciones en el método. En ocasiones esto
es apropiado cuando otro código es el responsable del origen de la excepción.
Se muestra enseguida una excepción que es “pasada”:
public void estarListoParaClases() throws

ExcepcionListaComprasCorta, ExcepcionSinDinero {
irCompras();
/* no se tiene que intentar o atrapar las excepciones
que irCompras() podrı́a lanzar, ya que estarListo-
ParaClase() las pasará de largo.
*/
hacerGalletas();
}
Un método puede declarar lanzar tantas excepciones como se quiera. Tal

lista puede simplificarse si todas las excepciones lanzadas son subclases de la
misma excepción. En tal caso, sólo se tiene que declarar que un método lanza
la superclase apropiada.
Tipos de lanzables
Java define las clases Exception y Error como subclases de Throwable.

Throwable indica que cualquier objeto podrı́a ser lanzado y atrapado. La
clase RuntimeException está definida como subclase de Exception. La clase
Error es usada para condiciones anormales en el ambiente de ejecución, como
agotamiento de memoria. Los errores pueden ser atrapados, pero quizás no se
deberı́a, porque estos avisan de problemas que no pueden ser manejados apro-
piadamente. Un mensaje de error o una repentina terminación de programa
está más allá de lo manejable. La clase Exception es la raı́z de la jerarquı́a
excepción. Excepciones especializadas, como ExcepcionViolacionLimites,
deberı́an ser definidas como subclases de Exception o de RuntimeException.
Las excepciones que no son subclases de RuntimeException deberán ser
declaradas en la cláusula throws de cualquier método que pueda lanzarla.
2.3.2. Atrapar excepciones

Cuando una excepción es lanzada, esta deber ser atrapada o el programa
terminará. En cualquier método particular, una excepción puede ser pasada al
método llamador o puede ser atrapada en el método. Cuando una excepción
es atrapada, esta puede ser analizada y manejada. La forma para manejar las
excepciones es try (intentar) ejecutar alguna porción de código que podrı́a
lanzar una excepción. Si se lanza una excepción, entonces la excepción es
atrapada y el flujo de control pasa a un bloque catch predefinido con el
código para manejar la excepción.
La sintaxis para un bloque try...catch es:
try {
bloque principal de sentencias
} catch(tipo excepcion1 variable 1) {
bloque de sentencias 1
} catch(tipo excepcion2 variable 2) {
bloque de sentencias 2
...
} finally {
bloque de sentencias n
}
donde debe haber al menos un catch, siendo finally opcional. Cada tipo -
de sentencias i es el tipo de alguna excepción.
El ambiente de ejecución Java inicia ejecutando un bloque try...catch
con la ejecución del bloque de sentencias, bloque principal de sentencias.
Si esta ejecución no genera excepciones, entonces el flujo de control sigue
con la primera sentencia después de la última lı́nea del bloque completo
try...catch, a menos que se incluya la parte finally opcional.
Por otra parte, si el bloque, bloque principal de sentencias, genera
una excepción, entonces la ejecución en el bloque try...catch termina en
ese punto y la ejecución pasa al bloque catch cuyo tipo excepcion sea más
cercana a la excepción lanzada. La variable para esta sentencia catch refiere
al propio objeto excepción, el cual puede ser usado en el bloque de la sentencia
catch apareado. Una vez que la ejecución de ese bloque catch se completa,
el flujo de control es pasado al bloque finally opcional, si este existe, o a la
primera sentencia después de la última lı́nea del bloque try...catch. De otra
forma, si no hay bloque catch que empate la excepción lanzada, entonces el
2.3 Excepciones 67
control es pasado al bloque finally opcional, si existe, y luego la excepción

es lanzada de regreso al método llamador.
Considerar el siguiente ejemplo del fragmento de código:
int indice = Integer.MAX VALUE; // -1+2E31
try { // El código podrı́a tener un problema ...
String aComprar = listaCompras[indice];
}
catch (ArrayIndexOutOfBoundsException e) {
System.out.println("Índice "+indice+" inválido.");
}
Si el código anterior no atrapa una excepción lanzada, entonces el flujo
de control saldrá inmediatamente del método y regresará al código que
llamó al método. En el método que hizo la llamada, el ambiente de ejecución
buscará nuevamente por un bloque catch. Si no lo hay, el flujo de control
pasará al que hizo la llamada para ir a ese método, y ası́ sucesivamente.
Eventualmente, si ningún código atrapa la excepción, el ambiente de ejecución,
el originador del flujo de control del programa, atrapará la excepción. En
este punto, un mensaje de error y la traza de la pila es mostrada en la salida
estándar y el programa es terminado.
El siguiente es un mensaje de error en tiempo de ejecución:
java.lang.NuIlPointerException: Returned a null locator
at java.awt.Component.handleEvent(Component.java:900)
at java.awt.Component.postEvent(Component.java:838)
at java.awt.Component.postEvent(Component.java:845)
at sun.awt.motif.MButtonPeer.action(MButtonPeer.java:39)
at java.lang.Thread.run(Thread.java)
Una vez que una excepción es atrapada, hay varias cosas que un progra-
mador podrı́a querer hacer. Una posibilidad es mostrar un mensaje de error y
terminar el programa. También hay algunos casos interesantes en los cuales
la mejor forma para manejar una excepción es ignorarla (usando un bloque
catch vacı́o).
Ignorar una excepción es hecho usualmente, por ejemplo, cuando el pro-
gramador no le importa si hay o no hay excepción. Otra manera legı́tima
de manejar excepciones es creando y lanzando otra excepción, quizás una
que indique la condición excepcional más precisa. El siguiente código es un
ejemplo de esta forma:
catch (ArrayIndexOutOfBoundsException e) {
throw new ExcepciónListaComprasCorta(
"Índice del producto no está en lista de compras");
}
La mejor forma de manejar una excepción, aunque no siempre es posible,
es encontrar el problema, arreglarlo, y continuar la ejecución.
2.4. Interfaces y clases abstractas

Para que dos objetos puedan interactuar, estos deben “conocer” acerca de
los mensajes que cada uno podrá aceptar, es decir, los métodos que cada objeto
soporta. Para reforzar este “conocimiento”, el paradigma del diseño orientado
al objeto requiere que las clases indiquen la interfaz de programación de
aplicaciones o API (Application Programming Interface), o interfaz, que
sus objetos presentan a otros objetos. En la aproximación ADT usada, sección
2.1.2, para estructuras de datos en este texto, una interfaz definiendo un ADT
es indicado como un tipo definición y una colección de métodos para este tipo,
con los argumentos para cada método siendo de tipos especificados. En su
momento, esta especificación es reforzada por el compilador o el sistema de
ejecución, los cuales requieren que los tipos de los parámetros que son pasados
a los métodos sean del tipo indicado en la interfaz. Este requerimiento es
conocido como tipado fuerte. El programador es obligado a tener que definir
interfaces y usar en estas tipado fuerte, pero esta carga es recompensada, por
obligar a emplear el principio de encapsulación y porque atrapa errores de
programación que de otra forma no se sabrı́an.
2.4.1. Implementación de interfaces

El elemento estructural principal en Java que forza una API es la interfaz.
Una interfaz es una colección de declaraciones de métodos sin datos y sin
cuerpos. Es decir, los métodos de una interfaz siempre están vacı́os, son sólo
firmas de métodos. Cuando una clase implementa una interfaz, deberá im-
plementar todos los métodos declarados en la interfaz. De esta forma, las
interfaces hacen cumplir los requisitos que una clase implementadora tenga
métodos con ciertas firmas especificadas.
Por ejemplo, suponer que se quiere crear un inventario de antigüedades,
categorizadas como objetos de tipos varios y con propiedades diversas. Se
2.4 Interfaces y clases abstractas 69
podrı́a querer identificar algunos de los objetos como vendibles, en tal caso
estos deberı́an implementar la interfaz Vendible, listado 2.7.
1 /* * Interfaz para objetos que pueden ser vendidos . */

2 public interface Vendible {
3
4 /* * descripci ó n del objeto */
5 public String descripcion ();
6
7 /* * precio de lista */
8 public float precioLista ();
9
10 /* * precio m ı́ nimo de venta */
11 public float precioMinimo ();
12 }
Listado 2.7: Interfaz Vendible.
Después se puede definir una clase concreta, Fotografia, listado 2.8,

que implementa la interfaz Vendible, para indicar que se estarı́a dispuesto
a vender cualquiera de los objetos fotografı́a. Esta clase define un objeto
que implementa cada uno de los métodos de la interfaz Vendible, como se
requiere. Ademas, agrega el método esColor() especializado para objetos
Fotografia.
1 /* * Clase para fotograf ı́ as que pueden ser vendidas . */

2 public class Fotografia implements Vendible {
3 private String descripcion ;
4 private float precio ; // precio puesto
5 private boolean color ; // true si foto es a color
6
7 // constructor
8 public Fotografia ( String d , float p , boolean c ) {
9 descripcion = d ;
10 precio = p ;
11 color = c ;
12 }
13
14 public String descripcion () { return descripcion ; }
15 public float precioLista () { return precio ; }
16 public float precioMinimo () { return precio /4; }
17 public boolean esColor () { return color ; }
18 }
Listado 2.8: Clase Fotografia implenentando la interfaz Vendible.
Otro tipo de antigüedades en el inventario podrı́a ser algo que se deba

transportar. Para tales objetos, se define la interfaz Transportable, listado

2.9.
1 /* * Interfaz para objetos que pueden ser transportados . */
2 public interface Transportable {
3
4 /* * peso en gramos */
5 public int peso ();
6
7 /* * si el objeto es peligroso */
8 public boolean esPeligroso ();
9 }
Listado 2.9: Interfaz Transportable.
Se podrı́a luego definir la clase ArticuloEmpacado, listado 2.10, para

antigüedades diversas que puedan ser vendidas, empacadas, y enviadas. Por
lo tanto, la clase ArticuloEmpacado implementa los métodos de la interfaz
Vendible y Transportable, además también se agregan los métodos espe-
cializados para poner un seguro y las dimensiones de un artı́culo empacado.
La clase ArticuloEmpacado muestra otra caracterı́stica de las clases y las
interfaces, una clase puede implementar varias interfaces, lo cual da flexibilidad
cuando se definen clases que deberı́an cumplir varias API. Mientras que
una clase en Java puede extender solamente una clase, puede sin embargo
implementar varias interfaces.
2.4.2. Herencia múltiple en interfaces

La habilidad de extender de más de una clase se conoce como herencia
múltiple. En Java, herencia múltiple está permitida para interfaces pero
no para clases. En Java no se permite la herencia múltiple en clases, por la
posible confusión cuando una clase intente extender de dos clases que tengan
métodos con cuerpo diferente y firma igual. Esta confusion no existe en las
interfaces porque sus métodos están vacı́os. Al no haber confusión, la herencia
múltiple de interfaces es útil.
En Java, el uso de herencia múltiple de interfaces es para aproximar una
técnica de herencia múltiple llamada mezcla. Se mezclan los métodos de dos o
más interfaces no relacionadas para definir una interface que combine su funcio-
nalidad, posiblemente agregando más métodos por su cuenta. Para el ejemplo
de los objetos antigüedad, se podrı́a definir la interfaz ArticuloAsegurable
para los artı́culos asegurados, como se muestra enseguida:
2.4 Interfaces y clases abstractas 71
1 /* * Clase para objetos que pueden ser vendidos , empacados ,

2 * y enviados . */
3 public class A r t i c u l o E m p a c a d o implements Vendible , Transportable {
4 private String descripcion ;
5 private float precio ;
6 private int peso ;
7 private boolean pelig ;
8 private int largo = 0; // largo empaque en cm
9 private int ancho = 0; // ancho empaque en cm
10 private int alto = 0; // alto empaque en cm
11 /* * Constructor */
12 public A r t i cu l o E m p a c a d o ( String d , float p , int pes , boolean pel ) {
13 descripcion = d ;
14 precio = p ;
15 peso = pes ;
16 pelig = pel ;
17 }
18 public String descripcion () { return descripcion ; }
19 public float precioLista () { return precio ; }
20 public float precioMinimo () { return precio /4; }
21 public int peso () { return peso ; }
22 public boolean esPeligroso () { return pelig ; }
23 public float v alorAseg urado () { return precio *1.5 f ; }
24 public void setCaja ( int l , int an , int al ) {
25 largo = l ;
26 ancho = an ;
27 alto = al ;
28 }
29 }
Listado 2.10: Clase ArticuloEmpacado

public interface ArticuloAsegurable

extends Transportable, Vendible {
/** Devolver el valor asegurado */
public int valorAsegurado();
}
La interfaz ArticuloAsegurable mezcla los métodos de la interfaz Trans-

portable con los métodos de la interfaz Vendibles, y agrega el método extra
valorAsegurado(). La interfaz ArticuloAsegurable podrı́a permitir definir
la clase ArticuloEmpacado como:
public class ArticuloEmpacado

implements ArticuloAsegurable {
// mismo código de la clase ArticuloEmpacado
}
Las interfaces de Java que aproximan la mezcla son: java.lang.Cloneable,

la cual agrega una caracterı́stica de copia para una clase; java.lang.-
Comparable, la cual agrega una caracterı́stica de comparación para una
clase; y java.util.Observer, la cual agrega una caracterı́stica de actualiza-
ción a una clase que quiere ser notificada cuando ciertos objetos “observables”
cambien de estado.
2.4.3. Clases abstractas y tipado fuerte

Una clase abstracta es una clase que contiene declaraciones de métodos
vacı́os, o sea, declaraciones de métodos sin cuerpo, y posiblemente definiciones
de métodos concretos y variables de instancia. Ası́, una clase abstracta
está entre una interfaz y una clase concreta. Al igual que una interfaz, una
clase abstracta no puede ser instanciada, o sea, crear un objeto desde la clase
abstracta. Una subclase de una clase abstracta deberá dar una implementación
para los métodos abstractos de su superclase, a menos que esta misma sea
abstracta. Al igual que una clase concreta, una clase abstracta A puede
extender otra clase abstracta, y clases abstractas o concretas pueden también
extender a A. Una clase nueva que no sea abstracta y extienda superclases
abstractas deberá implementar todos los métodos abstractos. Una clase
abstracta usa el estilo de especificación de herencia, pero también permite la
especialización y estilos de extensión.
2.5 Conversiones y genéricos 73
La clase java.lang.Number
Las clases número Java, cuadro 1.2, especializan la clase abstracta java.-
lang.Number. Cada clase número concreta, tales como java.lang.Integer
y java.lang.Double, extienden la clase java.lang.Number y completan los
detalles para los métodos abstractos de la superclase. Por ejemplo, los métodos
intValue(), floatValue(), longValue(), y doubleValue() son todos abs-
tractos en java.lang.Number. Cada clase número concreta deberá especificar
los detalles de estos métodos.
Tipado fuerte
Un objeto puede ser visto como siendo de varios tipos. El tipo primario de
un objeto o es la clase C indicada al momento que o fue instanciado. Además,
o es del tipo S para cada superclase S de C y es del tipo I para cada interfaz
I implementada por C.
Sin embargo, una variable puede ser declarada para ser de un sólo tipo,
ya sea clase o interfaz, la cual determina como la variable es usada y como
ciertos métodos actuarán en esta. De igual forma, un método tiene un único
tipo de regreso. En general, una expresión tiene un tipo único.
La técnica de tipado fuerte de Java, forzar a que todas las variables sean
tipadas y que los métodos declaren el tipo que se espera y que se regresa,
ayuda a prevenir errores. Pero por los requerimientos rı́gidos con tipos, es en
ocasiones necesario cambiar, o convertir, un tipo en otro. Tales conversiones
podrı́an tener que ser especificadas por un operador de conversión explı́cito.
En la sección 1.3.3 se indica como convertir a tipos base. En la siguiente
sección se indica como se realizan las conversiones para variables referencia.
2.5. Conversiones y genéricos
2.5.1. Conversiones para objetos

Se comenta enseguida varios métodos para conversiones de tipo para
objetos.
Conversiones anchas
Una conversión ancha ocurre cuando un tipo T es convertido a un tipo
U “amplio”. Los siguientes son casos comunes de conversiones anchas:
T y U son tipos clase y U es una superclase de T.
T y U son tipos interfaz y U es una superinterfaz de T.
T es una clase que implementa la interfaz U.
Las conversiones anchas son hechas automáticamente para guardar el
resultado de una expresión en una variable, sin la necesidad de una conversión
explı́cita. Por lo tanto, se puede asignar directamente el resultado de una
expresión de tipo T en una variable v de tipo U cuando la conversión de T
a U es una conversión ancha. El siguiente fragmento de código muestra una
expresión de tipo Integer, un objeto nuevo construido, asignándose a una
variable de tipo Number.
Integer i = new Integer(3);
Number n = i; // conversión ancha
La correctez de una conversión ancha es revisada por el compilador y su
validez no requiere prueba por el ambiente de ejecución Java al ejecutar el
programa.
Conversiones estrechas
Una conversión estrecha ocurre cuando un tipo T es convertido a un
tipo S “estrecho”. Los siguientes son casos comunes de conversiones estrechas:
T y S son tipos clase y S es una subclase de T.
T y S son tipos interfaz y S es una subinterfaz de T.
T es una interfaz implementada por la clase S.
En general, una conversión estrecha de tipos referencia necesita una
conversión explı́cita. También, la correctez de una conversión estrecha podrı́a
no ser verificada por el compilador. Por lo tanto, su validación deberı́a ser
probada por el ambiente de ejecución en la ejecución del programa.
El siguiente fragmento de código ejemplo muestra como usar una conversión
para realizar una conversión estrecha desde el tipo Number al tipo Integer.
Number n = new Integer(2); // conv. ancha Integer->Number

Integer i = (Integer) n; // conv. estrecha Number->Integer
En la primera sentencia, un objeto nuevo de la clase Integer es creado y

asignado a una variable n del tipo Number. Ası́, una conversión ancha ocurre
y no se ocupa conversión. En la segunda sentencia, se asigna n a una variable
i del tipo Integer usando una conversión. La asignación es posible porque n
se refiere a un objeto del tipo Integer. Sin embargo, como la variable n es
del tipo Number, una conversión estrecha ocurre y la conversión es necesaria.
Excepciones en conversiones
Se puede convertir una referencia objeto o de tipo T en un tipo S, si el
objeto o referido es en realidad del tipo S. Por otra parte, si el objeto o no
es del tipo S, entonces intentar convertir o al tipo S lanzará la excepción
ClassCastException. Lo anterior se presenta en el siguiente fragmento de
código:
Number n;
Integer i;
n = new Integer(3);
i = (Integer) n; // válido
n = new Double(3.1416);
i = (Integer) n; // no válido
Para evitar problemas como el anterior y evitar poner en el código bloques

try...catch cada vez que se haga una conversión, Java proporciona una
forma de asegurarse que una conversión objeto será correcta mediante el
operador, instanceof, el cual prueba si una variable objeto se refiere a un
objeto de una cierta clase o implementa una cierta interfaz. La sintaxis es:
referencia objeto instanceof tipo referencia
siendo referencia objeto una expresión que evalúa a una referencia objeto
y tipo referencia es el nombre de alguna clase, interfaz, o enumeración exis-
tente. Si referencia objeto es una instancia de tipo referencia entonces
el operador da true, de otra forma da false. Para evitar una excepción
ClassCastException que lanzarı́a el código previo, se deberá modificar de
la siguiente forma:
Number n;
Integer i;
n = new Integer(3);
if (n instanceof Integer)
i = (Integer) n; // válido
n = new Double(3.1416);
if (n instanceof Integer)
i = (Integer) n; // no será intentado
Conversiones con interfaces

Las interfaces permiten obligar que los objetos implementen ciertos méto-
dos, pero usando variables interfaz con objetos concretos en ocasiones se
requiere conversión. Suponer que se declara una interfaz Persona, listado 2.11.
Observar que el método igualA() de la interfaz Persona toma un parámetro
de tipo Persona. De esta forma, se puede pasar un objeto de cualquier clase
que implemente la interfaz Persona a este método.
1 public interface Persona {

2 public boolean igualA ( Persona otra ); // ¿ misma persona ?
3 public String getNombre (); // obtener nombre de la persona
4 public int getEdad (); // obtener edad de la persona
5 }
Listado 2.11: Interfaz Persona
En la clase Estudiante, listado 2.12, se implementa la interfaz Persona.

Se asume en el método igualA() que el argumento, declarado de tipo Persona,
es también del tipo Estudiante y se realiza una conversión estrecha del tipo
Persona, una interfaz, al tipo Estudiante, una clase, con una conversión
explı́cita. La conversión es permitida en este caso, porque es una conversión
estrecha desde una clase T a una interfaz U, en donde se tiene un objeto
tomado desde T tal que T extiende S y S implementa U.
Se requiere asegurar que en la implementación del método igualA() de la
clase Estudiante, no se intente la comparación de objetos Estudiante con
otros tipos de objetos, o de otra forma, la conversión en el método igualA()
fallará.
La posibilidad de realizar conversiones estrechas desde tipos interfaz a
tipos clase permite escribir tipos generales de estructuras de datos que sólo
1 public class Estudiante implements Persona {

2 String id ;
3 String nombre ;
4 int edad ;
5 public Estudiante ( String i , String n , int e ) {
6 id = i ;
7 nombre = n ;
8 edad = e ;
9 }
10 protected int horasEstudio () { return edad /3; }
11 public String getId () { return id ; } // id del estudiante
12 public String getNombre () { return nombre ; } // de interfaz
13 public int getEdad () { return edad ; } // de interfaz
14 public boolean igualA ( Persona otra ) { // de interfaz
15 Estudiante otr oEstudi ante = ( Estudiante ) otra ;
16 return ( id . equals ( otr oEstudi ante . getId ()));
17 }
18 public String toString () { // para mostrar
19 return " Estudiante ( Id : " + id +
20 " , Nombre : " + nombre +
21 " , Edad : " + edad + " ) " ;
22 }
23 }
Listado 2.12: Clase Estudiante implementando la interfaz Persona
hagan suposiciones mı́nimas acerca de los elementos que guardan. Se bosqueja

enseguida como construir un directorio para guardar parejas de objetos que
implementan la interfaz Persona. El método quitar() realiza una búsqueda
en el contenido del directorio y quita el par de personas indicadas, si existe, y
al igual que el método encontrarOtra(), usa el método igualA() para la
búsqueda.
public class DirectorioPareja {

// ... variables de instancia ...
public DirectorioPareja() { }
public void insertar(Persona persona, Persona otra) { }
public Persona encontrarOtra(Persona persona) {
return null ;
}
public void quitar (Persona persona, Persona otra) { }
}
Suponer que se ha llenado un directorio, miDirectorio, con parejas de

objetos Estudiante que representan parejas de compañeros de cuarto. Para
lograr encontrar el compañero de cuarto de un objeto Estudiante dado,

estudiante1, se podrı́a intentar hacer lo siguiente, lo cual está mal:
Estudiante estudiante2 =
miDirectorio.encontrarOtra(estudiante1);
Esta sentencia provoca un error de compilación “explicit-cast-required ”

(conversión explı́cita requerida), debido a que se intenta hacer una conver-
sión estrecha sin una conversión explı́cita. Es decir, el valor devuelto por
el método encontrarOtra() es del tipo Persona mientras que la variable
estudiante2, a la cual es asignada, es del tipo estrecho Estudiante, una
clase que implementa la interfaz Persona, Ası́, se debe hacer una conversión
del tipo Persona al tipo Estudiante, como se muestra enseguida:
Estudiante estudiante2 =
(Estudiante)miDirectorio.encontrarOtra(estudiante1);
Convertir el valor del tipo Persona regresado por el método encontrar-

Otra() al tipo Estudiante trabaja bien siempre que se asegure que la
llamada a miDirectorio.encontrarOtra() realmente devuelva un objeto
Estudiante. En general, las interfaces pueden ser una herramienta valiosa
para el diseño de estructuras de datos generales, las cuales pueden entonces
ser especializados por otros programadores usando la conversión.
2.5.2. Genéricos
A partir de Java 5.0 se incluye una estructura genérica para usar
tipos abstractos con la finalidad de evitar conversiones de tipos. Un tipo
genérico es un tipo que no está definido en tiempo de compilación, pero queda
especificado completamente en tiempo de ejecución. La estructura genérica
permite definir una clase en términos de un conjunto de parámetros de
tipo formal, los cuales podrı́an ser usados, por ejemplo, para abstraer los
tipos de algunas variables internas de la clase. Se usan paréntesis angulares
(<>) para encerrar la lista de los parámetros de tipo formal. Aunque cualquier
identificador válido puede ser usado para un parámetro de tipo formal, por
convención son usados los nombres de una sola letra mayúscula. Dada una
clase que ha sido definida con tales tipos parametrizados, se instancia un
objeto de esta clase usando los parámetros de tipo actual para indicar los
tipos concretos que serán usados.
En el listado 2.13, se muestra la clase Par que guarda el par llave-valor,

donde los tipos de la llave y el valor son especificados por los parámetros L y V,
respectivamente. El método main() crea dos instancias de esta clase, una para
un par String-Integer (por ejemplo, para guardar un tipo de dimensión y
su valor), y otro para un par Estudiante-Double (por ejemplo, para guardar
la calificación dada a un estudiante).
1 public class Par <L , V > { // entre < y > los par á metros de tipo formal
2 L llave ;
3 V valor ;
4 public void set ( L l , V v ) {
5 llave = l ;
6 valor = v ;
7 }
8 public L getLlave () { return llave ; }
9 public V getValor () { return valor ; }
10 public String toString () {
11 return " [ " + getLlave () + " , " + getValor () + " ] " ;
12 }
14 Par < String , Integer > par1 = new Par < String , Integer >();
15 par1 . set ( new String ( " altura " ) , new Integer (2));
16 System . out . println ( par1 );
17 Par < Estudiante , Double > par2 = new Par < Estudiante , Double >();
18 par2 . set ( new Estudiante ( " 8403725 A " ," Hector " ,14) , new Double (9.5));
19 System . out . println ( par2 );
20 }
21 }
Listado 2.13: Clase Par
La salida de la ejecución de la clase Par se muestra enseguida:
[altura, 2]
[Estudiante(Matricula: 8403725A, Nombre: Hector, Edad: 14), 9.5]
En el ejemplo, el parámetro del tipo actual puede ser un tipo arbitrario. Pa-
ra restringir el tipo de parámetro actual se puede usar la cláusula extends, co-
mo se muestra enseguida, donde la clase DirectorioParejaGenerico está de-
finida en términos de un parámetro de tipo genérico P, parcialmente especifi-
cado declarando que extiende la clase Persona.
public class DirectorioParejaGenerico<P extends Persona> {

// ... variables de instancia ...
public DirectorioParejaGenerico() { }
public void insertar(P persona, P otra) { }
public P encontrarOtra(P persona) { return null ; }
public void quitar (P persona, P otra) { }
}
Esta clase deberı́a ser comparada con la clase DirectorioPareja de la
sección 2.5.1. Dada la clase anterior, se puede declarar una variable refiriendo
a una instancia de DirectorioParejaGenerico, que guarde pares de objetos
de tipo Estudiante:
DirectorioParejaGenerico<Estudiante> miDirectorioEstudiante;
La estructura genérica permite definir versiones genéricas de métodos. En

este caso, se puede incluir la definición genérica entre los métodos modifi-
cadores. Por ejemplo, se muestra enseguida la definición de un método que
puede comparar las llaves de cualesquiera dos objetos Par, dado que sus llaves
implementen la interfaz Comparable:
public static <K extends Comparable,V,L,W> int
comparaPares(Par<K,V> p, Par<L,W> q) {
return p.getLlave().compareTo(q.getLlave());
// la llave de p implementa compareTo()
}
Una advertencia importante relacionada a los tipos genéricos es que
los elementos guardados en un arreglo no pueden ser de un tipo variable
o parametrizado. Java permite que un arreglo sea definido con un tipo
parametrizado, pero no permite que un tipo parametrizado sea usado para
crear un nuevo arreglo. Java permite que para un arreglo definido con un tipo
parametrizado sea inicializado con un arreglo nuevo no parametrizado, como
se muestra en la clase UsaPar, listado 2.14. Aún ası́, este mecanismo tardı́o
causa que el compilador de Java emita una advertencia, porque esto no es
tipado 100 % seguro.
1 public class UsaPar {

3 Par < String , Integer >[] a = new Par [10]; // correcto , pero da una advertencia
4 Par < String , Integer >[] b = new Par < String , Integer >[10]; // incorrecto
5 a [0] = new Par < String , Integer >(); // est á completamente bien
6 a [0]. set ( " Gato " ,10); // esta y la siguiente tambien est á n bien
7 System . out . println ( " Primer par es " + a [0]. getLlave ()+ " ," + a [0]. getValor ());
8 }
9 }
Listado 2.14: Ejemplo que muestra que un tipo parametrizado sea usado para crear
un nuevo arreglo.
Capı́tulo 3
Arreglos, listas enlazadas y

recurrencia
3.1. Que son las estructuras de datos

Una estructura de datos es un arreglo de datos en la memoria de
una computadora, y en algunas ocasiones en un disco. Las estructuras de
datos incluyen arreglos, listas enlazadas, pilas, árboles binarios, y tablas
de dispersión entre otros. Los algoritmos manipulan los datos en estas
estructuras de varias formas, para buscar un dato particular u ordenar los
datos.
3.1.1. Generalidades de las Estructuras de Datos

Una forma de ver las estructuras de datos es enfocándose en sus fortalezas
y debilidades. En el cuadro 3.1 se muestran las ventajas y desventajas de
las estructuras de datos que se revisarán, los términos que se usan serán
abordados en otros capı́tulos.
Las estructuras mostradas en el cuadro 3.1, excepto los arreglos, pueden

ser pensados como tipos de datos abstractos o ADT (Abstract Data
Type). Un ADT, de forma general, es una forma de ver una estructura de
datos: enfocándose en lo que esta hace e ignorando como hace su trabajo, es
decir, el ADT deberá cumplir con ciertas propiedades, pero la manera como
84 Arreglos, listas enlazadas y recurrencia
Estructura Ventajas Desventajas

Arreglo Inserción rápida, ac- Búsqueda y borrado
ceso muy rápido si se lento, tamaño fijo.
conoce el ı́ndice.
Arreglo ordenado Búsqueda más rápi- Inserción y borrado
da que el arreglo des- lento, tamaño fijo.
ordenado.
Pila Último en entrar es Acceso lento a otros
el primero en salir. elementos.
Cola El primero en entrar Acceso lento a otros
es el primero en salir. elementos.
Lista enlazada Inserción y borrado Búsqueda lenta.
rápido.
Árbol binario Búsqueda, inserción Complejo.
y borrado rápido si el
árbol permanece ba-
lanceado.
Árbol rojinegro Búsqueda, inserción Complejo.
y borrado rápido.
Árbol siempre balan-
ceado.
Árbol 2-3-4 Búsqueda, inserción Complejo.
y borrado rápido.
Árbol siempre balan-
ceado.
Tabla de disper- Acceso muy rápido si Borrado lento, acce-
sión se conoce la llave. In- so lento si no se cono-
serción rápida. ce la llave, uso inefi-
ciente de la memoria.
Montı́culo Inserción, borrado y Acceso lento a otros
acceso al elemento elementos.
más grande rápido
Grafo Modela situaciones Algunos algoritmos
del mundo real son lentos y comple-
jos.
Cuadro 3.1: Caracterı́sticas de las Estructuras de Datos

3.2 Arreglos 85
estará implementado puede variar, aún empleando el mismo lenguaje. Por

ejemplo, el ATD pila puede ser implementado con un arreglo o bien con una
lista enlazada.
Varios de los algoritmos que serán discutidos en este material se apli-
carán directamente a estructuras de datos especı́ficas. Para la mayorı́a de las
estructuras de datos, se requiere que hagan las siguientes tareas:
1. Insertar un nuevo dato.
2. Buscar un elemento indicado.
3. Borrar un elemento indicado.
También se necesitará saber como iterar a través de todos los elementos en

la estructura de datos, visitando cada uno en su turno ya sea para mostrarlo,
o para realizar alguna acción en este.
Otro algoritmo importante es el ordenamiento. Hay varias formas para
ordenar los datos, desde ideas simples hasta otras que permiten realizarlo de
manera rápida.
El concepto de recurrencia es importante en el diseño de ciertos algoritmos.
La recurrencia involucra que un método se llame a si mismo.
3.2. Arreglos
En esta sección, se exploran unas cuantas aplicaciones con arreglos.
3.2.1. Guardar entradas de juego en un arreglo

La primera aplicación que será revisada se usa para guardar las entradas
en un arreglo—en particular, las mejores marcas para un videojuego. Los
arreglos también se podrı́an usar para guardar registros de pacientes en un
hospital, o los nombres de estudiantes.
En primer lugar se debe determinar lo que se quiere incluir en el registro
de una puntuación alta. Por supuesto, un componente que se deberá incluir es
un entero representando los puntos obtenidos, al cual llamaremos puntuacion.
Otra caracterı́stica que deberá incluirse es el nombre de la persona que obtuvo
la puntuación, la cual denominaremos nombre. La clase EntradaJuego, listado
3.1, tiene el diseño para manejar una puntuación.
1 public class EntradaJuego {

2 protected String nombre ; // nombre del due ~ n o de la puntuaci ó n
3 protected int puntuacion ; // el valor de la puntuaci ó n
4 /* * Constructor para crear una entrada del juego */
5 public EntradaJuego ( String n , int p ) {
6 nombre = n ;
7 puntuacion = p ;
8 }
9 /* * Recupera el campo nombre */
10 public String getNombre () { return nombre ; }
11 /* * Recupera el campo puntuaci ó n */
12 public int getPuntuacion () { return puntuacion ; }
13 /* * Regresa una cadena de esta entrada */
15 return " ( " + nombre + " , " + puntuacion + " ) " ;
16 }
17 }
Listado 3.1: Clase EntradaJuego.java
Clase para las mayores puntuaciones
La cantidad de puntuaciones que serán guardadas se indica mediante una

constante con nombre, MAX ENTRADAS, la cual es inicializada con el valor 10.
Se usa esta constante para el caso en el que se quiera cambiar fácilmente la
cantidad de puntuaciones guardadas. Se define un arreglo, entradas, para
que sea un arreglo de tamaño MAX ENTRADAS. Cuando se crea el arreglo sus
entradas son null, pero conforme se juega, se van llenando las entradas del
arreglo con referencias a objetos EntradaJuego.
Se quiere almacenar los mayores registros en un arreglo llamado entradas.
La cantidad de registros puede variar, por lo que se usará el nombre simbólico,
maxEntradas, para representar el número máximo de registros que se pueden
guardar. Se debe poner esta variable con un valor especı́fico, y usando esta
variable en el código, se puede hacer fácilmente un cambio más tarde si se
requiere. Se define después el arreglo, entradas, para que sea un arreglo
de tamaño maxEntradas. Inicialmente, el arreglo guarda solamente entradas
nulas, pero conforme el usuario juega, se llenará en el arreglo con nuevos
objetos EntradaJuego. Por lo que se necesitará definir métodos para actualizar
las referencias EntradaJuego en las entradas del arreglo.
La forma como se mantiene organizado el arreglo entradas es simple—se
guarda el conjunto de objetos EntradaJuego ordenado por sus valores enteros
puntuacion, de mayor a menor. Si el número de objetos EntradaJuego es
menor que maxEntradas, entonces se permite que al final del arreglo se
3.2 Arreglos 87
1 /* * Clase para guardar las puntuaciones altas en un arreglo

2 en orden descendente . */
3 public class Puntuaciones {
4 public static final int MAX_ENTRADAS = 10; // cantidad de puntuaciones
5 protected int numEntradas ; // cantidad . actual de entradas
6 protected EntradaJuego [] entradas ; // arreglo de entradas
7 /* * Constructor por defecto */
8 public Puntuaciones () {
9 entradas = new EntradaJuego [ MAX_ENTRADAS ];
10 numEntradas = 0;
11 }
12 /* * Regresa una cadena de las mayores puntuaciones */
14 String s = " [ " ;
15 for ( int i = 0; i < numEntradas ; i ++) {
16 if ( i > 0) s += " , " ; // separar entradas con comas
17 s += entradas [ i ];
18 }
19 return s + " ] " ;
20 }
21 // ... m é todos para actualizar el conjunto de puntuaciones ...
Listado 3.2: Clase Puntuciones para manejar un conjunto de objetos Entrada.
guarden referencias null. Con este diseño se previene tener celdas vacı́as, u
“hoyos”, y los registros están desde el ı́ndice cero hasta antes de la cantidad de
juegos jugados. Se ilustra una instancia de la estructura de datos en la figura
3.1 y en la clase Puntuaciones, listado 3.2 parcial, se muestra el diseño.
El método toString() devuelve una cadena representando las mayores
puntuaciones del arreglo entradas. Puede también ser empleado para propósi-
tos de depuración. La cadena será una lista separada con comas de objetos
EntradaJuego del arreglo entradas. La lista se genera con un ciclo for, el
cual agrega una coma justo antes de cada entrada que venga después de la
primera.
Inserción
Una de las actualizaciones más comunes que se quiere hacer al arreglo

entradas es agregar una nueva entrada. Suponiendo que se quiera insertar un
nuevo objeto e del tipo EntradaJuego se considera como se harı́a la siguiente
operación en una instancia de la clase Puntuaciones:
Figura 3.1: Una ilustración de un arreglo de tamaño 10 guardando referencias a

6 objetos entradaJuego desde la celda 0 hasta la 5, y el resto siendo referencias
null.
add(e):inserta la entrada de juego e en la colección de las

mayores puntuaciones. Si la colección está llena,
entonces e es agregado solamente si su puntuación
es mayor que la menor puntuación en el conjunto,
y en este caso, e reemplaza la entrada con la menor
puntuación.
El reto principal en la implementación de esta operación es saber donde e

deberá ir en el arreglo entradas y hacerle espacio a e.
Se supondrá que las puntuaciones están en el arreglo de izquierda a
derecha desde la mayor hasta la menor. Entonces se quiere que dada una
nueva entrada, e, se requiere saber donde estará. Se inicia buscando al final
del arreglo entradas. Si la última referencia en el arreglo no es null y su
puntuación es mayor que la puntuación de e, entonces se detiene la búsqueda,
ya que en este caso, e no es una puntuación alta. De otra forma, se sabe
que e debe estar en el arreglo, y también se sabe que el último registro en
el arreglo ya no debe estar. Enseguida, se va al penúltima referencia, si esta
referencia es null o apunta a un objeto EntradaJuego con una puntuación
que es menor que e, esta referencia deberá ser movida una celda a la derecha
en el arreglo entrada. Se continua comparando y desplazando referencias de
entradas del juego hasta que se alcanza el inicio del arreglo o se compara la
3.2 Arreglos 89
puntuación de e con una entrada con una puntuación mayor. En cualquier

caso, se habrá identificado el lugar al que e pertenece. Ver figura 3.2
Figura 3.2: Preparación para agregar un nuevo objeto entradaJuego al arreglo

Entradas. Para hacer espacio a una nueva referencia, se tienen que desplazar las
referencias con los registros más pequeños que la nueva una celda a la derecha.
En el listado 3.3 se muestra la implementación para agregar la entrada

juego nuevo e al arreglo entradas. Se usa un ciclo para desplazar las referen-
cias. La cantidad de veces que se repite el ciclo depende de la cantidad de
referencias que se tengan que mover para hacer espacio para la nueva entrada.
La rapidez del método dependerá de la cantidad de entradas en el arreglo
y del valor de la puntuación. Cuando el arreglo está lleno puede ser que la
referencia a la última entrada se pierda o se falle al agregar la nueva entrada
de juego, e.
Remoción de un objeto
Suponiendo que algún jugador hace trampa y obtiene una puntuación

alta, se desearı́a tener un método que permita quitar la entrada del juego de
la lista de las mayores puntuaciones. Por lo tanto se considera como deberı́a
implementarse la siguiente operación:
1 /* * Intenta agregar una nueva puntuaci ó n a la coleccion si es lo

2 s uf ic ie n te me nt e alta . */
3 public void add ( EntradaJuego e ) {
4 int n ue va Pu n tu ac i on = e . getPuntuacion ();
5 // ¿ es la nueva entrada realmente un r é cord ?
6 if ( numEntradas == MAX_ENTRADAS ) { // el arreglo est á lleno
7 if ( n u ev aP u nt ua ci o n <= entradas [ numEntradas -1]. getPuntuacion () )
8 return ; // la nueva entrada , e , no es un record
9 }
10 else // el arreglo no est á lleno
11 numEntradas ++;
12 // Encontrar el lugar en donde la nueva entrada (( e )) estar á
13 int i = numEntradas -1;
14 for ( ; ( i >= 1) && ( n u ev aP u nt ua ci o n > entradas [i -1]. getPuntuacion ()); i - -)
15 entradas [ i ] = entradas [ i - 1]; // mover entrada i un lugar a la derecha
16 entradas [ i ] = e ; // agregar el nuevo r é cord a entradas
17 }
Listado 3.3: Codificación en la clase Puntuciones del método add() para insertar
un objeto Entrada.
remove(i):quita y regresa la entrada de juego e con el ı́ndice

i en el arreglo entradas. Si el ı́ndice i está fue-
ra de los lı́mites del arreglo entradas, entonces
el método deberá lanzar una excepción; de otra
forma, el arreglo entradas será actualizado para
quitar el objeto en la posición i y todos los ob-
jetos guardados con ı́ndices mayores que i serán
movidos encima para llenar el espacio del dejado
por el objeto quitado.
La implementación para remove() será parecida al algoritmo para agregar

un objeto, pero en forma inversa. Para remover la referencia al objeto con
ı́ndice i, se inicia en el ı́ndice i y se mueven todas las referencias con ı́ndices
mayores que i una celda a la izquierda. Ver figura 3.3.
Los detalles para hacer la operación de remoción consideran que prime-
ramente se debe guardar la entrada del juego, llamada e, en el ı́ndice i del
arreglo, en una variable temporal. Se usará esta variable para regresar e
cuando se haya terminado de borrar. Para el movimiento de las referencias
que son mayores que i una celda a la izquierda, no se hace hasta el final del
arreglo—se detiene en la penúltima referencia, ya que la última referencia
no tiene una referencia a su derecha. Para la última referencia en el arreglo
entradas, es suficiente con anularla. Se termina regresando una referencia de
3.2 Arreglos 91
Figura 3.3: Remoción en el ı́ndice 3 en el arreglo que guarda las referencias a objetos
entradaJuego.
la entrada removida, la cual no tiene una referencia que le apunte desde el

arreglo entradas. En el listado 3.4 se muestra la codificación del método.
Los métodos para agregar y quitar objetos en el arreglo de puntuaciones
altas son simples. Pero forman las bases de las técnicas usadas para construir
estructuras de datos más complejas.
1 /* * Quitar el r é cord del ı́ ndice i y devolverlo . */

2 public EntradaJuego remove ( int i ) throws I n d e x O u t O f B o u n d s E x c e p t i o n {
3 if (( i < 0) || ( i >= numEntradas ))
4 throw new I n d e x O u t O f B o u n d s E x c e p t i o n ( " Í ndice no v á lido : " + i );
5 // guardar temporalmente el objecto a ser quitado
6 EntradaJuego temp = entradas [ i ];
7 for ( int j = i ; j < numEntradas - 1; j ++) // contar hacia adelante desde i
8 entradas [ j ] = entradas [ j +1]; // mover una celda a la izquierda
9 entradas [ numEntradas - 1 ] = null ; // anular el registro menor
10 numEntradas - -;
11 return temp ; // devolver objeto eliminado
12 }
Listado 3.4: Codificación en la clase Puntuciones del método remove() de acuerdo

a un ı́ndice pasado.
3.2.2. Ordenar un arreglo

En la sección previa, se mostró como se pueden agregar objetos o quitar
estos en un cierto ı́ndice i en un arreglo mientras se conserva el ordenamiento
previo de los objetos intacto. En esta sección, se revisa una forma de iniciar
con un arreglo de objetos que no están ordenadados y dejarlos en orden. Esto
se conoce como el problema de ordenamiento.
Un algoritmo simple de inserción ordenada

Se revisarán varios algoritmos de ordenamiento en este material. Como
introducción, se describe en esta sección, un algoritmo simple de ordenamiento,
llamado inserción ordenada. En este caso, se describe una versión especı́fica
del algoritmo donde la entrada es un arreglo de elementos comparables. Se
consideran tipos más generales de algoritmos de ordenamiento mas adelante.
El algoritmo de inserción ordenada trabaja de la siguiente forma. Se
inicia con el primer elemento en el arreglo y este elemento por sı́ mismo ya
está ordenado. Entonces se considera el siguiente elemento en el arreglo. Si
este es menor que el primero, se intercambian. Enseguida se considera el
tercer elemento en el arreglo. Se intercambia hacia la izquierda hasta que
esté en su posición correcta respecto a los primeros dos elementos. De esta
manera se considera el resto de los caracteres, hasta que el arreglo completo
esté ordenado. Mezclando la descripción informal anterior con construcciones
de programación, se puede expresar el algoritmo de inserción ordenada como
se muestra enseguida.
Algoritmo InserciónOrdenada(A):
Entrada: Un arreglo A de n elementos comparables
Salida: El arreglo A con elementos reacomodados en orden creciente
para i ← 1 hasta n − 1 hacer
Insertar A[i] en su posición correcta en A[0], A[1], . . . , A[i − 1].
Esta es una descripción de alto nivel de inserción ordenada y muestra
porque este algoritmo recibe tal nombre—porque cada iteración inserta el
siguiente elemento en la parte ordenada del arreglo que está antes de este.
Antes de codificar la descripción se requiere trabajar más en los detalles de
como hacer la tarea de inserción.
Se reescribirá la descripción de tal forma que se tenga un ciclo anidado
dentro de otro. El ciclo externo considerará cada elemento del arreglo en turno
y el ciclo interno moverá ese elemento a su posición correcta en el subarreglo
3.2 Arreglos 93
ordenado de caracteres que están a su izquierda.
Inserción ordenada refinada
Se describe a continuación una descripción en nivel intermedio del algo-

ritmo de inserción ordenada. Esta descripción está más cercana al código
actual, ya que hace una mejor descripción para insertar el elemento A[i] en el
subarreglo que está antes de este. Todavı́a emplea una descripción informal
para el movimiento de los elementos si no están todavı́a ordenados.
Algoritmo InserciónOrdenada(A):
Entrada: Un arreglo A de n elementos comparables
Salida: El arreglo A con elementos recodados en orden creciente
{Insertar A[i] en su sitio correcto en A[0], A[1], . . . , A[i − 1].}
actual ← A[i]
j ←i−1
mientras j ≥ 0 Y A[j] > actual hacer
A[j + 1] ← A[j]
j ←j−1
A[j + 1] ← actual {actual está ahora en el lugar correcto}
Se ilustra un ejemplo de la ejecución del algoritmo de ordenamiento en la
figura 3.4. La parte ordenada del arreglo está en blanco, y el siguiente elemento
a ser insertado está en azul. Este se encuentra guardado en la variable cur.
Cada renglón corresponde a una iteración del ciclo externo, y cada copia del
arreglo en un renglón corresponde a una iteración del ciclo interno. Cada
comparación se muestra con un arco. También se indica si la comparación
dió un movimiento o no.
Descripción de inserción ordenada con Java
La clase OrdenaArreglo tiene el método estático insercionOrdenada()

el cual codifica el algoritmo de inserción ordenada. El código proporcionado
es para el caso especial cuando A es un arreglo de caracteres, referenciado
por a.
Figura 3.4: Ejecución del algoritmo de ordenamiento de un arreglo de 8 caracteres.
1 /* * Inserci ó n ordenada de un arreglo de caracteres en orden creciente */

2 public static void i n se r c i o n O r d e n a d a ( char [] a ) {
3 int n = a . length ;
4 for ( int i =1; i < n ; i ++) { // ı́ ndice desde el 2 ◦ car á cter en a
5 char actual = a [ i ]; // car á cter actual a ser insertado
6 int j = i -1; // se inicia con la celda izquierda de i
7 while (j >=0 && a [ j ] > actual ) // mientras a [ j ] no est é ordenado con actual
8 a [ j +1 ] = a [ j - - ]; // mover a [ j ] a la derecha y decrementar j
9 a [ j +1 ] = actual ; // este es el lugar correcto para actual
10 }
11 }
Listado 3.5: Método Java para ordenar un arreglo de caracteres usando el algoritmo
inserción ordenada
3.2 Arreglos 95
3.2.3. Métodos para arreglos y números aleatorios

Como los arreglos son muy importantes, Java proporciona un determinado
número de métodos incorporados para realizar tareas comunes en arreglos.
Estos métodos son estáticos en la clase java.util.Arrays. Esto es, ellos
están asociados con la propia clase, y no con alguna instancia particular de la
clase.
Métodos útiles de Arrays

Se listan a continuación algunos métodos simples de la clase java.util.-
Arrays que no requieren explicación adicional:
equals(A, B):regresa verdadero si y solo si el arreglo A y el

arreglo B son iguales. Se considera que dos arreglos
son iguales si estos tienen el mismo número de
elementos y cada par correspondiente de elementos
en los dos arreglos son iguales. Esto es, A y B
tienen los mismos elementos en el mismo orden.
fill(A, x):guarda el elemento x en cada celda del arreglo A.
sort(A):ordena el arreglo A usando el ordenamiento natural
de sus elementos. Para ordenar usa el algoritmo de
ordenamiento rápido, el cual es mucho más rápido
que el de inserción ordenada.
toString(A):devuelve un String representante del arreglo A.
Generación de números pseudoaleatorios

Otra capacidad incorporada en Java es la habilidad para generar números
pseudoaleatorios, los cuáles son útiles cuando se prueban programas que usan
arreglos. Estos números son estadı́sticamente aleatorios, pero no necesaria-
mente aleatorios verdaderos. En particular, Java tiene la clase incorporada,
java.util.Random, cuyas instancias son generadores de números pseu-
doaleatorios. Las secuencias no son actualmente aleatorias porque es posible
predecir el siguiente número en la secuencia dada la lista de números an-
teriores. Un generador de números pseudoaletorios popular para generar el
siguiente número, sig, a parte del número actual, actual, es:
sig = (a*actual + b) % n;
donde a, b, y n son enteros escogidos apropiadamente. La secuencia generada

se puede mostrar que es uniforme estadı́sticamente, lo cual está bien para la
mayorı́a de las aplicaciones que requieran números aleatorios, como los juegos.
Para aplicaciones donde se requieran secuencias aleatorias no predecibles,
como en configuraciones de seguridad de computadoras, una fórmula como la
anterior no debe ser usada. Se debe muestrear de una fuente que sea aleatoria,
como la estática de radio proveniente del espacio exterior.
Como el siguiente número en un generador pseudoaleatorio es determinado
por el número previo, entonces se requiere que el generador tenga un valor
para iniciar, el cual es llamado su semilla. La secuencia de números generados
por una semilla dada siempre será la misma. La semilla para una instancia
de la clase java.util.Random puede ser puesta en su constructor o con el
método setSeed().
Un truco para obtener una secuencia diferente cada vez que una aplicación
es ejecutada es usar una semilla que será diferente para cada ejecución. Por
ejemplo, se podrı́a usar algún tiempo ingresado por el usuario, o se podrı́a
poner la semilla al tiempo actual en milisegundos desde el 1◦ de enero de
1970, dado por el método System.currentTimeMillis().
Algunos de los métodos incluidos en la clase java.util.Random son los
siguientes:
nextBoolean():regresa el siguiente valor boolean pseudoaletario.

nextFloat():regresa el siguiente valor float pseudoaletario,
entre 0.0 y 1.0.
nextInt():regresa el siguiente valor int pseudoaletario.
nextInt(n):regresa el siguiente valor int pseudoaletario en el
rango [0, n).
setSeed(s):pone la semilla de este generador de números pseu-
doaleatorios con el entero largo s.
Ejemplo con números pseudoaleatorios

Se proporciona la aplicacion PruebaArreglo, listado 3.6, para mostrar el
uso de las clase Arrays y Random del paquete java.util
Una posible salida de esta aplicación es:
arreglos iguales antes de ordenar: true

arreglos iguales después de ordenar: false
ant = [49, 41, 8, 10, 48, 87, 52, 2, 97, 81]
3.2 Arreglos 97
1 import java . util . Arrays ;

2 import java . util . Random ;
3 /* * Programa que muestra algunos usos de los arreglos */
4 public class PruebaArreglo {
6 int num [] = new int [10];
7 Random rand = new Random (); // un generador de n ú meros p s e u d o a l e a t o r i o s
8 rand . setSeed ( System . c u r r e n t T i m e M i l l i s ()); // tiempo actual como semilla
9 // llenar el arreglo num con n ú meros p s e u d o a l e a t o ri o s entre 0 y 99 , incl .
10 for ( int i = 0; i < num . length ; i ++)
11 num [ i ] = rand . nextInt (100); // siguiente numero p se ud oa l ea to ri o
12 int [] ant = ( int []) num . clone (); // clonar arreglo num
13 System . out . println ( " arreglos iguales antes de ordenar : " +
14 Arrays . equals ( ant , num ));
15 Arrays . sort ( num ); // ordenar arreglo num ( ant esta sin cambios )
16 System . out . println ( " arreglos iguales despu é s de ordenar : " +
17 Arrays . equals ( ant , num ));
18 System . out . println ( " ant = " + Arrays . toString ( ant ));
19 System . out . println ( " num = " + Arrays . toString ( num ));
20 }
21 }
Listado 3.6: Aplicación PruebaArreglo usando varios métodos incorporados en

Java
num = [2, 8, 10, 41, 48, 49, 52, 81, 87, 97]
Por cierto, hay una leve posibilidad de que los arreglos ant y num per-
manezcan igual, aún después de que num sea ordenado, es decir, si num ya
está ordenado antes de que sea clonado. Pero la probabilidad de que esto
ocurra es menor que uno en cuatro millones, ası́ que es improbable que suceda
en unos cuantos miles de pruebas, per.
Criptografı́a simple con cadenas y arreglos de caracteres

Una de las aplicaciones primarias de los arreglos es la representación de
String. Los objetos cadena son usualmente representados internamente como
un arreglo de caracteres. Aún si las cadenas pudieran estar representadas de
otra forma, hay una relación natural entre cadenas y arreglos de caracteres—
ambos usan ı́ndices para referirse a sus caracteres. Gracias a esta relación,
Java hace fácil la creación de objetos String desde arreglos de caracteres y
viceversa. Para crear un objeto String de un arreglo de caracteres A, se usa
la expresión,
new String(A)
Esto es, uno de los constructores de la clase String toma un arreglo de

caracteres como su argumento y regresa una cadena teniendo los mismos
caracteres en el mismo orden como en el arreglo. De igual forma, dado un
String S, se puede crear un arreglo de caracteres de la representación de S
usando la expresión,
S.toCharArray()
es decir, la clase String tiene un método, toCharArray(), el cual regresa

un arreglo, del tipo char[] con los mismos caracteres de S.
El cifrador César
Una área donde se requiere poder cambiar de una cadena a un arreglo
de caracteres y de regreso es útil en criptografı́a, la ciencia de los mensajes
secretos y sus aplicaciones. Esta área estudia varias formas de realizar el
encriptamiento, el cual toma un mensaje, denominado el texto plano, y
lo convierte en un mensaje cifrado, llamado el texto cifrado. Asimismo,
la criptografı́a también estudia las formas correspondientes de realizar el
descifrado, el cual toma un texto cifrado y lo convierte de regreso en el texto
plano original.
Es discutible que el primer esquema de encriptamiento es el cifrador de
César, el cual es nombrado después de que Julio César usó este esquema
para proteger mensajes militares importantes. El cifrador de César es una
forma simple para oscurecer un mensaje escrito en un lenguaje que forma
palabras con un alfabeto.
El cifrador involucra reemplazar cada letra en un mensaje con una letra
que está tres letras después de esta en el alfabeto para ese lenguaje. Por lo
tanto, en un mensaje del español, se podrı́a reemplazar cada A con D, cada B
con E, cada C con F, y ası́ sucesivamente. Se continúa de esta forma hasta la
letra W, la cual es reemplazada con Z. Entonces, se permite que la sustitución
del patrón dé la vuelta, por lo que se reemplaza la X con A, Y con B, y Z
con C.
Usar caracteres como ı́ndices de arreglos

Si se fueran a numerar las letras como ı́ndices de arreglos, de tal forma
que A sea 0, B sea 1, C sea 2, y ası́ sucesivamente, entonces se puede escribir
la fórmula del cifrador de César para el alfabeto inglés de la siguiente forma:
3.2 Arreglos 99
Reemplazar cada letra i con la letra (i + 3) mód 26,
donde mód es el operador módulo, el cual regresa el residuo después de

realizar una división entera. El operador se denota con % en Java, y es el
operador que se requiere para dar la vuelta en el final del alfabeto. Para el 26
el módulo es 0, para el 27 es 1, y el 28 es 2. El algoritmo de desciframiento
para el cifrador de César es exactamente lo opuesto—se reemplaza cada letra
con una que está tres lugares antes que esta, con regreso para la A, B y C.
Se puede capturar esta regla de reemplazo usando arreglos para encriptar
y descifrar. Porque cada carácter en Java está actualmente guardado como un
número—su valor Unicode—se pueden usar letras como ı́ndices de arreglos.
Para una letra mayúscula C, por ejemplo, se puede usar C como un ı́ndice
de arreglo tomando el valor Unicode de C y restando A. Lo anterior sólo
funciona para letras mayúsculas, por lo que se requerirá que los mensajes
secretos estén en mayúsculas. Se puede entonces usar un arreglo, encriptar,
que represente la regla de encriptamiento, por lo que encriptar[i] es la
letra que reemplaza la letra con código i, la cual es C − A para una letra
mayúscula C en Unicode. De igual modo, un arreglo, descrifrar, puede
representar la regla de desciframiento, por lo que descifrar[i] es la letra
que reemplaza la letra número i.
Arreglo encriptar
D E F G H I J K L M N ... X Y Z A B C
0 1 2 3 4 5 6 7 8 9 10 ... 20 21 22 23 24 25
El arreglo de encriptamiento para el cifrador César quedarı́a como se

muestra previamente. Por ejemplo, para codificar el carácter ’J’, este es
usado como ı́ndice, haciendo ’J’ - ’A’, que es calculado por Java como 74
- 65 = 9, (los valores son sus códigos Unicode). Luego al acceder el arreglo
con ese ı́ndice se obtiene el carácter ’M’.
La aplicación Cesar, listado 3.7, tiene un cifrador de César simple y
completo usando la aproximación anterior. Además realiza las conversiones
entre cadenas y arreglos de caracteres.
Cuando se ejecuta este programa, se obtiene la siguiente salida:
Orden de Encriptamiento = DEFGHIJKLMNOPQRSTUVWXYZABC
Orden de Descifrado = XYZABCDEFGHIJKLMNOPQRSTUVW
HVWUXFWXUDV GH GDWRV; DUUHJORV B OLVWDV OLJDGDV.
ESTRUCTURAS DE DATOS; ARREGLOS Y LISTAS LIGADAS.
1 /* * Clase para encriptar y descifrar con el cifrador de C é sar . */

2 public class Cesar {
3 public static final char [] abc = { ’A ’ , ’B ’ , ’C ’ , ’D ’ , ’E ’ , ’F ’ , ’G ’ , ’H ’ , ’I ’ ,
4 ’J ’ , ’K ’ , ’L ’ , ’M ’ , ’N ’ , ’O ’ , ’P ’ , ’Q ’ , ’R ’ , ’S ’ , ’T ’ , ’U ’ , ’V ’ , ’W ’ , ’X ’ , ’Y ’ , ’Z ’ };
5 protected char [] encriptar = new char [ abc . length ]; // Arreglo encrip tamiento
6 protected char [] descifrar = new char [ abc . length ]; // Arreglo descif ramiento
7 /* * Constructor para inicializar los arreglos de encri ptamien to y
8 * descif ramiento */
9 public Cesar () {
10 for ( int i =0; i < abc . length ; i ++)
11 encriptar [ i ] = abc [( i + 3) % abc . length ]; // rotar alfabeto 3 lugares
12 for ( int i =0; i < abc . length ; i ++)
13 descifrar [ encriptar [ i ] - ’A ’] = abc [ i ]; // descifrar inverso a encriptar
14 }
15 /* * M é todo de encri ptamien to */
16 public String encriptar ( String secreto ) {
17 char [] mensj = secreto . toCharArray (); // arreglo mensaje
18 for ( int i =0; i < mensj . length ; i ++) // ciclo de e ncripta miento
19 if ( Character . isUpperCase ( mensj [ i ])) // se tiene que cambiar letra
20 mensj [ i ] = encriptar [ mensj [ i ] - ’A ’ ]; // usar letra como ı́ ndice
21 return new String ( mensj );
22 }
23 /* * M é todo de desci framien to */
24 public String descifrar ( String secreto ) {
25 char [] mensj = secreto . toCharArray (); // arreglo mensaje
26 for ( int i =0; i < mensj . length ; i ++) // ciclo desc iframien to
27 if ( Character . isUpperCase ( mensj [ i ])) // se tiene letra a cambiar
28 mensj [ i ] = descifrar [ mensj [ i ] - ’A ’ ]; // usar letra como ı́ ndice
29 return new String ( mensj );
30 }
31 /* * Metodo main para probar el cifrador de C é sar */
33 Cesar cifrador = new Cesar (); // Crear un objeto cifrado de C é sar
34 System . out . println ( " Orden de Encri ptamien to = " +
35 new String ( cifrador . encriptar ));
36 System . out . println ( " Orden de Descifrado = " +
37 new String ( cifrador . descifrar ));
38 String secreto = " ESTRUCTURAS DE DATOS ; ARREGLOS Y LISTAS LIGADAS . " ;
39 secreto = cifrador . encriptar ( secreto );
40 System . out . println ( secreto ); // el texto cifrado
41 secreto = cifrador . descifrar ( secreto );
42 System . out . println ( secreto ); // deber ı́ a ser texto plano
43 }
44 }
Listado 3.7: Una clase simple y completa de Java para el cifrador de César
3.2 Arreglos 101
0 1 2 3 4 5 6
0 1 2 3 4 5 6 7
1 2 3 4 5 6 7 8
2 3 4 5 6 7 8 9
3 4 5 6 7 8 9 0
4 5 6 7 8 9 0 1
Cuadro 3.2: Representación del arreglo de enteros bidimensional, Y, con 5 renglones

y 7 columnas. El valor de Y[2][4] es 7.
3.2.4. Arreglos bidimensionales y juegos de posición

Varios juegos de computadora, sean juegos de estrategia, de simulación,
o de conflicto de primera persona, usan un “tablero” bidimensional. Los
programas que manejan juegos de posición requieren una forma de representar
objetos en un espacio bidimensional. Una forma natural de hacerlo es con un
arreglo bidimensional, donde se usan dos ı́ndices, por ejemplo i y j, para
referirse a las celdas en el arreglo. El primer ı́ndice se refiere al número del
renglón y el segundo al número de la columna. Dado tal arreglo se pueden
mantener tableros de juego bidimensionales, ası́ como realizar otros tipos de
cálculos involucrando datos que están guardados en renglones y columnas.
Los arreglos en Java son unidimensionales; se puede usar un sólo ı́ndice
para acceder cada celda de un arreglo. Sin embargo, hay una forma como se
pueden definir arreglos bidimensionales en Java—se puede crear un arreglo
bidimensional como un arreglo de arreglos. Esto es, se puede definir un arreglo
de dos dimensiones para que sea un arreglo con cada una de sus celdas siendo
otro arreglo. Tal arreglo de dos dimensiones es a veces llamado una matriz.
En Java, se declara un arreglo de dos dimensiones como se muestra en el
siguiente ejemplo:
int[][] Y = new int[5][7];
La sentencia crea una “arreglo de arreglos” bidimensional, Y, el cual es

5 × 7, teniendo cinco renglones y siete columnas. Es decir, Y es un arreglo
de longitud cinco tal que cada elemento de Y es un arreglo de longitud de
siete enteros. Ver cuadro 3.2. Lo siguiente podrı́a entonces ser usos válidos
del arreglo Y y siendo i y j variables tipo int:
Y[i][i+1] = Y[i][i] + 3;
i = a.length; // i es 5
j = Y[4].length; // j es 7
Se revisa enseguida una aplicación de un arreglo bidimensional implemen-

tando un juego simple posicional, para revisar algunos detalles del uso de
arreglos bidimensionales.
El gato
Es un juego que se practica en un tablero de tres por tres. Dos jugadores—
X y O—alternan en colocar sus respectivas marcas en las celdas del tablero,
iniciando con el jugador X. Si algún jugador logra obtener tres marcas suyas
en un renglón, columna o diagonal, entonces ese jugador gana.
La idea básica es usar un arreglo bidimensional, tablero, para mantener
el tablero de juego. Las celdas en este arreglo guardan valores para indicar
si la celda está vacı́a, o guarda una X, o una O. Entonces, el tablero es
una matriz de tres por tres, donde por ejemplo, el renglón central son las
celdas tablero[1][0], tablero[1][1], tablero[1][2]. Para este caso, se
decidió que las celdas en el arreglo tablero sean enteros, un cero indica celda
vacı́a, un uno indica una X, y un menos uno indica O. Esta codificación
permite tener una forma simple de probar si en una configuración del tablero
es una victoria para X o para O, sabiendo si los valores de un renglón, columna
o diagonal suman -3 o 3. Se ilustra lo anterior en la figura 3.5.
Figura 3.5: Una ilustración del juego del gato a la izquierda, y su representación
empleando el arreglo tablero.
3.2 Arreglos 103
La clase Gato, listado 3.8, modela el tablero del gato para dos jugadores.
El código sólo mantiene el tablero del gato y registra los movimientos; no
realiza ninguna estrategia, ni permite jugar al gato contra la computadora.
1 /* * Simulaci ó n del juego del gato ( no tiene ninguna estrategia ). */
2 public class Gato {
3 protected static final int X = 1 , O = -1; // jugadores
4 protected static final int VACIA = 0; // celda vac ı́ a
5 protected int tablero [][] = new int [3][3]; // tablero
6 protected int jugador ; // jugador actual
8 public Gato () { li mpiarTa blero (); }
9 /* * Limpiar el tablero */
10 public void li mpiarTa blero () {
11 for ( int i = 0; i < 3; i ++)
12 for ( int j = 0; j < 3; j ++)
13 tablero [ i ][ j ] = VACIA ; // cada celda deber á estar vac ı́ a
14 jugador = X ; // el primer jugador es ’X ’
15 }
16 /* * Poner una marca X u O en la posici ó n i , j */
17 public void ponerMarca ( int i , int j ) throws I l l e g a l A r g u m e n t E x c e p t i o n {
18 if ( ( i < 0) || ( i > 2) || ( j < 0) || ( j > 2) )
19 throw new I l l e g a l A r g u m e n t E x c e p t i o n ( " Posici ó n invalida en el tablero " );
20 if ( tablero [ i ][ j ] != VACIA )
21 throw new I l l e g a l A r g u m e n t E x c e p t i o n ( " Posici ó n del tablero ocupada " );
22 tablero [ i ][ j ] = jugador ; // colocar la marca para el jugador actual
23 jugador = - jugador ; // intercambiar jugadores , se usa O es -X
24 }
25 /* * Revisar si la configuraci ó n del tablero es ganadora para un jugador dado */
26 public boolean esGanador ( int marca ) {
27 return (( tablero [0][0] + tablero [0][1] + tablero [0][2] == marca *3) // ren . 0
28 || ( tablero [1][0] + tablero [1][1] + tablero [1][2] == marca *3) // ren . 1
29 || ( tablero [2][0] + tablero [2][1] + tablero [2][2] == marca *3) // ren . 2
30 || ( tablero [0][0] + tablero [1][0] + tablero [2][0] == marca *3) // col . 0
33 || ( tablero [0][0] + tablero [1][1] + tablero [2][2] == marca *3) // diag .
34 || ( tablero [2][0] + tablero [1][1] + tablero [0][2] == marca *3)); // diag .
35 }
36 /* * Regresar el jugador ganador o 0 para indicar empate */
37 public int ganador () {
38 if ( esGanador ( X ))
39 return ( X );
40 else if ( esGanador ( O ))
41 return ( O );
42 else
43 return (0);
44 }
45 /* * Regresar una cadena simple mostrando el tablero actual */
47 String s = " " ;
48 for ( int i =0; i <3; i ++) {
49 for ( int j =0; j <3; j ++) {
50 switch ( tablero [ i ][ j ]) {
51 case X : s += " X " ; break ;
52 case O : s += " O " ; break ;
53 case VACIA : s += " " ; break ;

54 }
55 if ( j < 2) s += " | " ; // l ı́ mite de columna
56 }
57 if ( i < 2) s += " \n - - - - -\ n " ; // l ı́ mite de renglon
58 }
59 return s ;
60 }
61 /* * Ejecuci ó n de prueba de un juego simple */
63 Gato juego = new Gato ();
64 /* mueve X : */ /* mueve O : */
65 juego . ponerMarca (1 ,1); juego . ponerMarca (0 ,2);
69 juego . ponerMarca (2 ,0);
70 System . out . println ( juego . toString () );
71 int jugador Ganador = juego . ganador ();
72 if ( jugadorG anador != 0)
73 System . out . println ( jug adorGana dor + " gana " );
74 else
75 System . out . println ( " Empate " );
76 }
77 }
Listado 3.8: Clase Gato para simular el tablero del juego del gato.
Se muestra en la figura 3.6 el ejemplo de salida de la clase Gato.
O|X|O
-----
O|X|X
-----
X|O|X
Empate
Figura 3.6: Salida del ejemplo del juego del gato
Métodos para arreglos de arreglos

Se habı́a señalado en la sección 1.5, que una referencia arreglo apunta a
un objeto arreglo. Si se tienen dos arreglos bidimensionales, A y B, con ambos
3.2 Arreglos 105
teniendo las mismas entradas, se podrı́a decir que el arreglo A es igual a B.

Pero los arreglos unidimensionales que forman los renglones de A y B están
guardados en localidades de memoria diferentes, a pesar de que tengan el
mismo contenido interno. Por lo tanto, una llamada al método java.util.-
Arrays.equals(A,B) devolverá false en este caso. La razón de lo anterior
es porque el método equals() realiza una igualdad superficial, es decir,
prueba sólo si los elementos correspondientes en A y B son iguales entre ellos
usando sólo una noción simple de igualdad. La regla igualdad simple dice
que dos variables tipo base son iguales si estas tienen el mismo valor y dos
referencias objetos son iguales si ambas se refieren al mismo objeto. Cuando
se quiere realizar una igualdad profunda para arreglos de objetos, como los
arreglos bidimensionales, la clase java.util.Arrays proporciona el siguiente
método:
deepEquals(A,B) Devuelve si A y B son iguales profundamen-
te. Serán profundamente iguales A y B si
estos tienen la misma cantidad de elemen-
tos y los dos elementos A[i] y B[i] en cada
pareja de elementos correspondientes son
por sı́ mismos iguales en el sentido simple,
son arreglos del mismo tipo primitivo tal
que Arrays.equals(A[i],B[i]) podrı́an
devolver true, o son arreglos de referen-
cia objeto tal que A[i] y B[i] son iguales
profundamente.
Además de la igualdad profunda, se quiere un método profundo para
convertir un arreglo bidimensional o un arreglo de referencias objeto en una
cadena. Tal método es proporcionado también por la clase java.util.Arrays
deepToString(A) Devuelve una cadena representando los
contenidos de A. Para convertir un ele-
mento A[i] a una cadena, si A[i] es
una referencia arreglo entonces se llama a
Arrays.deepToString(A[i]), de otro mo-
do el método String.valueOf(A[i]) es
usado.
No está disponible un método para hacer una copia idéntica de un arreglo
bidimensional, por lo tanto, si se quiere hacer lo anterior, se necesita hacer una
llamada a A[i].clone() o java.util.Arrays.copyOf(A[i],A[i].length)
para cada renglón, A[i], de A.
3.3. Listas simples enlazadas

Los arreglos son elegantes y simples para guardar cosas en un determinado
orden, pero tienen el inconveniente de no ser muy adaptables, ya que se tiene
que fijar el tamaño del arreglo por adelantado.
Hay otras formas de guardar una secuencia de elementos, que no tiene el
inconveniente de los arreglos. En esta sección se explora una implementación
alterna, la cual es conocida como lista simple enlazada.
Una lista enlazada, en su forma más simple, es una colección de nodos
que juntos forman un orden lineal. El ordenamiento está determinado de tal
forma que cada nodo es un objeto que guarda una referencia a un elemento y
una referencia, llamado siguiente, a otro nodo. Ver la figura 3.7.
Figura 3.7: Ejemplo de una lista simple enlazada cuyos elementos son cadenas
indicando códigos de aeropuertos. El apuntador sig de cada nodo se muestra como
una flecha. El objeto null es denotado por Ø.
Podrı́a parecer extraño tener un nodo que referencia a otro nodo, pero tal
esquema trabaja fácilmente. La referencia sig dentro de un nodo puede ser
vista como un enlace o apuntador a otro nodo. De igual nodo, moverse de un
nodo a otro siguiendo una referencia a sig es conocida como salto de enlace
o salto de apuntador. El primer nodo y el último son usualmente llamados la
cabeza y la cola de la lista, respectivamente. Ası́, se puede saltar a través de
la lista iniciando en la cabeza y terminando en la cola. Se puede identificar la
cola como el nodo que tenga la referencia sig como null, la cual indica el
final de la lista. Una lista enlazada definida de esta forma es conocida como
una lista simple enlazada.
Como en un arreglo, una lista simple enlazada guarda sus elementos en
un cierto orden. Este orden está determinado por la cadenas de enlaces sig
yendo desde cada nodo a su sucesor en la lista. A diferencia de un arreglo, una
lista simple enlazada no tiene un tamaño fijo predeterminado, y usa espacio
proporcional al número de sus elementos. Asimismo, no se emplean números
ı́ndices para los nodos en una lista enlazada. Por lo tanto, no se puede decir
sólo por examinar un nodo si este es el segundo, quinto u otro nodo en la
lista.
3.3 Listas simples enlazadas 107
Implementación de una lista simple enlazada

Para implementar una lista simple enlazada, se define la clase Nodo, listado
3.9, la cual indica el tipo de los objetos guardados en los nodos de la lista.
Para este caso se asume que los elementos son String. También es posible
definir nodos que puedan guardar tipos arbitrarios de elementos. Dada la
clase Nodo, se puede definir una clase, ListaSimple, listado 3.10, para definir
la lista enlazada actual. Esta clase guarda una referencia al nodo cabeza y
una variable guarda el total de nodos de la lista.
1 /* * Nodo de una lista simple enlazada de cadenas . */

2 public class Nodo {
3 private String elemento ; // Los elementos son cadenas de caracteres
4 private Nodo sig ;
5 /* * Se crea un nodo con el elemento dado y el nodo sig . */
6 public Nodo ( String e , Nodo n ) {
7 elemento = e ;
8 sig = n ;
9 }
10 /* * Regresa el elemento de este nodo . */
11 public String getElemento () { return elemento ; }
12 /* * Regresa el nodo siguiente de este nodo . */
13 public Nodo getSig () { return sig ; }
14 // m é todos modificadores
15 /* * Pone el elemento de este nodo . */
16 public void setElemento ( String nvoElem ) { elemento = nvoElem ; }
17 /* * Pone el nodo sig de este nodo . */
18 public void setSig ( Nodo nvoSig ) { sig = nvoSig ; }
19 }
Listado 3.9: Implementación de un nodo de una lista simple enlazada
1 /* * Lista simple enlazada . */

2 public class ListaSimple {
3 protected Nodo cabeza ; // nodo cabeza de la lista
4 protected long tam ; // cantidad de nodos en la lista
5 /* * constructor por defecto para crear una lista vac ı́ a */
6 public ListaSimple () {
7 cabeza = null ;
8 tam = 0;
9 }
10 // ... m é todos de actualizacion y b ú squeda deber ı́ an ir aqu ı́
11 }
Listado 3.10: Implementación parcial de una lista simple enlazada

3.3.1. Inserción en una lista simple enlazada

Cuando se usa una lista simple enlazada, se puede fácilmente insertar un
elemento en la cabeza de la lista, como se muestra en la figura 3.8.
Figura 3.8: Inserción de un elemento en la cabeza de una lista simple enlazada: (a)
antes de la inserción; (b) creación de un nuevo nodo; (c) después de la inserción.
La idea principal es crear un nodo nuevo, poner su enlace sig para que se
refiera al mismo objeto que la cabeza, y luego poner la cabeza apuntando al
nuevo nodo.
Se muestra enseguida el algoritmo para insertar un nodo nuevo v al inicio
de una lista simple enlazada. Observar que este método trabaja aún si la lista
está vacı́a. Observar que se ha puesto el apuntador sig para el nuevo nodo v
antes de hacer que la variable cabeza apunte a v.
Algoritmo agregarInicio(v):
v.setSiguiente(cabeza) {hacer que v apunte al viejo nodo cabeza}
cabeza ← v {hacer que la variable cabeza apunte al nuevo nodo}
tam ← tam + 1 {incrementar la cuenta de nodos }
3.3 Listas simples enlazadas 109
Inserción de un elemento en la cola

Se puede también fácilmente insertar un elemento en la cola de la lista,
cuando se ha proporcionado una referencia al nodo cola, como se muestra en
la figura 3.9.
Figura 3.9: Inserción en la cola de una lista simple enlazada: (a) antes de la inserción;
(b) creación de un nuevo nodo; (c) después de la inserción. Observar que se puso el
enlace sig para cola en (b) antes de asignar a la variable cola para que apunte al
nuevo nodo en (c).
En este caso, se crea un nuevo nodo, se asigna su referencia sig para que
apunte al objeto null, se pone la referencia sig de la cola para que apunte a
este nuevo objeto, y entonces se asigna a la referencia cola este nuevo nodo.
El algoritmo agregarFinal inserta un nuevo nodo al final de la lista simple
enlazada. El método también trabaja si la lista está vacı́a. Se pone primero
el apuntador sig para el viejo nodo cola antes de hacer que la variable cola
apunte al nuevo nodo.
Algoritmo agregarFinal(v):
v.setSiguiente(null) {hacer que el nuevo nodo v apunte al objeto null}
cola.setSiguiente(v) {el viejo nodo cola apuntará al nuevo nodo}
cola ← v { hacer que la variable cola apunte al nuevo nodo }
tam ← tam + 1 {incrementar la cuenta de nodos }
3.3.2. Quitar un elemento de una lista simple enlazada

La operación contraria de insertar un nuevo elemento en la cabeza de una
lista enlazada es quitar un elemento en la cabeza. Esta operación es ilustrada
en la figura 3.10.
Figura 3.10: Remoción de un elemento en la cabeza de una lista simple enlazada:

(a) antes de la remoción; (b) desligando el viejo nodo; (c) después de la remoción.
En el algoritmo removerPrimero se muestra la forma de realizar la

remoción del elemento en la cabeza de la lista.
Algoritmo removerPrimero():
si cabeza = null Entonces
Indicar un error: la lista está vacı́a.
t ← cabeza
cabeza ← cabeza.getSiguiente() { cabeza apuntará al siguiente nodo }
t.setSiguiente(null) { anular el apuntador siguiente del nodo borrado.}
tam ← tam − 1 { decrementar la cuenta de nodos }
Desafortunadamente, no se puede borrar fácilmente el nodo cola de una
lista simple enlazada. Aún si se tiene una referencia cola directamente al
3.4 Listas doblemente enlazadas 111
último nodo de la lista, se necesita poder acceder el nodo anterior al último

nodo en orden para quitar el último nodo. Pero no se puede alcanzar el nodo
anterior a la cola usando los enlaces siguientes desde la cola. La única forma
para acceder este nodo es empezar en la cabeza de la lista y moverse a través
de la lista. Pero tal secuencia de operaciones de saltos de enlaces podrı́a tomar
un tiempo grande.
3.4. Listas doblemente enlazadas

Como se comentaba en la sección previa, quitar un elemento de la cola de
una lista simple enlazada no es fácil. Además, el quitar cualquier otro nodo
de la lista diferente de la cabeza de una lista simple enlazada es consumidor
de tiempo, ya que no se tiene una forma rápida de acceder al nodo que se
desea quitar. Por otra parte, hay varias aplicaciones donde no se tiene un
acceso rápido tal como el acceso al nodo predecesor. Para tales casos, serı́a
bueno tener manera de ir en ambas direcciones en una lista enlazada.
Hay un tipo de lista enlazada que permite ir en ambas direcciones, hacia
adelante y hacia atrás. Esta es la lista doblemente enlazada ó LDE. Tal
lista permite una gran variedad de operaciones rápidas de actualización,
incluyendo la inserción y el borrado en ambos extremos, y en el centro. Un
nodo en una LDE guarda dos referencias—un enlace sig, el cual apunta al
siguiente nodo en la lista, y un enlace prev, el cual apunta al nodo previo en
la lista.
Una implementación de un nodo de una LDE se muestra en la clase NodoD,
listado 3.11, donde se asume que los elementos son cadenas de caracteres.
Centinelas cabeza y cola

Para simplificar la programación, es conveniente agregar nodos especiales
en los extremos de la LDE: un nodo cabeza (header ) justo antes de la cabeza
de la lista, y un nodo cola (trailer ) justo después de la cola de la lista. Estos
nodos “falsos”, o centinelas, no guardan a ningún elemento. La cabeza tiene
una referencia sig válida pero una referencia prev nula, mientras cola tiene
una referencia prev válida pero una referencia sig nula. Una LDE con estos
centinelas se muestra en la figura 3.11.
Un objeto lista enlazada podrı́a necesitar guardar referencias a estos
dos centinelas y un contador tam que guarde el número de elementos, sin
1 /* * Nodo de una lista doblemente enlazada de una lista de cadenas */

2 public class NodoD {
3 protected String elemento ; // Nodo guarda un elemento String
4 protected NodoD sig , prev ; // Apuntadores a nodos siguiente y previo
5 /* * Constructor que crea un nodo con los campos dados */
6 public NodoD ( String e , NodoD p , NodoD s ) {
7 elemento = e ;
8 prev = p ;
9 sig = s ;
10 }
11 /* * Regresa el elemento de este nodo */
12 public String getElemento () { return elemento ; }
13 /* * Regresa el nodo previo de este nodo */
14 public NodoD getPrev () { return prev ; }
15 /* * Regresa el nodo siguiente de este nodo */
16 public NodoD getSig () { return sig ; }
17 /* * Pone el elemento de este nodo */
18 public void setElemento ( String nvoElem ) { elemento = nvoElem ; }
19 /* * Pone el nodo previo de este nodo */
20 public void setPrev ( NodoD nvoPrev ) { prev = nvoPrev ; }
21 /* * Pone el nodo siguiente de este nodo */
22 public void setSig ( NodoD nvoSig ) { sig = nvoSig ; }
23 }
Listado 3.11: Clase NodoD representando un nodo de una lista doblemente enlazada
que guarda una cadena de caracteres.
Figura 3.11: Una lista doblemente enlazada con centinelas, cabeza y cola, marcando
el final de la lista.
considerar a los centinelas, en la lista.

Insertar o remover elementos en cualquier extremo de la LDE se hace
directo. Además, el enlace prev elimina la necesidad de recorrer la lista para
obtener el nodo que está antes de la cola. Se muestran los detalles de la
operación remover en la cola de la lista doblemente enlazada en la figura 3.12.
Figura 3.12: Remoción del nodo al final de una lista doblemente enlazada con
centinelas: (a) antes de borrar en la cola; (b) borrando en la cola; (c) despueś del
borrado.
Los detalles de la remoción en la cola de la LDE se muestran en el algoritmo

removerÚltimo.
Algoritmo removerÚltimo():
si tam = 0 entonces
Indicar un error: la lista está vacı́a.
v ← cola.getP rev() { último nodo }
u ← v.getP rev() { nodo anterior al último nodo }
cola.setP rev(u)
u.setSig(cola)
v.setP rev(null)
v.setSig(null)
tam ← tam − 1 { decrementar la cuenta de nodos }
De igual modo, se puede fácilmente hacer una inserción de un nuevo
elemento al inicio de una LDE, como se muestra en la figura 3.13.
La implementación de la inserción de un nuevo nodo v al inicio, de acuerdo
al algoritmo agregarInicio, donde la variable tam guarda la cantidad de
Figura 3.13: Inserción de un elemento en el frente: (a) previo; (b) final.
elementos en la lista. Este algoritmo también trabaja con una lista vacı́a.
Algoritmo agregarInicio(v):
w ← cabeza.getSig() { primer nodo }
v.setSig(w)
v.setP rev(cabeza)
w.setP rev(v)
cabeza.setSig(v)
tam ← tam + 1
3.4.1. Inserción en el centro de la LDE

Las listas dobles enlazadas no nada mas son útiles para insertar y remover
elementos en la cabeza o en la cola de la lista. Estas también son convenientes
para mantener una lista de elementos mientras se permite inserción y remoción
en el centro de la lista. Dado un nodo v de una lista doble enlazada, el cual
posiblemente podrı́a ser la cabeza pero no la cola, se puede fácilmente insertar
un nuevo nodo z inmediatamente después de v. Especı́ficamente, sea w el
siguiente nodo de v. Se ejecutan los siguientes pasos.
1. Hacer que el enlace prev de z se refiera a v.
2. Hacer que el enlace sig de z se refiera a w.
3. Hacer que el enlace prev de w se refiera a z.
4. Hacer que el enlace sig de v se refiera a z.

Este método está dado en detalle en el algoritmo agregarDespués y es

ilustrado en la figura 3.14. Recordando el uso de los centinelas cabeza y cola,
este algoritmo trabaja aún si v es el nodo cola, el nodo que está justo antes
del centinela cola.
Figura 3.14: Inserción de un nuevo nodo después del nodo que guarda JFK: (a)
creación de un nuevo nodo con el elemento BWI y enlace de este; (b) después de la
inserción.
Algoritmo agregarDespues(v, z):

w ← v.getSig() { nodo después de v }
z.setP rev(v) { enlazar z a su predecesor, v }
z.setSig(w) { enlazar z a su sucesor, w }
w.setP rev(z) { enlazar w a su nuevo predecesor, z }
v.setSig(z) { enlazar v a su nuevo sucesor, z }
tam ← tam + 1
3.4.2. Remoción en el centro de la LDE

De igual modo, es fácil remover un nodo v intermedio de una lista do-
blemente enlazada. Se acceden los nodos u y w a ambos lados de v usando
sus métodos getPrev y getSig, estos nodos deberán existir, ya que se están
usando centinelas. Para quitar el nodo v, se tiene que hacer que u y w se
apunten entre ellos en vez de hacerlo hacia v. Esta operación es referida como
desenlazar a v. También se anulan los apuntadores prev y sig de v para que
ya no retengan referencias viejas en la lista. El algoritmo remover muestra
como quitar el nodo v aún si v es el primer nodo, el último o un nodo no
centinela y se ilustra en la figura 3.15.
Figura 3.15: Borrado del nodo que guarda PVD: (a) antes del borrado; (b) desenlace
del viejo nodo; (c) después de la remoción.
Algoritmo remover(v):
u ← v.getP rev() { nodo predecesor a v }
w ← v.getSig() { nodo sucesor a v }
w.setP rev(u) { desenlazar v }
u.setSig(w)
v.setP rev(null) { anular los campos de v }
v.setSig(null)
tam ← tam − 1 { decrementar el contador de nodos }
3.4.3. Una implementación

La clase ListaDoble, listado 3.12, muestra una implementación de una
LDE con nodos que guardan un String como elementos. Enseguida se dan
un conjunto de observaciones de la clase ListaDoble.
Los objetos de la clase NodoD, los cuales guardan elementos String, son
usados para todos los nodos de la lista, incluyendo los nodos centinela
cabeza y cola.
Se puede usar la clase ListaDoble para una LDE de objetos String

solamente. Para construir una lista de otros tipos, se puede usar una
declaración genérica.
Los métodos getPrimero() y getUltimo() dan acceso directo al primer

nodo y el último en la lista.
Los métodos getPrev() y getSig() permiten recorrer la lista.
Los métodos tienePrev() y tieneSig() detectan los lı́mites de la lista.
Los métodos agregarInicio() y agregarFinal() agregan un nuevo

nodo al inicio y al final de la lista, respectivamente.
Los métodos agregarAntes() y agregarDespues() agregan un nodo

antes y después de un nodo existente, respectivamente.
Tener sólo un método para borrar, remover(), no es actualmente una

restricción, ya que se puede remover al inicio o al final de una LDE L eje-
cutando L.remover(L.getPrimero()) o L.remover(L.getUltimo()),
respectivamente.
El método toString() que convierte la lista entera en una cadena es

útil para propósitos de prueba y depuración.
1 /* * Lista doblemente enlazada de nodos tipo NodoD para cadenas . */

2 public class ListaDoble {
3 protected int tam ; // cantidad de elementos
4 protected NodoD cabeza , cola ; // centinelas
5 /* * Constructor que crea una lista vac ı́ a */
6 public ListaDoble () {
7 tam = 0;
8 cabeza = new NodoD ( null , null , null ); // crer cabeza
9 cola = new NodoD ( null , cabeza , null ); // crear terminaci ó n
10 cabeza . setSig ( cola ); // cabeza apunta a terminaci ó n
11 }
12 /* * Regresa la cantidad de elementos en la lista */
13 public int tam () { return tam ; }
14 /* * Indica si la lista esta vac ı́ a */
15 public boolean estaVacia () { return ( tam == 0); }
16 /* * Regresa el primer nodo de la lista */
17 public NodoD getPrimero () throws I l l e g a l S t a t e E x c e p t i o n {
18 if ( estaVacia ()) throw new I l l e g a l S t a t e E x c e p t i o n ( " La lista esta vac ı́ a " );
19 return cabeza . getSig ();
20 }
21 /* * Regresa el ú ltimo nodo de la lista */
22 public NodoD getUltimo () throws I l l e g a l S t a t e E x c e p t i o n {
23 if ( estaVacia ()) throw new I l l e g a l S t a t e E x c e p t i o n ( " La lista esta vac ı́ a " );
24 return cola . getPrev ();
25 }
26 /* * Regresa el nodo anterior al nodo v dado . Un error ocurre si v
27 * es la cabeza */
28 public NodoD getPrev ( NodoD v ) throws I l l e g a l A r g u m e n t E x c e p t i o n {
29 if ( v == cabeza ) throw new I l l e g a l A r g u m e n t E x c e p t i o n
30 ( " No se puede mover hacia atr á s de la cabeza de la lista " );
31 return v . getPrev ();
32 }
33 /* * Regresa el nodo siguiente al nodo v dado . Un error ocurre si v
34 * es la cola */
35 public NodoD getSig ( NodoD v ) throws I l l e g a l A r g u m e n t E x c e p t i o n {
36 if ( v == cola ) throw new I l l e g a l A r g u m e n t E x c e p t i o n
37 ( " No se puede mover hacia adelante de la terminaci ó n de la lista " );
38 return v . getSig ();
39 }
40 /* * Inserta el nodo z dado antes del nodo v dado . Un error
41 * ocurre si v es la cabeza */
42 public void agregarAntes ( NodoD v , NodoD z ) throws I l l e g a l A r g u m e n t E x c e p t i o n {
43 NodoD u = getPrev ( v ); // podr ı́ a lanzar un I l l e g a l A r g u m e n t E x c e p t i o n
44 z . setPrev ( u );
45 z . setSig ( v );
46 v . setPrev ( z );
47 u . setSig ( z );
48 tam ++;
49 }
50 /* * Inserta el nodo z dado despues del nodo v dado . Un error
51 * ocurre si v es la cabeza */
52 public void ag regarDes pues ( NodoD v , NodoD z ) {
53 NodoD w = getSig ( v ); // podr ı́ a lanzar un I l l e g a l A r g u m e n t E x c e p t i o n
54 z . setPrev ( v );
55 z . setSig ( w );
56 w . setPrev ( z );
57 v . setSig ( z );
58 tam ++;
59 }
60 /* * Inserta el nodo v dado en la cabeza de la lista */
61 public void agregarInicio ( NodoD v ) {
62 agre garDespu es ( cabeza , v );
63 }
64 /* * Inserta el nodo v dado en la cola de la lista */
65 public void agregarFinal ( NodoD v ) {
66 agregarAntes ( cola , v );
67 }
68 /* * Quitar el nodo v dado de la lista . Un error ocurre si v es
69 * la cabeza o la cola */
70 public void remover ( NodoD v ) {
71 NodoD u = getPrev ( v ); // podr ı́ a lanzar I l l e g a l A r g u m e n t E x c e p t i o n
72 NodoD w = getSig ( v ); // podr ı́ a lanzar I l l e g a l A r g u m e n t E x c e p t i o n
73 // desenlazar el nodo v de la lista
74 w . setPrev ( u );
75 u . setSig ( w );
76 v . setPrev ( null );
77 v . setSig ( null );
78 tam - -;
79 }
80 /* * Regresa si un nodo v dado tiene un nodo previo */
81 public boolean tienePrev ( NodoD v ) { return v != cabeza ; }
3.5 Listas circulares y ordenamiento 119
82 /* * Regresa si un nodo v dado tiene un nodo siguiente */

83 public boolean tieneSig ( NodoD v ) { return v != cola ; }
84 /* * Regresa una cadena representando la lista */
86 String s = " [ " ;
87 NodoD v = cabeza . getSig ();
88 while ( v != cola ) {
89 s += v . getElemento ();
90 v = v . getSig ();
91 if ( v != cola )
92 s += " ," ;
93 }
94 s += " ] " ;
95 return s ;
96 }
97 }
Listado 3.12: Una clase de lista doblemente enlazada.
3.5. Listas circulares y ordenamiento

En esta sección se revisan algunas aplicaciones y extensiones de listas
enlazadas.
3.5.1. Lista circular enlazada

El juego de niños, “Pato, Pato, Ganso”, es jugado en varias culturas. Una
variación de la lista simple enlazada, llamada la lista circular enlazada, es
usada para una variedad de aplicaciones involucrando juegos circulares, como
el juego que se comenta. Enseguida se muestra la lista circular y su aplicación
en un juego circular.
Una lista circular enlazada tiene el mismo tipo de nodos que una lista
simple enlazada. Esto es, cada nodo en una lista circular enlazada tiene un
apuntador siguiente y una referencia a un elemento. Pero no hay una cabeza
o cola en la lista circular enlazada. En vez de hacer que el apuntador del
último nodo sea null, se hace que apunte de regreso al primer nodo. Por lo
tanto, no hay un primer nodo o último. Si se recorren los nodos de una lista
circular enlazada desde cualquier nodo usando los apuntadores sig, entonces
se hará un ciclo a través de los nodos.
Aún cuando una lista circular enlazada no tiene inicio o terminación, no
obstante se necesita que algún nodo esté marcado como especial, el cual
será llamado cursor. El nodo cursor permite tener un lugar para iniciar si se
requiere recorrer una lista circular enlazada. Y si se recuerda esta posición

inicial, entonces también se puede saber cuando se haya terminado con un
recorrido en la lista circular enlazada, porque es cuando se regresa al nodo
que fue el nodo cursor cuando se inició.
Se pueden entonces definir algunos métodos simples de actualización para
una lista circular enlazada:
agregar(v):inserta un nuevo nodo v inmediatamente después

del cursor; si la lista está vacı́a, entonces v se
convierte en el cursor y su apuntador sig apunta
a él mismo.
remover():borra y regresa el nodo v inmediatamente después
del cursor (no el propio cursor, a menos que este
sea el único nodo); si la lista queda vacı́a, el cursor
es puesto a null.
avanzar():pasa el cursor al siguiente nodo en la lista.
La clase ListaCircular, listado 3.13, muestra una implementación Java

de una lista circular enlazada, la cual usa la clase Nodo, listado 3.9. También
incluye un método toString() para generar una representación de cadena
de la lista.
Algunas observaciones acerca de la clase ListaCircular

Es un programa simple que puede dar suficiente funcionalidad para simular
juegos circulares, como Pato, Pato, Ganso, como se ve enseguida. No es un
programa robusto, sin embargo. En particular, si una lista circular está vacı́a,
entonces llamar avanzar o remover en esa lista causará una excepción.
Pato, Pato, Ganso

En el juego de niños Pato, Pato, Ganso, un grupo de niños se sienta en
cı́rculo. Uno de ellos es ellos es elegido para quedarse parado y este camina
alrededor del cı́rculo por fuera. El niño elegido toca a cada niño en la cabeza,
diciendo “Pato” o “Ganso”. Cuando el elegido decide llamar a alguien el
“Ganso”, el “Ganso” se levanta y persigue al otro niño alrededor del cı́rculo.
Si el “Ganso” no logra tocar al elegido, entonces a él le toca quedarse para la
próxima ronda, sino el elegido lo seguirá siendo en la siguiente ronda.
1 /* * Lista circularmente enlazada con nodos de tipo Nodo guardando cadenas . */

2 public class ListaCircular {
3 protected Nodo cursor ; // cursor actual
4 protected int tam ; // cantidad de nodos en la lista
5 /* * Constructor que crea una lista vacia */
6 public ListaCircular () { cursor = null ; tam = 0; }
7 /* * Regresa cantidad de nodos */
8 public int tam () { return tam ; }
9 /* * Regresa cursor */
10 public Nodo getCursor () { return cursor ; }
11 /* * Mueve cursor hacia adelante */
12 public void avanzar () { cursor = cursor . getSig (); }
13 /* * Agrega nodo despu é s del cursor */
14 public void agregar ( Nodo nodoNuevo ) {
15 if ( cursor == null ) { // ¿ lista vacia ?
16 nodoNuevo . setSig ( nodoNuevo );
17 cursor = nodoNuevo ;
18 }
19 else {
20 nodoNuevo . setSig ( cursor . getSig ());
21 cursor . setSig ( nodoNuevo );
22 }
23 tam ++;
24 }
25 /* * Quita nodo despu é s del cursor */
26 public Nodo remover () {
27 Nodo nodo = cursor . getSig (); // nodo que ser á removido
28 if ( nodo == cursor )
29 cursor = null ; // la lista quedar á vac ı́ a
30 else {
31 cursor . setSig ( nodo . getSig () ); // desenlazar el nodo
32 nodo . setSig ( null );
33 }
34 tam - -;
35 return nodo ;
36 }
37 /* * Devuelve una representaci ó n String de la lista ,
38 * iniciando desde el cursor */
40 if ( cursor == null ) return " [] " ;
41 String s = " [... " + cursor . getElemento ();
42 Nodo cursorOrig = cursor ;
43 for ( avanzar (); cursorOrig != cursor ; avanzar () )
44 s += " , " + cursor . getElemento ();
45 return s + " ...] " ;
46 }
47 }
Listado 3.13: Una clase de lista circular enlazada con nodos simples.
Simular este juego es una aplicación ideal de una lista circular enlazada.
Los nodos pueden representar a los niños que están sentados en cı́rculo. El
niño “elegido” puede ser identificado como el niño que está sentado después
del cursor, y puede ser removido del cı́rculo para simular el recorrido alrededor.
Se puede avanzar el cursor con cada “Pato” que el elegido identifique, lo
cual se puede simular con una decisión aleatoria. Una vez que un “Ganso”
es identificado, se puede remover este nodo de la lista, hacer una selección
aleatoria para simular si el “Ganso” alcanzó al elegido, e insertar el ganador
en la lista. Se puede entonces avanzar el cursor e insertar al ganador y repetir
el proceso, o terminar si esta es la última partida del juego.
Lista circular enlazada para Pato, Pato, Ganso

La clase PatoPatoGanso, listado 3.14, muestra el código para simular el
juego Pato, Pato, Ganso.
Se muestra un ejemplo de la salida de la ejecución del programa Pato,
Pato, Ganso a continuación:
Los jugadores son: [...Pedro, Alex, Eli, Paco, Gabi, Pepe, Luis, To~
no...]
Alex es el elegido.
Jugando Pato, Pato, Ganso con: [...Pedro, Eli, Paco, Gabi, Pepe, Luis, To~no...]
Eli es un pAto.
¡Paco es el ganso!
¡El ganso ganó!
Alex es el elegido.
Jugando Pato, Pato, Ganso con: [...Paco, Gabi, Pepe, Luis, To~
no, Pedro, Eli...]
Gabi es un pato.
¡Pepe es el ganso!
¡El ganso perdió!
Pepe es el elegido.
Jugando Pato, Pato, Ganso con: [...Alex, Luis, To~
no, Pedro, Eli, Paco, Gabi...]
Luis es un pato.
To~
no es un pato.
¡Pedro es el ganso!
¡El ganso ganó!
El circulo final es [...Pedro, Pepe, Eli, Paco, Gabi, Alex, Luis, To~no...]
Observar que cada iteración en esta ejecución del programa genera una
salida diferente, debido a las configuraciones iniciales diferentes y el uso de
opciones aleatorias para identificar patos y gansos. Además, la decisión de
que el ganso alcance al jugador parado es una decisión aleatoria.

2 public class PatoPatoGanso {
3 /* * Simulaci ó n de Pato , Pato , Ganso con una lista circular enlazada . */
5 ListaCircular lc = new ListaCircular ();
6 int n = 3; // veces que se jugar á el juego
7 Nodo eleg ; // jugador elegido
8 Nodo ganso ; // el ganso
9 Random rand = new Random ();
10 rand . setSeed ( System . c u r r e n t T i m e M i l l i s () ); // tiempo actual como semilla
11 // Los jugadores ...
12 String [] noms = { " Alex " ," Eli " ," Paco " ," Gabi " ," Pepe " ," Luis " ," To ~
n o " ," Pedro " };
13 for ( String nombre : noms ) {
14 lc . agregar ( new Nodo ( nombre , null ) );
15 lc . avanzar ();
16 }
17 System . out . println ( " Los jugadores son : " + lc . toString ());
18 for ( int i = 0; i < n ; i ++) { // jugar Pato , Pato , Ganso n veces
19 eleg = lc . remover ();
20 System . out . println ( eleg . getElemento () + " es el elegido . " );
21 System . out . println ( " Jugando Pato , Pato , Ganso con : " + lc . toString ());
22 // marchar alrededor del circulo
23 while ( rand . nextBoolean () || rand . nextBoolean ()) {
24 lc . avanzar (); // avanzar con probabilidad 3/4
25 System . out . println ( lc . getCursor (). getElemento () + " es un pato . " );
26 }
27 ganso = lc . remover ();
28 System . out . println ( " ¡ " + ganso . getElemento () + " es el ganso ! " );
29 if ( rand . nextBoolean () ) {
30 System . out . println ( " ¡ El ganso gan ó ! " );
31 lc . agregar ( ganso ); // meter ganso al c ı́ rculo
32 lc . avanzar (); // cursor est á sobre el ganso
33 lc . agregar ( eleg ); // elegido seguir á si é ndolo en la pr ó xima ronda
34 }
35 else {
36 System . out . println ( " ¡ El ganso perdi ó ! " );
37 lc . agregar ( eleg ); // poner elegido en lugar del ganso
38 lc . avanzar (); // cursor est á sobre persona elegida
39 lc . agregar ( ganso ); // ganso es el elegido en la siguiente ronda
40 }
41 }
42 System . out . println ( " El circulo final es " + lc . toString ());
43 }
44 }
Listado 3.14: El método main() de una aplicación que usa una lista circular enlazada
para simular el juego de niños Pato, Pato, Ganso.
3.5.2. Ordenar una LDE

Para ordenar una LDE se puede emplear el algoritmo InsercionOrde-
nada.
Algoritmo InsercionOrdenada(L):
Entrada: Una lista L doblemente enlazada de elementos comparables
Salida: La lista L con elementos rearreglados en orden creciente
si L.tam() ≤ 1 entonces
regresar
f in ← L.getP rimero()
mientras f in no sea el último nodo en L hacer
pivote ← f in.getSig()
Quitar pivote de L
ins ← f in
mientras ins no sea la cabeza y el elemento de ins sea mayor
que el del pivote hacer
ins ← ins.getP rev()
Agregar pivote justo después de ins en L
si ins = f in entonces { pivote no se movió por ser el mayor}
f in ← f in.getSig()
Una implementación en Java del algoritmo de inserción ordenada para una
lista doblemente enlazada representada por la clase ListaDoble se muestra
en el listado 3.15.
3.6. Recurrencia
La repetición se puede lograr escribiendo ciclos, como por ejemplo con
for, o con while. Otra forma de lograr la repetición es usando recurrencia,
la cual ocurre cuando una función se llama a sı́ misma. Se han visto ejemplos
de métodos que llaman a otros métodos, por lo que no deberı́a ser extraño que
muchos de los lenguajes de programación actual, incluyendo Java, permitan
que un método se llame a sı́ mismo. En esta sección, se verá porque esta
capacidad da una alternativa poderosa para realizar tareas repetitivas.
La función factorial
Para ilustrar la recurrencia, se inicia con un ejemplo sencillo para calcular
el valor de la función factorial. El factorial de un entero positivo n, denotada
3.6 Recurrencia 125
1 /* * Inserci ó n ordenada para una lista doblemente enlazada

2 de la clase ListaDoble . */
3 public static void ordenar ( ListaDoble L ) {
4 if ( L . tam () <= 1) return ; // L ya est á ordenada en este caso
5 NodoD pivote ; // nodo pivote
6 NodoD ins ; // punto de inserci ó n
7 NodoD fin = L . getPrimero (); // fin de la corrida
8 while ( fin != L . getUltimo ()) {
9 pivote = fin . getSig (); // obtener el siguiente nodo de pivote
10 L . remover ( pivote ); // quitar pivote de L
11 ins = fin ; // iniciar busqueda desde fin de la corrida ordenada
12 while ( L . tienePrev ( ins ) &&
13 ins . getElemento (). compareTo ( pivote . getElemento ()) > 0)
14 ins = ins . getPrev (); // mover a la izquierda
15 // agregar el pivote de regreso , despues del punto de inserci ó n
16 L . agregarD espues ( ins , pivote );
17 if ( ins == fin ) // se ha agregado pivote despu é s de fin ( se quedo
18 fin = fin . getSig (); // en el mismo lugar ) -> incrementar marcador fin
19 }
20 }
Listado 3.15: Ordenamiento por inserción para una lista doblemente enlazada
representada por la clase ListaDoble.
por n!, está definida como el producto de los enteros desde 1 hasta n. Si n = 0,
entonces n! está definida como uno por convención. Mas formalmente, para
cualquier entero n ≥ 0,

1 si n = 0
n! =
1 · 2 · · · (n − 2) · (n − 1) · n si n ≥ 1
Para denotar n! se empleará el siguiente formato usado en los métodos de
Java, factorial(n).
La función factorial puede ser definida de una forma que sugiera una
formulación recursiva. Para ver esto, observar que
factorial(5) = 5 · (4 · 3 · 2 · 1) = 5 · factorial(4)
Por lo tanto, se puede definir factorial(5) en términos del factorial(4).
En general, para un entero positivo n, se puede definir factorial(n) como
n · factorial(n − 1). Esto lleva a la siguiente definición recursiva.

1 si n = 0
factorial(n) = (3.1)
n · factorial(n − 1) si n ≥ 1
Esta definición es tı́pica de varias definiciones recursivas. Primero, esta
contiene uno, o más caso base, los cuales no están definidos recursivamente,
si no en términos de cantidades fijas. En este caso, n = 0 es el caso base.
Esta definición también contiene uno o más casos recursivos, los cuales
están definidos empleando la definición de la función que está siendo definida.
Observar que no hay circularidad en esta definición, porque cada vez que la
función es invocada, su argumento es más pequeño en uno.
Implementación recursiva de la función factorial

Se considera una implementación en Java, listado 3.16, de la función facto-
rial que está dada por la fórmula 3.1 con el nombre factorialRecursivo().
Observar que no se requiere ciclo. Las invocaciones repetidas recursivas de la
función reemplazan el ciclo.
1 public static int f a c t o r i a l R e c u r s i v o ( int n ) { // funci ó n recursiva factorial

2 if ( n == 0) return 1; // caso base
3 else return n * f a c t o r i a l R e c u r s i v o (n -1); // caso recursivo
4 }
Listado 3.16: Una implementación recursiva de la función factorial.
¿Cuál es la ventaja de usar recurrencia? La implementación recursiva de

la función factorial es un poco más simple que la versión iterativa, en este
caso no hay razón urgente para preferir la recurrencia sobre la iteración. Para
algunos problemas, sin embargo, una implementación recursiva puede ser
significativamente más simple y fácil de entender que una implementación
iterativa como en los ejemplos siguientes.
Dibujar una regla inglesa

Como un caso más complejo del uso de recurrencia, considerar como dibujar
las marcas de una regla tı́pica inglesa. Una regla está dividida en intervalos
de una pulgada, y cada intervalo consiste de un conjunto de marcas colocadas
en intervalos de media pulgada, un cuarto de pulgada, y ası́ sucesivamente.
Como el tamaño del intervalo decrece por la mitad, la longitud de la marca
decrece en uno, ver figura 3.16.
Cada múltiplo de una pulgada también tiene una etiqueta numérica. La
longitud de la marca más grande es llamada la longitud de la marca principal.
No se consideran las distancias actuales entre marcas, sin embargo, se imprime
una marca por lı́nea.
3.6 Recurrencia 127
---- 0 ----- 0 --- 0

- - -
-- -- --
- - -
--- --- --- 1
- - -
-- -- --
- - -
---- 1 ---- --- 2
- - -
-- -- --
- - -
--- --- --- 3
- -
-- --
- -
---- 2 ----- 1
(a) (b) (c)
Figura 3.16: Ejemplos de la función dibuja regla: (a) regla de 2” con longitud 4 de
la marca principal; (b) regla de 1” con longitud 5; (c) regla de 3” con longitud 3.
Una aproximación recursiva para dibujar la regla

La aproximación para dibujar tal regla consiste de tres funciones. La
función principal dibujaRegla() dibuja la regla entera. Sus argumentos son
el número total de pulgadas en la regla, nPulgadas, y la longitud de la marca
principal, longPrincipal. La función utilidad dibujaUnaMarca() dibuja una
sola marca de la longitud dada. También se le puede dar una etiqueta entera
opcional, la cual es impresa si esta no es negativa.
El trabajo interesante es hecho por la función recursiva dibujaMarcas(),
la cual dibuja la secuencia de marcas dentro de algún intervalo. Su único
argumento es la longitud de la marca asociada con la marca del intervalo
central. Considerar la regla de 1” con longitud 5 de la marca principal mostrada
en la figura 3.16(b). Ignorando las lı́neas conteniendo 0 y 1, considerar como
dibujar la secuencia de marcas que están entre estas lı́neas. La marca central
(en 1/2”) tiene longitud 4. Los dos patrones de marcas encima y abajo de
esta marca central son idénticas, y cada una tiene una marca central de
longitud 3. En general, un intervalo con una marca central de longitud L ≥ 1
está compuesto de lo siguiente:
Un intervalo con una longitud de marca central L − 1

Un sólo interalo de longitud L
Un intervalo con una longitud de marca central L − 1
Con cada llamada recursiva, la longitud decrece por uno. Cuando la
longitud llega a cero, se debe regresar. Como resultado, este proceso recursivo
siempre terminará. Esto sugiere un proceso recursivo, en el cual el primer
paso y último son hechos llamando a dibujaMarcas(L-1) recursivamente. El
paso central es realizado llamando a la función dibujaUnaMarca(L). Esta
formulación recursiva es mostrada en el listado 3.17. Como en el ejemplo del
factorial, el código tiene un caso base, cuando L = 0. En este ejemplo se
hacen dos llamadas recursivas a la función.
1 // dibuja regla conteniendo nPulgadas con marca de tama ~ n o longPrincipal
2 public static void dibujaRegla ( int nPulgadas , int longPrincipal ) {
3 dibu jaUnaMar ca ( longPrincipal , 0); // dibujar marca 0 y su etiqueta
4 for ( int i = 1; i <= nPulgadas ; i ++) {
5 dibujaMarcas ( longPrincipal -1); // dibujar marcas para esta pulgada
6 dibu jaUnaMar ca ( longPrincipal , i ); // dibujar marca i y su etiqueta
7 }
8 }
9 // dibuja marcas de longitud dada
10 public static void dibujaMarcas ( int longMarca ) {
11 if ( longMarca > 0) { // parar cuando la longitud llegue a 0
12 dibujaMarcas ( longMarca -1); // rec ursivame nte dibujar marca superior
13 dibu jaUnaMar ca ( longMarca ); // dibujar marca principal
14 dibujaMarcas ( longMarca -1); // rec ursivame nte dibujar marca inferior
15 }
16 }
17 // dibuja una marca sin etiqueta
18 public static void dibu jaUnaMa rca ( int longMarca ) {
19 dibu jaUnaMar ca ( longMarca , -1);
20 }
21 // dibuja una marca
22 public static void dibu jaUnaMa rca ( int longMarca , int etiqMarca ) {
23 for ( int i = 0; i < longMarca ; i ++)
24 System . out . print ( " -" );
25 if ( etiqMarca >= 0) System . out . print ( " " + etiqMarca );
26 System . out . print ( " \ n " );
27 }
Listado 3.17: Implementación recursiva del método dibujaMarcas() para mostrar

marcas de una regla.
Sumar elementos de un arreglo recursivamente

Suponer que se da un arreglo, A, de n enteros que se desean sumar juntos.
Se puede resolver el problema de la suma usando recurrencia lineal observando
3.6 Recurrencia 129
que la suma de todos los n enteros de A es igual a A[0], si n es 1, o la suma

de los primeros n − 1 enteros más la suma del último elemento en A. En
particular, se puede resolver esta suma usando el algoritmo recursivo siguiente.
Algoritmo SumaLineal(A, n):
Entrada: Un arreglo A de enteros y un entero n ≥ 1 tal que A tiene
al menos n elementos.
Salida: La suma de los primeros n enteros en A.
si n = 1 entonces
regresar A[0]
si no
regresar SumaLineal(A, n − 1) + A[n − 1]
Este ejemplo, también ilustra una propiedad importante que un método
recursivo deberı́a siempre tener—que el método termina. Se asegura esto
escribiendo una sentencia no recursiva para el caso n igual a 1. Además,
siempre se hace una llamada recursiva sobre un valor más pequeño del
parámetro n menos 1 que el que fue dado, n, por lo tanto, en algún punto,
en el punto mas bajo de la recurrencia, se hará la parte no recursiva del
cálculo, regresando A[0]. En general, un algoritmo que usa recurrencia lineal
tı́picamente tiene la siguiente forma:
Prueba para los casos base. Se inicia probando un conjunto de casos

base, deberı́a haber al menos uno. Estos casos basos deberı́an estar
definidos, por lo que cada posible encadenamiento de llamadas recursivas
eventualmente alcanzará un caso base, y el manejo de cada caso base
no deberı́a usar recurrencia.
Recurrencia. Después de probar los casos base, entonces se realizan

llamadas recursivas simples. Este paso recursivo podrı́a involucrar una
prueba que decida cual de varias posibles llamadas recursivas hacer, pero
finalmente deberı́a escoger hacer sólo una de estas posibles llamadas
cada vez que se haga este paso. Mas aún, se deberı́a definir cada posible
llamada recursiva para que esta progrese hacia el caso base.
Invertir un arreglo por recurrencia

Se considera ahora el problema de invertir los n elementos de un arreglo, A,
para que el primer elemento sea el último, el segundo elemento sea el penúltimo,
y ası́ sucesivamente. Se puede resolver este problema usando recurrencia lineal,
observando que la inversión de un arreglo se puede lograr intercambiando

el primer elemento y el último, y entonces invertir recursivamente el resto
de los elementos en el arreglo. Se describen a continuación los detalles de
este algoritmo, usando la convención de que la primera vez que se llama el
algoritmo se hace como InvertirArreglo(A, 0, n − 1).
Algoritmo InvertirArreglo(A, i, j):
Entrada: Un arreglo A e ı́ndices enteros no negativos i y j.
Salida: La inversión de los elementos en A iniciando en el ı́ndice i
y terminando en j.
si i < j entonces
Intercambiar A[i] y A[j]
InvertirArreglo(A, i + 1, j − 1)
regresar
En este algoritmo se tienen dos casos base implı́citos, a saber, cuando
i = j y cuando i > j. Sin embargo, en cualquier caso, se termina el algoritmo,
ya que una secuencia con cero elementos, o un elemento es trivialmente igual a
su inversión. Además, en el paso recursivo se está garantizando ir progresando
hacia uno de los dos casos base. Si n es par, eventualmente se alcanzará el
caso i = j, y si n es impar, eventualmente se alcanzará el caso i > j. El
argumento anterior implica que el algoritmo recursivo está garantizado para
terminar.
Definir problemas para facilitar la recurrencia
Para diseñar un algoritmo recursivo para un problema dado, es útil pensar

en las diferentes formas en que se puede subdividir el problema para definir
problemas que tengan la misma estructura general que el problema original.
Este proceso en ocasiones significa que se necesita redefinir el problema
original para facilitar la búsqueda de problemas similares. Por ejemplo, con
el algoritmo InvertirArreglo, se agregaron los parámetros i y j por
lo que una llamada recursiva para invertir la parte interna del arreglo A
podrı́a tener la misma estructura y la misma sintaxis, como la llamada para
invertir cualquier otro par de valores del arreglo A. Entonces, en vez de
inicialmente llamar al algoritmo como InvertirArreglo(A), se llama a este
inicialmente como InvertirArreglo(A, 0, n − 1). En general, si se tiene
dificultad para encontrar la estructura repetitiva requerida para diseñar un
algoritmo recursivo, en algunos casos es útil trabajar el problema con algunos
3.6 Recurrencia 131
ejemplos concretos pequeños para ver como los subproblemas deberı́an estar
definidos.
Recurrencia de cola
Usar la recurrencia puede ser con frecuencia una herramienta útil para
diseñar algoritmos que tienen definiciones cortas y elegantes. Pero esta utilidad
viene acompañado de un costo modesto. Cuando se usa un algoritmo recursivo
para resolver un problema, se tienen que usar algunas de las localidades de la
memoria para guardar el estado de las llamadas recursivas activas. Cuando la
memoria de la computadora es un lujo, entonces, es más útil en algunos casos
poder derivar algoritmos no recurrentes de los recurrentes.
Se puede emplear la estructura de datos pila para convertir un algo-
ritmo recurrente en uno no recurrente, pero hay algunos casos cuando se
puede hacer esta conversión más fácil y eficiente. Especı́ficamente, se puede
fácilmente convertir algoritmos que usan recurrencia de cola. Un algorit-
mo usa recurrencia de cola si este usa recursión lineal y el algoritmo hace
una llamada recursiva como su última operación. Por ejemplo, el algoritmo
InvertirArreglo usa recurrencia de cola.
Sin embargo, no es suficiente que la última sentencia en el método definición
incluya una llamada recurrente. Para que un método use recurrencia de cola, la
llamada recursiva deberá ser absolutamente la última parte que el método haga,
a menos que se esté en el caso base. Por ejemplo, el algoritmo SumaLineal no
usa recurrencia de cola, aún cuando su última sentencia incluye una llamada
recursiva. Esta llamada recursiva no es actualmente la última tarea que el
método realiza. Después de recibir el valor regresado de la llamada recursiva,
le agrega el valor de A[n − 1] y regresa su suma. Esto es, la última tarea que
hace el algoritmo es una suma, y no una llamada recursiva.
Cuando un algoritmo emplea recurrencia de cola, se puede convertir el
algoritmo recurrente en uno no recurrente, iterando a través de las llamadas
recurrentes en vez de llamarlas a ellas explı́citamente. Se ilustra este tipo de
conversión revisitando el problema de invertir los elementos de un arreglo.
El siguiente algoritmo no recursivo realiza la tarea de invertir los elementos
iterando a través de llamadas recurrentes del algoritmo InvertirArreglo.
Inicialmente se llama a este algoritmo como InvertirArregloIterati-
vo(A, 0, n − 1).
Algoritmo InvertirArregloIterativo(A, i, j):

Entrada: Un arreglo A e ı́ndices enteros no negativos i y j.
Salida: La inversión de los elementos en A iniciando en el ı́ndice i
y terminando en j.
mientras i < j hacer
Intercambiar A[i] y A[j]
i←i+1
j ←j−1
regresar
3.6.1. Recurrencia binaria

Cuando un algoritmo hace dos llamadas recurrentes, se dice que usa
recurrencia binaria. Estas llamadas pueden, por ejemplo, ser usadas para
resolver dos hojas similares de algún problema, como se hizo para dibujar
una regla inglesa, sección 3.6. Como otra aplicación de recurrencia binaria,
se revisitará el problema de sumar los n elementos de un arreglo de enteros
A. En este caso, se pueden sumar los elementos de A: (i) recurrentemente
los elementos en la primera mitad de A; (ii) recurrentemente los elementos
en la segunda mitad de A; y (iii) agregando estos dos valores juntos. Se dan
los detalles en el siguiente algoritmo, el cual es inicialmente llamado como
SumaBinaria(A, 0, n).
Algoritmo SumaBinaria(A, i, n):
Entrada: un arreglo A de enteros y enteros i y n.
Salida: la suma de los primeros n enteros en A iniciando en el ı́ndice i.
si n = 1 entonces
regresar A[i]
regresar SumaBinaria(A, i, dn/2e)+SumaBinaria(A, i + dn/2e, bn/2c)
Para analizar el algoritmo SumaBinaria, se considera, por simplicidad,
el caso cuando n es potencia de 2. La figura 3.17 muestra el trazado de la
recursión de una ejecución del método SumaBinaria(0,8). Se etiqueta cada
recuadro con los valores de los parámetros i y n, los cuales representan el
ı́ndice inicial y el tamaño de la secuencia de los elementos que serán sumados,
respectivamente. Observar que las flechas en el trazado van de un recuadro
etiquetado (i, n) a otro recuadro etiquetado (i, n/2) o (i+n/2, n/2). Esto es, el
valor del parámetro n es dividido en dos en cada llamada recursiva. Por lo tanto,
la profundidad de la recursión, esto es, el número máximo de instancias del
3.6 Recurrencia 133
método que están activas al mismo tiempo, es 1+log2 n. Entonces el algoritmo

usa una cantidad de espacio adicional aproximadamente proporcional a su
valor. El tiempo de ejecución del algoritmo es todavı́a proporcional a n, ya
que cada recuadro es visitado en tiempo constante y hay 2n − 1 recuadros.
Figura 3.17: Trazado de la recursión de SumaBinaria(0, 8).
Fibonacci con recurrencia binaria

Se considera ahora el problema de calcular el k-ésimo número de Fibonacci.
Los números de Fibonacci están recursivamente definidos como:
F0 = 0
F1 = 1
Fi = Fi−1 + Fi−2 para i > 1.
Aplicando directamente la definición anterior, el algoritmo FibBinario,
mostrado a continuación, encuentra la secuencia de los números de Fibonacci
empleando recurrencia binaria.
Algoritmo FibBinario(k):
Entrada: Un entero k no negativo.
Salida: El k-ésimo número de Fibonacci Fk .
si k ≤ 1 entonces
regresar k
si no
regresar FibBinario(k − 1)+FibBinario(k − 2)
Desafortunadamente, a pesar de que la definición de Fibonacci parece una
recursión binaria, esta técnica es ineficiente en este caso. De hecho, toma un
número de llamadas exponencial para calcular el k-ésimo número de Fibonacci
de esta forma. Especı́ficamente, sea nk el número de llamadas hechas en la
ejecución de FibBinario(k). Entonces, se tienen los siguientes valores para

las diferentes nk :
n0 = 1
n1 = 1
n2 = n1 + n0 + 1 = 3
n3 = n2 + n1 + 1 = 5
n4 = n3 + n2 + 1 = 9
n5 = n4 + n3 + 1 = 15
n6 = n5 + n4 + 1 = 25
n7 = n6 + n5 + 1 = 41
n8 = n7 + n6 + 1 = 67
Si se sigue hacia adelante el patrón, se ve que el número de llamadas es

más del doble para un ı́ndice que esté dos ı́ndices anteriores. Esto es, n4 es
más del doble que n2 , n5 es más del doble que n3 , y ası́ sucesivamente. Por
lo tanto, nk > 2k/2 , lo que significa que FibBinario(k) hace un número de
llamadas que son exponenciales en k. En otras palabras, emplear recurrencia
binaria para calcular números de Fibonacci es muy ineficiente.
Fibonacci con recurrencia lineal
El principal problema con la aproximación anterior, basada en recurrencia

binaria, es que el cálculo de los números de Fibonacci es realmente un problema
de recurrencia lineal. No es este un buen candidato para emplear recurrencia
binaria. Se empleó recurrencia binaria por la forma como el k-ésimo número
de Fibonacci, Fk , dependı́a de los dos valores previos, Fk−1 y Fk−2 . Pero se
puede encontrar Fk de una forma más eficiente usando recurrencia lineal.
Para poder emplear recurrencia lineal, se necesita redefinir ligeramente
el problema. Una forma de lograr esta conversión es definir una función
recursiva que encuentre un par consecutivo de números Fibonacci (Fk−1 , Fk ).
Entonces se puede usar el siguiente algoritmo de recurrencia lineal mostrado
a continuación.
3.6 Recurrencia 135
Algoritmo FibLineal(k):
Entrada: Un entero k no negativo.
Salida: El par de números Fibonacci (Fk , Fk−1 ).
si k ≤ 1 entonces
regresar (k, 0)
si no
(i, j) ← FibLineal(k − 1)
regresar (i + j, i)
El algoritmo dado muestra que usando recurrencia lineal para encontrar
los números de Fibonacci es mucho más eficiente que usando recurrencia
binaria. Ya que cada llama recurrente a FibLineal decrementa el argumento
k en 1, la llamada original FibLineal(k) resulta en una serie de k − 1
llamadas adicionales. Esto es, calcular el k-ésimo número de Fibonacci usando
recurrencia lineal requiere k llamadas al método. Este funcionamiento es
significativamente más rápido que el tiempo exponencial necesitado para
el algoritmo basado en recurrencia binaria. Por lo tanto, cuando se usa
recurrencia binaria, se debe primero tratar de particionar completamente el
problema en dos, o se deberı́a estar seguro que las llamadas recursivas que se
traslapan son realmente necesarias.
Usualmente, se puede eliminar el traslape de llamadas recursivas usando
más memoria para conservar los valores previos. De hecho, esta aproximación
es una parte central de una técnica llamada programación dinámica, la cual
está relacionada con la recursión.
3.6.2. Recurrencia múltiple

La generalización de la recurrencia binaria lleva a la recurrencia múlti-
ple, que es cuando un método podrı́a hacer varias llamadas recursivas, siendo
ese número potencialmente mayor que dos. Una de las aplicaciones más co-
munes de este tipo de recursión es usada cuando se quiere enumerar varias
configuraciones en orden para resolver un acertijo combinatorio. Por ejemplo,
el siguiente es un acertijo de suma:
par + ras = assa
Para resolver el acertijo, se necesita asignar un dı́gito único, esto es,

0,1,. . . ,9, a cada letra en la ecuación, para poder hacer la ecuación verdadera.
Tı́picamente, se resuelve el acertijo usando observaciones humanas del acertijo
particular que se está intentando resolver para eliminar configuraciones hasta

que se pueda trabajar con las configuraciones restantes, probando la correctez
de cada una.
Sin embargo, si el número de configuraciones posibles no es muy grande, se
puede usar una computadora para enumerar todas las posibilidades y probar
cada una, sin emplear observaciones humanas. Además, tal algoritmo puede
usar recurrencia múltiple para trabajar a través de todas las configuraciones
en una forma sistemática. Se proporciona enseguida pseudocódigo para tal
algoritmo. Para conservar la descripción general suficiente para ser usado con
otros acertijos, el algoritmo enumera y prueba todas las secuencias de longitud
k sin repeticiones de los elementos de un conjunto dado U . Se construyen las
secuencias de k elementos mediante los siguientes pasos:
1. Generar recursivamente las secuencias de k − 1 elementos.
2. Agregar a cada una de tales secuencias un elemento que no esté contenido

dentro de esta.
En toda la ejecución del algoritmo, se usa el conjunto U para saber los

elementos no contenidos en la secuencia actual, por lo que un elemento e no
ha sido usado aún sı́ y sólo sı́ e está en U .
Otra forma de ver el algoritmo siguiente es que este enumera cada sub-
conjunto ordenado posible de tamaño, y prueba cada subconjunto para ser
una posible solución al acertijo.
Para acertijos de sumas, U = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9} y cada posición en
la secuencia corresponde a una letra dada. Por ejemplo, la primera posición
podrı́a ser b, la segunda o, la tercera y, y ası́ sucesivamente.
3.6 Recurrencia 137
Algoritmo ResolverAcertijo(k, S, U ):
Entrada: Un entero k, secuencia S, y conjunto U .
Salida: Una enumeración de todas las extensiones k-longitud para S
usando elementos en U sin repeticiones.
para cada e en U hacer
Remover e de U { e está ahora siendo usado }
Agregar e al final de S
si k = 1 entonces
Probar si S es una configuración que resuelva el acertijo
si S resuelve el acertijo entonces
regresar “Solución encontrada: ” S
si no
ResolverAcertijo(k − 1, S, U )
Agregar e de regreso a U { e está ahora sin uso }
Remover e del final de S
Capı́tulo 4
Herramientas de análisis
4.1. Funciones
Se revisan brevemente, en esta sección, las siete funciones más importantes
usadas en el análisis de algoritmos.
4.1.1. La función constante

La función más simple que se emplea es la función constante. Esta es
la función
f (n) = c,
para alguna constante fija c, tal como c = 7, c = 25, o c = 28 . Con esta

función, para cualquier argumento n, la función constante f (n) asigna el valor
c, es decir, no importa cual sea el valor de n, f (n) siempre será igual al valor
constante c.
Como se emplean generalmente funciones enteras en el análisis, la función
constante más usada es g(n) = 1, y cualquier otra función constante, f (n) = c,
puede ser escrita como una constante c veces g(n), es decir, f (n) = cg(n).
Esta función caracteriza el número de pasos requeridos para hacer una
operación básica en la computadora, como la suma de dos números, asignar
un valor a una variable, o comparar dos números.
140 Herramientas de análisis
4.1.2. La función logarı́tmica

La función logarı́tmica f (n) = logb n, para alguna constante b > 1 es
ubicua, ya que aparece con bastante frecuencia en el análisis de estructuras
de datos y algoritmos. Esta función está definida como sigue:
x = logb n sı́ y sólo sı́ bx = n.

Por definición, logb 1 = 0. El valor de b es conocido como la base del
logaritmo.
Para encontrar el valor exacto de esta función para cualquier entero n se
requiere el uso de cálculo, pero se puede usar una aproximación útil en el
análisis sin emplear cálculo. En particular, se puede calcular el entero más
pequeño que sea mayor o igual a logb n, ya que este número es igual al número
de veces que se puede dividir n por b hasta que se obtenga un número menor
que, o igual a 1. Por ejemplo, log3 27 es 3, ya que 27/3/3/3 = 1. De igual
modo, log4 64 es 3, porque 64/4/4/4 = 1, y la aproximación a log2 12 es 4, ya
que 12/2/2/2/2 = 0.75 ≤ 1. La aproximación base dos surge en el análisis
de algoritmos, ya que es una operación común en los algoritmos “divide y
vencerás” por que repetidamente dividen la entrada por la mitad.
Además, como las computadoras almacenan los enteros en binario, la base
más común para la función logarı́tmica en ciencias de la computación es dos,
por lo que tı́picamente no se indica cuando es dos, ası́ se tiene,
log n = log2 n.
Hay algunas reglas importantes para logaritmos, parecidas a las reglas de
exponentes.
Proposición 4.1: Reglas de logaritmos dados números reales a > 0,
b > 1, c > 0, y d > 1, se tiene:
1. logb ac = logb a + logb c
2. logb a/c = logb a − logb c
3. logb ac = c logb a
4. logb a = (logd a)/ logd b
5. blogd a = alogd b
Como notación abreviada, se usa logc n para denotar la función (log n)c .
4.1 Funciones 141
4.1.3. La función lineal

Otra función simple e importante es la función lineal,
f (n) = n.
Esto es, dado un valor de entrada n, la función lineal f asigna el propio
valor n.
Esta función surge en el análisis de algoritmos cuando se tiene que ha-
cer una operación básica para cada uno de los n elementos. Por ejemplo,
comparar un número x con cada uno de los elementos de una arreglo de
tamaño n requerirá n comparaciones. La función lineal también representa el
mejor tiempo de ejecución que se espera lograr para cualquier algoritmo que
procese una colección de n objetos que no estén todavı́a en la memoria de la
computadora, ya que leer los n objetos requiere n operaciones.
4.1.4. La funcion N-Log-N

La función
f (n) = n log n,
es la que asigna a una entrada n el valor de n veces el logaritmo de base dos
de n. Esta función crece un poco más rápido que la función lineal, pero es
más rápida que la función cuadrática. Por lo tanto, si se logra mejorar el
tiempo de ejecución de algún problema desde un tiempo cuadrático a n-log-n,
se tendrá un algoritmo que corra más rápido en general.
4.1.5. La función cuadrática

La función cuadrática también aparece muy seguido en el análisis de
algoritmos,
f (n) = n2 .
Para un valor de entrada n, la función f asigna el producto de n con ella
misma, es decir, “n cuadrada”.
La razón principal por la que la función cuadrática aparece en el análisis
de algoritmos es porque hay muchos algoritmos que tienen ciclos anidados,
donde el ciclo interno realiza un número lineal de operaciones y el ciclo
externo también es realizado un número lineal de veces. Ası́, en tales casos, el

algoritmo realiza n · n = n2 operaciones.
Ciclos anidados y la función cuadrática

La función cuadrática puede también surgir en los ciclos anidados donde la
primera iteración de un ciclo usa una operación, la segunda usa dos operaciones,
la tercera usa tres operaciones, y ası́ sucesivamente, es decir, el número de
operaciones es
1 + 2 + 3 + · · · + (n − 2) + (n − 1) + n.
En otras palabras, este es el número total de operaciones que serán hechas
por el ciclo anidado, si el número de operaciones realizadas dentro del ciclo
se incrementa por uno con cada iteración del ciclo exterior.
Se cree que Carl Gauss usó la siguiente identidad para resolver el problema
que le habı́an dejado de encontrar la suma desde 1 hasta 100, cuando tenı́a
aproximadamente 10 años.
Proposición 4.2: Para cualquier entero n ≥ 1, se tiene
n(n + 1)
1 + 2 + 3 + · · · + (n − 2) + (n − 1) + n = .
2
En la figura 4.1 se da la justificación visual de la proposición 4.2.
Lo que se desprende de este resultado es que si se ejecuta un algoritmo
con ciclos anidados tal que las operaciones del ciclo anidado se incrementan
en uno cada vez, entonces el número total de operaciones es cuadrático en el
número de veces, n, que se hace el ciclo exterior. En particular, el número de
operaciones es n2 /2 + n/2, en este caso, lo cual es un poco más que un factor
constante (1/2) veces la función cuadrática n2 .
4.1.6. La función cúbica y otras polinomiales

De las funciones que son potencias de la entrada, se considera la función
cúbica,
f (n) = n3 ,
la cual asigna a un valor de entrada n el producto de n con el mismo tres
veces. Esta función aparece con menor frecuencia en el contexto del análisis
4.1 Funciones 143
Figura 4.1: Justificación visual de la proposición 4.2. Las figuras muestran la

identidad en términos del área total cubierta. En (a) los rectángulos son mostrados
cubriendo un triángulo de área n2 /2, base n y altura n, más n triángulos pequeños
de área 1/2 cada uno, base 1 y altura 1. En (b), se aplica sólo cuando n es par y
los rectángulos cubren un rectángulo de base n/2 y altura n + 1.
de algoritmos que las funciones constante, lineal o cuadrática pero aparece de

vez en cuando.
Polinomiales
Algunas de las funciones que se han revisado previamente pueden ser

vistas como una parte de una clase de funciones más grandes, las funciones
polinomiales.
Una función polinomial es una función de la forma,
f (n) = a0 + a1 n + a2 n2 + a3 n3 + · · · + ad nd ,
donde a0 , a1 , . . . , ad son constantes, llamados los coeficientes de la polinomial,

y ad 6= 0. El entero d, el cual indica la potencia más grande en el polinomio,
es llamado el grado del polinomio.
Sumatorias
Una notación que aparece varias veces en el análisis de las estructuras de
datos y algoritmos es la sumatoria, la cual está definida como sigue:
b
X
f (i) = f (a) + f (a + 1) + f (a + 2) + · · · + f (b),
i=a
donde a y b son enteros y a ≤ b. Las sumatorias surgen en el análisis de

algoritmos y estructuras de datos porque los tiempos de ejecución de ciclos
naturalmente dan estos.
La fórmula de la proposición 4.2 se puede reescribir usando la sumatoria
como:
n
X n(n + 1)
i= .
i=1
2
De igual forma, puede escribir un polinomio f (n) de grado d con coefi-
cientes a0 , . . . , ad como:
d
X
f (n) = ai ni .
i=0
La notación de sumatoria da una forma breve de expresar sumas de

términos incrementales que tienen una estructura regular.
4.1.7. La función exponencial

Otra función usada en el análisis de algoritmos es la función exponencial
f (n) = bn ,
donde b es una constante positiva, llamada la base, y el argumento n es el
exponente, es decir, la función f (n) asigna al argumento de entrada n el
valor obtenido de multiplicar la base b por sı́ misma n veces. En análisis de
algoritmos, la base más común para la función exponencial es b = 2. Por
ejemplo, si se tiene un ciclo que inicia realizando una operación y entonces
dobla el número de operaciones hechas con cada iteración, entonces el número
de operaciones realizadas en la n-ésima iteración es 2n . Además, una palabra
entera conteniendo n bits puede representar todos los enteros no negativos
4.1 Funciones 145
menores que 2n . La función exponencial también será referida como función

exponente.
En ocasiones se tienen otros exponentes además de n, por lo que es útil
conocer unas cuantas reglas para trabajar con exponentes.
Proposición 4.3: REglas de exponentes dados enteros positivos a, b, y
c, se tiene
1. (ba )c = bac
2. ba bc = ba+c
3. ba /bc = ba−c
Se puede extender la función exponencial a exponentes que son fracciones

o números reales y exponentes negativos, como sigue. Dado un entero positivo
k, se define b1/k como la k-ésima raı́z de b, esto es, el número r tal que
rk = b. Esta aproximación permite definir cualquier potencia cuyo exponente
pueda ser expresado como una fracción, para ba/c = (ba )1/c , por la regla 1 de
exponentes.
Se puede extender la función exponencial para definir bx para cualquier
número real x, calculando series de números de la forma ba/c para fracciones
a/c que estén progresivamente más y más cerca a x. Dado un exponente
negativo d, se define bd = 1/b−d , lo cual corresponde a usar la regla 3 de
exponentes con a = 0 y c = −d.
Sumas geométricas
Cuando se tiene un ciclo donde cada iteración toma un factor multipli-
cativo mayor que la previa, se puede analizar este ciclo usando la siguiente
proposición.
Proposición 4.4: Para cualquier entero n ≥ 0 y cualquier número real a tal
que a > 0 y a 6= 1, considerar la sumatoria
n
X
ai = 1 + a + a2 + · · · + an
i=0
recordando que a0 = 1 si a > 0. Esta suma es igual a
an+1 − 1
.
a−1
Las sumatorias, como la mostrada en la proposición anterior, son llamadas

sumatorias geométricas, porque cada término es geométricamente mayor
que el previo si a > 1. Por ejemplo, en la siguiente sumatoria
1 + 2 + 4 + 8 + · · · + 2n−1 = 2n − 1,
se calcula el entero más grande que puede ser representado en notación binaria
usando n bits.
4.1.8. Relaciones de crecimiento

El cuadro 4.1 muestra en orden de crecimiento cada una de las siete
funciones usadas principalmente en el análisis de algoritmos.
constante logarı́tmica lineal n-log-n cuadrática cúbica exponencial

1 log n n n log n n2 n3 an
Cuadro 4.1: Clases de funciones. Se asume que a > 1 es una constante.
Se quisiera que las operaciones en estructuras de datos se ejecuten en

tiempos proporcionales a la constante o la logarı́tmica, y que los algoritmos
lo hagan en tiempo lineal o n-log-n. Los algoritmos con tiempos de ejecución
cuadrático o cúbico son menos prácticos, pero algoritmos con tiempos expo-
nenciales son imposibles excepto para entradas pequeñas. Las siete funciones
están graficadas en la figura 4.2. Se usó base a = 2 para la función exponen-
cial. Las funciones están graficadas en una escala logarı́tmica, para comparar
principalmente las relaciones de crecimiento como pendientes.
Función piso y techo

El valor de un logaritmo generalmente no es un entero, aunque el tiempo
de ejecución de un algoritmo usualmente es dado por una cantidad entera, tal
como la cantidad de operaciones realizadas. Ası́, el análisis de un algoritmo
podrı́a en ocasiones involucrar el uso de la función piso y la función techo,
las cuales son definidas respectivamente como sigue:
bxc el entero más grande menor que o igual a x.

dxe el entero más pequeño mayor que o igual a x.
4.2 Análisis de algoritmos 147
Figura 4.2: Relaciones de crecimiento para las siete funciones fundamentales usadas
en análisis de algoritmos.
4.2. Análisis de algoritmos

Se está interesado en el diseño de estructuras de datos y algoritmos
“buenos”. De una manera simple, una estructura de datos es una forma
sistemática de organizar y acceder datos, y un algoritmo es un procedimiento
paso a paso para realizar alguna tarea en una cantidad finita de tiempo. Para
poder clasificar las estructuras de datos y los algoritmos como “buenos”, se
deben tener formas precisas de analizarlos.
La herramienta de análisis primario que se usará involucra la caracteriza-
ción de los tiempos de ejecución de los algoritmos y las operaciones de las
estructuras de datos, siendo también el espacio usado de interés. El tiempo
de ejecución es una medida natural de la “bondad”, ya que el tiempo es un
recurso precioso, las soluciones computacionales deberán ejecutarse tan rápido
como sea posible.
En general, el tiempo de ejecución de un algoritmo o de un método de una
estructura de datos se incrementa con el tamaño de la entrada, sin embargo
podrı́a variar para entradas diferentes con el mismo tamaño. También, el
tiempo de ejecución es afectado por el ambiente del hardware del sistema de
cómputo, como el procesador, frecuencia del reloj, memoria, disco, etc., y por
el ambiente del software, como el sistema operativo, lenguaje de programa-
ción, compilador, intérprete, etc., en el cual el algoritmo está implementado,
compilado y ejecutado. Siendo todos los factores iguales, el tiempo de eje-
cucion del mismo algoritmo con la misma entrada de datos será menor si
la computadora tiene un procesador más rápido, o si la implementación es

hecha en un programa compilado en código de máquina nativo en vez de una
implementación interpretada en una máquina virtual. Sin embargo, a pesar
de las posibles variaciones que se dan por factores ambientales diferentes, se
intenta enfocarse en la relación entre el tiempo de ejecución de un algoritmo
y el tamaño de su entrada.
Se está interesado en caracterizar el tiempo de ejecución del algoritmo
como una función del tamaño de la entrada, para lo cual se requiere saber de
una forma apropiada de medirla.
4.2.1. Estudios experimentales

Si un algoritmo ha sido implementado, se puede estudiar su tiempo de
ejecución usando varias pruebas de entrada y guardando el tiempo usado
en cada ejecución. Para hacer estas mediciones de forma precisa se pueden
hacer llamadas al sistema que están construidas en el lenguaje, o en el sistema
operativo, por ejemplo, usando el método System.currentTimeMillis().
Tales pruebas asignan un tiempo de ejecución especı́fico a una entrada de
tamaño especı́fico, pero se está interesado en determinar la dependencia
general del tiempo de ejecución de acuerdo al tamaño de la entrada, para
lo cual se deben hacer varios experimentos con muchas entradas de prueba
diferentes de varios tamaños. Entonces se pueden visualizar los resultados de
tales experimentos graficando el rendimiento de cada ejecución del algoritmo
como un punto con coordenada x igual al tamaño de la entrada, n, y la
coordenada y igual al tiempo de ejecución, t, como se hace en la figura 4.3. De
la gráfica y de los datos que lo soportan, se puede hacer un análisis estadı́stico
que encuentre la mejor función que represente el tamaño de entrada a los
datos experimentales. Para que sea útil, este análisis requiere que se escojan
entradas de muestra buenas y se prueben lo suficiente para hacer que tenga
sentido lo indicado por la estadı́stica acerca del tiempo de ejecución del
algoritmo.
Las limitaciones que tienen los estudios experimentales son:
Los experimentos sólo pueden hacerse en un conjunto limitado de

pruebas de entrada, por lo que quedarán entradas no incluidas que
podrı́an ser importantes.
Es difı́cil comparar los tiempos experimentales de ejecución de dos

Figura 4.3: Resultados de un estudio experimental del tiempo de ejecución de un

algoritmo.
algoritmos a menos que los experimentos sean hechos en el mismo

hardware y software.
Se tiene que implementar de forma completa y ejecutar un algoritmo

para poder estudiar sus tiempos de ejecución experimentalmente.
El último requerimiento es probablemente el que más tiempo consume,
aunque también las otras limitaciones también imponen obstáculos serios. Por
lo tanto, idealmente se quiere tener una herramienta de análisis que nos evite
realizar experimentos.
Se desarrolla una forma general de analizar los tiempos de ejecución de
algoritmos que:
Toma en cuenta todas las posibles entradas.
Permite evaluar la eficiencia relativa de cualesquiera dos algoritmos

en una forma que es indenpendiente del ambiente del hardware y el
software.
Puede ser realizado estudiando una descripción de alto nivel del algorit-
mo sin tenerlo que implementar o ejecutar experimentos en este.
Esta metodologı́a permite asociar, con cada algoritmo, una función f (n)
que caracteriza el tiempo de ejecución del algoritmo como una función del
tamaño de entrada n. Las funciones tı́picas que serán encontradas incluyen

las siete funciones mencionadas al inicio del capı́tulo.
4.2.2. Operaciones primitivas

Como se mencionó previamente, los análisis experimentales son valiosos,
pero tienen sus limitaciones. Si se desea analizar un algoritmo particular
sin realizar experimentos en su tiempo de ejecución, se puede realizar un
análisis directo de alto nivel en el pseudo-código. Se define un conjunto de
operaciones primitivas tales como las siguientes:
Asignar un valor a una variable.
Llamar un método.
Realizar una operación aritmética.
Comparar dos números.
Indexar en un arreglo.
Seguir la referencia a un objeto.
Regresar desde un método.
Conteo de operaciones primitivas

Una operación primitiva corresponde a una instrucción de bajo nivel con
un tiempo de ejecución que es constante. Se cuentan cuantas operaciones
primitivas son ejecutadas, y se usa este número t como una medida del tiempo
de ejecución del algoritmo.
El conteo de las operaciones está correlacionado a un tiempo de ejecu-
ción actual en una computadora particular, para cada operación primitiva
corresponde a una instrucción constante en el tiempo, y sólo hay número
fijo de operaciones primitivas. El número, t, de operaciones primitivas que
un algoritmo realiza será proporcional al tiempo de ejecución actual de ese
algoritmo.
Un algoritmo podrı́a ejecutarse más rápido con algunas entradas que con
otras del mismo tamaño. Por lo tanto, se podrı́a desear expresar el tiempo
de ejecución de un algoritmo como la función del tamaño de la entrada
obtenida de tomar el promedio de todas las posibles entradas del mismo

tamaño. Desafortunadamente, el análisis promedio suele ser muy difı́cil,
ya que requiere definir una distribución de probabilidad sobre el conjunto de
entradas, lo cual es una tarea difı́cil. La figura 4.4 muestra como, dependiendo
de la distribución de la entrada, el tiempo de ejecución de un algoritmo puede
estar en cualquier lugar entre el tiempo peor caso y el tiempo mejor caso. Por
ejemplo, ¿qué tal si las entradas son sólo de los tipos A y D?
Figura 4.4: Gráfica del tiempo de ejecución de algún algoritmo mostrando la

diferencia entre el tiempo peor caso y mejor caso.
Enfoque en el peor caso

Un análisis en caso promedio usualmente requiere que se calcule los tiempos
esperados de ejecución basados en una distribución de entrada dada, la cual
requiere generalmente teorı́a de probabilidad sofisticada. Por lo tanto, en este
documento, a menos que se indique lo contrario, se caracterizarán los tiempos
de ejecución en términos del peor caso, como una función del tamaño de la
entrada, n, del algoritmo.
El análisis del peor caso es más fácil que el caso promedio, ya que sólo
requiere la habilidad de identificar el peor caso de entrada, el cual es frecuen-
temente simple. Con esta aproximación también se llega a mejores algoritmos,
ya que logrando que el algoritmo se comporte bien para el peor caso, entonces
también lo hara para cualquier entrada.
4.2.3. Notación asintótica
En general, cada paso básico en una descripción en pseudo-código o en una

implementación de lenguaje de alto nivel corresponde a un número pequeño
de operaciones primitivas, excepto por las llamadas a métodos. Por lo tanto
se puede hacer un análisis simple de un algoritmo que estime el número de
operaciones primitivas ejecutadas hasta un factor constante, por lo pasos en el
pseudo-código. Se debe ser cuidadoso, ya que una sóla lı́nea de pseudo-código
podrı́a comprender una cantidad de pasos en ciertos casos.
En el análisis de algoritmos se enfoca en la relación de crecimiento del
tiempo de ejecución como una función del tamaño de la entrada n, tomando
una aproximación o una “foto panorámica”. Es en ocasiones suficiente con
saber que el tiempo de ejecución de un algoritmo, tal como maxArreglo
mostrado enseguida, crece proporcionalmente a n, siendo n veces un factor
constante que depende de la computadora, que su verdadero tiempo de
ejecución
Algoritmo maxArreglo(A, n):
Entrada: Un arreglo A con n ≥ 1 enteros.
Salida: El elemento máximo en A.
maxAct ← A[0]
si maxAct < A[i] entonces
maxAct ← A[i]
regresar maxAct
Se analizan los algoritmos usando una notación matemática para funciones

que no tiene en cuenta los factores constantes. Se caracterizan los tiempos
de ejecución de los algoritmos usando funciones que mapean el tamaño de
la entrada, n, a valores que corresponden al factor principal que determina
la relación de crecimiento en términos de n. Esta aproximación permite
enfocarse en los aspectos de la “foto panorámica” del tiempo de ejecución de
un algoritmo.
La notación “O-grande”
Sean f (n) y g(n) funciones que mapean enteros no negativos a números
reales. Se dice que f (n) es O(g(n)) si hay una constante c > 0 y una constante
entera n0 ≥ 1 tal que
f (n) ≤ cg(n), para n ≥ n0 .

Esta definición es frecuentemente referida como la notación “O-grande”,
por eso en ocasiones se dice “f (n) es O-grande de g(n)”. Alternativamente,
se puede también decir “f (n) es orden de g(n)”. La definición se ilustra en la
figura 4.5
Figura 4.5: Ilustración de la notación “O-grande”. f (n) es O(g(n)) pues f (n) ≤

c · g(n) cuando n ≥ n0 .
Ejemplo 4.1. La función 8n − 2 es O(n)

Justificación. Por la definición de O-grande, se necesita encontrar una
constante real c > 0 y una constante entera n0 ≥ 1 tal que 8n − 2 ≤ cn para
cada entero n ≥ n0 . Una posible opción es c = 8 y n0 = 1 de la infinidad
de opciones disponibles, ya que cualquier número real mayor que o igual a 8
funciona para c, y cualquier entero mayor que o igual a 1 trabajará para n0 .
La notación O-grande permite decir que una función f (n) es “menor que, o
igual a” otra función g(n) hasta un factor constante y en el sentido asintótico
conforme n tiene a infinito. Esto se debe al hecho de que la definición usa “≤”
para comparar f (n) con g(n) veces una constante, c, para los casos asintóticos
cuando n ≥ n0 .
Caracterización de tiempos de ejecución con O-grande

La notación O-grande es usada ampliamente para caracterizar los tiempos
de ejecución y el espacio requerido en términos de algún parámetro n, el
cual cambia de problema a problema, pero es siempre definido como una
medida escogida del “tamaño” del problema. Por ejemplo, si se está interesado
en encontrar el elemento más grande en un arreglo de enteros, como en el
algoritmo maxArreglo, n deberá denotar la cantidad de elementos en el
arreglo. Con la notación O-grande, se puede decir la siguiente proposición
matemáticamente precisa del tiempo de ejecución del algoritmo maxArreglo
para cualquier computadora.
Proposición 4.5: El algoritmo maxArreglo, para calcular el elemento
máximo en un arreglo de n enteros, corre en tiempo O(n).
Justificación. La cantidad de operaciones primitivas ejecutadas por el algo-
ritmo maxArreglo en cada iteración es una constante. Por lo tanto, como
cada operación primitiva se ejecuta en tiempo constante, se puede decir que
el tiempo de ejecución del algoritmo maxArreglo para una entrada de
tamaño n es a lo más una constante por n, esto es, se podrı́a concluir que el
tiempo de ejecución del algoritmo maxArreglo es O(n).
Algunas propiedades de la notación O-grande

La notación O-grande permite ignorar los factores constantes y los términos
de orden menor y enfocarse en los componentes principales de una función
que afectan su crecimiento.
Ejemplo 4.2. 5n4 + 3n3 + 2n2 + 4n + 1 es O(n4 )
Justificación: Observar que 5n4 +3n3 +2n2 +4n+1 ≤ (5+3+2+4+1)n4 = cn4 ,
para c = 15, cuando n ≥ n0 = 1
Se puede caracterizar la relación de crecimiento de cualquier función
polinomial.
Proposición 4.6: Si f (n) es un polinomio de grado n, esto es
f (n) = a0 + a1 n + · · · ad nd ,
y ad > 0, entonces f (n) es O(nd ).
Justificación: observar que, para n ≥ 1, se tiene 1 ≤ n ≤ n2 ≤ · · · ≤ nd por
lo tanto
a0 + a1 n + · · · + ad nd ≤ (a0 + a1 + · · · + ad )nd .
Ası́, se puede mostrar que f (n) es O(nd ) definiendo c = a0 + a1 + · · · + ad y

n0 = 1.
Ası́, el término de mayor grado en una función polinomial es el término
que determina la razón de crecimiento asintótico del polinomio. Se muestran a
continuación ejemplos adicionales, en donde se combinan las funciones vistas
al inicio del capı́tulo.
Ejemplo 4.3. 5n2 + 3n log n + 2n + 5 es O(n2 ).
Justificación: 5n2 + 3n log n + 2n + 5 ≤ (5 + 3 + 2 + 5)n2 = cn2 , para c =
15 cuando n ≥ n0 = 2. Observar que n log n es cero para n = 1.
Ejemplo 4.4. 20n3 + 10n log n + 5 es O(n3 ).
Justificación: 20n3 + 10n log n + 5 ≤ 35n3 , para n ≥ 1.
Ejemplo 4.5. 3 log n + 2 es O(log n).
Justificación: 3 log n + 2 ≤ 5 log n, para n ≥ 2. La razón por la que se usa
n ≥ 2 = n0 es porque log n es cero para n = 1.
Ejemplo 4.6. 2n+2 es O(2n ).
Justificación: 2n+2 = 2n 22 = 4 · 2n ; por lo tanto, se puede tomar c = 4 y
n0 = 1 en este caso.
Ejemplo 4.7. 2n + 100 log n es O(n).
Justificación: 2n + 100 log n ≤ 102n para n ≥ 2 = n0 ; por lo tanto, se puede
tomar a c = 102 en este caso.
Caracterización de funciones en términos más simples
Se podrı́a usar la notación O-grande para caracterizar una función tan

cercana como sea posible. Para la función f (n) = 4n3 + 3n2 es cierto que es
O(n5 ) o aún O(n4 ), pero es más preciso decir que f (n) es O(n3 ). También
se considera de mal gusto incluir factores constantes y términos de orden
inferior en la notación O-grande. No está de moda decir que la función 2n2
es O(4n2 + 6n log n), sin embargo esto es completamente correcto. Se debe
intentar describir la función en O-grande en los términos más simples.
Las funciones descritas en la sección 4 son las funciones más comunes
usadas en conjunción con la notación O-grande para caracterizar los tiempos
de ejecución y el espacio usado de los algoritmos. Además, se usan los nombres
de estas funciones para referirse a los tiempos de ejecución de los algoritmos
que están caracterizando. Por ejemplo, se podrı́a decir que un algoritmo que
se ejecuta con tiempo 4n2 + n log n en el peor caso como un algoritmo tiempo
cuadrático, ya que corre en tiempo O(n2 ). De igual forma, un algoritmo
ejecutándose en tiempo a lo más 5n + 20 log n + 4 podrı́a ser llamado un

algoritmo lineal.
Ω-grande
La notación O-grande proporciona una forma asintótica de decir que una
función es “menor que o igual a” otra función, la siguiente notación da una
forma asintótica para indicar que una función crece a un ritmo que es “mayor
que o igual a” otra función.
Sean f (n) y g(n) funciones que mapean enteros no negativos a números
reales. Se dice que f (n) es Ω(g(n)) (pronunciada “f(n) es notación Omega-
grande de g(n)”) si g(n) es O(f (n)), esto es, existe una constante real c > 0
y una constante entera n0 ≥ 1 tal que
f (n) ≥ cg(n), para n ≥ n0 .
Esta definición permite decir asintóticamente que una función es mayor

que o igual a otra, hasta un factor constante.
Ejemplo 4.8. La función 3n log n + 2n es Ω(n log n)
Justificación. 3n log n + 2n ≥ 3n log n, para n ≥ 2.
Θ (Teta-grande)
Además, hay una notación que permite decir que dos funciones crecen a la
misma velocidad, hasta unos factores constantes. Se dice que f (n) es Θ(g(n))
(pronunciado “f (n) es Tetha-grande de g(n)”) si f (n) es O(g(n)) y f (n) es
Ω(g(n)), esto es, existen constantes reales c0 > 0 y c00 > 0, y una constante
entera n0 ≥ 1 tal que
c0 g(n) ≤ f (n) ≤ c00 g(n), para n ≥ n0 .
Ejemplo 4.9. 3n log n + 4n + 5 log n es Θ(n log n)

Justificación. 3n log n ≤ 3n log n + 4n + 5 log n ≤ (3 + 4 + 5)n log n para
n ≥ 2.
4.2.4. Análisis asintótico

Suponiendo dos algoritmos que resuelven el mismo problema: un algoritmo
A, el cual tiene tiempo de ejecuión O(n), y un algoritmo B, con tiempo de
ejecución O(n2 ). Se desea sabe cuál algoritmo es mejor. Se sabe que B es

O(n2 ), lo cual implica que el algoritmo A es asintóticamente mejor que el
algoritmo B, sin embargo para un valor pequeño de n, B podrı́a tener un
tiempo de ejecución menor que A.
Se puede emplear la notación O-grande para ordenar clases de funciones
por su velocidad de crecimiento asintótico. Las siete funciones son ordenadas
por su velocidad de crecimiento incremental en la siguiente secuencia, esto es,
si una función f (n) precede a una función g(n) en la secuencia, entonces f (n)
es O(g(n)):
1 log n n n log n n2 n3 2n
Se muestra enseguida la tasa de crecimiento de algunas funciones impor-

tantes a continuación:
n log n n n log n n2 n3 2n
2 1 2 2 4 8 4
4 2 4 8 16 64 16
8 3 8 24 64 512 256
16 4 16 64 256 4,096 65,536
32 5 32 160 1,024 32,768 4,294,967,296
64 6 64 384 4,096 262,144 1.84 × 1019
128 7 128 896 16,384 2,097,152 3.40 × 1038
256 8 256 2,048 65,536 16,777,216 1.15 × 1077
512 9 512 4,608 262,144 134,217,728 1.34 × 10154
La siguiente tabla explora el tamaño máximo permitido para una instancia

de entrada que es procesada por un algoritmo en 1 segundo, 1 minuto, y 1
hora. Se muestra la importancia del diseño de un buen algoritmo, porque un
algoritmo lento asintóticamente es derrotado en una ejecución grande por
un algoritmo más rápido asintóticamente, aún si el factor constante para el
algoritmo más rápido es malo.
Tiempo Tamaño máximo del problema (n)

Ejecución (µs) 1 segundo 1 minuto 1 hora
400n 2,500 150,000 9,000,000
2n2 707 5,477 42,426
2n 19 25 31
La importancia del diseño de un buen algoritmo va más allá de que puede

ser resuelto eficientemente en una computadora dada. Como se muestra en
la siguiente tabla aún si se logra una aceleración dramática en el hardware,
todavı́a no se puede superar la desventaja de un algoritmo asintóticamente
lento. La tabla muestra el tamaño máximo del nuevo problema que se calcula
para una cantidad fija de tiempo, suponiendo que los algoritmos con los
tiempos de ejecución dados son ejecutados ahora en una computadora 256
veces más rápida que la previa.
Tiempo de ejecución Tamaño máximo del nuevo problema

400n 256m
2n2 16m
n
2 m+8
4.2.5. Uso de la notación O-grande

Se considera un abuso de la notación decir “f (n) ≤ O(g(n))”, ya que
la notación O-grande ya denota el concepto “menor que o igual a”. De
igual forma no es correcto completamente decir “f (n) = O(g(n)), porque no
hay forma de que haga sentido la sentencia “O(g(n)) = f (n)”. Además, es
completamente incorrecto decir “f (n) ≥ O(g(n))” o “f (n) > O(g(n))”, ya
que g(n) en la notación O-grande indica una cota superior de f (n). Es mejor
decir,
f (n)esO(g(n)).
Una expresión más matemática para lo anterior es,
f (n) ∈ O(g(n)),
ya que la notación O-grande está indicando una colección completa de
funciones.
Advertencia
El uso de la O-grande y las notaciones relacionadas puede ser engañoso
debido a que los factores constantes que “ocultan” pueden ser muy grandes.
Por ejemplo, es cierto que la función 10100 n es O(n), si este es el tiempo de
ejecución de un algoritmo siendo comparado con otro cuyo tiempo de ejecución
es 10n log n, se podrı́a preferir el algoritmo de tiempo O(n log n), a pesar de
que el algoritmo lineal es asintóticamente más rápido. La decisión es por el
factor constante, 10100 , “un googol”, considerado por muchos astrónomos
como una cota superior de la cantidad de átomos en el universo observable.
Serı́a improbable tener un problema del mundo real que tenga esa cantidad
como tamaño de entrada. Por lo tanto, incluso cuando se usa la notación
O-grande, se debe ser consciente de los factores constantes y los términos de
orden inferior que se están “ocultando”.
En general, cualquier algoritmo ejecutándose en tiempo O(n log n), con
un factor constante razonable, deberá ser considerado eficiente. Un método
con tiempo O(n2 ) podrı́a ser lo suficente rápido en algunos casos, por ejemplo,
cuando n es pequeño. Pero un algoritmo ejecutándose en tiempo O(2n ) casi
nunca deberı́a ser considerado eficiente.
Tiempos de ejecución exponencial

Si se deben separar los algoritmos eficientes de los ineficientes, se deberı́an
distinguir entre los algoritmos que se ejecutan en tiempo polinomial y los de
tiempo exponencial. Esto es, hacer la distinción entre los algoritmos con un
tiempo de ejecución O(nc ), para alguna constante c > 1, y aquellos con un
tiempo de ejecución O(bn ), para alguna constante b > 1. Podrı́a existir “un
prietito en el arroz” como un algoritmo ejecutándose en O(n100 ) no deberı́a ser
considerado como eficiente. Aún ası́, la distinción entre algoritmos de tiempo
polinomial y exponencial es considerado una medida robusta de tratabilidad.
Las notaciones asintóticas de O-grande, Omega-grande, y Teta-grande
dan un lenguaje conveniente para analizar estructuras de datos y algoritmos,
ya que permiten concentrarse en la foto grande en vez de los detalles de bajo
nivel.
Análisis asintótico para promedios de prefijos

Se analizan dos algoritmos que resuelven el mismo problema pero teniendo
diferentes tiempos de ejecución. El problema es el cálculo de promedios de
prefijos de una secuencia de números. Es decir, dado un arreglo X con n
números, se quiere calcular un arreglo A tal que A[i] es el promedio de los
elementos X[0], . . . , X[i], para i = 0, . . . , n − 1, esto es,
Pi
j=0 X[j]
A[i] = .
i+1
El cálculo de promedios de prefijos tiene varias aplicaciones en economı́a

y estadı́stica.
Un algoritmo de tiempo cuadrático

Para el problema de promedios de prefijos, se muestra enseguida el algorit-
mo promediosPrefijo1, el cual calcual cada elemento de A separadamente,
de acuerdo a la definición.
Algoritmo promediosPrefijo1(X):
Entrada: un arreglo X con n-elementos de números.
Salida: un arreglo A con n-elementos de números
tal que A[i] es el promedio de X[0], . . . , X[i].
Sea A un arreglo de n números.
a←0
para j ← 0 hasta i hacer
a ← a + X[j]
A[i] ← a/(i + 1)
regresar arreglo A
El análisis del algoritmo promediosPrefijo1 es el siguiente:
Inicializar el arreglo A al inicio y devolver el arreglo al final puede

ser hecho con una cantidad constante de operaciones primitivas por
elemento, y toma tiempo O(n).
Para los dos ciclos anidados para, el cuerpo del ciclo externo, controlado
por el contador i, es ejecutado n veces para i = 0, . . . , n − 1. Por lo
que sentencias como a ← 0 y A[i] ← a/(i + 1) son ejecutadas n veces
cada una. Estas dos sentencias, además del incremento y la prueba
del contador i, contribuyen una cantidad de operaciones primitivas
proporcional a n, o sea, tiempo O(n).
El cuerpo del ciclo interno, controlado por el contador j, se ejecuta

i + 1 veces, es decir, depende del valor actual del contador i del ciclo
externo. De este modo, la sentencia a ← a + X[j] en el ciclo interno es
ejecutada 1 + 2 + 3 + · · · + n = n(n + 1)/2 veces, ası́ que la sentencia en el
ciclo interno contribuye con tiempo O(n2 ). De igual manera sucede con
el incremento y la prueba del contador j, que también tienen tiempo
O(n2 ).
El tiempo de ejecución de promediosPrefijo1 está dado por la suma de

los tres términos. Los primeros dos términos son O(n), y el tercero es O(n2 ).
Usando la proposición 4.6, el tiempo de ejecución es O(n2 ).
Un algoritmo de tiempo lineal

Para calcular los promedios de prefijos de forma más eficiente, se puede
observar que dos promedios consecutivos A[i − 1] y A[i] son similares:
A[i − 1] = (X[0] + X[1] + · · · + X[i − 1])/i

A[i] = (X[0] + X[1] + · · · + X[i])/(i + 1)
Si se denota con Si la suma prefijo X[0] + X[1] + · · · + X[i], el cálculo

de los promedios prefijo es A[i] = Si /(i + 1). Es fácil llevar la suma prefijo
actual cuando se recorre el arreglo X con un ciclo. El siguiente algoritmo
promediosPrefijo2 usa la suma prefijo.
Algoritmo promediosPrefijo2(X):
Entrada: un arreglo X con n-elementos de números.
Salida: un arreglo A con n-elementos de números
tal que A[i] es el promedio de X[0], . . . , X[i].
Sea A un arreglo de n números.
s←0
s ← s + X[i]
A[i] ← s/(i + 1)
regresar arreglo A
El análisis del tiempo de ejecución del algoritmo promediosPrefijo2 es
el siguiente:
Inicializar el arreglo A al inicio y devolver el arreglo al final puede

ser hecho con una cantidad constante de operaciones primitivas por
elemento, y toma tiempo O(n).
Inicializar la variable s al inicio toma tiempo O(1).
Hay un sólo ciclo para, controlado por el contador i. El cuerpo del

ciclo es ejecutado n veces, para i = 0, . . . , n − 1. Ası́ las sentencias
s ← s + X[i] y A[i] ← s/(i + 1) son ejecutadas n veces cada uno.

Además de las operaciones anteriores, las de incremento y prueba del
contador i también contribuyen una cantidad de operaciones primitivas
proporcional a n, es decir, tiempo O(n).
El tiempo de ejecución del algoritmo promediosPrefijo2 está dado por

la suma de los tres términos. El primer término y el último son O(n), y el
segundo es O(1). Usando la proposición 4.6, el tiempo de ejecución es O(n),
el cual es mucho mejor que el tiempo cuadrático de promediosPrefijo1.
4.2.6. Algoritmo recursivo para calcular potencias

Se revisa un ejemplo más interesante de análisis de algoritmos, que es
el elevar un número x a un entero no negativo arbitrario, n. Es decir, se
quiere calcular la función potencia p(x, n), definida como p(x, n) = xn .
Esta función tiene una definición recursiva basada en recursión lineal:

1 si n = 0
p(x, n) =
x · p(x, n − 1) de otra forma.
Esta definición da un algoritmo recursivo que usa O(n) llamadas al método
para calcular p(x, n). Se puede calcular la función potencia más rápido usando
la siguiente definición alterna, también basada en recursión lineal, la cual
emplea una técnica de cuadrado:

 1 si n = 0
2
p(x, n) = x · p(x, (n − 1)/2) si n > 0 es impar
p(x, n/2)2 si n > 0 es par.

Para mostrar como esta definición trabaja, se dan los siguientes ejemplos:
2
24 = 2(4/2) = (24/2 )2 = (22 )2 = 42 = 16
2
25 = 21+(4/2) = 2(24/2 )2 = 2(22 )2 = 2(42 ) = 32
2
26 = 2(6/2) = (26/2 )2 = (23 )2 = 82 = 64
2
27 = 21+(6/2) = 2(26/2 )2 = 2(23 )2 = 2(82 ) = 128
De la última definción se puede obtener el siguiente algoritmo Potencia:

Algoritmo Potencia(x, n):

Entrada: un número x y un entero n ≥ 0.
Salida: el valor xn .
si n = 0 entonces
regresar 1
si n es impar entonces
y ← Potencia(x, (n − 1)/2)
regresar x · y · y
sino
y ← Potencia(x, n/2)
regresar y · y
Para analizar el tiempo de ejecución del algoritmo, se observa que en cada
llamada recursiva al método Potencia(x, n) se divide el exponente, n, por dos.
Ası́, hay O(log n) llamadas recursivas. Entonces, usando la recursión lineal y
la técnica del cuadrado, se reduce el tiempo de ejecución para el cálculo de la
función potencia de O(n) a O(log n).
Capı́tulo 5
Pilas y colas
5.1. Pilas
Una pila (stack ) es una colección de objetos que son insertados y removidos
de acuerdo al principio último en entrar, primero en salir, LIFO (last-in
first-out). Los objetos pueden ser insertados en una pila en cualquier momento,
pero solamente el más reciente insertado, es decir, el “último” objeto puede ser
removido en cualquier momento. Una analogı́a de la pila es el dispensador de
platos que se encuentra en el mobiliario de alguna cafeterı́a o cocina. Para este
caso, las operaciones fundamentales involucran push (empujar) platos y pop
(sacar) platos de la pila. Cuando se necesita un nuevo plato del dispensador,
se saca el plato que está encima de la pila, y cuando se agrega un plato, se
empuja este hacia abajo en la pila para que se convierta en el nuevo plato de
la cima. Otro ejemplo son los navegadores Web de internet que guardan las
direcciones de los sitios recientemente visitados en una pila. Cada vez que un
usuario visita un nuevo sitio, esa dirección del sitio es empujada en la pila de
direcciones. El navegador, mediante el botón Volver atrás, permite al usuario
sacar los sitios previamente visitados.
5.1.1. El tipo de dato abstracto pila

Las pilas son las estructuras de datos más simples, pero también están
entre las más importantes, porque se usan en una gran cantidad de aplica-
ciones diferentes que incluyen varias estructuras de datos más sofisticadas.
Formalmente, una pila es un tipo de dato abstracto que soporta los siguientes
dos métodos:
166 Pilas y colas
push(e):inserta el elemento e, para que sea la cima de la

pila.
pop():quita el elemento de la cima de la pila y lo regresa;
un error ocurre si la pila está vacı́a.
Adicionalmente, también se podrı́an definir los siguientes métodos:
size():regresa el número de elementos en la pila.
isEmpty():regresa un booleano indicando si la pila está vacı́a.
top():regresa el elemento de la cima de la pila, sin remo-
verlo; un error ocurre si la pila está vacı́a.
La siguiente tabla muestra una serie de operaciones en la pila y su efecto
en una pila de enteros inicialmente vacı́a, observar que los elementos son
metidos y sacados por el mismo lado, el lado derecho.
Operación Salida Contenido
push(5) – (5)
push(3) – (5,3)
pop() 3 (5)
push(7) – (5,7)
pop() 7 (5)
top() 5 (5)
pop() 5 ()
pop() “error” ()
isEmpty() true ()
push(9) – (9)
push(7) – (9,7)
push(3) – (9,7,3)
push(5) – (9,7,3,5)
size() 4 (9,7,3,5)
pop() 5 (9,7,3)
push(8) – (9,7,3,8)
pop() 8 (9,7,3)
pop() 3 (9,7)
Una interfaz pila en Java

Debido a su importancia, la estructura de datos pila está incluida co-
mo una clase en el paquete java.util. La clase java.util.Stack es una
5.1 Pilas 167
estructura que guarda objetos genéricos Java e incluye, entre otros, los
métodos push(), pop(), peek() (equivalente a top()), size(), y empty()
(equivalente a isEmpty()). Los métodos pop() y peek() lanzan la excep-
ción EmptyStackException del paquete java.util si son llamados con pilas
vacı́as. Mientras sea conveniente sólo usar la clase incorporada java.util.-
Stack, es instructivo aprender como diseñar e implementar una pila “desde
cero”.
Implementar un tipo de dato abstracto en Java involucra dos pasos. El
primer paso es la definición de una interfaz de programación de aplica-
ciones o API, o interfaz, la cual describe los nombres de los métodos que
la estructura abstracta de datos soporta y como tienen que ser declarados y
usados.
Además, se deben definir excepciones para cualquier condición de error
que pueda originarse. Por ejemplo, la condición de error que ocurre cuando se
llama al método pop() o top() en una cola vacı́a es señalado lanzando una
excepción de tipo EmptyStackException, la cual está definida en el listado
5.1
1 /* *
2 * Excepci ó n Runtime lanzada cuando se intenta hacer una operaci ó n
3 * top o pop con una cola vac ı́ a .
4 */
5 public class E m p t y S t a c k E x c e p t i o n extends R u n t i m e E x c e p t io n {
6 public E m p t y S t a c k E x c e p t i o n ( String err ) {
7 super ( err );
8 }
9 }
Listado 5.1: Excepción lanzada por los métodos pop() y top() de la interfaz pila
cuando son llamados con una pila vacı́a.
Una interfaz completa para el ADT pila está dado en el listado 5.2. Esta
interfaz es muy general ya que especifica que elementos de cualquier clase dada,
y sus subclases, pueden ser insertados en la pila. Se obtiene esta generalidad
mediante el concepto de genéricos (sección 2.5.2).
Para que un ADT dado sea para cualquier uso, se necesita dar una clase
concreta que implemente los métodos de la interfaz asociada con ese ADT. Se
da una implementación simple de la interfaz Stack en la siguiente subsección.
168 Pilas y colas
1 /* *
2 * Interfaz para una pila : una colecci ó n de objetos que son insertados
3 * y removidos de acuerdo al principio ú ltimo en entrar , primero en salir .
4 * Esta interfaz incluye los m é todos principales de java . util . Stack .
5 *
6 * @see E m p t y S t a c k E x c e p t i o n
7 */
8 public interface Stack <E > {
9 /* *
10 * Regresa el n ú mero de elementos en la pila .
11 * @return n ú mero de elementos en la pila .
12 */
13 public int size ();
14 /* *
15 * Indica si la pila est á vacia .
16 * @return true si la pila est á vac ı́a , de otra manera false .
17 */
18 public boolean isEmpty ();
19 /* *
20 * Explorar el elemento en la cima de la pila .
21 * @return el elemento cima en la pila .
22 * @exception E m p t y S t a c k E x c e p t i o n si la pila est á vac ı́ a .
23 */
24 public E top ()
25 throws E m p t y S t a c k E x c e p t i o n ;
26 /* *
27 * Insertar un elemento en la cima de la pila .
28 * @param elemento a ser insertado .
29 */
30 public void push ( E elemento );
31 /* *
32 * Quitar el elemento de la cima de la pila .
33 * @return elemento removido .
34 * @exception E m p t y S t a c k E x c e p t i o n si la pila est á vac ı́ a .
35 */
36 public E pop ()
37 throws E m p t y S t a c k E x c e p t i o n ;
38 }
Listado 5.2: Interfaz Stack con documentación en estilo Javadoc. Se usa el tipo
parametrizado genérico, E, para que la pila pueda contener elementos de cualquier
clase.
5.1.2. Implementación de una pila usando un arreglo

Se puede implementar una pila guardando sus elementos en un arreglo. La
pila en esta implementación consiste de una arreglo S de n elementos además
de una variable entera t que da el ı́ndice del elemento de la cima en el arreglo
S.
En Java el ı́ndice para los arreglos inicia con cero, por lo que t se inicializa
5.1 Pilas 169
Figura 5.1: Implementación de una pila con un arreglo S. El elemento de la cima

está guardado en la celda S[t].
con -1, y se usa este valor de t para identificar una pila vacı́a. Asimismo,
se pueda usar t para determinar el número de elementos (t+1). Se agrega
también una nueva excepción, llamada FullStackException, para señalar
el error que surge si se intenta insertar un nuevo elemento en una pila llena.
La excepción FullStackException es particular a esta implementación y no
está definida en la ADT pila. Se dan los detalles de la implementación de la
pila usando un arreglo en los siguientes algoritmos.
Algoritmo size():
regresar t + 1
Algoritmo isEmpty():
regresar (t < 0)
Algoritmo top():
si isEmpty() entonces
lanzar una EmptyStackException
regresar S[t]
Algoritmo push(e):
si size()= N entonces
lanzar una FullStackException
t←t+1
S[t] ← e
Algoritmo pop():
lanzar una EmptyStackException
e ← S[t]
S[t] ← null
t←t−1
regresar e
170 Pilas y colas
Análisis de la implementación de pila con arreglos
La correctez de los métodos en la implementación usando arreglos se tiene

inmediatamente de la definición de los propios métodos. Hay, sin embargo, un
punto medio interesante que involucra la implementación del método pop().
Se podrı́a haber evitado reiniciar el viejo S[t] a null y se podrı́a tener
todavı́a un método correcto. Sin embargo, hay una ventaja y desventaja en
evitar esta asignación que podrı́a pensarse al implementar los algoritmos en
Java. El equilibrio involucra el mecanismo colector de basura de Java que
busca en la memoria objetos que ya no son referenciados por objetos activos,
y recupera este espacio para su uso futuro. Sea e = S[t] el elemento de la
cima antes de que el método pop() sea llamado. Haciendo que S[t] tenga una
referencia nula, se indica que la pila no necesita mantener más una referencia
al objeto e. Además, si no hay otras referencias activas a e, entonces el espacio
de memoria usado por e será reclamado por el colector de basura.
En la siguiente tabla se muestran los tiempos de ejecución para los métodos
en la ejecución de una pila con un arreglo. Cada uno de los métodos de la pila en
el arreglo ejecuta un número constante de sentencias involucrando operaciones
aritméticas, comparaciones, y asignaciones. Además, pop() también llama
a isEmpty(), el cual también se ejecuta en tiempo constante. Por lo tanto,
en esta implementación del ADT pila, cada método se ejecuta en tiempo
constante, esto es, cada uno corre en tiempo O(1).
Método Tiempo
size O(1)
isEmpty O(1)
top O(1)
push O(1)
pop O(1)
La clase ArregloStack, listado 5.3, implementa la interfaz Stack. Se usa

el nombre simbólico, CAPACIDAD, para indicar el tamaño del arreglo. Este
valor permite indicar la capacidad del arreglo en un sólo lugar y que se visto
en todo el código.
5.1 Pilas 171
1 /* *
2 * Implementaci ó n de la ADT pila usando un arreglo de longitud fija .
3 * Una excepci ó n es lanzada si la operaci ó n push es intentada cuando
4 * el tama n ~ o de la pila es igual a la longitud del arreglo . Esta
5 * clase incluye los m é todos principales de la clase agregada
6 * java . util . Stack .
7 *
8 */
9 public class ArregloStack <E > implements Stack <E > {
10 protected int capacidad ; // capacidad actual del arreglo del stack
11 public static final int CAPACIDAD = 1000; // capacidad por defecto
12 protected E [] S ; // arreglo ègenrico usado para implementar el stack
13 protected int t = -1; // ı́ ndice para la cima del stack
14 public ArregloStack () {
15 this ( CAPACIDAD ); // capacidad por defecto
16 }
17 public ArregloStack ( int cap ) {
18 capacidad = cap ;
19 S = ( E []) new Object [ capacidad ]; // el compilador podr ı́ a dar advertencia
20 // pero est á bien
21 }
22 public int size () {
23 return ( t + 1);
24 }
25 public boolean isEmpty () {
26 return ( t < 0);
27 }
28 public void push ( E elemento ) throws F u l l S t a c k E x c e p t i o n {
29 if ( size () == capacidad )
30 throw new F u l l S t a c k E x c e p t i on ( " La pila est á llena . " );
31 S [++ t ] = elemento ;
32 }
33 public E top () throws E m p t y S t a c k E x c e p t i o n {
34 if ( isEmpty ())
35 throw new E m p t y S t a c k E x c e p t i o n ( " La pila est á vac ı́ a . " );
36 return S [ t ];
37 }
38 public E pop () throws E m p t y S t a c k E x c e p t i o n {
39 if ( isEmpty ())
40 throw new E m p t y S t a c k E x c e p t i o n ( " La pila est á vac ı́ a . " );
41 E elemento = S [ t ];
42 S [t - -] = null ; // des referenciar S [ t ] para el colector de basura .
43 return elemento ;
44 }
46 String s = " [ " ;
47 if ( size () > 0) s += S [0];
48 for ( int i = 1; i <= size () -1; i ++)
49 s += " , " + S [ i ];
50 return s + " ] " ;
51 }
52 // Imprime informaci ó n del estado de la pila y de la ú ltima operaci ó n
53 public void estado ( String op , Object elemento ) {
54 System . out . print ( " ----- -> " + op ); // imprime esta operaci ó n
55 System . out . println ( " , regresa " + elemento ); // que fue regresado
56 System . out . print ( " resultado : num . elems . = " + size ());
172 Pilas y colas
57 System . out . print ( " , ¿ est á vac ı́ o ? " + isEmpty ());

58 System . out . println ( " , pila : " + this ); // contenido de la pila
59 }
60 /* *
61 * Prueba el programa haciendo una serie de operaciones en pilas ,
62 * imprimiendo las operaciones realizadas , los elementos regresados y
63 * el contenido de la pila involucrada , despues de cada operaci ó n .
64 */
66 Object o ;
67 ArregloStack < Integer > A = new ArregloStack < Integer >();
68 A . estado ( " new ArregloStack < Integer > A " , null );
69 A . push (7);
70 A . estado ( " A . push (7) " , null );
71 o = A . pop ();
72 A . estado ( " A . pop () " , o );
73 A . push (9);
74 A . estado ( " A . push (9) " , null );
75 o = A . pop ();
76 A . estado ( " A . pop () " , o );
77 ArregloStack < String > B = new ArregloStack < String >();
78 B . estado ( " new ArregloStack < String > B " , null );
79 B . push ( " Paco " );
80 B . estado ( " B . push (\" Paco \") " , null );
81 B . push ( " Pepe " );
82 B . estado ( " B . push (\" Pepe \") " , null );
83 o = B . pop ();
84 B . estado ( " B . pop () " , o );
85 B . push ( " Juan " );
86 B . estado ( " B . push (\" Juan \") " , null );
87 }
88 }
Listado 5.3: Implementación de la interfaz Stack con un arreglo.
Salida ejemplo
Se muestra enseguida la salida del programa ArregloStack. Con el uso
de tipos genéricos, se puede crear un ArregloStack A para guardar enteros
y otro ArregloStack B para guardar String.
------> new ArregloStack<Integer> A, regresa null

resultado: num. elems. = 0, está vacio = true, pila: []
------> A.push(7), regresa null
resultado: num. elems. = 1, está vacio = false, pila: [7]
------> A.pop(), regresa 7
------> A.push(9), regresa null
resultado: num. elems. = 1, está vacio = false, pila: [9]
5.1 Pilas 173
------> A.pop(), regresa 9

------> new ArregloStack<String> B, regresa null
------> B.push("Paco"), regresa null
resultado: num. elems. = 1, está vacio = false, pila: [Paco]
------> B.push("Pepe"), regresa null
resultado: num. elems. = 2, está vacio = false, pila: [Paco, Pepe]
------> B.pop(), regresa Pepe
resultado: num. elems. = 1, está vacio = false, pila: [Paco]
------> B.push("Juan"), regresa null
resultado: num. elems. = 2, está vacio = false, pila: [Paco, Juan]
Limitación de la pila con un arreglo

La implementación con un arreglo de una pila es simple y eficiente. Sin
embargo, esta implementación tiene un aspecto negativo—esta debe asumir
un lı́mite superior fijo, CAPACIDAD, en el tamaño de la pila. Para el ejemplo
mostrado en el listado 5.3 se escogió una capacidad de 1,000 arbitrariamente.
Una aplicación podrı́a actualmente necesitar mucho menos espacio que esto,
por lo que se tendrı́a un desperdicio de memoria. Alternativamente, una
aplicación podrı́a necesitar más espacio que esto, lo cual causarı́a que la
implementación de la pila genere una excepción tan pronto como un programa
cliente intente rebasar la capacidad de la pila, por defecto 1,000 objetos. A
pesar de la simplicidad y eficiencia, la pila implementada con arreglo no es
precisamente ideal.
Afortunadamente, hay otra implementación, la cual se revisa a continua-
ción, que no tiene una limitación del tamaño y usa espacio proporcional al
número actual de elementos guardados en la pila. Sin embargo, en casos dónde
se tiene una buena estimación del número de elementos que se guardarán en
la pila, la implementación usando un arreglo es difı́cil de vencer. Las pilas
tienen un papel importante en un número de aplicaciones computacionales,
por lo tanto es útil tener una implementación rápida del ADT pila, como una
implementación simple basada en el arreglo.
5.1.3. Implementación de una pila usando lista simple

Se revisa la implementación del ADT pila usando una lista simple enlazada.
En el diseño se requiere decidir si la cima de la pila está en la cabeza de la
174 Pilas y colas
lista o en la cola. La mejor opción es en la cabeza ya que se pueden insertar

elementos y borrar en tiempo constante. Por lo tanto, es más eficiente tener
la cima de la pila en la cabeza de la lista. También, para hacer la operación
size() en tiempo constante, se lleva la cuenta del número actual de elementos
en una variable de instancia.
En vez de usar una lista ligada que solamente pueda guardar objetos
de un cierto tipo, como se mostró en la sección 3.3, se quiere, en este caso,
implementar una pila genérica usando una lista genérica enlazada. Por lo
tanto, se necesita usar un nodo de tipo genérico para implementar esta lista
enlazada. Se muestra tal clase Nodo en el listado 5.4.
1 /* *
2 * Nodo de una lista simple enlazada , la cual guarda referencias
3 * a su elemento y al siguiente nodo en la lista .
4 *
5 */
6 public class Nodo <E > {
7 // Variables de instancia :
8 private E elemento ;
9 private Nodo <E > sig ;
10 /* * Crea un nodo con referencias nulas a su elemento y al nodo sig . */
11 public Nodo () {
12 this ( null , null );
13 }
14 /* * Crear un nodo con el elemento dado y el nodo sig . */
15 public Nodo ( E e , Nodo <E > s ) {
16 elemento = e ;
17 sig = s ;
18 }
19 // M é todos accesores :
20 public E getElemento () {
22 }
23 public Nodo <E > getSig () {
24 return sig ;
25 }
26 // M é todos modificadores :
27 public void setElemento ( E nvoElem ) {
28 elemento = nvoElem ;
29 }
30 public void setSig ( Nodo <E > nvoSig ) {
31 sig = nvoSig ;
32 }
33 }
Listado 5.4: La clase Nodo implementa un nodo genérico para una lista simple
enlazada.
5.1 Pilas 175
Clase genérica NodoStack

Una implementación de una pila, usando una lista simple enlazada, se da
en el listado 5.5. Todos los métodos de la interfaz Stack son ejecutados en
tiempo constante. Además de ser eficiente en el tiempo, esta implementación
de lista enlazada tiene un requerimiento de espacio que es O(n), donde n es
el número actual de elementos en la pila. Por lo tanto, esta implementación
no requiere que una nueva excepción sea creada para manejar los problemas
de desbordamiento de tamaño. Se usa una variable de instancia cima para
referirse a la cabeza de la lista, la cual apunta al objeto null si la lista
está vacı́a. Cuando se mete un nuevo elemento e en la pila, se crea un nuevo
nodo v para e, e es referenciado desde v, y se inserta v en la cabeza de la
lista. De igual modo, cuando se quita un elemento de la pila, se remueve el
nodo en la cabeza de la lista y se regresa el elemento. Por lo tanto, se realizan
todas las inserciones y borrados de elementos en la cabeza de la lista.
1 public class NodoStack <E > implements Stack <E > {
2 protected Nodo <E > cima ; // referencia el nodo cabeza
3 protected int tam ; // n ú mero de elementos en la pila
4 /* * Crear una pila vac ı́ a . */
5 public NodoStack () {
6 cima = null ;
7 tam = 0;
8 }
9 public int size () { return tam ; }
11 return cima == null ;
12 }
13 public void push ( E elem ) {
14 Nodo <E > v = new Nodo <E >( elem , cima ); // crear un nuevo nodo y enlazarlo
15 cima = v ;
16 tam ++;
17 }
18 public E top () throws E m p t y S t a c k E x c e p t i o n {
19 if ( isEmpty ()) throw new E m p t y S t a c k E x c e p t i o n ( " La pila est á vac ı́ a . " );
20 return cima . getElemento ();
21 }
22 public E pop () throws E m p t y S t a c k E x c e p t i o n {
23 if ( isEmpty ()) throw new E m p t y S t a c k E x c e p t i o n ( " La pila est á vac ı́ a . " );
24 E temp = cima . getElemento ();
25 cima = cima . getSig (); // desenlazar el antiguo nodo cima
26 tam - -;
27 return temp ;
28 }
30 Nodo <E > cur = cima ;
31 String s = " [ " ;
32 while ( cur != null ) {
33 if ( cur == cima ) // primer elemento
34 s += cur . getElemento ();
35 else
176 Pilas y colas
36 s += " , " + cur . getElemento ();

37 cur = cur . getSig ();
38 }
39 return s + " ] " ;
40 }
41 // Imprime informaci ó n del estado de la pila y de la ú ltima operaci ó n
42 public static void estado ( Stack S , String op , Object elemento ) {
43 System . out . println ( " - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - " );
44 System . out . println ( op );
45 System . out . println ( " Regresado : " + elemento );
46 String estadoVacio ;
47 if ( S . isEmpty ())
48 estadoVacio = " vac ı́ o " ;
49 else
50 estadoVacio = " no vac ı́ o " ;
51 System . out . println ( " tam = " + S . size () + " , " + estadoVacio );
52 System . out . println ( " Pila : " + S );
53 }
54 /* *
55 * Programa de prueba que realiza una serie de operaciones en una pila
56 * e imprime la operaci ó n realizada , el elemento regresado
57 * y el contenido de la pila despu é s de cada operaci ó n .
58 */
60 Object o ;
61 Stack < Integer > A = new NodoStack < Integer >();
62 estado (A , " Nueva Pila Vac ı́ a " , null );
63 A . push (5);
64 estado (A , " push (5) " , null );
65 A . push (3);
67 A . push (7);
69 o = A . pop ();
70 estado (A , " pop () " , o );
71 A . push (9);
73 o = A . pop ();
74 estado (A , " pop () " , o );
75 o = A . top ();
76 estado (A , " top () " , o );
77 }
78 }
Listado 5.5: Clase NodoStack implementando la interfaz Stack usando una lista
simple enlazada con los nodos genéricos del listado 5.4.
5.1.4. Invertir un arreglo con una pila

Se puede usar una pila para invertir los elementos en un arreglo, ası́ el
problema de la sección 3.6 se resuelve sin recursión. La idea básica es meter
todos los elementos del arreglo en orden en una pila y luego rellenar el arreglo
5.1 Pilas 177
sacando los elementos de la pila, el listado 5.6 muestra la implementación de

esta idea. En el método invertir() se muestra como se pueden usar tipos
genéricos en una aplicación simple que usa una pila genérica. En particular,
cuando los elementos son sacados de la pila en el ejemplo, estos son automáti-
camente regresados como elementos del tipo E; por lo tanto, estos pueden ser
inmediatamente regresados al arreglo de entrada. Se muestran dos ejemplos
que usan este método.
1 public static <E > void invertir ( E [] a ) {
2 Stack <E > S = new ArregloStack <E >( a . length );
3 for ( int i =0; i < a . length ; i ++)
4 S . push ( a [ i ]);
5 for ( int i =0; i < a . length ; i ++)
6 a [ i ] = S . pop ();
7 }
8 /* * Rutina para probar la inversi ó n de arreglos */
9 public static void main ( String args []) {
10 // autoboxing : a partir de Java 1.5 , hace la conversi ó n de tipos
11 // primitivos a objetos autom á ticamente y viceversa .
12 // Se usa a continuaci ó n .
13 Integer [] a = {4 , 8 , 15 , 16 , 23 , 42};
14 String [] s = { " Jorge " ," Paco " ," Pedro " ," Juan " ," Marta " };
15 System . out . println ( " a = " + Arrays . toString ( a ));
16 System . out . println ( " s = " + Arrays . toString ( s ));
17 System . out . println ( " Invirtiendo ... " );
18 invertir ( a );
19 invertir ( s );
20 System . out . println ( " a = " + Arrays . toString ( a ));
21 System . out . println ( " s = " + Arrays . toString ( s ));
22 }
23 }
Listado 5.6: Método genérico para invertir los elementos en un arreglo genérico
mediante una pila de la interfaz Stack<E>
La salida del listado 5.6 se muestra a continuación:
a = [4, 8, 15, 16, 23, 42]

s = [Jorge, Paco, Pedro, Juan, Marta]
Invirtiendo ...
a = [42, 23, 16, 15, 8, 4]
s = [Marta, Juan, Pedro, Paco, Jorge]
5.1.5. Aparear paréntesis y etiquetas HTML

En esta subsección, se exploran dos aplicaciones relacionadas de pilas, la
primera es para el apareamiento de paréntesis y sı́mbolos de agrupamiento en
expresiones aritméticas.
178 Pilas y colas
Las expresiones aritméticas pueden contener varios pares de sı́mbolos de

agrupamiento, tales como:
Paréntesis: “(” y “)”
Llaves: “{” y “}”
Corchetes: “[” y “]”
Sı́mbolos de la función piso: “b” y “c”
Sı́mbolos de la función techo: “d” y “e”
y cada sı́mbolo de apertura deberá aparearse con su correspondiente sı́mbolo

de cierre. Por ejemplo, un corchete izquierdo, “[”, deberá aparearse con su
correspondiente corchete derecho, “]”, como en la siguiente expresión:
[(5 + x) − (y + z)].
Los siguientes ejemplos ilustran este concepto:
Correcto: ()(()){([()])}
Correcto: ((()(()){([()])}))
Incorrecto: )(()){([()])}
Incorrecto: ({[ ])}
Incorrecto: (
Un algoritmo para el apareamiento de paréntesis

Un problema importante en el procesamiento de expresiones aritméticas es
asegurar que los sı́mbolos de agrupamiento se apareen correctamente. Se puede
usar una pila S para hacer el apareamiento de los sı́mbolos de agrupamiento
en una expresión aritmética con una sola revisión de izquierda a derecha. El
algoritmo prueba que los sı́mbolos izquierdo y derecho se apareen y también
que ambos sı́mbolos sean del mismo tipo.
Suponiendo que se da una secuencia X = x0 x1 x2 . . . xn−1 , donde cada xi es
un sı́mbolo que puede ser un sı́mbolo de agrupamiento, un nombre de variable,
un operador aritmético, o un número. La idea básica detrás de la revisión de
5.1 Pilas 179
que los sı́mbolos de agrupamiento en S empaten correctamente, es procesar los

sı́mbolos en X en orden. Cada vez que se encuentre un sı́mbolo de apertura,
se mete ese sı́mbolo en S, y cada vez que se encuentre un sı́mbolo de cierre, se
saca el sı́mbolo de la cima de la pila S, suponiendo que S no está vacı́a, y se
revisa que esos sı́mbolos sean del mismo tipo. Suponiendo que las operaciones
push y pop son implementadas para ejecutarse en tiempo constante, este
algoritmo corre en tiempo O(n), o sea lineal. Se da un pseudocódigo de este
algoritmo a continuación.
Algoritmo ApareamientoParéntesis(X, n):
Entrada: Un arreglo X de n sı́mbolos, cada uno de los cuales
es un sı́mbolo de agrupamiento, una variable, un operador
aritmético, o un número.
Salida: true si y sólo si todos los sı́mbolos de agrupamiento
en X se aparean.
Sea S una pila vacı́a
si X[i] es un sı́mbolo de apertura entonces
S.push(X[i])
si no Si X[i] es sı́mbolo de cierre entonces
si S.isEmpty() entonces
regresar false { nada para aparear }
si S.pop() no empata el tipo de X[i] entonces
regresar false { tipo incorrecto }
si S.isEmpty() entonces
regresar true { cada sı́mbolo apareado }
si no
regresar false { algunos sı́mbolos no empataron }
Apareamiento de etiquetas en un documento HTML

Otra aplicación en la cual el apareamiento es importante es en la validación
de documentos HTML. HTML es el formato estándar para documentos
hiperenlazados en el Internet. En un documento HTML, porciones de texto
están delimitados por etiquetas HTML. Una etiqueta simple de apertura
HTML tiene la forma “<nombre>” y la correspondiente etiqueta de cierre tiene
la forma “</nombre>”. Las etiquetas HTML comúnmente usadas incluyen
body: cuerpo del documento

180 Pilas y colas
h1: sección cabecera
blockquote: sección sangrada
p: párrafo
ol: lista ordenada
li: elemento de la lista
Idealmente, un documento HTML deberı́a tener todas sus etiquetas apa-

readas, sin embargo varios navegadores toleran un cierto número de etiquetas
no apareadas.
El algoritmo de la sección para el apareamiento de paréntesis puede ser
usado para aparear las etiquetas en un documento HTML. En el listado 5.7
se da un programa en Java para aparear etiquetas en un documento HTML
leı́do de la entrada estándar. Por simplicidad, se asume que todas las etiquetas
son etiquetas simples de apertura y cierre, es decir sin atributos, y que no
hay etiquetas formadas incorrectamente. El método esHTMLApareada usa una
pila para guardar los nombres de las etiquetas
1 import java . io . IOException ;
2 import java . util . Scanner ;
3
4 /* * Prueba simplificada de apareamiento de etiquetas en un documento HTML . */
5 public class HTML {
6 /* * Quitar el primer car á cter y el ú litmo de una < etiqueta > cadena . */
7 public static String quitarEx tremos ( String t ) {
8 if ( t . length () <= 2 ) return null ; // esta es una etiqueta degenerada
9 return t . substring (1 , t . length () -1);
10 }
11 /* * Probar si una etiqueta desnuda ( sin los s ı́ mbolos inicial y final )
12 * esta vac ı́ a o es una etiqueta verdadera de apertura . */
13 public static boolean e s E t i q u e t a A p e r t u r a ( String etiqueta ) {
14 return etiqueta . length ()==0 || etiqueta . charAt (0)!= ’/ ’;
15 }
16 /* * Probar si etiqueta1 desnuda aparea con etiqueta2 de cierre . */
17 public static boolean seAparean ( String etiqueta1 , String etiqueta2 ) {
18 // probar contra el nombre despu é s de ’/ ’
19 return etiqueta1 . equals ( etiqueta2 . substring (1));
20 }
21 /* * Probar si cada etiqueta de apertura tiene una etiqueta de cierre . */
22 public static boolean esHTML Apareada ( String [] etiqueta ) {
23 Stack < String > S = new NodoStack < String >(); // Pila para aparear etiquetas
24 for ( int i =0; (i < etiqueta . length )&&( etiqueta [ i ]!= null ); i ++)
25 if ( e s E t i q u e t a A p e r t u r a ( etiqueta [ i ]))
26 S . push ( etiqueta [ i ]); // etiqueta apertura ; meterla en la pila
27 else {
28 if ( S . isEmpty ())
29 return false ; // nada para aparear
5.2 Colas 181
30 if (! seAparean ( S . pop () , etiqueta [ i ]))

31 return false ; // apareamiento incorrecto
32 }
33 if ( S . isEmpty ()) return true ; // se apareo todo
34 return false ; // hay algunas etiquetas que nunca fueron apareadas
35 }
36 public final static int CAPACIDAD = 1000; // Capacidad del arreglo etiqueta
37 /* Dividir un documento HTML en un arreglo de etiquetas html */
38 public static String [] parseHTML ( Scanner s ) {
39 String [] etiqueta = new String [ CAPACIDAD ]; // el arreglo etiqueta
40 int contador = 0; // contador de etiquetas
41 String elemento ; // elemento regresado por el scanner s
42 while ( s . hasNextLine ()) {
43 while (( elemento = s . findInLine ( " <[^ >]* > " ))!= null ) // encontrar sig etiq
44 etiqueta [ contador ++]= qui tarExtre mos ( elemento );
45 s . nextLine (); // ir a la siguiente l ı́ nea
46 }
47 return etiqueta ; // arreglo de etiquetas desnudas
48 }
49 public static void main ( String [] args ) throws IOException { // probador
50 System . out . print ( " El archivo de entrada es un documento " );
51 if ( esHTMLAp areada ( parseHTML ( new Scanner ( System . in ))))
52 System . out . println ( " HTML apareado " );
53 else
54 System . out . println ( " HTML NO apareado " );
55 }
56 }
Listado 5.7: Clase HTML para revisar el apareamiento de las etiquetas en un docu-
mento HTML.
5.2. Colas
Otra estructura de datos fundamental es la cola (queue). Una cola es una
colección de objetos que son insertados y removidos de acuerdo al principio
primero en entrar, primero en salir, o FIFO (first-in first-out). Esto es, los
elementos pueden ser insertados en cualquier momento, pero sólo el elemento
que ha estado en la cola por más tiempo es el siguiente en ser removido.
Se dice que los elementos entran a una cola por la parte de atrás y son
removidos del frente. La metáfora para esta terminologı́a es una fila de gente
esperando para subir a un juego mecánico. La gente que espera para tal juego
entra por la parte trasera de la fila y se sube al juego desde el frente de la
lı́nea.
182 Pilas y colas
5.2.1. Tipo de dato abstracto cola
El tipo de dato abstracto cola define una colección que guarda los objetos
en una secuencia, donde el acceso al elemento y borrado están restringidos
al primer elemento en la secuencia, el cual es llamado el frente de la cola, y
la inserción del elemento está restringida al final de la secuencia, la cual es
llamada la parte posterior de la cola. Esta restricción forza la regla de que
los elementos son insertados y borrados en una cola de acuerdo al principio
primero en entrar, primero en salir, FIFO.
El ADT cola soporta los siguientes dos métodos fundamentales:
enqueue(e):insertar el elemento e en la parte posterior de la

cola.
dequeue():quitar el elemento del frente de la cola y regresarlo;
un error ocurre si la cola está vacı́a.
Adicionalmente, de igual modo como que con el ADT pila, el ADT cola
incluye los siguientes métodos de apoyo:
size():regresar el número de elementos en la cola.

isEmpty():regresar un booleano indicando si la cola está vacı́a.
front():regresar el elemento del frente de la cola, sin remo-
verlo; un error ocurre si la cola está vacı́a.
La siguiente tabla muestra una serie de operaciones de cola y su efecto en

una cola Q inicialmente vacı́a de objetos enteros. Por simplicidad, se usan
enteros en vez de objetos enteros como argumentos de las operaciones.
5.2 Colas 183
Operación Salida f rente ← Q ← cola

enqueue(5) – (5)
enqueue(3) – (5,3)
dequeue() 5 (3)
enqueue(7) – (3,7)
dequeue() 3 (7)
front() 7 (7)
dequeue() 7 ()
dequeue() “error” ()
isEmpty() true ()
enqueue(9) – (9)
enqueue(7) – (9,7)
size() 2 (9,7)
enqueue(3) – (9,7,3)
enqueue(5) – (9,7,3,5)
dequeue() 9 (7,3,5)
Hay varias aplicaciones posibles para las colas. Tiendas, teatros, centros
de reservación, y otros servicios similares que tı́picamente procesen peticiones
de clientes de acuerdo al principio FIFO. Una cola serı́a por lo tanto una
opción lógica para una estructura de datos que maneje el procesamiento de
transacciones para tales aplicaciones.
Interfaz java.util.Queue
El API de Java proporciona una interfaz cola, java.util.Queue, la cual
tiene funcionalidad similar al ADT cola, dado previamente, pero la documen-
tación para esta interfaz no indica que sólo soporte el principio FIFO. Cuando
se soporta FIFO, los métodos de las dos interfaces son equivalentes.
ADT Queue Interfaz java.util.Queue
size() size()
isEmpty() isEmpty()
enqueue(e) add(e) o offer(e)
dequeue() remove() o poll()
front() peek() o element()
Hay clases concretas del paquete java.util.concurrent de Java que
implementan la interfaz java.util.Queue con el principio FIFO como:
ArrayBlockingQueue, ConcurrentLinkedQueue y LinkedBlockingQueue
184 Pilas y colas
Interfaz cola
Una interfaz Java para el ADT cola se proporciona en el listado 5.8. Esta
interfaz genérica indica que objetos de tipo arbitrario pueden ser insertados
en la cola. Por lo tanto, no se tiene que usar conversión explı́cita cuando se
remuevan elementos.
Los métodos size() e isEmpty() tienen el mismo significado como sus
contrapartes en el ADT pila. Estos dos métodos, al igual que el método
front(), son conocidos como métodos accesores, por su valor regresado y no
cambian el contenido de la estructura de datos.
1 /* *
2 * Interfaz para una cola : una colecci ó n de elementos que son insertados
3 * y removidos de acuerdo con el principio primero en entrar , primero en
4 * salir .
5 *
6 * @see E m p t y Q u e u e E x c e p t i o n
7 */
8 public interface Queue <E > {
9 /* *
10 * Regresa el numero de elementos en la cola .
11 * @return n ú mero de elementos en la cola .
12 */
14 /* *
15 * Indica si la cola est á vac ı́ a
16 * @return true si la cola est á vac ı́a , false de otro modo .
17 */
19 /* *
20 * Regresa el elemento en el frente de la cola .
21 * @return elemento en el frente de la cola .
22 * @exception E m p t y Q u e u e E x c e p t i o n si la cola est á vac ı́ a .
23 */
24 public E front () throws E m p t y Q u e u e E x c e p t i o n ;
25 /* *
26 * Insertar un elemento en la zaga de la cola .
27 * @param elemento nuevo elemento a ser insertado .
28 */
29 public void enqueue ( E element );
30 /* *
31 * Quitar el elemento del frente de la cola .
32 * @return elemento quitado .
33 * @exception E m p t y Q u e u e E x c e p t i o n si la cola est á vac ı́ a .
34 */
35 public E dequeue () throws E m p t y Q u e u e E x c e p t i o n ;
36 }
Listado 5.8: Interfaz Queue con documentación estilo Javadoc.

5.2 Colas 185
5.2.2. Implementación simple de la cola con un arreglo

Se presenta una realización simple de una cola mediante un arreglo, Q,
de capacidad fija, guardando sus elementos. Como la regla principal con el
tipo ADT cola es que se inserten y borren los objetos de acuerdo al principio
FIFO, se debe decidir como se va a llevar el frente y la parte posterior de la
cola.
Una posibilidad es adaptar la aproximación empleada para la implemen-
tación de la pila, dejando que Q[0] sea el frente de la cola y permitiendo que
la cola crezca desde allı́. Sin embargo, esta no es una solución eficiente, para
esta se requiere que se muevan todos los elementos hacia adelante una celda
cada vez que se haga la operación dequeue. Tal implementación podrı́a tomar
por lo tanto tiempo O(n) para realizar el método dequeue(), donde n es el
número actual de objetos en la cola. Si se quiere lograr tiempo constante para
cada método de la cola, se necesita una aproximación diferente.
Usar arreglo en forma circular

Para evitar mover objetos una vez que son colocados en Q, se definen dos
variables f y r, que tienen los siguientes usos:
f es un ı́ndice a la celda de Q guardando el primer elemento de la

cola, el cual es el siguiente candidato a ser eliminado por una operación
dequeue, a menos que la cola esté vacı́a, en tal caso f = r.
r es un ı́ndice a la siguiente celda del arreglo disponible en Q.
Inicialmente, se asigna f = r = 0, lo cual indica que la cola está vacı́a.

Cuando se quita un elemento del frente de la cola, se incrementa f para indicar
la siguiente celda. Igualmente, cuando se agrega un elemento, se guarda este
en la celda Q[r] y se incrementa r para indizar la siguiente celda disponible en
Q. Este esquema permite implementar los métodos front(), enqueue(), y
dequeue() en tiempo constante, esto es, tiempo O(1). Sin embargo, todavı́a
hay un problema con esta aproximación.
Considerar, por ejemplo, que sucede si repetidamente se agrega y se quita
un solo elemento N veces. Se tendrı́a f = r = N . Si se intentará entonces
insertar el elemento una vez más, se podrı́a obtener un error de arreglo fuera
de lı́mites, ya que las N localidades válidas en Q son de Q[0] a Q[N − 1],
aunque hay espacio en la cola para este caso. Para evitar este problema y
186 Pilas y colas
poder utilizar todo el arreglo Q, se permite que los ı́ndices reinicien al final
de Q. Esto es, se ve ahora a Q como un “arreglo circular” que va de Q[0] a
Q[N − 1] y entonces inmediatamente regresan a Q[0] otra vez, ver figura 5.2.
Figura 5.2: Usando arreglo Q en un modo circular: (a) la configuración “normal”

con f ≤ r; (b) la configuración “envuelto alrededor de” con r < f
Implementar esta vista circular de Q es fácil. Cada vez que se incremente

f o r, se calcula este incremento como “(f + 1) mód N ” o “(r + 1) mód N ”,
respectivamente.
El operador “mód” es el operador módulo, el cual es calculado tomando
el residuo después de la división entera. Por ejemplo, 14 dividido por 4 es 3
con residuo 2, ası́ 14 mód 4 = 2. Especı́ficamente, dados enteros x y y tal
que x ≥ 0 y y ≥ 0, se tiene x mód y = x − bx/ycy. Esto es, si r = x mód y,
entonces hay un entero no negativo q, tal que x = qy + r. Java usa “ %” para
denotar el operador módulo. Mediante el uso del operador módulo, se puede
ver a Q como un arreglo circular e implementar cada método de la cola en
una cantidad constante de tiempo, es decir, tiempo O(1). Se describe como
usar esta aproximación para implementar una cola enseguida.
Algoritmo size():
return (N − f + r) mód N
Algoritmo isEmpty():
return (f = r)
Algoritmo front():
lanzar una EmptyQueueException
return Q[f ]
5.2 Colas 187
Algoritmo enqueue(e):
si size()= N − 1 entonces
lanzar una FullQueueException
Q[r] ← e
r ← (r + 1) mód N
Algoritmo dequeue():
lanzar una EmptyQueueException
e ← Q[f ]
Q[f ] ← null
f ← (f + 1) mód N
return e
La implementación anterior contiene un detalle importante, la cual podrı́a
ser ignorada al principio. Considerar la situación que ocurre si se agregan N
objetos en Q sin quitar ninguno de ellos. Se tendrı́a f = r, la cual es la misma
condición que ocurre cuando la cola está vacı́a. Por lo tanto, no se podrı́a
decir la diferencia entre una cola llena y una vacı́a en este caso. Existen varias
formas de manejarlo.
La solución que se describe es considerando que Q no puede tener más de
N − 1 objetos. Esta regla simple para manejar una cola llena se considera
en el algoritmo enqueue dado previamente. Para señalar que no se pueden
insertar más elementos en la cola, se emplea una excepción especı́fica, llamada
FullQueueException. Para determinar el tamaño de la cola se hace con
la expresión (N − f + r) mód N , la cual da el resultado correcto en una
configuración “normal”, cuando f ≤ r, y en la configuración “envuelta”
cuando r < f . La implementación Java de una cola por medio de un arreglo
es similar a la de la pila, y se deja como ejercicio.
Al igual que con la implementación de la pila con arreglo, la única desven-
taja de la implementación de la cola con arreglo es que artificialmente se pone
la capacidad de la cola a algún valor fijo. En una aplicación real, se podrı́a
actualmente necesitar más o menos capacidad que esta, pero si se tiene una
buena estimación de la capacidad, entonces la implementación con arreglo es
bastante eficiente.
La siguiente tabla muestra los tiempos de ejecución de los métodos de
una cola empleando un arreglo. Cada uno de los métodos en la realización
arreglo ejecuta un número constante de sentencias involucrando operaciones
aritméticas, comparaciones, y asignaciones. Por lo tanto, cada método en esta
188 Pilas y colas
implementación se ejecuta en tiempo O(1).
Método Tiempo
size O(1)
isEmpty O(1)
front O(1)
enqueue O(1)
dequeue O(1)
5.2.3. Implementación con una lista enlazada

Se puede implementar eficientemente el ADT cola usando una lista genérica
simple ligada. Por razones de eficiencia, se escoge el frente de la cola para que
esté en la cabeza de la lista, y la parte posterior de la cola para que esté en
la cola de la lista. De esta forma se quita de la cabeza y se inserta en la cola.
Para esto se necesitan mantener referencias a los nodos cabeza y cola de la
lista. Se presenta en el listado 5.9, una implementación del método queue()
de la cola, y en el listado 5.10 del método dequeue().
1 public void enqueue ( E elem ) {
2 Nodo <E > nodo = new Nodo <E >();
3 nodo . setElemento ( elem );
4 nodo . setSig ( null ); // nodo ser á el nuevo nodo cola
5 if ( tam == 0)
6 cabeza = nodo ; // caso especial de una cola previamente vac ı́ a
7 else
8 cola . setSig ( nodo ); // agregar nodo en la cola de la lista
9 cola = nodo ; // actualizar la referencia al nodo cola
10 tam ++;
11 }
Listado 5.9: Implementación del método enqueue() del ADT cola usando de una
lista simple ligada con nodos de la clase Nodo.
1 public E dequeue () throws E m p t y Q u e u e E x c e p t i o n {

2 if ( tam == 0)
3 throw new E m p t y Q u eu e E x c e p t i o n ( " La cola est á vac ı́ a . " );
4 E e = cabeza . getElemento ();
5 cabeza = cabeza . getSig ();
6 tam - -;
7 if ( tam == 0)
8 cola = null ; // la cola est á ahora vac ı́ a
9 return e ;
10 }
Listado 5.10: Implementación del método dequeue() del ADT cola usando una
lista simple ligada con nodos de la clase Nodo.
5.2 Colas 189
Cada uno de los métodos de la implementación del ADT cola, con una
implementación de lista ligada simple, corren en tiempo O(1). Se evita la
necesidad de indicar un tamaño máximo para la cola, como se hizo en la
implementación de la cola basada en un arreglo, pero este beneficio viene a
expensas de incrementar la cantidad de espacio usado por elemento. A pesar
de todo, los métodos en la implementación de la cola con la lista ligada son
más complicados que lo que se desearı́a, se debe tener cuidado especial de el
manejo de los casos especiales, como cuando la cola está vacı́a y se hace la
operación enqueue, o cuando la cola se vacı́a por la operación dequeue.
5.2.4. Planificador Round Robin

Un uso popular de la estructura de datos cola es para implementar un pla-
nificador round robin, donde se itera a través de una colección de elementos
en forma circular y se “atiende” cada elemento mediante la realización de
una acción dada sobre este. Dicha pauta es usada, por ejemplo, para asignar
equitativamente un recurso que deberá ser compartido por una colección
de clientes. Por ejemplo, se puede usar un planificador round robin para
asignar una parte del tiempo del CPU a varias aplicaciones ejecutándose
concurrentemente en una computadora.
Se puede implementar un planificador round robin usando una cola, Q,
mediante la repetición de los siguientes pasos:
1. e ← Q.dequeue()
2. Servir elemento e
3. Q.enqueue(e)
El problema de Josefo
En el juego de niños de la “Papa Caliente”, un grupo de n niños sentados
en cı́rculo se pasan un objeto, llamado la “papa” alrededor del cı́rculo. El
juego se inicia con el niño que tenga la papa pasándola al siguiente en el
cı́rculo, y estos continúan pasando la papa hasta que un coordinador suena
una campana, en donde el niño que tenga la papa deberá dejar el juego y pasar
la papa al siguiente niño en el cı́rculo. Después de que el niño seleccionado
deja el juego, los otros niños estrechan el cı́rculo. Este proceso es entonces
continuado hasta que quede solamente un niño, que es declarado el ganador.
190 Pilas y colas
Si el coordinador siempre usa la estrategia de sonar la campana después de

que la papa ha pasado k veces, para algún valor fijo k, entonces determinar el
ganador para una lista de niños es conocido como el problema de Josefo.
Solución del problema de Josefo con una cola

Se puede resolver el problema de Josefo para una colección de n elementos
usando una cola, mediante la asociación de la papa con el elemento en el
frente de la cola y guardando elementos en la cola de acuerdo a su orden
alrededor del cı́rculo. Por lo tanto, pasar la papa es equivalente a retirar un
elemento de la cola e inmediatamente agregarlo otra vez. Después de que
este proceso se ha realizado k veces, se quita el elemento del frente usando
dequeue y descartándolo. Se muestra en el listado 5.11, un programa Java
completo para resolver el problema de Josefo, el cual describe una solución
que se ejecuta en tiempo O(nk).
1 public class Josefo {
2 /* * Soluci ó n del problema de Josefo usando una cola . */
3 public static <E > E Josefo ( Queue <E > Q , int k ) {
4 if ( Q . isEmpty ()) return null ;
5 while ( Q . size () > 1 ) {
6 System . out . println ( " Cola : " + Q + " k = " + k );
7 for ( int i =0; i < k ; i ++)
8 Q . enqueue ( Q . dequeue ()); // mover el elemento del frente al final
9 E e = Q . dequeue (); // quitar el elemento del frente de la coleccci ó n
10 System . out . println ( " \ t " + e + " est á eliminad@ " );
11 }
12 return Q . dequeue (); // el ganador
13 }
14 /* * Construir una cola desde un arreglo de objetos */
15 public static <E > Queue <E > construirCola ( E a []) {
16 Queue <E > Q = new NodoQueue <E >();
17 for ( E e : a )
18 Q . enqueue ( e );
19 return Q ;
20 }
21 /* * M é todo probador */
23 String [] a1 = { " Jorge " ," Pedro " ," Carlos " };
24 String [] a2 = { " Gabi " ," To ~ n o " ," Paco " ," Mari " ," Iv á n " ," Alex " ," N é stor " };
25 String [] a3 = { " Rigo " ," Edgar " ," Karina " ," Edgar " ," Temo " ," H é ctor " };
26 System . out . println ( " Primer ganador es " + Josefo ( construirCola ( a1 ) ,7));
27 System . out . println ( " Segundo ganador es " + Josefo ( construirCola ( a2 ) ,10));
28 System . out . println ( " Tercer ganador es " + Josefo ( construirCola ( a3 ) ,2));
29 }
30 }
Listado 5.11: Un programa Java completo para resolver el problema de Josefo

usando una cola. La clase NodoQueue es mostrada en los listados 5.9 y 5.10.
5.3 Colas con doble terminación 191
5.3. Colas con doble terminación

Considerar una estructura de datos parecida a una cola que soporte
inserción y borrado tanto en el frente y la parte posterior de la cola. Tal
extensión de una cola es llamada una cola con doble terminación o en
inglés double-ended queue, o deque, está última se pronuncia ‘dek’, para
evitar confusión con el método dequeue() de un ADT cola regular, que se
pronuncia como ‘dikiu’
5.3.1. Tipo de dato abstracto deque

El tipo de dato abstracto es más completo que los ADT pila y cola. Los
métodos fundamentales del ADT deque son los siguientes:
addFirst(e):inserta un nuevo elemento e al inicio de la deque.

addLast(e):inserta un nuevo elemento e al final de la deque.
removeFirst():retira y regresa el primer elemento de la deque; un
error ocurre si la deque está vacı́a.
removeLast():retira y regresa el último elemento de la deque; un
error ocurre si la deque está vacı́a.
Adicionalmente, el ADT deque podrı́a también incluir los siguientes méto-

dos de apoyo:
getFirst():regresa el primer elemento de la deque; un error

ocurre si la deque está vacı́a.
getLast():regresa el último elemento de la deque; un error
ocurre si la deque está vacı́a.
size():regresa el número de elementos de la deque.
isEmpty():determina si la deque está vacı́a.
La siguiente tabla muestra una serie de operaciones y sus efectos sobre

una deque D inicialmente vacı́a de objetos enteros. Por simplicidad, se usan
enteros en vez de objetos enteros como argumentos de las operaciones.
192 Pilas y colas
Operación Salida D
addFirst(3) – (3)
addFirst(5) – (5,3)
removeFirst() 5 (3)
addLast(7) – (3,7)
removeFirst() 3 (7)
removeLast() 7 ()
removeFirst() “error” ()
isEmpty() true ()
5.3.2. Implementación de una deque
Como la deque requiere inserción y borrado en ambos extremos de una

lista, usando una lista simple ligada para implementar una deque serı́a inefi-
ciente. Sin embargo, se puede usar una LDE, para implementar una deque
eficientemente. La inserción y remoción de elementos en cualquier extremo de
una LDE es directa para hacerse en tiempo O(1), si se usan nodos centinelas
para la cabeza y la cola.
Para una inserción de un nuevo elemento e, se puede tener acceso al nodo
p que estará antes de e y al nodo q que estará después del nodo e. Para
insertar un nuevo elemento entre los nodos p y q, cualquiera o ambos de estos
podrı́an ser centinelas, se crea un nuevo nodo t, haciendo que los enlaces prev
y sig de t hagan referencia a p y q respectivamente.
De igual forma, para quitar un elemento guardado en un nodo t, se puede
acceder a los nodos p y q que están a los lados de t, y estos nodos deberán
existir, ya que se usan centinelas. Para quitar el nodo t entre los nodos p y q,
se tiene que hacer que p y q se apunten entre ellos en vez de t. No se requiere
cambiar ninguno de los campos en t, por ahora t puede ser reclamado por el
colector de basura, ya que no hay nadie que esté apuntando a t.
Todos los métodos del ADT deque, como se describen previamente, están
incluidos en la clase java.util.LinkedList<E>. Por lo tanto, si se necesita
usar una deque y no se desea implementarla desde cero, se puede usar la clase
anterior.
De cualquier forma, se muestra la interfaz Deque en el listado 5.12 y una
implementación de esta interfaz en el listado 5.13.
1 /* *
2 * Interfaz para una deque : una colecci ó n de objetos que pueden ser
3 * insertados y quitados en ambos extremos ; un subconjunto de los
4 * m é todos de java . util . LinkedList .
5 *
6 */
7 public interface Deque <E > {
8 /* *
9 * Regresa el n ú mero de elementos en la deque .
10 */
12 /* *
13 * Determina si la deque est á vac ı́ a .
14 */
16 /* *
17 * Regresa el primer elemento ; una excepci ó n es lanzada si la deque
18 * est á vac ı́ a .
19 */
20 public E getFirst () throws E m p t y D e q u e E x c e p t i o n ;
21 /* *
22 * Regresa el ú ltimo elemento ; una excepci ó n es lanzada si la deque
24 */
25 public E getLast () throws E m p t y D e q u e E x c e p t i o n ;
26 /* *
27 * Insertar un elemento para que sea el primero en la deque .
28 */
29 public void addFirst ( E elemento );
30 /* *
31 * Insertar un elemento para que sea el ú ltimo en la deque .
32 */
33 public void addLast ( E elemento );
34 /* *
35 * Quita el primer elemento ; una excepci ó n es lanzada si la deque
37 */
38 public E removeFirst () throws E m p t y D e q u e E x c e p t i o n ;
39 /* *
40 * Quita el ú ltimo elemento ; una excepci ó n es lanzada si la deque
42 */
43 public E removeLast () throws E m p t y D e q u e E x c e p t i o n ;
44 }
Listado 5.12: Interfaz Deque con documentación estilo Javadoc. Se usa el tipo
parametrizado genérico E con lo cual una deque puede contener elementos de
cualquier clase especificada.
194 Pilas y colas
1 /* *
2 * Implementaci ó n de la interfaz Deque mediante una lista doblemente
3 * enlazada . Esta clase usa la clase NodoDL , la cual implementa un nodo de
4 * la lista .
5 */
6 public class NodoDeque <E > implements Deque <E > {
7 protected NodoDL <E > cabeza , cola ; // nodos centinelas
8 protected int tam ; // cantidad de elementos
9 /* * Constructor sin par á metros para crear una deque vac ı́ a . */
10 public NodoDeque () { // inicializar una deque vac ı́ a
11 cabeza = new NodoDL <E >();
12 cola = new NodoDL <E >();
13 cabeza . setSig ( cola ); // hacer que cabeza apunte a cola
14 cola . setPrev ( cabeza ); // hacer que cola apunte a cabeza
15 tam = 0;
16 }
18 return tam ;
19 }
21 return tam == 0;
22 }
23 public E getFirst () throws E m p t y D e q u e E x c e p t i o n {
24 if ( isEmpty ())
25 throw new E m p t y D e q u e E x c e p t i o n ( " Deque est á vac ı́ a . " );
26 return cabeza . getSig (). getElemento ();
27 }
28 public E getLast () throws E m p t y D e q u e E x c e p t i o n {
29 if ( isEmpty ())
31 return cola . getPrev (). getElemento ();
32 }
33 public void addFirst ( E o ) {
34 NodoDL <E > segundo = cabeza . getSig ();
35 NodoDL <E > primero = new NodoDL <E >( o , cabeza , segundo );
36 segundo . setPrev ( primero );
37 cabeza . setSig ( primero );
38 tam ++;
39 }
40 public void addLast ( E o ) {
41 NodoDL <E > penultimo = cola . getPrev ();
42 NodoDL <E > ultimo = new NodoDL <E >( o , penultimo , cola );
43 penultimo . setSig ( ultimo );
44 cola . setPrev ( ultimo );
45 tam ++;
46 }
47 public E removeFirst () throws E m p t y D e q u e E x c e p t i o n {
48 if ( isEmpty ())
50 NodoDL <E > primero = cabeza . getSig ();
51 E e = primero . getElemento ();
52 NodoDL <E > segundo = primero . getSig ();
53 cabeza . setSig ( segundo );
54 segundo . setPrev ( cabeza );
55 tam - -;
56 return e ;
57 }
58 public E removeLast () throws E m p t y D e q u e E x c e p t i o n {
59 if ( isEmpty ())
61 NodoDL <E > ultimo = cola . getPrev ();
62 E e = ultimo . getElemento ();
63 NodoDL <E > penultimo = ultimo . getPrev ();
64 cola . setPrev ( penultimo );
65 penultimo . setSig ( cola );
66 tam - -;
67 return e ;
68 }
69 }
Listado 5.13: Clase NodoDeque que implementa la interfaz Deque con la clase NodoDL
(que no se muestra). NodoDL es un nodo de una lista doblemente enlazada genérica.
196 Pilas y colas
Capı́tulo 6
Listas e Iteradores
6.1. Lista arreglo

Supóngase que se tiene una colección S de n elementos guardados en un
cierto orden lineal, de este modo se puede referir a los elementos en S como
primero, segundo, tercero, etc. Tal colección es generalmente referida como
una lista o secuencia. Se puede referir únicamente a cada elemento e en S
usando un entero en el rango [0, n − 1], esto es igual al número de elementos
de S que preceden a e en S. El ı́ndice de un elemento e en S es el número
de elementos que están antes que e en S. Por lo tanto, el primer elemento en
S tiene ı́ndice cero y el último elemento tiene ı́ndice n − 1. También, si un
elemento de S tiene ı́ndice i, su elemento previo, si este existe, tiene ı́ndice
i − 1, y su siguiente elemento, si este existe, tiene ı́ndice i + 1. Este concepto
de ı́ndice está relacionado al de rango de un elemento en una lista, el cual es
definido para que sea uno más que su ı́ndice; por lo que el primer elemento
tiene rango uno, el segundo tiene rango dos, etc.
Una secuencia que soporte acceso a sus elementos mediante sus ı́ndices
es llamado una lista arreglo, o también con el término más viejo vector.
Como la definición de ı́ndice es más consistente con la forma como los arreglos
son ı́ndizados en Java y otros lenguajes de programación, como C y C++, se
hará referencia al lugar donde un elemento es guardado en una lista arreglo
como su “ı́ndice”, no su “rango”.
Este concepto de ı́ndice es simple pero potente, ya que puede ser usado
para indicar donde insertar un nuevo elemento en una lista o de donde quitar
un elemento viejo.
198 Listas e Iteradores
6.1.1. El tipo de dato abstracto lista arreglo

Como un ADT, una lista arreglo S tiene los siguientes métodos, además
de los métodos estándares size() e isEmpty():
get(i):regresa el elemento de S con ı́ndice i; una condición

de error ocurre si i < 0 ó i >size()−1.
set(i, e):reemplaza con e y regresa el elemento en el ı́ndice
i; una condición de error ocurre si i < 0 ó i >
size() − 1.
add(i, e):inserta un nuevo elemento e en S para tener ı́ndice
i; una condición de error ocurre si i < 0 ó i >
size().
remove(i):quita de S el elemento en el ı́ndice i; una condición
de error ocurre si i < 0 ó i > size() − 1.
No se insiste en que un arreglo deberı́a ser usado para implementar una

lista arreglo, ası́ el elemento en el ı́ndice 0 está guardado en el ı́ndice 0 en el
arreglo, aunque esta es una posibilidad muy natural. La definición de ı́ndice
ofrece una forma para referirse al “lugar” donde un elemento está guardado en
una secuencia sin tener que preocuparse acerca de la implementación exacta
de esa secuencia. El ı́ndice de un elemento podrı́a cambiar cuando la secuencia
sea actualizada, como se muestra en el siguiente ejemplo.
Operación Salida S
add(0,7) – (7)
add(0,4) – (4,7)
get(1) 7 (4,7)
add(2,2) – (4,7,2)
get(3) “error” (4,7,2)
remove(1) 7 (4,2)
add(1,5) – (4,5,2)
add(1,3) – (4,3,5,2)
add(4,9) – (4,3,5,2,9)
get(2) 5 (4,3,5,2,9)
set(3,8) 2 (4,3,5,8,9)
6.1 Lista arreglo 199
6.1.2. Patrón de diseño adaptador

Las clases son frecuentemente escritas para dar funcionalidad similar a
otras clases. El patrón de diseño adaptador se aplica a cualquier contexto
donde se quiere modificar una clase existente para que sus métodos empaten
con los de una clase o una interfaz relacionada diferente. Una forma general
para aplicar el patrón adaptador es definir la nueva clase de tal forma que esta
contenga una instancia de la clase vieja como un campo oculto, e implementar
cada método de la nueva clase usando métodos de esta variable de instancia
oculta. El resultado de aplicar el patrón adaptador sirve para que una nueva
clase realice casi las mismas funciones que alguna clase previa, pero de una
forma más conveniente.
Con respecto al ADT lista arreglo, se observa que esta es suficiente para
definir una clase adaptadora para el ADT deque, como se ve en la tabla 6.1:
Método Deque Realización con Métodos

de Lista Arreglo
size(), isEmpty() size(), isEmpty()
getFirst() get(0)
getLast() get(size()-1)
addFirst(e) add(0,e)
addLast(e) add(size(),e)
removeFirst() remove(0)
removeLast() remove(size()-1)
Cuadro 6.1: Realización de una deque por medio de una lista arreglo.
6.1.3. Implementación simple con un arreglo

Una opción obvia para implementar el ADT lista arreglo es usar un arreglo
A, donde A[i] guarda una referencia al elemento con ı́ndice i. Se escoge el
tamaño N del arreglo A lo suficientemente grande, y se mantiene el número
de elementos en una variable de instancia, n < N .
Los detalles de esta implementación del ADT lista arreglo son simples.
Para implementar la operación get(i), por ejemplo, sólo se regresa A[i]. La
implementación de los métodos add(i, e) y remove(i) son dados a continua-
ción. Una parte importante y consumidora de tiempo de esta implementación
involucra el desplazamiento de elementos hacia adelante y hacia atrás para

mantener las celdas ocupadas en el arreglo de forma continua. Estas opera-
ciones de desplazamiento son requeridas para mantener la regla de guardar
siempre un elemento cuyo ı́ndice en la lista es i en el ı́ndice i del arreglo A,
ver figura 6.1.
Algoritmo add(i, e):
para j ← n − 1, n − 2, . . . , i hacer
A[j + 1] ← A[j] {hacer espacio para el nuevo elemento}
A[i] ← e
n←n+1
Algoritmo remove(i):
e ← A[i] { e es una variable temporal }
para j ← i, i + 1, . . . , n − 2 hacer
A[j] ← A[j + 1] {llenar el espacio del elemento quitado}
n←n−1
regresar e
Figura 6.1: Implementación basada en un arreglo de una lista arreglo S que

está guardando n elementos: (a) desplazando hacia adelante para una inserción en
el ı́ndice i; (b) desplazamiento hacia atrás para un borrado en el ı́ndice i.
Rendimiento de una implementación simple con un arreglo
El cuadro 6.2 muestra los tiempos de ejecución en el peor caso de un

arreglo lista con n elementos realizados por medio de un arreglo. Los métodos
isEmpty(), size(), get() y set() se ejecutan en tiempo O(1), pero los
métodos de inserción y borrado pueden tomar más tiempo. En particular,
add(i, e) se ejecuta en tiempo O(n). En efecto, el peor caso para esta operación
ocurre cuando i es cero, ya que todos los n elementos existentes tienen que
ser desplazados hacia adelante. Un argumento similar se aplica al método
remove(i), el cual corre en tiempo O(n), porque se tiene que desplazar hacia
atrás n − 1 elementos en el peor caso cuando i es igual a cero. De hecho,
suponiendo que cada ı́ndice posible es igualmente probable de que sea pasado
como un argumento a estas operaciones, su tiempo promedio es O(n), ya que
se tienen que desplazar n/2 elementos en promedio.
Método Tiempo
size() O(1)
isEmpty() O(1)
get(i) O(1)
set(i, e) O(1)
add(i, e) O(n)
remove(i) O(n)
Cuadro 6.2: Rendimiento de un lista arreglo con n elementos usando un arreglo. El

espacio usado es O(N ), donde N es el tamaño del arreglo.
Para add(i, e) y remove(i) se observa que el tiempo en cada ejecución es

O(n − i + 1), ya que sólo aquellos elementos con ı́ndice igual o mayor a i tienen
que ser desplazadas hacia atrás o adelante. Ası́, insertar y quitar un elemento
al final de una lista arreglo, usando los métodos add(n, e) y remove(n − 1),
respectivamente toman tiempo O(1) cada uno. Por otra parte, esta observación
tiene una consecuencia interesante para la adaptación del ADT lista arreglo
al ADT deque, dado en la sección 5.12, si el ADT lista arreglo en este caso es
implementado por medio de un arreglo como se describe previamente, entonces
los métodos addLast y removeLast del deque se ejecutan en tiempo O(1).
Sin embargo, los métodos addFirst y removeFirst del deque se ejecutan en
tiempo O(n).
Actualmente, con un poco de esfuerzo, se puede generar una implementa-

ción basada en un arreglo para que el ADT lista arreglo logre tiempo O(1)
para inserciones y borrados en el ı́ndice 0, al igual que inserciones y borrados
al final de la lista arreglo. Para lograrlo se requiere que no se dé la regla de
que un elemento con ı́ndice i es guardado en el arreglo en el ı́ndice i, se ocupa
en este caso usar una aproximación de arreglo circular como la que fue usada
en la sección 5.2 para implementar una cola.
6.1.4. Interfaz ListaIndice y la clase java.util.ArrayList
Para construir una implementación Java del ADT lista arreglo, se mues-
tra, en el listado 6.1 la interfaz ListaIndice, la cual captura los méto-
dos principales del ADT lista arreglo. En este caso, se usa la excepción
IndexOutOfBoundsException para indicar un argumento con ı́ndice inválido.
1 /* *
2 * Una interfaz para listas arreglo .
3 */
4 public interface ListaIndice <E > {
5 /* * Regresa el n ú mero de elementos en esta lista . */
7 /* * Prueba si la lista vac ı́ a . */
9 /* * Insertar un elemento e para estar en el ı́ ndice i ,
10 * desplazando todos los elementos despu é s de este . */
11 public void add ( int i , E e )
12 throws I n d e x O u t O f B o u n d s E x c e p t i o n ;
13 /* * Regresar el elemento en el ı́ ndice i , sin quitarlo . */
14 public E get ( int i )
16 /* * Quita y regresa el elemento en el ı́ ndice i ,
17 * desplazando los elementos despu é s de este . */
18 public E remove ( int i )
20 /* * Reemplaza el elemento en el ı́ ndice i con e ,
21 * regresando el elemento previo en i . */
22 public E set ( int i , E e )
24 }
Listado 6.1: La interfaz ListaIndice para el ADT lista arreglo.

La clase java.util.ArrayList
Java proporciona la clase, java.util.ArrayList, la cual implementa

todos los métodos que se dieron previamente para el ADT lista arreglo. Esta
incluye todos los métodos dados en el listado 6.1 para la interfaz ListaIndice.
Por otra parte, la clase java.util.ArrayList tiene caracterı́sticas adicionales
a las que fueron dadas en el ADT lista arreglo simplificado. Por ejemplo, la
clase incluye el método, clear(), para remover todos los elementos de la lista
arreglo, y el método, toArray(), el cual regresa un arreglo conteniendo todos
los elementos de la lista arreglo con el mismo orden. Además, también tiene
métodos para buscar en la lista, como el método indexOf(e), el cual regresa
el ı́ndice de la primera ocurrencia de un elemento igual a e en la lista arreglo,
y el método lastIndexOf(e), el cual regresa el ı́ndice de la última ocurrencia
de un elemento igual a e en la lista arreglo. Ambos métodos regresan el valor
ı́ndice inválido −1 si no se encuentra un elemento igual a e.
6.1.5. Lista arreglo usando un arreglo extendible

Además de implementar los métodos de la interfaz ListaIndice y algunos
otros métodos útiles, la clase java.util.ArrayList proporciona una carac-
terı́stica interesante que supera una debilidad en la implementación simple de
la lista arreglo.
La mayor debilidad de la implementación simple para el ADT lista arreglo
dado en la sección 6.1.3, es que esta requiere una especificación avanzada de la
capacidad fija, N , para el número total de elementos que podrı́an ser guardados
en la lista arreglo. Si el número actual de elementos, n, de la lista arreglo es
mucho menor que N , entonces la implementación desperdiciará espacio. Peor
aún, si n se incrementa y rebasa a N , entonces esta implementación fallará.
Para evitar lo anterior, java.util.ArrayList usa una técnica interesante
de arreglo extendible con lo que no habrá preocupación de que el arreglo sea
desbordado cuando se usa esta clase.
Al igual que la clase java.util.ArrayList, se proporciona un medio
para crecer el arreglo A que guarda los elementos de una lista arreglo S. Por
supuesto, en Java y en otros lenguajes de programación, no se puede crecer
el arreglo A; su capacidad está fija a algún número N , como ya se ha visto.
Cuando un desbordamiento ocurre, es decir, n = N y se hace una llamada al
método add, se realizan los siguientes pasos adicionales.
1. Reservar un nuevo arreglo B de capacidad 2N .
2. Hacer B[i] ← A[i], para i = 0, . . . , N − 1.
3. Hacer A ← B, esto es, se usa B como el arreglo que soporta a S.
4. Insertar el nuevo elemento en A.
Esta estrategia de reemplazo de arreglo es conocida como arreglo exten-

dible, y puede ser vista como extender la terminación del arreglo subyacente
para hacerle espacio para más elementos, ver figura 6.2. Intuitivamente, este
estrategia es parecida a la del cangrejo ermitaño, el cual se cambia a un
caracol más grande cuando sobrepasa al anterior.
Figura 6.2: Los tres pasos para “crecer” un arreglo extendible: (a) crea un nuevo
arreglo B; (b) copiar los elementos de A a B; (c) reasignar referencia A al nuevo
arreglo
Implementación de ListaIndice con un arreglo extendible

Se dan porciones de una implementación Java del ADT lista arreglo usando
un arreglo extendible en el código 6.2. Esta clase sólo proporciona los medios
para crecer. Un ejercicio es la implementación para poder reducir.
1 /* * Realizaci ó n de una lista indizada por medio de un arreglo , el cual es
2 * doblado cuando el tama ~ n o de la lista excede la capacidad del arreglo .
3 */
4 public class ArregloListaIndice <E > implements ListaIndice <E > {
5 private E [] A ; // arreglo almacenando los elementos de la lista indizada
6 private int capacidad = 16; // tama ~ n o inicial del arreglo A
7 private int tam = 0; // n ú mero de elementos guardados en la lista
8 /* * Crear la lista indizada con capacidad inicial de 16. */
9 public A r r e g l o L i s t a I n d i c e () {
10 A = ( E []) new Object [ capacidad ]; // compilador podr ı́ a advertir
11 }
12 /* * Insertar un elemento en el ı́ ndice dado . */
13 public void add ( int r , E e )
14 throws I n d e x O u t O f B o u n d s E x c e p t i o n {
15 revisarIndice (r , size () + 1);
16 if ( tam == capacidad ) { // un sobreflujo

17 capacidad *= 2;
18 E [] B =( E []) new Object [ capacidad ]; // el compilador podr ı́ a advertir
19 for ( int i =0; i < tam ; i ++)
20 B [ i ] = A [ i ];
21 A = B;
22 }
23 for ( int i = tam -1; i >= r ; i - -) // desplazar elementos hacia adelante
24 A [ i +1] = A [ i ];
25 A[r] = e;
26 tam ++;
27 }
28 /* * Quitar el elemento guardado en el ı́ ndice dado . */
29 public E remove ( int r )
30 throws I n d e x O u t O f B o u n d s E x c e p t i o n {
31 revisarIndice (r , size ());
32 E temp = A [ r ];
33 for ( int i = r ; i < tam -1; i ++) // desplazar elementos hacia atr á s
34 A [ i ] = A [ i +1];
35 tam - -;
36 return temp ;
37 }
Listado 6.2: Parte de la clase ArregloListaIndice realizando el ADT lista arreglo

por medio de un arreglo extendible. El método revisarIndice vigila que el ı́ndice
r esté entre 0 y n − 1.
Análisis amortizado del arreglo extendible

La estrategia de reemplazo del arreglo podrı́a parecer lento a simple vista,
ya que para realizarlo se ocupa tiempo O(n). Pero se debe observar que
después de que se haga el reemplazo, en el nuevo arreglo se pueden agregar
hasta n nuevos elementos en la lista arreglo antes de que el arreglo deba ser
reemplazado nuevamente. Este hecho permite mostrar que realizando una
serie de operaciones en un lista arreglo vacı́o es actualmente muy eficiente. Se
considerará la inserción de un elemento con el ı́ndice más grande posible, es
decir, n. En la tabla 6.3 se muestra el tiempo que toma realizar la inserción
al final de la lista y el tamaño actual del arreglo. El tamaño inicial del arreglo
es uno.
Usando un patrón de diseño algorı́tmico llamado amortización, se puede
mostrar que realizando una secuencia de operaciones, como las descritas
previamente, sobre una lista arreglo implementada con un arreglo extendible
es eficiente. Para realizar un análisis amortizado, se usa una técnica de
conteo dónde se ve a la computadora como una aplicación operada con
monedas que requiere el pago de un ciber-peso para una cantidad constante de
Elementos Tiempo Tamaño de A

1 1 1
2 2 2
3 3 4
4 1 4
5 5 8
6 1 8
7 1 8
8 1 8
9 9 16
10 1 16
11 1 16
12 1 16
13 1 16
14 1 16
15 1 16
16 1 16
Cuadro 6.3: Tiempo de ejecución para la inserción de elementos en un arreglo con

reemplazo.
tiempo computacional. Cuando una operación es ejecutada, se deberán tener

suficientes ciber-pesos disponibles en la “cuenta bancaria” para pagar las
tiempos de ejecución de las operaciones. Ası́, la cantidad total de ciber-pesos
gastados para cualquier cómputo será proporcional al tiempo gastado en
ese cómputo. La ventaja de usar este método de análisis es que se pueden
sobrecargar algunas operaciones para ahorrar ciber-pesos para pagar otras.
Proposición 6.1: Sea S una lista arreglo implementada por medio de un
arreglo extendible con un tamaño inicial uno. El tiempo total para realizar
una serie de n inserciones al final de la lista en S, iniciando con S vacı́a es
O(n)
Justificación. Suponiendo que un ciber-peso es suficiente para pagar por la
operación de inserción al final de la lista en S, sin considerar el tiempo gastado
en crecer el arreglo. Suponer que el crecimiento del arreglo de tamaño k a
2k requiere k ciber-pesos por el tiempo gastado en copiar los elementos. Se
cargará en cada operación de inserción tres ciber-pesos. Ası́, se sobrecarga
cada operación de inserción que no causa un sobreflujo por dos ciber-pesos.
Estos dos ciber-pesos se pueden pensar como un ahorro. Un sobreflujo ocurre
cuando la lista arreglo S tiene 2i elementos, para algún i ≥ 0, y el tamaño
6.2 Listas nodo 207
del arreglo usado es 2i . Entonces, doblar el tamaño del arreglo requerirá 2i

ciber-pesos. Estos ciber-pesos se pueden tomar de los elementos guardados
desde la celda 2i−1 hasta 2i − 1 (ver figura 6.3). Observar que sobreflujo
previo ocurrió cuando la cantidad de elementos se hizo más grande que 2i−1 la
primera vez, y de esta forma los ciber-pesos ahorrados en las celdas 2i−1 hasta
2i −1 no fueron previamente gastados. Por lo tanto, se tiene un esquema válido
de amortización en el cual cada operación es cargada con tres ciber-pesos
y todos los tiempos de cómputo son pagados. Es decir, se puede pagar la
ejecución de n inserciones al final usando 3n ciber-pesos. Es decir, el tiempo
de ejecución amortizado para cada operación de inserción al final es O(1);
por lo tanto, el tiempo total de ejecución de n operaciónes de inserciones al
final es O(n).
Figura 6.3: Ilustración de una serie de operaciones de inserción al final de la lista

arreglo: (a) un arreglo de 8 celdas lleno, con dos ciber-pesos ahorrados en las celdas
del 4 al 7; (b) una operación de inserción causa un sobreflujo y un doblado de
la capacidad. Copiar los 8 viejos elementos al nuevo arreglo se ha pagado con
los ciber-pesos ahorrados. Insertar el nuevo elemento es pagado por uno de los
ciber-pesos dados, y dos ciber-pesos son ahorrados en la celda 8.
6.2. Listas nodo

Usar un ı́ndice no es la única forma de referirse al lugar donde un elemento
aparece en una secuencia. Si se tiene una secuencia S implementada con una
lista enlazada, simple o doble, entonces podrı́a ser más natural y eficiente
usar un nodo en vez de un ı́ndice como medio de identificación para acceder

a S o para actualizar. Se define en esta sección el ADT lista nodo el cual
abstrae la estructura de datos concreta lista enlazada, secciones 3.3 y 3.4,
usando el ADT posición relacionada, el cual abstrae la noción de “lugar” en
una lista nodo.
6.2.1. Operaciones basadas en nodos

Sea S una lista enlazada simple o doble. Se desearı́a definir métodos para
S que tomen nodos como parámetros y proporcionen nodos como tipos de
regreso. Tales métodos podrı́an dar aumentos de velocidad significativos sobre
los métodos basados en ı́ndices, porque encontrar el ı́ndice de un elemento
en una lista enlazada requiere buscar a través de la lista incrementalmente
desde el inicio o final, contando los elementos conforme se recorra.
Por ejemplo, se podrı́a definir un método hipotético remove(v) que quite
el elemento de S guardado en el nodo v de la lista. Usando un nodo como un
parámetro permite remover un elemento en tiempo O(1) yendo directamente
al lugar donde está guardado el nodo y entonces “desenlazando” este nodo
mediante una actualización a los enlaces sig y prev de sus vecinos. De igual
modo, se puede insertar, en tiempo O(1), un nuevo elemento e en S con una
operación tal como addAfter(v, e), la cual indica el nodo v después del cual
el nodo del nuevo elemento deberı́a ser insertado. En este caso se “enlaza” el
nuevo nodo.
Para abstraer y unificar las diferentes formas de guardar elementos en las
diversas implementaciones de una lista, se introduce el concepto de posición,
la cual formaliza la noción intuitiva de “lugar” de un elemento relativo a los
otros en la lista.
6.2.2. Posiciones
A fin de ampliar de forma segura el conjunto de operaciones para listas,
se abstrae la noción de “posición” la cual permite usar la eficiencia de
la implementación de las listas simples enlazadas, o dobles, sin violar los
principios del diseño orientado a objetos. En este marco, se ve a la lista como
una colección que guarda a cada elemento en una posición y que mantiene
estas posiciones organizadas en un orden lineal. Una posición es por sı́ misma
un tipo de dato abstracto que soporta el siguiente método simple:
6.2 Listas nodo 209
elemento():regresa el elemento guardado en esta posición.
Una posición está siempre definida relativamente, esto es, en términos

de sus vecinos. En una lista, una posición p siempre estará “después” de
alguna posición q y “antes” de alguna posición s, a menos que p sea la primera
posición o la última. Una posición p, la cual está asociada con algún elemento
e en una lista S, no cambia, aún si el ı́ndice de e cambia en S, a menos que se
quite explı́citamente e, y por lo tanto, se destruya la posición p. Por otra parte,
la posición p no cambia incluso si se reemplaza o intercambia el elemento
e guardado en p con otro elemento. Estos hechos acerca de las posiciones
permiten definir un conjunto de métodos de lista basados en posiciones que
usan objetos posición como parámetros y también proporcionan objetos
posición como valores de regreso.
6.2.3. El tipo de dato abstracto lista nodo

Usando el concepto de posición para encapsular la idea de “nodo” en
una lista, se puede definir otro tipo de ADT secuencia llamado el ADT lista
nodo. Este ADT soporta los siguientes métodos para una lista S:
first():regresa la posición del primer elemento de S; un

error ocurre si S está vacı́a.
last():regresa la posición del último elemento de S; un
error ocurre si S está vacı́a.
prev(p):regresa la posición del elemento de S precediendo
al de la posición p; un error ocurre si p está en la
primera posición.
next(p):regresa la posición del elemento de S siguiendo al
de la posición p; un error ocurre si p está en la
última posición.
Los métodos anteriores permiten referirse a posiciones relativas en una

lista, comenzando en el inicio o final, y moviéndose incrementalmente a la
izquierda o a la derecha de la lista. Estas posiciones pueden ser pensadas como
nodos en la lista pero, se debe observar que no hay referencias especı́ficas a
objetos nodos. Además, si se proporciona una posición como un argumento a
un método lista, entonces la posición deberá representar una posición válida
en esa lista.
Métodos de actualización de la lista nodo

Además de los métodos anteriores y los métodos genéricos size e isEmpty,
se incluyen también los siguientes métodos de actualización para el ADT lista
nodo, los cuales usan objetos posición como parámetros y regresan objetos
posición como valores de regreso algunos de ellos.
set(p, e):reemplaza el elemento en la posición p con e, re-
gresando el elemento anterior en la posición p.
addFirst(e):inserta un nuevo elemento e en S como el primer
elemento.
addLast(e):inserta un nuevo elemento e en S como el último
elemento.
addBefore(p, e):inserta un nuevo elemento e en S antes de la posi-
ción p.
addAfter(p, e):inserta un nuevo elemento e en S después de la
posición p.
remove(p):quita y regresa el elemento e en la posición p en
S, invalidando esta posición en S.
El ADT lista nodo permite ver una colección ordenada de objetos en
términos de sus lugares, sin tenerse que preocupar acerca de la forma exacta
como estos lugares están representados, ver figura 6.4.
Figura 6.4: Una lista nodo. Las posiciones en el orden actual son p, q, r, y s.
Podrı́a parecer a primera vista que hay redundancia en el repertorio

anterior de operaciones para el ADT lista nodo, ya que se puede hacer la ope-
ración addFirst(e) con addBefore(first(),e), y la operación addLast(e)
con addAfter(last(),e). Pero estas sustituciones sólo pueden ser hechas
para una lista no vacı́a.
Observar que una condición de error ocurre si una posición pasada como
argumento a una de las operaciones de la lista es inválida. Las razones para
que una posición p sea inválida incluyen:
6.2 Listas nodo 211
p = null
p fue previamente borrada de la lista
p es una posición de una lista diferente
p es la primera posición de la lista y se llama prev(p)
p es la última posición de la lista y se llama next(p)
Se muestra enseguida una serie de operaciones para una lista nodo S

inicialmente vacı́a. Se usan las variables p1 , p2 , etc., para denotar diferentes
posiciones, y se muestra el objeto guardado actualmente en tal posición entre
paréntesis.
Operación Salida S
addFirst(8) – (8)
p1 ← first() [8] (8)
addAfter(p1 , 5) – (8,5)
p2 ← next(p1 ) [5] (8,5)
addBefore(p2 , 3) – (8,3,5)
p3 ← prev(p2 ) [3] (8,3,5)
addFirst(9) – (9,8,3,5)
p2 ← last() [5] (9,8,3,5)
remove(first()) 9 (8,3,5)
set(p3 , 7) 3 (8,7,5)
addAfter(first(), 2) – (8,2,7,5)
El ADT lista nodo, con su noción incorporada de posición, es útil para

realizar ajustes. Por ejemplo, un programa que simula un juego de cartas
podrı́a simular la mano de cada persona como una lista nodo. Ya que la
mayorı́a de las personas guarda las cartas de la misma figura juntas, insertar
y sacar cartas de la mano de una persona podrı́a ser implementado usando los
métodos del ADT lista nodo, con las posiciones siendo determinadas por un
orden natural de las figuras. Igualmente, un editor de texto simple encaja la
noción de inserción posicional y remoción, ya que tales editores tı́picamente
realizan todas las actualizaciones relativas a un cursor, el cual representa la
posición actual en la lista de caracteres de texto que está siendo editada.
Una interfaz Java representando el ADT posición está dado en el listado
6.3.
1 public interface Posicion <E > {

2 /* * Regresa el elemento guardado en esta posici ó n . */
3 E elemento ();
4 }
Listado 6.3: Una interfaz Java para el ADT posición.
Una interfaz, con los métodos requeridos, para el ADT lista nodo, llamada
ListaPosicion, está dada en el listado 6.4. Esta interfaz usa las siguientes
excepciones para indicar condiciones de error.
BoundaryViolationException: lanzada si un intento es hecho al acceder

una elemento cuya posición está fuera del rango de posiciones de la
lista, por ejemplo llamando al método next en la última posición de la
secuencia.
InvalidPositionException: lanzada si una posición dada como argumento

no es válida, por ejemplo, esta es una referencia null o esta no tiene
lista asociada.
1 import java . util . Iterator ;

2 /* *
3 * Una interfaz para listas posicionales .
4 *
5 */
6 public interface ListaPosicion <E > extends Iterable <E > {
7 /* * Regresa un iterador de todos los elementos en la lista . */
8 public Iterator <E > iterator ();
9 /* * Regresa una colecci ó n iterable de todos los nodos en la lista . */
10 public Iterable < Posicion <E > > positions ();
11 /* * Regresa el n ú mero de elementos en esta lista . */
13 /* * Indica si la lista est á vac ı́ a . */
15 /* * Regresa el primer nodo en la lista . */
16 public Posicion <E > first ();
17 /* * Regresa el ú ltimo nodo en la lista . */
18 public Posicion <E > last ();
19 /* * Regresa el nodo siguiente a un nodo dado en la lista . */
20 public Posicion <E > next ( Posicion <E > p )
21 throws InvalidPositionException , B o u n d a r y V i o l a t i o n E x c e p t i o n ;
22 /* * Regresa el nodo anterior a un nodo dado en la lista . */
23 public Posicion <E > prev ( Posicion <E > p )
25 /* * Inserta un elemento en el frente de la lista ,
26 * regresando la nueva posici ó n . */
27 public void addFirst ( E e );
28 /* * Inserta un elemento en la parte de atr á s de la lista ,
6.2 Listas nodo 213
29 * regresando la nueva posici ó n . */

30 public void addLast ( E e );
31 /* * Inserta un elemento despu é s del nodo dado en la lista . */
32 public void addAfter ( Posicion <E > p , E e )
33 throws I n v a l i d P o s i t i o n E x c e p t i o n ;
34 /* * Inserta un elemento antes del nodo dado en la lista . */
35 public void addBefore ( Posicion <E > p , E e )
37 /* * Quita un nodo de la lista , regresando el elemento guardado . */
38 public E remove ( Posicion <E > p ) throws I n v a l i d P o s i t i o n E x c e p t i o n ;
39 /* * Reemplaza el elemento guardado en el nodo dado ,
40 regresando el elemento viejo . */
41 public E set ( Posicion <E > p , E e ) throws I n v a l i d P o s i t i o n E x c e p t i o n ;
42 }
Listado 6.4: Interfaz para el ADT lista nodo.
Otro adaptador Deque

El ADT lista nodo es suficiente para definir una clase adaptadora para el
ADT deque, como se muestra en la tabla 6.4.
Método Deque Realización con Métodos

de la lista nodo
size(), isEmpty() size(), isEmpty()
getFirst() first().elemento()
getLast() last().elemento()
addFirst(e) addFirst(e)
addLast(e) addLast(e)
removeFirst() remove(first())
removeLast() remove(last())
Cuadro 6.4: Realización de una deque por medio de una lista nodo.
6.2.4. Implementación con lista doblemente enlazada

Si se quiere implementar el ADT lista nodo usando una lista doblemente
enlazada, sección 3.4, se debe hacer que los nodos de la lista enlazada im-
plementen el ADT posición. Esto es, se tiene cada nodo implementando la
interfaz Posicion y por lo tanto definen un método, elemento(), el cual
regresa el elemento guardado en el nodo. Ası́, los propios nodos actúan como
posiciones. Son vistos internamente por la lista enlazada como nodos, pero
desde el exterior, son vistos solamente como posiciones. En la vista interna,
se puede dar a cada nodo v variables de instancia prev y next que respecti-
vamente refieran a los nodos predecesor y sucesor de v, los cuales podrı́an ser
de hecho nodos centinelas, cabeza y cola, marcando el inicio o el final de la
lista. En lugar de usar las variables prev y next directamente, se definen los
métodos getPrev, setPrev, getNext, y setNext de un nodo para acceder y
modificar estas variables.
En el listado 6.5, se muestra la clase Java, NodoD, para los nodos de una
lista doblemente enlazada implementando el ADT posición. Esta clase es
similar a la clase NodoD mostrada en el listado 3.11, excepto que ahora los
nodos guardan un elemento genérico en lugar de una cadena de caracteres.
Observar que las variables de instancia prev y next en la clase NodoD son
referencias privadas a otros objetos NodoD.
1 public class NodoD <E > implements Posicion <E > {
2 private NodoD <E > prev , next ; // Referencia a los nodos anterior y posterior
3 private E elemento ; // Elemento guardado en esta posici ó n
5 public NodoD ( NodoD <E > nuevoPrev , NodoD <E > nuevoNext , E elem ) {
6 prev = nuevoPrev ;
7 next = nuevoNext ;
8 elemento = elem ;
9 }
10 // M é todo de la interfaz Posicion
11 public E elemento () throws I n v a l i d P o s i t i o n E x c e p t i o n {
12 if (( prev == null ) && ( next == null ))
13 throw new I n v a l i d P o s i t i o n E x c e p t i o n ( " ¡ La posici ó n no est á en una lista ! " );
15 }
16 // M é todos accesores
17 public NodoD <E > getNext () { return next ; }
18 public NodoD <E > getPrev () { return prev ; }
19 // M é todos actu alizador es
20 public void setNext ( NodoD <E > nuevoNext ) { next = nuevoNext ; }
21 public void setPrev ( NodoD <E > nuevoPrev ) { prev = nuevoPrev ; }
22 public void setElemento ( E nuevoElemento ) { elemento = nuevoElemento ; }
23 }
Listado 6.5: Clase NodoD realizando un nodo de una lista doblemente enlazada
implementando la interfaz Posicion.
Dada una posición p en S, se puede “desenvolver” p para revelar el nodo

v subyacente mediante una conversión de la posición a un nodo. Una vez que
se tiene un nodo v, se puede, por ejemplo, implementar el método prev(p)
con v.getPrev, a menos que el nodo regresado por v.getPrev sea la cabeza,
6.2 Listas nodo 215
en tal caso se señala un error. Por lo tanto, posiciones en una implementación

lista doblemente enlazada se pueden soportar en una forma orientada al objeto
sin ningún gasto adicional de tiempo o espacio.
Considerar ahora como se podrı́a implementar el método addAfter(p, e),
para insertar un elemento e después de la posición p. Se crea un nuevo nodo v
para mantener el elemento e, se enlaza v en su lugar en la lista, y entonces se
actualizan las referencias next y prev de los dos vecinos de v. Este método
está dado en el siguiente pseudocódigo, y se ilustra en la figura 6.5, recordando
el uso de centinelas, observar que este algoritmo trabaja aún si p es la última
posición real.
Algoritmo addAfter(p, e):
Crear un nuevo nodo v
v.setElemento(e)
v.setPrev(p) { enlazar v a su predecesor }
v.setNext(p.getNext()) { enlazar v a su sucesor }
(p.getNext()).setPrev(v) { enlazar el viejo sucesor de p a v }
p.setNext(v) { enlazar p a su nuevo sucesor, v }
Figura 6.5: Agregar un nuevo nodo después de la posición “JFK”:(a) antes de la

inserción; (b) creación de un nodo v con el elemento “BWI” y el enlazado a la lista;
(c) después de la inserción.
Los algoritmos para los métodos addBefore, addFirst, y addLast son

similares al método addAfter. Se dejan sus detalles como un ejercicio.
Considerar, ahora, el método remove(e), el cual quita el elemento e guar-

dado en la posición p. Para realizar esta operación, se enlazan los dos vecinos
de p para referirse entre ellos como nuevos vecinos—desenlazando p. Observar
que después de que p está desenlazado, no hay nodos apuntando a p; por lo
tanto, el recolector de basura puede reclamar el espacio de p. Este algoritmo
está dado en el siguiente pseudocódigo y se ilustra en la figura 6.6. Recordando
el uso de los centinelas cabeza y cola, este algoritmo trabaja aún si p es la
primera posición, la última, o solamente una posición real en la lista.
Algoritmo remove(p):
t ← p.elemento() { una variable temporal para guardar el valor de regreso }
(p.getPrev()).setNext(p.getNext()) { desenlazar p }
(p.getNext()).setPrev(p.getPrev())
p.setPrev(null) { invalidar la posición p }
p.setNext(null)
regresar t
Figura 6.6: Quitando el objeto guardado en la posición para “PVD”: (a) antes de
la remoción; (b) desenlazando el nodo viejo; (c) después de la remoción.
En conclusión, usando una lista doblemente enlazada, se pueden ejecu-

tar todos los métodos del ADT lista nodo en tiempo O(1). Ası́, una lista
doblemente enlazada es una implementación eficiente del ADT lista nodo.
6.2 Listas nodo 217
Implementación de la lista nodo en Java
La clase Java ListaNodoPosicion, la cual implementa el ADT lista nodo

usando una lista doblemente enlazada, se muestra en el listado 6.6. En esta
clase se tienen declaradas variables de instancia para guardar el número
de elementos en la lista, ası́ como los centinelas especiales para manejar
más fácilmente la lista. También se tiene un constructor sin parámetros que
permite crear una lista nodo vacı́a. En esta clase además de implementar los
métodos declarados en la interfaz ListaPosicion se tienen otros métodos
de conveniencia, por ejemplo para revisar si una posición es válida, probar
si una posición es la primera o la última, intercambiar los contenidos de dos
posiciones, u obtener una representación textual de la lista.
2 /* *
3 * Realizaci ó n de una ListaPosici ó n usando una lista doblemente enlazada
4 * de nodos .
5 *
6 */
7 public class ListaNodoPosicion <E > implements ListaPosicion <E > {
8 protected int tam ; // n ú mero de elementos en la lista
9 protected NodoD <E > cabeza , cola ; // centinelas especiales
10 /* * Constructor que crea una lista vac ı́ a ; tiempo O (1) */
11 public L i s t a N o d o P o s i c i o n () {
12 tam = 0;
13 cabeza = new NodoD <E >( null , null , null ); // crea cabeza
14 cola = new NodoD <E >( cabeza , null , null ); // crea cola
15 cabeza . setNext ( cola ); // hacer que cabeza apunte a cola
16 }
17 /* * Regresa el n ú mero de elementos en la lista ; tiempo O (1) */
18 public int size () { return tam ; }
19 /* * Valida si la lista est á vac ı́ a ; tiempo O (1) */
20 public boolean isEmpty () { return ( tam == 0); }
21 /* * Regresa la primera posici ó n en la lista ; tiempo O (1) */
22 public Posicion <E > first ()
23 throws E m p t y L i s t E x c e p t i o n {
24 if ( isEmpty ())
25 throw new E m p t y L i s t E x c e p t i on ( " La lista est á vac ı́ a " );
26 return cabeza . getNext ();
27 }
28 /* * Regresa la ú ltima posici ó n en la lista ; tiempo O (1) */
29 public Posicion <E > last ()
30 throws E m p t y L i s t E x c e p t i o n {
31 if ( isEmpty ())
32 throw new E m p t y L i s t E x c e p t i on ( " La lista est á vac ı́ a " );
33 return cola . getPrev ();
34 }
35 /* * Regresa la posici ó n anterior de la dada ; tiempo O (1) */
36 public Posicion <E > prev ( Posicion <E > p )
37 throws InvalidPositionException , B o u n d a r y V i o l a t i o n E x c e p t i o n {
38 NodoD <E > v = revis aPosicio n ( p );
39 NodoD <E > prev = v . getPrev ();
40 if ( prev == cabeza )
41 throw new B o u n d a r y V i o l a t i o n E x c e p t i o n
42 ( " No se puede avanzar m á s all á del inicio de la lista " );
43 return prev ;
44 }
45 /* * Regresa la posici ó n despu é s de la dada ; tiempo O (1) */
46 public Posicion <E > next ( Posicion <E > p )
49 NodoD <E > next = v . getNext ();
50 if ( next == cola )
51 throw new B o u n d a r y V i o l a t i o n E x c e p t i o n
52 ( " No se puede avanzar m á s all á del final de la lista " );
53 return next ;
54 }
55 /* * Insertar el elemento dado antes de la posici ó n dada : tiempo O (1) */
56 public void addBefore ( Posicion <E > p , E elemento )
57 throws I n v a l i d P o s i t i o n E x c e p t i o n {
59 tam ++;
60 NodoD <E > nodoNuevo = new NodoD <E >( v . getPrev () , v , elemento );
61 v . getPrev (). setNext ( nodoNuevo );
62 v . setPrev ( nodoNuevo );
63 }
64 /* * Insertar el elemento dado despu é s de la posici ó n dada : tiempo O (1) */
65 public void addAfter ( Posicion <E > p , E elemento )
68 tam ++;
69 NodoD <E > nodoNuevo = new NodoD <E >( v , v . getNext () , elemento );
70 v . getNext (). setPrev ( nodoNuevo );
71 v . setNext ( nodoNuevo );
72 }
73 /* * Insertar el elemento dado al inicio de la lista , regresando
74 * la nueva posici ó n ; tiempo O (1) */
75 public void addFirst ( E elemento ) {
76 tam ++;
77 NodoD <E > nodoNuevo = new NodoD <E >( cabeza , cabeza . getNext () , elemento );
78 cabeza . getNext (). setPrev ( nodoNuevo );
79 cabeza . setNext ( nodoNuevo );
80 }
81 /* * Insertar el elemento dado al final de la lista , regresando
82 * la nueva posici ó n ; tiempo O (1) */
83 public void addLast ( E elemento ) {
84 tam ++;
85 NodoD <E > ultAnterior = cola . getPrev ();
86 NodoD <E > nodoNuevo = new NodoD <E >( ultAnterior , cola , elemento );
87 ultAnterior . setNext ( nodoNuevo );
88 cola . setPrev ( nodoNuevo );
89 }
90 /* * Quitar la posici ó n dada de la lista ; tiempo O (1) */
91 public E remove ( Posicion <E > p )
94 tam - -;
95 NodoD <E > vPrev = v . getPrev ();
96 NodoD <E > vNext = v . getNext ();
6.2 Listas nodo 219
97 vPrev . setNext ( vNext );

98 vNext . setPrev ( vPrev );
99 E vElem = v . elemento ();
100 // desenlazar la posici ó n de la lista y hacerlo inv á lido
101 v . setNext ( null );
102 v . setPrev ( null );
103 return vElem ;
104 }
105 /* * Reemplaza el elemento en la posici ó n dada con el nuevo elemento
106 * y regresar el viejo elemento ; tiempo O (1) */
107 public E set ( Posicion <E > p , E elemento )
110 E elemVjo = v . elemento ();
111 v . setElemento ( elemento );
112 return elemVjo ;
113 }
114 /* * Regresa un iterador con todos los elementos en la lista . */
115 public Iterator <E > iterator () { return new ElementoIterador <E >( this ); }
117 public Iterable < Posicion <E > > positions () { // crea una lista de posiciones
118 ListaPosicion < Posicion <E > > P = new ListaNodoPosicion < Posicion <E > >();
119 if (! isEmpty ()) {
120 Posicion <E > p = first ();
121 while ( true ) {
122 P . addLast ( p ); // agregar posici ó n p como el ú lt . elemento de la lista P
123 if ( p == last ())
124 break ;
125 p = next ( p );
126 }
127 }
128 return P ; // regresar P como el objeto iterable
129 }
130 // M é todos de conveniencia
131 /* * Revisa si la posici ó n es v á lida para esta lista y la convierte a
132 * NodoD si esta es v á lida : tiempo O (1) */
133 protected NodoD <E > rev isaPosic ion ( Posicion <E > p )
135 if ( p == null )
136 throw new I n v a l i d P o s i t i o n E x c e p t i o n
137 ( " Posici ó n Null pasada a ListaNodo " );
138 if ( p == cabeza )
140 ( " El nodo cabeza no es una posici ó n v á lida " );
141 if ( p == cola )
143 ( " El nodo cola no es una posici ó n v á lida " );
144 try {
145 NodoD <E > temp = ( NodoD <E >) p ;
146 if (( temp . getPrev () == null ) || ( temp . getNext () == null ))
148 ( " Posici ó n no pertenece a una ListaNodo v á lida " );
149 return temp ;
150 } catch ( C l a s s C a s t E x c e p t i o n e ) {
152 ( " Posici ó n es de un tipo incorrecto para esta lista " );
153 }
154 }
155 /* * Valida si una posici ó n es la primera ; tiempo O (1). */
156 public boolean isFirst ( Posicion <E > p )
159 return v . getPrev () == cabeza ;
160 }
161 /* * Valida si una posici ó n es la ú ltima ; tiempo O (1). */
162 public boolean isLast ( Posicion <E > p )
165 return v . getNext () == cola ;
166 }
167 /* * Intercambia los elementos de dos posiciones dadas ; tiempo O (1) */
168 public void swapElements ( Posicion <E > a , Posicion <E > b )
170 NodoD <E > pA = rev isaPosic ion ( a );
171 NodoD <E > pB = rev isaPosic ion ( b );
172 E temp = pA . elemento ();
173 pA . setElemento ( pB . elemento ());
174 pB . setElemento ( temp );
175 }
176 /* * Regresa una representaci ó n textual de una lista nodo usando for - each */
177 public static <E > String f or Ea c hT oS tr i ng ( ListaPosicion <E > L ) {
178 String s = " [ " ;
179 int i = L . size ();
180 for ( E elem : L ) {
181 s += elem ; // moldeo impl ı́ cito del elemento a String
182 i - -;
183 if ( i > 0)
184 s += " , " ; // separar elementos con una coma
185 }
186 s += " ] " ;
187 return s ;
188 }
189 /* * Regresar una representaci ó n textual de una lista nodo dada */
190 public static <E > String toString ( ListaPosicion <E > l ) {
191 Iterator <E > it = l . iterator ();
192 String s = " [ " ;
193 while ( it . hasNext ()) {
194 s += it . next (); // moldeo impl ı́ cito del elemento a String
195 if ( it . hasNext ())
196 s += " , " ;
197 }
198 s += " ] " ;
199 return s ;
200 }
201 /* * Regresa una representaci ó n textual de la lista */
203 return toString ( this );
204 }
205 }
Listado 6.6: La clase ListaNodoPosicion implementando el ADT lista nodo con

una lista doblemente enlazada.
6.3 Iteradores 221
6.3. Iteradores
Un cálculo tı́pico en una lista arreglo, lista, o secuencia es recorrer sus
elementos en orden, uno a la vez, por ejemplo, para buscar un elemento
especı́fico.
6.3.1. Tipos de dato abstracto Iterador e Iterable

Un iterador (iterator) es un patrón de diseño de software que abstrae
el proceso de explorar un elemento a la vez desde una colección de elementos.
Un iterador consiste de una secuencia S, un elemento actual de S, y una
forma de pasar al siguiente elemento en S y hacerlo el elemento actual. Ası́,
un iterador extiende el concepto del ADT posición que se introdujo en la
sección 6.2. De hecho, una posición puede ser pensada como un iterador que
no va a ninguna parte. Un iterador encapsula los conceptos de “lugar” y
“siguiente” en una colección de objetos.
Se define el ADT iterador soportando los siguientes dos métodos:
hasNext():prueba si hay elementos pendientes en el iterador.

next():regresa el siguiente elemento en el iterador.
El ADT iterador usa el concepto de cursor como el elemento “actual” en

el recorrido de una secuencia. El primer elemento en un iterador es devuelto
en la primera llamada al método next, siempre y cuando el iterador contenga
al menos un elemento.
Un iterador da un esquema unificado para acceder a todos los elementos de
una colección de objetos en una forma que es independiente de la organización
especı́fica de la colección. Un iterador para una lista arreglo, lista nodo, o
secuencia deberá regresar los elementos de acuerdo a su orden lineal.
Iteradores simples en Java

Java proporciona un iterador a través de su interfaz java.util.Iterator.
La clase java.util.Scanner implementa esta interfaz. Esta interfaz soporta
un método adicional opcional para quitar el elemento previamente regresado
de la colección. Esta funcionalidad, de quitar elementos a través de un iterador,
es algo controversial desde un punto de vista orientado al objeto, sin embargo,
no es sorprendente que su implementación por las clases es opcional. Java
también da la interfaz java.util.Enumeration, la cual es históricamente
más vieja que la interfaz iterador y en vez de los nombres anteriores, usa
hasMoreElements() y nextElement().
El tipo de dato abstracto Iterable

Para dar un mecanismo unificado genérico para explorar a través de una
estructura de datos, los ADT que guardan colecciones de objetos deberı́an
soportar el siguiente método:
iterator():regresa un iterador de los elementos en la colección.
Este método está soportado por la clase java.util.ArrayList y es
muy importante, por lo que hay una interfaz completa java.lang.Iterable
conteniendo sólo este método. Este método puede simplificar al usuario la
tarea de recorrer los elementos de una lista. Para garantizar que una lista
nodo soporta el método anterior, por ejemplo, se podrı́a agregar este método
a la interfaz ListaPosicion, como se muestra en el listado 6.4. En este caso,
también se quisiera indicar que ListaPosicion extiende Iterable. Por lo
tanto, se asume que las listas arreglo y las listas nodo soportan el método
iterator().
2 /* * Regresa un iterador de todos los elementos en la lista . */
Listado 6.7: Agregando el método iterator a la interfaz ListaPosicion
Dada tal definición de una ListaPosicion, se podrı́a usar el iterador

devuelto por el método iterator() para crear una representación de cadena
de una lista nodo, como se muestra en el listado 6.8.
6.3.2. El ciclo for-each

Para recorrer los elementos regresados por un iterador es una construcción
común, Java proporciona una notación breve para tales ciclos, llamada el
ciclo ciclo for-each. La sintaxis para tal ciclo es la siguiente:
for (tipo nombre : expresión)

sentencia del ciclo
6.3 Iteradores 223
1 /* * Regresar una representaci ó n textual de una lista nodo dada */

2 public static <E > String toString ( ListaPosicion <E > l ) {
3 Iterator <E > it = l . iterator ();
4 String s = " [ " ;
5 while ( it . hasNext ()) {
6 s += it . next (); // moldeo impl ı́ cito del elemento a String
7 if ( it . hasNext ())
8 s += " , " ;
9 }
10 s += " ] " ;
11 return s ;
12 }
Listado 6.8: Ejemplo de un iterador Java usado para convertir una lista nodo a
una cadena.
donde expresión evalúa a una colección que implementa la interfaz java.lang.-

Iterable, tipo es el tipo de objeto regresado por el iterador para esta clase, y
nombre es el nombre de una variable que tomará los valores de los elementos
de este iterador en la sentencia del ciclo. Esta notación es la versión corta de
la siguiente:
for (Iterator<tipo> it=expresión.iterator(); it.hasNext(); ) {

Tipo nombre= it.next();
sentencia del ciclo
}
Por ejemplo, si se tiene una lista, valores, de objetos Integer, y valores

implementa java.lang.Iterable, entonces se pueden sumar todos los enteros
en valores como sigue:
List<Integer> valores;
...sentencias que crean una nueva lista y la llenan con Integer.
int suma = 0;
for (Integer i : valores)
suma += i; // el moldeo implı́cito permite esto
Se podrı́a leer el ciclo anterior como, “para cada Integer i en valores,

hacer el cuerpo del ciclo, en este caso, sumar i a suma”
Además de la forma anterior del ciclo for-each, Java también permite que
un ciclo for-each sea definido cuando expresión es un arreglo de tipo Tipo, el

cual puede ser un tipo base o un tipo objeto. Por ejemplo se puede totalizar
los enteros en un arreglo, v, el cual guarda los primeros diez enteros positivos,
como sigue:
int[] v={1, 2, 3, 4, 5, 6, 7, 8, 9, 10};

int total = 0;
for (int i: v)
total += i;
6.3.3. Implementación de los iteradores

Una forma de implementar un iterador para una colección de elementos es
hacer una “foto” de esta e iterar sobre esta. Esta aproximación involucrarı́a
guardar la colección en una estructura de datos separada que soporte acceso
secuencial a sus elementos. Por ejemplo, se podrı́an insertar todos los ele-
mentos de la colección en una cola, en tal caso el método hasNext() podrı́a
corresponder a !isEmpty() y next() podrı́a corresponder a dequeue(). Con
esta aproximación, el método iterator() toma tiempo O(n) para una colec-
ción de tamaño n. Como esta sobrecarga de copiado es relativamente costosa,
se prefiere, en muchos casos, tener iteradores que operen sobre la misma
colección, y no en una copia.
Para implementar esta aproximación directa, se necesita solo realizar un
seguimiento a donde el cursor del iterador apunta en la colección. Ası́, crear un
nuevo iterador en este caso involucra crear un objeto iterador que represente
un cursor colocado solo antes del primer elemento de la colección. Igualmente,
hacer el método next() involucra devolver el siguiente elemento, si este existe,
y mover el cursor pasando esta posición del elemento. En esta aproximación,
crear un iterador cuesta tiempo O(1), al igual que hacer cada uno de los
métodos del iterador. Se muestra una clase implementando tal iterador en el
listado 6.9, y se muestra en el listado 6.10 como este iterador podrı́a ser usado
para implementar el método iterator() en la clase ListaNodoPosicion.
Iteradores posición
Para los ADT que soporten la noción de posición, tal como las ADT lista
y secuencia, se puede también dar el siguiente método:
6.3 Iteradores 225
1 public class ElementoIterador <E > implements Iterator <E > {

2 protected ListaPosicion <E > lista ; // la lista subyacente
3 protected Posicion <E > cursor ; // la siguiente posici ó n
4 /* * Crea un elemento iterador sobre la lista dada . */
5 public E l e m en t o I t e r a d o r ( ListaPosicion <E > L ) {
6 lista = L ;
7 cursor = ( lista . isEmpty ())? null : lista . first ();
8 }
9 /* * Valida si el iterador tiene un objeto siguiente . */
10 public boolean hasNext () { return ( cursor != null ); }
11 /* * Regresa el siguiente objeto en el iterador . */
12 public E next () throws N o S u c h E l e m e n t E x c e p t i o n {
13 if ( cursor == null )
14 throw new N o S u c h E l e m e n t E x c e p t i o n ( " No hay elemento siguiente " );
15 E aRegresar = cursor . elemento ();
16 cursor = ( cursor == lista . last ())? null : lista . next ( cursor );
17 return aRegresar ;
18 }
Listado 6.9: Una clase elemento iterador para una ListaPosicion.
1 /* * Regresa un iterador con todos los elementos en la lista . */

2 public Iterator <E > iterator () { return new ElementoIterador <E >( this ); }
Listado 6.10: El método iterator() de la clase ListaNodoPosicion.
positions():regresa un objeto Iterable, por ejemplo una lista

arreglo, o una lista nodo, conteniendo las posicio-
nes en la colección como elementos.
Un iterador regresado por este método permite recorrer las posiciones de

una lista. Para garantizar que una lista nodo soporta este método, se podrı́a
agregar a la interfaz ListaPosicion, por lo que se debe agregar una imple-
mentación del método positions() en la clase ListaNodoPosicion, como se
muestra en el listado 6.12. Este método usa la propia clase ListaNodoPosicion
para crear una lista que contiene las posiciones de la lista original como sus ele-
mentos. Regresando esta lista posición como su objeto Iterable permitiendo
llamar iterator() sobre este objeto para obtener un iterador de posiciones
de la lista original.
2 // ... todos los otros m é todos de la ADT lista ...
5 }
Listado 6.11: Adición de la interfaz Iterable a la interfaz ListaPosicion.
1 public Iterable < Posicion <E > > positions () { // crea una lista de posiciones
2 ListaPosicion < Posicion <E > > P = new ListaNodoPosicion < Posicion <E > >();
3 if (! isEmpty ()) {
4 Posicion <E > p = first ();
5 while ( true ) {
6 P . addLast ( p ); // agregar posici ó n p como el ú lt . elemento de la lista P
7 if ( p == last ())
8 break ;
9 p = next ( p );
10 }
11 }
12 return P ; // regresar P como el objeto iterable
13 }
Listado 6.12: El método positions() de la clase ListaNodoPosicion.
El iterador regresado por iterator() y otros objetos Iterable definen un

tipo restringido de iterador que permite solo una pasada a los elementos. Sin
embargo, iteradores más poderosos pueden también ser definidos, los cuales
permiten moverse hacia atrás y hacia adelante sobre un cierto ordenamiento
de los elementos.
6.3.4. Iteradores lista en Java
La clase java.util.LinkedList no expone un concepto posición a los

usuarios en su API. La forma para acceder y actualizar un objeto LinkedList
en Java, sin usar ı́ndices, es usando un ListIterator que es generado por
LinkedList, usando el método listIterator(). Tal iterador da métodos
de recorrido hacia atrás y hacia adelante al igual que métodos locales para
actualizar. Este ve su posición actual como estando antes del primer elemento,
entre dos elementos, o después del último elemento. Esto es, usa un cursor
lista, parecido a como un cursor de pantalla es visto localizado entre dos
caracteres en una pantalla. La interfaz java.util.ListIterator incluye los
siguientes métodos:
6.4 ADT listas y el marco de colecciones 227
add(e):agrega el elemento e al final de la lista.

add(i, e):inserta el elemento e en la posición i especificada
en la lista.
hasNext():verdadero si y solo si hay un elemento después de
la posición actual del iterador.
hasPrevious():verdadero si y solo si hay un elemento antes de la
posición actual del iterador.
previous():regresa el elemento e antes de la posición actual y
mueve el cursor a e, por lo que puede usarse para
iterar hacia atrás.
next():regresa el elemento e después de la posición actual
y mueve el cursor a e, por lo que puede usarse para
iterar hacia adelante.
nextIndex():regresa el ı́ndice del siguiente elemento.
previousIndex():regresa el ı́ndice del elemento previo.
set(e):reemplaza el último elemento regresado por next()
o previous() con el elemento indicado.
remove():quita de la lista el último elemento que fue regre-
sado por next() o previous().
Es riesgoso usar múltiples iteradores sobre la misma lista mientras se
modifica su contenido. Si inserciones, borrados, o reemplazos son ocupados
en múltiples “lugares” en una lista, es más seguro usar posiciones para
indicar estas localidades. Pero la clase java.util.LinkedList no expone
sus objetos posición al usuario. Por lo tanto, para evitar los riesgos de
modificar una lista que ha creado múltiples iteradores, por llamadas a su
método iterator, los objetos java.util.Iterator tienen una capacidad
fail-fast que inmediatamente invalida tal iterador si su colección subyacente
es modificada inesperadamente. Java permite muchos iteradores lista para
estar recorriendo una lista ligada al mismo tiempo, pero si uno de ellos la
modifica, usando add, remove o set, entonces el resto de los iteradores se
hacen inválidos.
6.4. ADT listas y el marco de colecciones

Se revisa en esta sección los ADT lista general, los cuales combinan
métodos de la deque, lista arreglo, y lista nodo y como son usados en el marco
de colecciones de Java.
6.4.1. Listas en el marco de colecciones Java

Java proporciona un paquete de interfaces y clases para estructuras de
datos, las cuales conjuntamente definen el marco de colecciones Java (Java
Collections Framework ). Este paquete, java.util, incluye versiones de varias
de las estructuras de datos comentadas en este texto, algunas de las cuales
ya han sido discutidas y otras serán revisadas posteriormente. La interfaz
raı́z en el marco de colecciones Java es la interfaz Collection. Esta es una
interfaz general para cualquier estructura de datos que contenga una colección
de elementos, como una lista. Collection extiende a java.lang.Iterable;
por lo tanto, incluye el método iterator(), el cual regresa un iterador de
los elementos en esta colección. También es una superinterface para otras
interfaces en el marco de colecciones que guardan elementos, incluyendo las
interfaces Deque, List y Queue de java.util. Además Collection tiene
una subinterface que define el tipo de colección Set y tiene varias interfaces
importantes relacionadas, incluyendo las interfaces Iterator y ListIterator,
al igual que la interfaz Map.
El marco de colecciones de Java también incluye varias clases concretas
basadas en lista que implementan varias combinaciones de interfaces basadas
en lista. Las siguientes clases son incluidas en java.util:
ArrayBlockingQueue:Una implementación con arreglo de la interfaz

Queue con capacidad limitada.
ArrayDeque:Una implementación de la interfaz Deque que usa
un arreglo, el cual puede crecer o decrecer, como
se requiera.
ArrayList:Una implementación de la interfaz List que usa
un arreglo, el cual puede crecer o decrecer, como
se requiera.
ConcurrentLinkedQueue:Una implementación con lista enlazada de la inter-
faz Queue que es proceso seguro.
LinkedBlockingDeque:Una implementación con lista enlazada de la inter-
faz Deque con capacidad limitada.
LinkedBlockingQueue:Una implementación con lista enlazada de la inter-
faz Queue con capacidad limitada.
LinkedList:Una implementación con lista enlazada de la inter-
faz List.
Stack:Una implementación del ADT pila.
Cada una de las clases anteriores implementan la interfaz java.lang.Iter-

able, por lo tanto, incluyen el método iterator() y pueden ser usados en el
ciclo for-each. Además cualquier clase implementando la interfaz java.util.-
List, con las clases ArrayList y LinkedList, también incluyen el método
listIterator(). Como se indicó previamente, estas interfaces son útiles para
recorrer los elementos de una colección o lista.
Algoritmos basados en lista en el marco de colecciones Java

Además de las clases basadas en lista que son dadas en el marco de
colecciones Java, también hay una cantidad de algoritmos simples que son
dados. Estos métodos están implementados como métodos de clase en la clase
java.util.Collections y se incluyen los siguientes métodos.
disjoint(C, D):regresa un valor booleano indicando si las coleccio-

nes C y D son disjuntas.
fill(L, e):Reemplaza cada uno de los elementos en la lista
L con el mismo elemento, e.
frecuency(C, e):Regresa la cantidad de elementos en la colección
C que son iguales a e.
max(C):Regresa el elemento máximo en la colección C, ba-
sados en el ordenamiento natural de sus elementos.
min(C):Regresa el elemento mı́nimo en la colección C, ba-
sados en el ordenamiento natural de sus elementos.
replaceAll(L, e, f ):Reemplaza cada uno de los elementos en L que
son iguales a e con el mismo elemento, f .
reverse(L):Invierte el ordenamiento de los elementos en la
lista L.
rotate(L, d):Rota los elementos en la lista L por la distancia d,
la cual puede ser negativa, en una forma circular.
shuffle(L):Permuta pseudoaleatoriamente el ordenamiento de
los elementos en la lista L.
sort(L):Ordena la lista L, usando el ordenamiento natural
de los elementos en L.
Conversión de listas a arreglos

Las listas son un concepto interesante y pueden ser aplicadas en una
cantidad de contextos diferentes, pero hay algunos casos dónde podrı́a ser
más útil usar la lista como un arreglo. La interfaz java.util.Collection

incluye los siguientes métodos útiles para generar un arreglo que tenga los
mismos elementos que la colección dada:
toArray():Regresa un arreglo de elementos del tipo Object

conteniendo todos los elementos en esta colección.
toArray(A):Regresa un arreglo de elementos del mismo tipo
de A conteniendo todos los elementos en esta co-
lección.
Si la colección es una lista, entonces el arreglo devuelto debe tener sus

elementos guardados en el mismo orden que la lista original. Por lo tanto,
si se tiene un método útil basado en arreglo que se quiere usar en una lista
u otro tipo de colección, entonces se puede usar el método toArray() de la
colección para producir una representación arreglo de esa colección.
Conversión de arreglos a listas

De manera similar, es útil en ocasiones poder convertir un arreglo en su
lista equivalente. La clase java.util.Arrays incluye el siguiente método:
asList(A):Regresa una representación de lista del arreglo A,

con el mismo tipo de elemento que los elementos
de A.
La lista devuelta por este método usa el arreglo A como su representación

interna para la lista. Por lo que esta lista está garantizada para ser un
lista basada en arreglo y cualquier cambio hecho a esta automáticamente
será reflejada en A. Por estos tipos de efectos laterales, el uso del método
asList() deberá hacerse siempre con cuidado, para evitar consecuencias no
deseadas. Usando este método con cuidado puede ahorrar trabajo.
La interfaz java.util.List y sus implementaciones

Java proporciona funcionalidad similar a los ADT lista arreglo y lista
nodo en la interfaz java.util.List, la cual es implementada con un arreglo
en java.util.ArrayList y con una lista ligada en java.util.LinkedList.
Hay algunas compensaciones entre estas dos implementaciones. Java usa
iteradores para lograr una funcionalidad similar a la del ADT lista nodo
derivada de posiciones. El cuadro 6.5 indica la correspondencia entre los

métodos de los ADT lista (arreglo y nodo) con las interfaces java.util.List
y java.util.ListIterator.
Método del Método de Método de

ADT lista List ListIterator Notas
size() size() O(1)
isEmpty() isEmpty() O(1)
get(i) get(i) A es O(1),
L es O(mı́n{i, n − i})
first() listIterator() Primer elemento
es next
last() listIterator(size()) Último elemento
es previous
prev(p) previous() O(1)
next(p) next() O(1)
set(p, e) set(e) O(1)
set(i, e) set(i, e) A es O(1),
add(i, e) add(i, e) O(n)
remove(i) remove(i) A es O(n),
addFirst(e) add(0, e) A es O(n), L es O(1)
addFirst(e) addFirst(e) Sólo en L, O(1)
addLast(e) add(e) O(1)
addLast(e) addLast(e) Sólo en L, O(1)
addAfter(p, e) add(e) A es O(n), L es O(1)
inserción en el cursor
addBefore(p, e) add(e) A es O(n), L es O(1)
inserción en el cursor
remove(p) remove() A es O(n), L es O(1)
borrado en el cursor
Cuadro 6.5: Correspondencia entre los métodos de los ADT lista arreglo y lista nodo
(1a columna) contra las interfaces List y ListIterator de java.util. Se usa A y L
como abreviaturas para las clases java.util.ArrayList y java.util.LinkedList
6.4.2. Secuencias
Una secuencia es un ADT que soporta todos los métodos del ADT deque
(sección 5.12), el ADT lista arreglo (sección 6.1), y el ADT lista nodo (sección
6.2). Entonces, este proporciona acceso explı́cito a los elementos en la lista ya
sea por sus ı́ndices, o por sus posiciones. Por otra parte, como se proporciona
capacidad de acceso dual, se incluye en el ADT secuencia, los siguientes dos
métodos “puente” que proporcionan conexión entre ı́ndices y posiciones:
atIndex(i):regresar la posición del elemento con ı́ndice i; una

condición de error ocurre si i < 0 o i > size() − 1.
indexOf(p):regresar el ı́ndice del elemento en la posición p.
Herencia múltiple en el ADT secuencia

La definición del ADT secuencia incluye todos los métodos de tres ADT
diferentes siendo un ejemplo de herencia múltiple. Esto es, el ADT secuencia
hereda métodos de tres “super” tipos de datos abstractos. En otras palabras,
sus métodos incluyen la unión de los métodos de estos super ADT. Ver el
listado 6.13 para una especificación Java del ADT como una interfaz Java.
1 /* *
2 * Una interfaz para una secuecia , una estructura de datos que
3 * soporta todas las operaciones de un deque , lista indizada y
4 * lista posici ó n .
5 */
6 public interface Secuencia <E >
7 extends Deque <E > , ListaIndice <E > , ListaPosicion <E > {
8 /* * Regresar la posici ó n conteniendo el elemento en el ı́ ndice dado . */
9 public Posicion <E > atIndex ( int r ) throws B o u n d a r y V i o l a t i o n E x c e p t i o n ;
10 /* * Regresar el ı́ ndice del elemento guardado en la posici ó n dada . */
11 public int indexOf ( Posicion <E > p ) throws I n v a l i d P o s i t i o n E x c e p t i o n ;
12 }
Listado 6.13: La interfaz Secuencia definida por herencia múltiple por las interfaces
Deque, ListaIndice, y ListaPosicion y agregando los dos métodos puente.
Secuencia implementada con una lista ligada

Suponiendo que se implementa una secuencia con una lista doblemen-
te enlazada, la cual, como se indica en la documentación para la clase
java.util.LinkedList, es la implementación para esta clase. Con esta im-

plementación, todos los métodos de actualización basados en posición se
ejecutan en tiempo O(1) cada uno. De igual forma, todos los métodos del
ADT deque corren en tiempo O(1), ya que sólo se requiere actualizar o acceder
la lista en sus extremos. Pero los métodos del ADT lista arreglo, los cuales
están incluidos en la clase java.util.LinkedList, no son muy adecuados
para una implementación de una secuencia con una lista doblemente enlazada.
Balance de eficiencia en una secuencia con lista enlazada
Como una lista enlazada no permite acceso indizado a sus elementos, reali-
zar la operación get(i), para regresar el elemento en un ı́ndice i dado, requiere
que se hagan “saltos” desde uno de los extremos de la lista, incrementando
o decrementando, hasta que se ubique el nodo que guarda el elemento con
ı́ndice i. Como una leve optimización, se puede iniciar saltando del extremo
más cercano de la lista, logrando ası́ el siguiente tiempo de ejecución
O(mı́n(i + 1, n − i))
donde n es el número de elementos en la lista. El peor caso de este tipo de

búsquedas ocurre cuando
r = bn/2c
Por lo tanto, el tiempo de ejecución todavı́a es O(n).

Las operaciones add(i, e) y remove(i) también deben hacer saltos para
ubicar el nodo que guarda el elemento con ı́ndice i, y entonces insertar o
borrar un nodo. Los tiempos de ejecución de estas implementaciones son
también
O(mı́n(i + 1, n − i + 1))
lo cual es O(n). Una ventaja de esta aproximación es que, si i = 0 o i = n − 1,

como en el caso de la adaptación del ADT lista arreglo para el ADT deque dado
en la sección 6.1.2, entonces estos métodos se ejecutan en tiempo O(1). Pero,
en general, usar métodos lista arreglo con un objeto java.util.LinkedList
es ineficiente.
Secuencia implementada con un arreglo

Supóngase que se quiere implementar la secuencia S guardando cada
elemento e de S en una celda A[i] de un arreglo A. Se puede definir un
objeto posición p para guardar un ı́ndice i y una referencia al arreglo A, como
variables de instancia en este caso. Entonces se puede implementar el método
elemento(p) para regresar A[i]. Una desventaja importante es que las celdas
en A no tendrán forma de referirse a su correspondiente posición. Ası́, después
de realizar la operación addFirst, no se tiene forma de avisar a las posiciones
existentes en S que cada uno de sus ı́ndices se debe incrementar en uno (las
posiciones en una secuencia están definidas relativamente a las posiciones
vecinas, no a los ı́ndices). Por lo tanto, si se implementa una secuencia con
un arreglo, se necesita una aproximación diferente.
Considerar una solución alterna en la cual, en vez de guardar los elementos
de S en el arreglo A, se guarda un nuevo tipo de objeto posición en cada
celda de A, y se guardan los elementos en las posiciones. El nuevo objeto
posición p guarda el ı́ndice i y el elemento asociado con p.
Con esta estructura de datos, ilustrada en la figura 6.7, se puede buscar a
través del arreglo para actualizar la variable ı́ndice i para cada posición cuyo
ı́ndice cambie debido a una inserción o borrado.
Figura 6.7: Una implementación basada en un arreglo del ADT secuencia.
Balance de eficiencia en una secuencia con arreglo

En esta implementación usando un arreglo para una secuencia, los métodos
addFirst, addBefore, addAfter, y remove toman tiempo O(n), por que se
tienen que desplazar objetos posición para hacer espacio para la nueva posición,
6.5 Ejemplo: Heurı́stica mover al frente 235
o para llenar el espacio creado por la remoción de una vieja posición, como
en los métodos insertar y remover basados en ı́ndice. Todos los otros métodos
basados en la posición toman tiempo O(1).
6.5. Ejemplo: Heurı́stica mover al frente

Supóngase que se desea mantener una colección de elementos además de
saber el número de veces que cada elemento es accedido. Conocer el número de
accesos permite, por ejemplo, conocer cuales son los primeros diez elementos
más populares. Ejemplos de tales escenarios incluyen los navegadores Web
que mantienen un registro de las direcciones Web más populares visitadas
por un usuario o un programa álbum de fotos que mantiene una lista de
las imágenes más populares que un usuario ve. Adicionalmente, una lista de
favoritos podrı́a ser usada en una interfaz gráfica para conocer las acciones
más populares de un menú desplegable, para después presentar al usuario un
menú condensando conteniendo sólo las opciones más populares.
Se considera en esta sección como se puede implementar el ADT lista de
favoritos, el cual soporta los métodos size() e isEmpty() además de los
siguientes:
access(e):acceder el elemento e e incrementar su cuenta de

acceso, o agregarlo a la lista de favoritos, si todavı́a
no estaba presente.
remove(e):quitar el elemento e de la lista de favoritos, dado
que este se encuentre.
top():regresar un colección iterable de los k elementos
más accedidos.
6.5.1. Implementación con una lista ordenada y una

clase anidada
La primera implementación de una lista de favoritos que se considera (lista-
do 6.14) es construyendo una clase, ListaFavoritos, guardando referencias a
los objectos accesados en una lista ligada ordenada de forma decreciente, por
la cantidad de accesos. La clase usa una caracterı́stica de Java que permite
definir una clase anidada y relacionada dentro de la definición de una clase. Tal
clase anidada deberá ser declarada static, para indicar que esta definición
está relacionada a la clase que la contiene, y no a una instancia especifica

de esa clase. Mediante clases anidadas se pueden definir clases de “ayuda” o
“soporte” que pueden ser protegidas de uso externo.
La clase anidada, Entrada, guarda para cada elemento e en la lista, un
par (c, v), donde c es la cuenta de accesos para e y v es una referencia valor
al propio elemento e. Cada vez que un elemento es accedido, se busca este
en la liga ligada (agregándolo si todavı́a no está) e incrementando su cuenta
de acceso. Remover un elemento requiere encontralo y quitarlo de la lista
ligada. Devolver los k elementos más accedidos involucra copiar los valores de
entrada en un lista de salida de acuerdo a su orden en lista ligada interna.
1 /* * Lista de elementos favoritos , con sus cuentas de acceso . */
2 public class ListaFavoritos <E > {
3 protected ListaPosicion < Entrada <E > > listaF ; // lista de entradas
4 /* * Constructor ; tiempo O (1) */
5 public Lista Favorit os () {
6 listaF = new ListaNodoPosicion < Entrada <E > >();
7 }
8 /* * Regresa el ùnmero de elementos en la lista ; tiempo O (1). */
9 public int size () { return listaF . size (); }
10 /* * Prueba si la lista est á vac ı́ a ; tiempo O (1) */
11 public boolean isEmpty () { return listaF . isEmpty (); }
12 /* * Quitar un elemento dado , dado que esta en la lista ; tiempo O ( n ) */
13 public void remove ( E obj ) {
14 Posicion < Entrada <E > > p = encontrar ( obj ); // b ú squeda de obj
15 if ( p != null )
16 listaF . remove ( p ); // quitar la entrada
17 }
18 /* * Incrementar la cuenta de accesos para el elemento dado y lo inserta
19 * si todav ı́ a no est á presente ; tiempo O ( n ) */
20 public void access ( E obj ) {
21 Posicion < Entrada <E > > p = encontrar ( obj ); // b ú squeda de obj
22 if ( p != null )
23 p . elemento (). i n c r e m e n t a r C u e n t a (); // incrementar cuenta de acceso
24 else {
25 listaF . addLast ( new Entrada <E >( obj )); // agregar la entrada al final
26 p = listaF . last ();
27 }
28 moverArriba ( p );
29 }
30 /* * Encontar la posici ó n de un elemento dado , o regresar null ; tiempo O ( n ) */
31 protected Posicion < Entrada <E > > encontrar ( E obj ) {
32 for ( Posicion < Entrada <E > > p : listaF . positions ())
33 if ( valor ( p ). equals ( obj ))
34 return p ; // encontrado en posici ó n p
35 return null ; // no encontrado
36 }
37 protected void moverArriba ( Posicion < Entrada <E > > cur ) {
38 Entrada <E > e = cur . elemento ();
39 int c = cuenta ( cur );
40 while ( cur != listaF . first () ) {
41 Posicion < Entrada <E > > prev = listaF . prev ( cur ); // posici ó n previa
42 if ( c <= cuenta ( prev ) ) break ; // entrada en su posic ó n correcta
43 listaF . set ( cur , prev . elemento ()); // descender la entrada previa

44 cur = prev ;
45 }
46 listaF . set ( cur , e ); // guardar la entrada en su posici ó n final
47 }
48 /* * Regresa los k elementos m á s accedidos , para un k ; tiempo O ( k ) */
49 public Iterable <E > top ( int k ) {
50 if ( k <0 || k > size () )
51 throw new I l l e g a l A r g u m e n t E x c e p t i o n ( " Argumento inv á lido " );
52 ListaPosicion <E > T = new ListaNodoPosicion <E >(); // lista top - k
53 int i =0; // contador de las entradas agregadas a la lista
54 for ( Entrada <E > e : listaF ) {
55 if ( i ++ >= k )
56 break ; // todas las k entradas han sido agregadas
57 T . addLast ( e . valor () ); // agregar una entrada a la lista
58 }
59 return T ;
60 }
61 /* * Representaci ó n String de lista de favoritos */
62 public String toString () { return listaF . toString (); }
63 /* * M é todo auxiliar que extrae el valor de la entrada en una posici ó n */
64 protected E valor ( Posicion < Entrada <E > > p ) { return p . elemento (). valor (); }
65 /* * M é todo auxiliar que extrae el contador de la entrada en una pos . */
66 protected int cuenta ( Posicion < Entrada <E > > p ) { return p . elemento (). cuenta (); }
67
68 /* * Clase interna para guardar elementos y sus cuentas de acceso . */
69 protected static class Entrada <E > {
70 private E valor ; // elemento
71 private int cuenta ; // cuenta de accesos
73 Entrada ( E v ) {
74 cuenta = 1;
75 valor = v ;
76 }
77 /* * Regresar el elemento */
78 public E valor () { return valor ; }
79 public int cuenta () { return cuenta ; }
80 public int i n c r e m e n t a r C u e n t a () { return ++ cuenta ; }
81 public String toString () { return " [ " + cuenta + " ," + valor + " ] " ; }
82 }
83 } // Fin de la clase Li staFavo ritos
Listado 6.14: La clase ListaFavoritos que incluye una clase anidada, Entrada, la
cual representa los elementos y su contador de accesos
6.5.2. Lista con heurı́stica mover al frente

La implementación previa de la lista de favoritos hace el método access(e)
en tiempo proporcional al ı́ndice de e en la lista de favoritos, es decir, si e es
el k-ésimo elemento más popular en la lista, entonces accederlo toma tiempo
O(k). En varias secuencias de acceso de la vida real, es común, que una vez
que el elemento es accedido, es muy probable que sea accedido otra vez en el
futuro cercano. Se dice que tales escenarios poseen localidad de referencia.
Una heurı́stica, o regla de oro, que intenta tomar ventaja de la localidad
de referencia que está presente en una secuencia de acceso es la heurı́stica
mover al frente. Para aplicar esta huerı́stica, cada vez que se accede un
elemento se mueve al frente de la lista. La esperanza es que este elemento sea
accedido otra vez en el futuro cercano. Por ejemplo, considerar un escenario
en el cual se tienen n elementos donde cada elemento es accedido n veces, en
el siguiente orden: se accede el primer elemento n veces, luego el segundo n
veces, y ası́ hasta que el n-ésimo elemento se accede n veces.
Si se guardan los elementos ordenados por la cantidad de accesos, e
insertando cada elemento la primera vez que es accedido, entonces:
cada acceso al elemento 1 se ejecuta en tiempo O(1);
...
cada acceso al elemento n se ejecuta en tiempo O(n);
Ası́, el tiempo total para realizar las series de accesos es proporcional a
n + 2n + 3n + . . . + nn = n(1 + 2 + 3 + . . . + n) = n · n(n + 1)/2
lo cual es O(n3 ).
Por otra parte, si se emplea la heurı́stica mover al frente, insertando cada
elemento la primera vez, entonces
...
cada acceso al elemento n se ejecuta en tiempo O(1);
Por lo que el tiempo de ejecución para realizar todos los accesos en este
caso es O(n2 ). Ası́, la implementación mover al frente tiene tiempos de acceso
más rápidos para este escenario. Sin embargo este beneficio vien a un costo.
Implementación de la heurı́stica mover al frente

En el listado 6.15 se da una implementación de una lista de favoritos usando
la heurı́stica mover al frente, definiendo una nueva clase ListaFavoritosMF, la
cual extiende a la clase ListaFavoritos y entonces se anulan las definiciones
de los métodos moverArriba y top. El método moverArriba en este caso
quita el elemento accedido de su posición frente en la lista ligada y la inserta
de regreso en la lista en el frente. El método top, por otra parte, es más
complicado.
1 /* * Lista de elementos favoritos con la heur ı́ stica mover al frente */
2 public class ListaFavoritosMF <E > extends ListaFavoritos <E >{
4 public L i s t aF a v o r i t o s M F () { }
5 /* * Mueve una entrada a la primera posici ó n : tiempo O (1) */
6 protected void moverArriba ( Posicion < Entrada <E > > pos ) {
7 listaF . addFirst ( listaF . remove ( pos ));
8 }
9 /* * Regresa los k elementos m á s accedidos , para un k ; tiempo O ( k ) */
10 public Iterable <E > top ( int k ) {
11 if ( k <0 || k > size () )
12 throw new I l l e g a l A r g u m e n t E x c e p t i o n ( " Argumento inv á lido " );
13 ListaPosicion <E > T = new ListaNodoPosicion <E >(); // lista top - k
14 if ( ! isEmpty () ){
15 // copiar las entradas en una lista temporal C
16 ListaPosicion < Entrada <E > > C = new ListaNodoPosicion < Entrada <E > >();
17 for ( Entrada <E > e : listaF )
18 C . addLast ( e );
19 // encontrar los top k elementos , uno a la vez
20 for ( int i =0; i < k ; i ++) {
21 Posicion < Entrada <E > > posMax = null ; // posici ó n de la entrada sup .
22 int cuentaMax = -1; // cuenta de accesos de la entrada top
23 for ( Posicion < Entrada <E > > p : C . positions ()) {
24 // examinar todas las entradas de C
25 int c = cuenta ( p );
26 if ( c > cuentaMax ) { // encontr ó una entrada con una cuenta mayor
27 cuentaMax = c ;
28 posMax = p ;
29 }
30 }
31 T . addLast ( valor ( posMax ) ); // agregar entrada top a T
32 C . remove ( posMax ); // quitar la posici ó n que ya fue agregada
33 }
34 }
35 return T ;
36 }
37 } // Fin de la clase L i s t a F a v o r i t o s M F
Listado 6.15: La clase ListaFavoritosMF implementa la heurı́stica mover al frente.

Esta clase extiende a la clase ListaFavoritos y anula los métodos moverArriba
y top.
El listado 6.16 muestra una aplicación que crea dos listas de favoritos,
una usa la clase ListaFavoritos y la otra ListaFavoritosMF. Las listas de
favoritos son construidas usando un arreglo de direcciones Web, y después se
generan 20 números pseudoaleatorios que están en el rango de 0 al tamaño
del arreglo menos uno. Cada vez que se marca un acceso se muestra el estado
de las listas. Posteriormente se obtiene, de cada lista, el top del tamaño de la
lista. Con el sitio más popular de la 1a lista se abre en una ventana.
1 import java . io .*;
2 import javax . swing .*;
3 import java . awt .*;
4 import java . net .*;
6 /* * Programa ejemplo para las clases List aFavorit os y L i s t a F a v o r i t o s M F */
7 public class P r o b a d o r F a v o r i t o s {
9 String [] arregloURL = { " http :// google . com " ," http :// mit . edu " ,
10 " http :// bing . com " ," http :// yahoo . com " ," http :// unam . mx " };
11 ListaFavoritos < String > L1 = new ListaFavoritos < String >();
12 ListaFavoritosMF < String > L2 = new ListaFavoritosMF < String >();
13 int n = 20; // cantidad de operaciones de acceso
14 // Escenario de simulaci ó n : acceder n veces un URL aleatorio
15 Random rand = new Random ();
16 for ( int k =0; k < n ; k ++) {
17 System . out . println ( " _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ " );
18 int i = rand . nextInt ( arregloURL . length ); // ı́ ndice aleatorio
19 String url = arregloURL [ i ];
20 System . out . println ( " Accediendo : " + url );
21 L1 . access ( url );
22 System . out . println ( " L1 = " + L1 );
23 L2 . access ( url );
24 System . out . println ( " L2 = " + L2 );
25 }
26 int t = L1 . size ()/2;
27 System . out . println ( " - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - " );
28 System . out . println ( " Top " + t + " en L1 = " + L1 . top ( t ));
29 System . out . println ( " Top " + t + " en L2 = " + L2 . top ( t ));
30 // Mostrar una ventana navegador del URL m á s popular de L1
31 try {
32 String popular = L1 . top (1). iterator (). next (); // el m á s popular
33 JEditorPane jep = new JEditorPane ( popular );
34 jep . setEditable ( false );
35 JFrame frame = new JFrame ( " URL m á s popular en L1 : " + popular );
36 frame . getCo ntentPa ne (). add ( new JScrollPane ( jep ) , BorderLayout . CENTER );
37 frame . setSize (640 ,480);
38 frame . setVisible ( true );
39 frame . s e t D e f a u l t C l o s e O p e r a t i o n ( JFrame . EXIT_ON_CLOSE );
40 } catch ( IOException e ) { /* ignorar excepciones I / O */ }
41 }
42 }
Listado 6.16: ProbadorFavoritos usa ListaFavoritos y ListaFavoritosMF para

contar la simulación de accesos a páginas Web y mostrar la más popular.
El compromiso con la heurı́stica mover al frente

La lista de favoritos no será mantenida en orden por la cantidad de accesos,
cuando se pide encontrar los k elementos más accedidos, se necesita buscarlos.
Se puede implementar el método top(k) como sigue:
1. Se copian las entradas de la lista de favoritos en otra lista, C, y se crea

una lista vacı́a, A.
2. La lista C se explora k veces. En cada ocasión, se encuentra una entrada

de C con la cuenta de acceso más grande, quitando esta entrada de C,
e insertando su valor al final de A.
3. Se regresa la lista A.
La implementación del método top() toma tiempo O(kn). Ası́, cuando

k es una constante, el método se ejecuta en tiempo O(n). Esto ocurre si se
quiere obtener la lista del top-ten. Sin embargo, si k es proporcional a n,
entonces la ejecución toma tiempo O(n2 ) y sucede cuando se quiere la lista
del top 25 %.
Capı́tulo 7
Árboles
7.1. Árboles generales

En este capı́tulo, se discute una de las estructuras de datos no lineal
más importante en computación—árboles. Las estructuras árbol son además
un progreso en la organización de datos, ya que permiten implementar un
conjunto de algoritmos más rápidos que cuando se usan estructuras lineales
de datos, como una lista. Los árboles también dan una organización natural
para datos, y por lo tanto, se han convertido en estructuras indispensables
en sistemas de archivos, interfaces gráficas de usuario, bases de datos, sitios
Web, y otros sistemas de cómputo.
Cuando se dice que los árboles “no son lineales”, se hace referencia a
una relación organizacional que es más rica que las relaciones simples “antes”
y “después” entre objetos en secuencias. Las relaciones en un árbol son
jerárquicas, con algunos objetos estando “encima” y algunos otros “abajo”.
Actualmente, la terminologı́a principal para estructuras de dato árbol viene
de los árboles genealógicos, con los términos “padre”, “hijo”, “ancestro”,
y “descendiente” siendo las palabras más comunes usadas para describir
relaciones.
7.1.1. Definiciones de árboles y propiedades

Un árbol es un tipo de dato abstracto que guarda elementos jerárquica-
mente. Con la excepción del elemento cima, cada elemento en un árbol tiene
un elemento padre y cero o mas elementos hijos. Un árbol es visualizado
colocando elementos dentro de óvalos o rectángulos, y dibujando las conexio-
244 Árboles
nes entre padres e hijos con lı́neas rectas, ver figura 7.1. Se llama al elemento
cima la raı́z del árbol, pero este es dibujado como el elemento más alto, con
los otros elementos estando conectados abajo, justo lo opuesto a un árbol
vivo.
Figura 7.1: Árbol con 17 nodos para representar la organización de una corporación.
Definición formal de árbol
Se define un árbol A como un conjunto de nodos guardando elementos

tal que los nodos tienen una relación padre-hijo, satisfaciendo las siguientes
propiedades:
Si A no está vacı́o, este tiene un nodo especial, llamado la raı́z, o root,

de A, que no tiene padre.
Cada nodo v de A diferente de la raı́z tiene un nodo padre único w;

cada nodo con padre w es un hijo de w.
7.1 Árboles generales 245
De acuerdo a la definición, un árbol puede estar vacı́o, es decir, no tener

nodos. Esta convención también permite definir un árbol recursivamente, tal
que un árbol A está vacı́o o consiste de un nodo r, llamado la raı́z de A, y un
conjunto de árboles, posiblemente vacı́o, cuyas raı́ces son los hijos de r.
Dos nodos que son hijos del mismo padre son hermanos. Un nodo v es
externo si v no tiene hijos. Un nodo v es interno si este tiene uno o más
hijos. Los nodos externos son también conocidos como hojas.
Ejemplo 7.1. En la mayorı́a de los sistemas operativos, los archivos son
organizados jerárquicamente en directorios anidados, también conocidos como
carpetas, los cuales son presentados al usuario en la forma de un árbol, ver
figura 7.2. Más especı́ficamente, los nodos internos del árbol están asociados
con directorios y los nodos externos están asociados con archivos regulares.
En el sistema operativo UNIX. la raı́z del árbol es llamada el “directorio raı́z”,
y es representada por el sı́mbolo “/”.
Figura 7.2: Representación de árbol de una porción de un sistema de archivos.
Un nodo u es un ancestro de un nodo v si u = v o u es un ancestro del

padre de v. A la inversa, se dice que un nodo v es un descendiente de un
nodo u si u es un ancestro de v. En la figura 7.2 cs252/ es un ancestro de
246 Árboles
papers/, y pr3 es un descendiente de cs016/. El subárbol enraı́zado de

A en un nodo v es el árbol consistente de todos los descendientes de v en
A, incluyendo al propio v. En la figura 7.2, el subárbol enraizado en cs016/
consiste de los nodos cs016/, grades, homeworks/, programs/, hw1, hw2,
hw3, pr1, pr2 y pr3.
Aristas y caminos en árboles
Una arista del árbol A es un par de nodos (u, v) tal que u es el padre de
v, o viceversa. Un camino de A es una secuencia de nodos tal que dos nodos
consecutivos cualesquiera en la secuencia forman una arista. Por ejemplo, el
árbol de la figura 7.2 contiene el camino cs016/programs/pr2.
Ejemplo 7.2. La relación de herencia entre clases en un programa Java
forman un árbol. La raı́z, java.lang.Object, es un ancestro de todas las otras
clases. Cada clase, C, es una descendiente de esta raı́z y es la raı́z de un
subárbol de las clases que extienden a C. Ası́, hay un camino de C a la raı́z,
java.lang.Object, en este árbol de herencia.
Árboles ordenados
Si hay un ordenamiento lineal definido para los hijos de cada nodo en

un árbol, es un árbol ordenado; esto es, se puede identificar los hijos de
un nodo como el primero, el segundo, el tercero, etc. Tal ordenamiento es
visualizado arreglando los hermanos de izquierda a derecha, de acuerdo a su
ordenamiento. Los árboles ordenados indican el orden lineal entre hermanos
listándolos en el orden correcto.
Ejemplo 7.3. Los componentes de un documento estructurado, tal como un
libro, están jerárquicamente organizados como un árbol cuyos nodos internos
son partes, capı́tulos, y secciones, y cuyos nodos externos son párrafos, tablas,
figuras, etcétera, ver figura 7.3. La raı́z del árbol corresponde al propio libro.
Se podrı́a considerar expandir más el árbol para mostrar párrafos consistentes
de sentencias, sentencias consistentes de palabras, y palabras consistentes
de caracteres. Tal árbol es un ejemplo de un árbol ordenado, porque hay un
ordenamiento bien definido entre los hijos de cada nodo.
Figura 7.3: Un árbol ordenado asociado con un libro.
7.1.2. El tipo de dato abstracto árbol

El ADT árbol guarda elementos en posiciones, las cuales, al igual que las
posiciones en una lista, están definidas relativamente a posiciones vecinales.
Las posiciones en un árbol son sus nodos y las posiciones vecinales satisfa-
cen las relaciones padre-hijo que definen un árbol válido. Por lo tanto, se usan
los términos “posición” y “nodo” indistintamente para árboles. Al igual que
con una lista posición, un objeto posición para un árbol soporta el método:
elemento():regresa el objeto guardado en esta posición.
Sin embargo, las posiciones nodo en un árbol tienen una funcionalidad

mayor, ya que hay métodos accesores del ADT árbol que aceptan y regresan
posiciones, como las siguientes:
root():regresa la raı́z del árbol; un error ocurre si el árbol

está vacı́o.
parent(v):regresa el padre de v; un error ocurre si v es la
raı́z.
children(v):regresa una colección iterable que lleva los hijos
del nodo v.
Si un árbol A está ordenado, entonces la colección iterable, children(v),

guarda los hijos de v en orden. Si v es un nodo externo, entonces children(v)
está vacı́o.
248 Árboles
Además de los métodos accesores fundamentales previos, también se

incluyen los siguientes métodos de consulta:
isInternal(v):indica si el nodo v es interno.

isExternal(v):indica si el nodo v es externo.
isRoot(v):indica si el nodo v es la raı́z.
Estos métodos hacen la programación con árboles más fácil y más legible,
ya que pueden ser usados en las condiciones de las sentencias if y de los ciclos
while, en vez de usar un condicional no intuitivo.
Hay también un número de métodos genéricos que un árbol probablemente
podrı́a soportar y que no están necesariamente relacionados con la estructura
del árbol, incluyendo los siguientes:
size():regresa la cantidad de nodos en el árbol.

isEmpty():valida si el árbol no tiene nodos.
iterator():regresa un iterador de todos los elementos guarda-
dos en nodos del árbol.
positions():regresa una colección iterable de todos los nodos
del árbol.
replace(v, e):regresa el elemento del nodo v antes de cambiarlo
por e.
Cualquier método que tome una posición como un argumento podrı́a

generar una condición de error si esa posición es no válida. No se definen
métodos de actualización especializados para árboles. En su lugar, se describen
métodos de actualización diferentes de acuerdo con las aplicaciones especı́ficas
de árboles.
7.1.3. Interfaz del ADT árbol

La interfaz Java mostrada en el listado 7.1 representa el ADT árbol.
Las condiciones de error son manejadas como sigue: cada método puede
tomar una posición como un argumento, estos métodos podrı́an lanzar
InvalidPositionException para indicar que la posición es inválida. El
método parent() lanza BoundaryViolationException si este es llamado
sobre un árbol vacı́o. El método root() lanza EmptyTreeException si es
llamado con un árbol vacı́o.

2 /* *
3 * Una interfaz para un á rbol donde los nodos pueden tener
4 * una cantidad arbitraria de hijos .
5 */
6 public interface Tree <E > {
7 /* * Regresa el n ú mero de nodos en el á rbol . */
9 /* * Valida si el á rbol est á vac ı́ o . */
11 /* * Regresa un iterador de los elementos guardados en el á rbol . */
13 /* * Regresa una colecci ó n iterable de los nodos . */
15 /* * Reemplaza el elemento guardado en un nodo dado . */
16 public E replace ( Posicion <E > v , E e )
18 /* * Regresa la ra ı́ z del á rbol . */
19 public Posicion <E > root () throws E m p t y T r e e E x c e p t i o n ;
20 /* * Regresa el padre de un nodo dado . */
21 public Posicion <E > parent ( Posicion <E > v )
23 /* * Regresa una colecci ó n iterable de los hijos de un nodo dado . */
24 public Iterable < Posicion <E > > children ( Posicion <E > v )
26 /* * Valida si un nodo dado es interno . */
27 public boolean isInternal ( Posicion <E > v )
29 /* * Valida si un nodo dado es externo . */
30 public boolean isExternal ( Posicion <E > v )
32 /* * Valida si un nodo dado es la ra ı́ z del á rbol . */
33 public boolean isRoot ( Posicion <E > v )
35 }
Listado 7.1: Interfaz Java Tree para representar el ADT árbol. Métodos adicionales
de actualización podrı́an ser agregados dependiendo de la aplicación.
Una estructura enlazada para árboles generales

Una forma natural para crear un árbol A es usar una estructura enlaza-
da, donde se representa cada nodo v de A por un objeto posición, ver figura
7.4 (a), con los siguientes campos: una referencia al elemento guardado en v,
un enlace al padre de v, y algún tipo de colección, por ejemplo, una lista o
arreglo, para guardar enlaces a los hijos de v. Si v es la raı́z de A entonces el
campo parent de v es null. También, se guarda una referencia a la raı́z de
A y el número de nodos de A en variables internas. Se muestra en la figura
7.4 (b) la estructura esquemáticamente.
250 Árboles
Figura 7.4: La estructura enlazada para un árbol general: (a) el objeto posición
asociado con un nodo; (b) la porción de la estructura de dato asociada con un nodo
y sus hijos.
La tabla 7.1 resume el rendimiento de la implementación de un árbol

general usando una estructura enlazada. Se observa que usando una colección
para guardar los hijos de cada nodo v, se puede implementar children(v)
regresando una referencia a esta colección.
Operación Tiempo
size(), isEmpty() O(1)
iterator(), positions() O(n)
replace() O(1)
root(), parent() O(1)
children(v) O(cv )
isInternal(), isExternal(), isRoot() O(1)
Cuadro 7.1: Tiempos de ejecución de los métodos de un árbol general de n-nodos

con una estructura enlazada. cv denota el número de hijos de un nodo v. El espacio
usado es O(n).
7.2 Algoritmos de recorrido para árboles 251
7.2. Algoritmos de recorrido para árboles

En esta sección, se presentan algoritmos para hacer recorridos en un árbol
accediendo este a través de los métodos del ADT árbol.
7.2.1. Profundidad y altura

Sea v un nodo de un árbol A. La profundidad de v es el número de ances-
tros de v, excluyendo al propio v. Esta definición implica que la profundidad
de la raı́z de A es cero.
La profundidad de un nodo v también puede ser definida recursivamente
como sigue:
Si v es la raı́z, entonces la profundidad de v es cero.
De otra forma, la profundidad de v es uno mas la profundidad del padre

de v.
Usando la definición previa se presenta un algoritmo recursivo simple,

depth para calcular la profundidad de un nodo v de A. Este método se llama
a sı́ mismo recursivamente en el padre de v, y agrega uno al valor regresado.
Algoritmo depth(A, v):
si v es la raı́z de A entonces
regresar 0
si no
regresar 1+depth(A, w), donde w es el padre de v en A
Una implementación Java simple de este algoritmo se da en el listado 7.2.
1 public static <E > int depth ( Tree <E > T , Posicion <E > v ) {
2 if ( T . isRoot ( v ) )
3 return 0;
4 else
5 return 1 + depth (T , T . parent ( v ) );
6 }
Listado 7.2: El método depth() escrito en Java.
El tiempo de ejecución del algoritmo depth(A, v) es O(dv ), donde dv

denota la profundidad del nodo v en el árbol A, porque el algoritmo realiza
un paso recursivo tiempo constante para cada ancestro de v. Ası́, el algoritmo
depth(A, v) se ejecuta en tiempo O(n) en el peor caso, donde n es el número
total de nodos de A, ya que un nodo de A podrı́a tener profundidad n − 1 en
252 Árboles
el peor caso. Aunque tal tiempo de ejecución es una función del tamaño de
entrada, es más preciso caracterizar el tiempo de ejecución en términos del
parámetro dv , debido a que este parámetro puede ser mucho menor que n.
Altura
La altura de un nodo v en un árbol A se puede definir también recursiva-
mente:
Si v es un nodo externo, entonces la altura de v es cero.
De otra forma, la altura de v es uno más la altura máxima de los hijos

de v.
La altura de un árbol no vacı́o A es la altura de la raı́z de A. Por

ejemplo, el árbol de la figura 7.1 tiene altura 4. Además la altura puede
también ser definida como sigue.
Proposición 7.1: La altura de un árbol no vacı́o A es igual a la máxima
profundidad de un nodo externo de A.
El algoritmo height1() calcula la altura de un árbol no vacı́o A usando
la proposición anterior y el algoritmo depth. El listado 7.3 muestra su
implementación en Java.
Algoritmo height1(A):
h←0
para cada vértice v en A hacer
si v es un nodo externo de A entonces
h ← max(h, depth(A, v))
regresar h
1 public static <E > int height1 ( Tree <E > T ) {

2 int h = 0;
3 for ( Posicion <E > v : T . positions () )
4 if ( T . isExternal ( v ) )
5 h = Math . max ( h , depth (T , v ) );
6 return h ;
7 }
Listado 7.3: Método height1(), que usa el método max() de la clase java.lang.-
Math
Desafortunadamente, el algoritmo height1 no es muy eficiente. Como

height1 llama al algoritmo depth(v) en cada nodo P externo v de A, el tiempo
de ejecución de height1 está dado por O(n + v (1 + dv )), donde n es el
número de nodos de A, dv es la profundidad del nodo v, y la suma se
Phace sólo
con el conjunto de nodos externos de A. En el peor caso, la suma v (1 + dv )
es proporcional a n2 . Ası́, el algoritmo height1 corre en tiempo O(n2 ).
El algoritmo height2, mostrado a continuación e implementado en Java
en el listado 7.4, calcula la altura del árbol A de una forma más eficiente
usando la definición recursiva de altura.
Algoritmo height2(A, v):
si v es un nodo externo de A entonces
regresar 0
si no
h←0
para cada hijo w de v en A hacer
h ← max(h,height2(A, w))
regresar h+1
1 public static <E > int height2 ( Tree <E > T , Posicion <E > v ) {
2 if ( T . isExternal ( v ) ) return 0;
3 int h = 0;
4 for ( Posicion <E > w : T . children ( v ) )
5 h = Math . max (h , height2 ( T , w ));
6 return 1 + h ;
7 }
Listado 7.4: Método height2() escrito en Java.
El algoritmo height2 es más eficiente que height1. El algoritmo es

recursivo, y, si este es inicialmente llamado con la raı́z de A, este eventualmente
será llamado con cada nodo de A. Ası́, se puede determinar el tiempo de
ejecución de este método sumando, sobre todos los nodos, la cantidad de
tiempo gastado en cada nodo. Procesar cada nodo en children(v) toma
tiempo O(cv ), donde cv es el número de hijos de un nodo v. También, el
ciclo while tiene cv iteraciones y cada iteración en el ciclo toma tiempo O(1)
más el tiempo para la llamada recursiva con un hijo de v. Ası́, el algoritmo
height2
P gasta tiempo O(1 + cv ) en cada nodo v, y su tiempo de ejecución es
O( v (1 + cv )).
Sea un árbol A con n nodos, y cv el número
P de hijos de un nodo v de A,
entonces sumando sobre los vértices en A, v cv = n − 1, ya que cada nodo
254 Árboles
de A, con la excepción de la raı́z, es un hijo de otro nodo, y ası́ contribuye

una unidad a la suma anterior.
Con el resultado anterior, el tiempo de ejecución del algoritmo height2,
cuando es llamado con la raı́z de A, es O(n), donde n es el número de nodos
de A.
7.2.2. Recorrido en preorden

Un recorrido de un árbol A es una forma sistemática de acceder, “visitar”,
todos los nodos de A. Se presenta un esquema básico de recorrido para árboles,
llamado recorrido en preorden. En la siguiente sección, se revisa otro esquema
básico de recorrido, llamado recorrido en postorden.
En un recorrido en preorden de un árbol A, la raı́z de A es visitada
primero y entonces los subárboles enraizados con sus hijos son recorridos re-
cursivamente. Si el árbol está ordenado, entonces los subárboles son recorridos
de acuerdo al orden de los hijos. La acción especı́fica asociada con la “visita”
de un nodo v depende de la aplicación de este recorrido, y podrı́a involucrar
desde incrementar un contador hasta realizar algún cálculo complejo para v.
El pseudocódigo para el recorrido en preorden del subárbol enraizado en un
nodo v se muestra enseguida.
Algoritmo preorden(A, v):
Realizar la acción “visita” para el nodo v
preorden(A, w) {recursivamente recorrer el subárbol en w}
El algoritmo de recorrido en preorden es útil para producir un ordenamiento
lineal de los nodos de un árbol donde los padres deberán estar antes que
sus hijos en el ordenamiento. Tales ordenamientos tienen varias aplicaciones
diferentes. Se comenta a continuación un ejemplo simple de tal aplicación en
el siguiente ejemplo.
Ejemplo 7.4. El recorrido en preorden del árbol asociado con un documento
examina un documento entero secuencialmente, desde el inicio hasta el fin.
Si los nodos externos son quitados antes del recorrido, entonces el recorrido
examina la tabla de contenido del documento. Ver figura 7.5.
El recorrido en preorden es también una forma eficiente para acceder a
todos los nodos de un árbol. El análisis es similar al del algoritmo height2.
En cada nodo v, la parte no recursiva del algoritmo de recorrido en preorden
requiere tiempo O(1 + cv ), donde cv es el número de hijos de v, Ası́, el tiempo
Figura 7.5: Recorrido en preorden de un árbol ordenado, donde los hijos de cada
nodo están ordenados de izquierda a derecha.
total de ejecución en el recorrido en preorden de A es O(n). También se puede

observar que cada nodo es visitado sólo una vez.
El algoritmo toStringPreorden implementado con Java, listado 7.5,
hace una impresión en preorden del subárbol de un nodo v de A, es decir,
realiza el recorrido en preorden del subárbol enraizado en v, e imprime los
elementos guardados en un nodo cuando el nodo es visitado. El método
A.children(v) regresa una colección iterable que accede a los hijos de v en
orden.
1 public static <E > String t o S t r i n g P r e o r d e n ( Tree <E > T , Posicion <E > v ) {
2 String s = v . elemento (). toString (); // acci ó n principal de visita
3 for ( Posicion <E > h : T . children ( v ))
4 s += " , " + t o S t r i n g P r e o r d en (T , h );
5 return s ;
6 }
Listado 7.5: Método toStringPreordenque hace una impresión en preorden de los

elementos en el subárbol del nodo v de A.
Hay una aplicación interesante del algoritmo de recorrido en preorden

que produce una representación de cadena de un árbol entero. Suponiendo
que para cada elemento e guardado en el árbol A, la llamada e.toString()
regresa una cadena asociada con e. La representación parentética de
cadena P (A) del árbol A definida recursivamente como sigue. Si A tiene un
sólo nodo v, entonces
P (A) = v.elemento().toString().
256 Árboles
De otra forma,
P (A) = v.elemento().toString() + “(” + P (A1 ) + “,” + · · · + “,” + P (Ak ) + “)”,
donde v es la raı́z de A y A1 , A2 , . . . , Ak son los subárboles enraizados de los
hijos de v, los cuales están dados en orden si A es un árbol ordenado.
La definición de P (A) es recursiva y el operador “+” indica la concatena-
ción de cadenas. La representación parentética del árbol de la figura 7.1 se
muestra enseguida, donde el sangrado y los espacios han sido agregados para
claridad, y además se han retirado las comas.
Electronics R’Us (
R&D
Sales (
Domestic
International (
Canada
S. America
Overseas (
Africa
Europe
Asia
Australia
)
)
)
Purchasing
Manufacturing (
TV
CD
Tuner
)
)
El método Java representacionParentetica, listado 7.6, es una varia-
ción del método toStringPreorden, listado 7.5. Está implementado por la
definición anterior para obtener una representaión parentética de cadena de
un árbol A. El método representacionParentetica hace uso del método
toString que está definido para cada objeto Java. Se puede ver a este método
como un tipo de método toString() para objetos árbol.
1 public static <E > String r e p r e s e n t a c i o n P a r e n t e t i c a (

2 Tree <E > T , Posicion <E > v ) {
3 String s = v . elemento (). toString (); // acci ó n principal de visita
4 if ( T . isInternal ( v )) {
5 Boolean primeraVez = true ;
6 for ( Posicion <E > w : T . children ( v ))
7 if ( primeraVez ) {
8 s += " ( " + r e p r e s e n t a c i o n P a r e n t e t i c a (T , w ); // 1 er hijo
9 primeraVez = false ;
10 }
11 else
12 s += " , " + r e p r e s e n t a c i o n P a r e n t e t i c a (T , w ); // hijos siguientes
13 s += " ) " ; // cerrar par é ntesis
14 }
15 return s ;
16 }
Listado 7.6: Método representacionParentetica() dónde se emplea el operador

+ para concatenar dos cadenas.
7.2.3. Recorrido en postorden

El algoritmo de recorrido en postorden puede ser visto como el opuesto
al recorrido en preorden, porque este recursivamente recorre los subárboles
enraizados en los hijos de la raı́z primero, y después visita la raı́z. Al igual que
en el recorrido en preorden se emplea el algoritmo para resolver un problema
particular especializando una acción asociada con la “visita” de un nodo v. Si
el árbol está ordenado, se hacen llamadas recursivas para los hijos de un nodo
v de acuerdo a su orden indicado. El pseudocódigo es dado a continuación.
Algoritmo postorden(A, v):
postorden(A, w) {recursivamente recorrer el subárbol en w}
El nombre de recorrido en postorden se debe a que este método de recorrido
visitará un nodo v después de que este ha visitado todos los nodos en los
subárboles enraizados en v. Ver figura 7.6.
El análisis del tiempo de ejecución del recorrido en postorden es análogo
al del recorrido en preorden. El tiempo total gastado en las porciones no
recursivas del algoritmo es proporcional al tiempo gastado en visitar los hijos
de cada nodo en el árbol. Entonces el recorrido de un árbol A con n nodos
toma tiempo O(n), suponiendo que cada visita tome tiempo O(1), ası́ el
recorrido se ejecuta en tiempo lineal.
258 Árboles
Figura 7.6: Recorrido en postorden del árbol ordenado de la figura 7.5
En el listado 7.7 se muestra el método Java toStringPostOrden() el cual

realiza un recorrido en postorden de un árbol A. Este método muestra el
elemento guardado en un nodo cuando este es visitado. Este método también
llama implı́citamente al método toString() con los elementos, cuando están
involucrados en una operación de concatenación de cadenas.
1 public static <E > String t o S t r i n g P o s t o r d e n ( Tree <E > T , Posicion <E > v ) {
2 String s = " " ;
4 s += " , " + t o St r i n g P r e o r d en (T , h )+ " " ;
5 s += v . elemento ();
6 return s ;
7 }
Listado 7.7: Método toStringPostorden que realiza una impresión en postorden

de los elementos en el subárbol del nodo v de A.
El método de recorrido en postorden es útil para resolver problemas donde

se desea calcular alguna propiedad para cada nodo v en un árbol, pero para
poder calcular esa propiedad sobre v se requiere que ya se haya calculado
esa propiedad para los hijos de v. Se muestra una aplicación en el siguiente
ejemplo.
Ejemplo 7.5. Considerar un árbol sistema de archivos A, donde los nodos
externos representan archivos y los nodos internos representan directorios.
Supóngase que se quiere calcular el espacio en disco usado en un directorio,
ver figura 7.7, lo cual es recursivamente dado por la suma de:
El tamaño del directorio propio.
Los tamaños de los archivos en el directorio.

El espacio usado por los directorios hijos.
El cálculo puede ser hecho en un recorrido en postorden del árbol A.

Después de que los subárboles de un nodo interno v han sido recorridos, se
calcula el espacio usado por v agregando el tamaño del propio directorio v y
los tamaños de los archivos contenidos en v al espacio usado por cada hijo
interno de v, el cual fue calculado por los recorridos recursivos en postorden
de los hijos de v.
Figura 7.7: El árbol de la figura 7.2 del sistema de archivos con nombre, tamaño
asociado para cada archivo o directorio dentro de cada nodo, y el espacio usado
por cada directorio encima de cada nodo interno.
Cálculo del espacio en disco
De acuerdo con el ejemplo anterior, el método espacioDisco(), mostrado

en el listado 7.8, realiza un recorrido en postorden de un árbol sistema
de archivos A, imprimiendo el nombre y el espacio usado por el directorio
asociado con cada nodo interno de A. Cuando se llama desde la raı́z de A,
espacioDisco se ejecuta en tiempo O(n), donde n es el número de nodos de
A dados que los métodos auxiliares nombre y tam toman tiempo O(1).
260 Árboles
1 public static <E > int espacioDisco ( Tree <E > T , Posicion <E > v ) {
2 int t = tam ( v ); // iniciar con el tama ~ n o del propio nodo
4 // agregar espacio calculado recurs ivament e usado por los hijos
5 t += espacioDisco (T , h );
6 if ( T . isInternal ( v ))
7 // imprimir nombre y espacio en disco usado
8 System . out . print ( nombre ( v ) + " : " + t );
9 return t ;
10 }
Listado 7.8: El método espacioDisco imprime el nombre y el espacio en disco

usado por los directorios asociados con cada nodo interno de un árbol sistema de
archivos. Los métodos auxiliares nombre y tam deben ser definidos para regresar
el nombre y el tamaño asociado con un nodo.
Otros tipos de recorridos

A pesar de que los recorridos en preorden y postorden son formas comu-
nes de visitar los nodos de un árbol, se pueden tener otros recorridos. Por
ejemplo, se podrı́a recorrer un árbol del que se visiten todos los nodos de una
profundidad p antes que se visiten los nodos en una profundidad p + 1. Este
recorrido es conocido “por niveles”. Cuando se recorren los nodos del árbol
consecutivamente numerándoles conforme se visitan se llama la numeración
por nivel de los nodos de A.
7.3. Árboles Binarios

Un árbol binario es un árbol ordenado con las siguientes propiedades:
1. Cada nodo tiene a lo más dos hijos.
2. Cada nodo hijo está etiquetado ya se como un hijo izquierdo o como un

hijo derecho.
3. Un hijo izquierdo precede a un hijo derecho en el ordenamiento de los

hijos de un nodo.
El subárbol enraizado en un hijo izquierdo o un hijo derecho de un

nodo interno v es llamado un subárbol izquierdo o subárbol derecho,
respectivamente, de v. Un árbol binario es árbol binario propio si cada
7.3 Árboles Binarios 261
nodo tiene cero o dos hijos. Algunos autores también se refieren a tales árboles
como árboles binarios árbol binario completo. Ası́, en un árbol binario
propio, cada nodo interno tiene exactamente dos hijos. Un árbol binario que
no es propio es árbol impropio.
Ejemplo 7.6. Una clase de árboles binarios se emplean en los contextos donde
se desea representar un número de diferentes salidas que pueden resultar de
contestar una serie de preguntas si o no. Cada nodo interno está asociado con
una pregunta. Iniciando en la raı́z, se va con el hijo izquierdo o derecho del
nodo actual, dependiendo de si la respuesta a la pregunta fue “Si” o “No”. Con
cada decisión, se sigue una arista desde un padre a un hijo, eventualmente
trazando un camino en el árbol desde la raı́z a un nodo externo. Tales árboles
binarios son conocidos como árboles de decisión, porque cada nodo externo
V en tal árbol representa una decisión de que hacer si la pregunta asociada con
los ancestros de v fueron contestadas en una forma que llevan a v. Un árbol de
decisión es un árbol binario propio. La figura 7.8 muestra un árbol de decisión
para mostrar en orden ascendente tres valores guardados en las variables A,
B y C, donde los nodos internos del árbol representan comparaciones y los
nodos externos representan la secuencia ordenada en forma creciente.
Figura 7.8: Un árbol de decisión para ordenar tres variables en orden creciente
Ejemplo 7.7. Una expresión aritmética puede ser representada con un árbol
binario cuyos nodos externos están asociados con variables o constantes, y
cuyos nodos internos están asociados con los operadores +, −, × y /. Ver
figura 7.9. Cada nodo en tal árbol tiene un valor asociado con este.
Si un nodo es externo, entonces su valor es aquel de su variable o

262 Árboles
constante.
Si un nodo es interno, entonces su valor está definido aplicando la
operación a los valores de sus hijos.
Un árbol de expresión aritmética es un árbol binario propio, ya que los

operadores +, −, × y / requieren exactamente dos operandos.
Figura 7.9: Un árbol binario representando la expresión aritmética ((((3 + 1) ×

3)/((9 − 5) + 2)) − ((3 × (7 − 4)) + 6)).
Definición recursiva de un árbol binario

Se puede definir un árbol binario en una forma recursiva tal que un árbol
binario está vacı́o o consiste de:
Un nodo r, llamado la raı́z de A y que guarda un elemento.
Un árbol binario, llamado el subárbol izquierdo de A.
Un árbol binario, llamado el subárbol derecho de A.
7.3.1. El ADT árbol binario

Como un tipo de dato abstracto, un árbol binario es una especialización
de un árbol que soporta cuatro métodos accesores adicionales:
left(v):Regresa el hijo izquierdo de v; una condición de

error ocurre si v no tiene hijo izquierdo.
right(v):Regresa el hijo derecho de v; una condición de
error ocurre si v no tiene hijo derecho.
hasLeft(v):Prueba si v tiene hijo izquierdo.
hasRight(v):Prueba si v tiene hijo derecho.
No se definen métodos de actualización especializados sino que se con-

sideran algunas posibles actualizaciones de métodos cuando se describan
implementaciones especı́ficas y aplicaciones de árboles binarios.
7.3.2. Una interfaz árbol binario en Java

Se modela un árbol binario como un tipo de dato abstracto que extiende el
ADT árbol y agrega los cuatro métodos especializados para un árbol binario.
En el listado 7.9, se muestra la interfaz que se define con esta aproximación.
Como los árboles binarios son árboles ordenados, la colección iterable regresada
por el método children(v), que se hereda de la interfaz Tree guarda el hijo
izquierdo de v antes que el hijo derecho.
1 /* *
2 * Una interfaz para un á rbol binario donde cada nodo tiene
3 * cero , uno o dos hijos .
4 *
5 */
6 public interface ArbolBinario <E > extends Tree <E > {
7 /* * Regresa el hijo izquierdo de un nodo . */
8 public Posicion <E > left ( Posicion <E > v )
10 /* * Regresa el hijo derecho de un nodo . */
11 public Posicion <E > right ( Posicion <E > v )
13 /* * Indica si un un nodo tiene hijo izquierdo . */
14 public boolean hasLeft ( Posicion <E > v ) throws I n v a l i d P o s i t i o n E x c e p t i o n ;
15 /* * Indica si un un nodo tiene hijo derecho . */
16 public boolean hasRight ( Posicion <E > v ) throws I n v a l i d P o s i t i o n E x c e p t i o n ;
17 }
Listado 7.9: Interfaz Java ArbolBinario para el ADT árbol binario que extiende a
Tree (listado 7.1).
264 Árboles
7.3.3. Propiedades del árbol binario

Las propiedades de los árboles binarios se relacionan con sus alturas y el
número de nodos Se denota al conjunto de todos los nodos de un árbol A
que están a la misma profundidad d como el nivel de un árbol binario de
A. Para el árbol binario, el nivel 0 tiene a lo más un nodo, la raı́z, el nivel 1
tiene a los más dos nodos, los hijos de la raı́z, el nivel 2 tiene a lo más 4 hijos,
y ası́ sucesivamente. Ver figura 7.10. En general, el nivel d tiene a lo más 2d
nodos.
Figura 7.10: Número máximo de nodos en los niveles de un árbol binario.
Se observa que el número máximo de nodos en los niveles del árbol binario
crece exponencialmente conforme se baja en el árbol. De esta observación, se
pueden derivar las siguientes propiedades de relación entre la altura de un
árbol binario A con el número de nodos.
Proposición 7.2: Sea A un árbol binario no vacı́o, y sean n, nE , nI y h el
número de nodos, número de nodos externos, numero de nodos internos, y la
altura de A, respectivamente. Entonces A tiene las siguientes propiedades:
1. h + 1 ≤ n ≤ 2h+1 − 1
2. 1 ≤ nE ≤ 2h
3. h ≤ nI ≤ 2h − 1
4. log(n + 1) − 1 ≤ h ≤ n − 1
También, si A es propio, entonces A tiene las siguientes propiedades:
1. 2h + 1 ≤ n ≤ 2h+1 − 1
2. h + 1 ≤ nE ≤ 2h
3. h ≤ nI ≤ 2h − 1
4. log(n + 1) − 1 ≤ h ≤ (n − 1)/2
También se cumple la siguiente relación entre el número de nodos internos

y los nodos externos en un árbol binario propio
nE = nI + 1.
Para mostrar lo anterior se pueden quitar los nodos de A y dividirlos en
dos “pilas”, una pila con los nodos internos y otra con los nodos externos,
hasta que A quede vacı́o. Las pilas están inicialmente vacı́as. Al final, la
pila de nodos externos tendrá un nodo más que la pila de nodos internos,
considerar dos casos:
Caso 1: Si A tiene un sólo nodo v, se quita v y se coloca en

la pila externa. Ası́, la pila de nodos externos tiene un sólo nodo
y la pila de nodos internos está vacı́a.
Caso 2: De otra forma, A tiene más de un nodo, se quita de

A un nodo externo arbitrario w y su padre v, el cual es un nodo
interno. Se coloca a w en la pila de nodos externos y v en la pila
de nodos internos. Si v tiene un padre u, entonces se reconecta u
con el ex-hermano z de w, como se muestra en la figura 7.11. Esta
operación quita un nodo interno y uno externo, y deja al árbol
como un árbol binario propio.
Se repite esta operación, hasta que eventualmente se tiene un
árbol final consistente de un sólo nodo. Entonces se quita el nodo
del árbol final se coloca en la pila externa, teniendo ası́ esta pila
un nodo más que la pila interna.
266 Árboles
Figura 7.11: Operación para quitar un nodo externo y su nodo padre, usado en la
demostración
7.3.4. Una estructura enlazada para árboles binarios

Una forma natural de realizar un árbol binario A es usar una estructura
ligada, donde se representa cada nodo v de A por un objeto Posicion, ver
figura 7.12, con los campos dando referencias al elemento guardado en v y a
objetos Posicion asociados con los hijos y el padre de v.
Si v es la raı́z de A, entonces el campo padre de v es null. También, se
guarda el número de nodos de A en la variable tam.
Implementación Java de un nodo del árbol binario

Se emplea la interfaz Java PosicionAB para representar un nodo del árbol
binario. Esta interfaz extiende Posicion, por lo que se hereda el método
elemento, y tiene métodos adicionales para poner el elemento en el nodo,
setElemento y para poner y devolver el padre, el hijo izquierdo y el hijo
derecho, como se muestra en el listado 7.10.
1 /* *
2 * Interfaz para un nodo de un á rbol binario . Esta mantiene un elemento ,
3 * un nodo padre , un nodo izquierdo , y nodo derecho .
4 *
5 */
6 public interface PosicionAB <E > extends Posicion <E > { // hereda elemento ()
7 public void setElemento ( E o );
8 public PosicionAB <E > getIzq ();
9 public void setIzq ( PosicionAB <E > v );
10 public PosicionAB <E > getDer ();
11 public void setDer ( PosicionAB <E > v );
12 public PosicionAB <E > getPadre ();
13 public void setPadre ( PosicionAB <E > v );
14 }
Listado 7.10: Interfaz Java PosicionAB para definir los métodos que permiten
acceder a los elementos de un nodo del árbol binario.
Figura 7.12: Representación de un árbol binario con estructura enlazada. (a) Diseño
del nodo; (b) Ejemplo.
268 Árboles
La clase NodoAB, listado 7.11, implementa la interfaz PosicionAB para un

objeto con los campos elemento, izq, der, y padre, lo cual, para un nodo v,
se refiere al elemento en v, el hijo izquierdo de v, el hijo derecho de v, y el
padre de v respectivamente.
1 /* *
2 * La clase implementa un nodo de un á rbol binario guardando las referencias
3 * a un elemento , un nodo padre , un nodo izquierdo , y un nodo derecho .
4 *
5 */
6 public class NodoAB <E > implements PosicionAB <E > {
7 private E elemento ; // elemento guardado en este nodo
8 private PosicionAB <E > izq , der , padre ; // nodos adyacentes
10 public NodoAB () { }
11 /* * Constructor principal */
12 public NodoAB ( E elemento , PosicionAB <E > padre ,
13 PosicionAB <E > izq , PosicionAB <E > der ) {
14 setElemento ( elemento );
15 setPadre ( padre );
16 setIzq ( izq );
17 setDer ( der );
18 }
19 /* * Regresa el elemento guardado en esta posici ó n */
20 public E elemento () { return elemento ; }
21 /* * Pone el elemento guardado en esta posici ó n */
22 public void setElemento ( E o ) { elemento = o ; }
23 /* * Regresa el hijo izquierdo de esta posici ó n */
24 public PosicionAB <E > getIzq () { return izq ; }
25 /* * Pone el hijo izquierdo de esta posici ó n */
26 public void setIzq ( PosicionAB <E > v ) { izq = v ; }
27 /* * Regresa el hijo derecho de esta posici ó n */
28 public PosicionAB <E > getDer () { return der ; }
29 /* * Pone el hijo derecho de esta posici ó n */
30 public void setDer ( PosicionAB <E > v ) { der = v ; }
31 /* * Regresa el padre de esta posici ó n */
32 public PosicionAB <E > getPadre () { return padre ; }
33 /* * Pone el padre de esta posici ó n */
34 public void setPadre ( PosicionAB <E > v ) { padre = v ; }
35 }
Listado 7.11: Clase auxiliar NodoAB para implementar los nodos del árbol binario.
Implementación Java del árbol binario enlazado

En el listado 7.12 se muestra la clase ArbolBinarioEnlazado que imple-
menta la interfaz ArbolBinario, listado 7.9, usando una estructura de datos
enlazada. Esta clase guarda el tamaño del árbol y una referencia al objeto
NodoAB asociado con la raı́z del árbol en variables internas. Adicional a los
métodos de la interfaz ArbolBinario, la clase tiene otros métodos, incluyendo
el método accesor sibling(v), el cual regresa el hermano de un nodo v, y

los siguientes métodos de actualización:
addRoot(e):Crea y regresa un nuevo nodo r que guarda el

elemento e y hace a r la raı́z del árbol, un error
ocurre si el árbol no está vacı́o.
insertLeft(v, e):Crea y regresa un nuevo nodo w que guarda a e,
agrega a w como el hijo izquierdo de v y regresa
w, un error ocurre si v ya tiene un hijo izquierdo.
insertRight(v, e):Crea y regresa un nuevo nodo w que guarda a e,
agrega a w como el hijo derecho de v y regresa w,
un error ocurre si v ya tiene un hijo derecho.
remove(v):Quita el nodo v y lo reemplaza con su hijo, si
tiene, y regresa el elemento guardado en v; un
error ocurre si v tiene dos hijos.
attach(v, T1 , T2 ):Une T1 y T2 como los subárboles izquierdo y de-

recho del nodo externo v, una condición de error
ocurre si v no es externo.
La clase ArbolBinarioEnlazado tiene un constructor sin argumentos que

regresa un árbol binario vacı́o. Iniciando con este árbol vacı́o, se puede construir
cualquier árbol binario creando el primer nodo con el método addRoot() y
aplicando repetidamente los métodos insertLeft(), insertRight() o el
método attach(). De igual forma, se puede desmantelar cualquier árbol
binario A usando la operación remove, llegando hasta un árbol binario vacı́o.
Cuando una posición v es pasado como un argumento a alguno de los
métodos de la clase ArbolBinarioEnlazado, su validez se revisa llamando un
método auxiliar de ayudo, checkPosition(v). Una lista de los nodos visitados
en un recorrido en preorden del árbol es construido por un método recursivo
preorderPositions. Las condiciones de error son indicadas lanzando excep-
ciones InvalidPositionException, BoundaryViolationException, Empty-
TreeException, y NonEmptyTreeException.
270 Árboles

2 /* *
3 * Una implementaci ó n de la interfaz ArbolBinario usando una estructura
4 * enlazada .
5 * @see ArbolBinario */
6 public class ArbolBinarioEnlazado <E > implements ArbolBinario <E > {
7 protected PosicionAB <E > raiz ; // referencia a la ra ı́ z
8 protected int tam ; // n ú mero de nodos
9 /* * Crea un á rbol binario vac ı́ o */
10 public A r b o l B i n a r i o E n l a z a d o () {
11 raiz = null ; // empezar con un á rbol binario
12 tam = 0;
13 }
14 /* * Regresa el n ú mero de nodos en el á rbol . */
16 return tam ;
17 }
18 /* * Indica si el á rbol est á vac ı́ o . */
20 return ( tam == 0);
21 }
22 /* * Indica si un nodo es interno . */
23 public boolean isInternal ( Posicion <E > v ) throws I n v a l i d P o s i t i o n E x c e p t i o n {
24 revi saPosici on ( v ); // m é todo auxiliar
25 return ( hasLeft ( v ) || hasRight ( v ));
26 }
27 /* * Indica si un nodo es externo */
28 public boolean isExternal ( Posicion <E > v ) throws I n v a l i d P o s i t i o n E x c e p t i o n {
29 return ! isInternal ( v );
30 }
31 /* * Indica si un nodo es la ra ı́ z */
32 public boolean isRoot ( Posicion <E > v ) throws I n v a l i d P o s i t i o n E x c e p t i o n {
33 revi saPosici on ( v );
34 return ( v == root ());
35 }
36 /* * Indica si un nodo tiene hijo izquierdo */
37 public boolean hasLeft ( Posicion <E > v ) throws I n v a l i d P o s i t i o n E x c e p t i o n {
38 PosicionAB <E > vv = revisaP osicion ( v );
39 return ( vv . getIzq () != null );
40 }
41 /* * Indica si un nodo tiene hijo derecho */
42 public boolean hasRight ( Posicion <E > v ) throws I n v a l i d P o s i t i o n E x c e p t i o n {
44 return ( vv . getDer () != null );
45 }
46 /* * Regresa la ra ı́ z del á rbol */
47 public Posicion <E > root () throws E m p t y T r e e E x c e p t i o n {
48 if ( raiz == null )
49 throw new E m p t y T r e e E x c e p t i o n ( " El á rbol est á vac ı́ o " );
50 return raiz ;
51 }
53 public Posicion <E > left ( Posicion <E > v )
56 Posicion <E > posIzq = vv . getIzq ();
57 if ( posIzq == null )
58 throw new B o u n d a r y V i o l a t i o n E x c e p t i o n ( " Sin hijo izquierdo " );
59 return posIzq ;
60 }
62 public Posicion <E > right ( Posicion <E > v )
65 Posicion <E > posDer = vv . getDer ();
66 if ( posDer == null )
67 throw new B o u n d a r y V i o l a t i o n E x c e p t i o n ( " Sin hijo derecho " );
68 return posDer ;
69 }
70 /* * Regresa el padre de un nodo . */
71 public Posicion <E > parent ( Posicion <E > v )
74 Posicion <E > posPadre = vv . getPadre ();
75 if ( posPadre == null )
76 throw new B o u n d a r y V i o l a t i o n E x c e p t i o n ( " Sin padre " );
77 return posPadre ;
78 }
79 /* * Regresa una colecci ó n iterable de los hijos de un nodo . */
80 public Iterable < Posicion <E > > children ( Posicion <E > v )
82 ListaPosicion < Posicion <E > > children = new ListaNodoPosicion < Posicion <E > >();
83 if ( hasLeft ( v ))
84 children . addLast ( left ( v ));
85 if ( hasRight ( v ))
86 children . addLast ( right ( v ));
87 return children ;
88 }
89 /* * Regresa una colecci ó n iterable de los nodos de un á rbol . */
90 public Iterable < Posicion <E > > positions () {
91 ListaPosicion < Posicion <E > > posiciones = new ListaNodoPosicion < Posicion <E > >();
92 if ( tam != 0)
93 p r e o r d e n P o s i c i o n e s ( root () , posiciones ); // asignar posiciones en preorden
94 return posiciones ;
95 }
96 /* * Regresar un iterado de los elementos guardados en los nodos . */
97 public Iterator <E > iterator () {
98 Iterable < Posicion <E > > posiciones = positions ();
99 ListaPosicion <E > elementos = new ListaNodoPosicion <E >();
100 for ( Posicion <E > pos : posiciones )
101 elementos . addLast ( pos . elemento ());
102 return elementos . iterator (); // Un iterador de elementos
103 }
104 /* * Reemplaza el elemento en un nodo . */
105 public E replace ( Posicion <E > v , E o )
108 E temp = v . elemento ();
109 vv . setElemento ( o );
110 return temp ;
111 }
112 // M é todos adicionales accesores
113 /* * Regresa el hermano de un nodo . */
272 Árboles
114 public Posicion <E > sibling ( Posicion <E > v )

117 PosicionAB <E > posPadre = vv . getPadre ();
118 if ( posPadre != null ) {
119 PosicionAB <E > posHermano ;
120 PosicionAB <E > posIzq = posPadre . getIzq ();
121 if ( posIzq == vv )
122 posHermano = posPadre . getDer ();
123 else
124 posHermano = posPadre . getIzq ();
125 if ( posHermano != null )
126 return posHermano ;
127 }
128 throw new B o u n d a r y V i o l a t i o n E x c e p t i o n ( " Sin hermano " );
129 }
130 // M é todos adicionales de actualizaci ó n
131 /* * Agrega un nodo ra ı́ z a un á rbol vac ı́ o */
132 public Posicion <E > addRoot ( E e ) throws N o n E m p t y T r e e E x c e p t i o n {
133 if (! isEmpty ())
134 throw new N o n E m p t y T r e e E x c e p t i o n ( " El á rbol ya tiene ra ı́ z " );
135 tam = 1;
136 raiz = creaNodo (e , null , null , null );
137 return raiz ;
138 }
139 /* * Insertar un hijo izquierdo en un nodo dado . */
140 public Posicion <E > insertLeft ( Posicion <E > v , E e )
143 Posicion <E > posIzq = vv . getIzq ();
144 if ( posIzq != null )
145 throw new I n v a l i d P o s i t i o n E x c e p t i o n ( " El nodo ya tiene hijo izquierdo " );
146 PosicionAB <E > ww = creaNodo (e , vv , null , null );
147 vv . setIzq ( ww );
148 tam ++;
149 return ww ;
150 }
151 /* * Insertar un hijo derecho en un nodo dado . */
152 public Posicion <E > insertRight ( Posicion <E > v , E e )
155 Posicion <E > posDer = vv . getDer ();
156 if ( posDer != null )
157 throw new I n v a l i d P o s i t i o n E x c e p t i o n ( " El nodo ya tiene hijo derecho " );
158 PosicionAB <E > w = creaNodo (e , vv , null , null );
159 vv . setDer ( w );
160 tam ++;
161 return w ;
162 }
163 /* * Quitar un nodo con un hijo o sin hijos . */
164 public E remove ( Posicion <E > v )
167 PosicionAB <E > posIzq = vv . getIzq ();
168 PosicionAB <E > posDer = vv . getDer ();
169 if ( posIzq != null && posDer != null )
170 throw new I n v a l i d P o s i t i o n E x c e p t i o n ( " No se puede remover nodo con dos hijos " );
171 PosicionAB <E > ww = null ; // el ú nico hijo de v , si tiene

172 if ( posIzq != null )
173 ww = posIzq ;
174 else if ( posDer != null )
175 ww = posDer ;
176 if ( vv == raiz ) { // v es la ra ı́ z entonces
177 if ( ww != null ) // hacer al hijo la nueva ra ı́ z
178 ww . setPadre ( null );
179 raiz = ww ;
180 }
181 else { // v no es la ra ı́ z
182 PosicionAB <E > uu = vv . getPadre ();
183 if ( vv == uu . getIzq ())
184 uu . setIzq ( ww );
185 else
186 uu . setDer ( ww );
187 if ( ww != null )
188 ww . setPadre ( uu );
189 }
190 tam - -;
191 return v . elemento ();
192 }
193
194 /* * Conecta dos á rboles para ser los sub á rboles de un nodo externo . */
195 public void attach ( Posicion <E > v , ArbolBinario <E > T1 , ArbolBinario <E > T2 )
198 if ( isInternal ( v ))
199 throw new I n v a l i d P o s i t i o n E x c e p t i o n ( " No se pueda conectar del nodo interno " );
200 if (! T1 . isEmpty ()) {
201 PosicionAB <E > r1 = revisaPo sicion ( T1 . root ());
202 vv . setIzq ( r1 );
203 r1 . setPadre ( vv ); // T1 deber á ser inv á lidado
204 }
205 if (! T2 . isEmpty ()) {
206 PosicionAB <E > r2 = revisaPo sicion ( T2 . root ());
207 vv . setDer ( r2 );
208 r2 . setPadre ( vv ); // T2 deber á ser inv á lidado
209 }
210 }
211 /* * Intercambiar los elementos en dos nodos */
212 public void swapElements ( Posicion <E > v , Posicion <E > w )
215 PosicionAB <E > ww = revisaP osicion ( w );
216 E temp = w . elemento ();
217 ww . setElemento ( v . elemento ());
218 vv . setElemento ( temp );
219 }
220 /* * Expandir un nodo externo en un nodo interno con dos nodos
221 * externos hijos */
222 public void ex pandExt ernal ( Posicion <E > v , E l , E r )
224 if (! isExternal ( v ))
225 throw new I n v a l i d P o s i t i o n E x c e p t i o n ( " El nodo no es externo " );
226 insertLeft (v , l );
227 insertRight (v , r );
274 Árboles
228 }
229 /* * Quitar un nodo externo v y reemplazar su padre con el hermano de v */
230 public void r e m o v e A b o v e E x t e r n a l ( Posicion <E > v )
232 if (! isExternal ( v ))
233 throw new I n v a l i d P o s i t i o n E x c e p t i o n ( " El nodo no es externo " );
234 if ( isRoot ( v ))
235 remove ( v );
236 else {
237 Posicion <E > u = parent ( v );
238 remove ( v );
239 remove ( u );
240 }
241 }
242 // M é todos auxiliares
243 /* * Si v es un nodo de un á rbol binario , convertir a PosicionAB ,
244 * si no lanzar una excepci ó n */
245 protected PosicionAB <E > re visaPosi cion ( Posicion <E > v )
247 if ( v == null || !( v instanceof PosicionAB ))
248 throw new I n v a l i d P o s i t i o n E x c e p t i o n ( " La posici ó n no es v á lida " );
249 return ( PosicionAB <E >) v ;
250 }
251 /* * Crear un nuevo nodo de un á rbol binario */
252 protected PosicionAB <E > creaNodo ( E elemento , PosicionAB <E > parent ,
253 PosicionAB <E > left , PosicionAB <E > right ) {
254 return new NodoAB <E >( elemento , parent , left , right ); }
255 /* * Crear una lista que guarda los nodos en el sub á rbol de un nodo ,
256 * ordenada de acuerdo al recorrido en preordel del sub á rbol . */
257 protected void p r e o r d en P o s i c i o n e s ( Posicion <E > v , ListaPosicion < Posicion <E > > pos )
259 pos . addLast ( v );
261 p r e o r d e n P o s i c i o n e s ( left ( v ) , pos ); // recursividad en el hijo izquierdo
263 p r e o r d e n P o s i c i o n e s ( right ( v ) , pos ); // recursividad en el hijo derecho
264 }
265 /* * Crear una lista que guarda los nodos del sub á rbol de un nodo ,
266 ordenados de acuerdo al recorrido en orden del sub á rbol . */
267 protected void p o s i c i o n e s E n o r d e n ( Posicion <E > v , ListaPosicion < Posicion <E > > pos )
270 p o s i c i o n e s E n o r d e n ( left ( v ) , pos ); // recursividad en el hijo izquierdo
271 pos . addLast ( v );
273 p o s i c i o n e s E n o r d e n ( right ( v ) , pos ); // recursividad en el hijo derecho
274 }
275 }
Listado 7.12: ArbolBinarioEnlazado el cual implementa la interfaz ArbolBinario.

Rendimiento de ArbolBinarioEnlazado
Los tiempos de ejecución de los métodos de la clase ArbolBinarioEnlazado,
el cual usa una representación de estructura enlazada, se muestran enseguida:
Los métodos size() e isEmpty() usan una variable de instancia que

guarda el número de nodos de A, y cada uno toma tiempo O(1).
Los métodos accesores root(), left(), right(), sibling(), y parent()

toman tiempo O(1).
El método replace(v, e) toma tiempo O(1).
Los métodos iterator() y positions() están implementados ha-

ciendo un recorrido en preorden del árbol, usando el método auxiliar
preordenPosiciones(). El iterador de salida es generado con el método
iterator() de la clase ListaNodoPosicion. Los métodos iterator()
y positions() toma tiempo O(n).
El método children() emplea una aproximación similar para construir

la colección iterable que se regresa, pero este corre en tiempo O(1), ya
que hay a lo más dos hijos para cualquier nodo en un árbol binario.
Los métodos de actualización insertLeft(), insertRight(), attach(),

y remove() corren en tiempo O(1), ya que involucran manipulación en
tiempo constante de un número constante de nodos.
7.3.5. Árbol binario con lista arreglo

Esta representación alterna de un árbol binario A está basado en una
forma de numerar los nodos de A. Para cada nodo v de A, sea p(v) el entero
definido como sigue:
Si v es la raı́z de A, entonces p(v) = 1.
Si v es el hijo izquierdo de un nodo u, entonces p(v) = 2p(u).
Si v es el hijo derecho de un nodo u, entonces p(v) = 2p(u) + 1.

276 Árboles
Figura 7.13: Numeración por nivel de un árbol binario: (a) esquema general; (b)
un ejemplo.
La función de numeración p se conoce como numeración de nivel de

los nodos en un árbol binario A, esta numera los nodos en cada nivel de A en
orden creciente de izquierda a derecha, pudiendo brincarse algunos números,
ver figura 7.13.
La función de numeración de nivel p sugiere una representación de un
árbol binario A por medio de una lista arreglo S tal que cada nodo v de
A es el elemento de S en el ı́ndice p(v). Como se menciono en el capı́tulo
previo, se lleva a cabo la lista arreglo S mediante un arreglo extendible, ver
sección 6.1. Tal implementación es simple y eficiente, para poder usarlo para
los métodos root(), parent(), left(), right(), hasLeft(), hasRight(),
isInternal(), isExternal(), e isRoot() usando operaciones aritméticas
sobre los números p(v) asociados con cada nodo v involucrado en la operación.
Se muestra un ejemplo de representación lista arreglo de un árbol binario
en la figura 7.14.
Figura 7.14: Representación de un árbol binario A por medio de una lista arreglo
S.
Sea n el número de nodos de A, y sea pM el valor máximo de p(v) sobre

todos los nodos de A. La lista arreglo S tiene tamaño N = pM + 1 ya que el
elemento de S en el ı́ndice 0 no está asociado con ningún nodo de A. También,
S tendrá, en general, un número de elementos vacı́os que no se refieren a
nodos existentes de A. En el peor caso, N = 2n .
Los tiempos de ejecución para un árbol binario A implementado con una
lista arreglo S, son iguales a los del árbol binario enlazado, sección 7.3.4.
278 Árboles
7.3.6. Recorrido de árboles binarios

Como en los árboles generales, los cálculos de árboles binarios involucran
recorridos. Se muestra enseguida ejemplos de recorridos que pueden ocuparse
para resolver algunos problemas.
Construcción de un árbol de expresión

Para el problema de construir un árbol de expresión de una expresión
aritmética completamente parentetizada de tamaño n se da el algoritmo
construirExpresion, suponiendo que todas las operaciones aritméticas
son binarias y las variables no están parentetizadas. Ası́, cada subexpresión
parentetizada contiene un operador en el centro. El algoritmo usa una pila P
mientras se explora la expresión de entrada E buscando variables, operadores,
y paréntesis derechos.
Cuando se ve una variable u operador x, se crea un árbol binario de un

sólo nodo A, cuya raı́z guarda a x, y se mete A a la pila.
Cuando se ve un paréntesis derecho, “)”, se sacan de la cima tres árboles

de la pila S, los cuales representan una subexpresión (E1 ◦ E2 ). Entonces
se conectan los árboles para E1 y E2 en uno para ◦, y se mete el resultado
de regreso a la pila P .
Se repite esto hasta que la expresión E ha sido procesada, en ese momento

el elemento de la cima en la pila es el árbol de expresión para E. El tiempo
total de ejecución es O(n).
Algoritmo construirExpresion(E):
Entrada: Una expresión aritmética completamente parentetizada E =
e0 , e1 , . . . , en−1 , siendo cada ei una variable, operador, o sı́mbolo paréntesis
Salida: Un árbol binario A representando la expresión aritmética E
P ← una nueva pila inicialmente vacı́a
si ei es una variable o un operador entonces
A ← un nuevo árbol binario vacı́o
A.addRoot(ei )
P.push(A)
si no si ei =0 (0 entonces
Continuar el ciclo
si no { ei =0 )0 }
A2 ← P.pop() { el árbol que representa a E2 }
A ← P.pop() { el árbol que representa a ◦ }
A1 ← P.pop() { el árbol que representa a E1 }
A.attach(A.root(), A1 , A2 )
P.push(A)
regresar P.pop()
Recorrido en preorden de un árbol binario
Como cualquier árbol binario puede ser visto como un árbol general, el
recorrido en preorden para árboles generales, sección 7.2.2, puede ser aplicado
a cualquier árbol binario y simplificado como se da a continuación.
Algoritmo preordenBinario(A, v):
si v tiene un hijo izquierdo u en A entonces
preordenBinario(A, u) { recursivamente recorrer el subárbol izquierdo }
si v tiene un hijo derecho w en A entonces
preordenBinario(A, w) { recursivamente recorrer el subárbol derecho }
Como en el caso de los árboles generales, hay varias aplicaciones de
recorrido en preorden para árboles binarios.
Recorrido en postorden de un árbol binario
De manera análoga, el recorrido en postorden para árboles generales,

sección 7.2.3, puede ser especializado para árboles binarios, como se muestra
enseguida.
Algoritmo postordenBinario(A, v):
postordenBinario(A, u) { recursivamente recorrer el subárbol izquierdo }
postordenBinario(A, w) { recursivamente recorrer el subárbol
derecho }
280 Árboles
Evaluación de un árbol de expresión
El recorrido en postorden de un árbol binario puede ser usado para resolver

el problema de evaluación del árbol de expresión. En este problema, se da
un árbol de expresión aritmética, es decir, un árbol binario donde cada nodo
externo tiene asociado un valor con este y cada nodo interno tiene un operador
aritmético asociado con este, y se quiere calcular el valor de la expresión
aritmética representada por el árbol.
El algoritmo evaluarExpresion, dado enseguida, evalúa la expresión
asociada con el subárbol enraizado en el nodo v de un árbol A de expresión
aritmética realizando un recorrido en postorden de A iniciando en v. En este
caso, la acción “visita” consiste realizar una sola operación aritmética. Se
supone que el árbol de expresión aritmética es un árbol binario propio.
Algoritmo evaluarExpresion(A, v):
si v es un nodo interno en A entonces
Sea ◦ el operador guardado en v
x ← evaluarExpresion(A, A.left(v))
y ← evaluarExpresion(A, A.right(v))
regresar x ◦ y
si no
regresar el valor guardado en v
El algoritmo evaluarExpresion, al hacer un recorrido en postorden,
da un tiempo O(n) para evaluar un expresión aritmética representada por un
árbol binario con n nodos. Al igual que en el recorrido en postorden general,
el recorrido en postorden para árboles binarios puede ser aplicado a otros
problemas de evaluación bottom-up (ascendente) también, tal como calcular
el tamaño dado en el ejemplo 7.5.
Recorrido en orden de un árbol binario
Un método de recorrido adicional para un árbol binario es el recorrido

recorrido en orden. En este recorrido, se visita un nodo entre los recorridos
recursivos de sus subárboles izquierdo y derecho. El recorrido en orden del
subárbol enraizado en un nodo v de un árbol binario A se da en el siguiente
algoritmo.
Algoritmo enordenBinario(A, v):

enordenBinario(A, u) { recursivamente recorrer el subárbol izquierdo }
enordenBinario(A, w) { recursivamente recorrer el subárbol derecho }
El recorrido en orden de un árbol binario A puede ser visto informalmente
como visitar los nodos de A “de izquierda a derecha”. Además, para cada
nodo v, el recorrido en orden visita v después de que todos los nodos en el
subárbol izquierdo de v y antes que todos los nodos en subárbol derecho de v,
ver figura 7.15.
Figura 7.15: Recorrido en orden de un árbol binario.
Árboles binarios de búsqueda

Sea S un conjunto cuyos elementos tienen una relación de orden. Por
ejemplo, S podrı́a ser un conjunto de enteros. Un árbol árbol binario de
búsqueda para S es un árbol binario propio A tal que
Cada nodo interno v de A guarda un elemento de S, denotado con x(v).
Para cada nodo interno v de A, los elementos guardados en el subárbol

izquierdo de v son menores que o iguales a x(v) y los elementos guardados
en el subárbol derecho de v son mayores que x(v).
Los nodos externos de A no guardan ningún elemento.

282 Árboles
Un recorrido en orden de los nodos internos de un árbol binario de búsqueda

A visita los elementos en orden creciente, ver figura 7.16.
Figura 7.16: Un árbol binario de búsqueda ordenando enteros. El camino azul sólido
es recorrido cuando se busca exitosamente el 36. El camino azul discontinuo es
recorrido cuando se busca sin éxito el 70.
Se puede usar un árbol binario de búsqueda A para un conjunto S para

encontrar si un valor de búsqueda y está en S, recorriendo el camino descen-
dente del árbol A, iniciando con la raı́z, En cada nodo interno v encontrado,
se compara el valor de búsqueda y con el elemento x(v) guardado en v. Si
y < x(v), entonces la búsqueda continúa en el subárbol izquierdo de v. Si
y = x(v), entonces la búsqueda termina exitosamente. Si y > x(v), entonces
la búsqueda continúa en el subárbol derecho de v. Finalmente, si se alcanza
un nodo externo, la búsqueda termina sin éxito. El árbol binario de búsqueda
puede ser visto como un árbol de decisión, donde la pregunta hecha en cada
nodo interno es si el elemento en ese nodo es menor que, igual a, o mayor que
el elemento que se está buscando.
El tiempo de ejecución de la búsqueda en un árbol binario de búsqueda A
es proporcional a la altura de A. La altura de un árbol binario propio con n
nodos puede ser tan pequeño como log(n + 1) − 1 o tan grande como (n − 1)/2,
ver la propiedades del árbol binario, sección 7.3.3. Por lo anterior los árboles
binarios de búsqueda son más eficientes cuando tienen alturas pequeñas.
Recorrido en orden para dibujar un árbol

El recorrido en orden puede ser aplicado al problema de dibujar un árbol
binario. Se puede dibujar un árbol binario A con un algoritmo que asigne
coordenadas x e y a un nodo de v de A usando las siguientes reglas, ver figura

7.17:
x(v) es el número de nodos visitados antes de v en el recorrido en orden

de A.
y(v) es la profundidad de v en A.
En esta aplicación, se toma la convención común en computación para

las gráficas de que la coordenada x se incrementa de izquierda a derecha y la
coordenada y se incrementa de arriba hacia abajo. Ası́ el origen está en la
esquina superior izquierda de la pantalla de la computadora.
Figura 7.17: Un dibujo en orden de un árbol binario.
Recorrido de Euler de un árbol binario

Los algoritmos de recorrido para árbol que se han visto, todos ellos son
de la forma de iteradores. Cada recorrido visita los nodos de un árbol en
un cierto orden, y se garantiza visitar cada nodo exactamente una vez. Se
pueden unificar los tres algoritmos de recorrido dados en una sola estructura,
relajando los requerimientos de que cada nodo sea visitado una sola vez. La
ventaja de este recorrido es que permite tipos más generales de algoritmos
para ser expresados sencillamente.
El recorrido de Euler de un árbol binario A puede ser informalmente
definido como una “caminata” alrededor de A, que se inicia yendo desde la
raı́z hacia su hijo izquierdo, viendo a las aristas de A como “paredes” que
siempre se conservan a la izquierda, ver figura 7.18. Cada nodo v de A es
encontrado tres veces por el recorrido de Euler:
284 Árboles
Figura 7.18: Un recorrido de Euler de un árbol binario.
“A la izquierda”, antes del recorrido de Euler de subárbol izquierdo de

v.
“Desde abajo”, entre los recorridos de Euler de los dos subárboles de v.
“A la derecha”, después del recorrido de Euler de subárbol derecho de

v.
Si v es un nodo externo, entonces estas tres “visitas” suceden todas al

mismo tiempo. Se describe el recorrido de Euler del subárbol enraizado en v
en el siguiente algoritmo:
Algoritmo RecorridoEuler(A, v):
realizar la acción para visitar nodo v a la izquierda
RecorridoEuler(A, u) { recursivamente recorrer subárbol izquierdo de v }
realizar la acción para visitar nodo v desde abajo
RecorridoEuler(A, w) { recursivamente recorrer subárbol derecho de v }
realizar la acción para visitar nodo v a la derecha
El tiempo de ejecución del recorrido de Euler de un árbol de n-nodos
se obtiene ası́, suponiendo que cada acción visita toma tiempo O(1). Como
se usa una cantidad constante de tiempo en cada nodo del árbol durante el
recorrido, el tiempo de ejecución total es O(n).
El recorrido en preorden de un árbol binario es equivalente a un recorrido
de Euler tal que cada nodo tiene asociado una acción “visita” ocurriendo
solamente cuando este es encontrada a la izquierda. De la misma forma, los

recorridos en orden y postorden son equivalentes a un recorrido de Euler
cuando el nodo encontrado desde abajo o a la derecha, respectivamente. Se
puede usar el recorrido de Euler para hacer otros tipos de recorridos. Por
ejemplo, suponer que se desea calcular el número de descendientes de cada
nodo v en un árbol binario de n nodos. Se inicia un recorrido de Euler
inicializando un contador a cero, y entonces incrementando el contador cada
vez que se visita un nodo a la izquierda. Para determinar el número de
descendientes de un nodo v, se calcula la diferencia entre los valores del
contador cuando v es visitado a la izquierda y cuando es visitado a la derecha,
y agregado uno. Esta regla da el número de descendientes de v, porque cada
nodo en el subárbol enraizado es contado la visita de v y la visita de v a
la derecha. Por lo tanto, se tiene un método tiempo O(n) para calcular el
número de descendientes de cada nodo.
Otra aplicación del recorrido de Euler es imprimir una expresión aritmética
completamente parentizada a partir de su árbol de expresión. El algoritmo
imprimirExpresión, mostrado a continuación, realiza esta tarea realizando
las siguientes acciones en un recorrido de Euler:
Acción “a la izquierda”: si el nodo es interno, imprimir “(”
Acción “desde abajo”: imprimir el valor u operador guardado en el nodo
Acción “a la derecha”: si el nodo es interno, imprimir “)”
Algoritmo imprimirExpresión(A, v):

si A.isInternal(v) entonces
imprimir “(”
si A.hasLeft(v) entonces
imprimirExpresión(A, A.left(v))
imprimir el operador guardado en v
si no
imprimir el valor guardado en v
si A.hasRight(v) entonces
imprimirExpresión(A, A.right(v))
imprimir “)”
286 Árboles
7.3.7. Plantilla método patrón

Los métodos de recorrido para árboles descritos previamente son ejemplos
de patrones de diseño de software orientado al objeto, la plantilla método
patrón. La plantilla método patrón describe un mecanismo genérico de cálculo
que puede ser especializado para una aplicación particular redefiniendo cierto
pasos. Siguiendo la plantilla método patrón, se diseña un algoritmo que
implementa un recorrido de Euler genérico de un árbol binario. Se muestra
enseguida el algoritmo plantillaRecorridoEuler.
Algoritmo plantillaRecorridoEuler(A, v):
r ← nuevo objeto del tipo ResultadoRecorrido
visitarIzquierda(A, v, r)
si A.hasLeft(v) entonces
r.izq ← plantillaRecorridoEuler(A, A.left(v))
visitarAbajo(A, v, r)
si A.hasRight(v) entonces
r.der ← plantillaRecorridoEuler(A, A.right(v))
visitarDerecha(A, v, r)
regresar r.salida
Cuando se llama con un nodo v, el método plantillaRecorridoEuler()
llama varios métodos auxiliares en diferentes fases del recorrido. Como se
describe enseguida:
Crear una variable local r del tipo ResultadoRecorrido, la cual es usada

para guardar resultados intermedios del cálculo, que tiene campos izq,
der y salida.
Se llama al método auxiliar visitarIzquierda(A, v, r), el cual realiza

los cálculos asociados encontrándose a la izquierda del nodo.
Si v tiene hijo izquierdo, se llama recursivamente sobre él mismo con el

hijo izquierdo de v y se guarda el valor regresado en r.izq.
Se llama al método auxiliar visitarAbajo(A, v, r), el cual realiza los

cálculos asociados encontrándose abajo del nodo.
Si v tiene hijo derecho, se llama recursivamente sobre él mismo con el

hijo derecho de v y se guarda el valor regresado en r.der.
Se llama al método auxiliar visitarDerecha(A, v, r), el cual realiza los

cálculos asociados encontrándose a la derecha del nodo.
Regresar r.salida.
El método plantillaRecorridoEuler puede ser visto como una plantilla

o “esqueleto” de un recorrido Euleriano.
Implementación Java
La clase RecorridoEuler, mostrada en el listado 7.13, implementa un
recorrido transversal de Euler usando la plantilla método patrón. El recorrido
transversal es hecha por el método RecorridoEuler(). Los métodos auxiliares
llamados por RecorridoEuler son lugares vacı́os, tienen cuerpos vacı́os o
solo regresan null. La clase RecorridoEuler es abstracta y por lo tanto no
puede ser instanciada. Contiene un método abstracto, llamado ejecutar, el
cual necesita ser especificado en las subclases concretas de RecorridoEuler.
1 /* *
2 * Plantilla para algoritmos que recorren un á rbol binario usando un
3 * recorrido euleriano . Las subclases de esta clase redefinir á n
4 * algunos de los m é todos de esta clase para crear un recorrido
5 * espec ı́ fico .
6 */
7 public abstract class RecorridoEuler <E , R > {
8 protected ArbolBinario <E > arbol ;
9 /* * Ejecuci ó n del recorrido . Este m é todo abstracto deber á ser
10 * especificado en las subclases concretas . */
11 public abstract R ejecutar ( ArbolBinario <E > T );
12 /* * Inicializaci ó n del recorrido */
13 protected void inicializar ( ArbolBinario <E > T ) { arbol = T ; }
14 /* * M é todo plantilla */
15 protected R recorri doEuler ( Posicion <E > v ) {
16 ResultadoRecorrido <R > r = new ResultadoRecorrido <R >();
17 v i s i t a r I z q u i e rd a (v , r );
18 if ( arbol . hasLeft ( v ))
19 r . izq = r ecorrido Euler ( arbol . left ( v )); // recorrido recursivo
20 visitarAbajo (v , r );
21 if ( arbol . hasRight ( v ))
22 r . der = r ecorrido Euler ( arbol . right ( v )); // recorrido recursivo
23 visi tarDerec ha (v , r );
24 return r . salida ;
25 }
26 // M é todos auxiliares que pueden ser redefinidos por las subclases
27 /* * M é todo llamado para visitar a la izquierda */
28 protected void v i s i t a r I z q u i e r d a ( Posicion <E > v , ResultadoRecorrido <R > r ) {}
29 /* * M é todo llamado para visitar abajo */
30 protected void visitarAbajo ( Posicion <E > v , ResultadoRecorrido <R > r ) {}
31 /* * M é todo llamado para visitar a la derecha */
32 protected void vi sitarDe recha ( Posicion <E > v , ResultadoRecorrido <R > r ) {}
288 Árboles
33
34 /* Clase interna para modelar el resultado del recorrido */
35 public class ResultadoRecorrido <R > {
36 public R izq ;
37 public R der ;
38 public R salida ;
39 }
40 }
Listado 7.13: Clase RecorridoEuler.java que define un recorrido Euleriano genéri-

co de un árbol binario
La clase, RecorridoEuler, por si misma no hace ningún cálculo útil. Sin

embargo, se puede extender y reemplazar los métodos auxiliares vacı́os para ha-
cer cosas útiles. Se ilustra este concepto usando árboles de expresión aritmética,
ver ejemplo 7.7. Se asume que un árbol de expresión aritmética tiene objetos de
tipo TerminoExpresion en cada nodo. La clase TerminoExpresion tiene sub-
clases VariableExpresión (para variables) y OperadorExpresion (para ope-
radores). A su vez, la clase OperadorExpresion tiene subclases para los opera-
dores aritméticos, tales como OperadorSuma y OperadorMultiplicacion. El
método valor de TerminoExpresion es reemplazado por sus subclases. Para
una variable, este regresa el valor de la variable. Para un operador, este regresa
el resultado de aplicar el operador a sus operandos. Los operandos de un
operador son puesto por el método setOperandos() de OperadorExpresion.
En los códigos de los listados 7.14, 7.15, 7.16 y 7.17 se muestran las clases
anteriores.
1 /* * Clase para un t é rmino ( operador o variable de una expresi ó n

2 * aritm é tica .
3 */
4 public class T e r m i n o E x p r e s i o n {
5 public Integer getValor () { return 0; }
6 public String toString () { return new String ( " " ); }
7 }
Listado 7.14: Clase TerminoExpresion.java para una expresión
1 /* * Clase para una variable de una expresi ó n artim é tica . */

2 public class V a r i a b l e E x p r e s i o n extends Te r m i n o E x p r e s i o n {
3 protected Integer var ;
4 public V a r i a b l e E x p r e s i o n ( Integer x ) { var = x ; }
5 public void setVariable ( Integer x ) { var = x ; }
6 public Integer getValor () { return var ; }
7 public String toString () { return var . toString (); }
8 }
Listado 7.15: Clase VariableExpresion.java para una variable
1 /* * Clase para un operador de una expresi ó n aritm é tica . */

2 public class O p e r a d o r E x p r e s i o n extends Te r m i n o E x p r e s i o n {
3 protected Integer primerOperando , s eg un d oO pe ra n do ;
4 public void setOperandos ( Integer x , Integer y ) {
5 prim erOperan do = x ;
6 s eg un do O pe ra nd o = y ;
7 }
8 }
Listado 7.16: Clase OperadorExpresion.java para un operador genérico
1 /* * Clase para el operador adici ó n en una expresi ó n aritm é tica . */

2 public class OperadorSuma extends O p e r a d o r E x p r e s i o n {
3 public Integer getValor () {
4 // desencajonar y despu é s encajonar
5 return ( prim erOperan do + se gu n do Op er a nd o );
6 }
7 public String toString () { return new String ( " + " ); }
8 }
Listado 7.17: Clase OperadorSuma.java el operador suma

En los listados 7.18 y 7.19, se muestran las clases RecorridoEvaluarExpre-
sion y RecorridoImprimirExpresion, especializando RecorridoEuler, que
evalúa e imprime una expresión aritmética guardada en un árbol binario,
respectivamente. La clase RecorridoEvaluarExpresion reemplaza el método
auxiliar visitarDerecha(A, v, r) con el siguiente cálculo:
Si v es un nodo externo, poner r.salida igual al valor de la variable
guardada en v;
290 Árboles
si no (v es un nodo interno), combinar r.izq y r.der con el operador

guardado en v, y pone r.salida igual al resultado de la operación.
1 /* * Calcular el valor de un á rbol de expresi ó n aritm é tica . */

2 public class R e c o r r i d o E v a l u a r E x p r e s i o n
3 extends RecorridoEuler < TerminoExpresion , Integer > {
4
5 public Integer ejecutar ( ArbolBinario < TerminoExpresion > T ) {
6 inicializar ( T ); // llamar al m é todo de la superclase
7 return recorr idoEule r ( arbol . root ()); // regresar el valor de la expresi ó n
8 }
9
10 protected void vi sitarDer echa ( Posicion < TerminoExpresion > v ,
11 ResultadoRecorrido < Integer > r ) {
12 T e r m i n o E x p r e s io n termino = v . elemento ();
13 if ( arbol . isInternal ( v )) {
14 O p e r a d o r E x p r e s i o n op = ( O p e r a d o r E x p r e s i o n ) termino ;
15 op . setOperandos ( r . izq , r . der );
16 }
17 r . salida = termino . getValor ();
18 }
19 }
Listado 7.18: Clase RecorridoEvaluarExpresion.java especializa

RecorridoEuler para evaluar la expresión asociada con un árbol de expresión
aritmética.
La clase RecorridoImprimirExpresion reemplaza los métodos visitar-

Izquierda, visitarAbajo, visitarDerecha siguiendo la aproximación de
la versión pseudocódigo dada previamente.
1 /* * Imprimir la expresi ó n guardada en un á rbol de expresi ó n aritm é tica . */
2 public class R e c o r r i d o I m p r i m i r E x p r e s i o n
3 extends RecorridoEuler < TerminoExpresion , String > {
4
5 public Integer ejecutar ( ArbolBinario < TerminoExpresion > T ) {
6 inicializar ( T );
7 System . out . print ( " Expresi ó n : " );
8 reco rridoEul er ( T . root ());
9 System . out . println ();
10 return null ; // nada que regresar
11 }
12
13 protected void v i s i t a r I z q u i e r d a ( Posicion < TerminoExpresion > v ,
14 ResultadoRecorrido < String > r ) {
15 if ( arbol . isInternal ( v )) System . out . print ( " ( " ); }
16
17 protected void visitarAbajo ( Posicion < TerminoExpresion > v ,
19 System . out . print ( v . elemento ()); }
20
21 protected void vi sitarDer echa ( Posicion < TerminoExpresion > v ,
23 if ( arbol . isInternal ( v )) System . out . print ( " ) " ); }

24 }
Listado 7.19: Clase RecorridoImprimirExpresion.java especializa

RecorridoEuler para imprimir la expresión asociada con un árbol de ex-
presión aritmética.
292 Árboles
Bibliografı́a
[1] R. Lafore, Data Structures & Algorithms, Second Edition, Sams, 2003.
[2] M. Goodrich, R. Tamassia, Data Structures and Algorithms in Java,

Fourth Edition, John Wiley & Sons, 2005.
Índice alfabético
ı́ndice, 38, 199 super, 58

árbol, 245, 246 switch, 31
árbol binario, 263 this, 58
árbol binario completo, 263 true, 23
árbol binario de búsqueda, 281 try, 68
árbol binario propio, 263 void, 20
árbol impropio, 263 while, 32
árbol ordenado, 248
abstracción, 51
árboles, 245
adaptabilidad, 50
árboles de decisión, 263
adaptador, 201
Scanner, 43
ADT, 85
break, 32, 36
alcance, 15
catch, 68
alfabeto, 12
clone(), 41
algoritmo, 149
continue, 37
algoritmos, 85
do...while, 35
altura, 254
double, 23
amortización, 207
enum, 17
análisis amortizado, 207
extends, 58
análisis promedio, 153
false, 23
ancestro, 247
finally, 68
API, 70, 169
for, 33
arista, 248
if, 30
arreglo, 38
import, 46
arreglo bidimensional, 103
instanceof, 78
arreglo extendible, 206
int, 23
atrapada, 66, 68
length, 38
autoempacado, 29
new, 13
null, 13, 23 bloque, 8
return, 20, 36 bloque de sentencias, 22
ÍNDICE ALFABÉTICO 295
camino, 248 especializa, 54

campos, 7, 14 especialización, 57
capacidad, 39 estructura de datos, 85, 149
caso base, 128 estructura genérica, 81
casos recursivos, 128 etiqueta, 37
celda, 38 etiquetas HTML, 183
ciclo for-each, 224 evolucionabilidad, 50
cifrador de César, 100 extensión, 57
clase, 7, 49, 51 externo, 247
abstract, 9 extiende, 54
final, 9
FIFO, 185
public, 9
firma, 18
amigable, 9
for
clase base, 54
condición, 34
clases número, 12
incremento, 34
cola con doble terminación, 194
inicialización, 33
concatenación, 13, 27
función cúbica, 144
constructor, 21
función constante, 141
conversión ancha, 76
función cuadrática, 143
conversión implı́cita, 29
función exponencial, 146
criptografı́a, 100
función exponente, 147
cuerpo, 18
función factorial, 126
cursor, 213
función lineal, 143
definición recursiva, 127 función logarı́tmica, 142
deque, 194 función piso, 148
descendiente, 247 función potencia, 164
descifrado, 100 función techo, 148
funciones polinomiales, 145
desempacado, 29
dirección, 13 generadores de números pseudoaleato-
double-ended queue, 194 rios, 97
elemento, 39 herencia, 54
encadenamiento constructor, 58 herencia única, 58
encapsulación, 51 herencia múltiple, 74
encriptamiento, 100 hermanos, 247
enlazado dinámico, 56 heurı́stica, 239
envı́o dinámico, 56 heurı́stica mover al frente, 239
296 ÍNDICE ALFABÉTICO
hijos, 245 matriz, 103

hojas, 247 mezcla, 74
miembros, 7
identificador, 8 modificador
igualdad profunda, 107 final, 17
igualdad simple, 107 static, 17
igualdad superficial, 107 modificadores de clase, 9
Implementar una interfaz, 51 modularidad, 52
inserción ordenada, 94
interfaz, 70 nivel de un árbol binario, 266
interfaz de programación de aplicacio- nodo cabeza, 113
nes, 70, 169 nodo cola, 113
interno, 247 nodos, 108
iterador, 223 notación Omega-grande, 158
iterator, 223 notación Tetha-grande, 158
numeración de nivel, 274
jerárquicas, 245 numeración por nivel, 261
jerárquico, 52
O-grande, 155
lanza, 66 objeto, 8
lanzados, 66 objeto compuesto, 20
LDE, 113 objetos, 7
LIFO, 167 operaciones primitivas, 152
lista, 199 operador
lista arreglo, 199 new, 10
lista circular enlazada, 121
lista de favoritos, 237 padre, 245
lista doblemente enlazada, 113 padre-hijo, 246
lista enlazada, 108 paquete, 46
lista nodo, 211 parámetros de tipo actual, 81
lista simple enlazada, 108 parámetros de tipo formal, 81
literal, 23 patrón de diseño, 53
localidad de referencia, 239 peor caso, 153
pila, 167
método plantilla método patrón, 285
firma, 14, 56 polimórfica, 56
métodos, 7 por valor, 20
módulo, 101, 189 portabilidad, 50
marco de colecciones Java, 230 posición, 210
ÍNDICE ALFABÉTICO 297
posiciones en un árbol, 249 texto plano, 100

problema de Josefo, 193 tipado fuerte, 76
profundidad, 253 tipo, 7, 14
progresión aritmética, 59 tipo genérico, 81
progresión Fibonacci, 63 tipos, 8
progresión geométrica, 59 tipos base, 10
tipos de datos abstractos, 51, 85
raı́z, 246 tipos primitivos, 10
rango, 199
recorrido, 256 variables de instancia, 7, 14
recorrido en orden, 280 variables locales, 22
recorrido en postorden, 259 vector, 199
recorrido en preorden, 256
recurrencia, 126
recurrencia binaria, 134
recurrencia de cola, 133
recurrencia múltiple, 137
reemplazo, 58
referencia, 10, 13, 55
refinamiento, 58
reglas de exponentes, 147
reglas de logaritmos, 142
relativamente, 211
representación parentética de cadena,
257
robusto, 49
round robin, 192
secuencia, 199, 234

semilla, 98
sobrecarga, 56
subárbol derecho, 263
subárbol enraı́zado, 248
subárbol izquierdo, 263
sumatoria, 146
sumatorias geométricas, 148
superclase, 54
texto cifrado, 100

Estructuras de Datos Con Java. Héctor Tejeda V PDF

Încărcat de

Informații document

Titlu original

Drepturi de autor

Formate disponibile

Partajați acest document

Partajați sau inserați document

Opțiuni de partajare

Vi se pare util acest document?

Este necorespunzător acest conținut?

Drepturi de autor:

Formate disponibile

Estructuras de Datos Con Java. Héctor Tejeda V PDF

Încărcat de

Drepturi de autor:

Formate disponibile

Estructuras de Datos con Java

2. Diseño orientado al objeto 47

2.2.3. Uso de herencia en Java . . . . . . . . . . . . . . . . . 55

3. Arreglos, listas enlazadas y recurrencia 83

4. Herramientas de análisis 139

4.1.3. La función lineal . . . . . . . . . . . . . . . . . . . . . 141

5. Pilas y colas 165

6. Listas e Iteradores 197

6.2.1. Operaciones basadas en nodos . . . . . . . . . . . . . . 208

1.1. Clases, tipos, y objetos

Datos de objetos Java son guardados en variables de instancia, o

Declaración de una clase

Un objeto es una combinación especı́fica de datos y métodos que pueden

1 public class Contador {

abstract default goto package this

1.1.1. Tipos base

1 public class Base {

Listado 1.2: La clase Base muestra ejemplos de uso de tipos base.

objeto. Enseguida inmediatamente del operador new se pone una llamada al

1 public class Ejemplo {

Listado 1.3: Ejemplos de uso del operador new.

El constructor para el nuevo objeto es llamado con los parámetros

Después que el constructor termina, el operador new devuelve una

Tipo Nombre Ejemplo Ejemplo

una cadena s puede ser referenciado por su ı́ndice en la cadena, que es la

String s = "fut" + "bol";

La sentencia define una variable s que refiere un objeto de clase String,

Puede haber varias referencias al mismo objeto, y cada referencia a un

Cada una de las llamadas a métodos se refiere a un método diferente

todos. Usando el operador punto se puede acceder y poner el valor de tales

1 public class Duende {

Listado 1.4: La clase Duende

2. final. Una variable de instancia final es una a la que se le debe asignar

1.1.3. Tipo enum

[modificador] enum nombre { nombre valor0, nombre valor1, ...};

donde el modificador es opcional, o puede ser public, protected, o private.

1 public class DiaCurso {

Listado 1.5: Un ejemplo del uso del tipo enum

alguna clase. La definición de un método tiene dos partes: la firma, la cual

un método static, el cual está asociado con la propia clase. Al invocar el

1. public. Cualquiera puede llamar al método.

2. protected. Sólo métodos del mismo paquete o de sus subclases pueden

3. private. Sólo métodos de la misma clase pueden llamar.

4. Si ninguno de los anteriores modificadores es usado, el método es ami-

Los modificadores anteriores podrı́an ser seguidos por los modificadores

1. abstract. Un método declarado como abstracto no tiene código. La

public abstract void setEstatura( double nvaEst );

Los métodos abstractos pueden aparecer sólo en clases abstractas. Se

2. final. El método no puede ser anulado por una subclase.

3. static. El método está asociado con la propia clase, y no con alguna

Una definición de método deberá indicar el tipo de valor que el método

Los parámetros de un método están definidos en una lista separada por

[modificadores] nombre(tipo0 parámetro0, tipo1 parámetro1, . . . ){

public Camaron(int p, String n) {

Definición del constructor e invocación

Camaron miCamaron = new Camaron(50,"Popeye");

En este caso, el sistema de ejecución Java busca una versión compilada de

public static void main(String[] args) {

Bloques de sentencias y variables locales

La primera declaración solo define el identificador, nombre, para ser de

La referencia objeto null. Es la única literal objeto y se permite usar

Las constantes booleanas true y false.

’\n’ nueva lı́nea ’\t’ tabulador