Pensando la computación como un científico (con ... Catalogue en ligne

Pensando la computación como un científico (con Java)

Título:	Pensando la computación como un científico (con Java)
Autores:	Allen B. Downey, Autor ; Diego Delle Donne, Traductor ; Germán Kruszewski, Traductor ; Francisco Laborda, Traductor ; Maximiliano Llosa, Traductor ; Javier Pimás, Traductor
Tipo de documento:	documento electrónico
Mención de edición:	1a ed. 4a reimp.
Editorial:	Los Polvorines [Argentina] : Universidad Nacional de General Sarmiento, 2017
Colección:	Ciencia, innovación y desarrollo, num. 3
ISBN/ISSN/DL:	978-987-630-117-6
Dimensiones:	348 p. / PDF
Langues:	Español
Langues originales:	Inglés
Mots-clés:	GENERALIDADES, INFORMÁTICA, PROGRAMACIÓN
Nota de contenido:	Índice general: Prefacio VII 1 El camino del programa 1 1.1 ¿Qué es un lenguaje de programación? . . . . . . . . . . . . . . 1 1.2 ¿Qué es un programa?. . . . . . . . . . . . . . . . . . . . . . . . . . . 4 1.3 ¿Qué es la depuración? . . . . . . . . . . . . . . . . . . . . . . . . . . 5 1.3.1 Errores de sintaxis . . . . . . . . . . . . . . . . . . 5 1.3.2 Errores en tiempo de ejecución . . . . . . . . . . . 5 1.3.3 Errores semánticos . . . . . . . . . . . . . . . . . . 6 1.3.4 Depuración experimental . . . . . . . . . . . . . . 6 1.4 Lenguajes formales y lenguajes naturales. . . . . . . . . . . . 7 1.5 El primer programa . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9 1.6 Glosario . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10 1.7 Ejercicios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12 2 Variables y tipos 15 2.1 Imprimiendo más. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15 2.2 Variables . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16 2.3 Asignación. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17 2.4 Imprimiendo variables. . . . . . . . . . . . . . . . . . . . . . . . . . . 18 2.5 Palabras reservadas. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20 2.6 Operadores . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20 2.7 Orden de las operaciones . . . . . . . . . . . . . . . . . . . . . . . . 21 2.8 Operadores de cadenas . . . . . . . . . . . . . . . . . . . . . . . . . . 22 2.9 Composición . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22 2.10 Glosario . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23 2.11 Ejercicios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24 3 Métodos 27 3.1 Punto flotante . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27 3.2 Convirtiendo entre double e int . . . . . . . . . . . . . . . . . . . . 28 3.3 Métodos de la clase Math . . . . . . . . . . . . . . . . . . . . . . . . 29 3.4 Composición . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30 3.5 Agregando nuevos métodos . . . . . . . . . . . . . . . . . . . . . . 31 3.6 Clases y métodos. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33 3.7 Programas con múltiples métodos. . . . . . . . . . . . . . . . . . 34 3.8 Parámetros y argumentos . . . . . . . . . . . . . . . . . . . . . . . . 35 3.9 Diagramas de la pila de ejecución . . . . . . . . . . . . . . . . . . 37 3.10 Métodos con múltiples parámetros . . . . . . . . . . . . . . . . . 37 3.11 Métodos con resultados. . . . . . . . . . . . . . . . . . . . . . . . . . 38 3.12 Glosario . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 38 3.13 Ejercicios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 39 4 Condicionales y recursión 43 4.1 El operador módulo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 43 4.2 Ejecución condicional . . . . . . . . . . . . . . . . . . . . . . . . . . . 43 4.3 Ejecución alternativa . . . . . . . . . . . . . . . . . . . . . . . . . . . . 44 4.4 Condicionales encadenados . . . . . . . . . . . . . . . . . . . . . . 45 4.5 Condicionales anidados. . . . . . . . . . . . . . . . . . . . . . . . . . 46 4.6 La sentencia return . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 46 4.7 Conversión de tipos. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 47 4.8 Recursión. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 47 4.9 Diagramas de la pila de ejecución para métodos recursivos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 49 4.10 Convención y Ley Divina . . . . . . . . . . . . . . . . . . . . . . . . . 50 4.11 Glosario . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 51 4.12 Ejercicios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 52 5 Métodos con resultados 55 5.1 Valores de retorno . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 55 5.2 Desarrollo de un programa . . . . . . . . . . . . . . . . . . . . . . . 57 5.3 Composición . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 59 5.4 Sobrecarga. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 60 5.5 Expresiones booleanas . . . . . . . . . . . . . . . . . . . . . . . . . . 61 5.6 Operadores lógicos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 62 5.7 Métodos booleanos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 63 5.8 Más recursión . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 64 5.9 Salto de fe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 66 5.10 Un ejemplo más . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 67 5.11 Glosario . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 68 5.12 Ejercicios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 69 6 Iteración 75 6.1 Asignación múltiple. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 75 6.2 Iteración . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 76 6.3 La sentencia while . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 76 6.4 Tablas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 78 6.5 Tablas de dos dimensiones . . . . . . . . . . . . . . . . . . . . . . . 80 6.6 Encapsulamiento y generalización . . . . . . . . . . . . . . . . . 81 6.7 Métodos. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 82 6.8 Más encapsulamiento . . . . . . . . . . . . . . . . . . . . . . . . . . . 83 6.9 Variables locales . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 83 6.10 Más generalización . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 84 6.11 Glosario . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 86 6.12 Ejercicios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 86 7 Cadenas y cosas 91 7.1 Invocando métodos en objetos . . . . . . . . . . . . . . . . . . . . 91 7.2 Largo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 92 7.3 Recorrido . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 93 7.4 Errores en tiempo de ejecución . . . . . . . . . . . . . . . . . . . . 93 7.5 Leyendo la documentación . . . . . . . . . . . . . . . . . . . . . . . 94 7.6 El método indexOf . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 95 7.7 Iterando y contando. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 96 7.8 Operadores de incremento y decremento . . . . . . . . . . . . 96 7.9 Los Strings son inmutables . . . . . . . . . . . . . . . . . . . . . . . 97 7.10 Los Strings no son comparables . . . . . . . . . . . . . . . . . . . 98 7.11 Glosario . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 99 7.12 Ejercicios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 99 8 Objetos interesantes 105 8.1 ¿Qué es interesante? . . . . . . . . . . . . . . . . . . . . . . . . . . . . 105 8.2 Paquetes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 105 8.3 Objetos Point. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 106 8.4 Variables de instancia . . . . . . . . . . . . . . . . . . . . . . . . . . . 107 8.5 Objetos como parámetros . . . . . . . . . . . . . . . . . . . . . . . . 107 8.6 Rectángulos. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 108 8.7 Objetos como tipo de retorno. . . . . . . . . . . . . . . . . . . . . . 109 8.8 Los objetos son mutables . . . . . . . . . . . . . . . . . . . . . . . . 109 8.9 Aliasing . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 110 8.10 null . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 111 8.11 Recolector de basura . . . . . . . . . . . . . . . . . . . . . . . . . . . . 112 8.12 Objetos y tipos primitivos . . . . . . . . . . . . . . . . . . . . . . . . 113 8.13 Glosario . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 113 8.14 Ejercicios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 114 9 Creá tus propios objetos 119 9.1 Definiciones de clases y tipos de objetos. . . . . . . . . . . . . 119 9.2 Tiempo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 120 9.3 Constructores . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 121 9.4 Más constructores . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 122 9.5 Creando un objeto nuevo. . . . . . . . . . . . . . . . . . . . . . . . . 122 9.6 Imprimiendo un objeto . . . . . . . . . . . . . . . . . . . . . . . . . . 124 9.7 Operaciones sobre objetos. . . . . . . . . . . . . . . . . . . . . . . . 124 9.8 Funciones puras . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 125 9.9 Modificadores . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 127 9.10 Métodos de llenado . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 128 9.11 ¿Cuál es mejor? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 128 9.12 Desarrollo incremental vs. planificación . . . . . . . . . . . . . 129 9.13 Generalización. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 130 9.14 Algoritmos. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 131 9.15 Glosario . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 131 9.16 Ejercicios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 132 10 Arreglos 137 10.1 Accediendo a los elementos . . . . . . . . . . . . . . . . . . . . . . 138 10.2 Copiando arreglos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 139 10.3 Ciclos for. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 139 10.4 Arreglos y objetos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 140 10.5 Longitud de un arreglo . . . . . . . . . . . . . . . . . . . . . . . . . . 141 10.6 Números aleatorios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 141 10.7 Arreglos de números aleatorios. . . . . . . . . . . . . . . . . . . . 142 10.8 Contando. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 144 10.9 El histograma . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 145 10.10 Solución de una sola pasada . . . . . . . . . . . . . . . . . . . . . . 146 10.11 Glosario . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 146 10.12 Ejercicios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 147 11 Arreglos de Objetos 153 11.1 Composición . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 153 11.2 Objetos Carta. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 153 11.3 El método imprimirCarta . . . . . . . . . . . . . . . . . . . . . . . . . 155 11.4 El método mismaCarta. . . . . . . . . . . . . . . . . . . . . . . . . . . . 157 11.5 El método compararCarta . . . . . . . . . . . . . . . . . . . . . . . . . 158 11.6 Arreglos de cartas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 159 11.7 El método imprimirMazo . . . . . . . . . . . . . . . . . . . . . . . . . . 161 11.8 Búsqueda . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 161 11.9 Mazos y submazos. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 165 11.10 Glosario . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 166 11.11 Ejercicios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 166 12 Objetos como Arreglos 169 12.1 La clase Mazo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 169 12.2 Mezclando . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 171 12.3 Ordenamiento . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 172 12.4 Submazos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 172 12.5 Mezclando y repartiendo . . . . . . . . . . . . . . . . . . . . . . . . . 174 12.6 Mergesort . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 174 12.7 Glosario . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 177 12.8 Ejercicios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 177 13 Programación Orientada a Objetos 181 13.1 Lenguajes de programación y estilos. . . . . . . . . . . . . . . . 181 13.2 Métodos de clase y de objeto. . . . . . . . . . . . . . . . . . . . . . 182 13.3 El objeto actual . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 182 13.4 Números complejos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 182 13.5 Una función de números Complejos . . . . . . . . . . . . . . . . . 183 13.6 Otra función sobre números Complejos . . . . . . . . . . . . . . 184 13.7 Un modificador . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 185 13.8 El método toString . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 186 13.9 El método equals . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 187 13.10 Llamando a un método de objeto desde otro . . . . . . . . . . 188 13.11 Rarezas y errores. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 188 13.12 Herencia . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 189 13.13 Rectángulos dibujables . . . . . . . . . . . . . . . . . . . . . . . . . . 189 13.14 La jerarquía de clases . . . . . . . . . . . . . . . . . . . . . . . . . . . 190 13.15 Diseño orientado a objetos . . . . . . . . . . . . . . . . . . . . . . . 191 13.16 Glosario . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 191 13.17 Ejercicios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 191 14 Listas enlazadas 193 14.1 Referencias en objetos. . . . . . . . . . . . . . . . . . . . . . . . . . . 193 14.2 La clase Nodo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 193 14.3 Listas como colecciones. . . . . . . . . . . . . . . . . . . . . . . . . . 195 14.4 Listas y recursión . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 196 14.5 Listas infinitas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 197 14.6 El teorema fundamental de la ambigüedad . . . . . . . . . . . 198 14.7 Métodos de instancia para nodos . . . . . . . . . . . . . . . . . . 199 14.8 Modificando listas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 199 14.9 Adaptadores y auxiliares. . . . . . . . . . . . . . . . . . . . . . . . . 200 14.10 La clase ListaInt . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 201 14.11 Invariantes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 202 14.12 Glosario . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 203 14.13 Ejercicios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 203 15 Pilas 205 15.1 Tipos de datos abstractos . . . . . . . . . . . . . . . . . . . . . . . . 205 15.2 El TAD Pila . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 206 15.3 El objeto Stack de Java . . . . . . . . . . . . . . . . . . . . . . . . . . 206 15.4 Clases adaptadoras . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 208 15.5 Creando adaptadores . . . . . . . . . . . . . . . . . . . . . . . . . . . 209 15.6 Creando más adaptadores . . . . . . . . . . . . . . . . . . . . . . . . 209 15.7 Sacando los valores afuera. . . . . . . . . . . . . . . . . . . . . . . . 209 15.8 Métodos útiles en las clases adaptadoras . . . . . . . . . . . . 210 15.9 Notación polaca . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 211 15.10 Parseo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 211 15.11 Implementando TADs . . . . . . . . . . . . . . . . . . . . . . . . . . . 213 15.12 Implementación del TAD Pila usando arreglos . . . . . . . . 213 15.13 Redimensionando el arreglo . . . . . . . . . . . . . . . . . . . . . . 214 15.14 Glosario . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 216 15.15 Ejercicios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 217 16 Colas y colas de prioridad 221 16.1 El TAD Cola . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 222 16.2 Veneer . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 223 16.3 Cola enlazada . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 224 16.4 Buffer circular . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 226 16.5 Cola de prioridad . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 230 16.6 Metaclase . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 231 16.7 Implementación de Cola de Prioridad sobre Arreglo . . . . 231 16.8 Un cliente de la Cola de Prioridad . . . . . . . . . . . . . . . . . . 233 16.9 La clase Golfista . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 234 16.10 Glosario . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 236 16.11 Ejercicios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 237 17 Árboles 239 17.1 Un nodo del árbol . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 239 17.2 Construcción de árboles . . . . . . . . . . . . . . . . . . . . . . . . . 240 17.3 Recorrido de árboles . . . . . . . . . . . . . . . . . . . . . . . . . . . . 240 17.4 Árboles de expresiones . . . . . . . . . . . . . . . . . . . . . . . . . . 241 17.5 Recorrido . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 242 17.6 Encapsulamiento . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 243 17.7 Definición de una metaclase . . . . . . . . . . . . . . . . . . . . . . 244 17.8 Implementando una metaclase . . . . . . . . . . . . . . . . . . . . 245 17.9 La clase Vector. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 246 17.10 La clase Iterator . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 248 17.11 Glosario . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 249 17.12 Ejercicios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 250 18 Heap 253 18.1 Implementación de árbol sobre arreglo . . . . . . . . . . . . . . 253 18.2 Análisis de eficiencia. . . . . . . . . . . . . . . . . . . . . . . . . . . . 257 18.3 Análisis de mergesort . . . . . . . . . . . . . . . . . . . . . . . . . . . 259 18.4 Overhead. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 261 18.5 Implementaciones de la Cola de Prioridad. . . . . . . . . . . . 261 18.6 Definición de un Heap . . . . . . . . . . . . . . . . . . . . . . . . . . . 263 18.7 quitar en Heap . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 264 18.8 agregar en Heap . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 266 18.9 Eficiencia de los Heaps . . . . . . . . . . . . . . . . . . . . . . . . . . 266 18.10 Heapsort . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 267 18.11 Glosario . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 268 18.12 Ejercicios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 269 19 Maps 271 19.1 Arreglos, Vectores y Maps. . . . . . . . . . . . . . . . . . . . . . . . 271 19.2 El TAD Map . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 272 19.3 El HashMap preincorporado . . . . . . . . . . . . . . . . . . . . . . 272 19.4 Una implementación usando Vector . . . . . . . . . . . . . . . . 274 19.5 La metaclase List . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 277 19.6 Implementación de HashMap . . . . . . . . . . . . . . . . . . . . . 277 19.7 Funciones de Hash . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 278 19.8 Redimensionamiento de un HashMap . . . . . . . . . . . . . . . 279 19.9 Rendimiento del redimensionado . . . . . . . . . . . . . . . . . . 280 19.10 Glosario . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 280 19.11 Ejercicios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 281 20 Código Huffman 285 20.1 Códigos de longitud variable. . . . . . . . . . . . . . . . . . . . . . 285 20.2 La tabla de frecuencias . . . . . . . . . . . . . . . . . . . . . . . . . . 286 20.3 El árbol de Huffman. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 287 20.4 El método super . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 290 20.5 Decodificando . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 291 20.6 Codificando . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 292 20.7 Glosario . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 293 Apéndices 295 A Planificación del desarrollo de un programa 295 B Depuración 303 B.1 Errores en tiempo de compilación . . . . . . . . . . . . . . . . . . 303 B.2 Errores en tiempo de ejecución . . . . . . . . . . . . . . . . . . . . 307 B.3 Errores semánticos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 310 C Entrada y salida en Java 317 C.1 Objetos del sistema . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 317 C.2 Entrada por teclado . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 318 C.3 Entrada por archivos . . . . . . . . . . . . . . . . . . . . . . . . . . . . 318 D Gráficos 321 D.1 Objetos Pizarra y Graphics . . . . . . . . . . . . . . . . . . . . . . . 321 D.2 Llamando métodos en un objeto Graphics . . . . . . . . . . . . 322 D.3 Coordenadas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 323 D.4 Un Ratón Mickey medio pelo . . . . . . . . . . . . . . . . . . . . . . 324 D.5 Otros comandos para dibujar. . . . . . . . . . . . . . . . . . . . . . 325 D.6 La clase Pizarra . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 326 E Licencia de Documentación Libre de GNU 333 E.1 Aplicabilidad y definiciones. . . . . . . . . . . . . . . . . . . . . . . 334 E.2 Copia literal . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 335 E.3 Copiado en cantidades . . . . . . . . . . . . . . . . . . . . . . . . . . 335 E.4 Modificaciones. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 336 E.5 Combinando documentos . . . . . . . . . . . . . . . . . . . . . . . . 338 E.6 Colecciones de documentos. . . . . . . . . . . . . . . . . . . . . . . 338 E.7 Agregación con trabajos independientes . . . . . . . . . . . . 338 E.8 Traducción. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 339 E.9 Terminación. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 339 E.10 Futuras revisiones de esta licencia . . . . . . . . . . . . . . . . . 339 E.11 Addendum. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 340
En línea:	https://ediciones.ungs.edu.ar/wp-content/uploads/2020/03/9789876301176-completo.pdf