Estructuras de Datos y Algoritmos

APUNTES DE CLASE

Ricardo Peña Mari

Marco Antonio Gómez Martín

Gonzalo Méndez Pozo

Manuel Freire Morán

Antonio Sánchez Ruiz-Granados

Isabel Pita Andreu

Ramón González del Campo

Miguel Valero Espada

Clara Segura Díaz

Facultad de Informática

Universidad Complutense de Madrid

30 de septiembre de 2015

Documento maquetado con TEXiS v.1.0+.

Este documento está preparado para ser imprimido a doble cara.

Estructuras de Datos y Algoritmos

Apuntes de clase

Grado en Ingeniería de Computadores

Grado en Ingeniería Informática

Grado en Ingeniería del Software

Doble grado de Matemáticas e Ingeniería Informática

Facultad de Informática

Universidad Complutense de Madrid

30 de septiembre de 2015

Copyright c© Ricardo Peña Mari, Marco Antonio Gómez Martín, Gonzalo MéndezPozo, Manuel Freire Morán, Antonio Sánchez Ruiz-Granados, Isabel Pita Andreu, RamónGonzález del Campo, Miguel Valero Espada, Clara Segura Díaz

ISBN 978-84-697-0852-1

Índice

1. Análisis de la eficiencia 1

1. Introducción . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12. Medidas asintóticas de la eficiencia . . . . . . . . . . . . . . . . . . . . . . . 33. Jerarquía de órdenes de complejidad . . . . . . . . . . . . . . . . . . . . . . 64. Propiedades de los órdenes de complejidad . . . . . . . . . . . . . . . . . . . 7Notas bibliográficas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9Ejercicios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9

2. Especificación de algoritmos 13

1. Introducción . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 132. Predicados . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 153. Significado . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 174. Ejemplos de especificación . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18Notas bibliográficas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21Ejercicios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21

3. Diseño de algoritmos iterativos 25

1. Introducción . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 252. Reglas prácticas para el cálculo de la eficiencia . . . . . . . . . . . . . . . . 25

2.1. Ejemplos de cálculo de complejidad de algoritmos iterativos . . . . . 263. Verificación . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30

3.1. Semántica de un lenguaje imperativo . . . . . . . . . . . . . . . . . . 303.2. Reglas específicas para el cálculo de la precondición más débil . . . . 313.3. Ejemplos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 313.4. Bucles e invariantes . . . . . . . . . . . . . . . . . . . . . . . . . . . 323.5. Ejemplos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33

4. Derivación . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 354.1. Ejemplos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 36

Notas bibliográficas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 42Ejercicios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 42

4. Diseño de algoritmos recursivos 49

1. Introducción . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 491.1. Recursión simple . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 51

v

vi Índice

1.2. Recursión final . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 531.3. Recursión múltiple . . . . . . . . . . . . . . . . . . . . . . . . . . . . 541.4. Resumen de los distintos tipos de recursión . . . . . . . . . . . . . . 56

2. Diseño de algoritmos recursivos . . . . . . . . . . . . . . . . . . . . . . . . . 562.1. Implementación recursiva de la búsqueda binaria . . . . . . . . . . . 612.2. Algoritmos avanzados de ordenación . . . . . . . . . . . . . . . . . . 68

3. Análisis de la complejidad de algoritmos recursivos . . . . . . . . . . . . . . 763.1. Ecuaciones de recurrencias . . . . . . . . . . . . . . . . . . . . . . . . 763.2. Despliegue de recurrencias . . . . . . . . . . . . . . . . . . . . . . . . 773.3. Resolución general de recurrencias . . . . . . . . . . . . . . . . . . . 80

4. Técnicas de generalización de algoritmos recursivos . . . . . . . . . . . . . . 824.1. Planteamientos recursivos finales . . . . . . . . . . . . . . . . . . . . 834.2. Generalización por razones de eficiencia . . . . . . . . . . . . . . . . 85

5. Verificación de algoritmos recursivos . . . . . . . . . . . . . . . . . . . . . . 89Notas bibliográficas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 90Ejercicios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 90

5. Divide y Vencerás 97

1. Introducción . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 972. Ejemplos de aplicación del esquema con éxito . . . . . . . . . . . . . . . . . 993. Problema de selección . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1004. Organización de un campeonato . . . . . . . . . . . . . . . . . . . . . . . . . 103

4.1. Implementación . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1045. El problema del par más cercano . . . . . . . . . . . . . . . . . . . . . . . . 106

5.1. Corrección . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1075.2. Implementación . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 108

6. La determinación del umbral . . . . . . . . . . . . . . . . . . . . . . . . . . 112Notas bibliográficas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 114Ejercicios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 114

6. Vuelta Atrás 119

1. Motivación . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1192. Introducción . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 120

2.1. Esquema básico de la vuelta atrás . . . . . . . . . . . . . . . . . . . . 1222.2. Resolución del problema de las palabras . . . . . . . . . . . . . . . . 123

3. Vuelta atrás con marcaje . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1244. Ejemplo: problema de las n-reinas . . . . . . . . . . . . . . . . . . . . . . . . 1255. Ejemplo de búsqueda de una sola solución: Dominó . . . . . . . . . . . . . . 1276. Ejemplo que no necesita desmarcar: El laberinto . . . . . . . . . . . . . . . 1297. Optimización . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 131

7.1. Ejemplo: Problema del viajante . . . . . . . . . . . . . . . . . . . . . 1317.2. Ejemplo: Problema de la mochila . . . . . . . . . . . . . . . . . . . . 133

8. Para terminar... . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 134Notas bibliográficas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 135Ejercicios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 135

7. Implementación y uso de TADs 139

Estructura de Datos y Algoritmos

Índice vii

1. Motivación . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1392. Introducción . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 140

2.1. Abstracción . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1402.2. TADs de usuario . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1412.3. Diseño con TADs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 144

3. Implementación de TADs . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1473.1. Tipos de operaciones y el modificador const . . . . . . . . . . . . . . 1473.2. Uso de sub-TADs y extensión de TADs . . . . . . . . . . . . . . . . . 1483.3. TADs genéricos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1493.4. Implementación, parcialidad y errores . . . . . . . . . . . . . . . . . 1503.5. Implementaciones dinámicas y estáticas . . . . . . . . . . . . . . . . 160

4. Probando y documentando TADs . . . . . . . . . . . . . . . . . . . . . . . . 1644.1. Documentando TADs . . . . . . . . . . . . . . . . . . . . . . . . . . 166

5. Para terminar... . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 169Notas bibliográficas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 170Ejercicios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 170

8. Diseño e implementación de TADs lineales 175

1. Motivación . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1752. Estructuras de datos lineales . . . . . . . . . . . . . . . . . . . . . . . . . . . 176

2.1. Vectores de elementos . . . . . . . . . . . . . . . . . . . . . . . . . . 1762.2. Listas enlazadas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1792.3. En el mundo real... . . . . . . . . . . . . . . . . . . . . . . . . . . . . 181

3. Pilas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1823.1. Implementación de pilas con vector dinámico . . . . . . . . . . . . . 1833.2. Implementación de pilas con una lista enlazada . . . . . . . . . . . . 185

4. Colas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1874.1. Implementación de colas con un vector . . . . . . . . . . . . . . . . . 1874.2. Implementación de colas con una lista enlazada . . . . . . . . . . . . 1884.3. Implementación de colas con una lista enlazada y nodo fantasma . . 190

5. Colas dobles . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1906. Listas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1957. Recorridos de listas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 200

7.1. Implementación de un iterador básico . . . . . . . . . . . . . . . . . 2017.2. Iteradores para modificar elementos . . . . . . . . . . . . . . . . . . 2037.3. Usando iteradores para insertar elementos . . . . . . . . . . . . . . . 2047.4. Usando iteradores para eliminar elementos . . . . . . . . . . . . . . . 2057.5. Peligros de los iteradores . . . . . . . . . . . . . . . . . . . . . . . . . 2057.6. En el mundo real... . . . . . . . . . . . . . . . . . . . . . . . . . . . . 206

8. Para terminar... . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 207Notas bibliográficas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 208Ejercicios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 208

9. Diseño e implementación de TADs arborescentes 215

1. Motivación . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2152. Introducción . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 216

2.1. Modelo matemático . . . . . . . . . . . . . . . . . . . . . . . . . . . 216

Facultad de Informática - UCM

viii Índice

2.2. Terminología . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2172.3. Tipos de árboles . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 218

3. Árboles binarios: operaciones . . . . . . . . . . . . . . . . . . . . . . . . . . 2184. Implementación de árboles binarios . . . . . . . . . . . . . . . . . . . . . . . 2195. Recorridos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2246. Implementación eficiente de los árboles binarios . . . . . . . . . . . . . . . . 2277. Implementación estática ad-hoc de árboles binarios . . . . . . . . . . . . . . 2308. En el mundo real... . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2319. Árboles generales . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23210. Para terminar... . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 232Notas bibliográficas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 233Ejercicios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 233

10.Diccionarios 241

1. Motivación . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2412. Introducción . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 241

2.1. Especificación . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2422.2. Implementación con acceso basado en búsqueda . . . . . . . . . . . . 243

3. Árboles de búsqueda . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2443.1. Implementación . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2453.2. Coste de las operaciones . . . . . . . . . . . . . . . . . . . . . . . . . 2533.3. Recorrido de los elementos mediante un iterador . . . . . . . . . . . 2543.4. Búsqueda en el diccionario con iteradores . . . . . . . . . . . . . . . 256

4. Tablas dispersas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2574.1. Función de localización . . . . . . . . . . . . . . . . . . . . . . . . . . 2574.2. Colisiones . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 258

5. Tablas dispersas abiertas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2595.1. Invariante de la representación . . . . . . . . . . . . . . . . . . . . . 2595.2. Implementación de las operaciones auxiliares . . . . . . . . . . . . . 2625.3. Implementación de las operaciones públicas . . . . . . . . . . . . . . 2645.4. Tablas dinámicas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2665.5. Recorrido usando iteradores . . . . . . . . . . . . . . . . . . . . . . . 268

6. Funciones de localización . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2706.1. Para enteros . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2716.2. Para cadenas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2726.3. Para clases definidas por el programador . . . . . . . . . . . . . . . . 272

7. En el mundo real... . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2748. Para terminar... . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 274Notas bibliográficas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 275Ejercicios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 275

11.Aplicaciones de tipos abstractos de datos 279

1. Problemas resueltos: . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2791.1. Confederación hidrográfica. . . . . . . . . . . . . . . . . . . . . . . . 2791.2. Motor de búsqueda. . . . . . . . . . . . . . . . . . . . . . . . . . . . 2831.3. Agencia de viajes. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2861.4. E-reader. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 289

Estructura de Datos y Algoritmos

Índice ix

2. Problemas propuestos: . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 302

Bibliografía 307

Facultad de Informática - UCM

Índice de figuras

1. Crecimiento de distintas funciones de complejidad . . . . . . . . . . . . . . . 62. Jerarquía de órdenes de complejidad . . . . . . . . . . . . . . . . . . . . . . 7

1. Ejecución de factorial(3) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 502. Llamadas recursivas de factorial(3) . . . . . . . . . . . . . . . . . . . . . . . 513. Vuelta de las llamadas recursivas de factorial(3) . . . . . . . . . . . . . . . . 514. Ejecución de fib(4) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 565. Cálculo del punto medio . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 626. Búsqueda en la mitad derecha . . . . . . . . . . . . . . . . . . . . . . . . . . 627. Búsqueda en la mitad izquierda . . . . . . . . . . . . . . . . . . . . . . . . . 628. Planteamiento del algoritmo quicksort . . . . . . . . . . . . . . . . . . . . . 699. Diseño de particion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7110. Planteamiento del algoritmo mergesort . . . . . . . . . . . . . . . . . . . . . 7311. Diseño de mezcla . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 75

1. Solución gráfica del problema del torneo . . . . . . . . . . . . . . . . . . . . 1052. Razonamiento de corrección del problema del par más cercano . . . . . . . . 108

1. Función de abstracción y vistas del usuario y el implementador . . . . . . . 1522. Conjunto antes y después de insertar el elemento 4 . . . . . . . . . . . . . . 1553. Conjuntos equivalentes (según la función de equivalencia del TAD) . . . . . 155

1. Posiciones y valores de cada nodo de un árbol. . . . . . . . . . . . . . . . . . 2172. Distintas formas de recorrer un árbol. . . . . . . . . . . . . . . . . . . . . . 224

1. Dos árboles de búsqueda distintos pero equivalentes. . . . . . . . . . . . . . 2462. Ejemplo de tabla abierta. La función de localización usada en el ejemplo es

claramente mejorable. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 260

xi

Índice de Tablas

xiii

Capítulo 1

Análisis de la eficiencia de losalgoritmos 1

No puede haber orden cuando hay mucha prisa

Seneca

Resumen: En este tema se muestra la importancia de contar con algoritmos eficien-

tes, se define qué se entiende por coste de un algoritmo y se enseña a comparar las

funciones de coste de distintos algoritmos con el fin de decidir cuál de ellos es preferi-

ble. Se define una jerarquía de órdenes de complejidad que ilustra la separación entre

algoritmos eficientes y los que no lo son.

1. Introducción

⋆ Aproximadamente cada año y medio se duplica el número de instrucciones por se-gundo que son capaces de ejecutar los computadores. Ello puede inducir a pensarque basta con esperar algunos años para que problemas que hoy necesitan muchashoras de cálculo puedan resolverse en pocos segundos.

⋆ Sin embargo hay algoritmos tan ineficientes que ningún avance en la velocidad de lasmáquinas podrá conseguir para ellos tiempos aceptables. El factor predominante quedelimita lo que es soluble en un tiempo razonable de lo que no lo es, es precisamenteel algoritmo elegido para resolver el problema.

⋆ En este capítulo enseñaremos a medir la eficiencia de los algoritmos y a compararla eficiencia de distintos algoritmos para un mismo problema. Después de la correc-ción, conseguir eficiencia debe ser el principal objetivo del programador. Mediremosprincipalmente la eficiencia en tiempo de ejecución, pero los mismos conceptosson aplicables a la medición de la eficiencia en espacio, es decir a medir la memoriaque necesita el algoritmo.

⋆ El siguiente programa ordena un vector a[0..n− 1] por el método de selección:

1Ricardo Peña es el autor principal de este tema.

1

2 Capítulo 1. Análisis de la eficiencia

1 int a[n];

2 int i, j, pmin, temp;

3 for (i = 0; i < n-1; i++)

4 // pmin c a l c u l a l a p o s i c i ó n d e l mínimo de a [ i . . n−1]5 pmin = i;

6 for (j = i+1; j < n; j++)

7 if (a[j] < a[pmin]) pmin = j;

8 // ponemos e l mínimo en a [ i ]9 temp = a[i]; a[i] = a[pmin]; a[pmin] = temp;

10

⋆ Una manera de medir la eficiencia en tiempo de este programa es contar cuántasinstrucciones de cada tipo se ejecutan, multiplicar este número por el tiempo queemplea la instrucción en ejecutarse, y realizar la suma para los diferentes tipos. Sean

ta = tiempo de una asignación entre enteros (1.1)

tc = tiempo de una comparación entre enteros

ti = tiempo de incrementar un entero

tv = tiempo de acceso a un elemento de un vector

La línea (3) da lugar a una asignación, a n−1 incrementos y a n comparaciones,es decir, a un tiempo ta + (n− 1)ti + ntc.

La línea (5) da lugar a un tiempo (n− 1)ta.

El bucle interior for se ejecuta n− 1 veces, cada una con un valor diferente dei. Para cada valor de i y siguiendo el cálculo hecho para la (3), la línea (6) dalugar a un tiempo ta + (n− i− 1)ti + (n− i)tc.

La línea (7) da, para cada valor de i, un tiempo mínimo de (n− i− 1)(2tv + tc),suponiendo que la instrucción pmin = j nunca se ejecuta. A ello hay que sumar(n− i− 1)ta en el caso más desfavorable en que dicha rama se ejecute todas lasveces. El caso promedio tendrá un tiempo de ejecución entre estos dos.

Finalmente, la línea (9) dará lugar a un tiempo (n− 1)(4tv + 3ta).

Por tanto, el tiempo del bucle interior for, en el caso más desfavorable, secalcula mediante el siguiente sumatorio:

n−2∑

i=0

(ta + tc + (n− i− 1)(ti + 2tv + ta + 2tc)) = P (n− 1) +1

2Qn(n− 1)

siendo P = ta + tc y Q = ti + 2tv + ta + 2tc.

Para no cansar al lector con tediosos cálculos, concluiremos que la suma de todosestos tiempos da lugar a dos polinomios de la forma:

Tmin = An2 −Bn+ C

Tmax = A′n2 −B′n+ C ′

donde A, A′, B, B′, C y C ′ son expresiones racionales positivas que dependen lineal-mente de los tiempos elementales descritos en 1.1.

⋆ En este sencillo ejemplo se observan claramente los tres factores de los que en generaldepende el tiempo de ejecución de un algoritmo:

Estructura de Datos y Algoritmos

2. Medidas asintóticas de la eficiencia 3

1. El tamaño de los datos de entrada, simbolizado aquí por la longitud n delvector.

2. El contenido de los datos de entrada, que en el ejemplo hace que el tiempopara diferentes vectores del mismo tamaño esté comprendido entre los valoresTmin y Tmax .

3. El código generado por el compilador y el computador concreto utilizados,que afectan a los tiempos elementales 1.1.

⋆ Como el objetivo es poder comparar algoritmos independientemente del valor de losdatos de entrada, el segundo factor podemos eliminarlo de dos maneras:

O bien midiendo solo el caso peor, es decir la ejecución que tarde más tiempode todos los ejemplares de tamaño n.

O bien midiendo todos los casos de tamaño n y calculando el tiempo del casopromedio.

En esta asignatura nos concentraremos en el caso peor por dos razones:

1. El caso peor establece una cota superior fiable para todos los casos del mismotamaño.

2. El caso peor es más fácil de calcular.

El caso promedio es más difícil de calcular pero a veces es más informativo. Ademásexige conocer la probabilidad con la que se va a presentar cada caso. Muy raramentepuede ser útil conocer el caso mejor de un algoritmo para un tamaño n dado. Esecoste es una cota inferior al coste de cualquier otro ejemplar de ese tamaño.

⋆ El tercer factor impediría comparar algoritmos escritos en diferentes lenguajes, tra-ducidos por diferentes compiladores, o ejecutados en diferentes máquinas. El criterioque seguiremos es ignorar estos factores.

⋆ Por tanto solo mediremos la eficiencia de un algoritmo en función del tamaño delos datos de entrada. Este criterio está en la base de lo que llamaremos medidaasintótica de la eficiencia.

2. Medidas asintóticas de la eficiencia

⋆ El criterio asintótico para medir la eficiencia de los algoritmos tiene como objetivocomparar algoritmos independientemente de los lenguajes en que están escritos,de las máquinas en que se ejecutan y del valor concreto de los datos que recibencomo entrada. Tan solo considera importante el tamaño de dichos datos. Para cadaproblema habrá que definir qué se entiende por tamaño del mismo.

⋆ Se basa en tres principios:

1. El coste o eficiencia es una función que solo depende del tamaño de la entrada,e.g. f(n) = n2.

2. Las constantes multiplicativas o aditivas no se tienen en cuenta, e.g. f(n) = n2

y g(n) = 3n2 + 27 se consideran costes equivalentes.

Facultad de Informática - UCM

4 Capítulo 1. Análisis de la eficiencia

3. La comparación entre funciones de coste se hará para valores de n suficien-temente grandes, es decir los costes para tamaños pequeños se consideranirrelevantes.

⋆ Sea N el conjunto de los números naturales y R+ el conjunto de los reales estricta-

mente positivos.

Definición 1.1 Sea f : N−→ R+ ∪ 0. El conjunto de las funciones del orden de

f(n), denotado O(f(n)), se define como:

O(f(n)) = g : N−→ R+ ∪ 0 | ∃c ∈ R

+, n0 ∈ N . ∀n ≥ n0 . g(n) ≤ cf(n)

Asímismo, diremos que una función g es del orden de f(n) cuando g ∈ O(f(n)).También diremos que g está en O(f(n)).

cf(n)

g(n)

⋆ Generalizando, admitiremos también que una función negativa o indefinida para unnúmero finito de valores de n pertenece al conjunto O(f(n)) si eligiendo n0 suficien-temente grande, satisface la definición.

⋆ Esta garantiza que, si el tiempo de ejecución g(n) de una implementación concretade un algoritmo es del orden de f(n), entonces el tiempo g′(n) de cualquier otraimplementación del mismo que difiera de la anterior en el lenguaje, el compilador,o/y la máquina empleada, también será del orden de f(n). Por tanto, el coste O(f(n))expresa la eficiencia del algoritmo per se, no el de una implementación concreta delmismo.

⋆ Las clases O(f(n)) para diferentes funciones f(n) se denominan clases de comple-jidad, u órdenes de complejidad. Algunos órdenes tienen nombre propio. Así, alorden de complejidad O(n) se le llama lineal, al orden O(n2), cuadrático, el ordenO(1) describe la clase de las funciones constantes, etc. Eligiremos como represen-tante del orden O(f(n)) la función f(n) más sencilla posible dentro del mismo.

⋆ Nótese que la definición 1.1 se puede aplicar tanto a un análisis en el caso peor, comoa un análisis en el caso promedio. Por ejemplo, hay algoritmos cuyo coste en tiempoestá en O(n2) en el caso peor y en O(n log n) en el caso promedio.

⋆ Nótese también que las unidades en que se mide el coste en tiempo (horas, segundos,milisegundos, etc.), o en memoria (octetos, palabras, celdas de longitud fija, etc.) noson relevantes en la complejidad asintótica: dos unidades distintas se diferencianen una constante multiplicativa (e.g. 120 n2 segundos son 2 n2 minutos, ambos enO(n2)).

⋆ Aplicando directamente la definición de O(f(n)), demostremos que (n+1)2 ∈ O(n2).Un modo de hacerlo es por inducción sobre n. Elegimos n0 = 1 y c = 4, es decirdemostraremos ∀n ≥ 1 . (n+ 1)2 ≤ 4n2:

Estructura de Datos y Algoritmos

2. Medidas asintóticas de la eficiencia 5

Caso base: n = 1, (1 + 1)2 ≤ 4 · 12

Paso inductivo: h.i. (n+ 1)2 ≤ 4n2. Demostrémoslo para n+ 1:

(n+ 1 + 1)2 ≤ 4(n+ 1)2

(n+ 1)2 + 1 + 2(n+ 1) ≤ 4n2 + 4 + 8n

(n+ 1)2 ≤ 4n2 + 6n+ 1︸ ︷︷ ︸

≥0

⋆ También podemos probar que 3n 6∈ O(2n). Si perteneciera, existiría c ∈ R+, n0 ∈ N

tales que 3n ≤ c · 2n para todo n ≥ n0. Esto implicaría que (32)n ≤ c para todo

n ≥ n0. Pero esto es falso porque dado un c cualquiera, bastaría tomar n > log1,5 c

para que (32)n > c, es decir (32)

n no se puede acotar superiormente.

⋆ La notación O(f(n)) nos da una cota superior al tiempo de ejecución t(n) de unalgoritmo. Normalmente estaremos interesados en la menor función f(n) tal quet(n) ∈ O(f(n)). Una forma de realizar un análisis más completo es encontrar ademásla mayor función g(n) que sea una cota inferior de t(n). Para ello introducimos lasiguiente medida.

Definición 1.2 Sea f : N−→ R+ ∪ 0. El conjunto Ω(f(n)), leído omega de f(n),

se define como:

Ω(f(n)) = g : N−→ R+ ∪ 0 | ∃c ∈ R

+, n0 ∈ N . ∀n ≥ n0 . g(n) ≥ cf(n)

g(n)

cf(n)

⋆ Es frecuente confundir la medida O(f(n)) como aplicable al caso peor y la medidaΩ(f(n)) como aplicable al caso mejor. Esta idea es errónea. Aplicaremos ambasmedidas al caso peor (también podríamos aplicar ambas al caso promedio, o alcaso mejor). Si el tiempo t(n) de un algoritmo en el caso peor está en O(f(n)) y enΩ(g(n)), lo que estamos diciendo es que t(n) no puede valer más que c1f(n), ni menosque c2g(n), para dos constantes apropiadas c1 y c2 y valores de n suficientementegrandes.

⋆ Es fácil demostrar (ver ejercicios) el llamado principio de dualidad: g(n) ∈ O(f(n))si y sólo si f(n) ∈ Ω(g(n)).

⋆ Sucede con frecuencia que una misma función f(n) es a la vez cota superior e inferiordel tiempo t(n) (peor, promedio, etc.) de un algoritmo. Para tratar estos casos,introducimos la siguiente medida.

Definición 1.3 El conjunto de funciones Θ(f(n)), leído del orden exacto de f(n),se define como:

Θ(f(n)) = O(f(n)) ∩ Ω(f(n))

Facultad de Informática - UCM

6 Capítulo 1. Análisis de la eficiencia

n log10

n n n log10

n n2 n3 2n

10 1 ms 10 ms 10 ms 0.1 s 1 s 1.02 s

102 2 ms 0.1 s 0.2 s 10 s 16.67 m 4.02∗1020 sig

103 3 ms 1 s 3 s 16.67 m 11.57 d 3.4∗10291 sig

104 4 ms 10 s 40 s 1.16 d 31.71 a 6.3 ∗ 103000 sig

105 5 ms 1.67 m 8.33 m 115.74 d 317.1 sig 3.16 ∗ 1030093 sig

106 6 ms 16.67 m 1.67 h 31.71 a 317 097.9 sig 3.1 ∗ 10301020 sig

Figura 1: Crecimiento de distintas funciones de complejidad

También se puede definir como:

Θ(f(n)) = g : N−→ R+ ∪ 0 | ∃c1, c2 ∈ R

+, n0 ∈ N .∀n ≥ n0 . c1f(n) ≤ g(n) ≤ c2f(n)

g(n)

c1f(n)

c2f(n)

⋆ Siempre que sea posible, daremos el orden exacto del coste de un algoritmo, por sermás informativo que dar solo una cota superior.

3. Jerarquía de órdenes de complejidad

⋆ Es importante visualizar las implicaciones prácticas de que el coste de un algoritmopertenezca a una u otra clase de complejidad. La Figura 1 muestra el crecimientode algunas de estas funciones, suponiendo que expresan un tiempo en milisegundos(ms = milisegundos, s = segundos, m = minutos, h = horas, etc.).

⋆ Se aprecia inmediatamente la extraordinaria eficiencia de los algoritmos de costeen O(log n): pasar de un tamaño de n = 10 a n = 1 000 000 solo hace que eltiempo crezca de 1 milisegundo a 6. La búsqueda binaria en un vector ordenado, yla búsqueda en ciertas estructuras de datos de este curso, tienen este coste en el casopeor.

⋆ En sentido contrario, los algoritmos de coste O(2n) son prácticamente inútiles:mientras que un problema de tamaño n = 10 se resuelve en aproximadamente unsegundo, la edad del universo conocido (1, 4×108 siglos) sería totalmente insuficientepara resolver uno de tamaño n = 100. Algunos algoritmos de vuelta atrás que veremosen este curso tienen ese coste en el caso peor.

Estructura de Datos y Algoritmos

4. Propiedades de los órdenes de complejidad 7

O(1) ⊂ O(log n) ⊂ O(n) ⊂ O(n log n) ⊂ O(n2)︸ ︷︷ ︸

razonables en la práctica

⊂ . . . ⊂ O(nk)

︸ ︷︷ ︸

tratables

⊂ . . . ⊂ O(2n) ⊂ O(n!)

︸ ︷︷ ︸

intratables

Figura 2: Jerarquía de órdenes de complejidad

⋆ Esta tabla confirma la afirmación hecha al comienzo de este capítulo de que paraciertos algoritmos es inútil esperar a que los computadores sean más rápidos. Es másproductivo invertir esfuerzo en diseñar mejores algoritmos para ese problema.

⋆ Para mejorar la intuición anterior, hagamos el siguiente experimento: supongamosseis algorimos con los costes anteriores, tales que tardan todos ellos 1 hora en re-solver un problema de tamaño n = 100. ¿Qué ocurre si duplicamos la velocidad delcomputador? O lo que es lo mismo, ¿qué ocurre si duplicamos el tiempo disponible?

t(n) t = 1h. t = 2h.

k1 · log n n = 100 n = 10 000

k2 · n n = 100 n = 200

k3 · n log n n = 100 n = 178

k4 · n2 n = 100 n = 141

k5 · n3 n = 100 n = 126

k6 · 2n n = 100 n = 101

⋆ Observamos que mientras el de coste logarítmico es capaz de resolver problemas 100veces más grandes, el de coste exponencial resuelve un tamaño practicamente igualal anterior. Obsérvese que los de coste O(n) y O(n log n) se comportan de acuerdo ala intuición de un usuario no informático: al duplicar la velocidad del computador (oel tiempo disponible), se duplica aproximadamente el tamaño del problema resuelto.En los de coste O(nk), al duplicar la velocidad, el tamaño se multiplica por un factork√2.

⋆ En la Figura 2 se muestra la jerarquía de órdenes de complejidad. Las inclu-siones estrictas expresan que se trata de clases distintas. Los algoritmos cuyos costesestán en la parte izquierda resuelven problemas que se denominan tratables. Estoscostes se denominan en su conjunto polinomiales. Hay problemas que sólo admitenalgoritmos de complejidad exponencial o superior. Se llaman intratables.

⋆ También hay muchos problemas interesantes cuyos mejores algoritmos conocidos sonexponenciales en el caso peor, pero no se sabe si existirán para ellos algoritmospolinomiales. Se llaman NP-completos y se verán en el próximo curso. El másconocido de todos es el problema SAT que consiste en determinar si una fórmula dela lógica proposicional es satisfactible.

4. Propiedades de los órdenes de complejidad

⋆ O(a · f(n)) = O(f(n)) con a ∈ R+.

Facultad de Informática - UCM

8 Capítulo 1. Análisis de la eficiencia

(⊆) g ∈ O(a ·f(n)) ⇔ ∃c ∈ R+, n0 ∈ N tal que ∀n ≥ n0 . g(n) ≤ c ·a ·f(n). Tomando

c′ = c · a se cumple que ∀n ≥ n0 . g(n) ≤ c′ · f(n), luego g ∈ O(f(n)).

(⊇) g ∈ O(f(n)) ⇔ ∃c ∈ R+, n0 ∈ N tal que ∀n ≥ n0 . g(n) ≤ c · f(n).

Entonces tomando c′ = ca

se cumple que ∀n ≥ n0 . g(n) ≤ c′ · a · f(n), luegog ∈ O(a · f(n)).

⋆ La base del logaritmo no importa: O(loga n) = O(logb n), con a, b > 1. La demostra-ción es inmediata sabiendo que:

logb n =loga n

loga b

⋆ Si f ∈ O(g) y g ∈ O(h), entonces f ∈ O(h).

f ∈ O(g) ⇒ ∃c1 ∈ R+, n1 ∈ N tal que ∀n ≥ n1 . f(n) ≤ c1 · g(n)

g ∈ O(h) ⇒ ∃c2 ∈ R+, n2 ∈ N tal que ∀n ≥ n2 . g(n) ≤ c2 · h(n)

Tomando n0 = max(n1, n2) y c = c1 · c2, se cumple

∀n ≥ n0 . f(n) ≤ c1 · g(n) ≤ c1 · c2 · h(n)

Y por tanto f ∈ O(h).

⋆ Regla de la suma: O(f + g) = O(max(f, g)).

(⊆) h ∈ O(f + g) ⇒ ∃c ∈ R+, n0 ∈ N . ∀n ≥ n0 . h(n) ≤ c · (f(n) + g(n)). Pero

f ≤ max(f, g) y g ≤ max(f, g), luego:

h(n) ≤ c · (max(f(n), g(n)) + max(f(n), g(n))) = 2 · c ·max(f(n), g(n))

Tomando c′ = 2 · c se cumple que ∀n ≥ n0 . h(n) ≤ c′ · max(f(n), g(n)) y portanto h ∈ O(max(f, g)).

(⊇) h ∈ O(max(f, g)) ⇒ ∃c ∈ R+, n0 ∈ N . ∀n ≥ n0 . h(n) ≤ c · max(f(n), g(n)).

Pero max(f, g) ≤ f + g, luego h ∈ O(f + g) trivialmente.

⋆ Regla del producto: Si g1 ∈ O(f1) y g2 ∈ O(f2), entonces g1 · g2 ∈ O(f1 · f2). Lademostración es similar.

⋆ Teorema del límite

• lımn→∞f(n)g(n) = m ∈ R

+ ⇒ f ∈ O(g) y g ∈ O(f) ⇔ O(f) = O(g)

• lımn→∞f(n)g(n) = 0 ⇒ f ∈ O(g) y g 6∈ O(f) ⇔ O(f) ⊂ O(g)

• lımn→∞f(n)g(n) = +∞ ⇒ f 6∈ O(g) y g ∈ O(f) ⇔ O(f) ⊃ O(g)

Estructura de Datos y Algoritmos

Notas bibliográficas 9

⋆ Por el principio de dualidad, también tenemos:

• lımn→∞f(n)g(n) = m ∈ R

+ ⇒ g ∈ Ω(f) y f ∈ Ω(g) ⇔ Ω(f) = Ω(g)

• lımn→∞f(n)g(n) = 0 ⇒ g ∈ Ω(f) y f 6∈ Ω(g) ⇔ Ω(f) ⊃ Ω(g)

• lımn→∞f(n)g(n) = +∞ ⇒ g 6∈ Ω(f) y f ∈ Ω(g) ⇔ Ω(f) ⊂ Ω(g)

⋆ Aplicando la definición de Θ(f), también tenemos:

• lımn→∞f(n)g(n) = m ∈ R

+ ⇒ g ∈ Θ(f) y f ∈ Θ(g)

• lımn→∞f(n)g(n) = 0 ⇒ f ∈ O(g) pero f 6∈ Θ(g)

• lımn→∞f(n)g(n) = +∞ ⇒ g ∈ O(f) pero g 6∈ Θ(f)

Notas bibliográficas

Se recomienda ampliar el contenido de estas notas estudiando el Capítulo 1 de (Peña,2005) en el cual se han basado. También la Sección 1.4 de (Rodríguez Artalejo et al., 2011).

El Capítulo 3 de (Martí Oliet et al., 2012) contiene material válido para este capítuloy material adicional que será utilizado en los Capítulos 3 y 4. También tiene numerososejemplos resueltos.

Ejercicios

1. Demostrar el Principio de dualidad, es decir g(n) ∈ O(f(n)) ⇔ f(n) ∈ Ω(g(n)).

2. Demostrar que todo polinomio amnm + · · · + a1n + a0, en n y de grado m, cuyocoeficiente am correspondiente al mayor grado sea positivo, está en O(nm).

3. Demostrar

lımn→∞

f(n)

g(n)= 0 ⇒ O(f(n)) ⊂ O(g(n))

Dar un ejemplo de que la implicación inversa puede no ser cierta.

4. Demostrar

lımn→∞

f(n)

g(n)= k > 0 ⇒ f(n) ∈ Θ(g(n))

5. Usar el teorema del límite para demostrar las siguientes inclusiones estrictas (supo-nemos k > 1):

O(1) ⊂ O(log n) ⊂ O(n) ⊂ O(nk) ⊂ O(2n) ⊂ O(n!)

6. Si tenemos dos algoritmos con costes t1(n) = 3n3 y t2(n) = 600n2, ¿cuál es mejor entérminos asintóticos? ¿A partir de que umbral el segundo es mejor que el primero?

7. Si el coste de un algoritmo está en O(n2) y tarda 1 segundo para un tamaño n = 100,¿de qué tamaño será el problema que puede resolver en 10 segundos?

8. Demostrar por inducción sobre n ≥ 0 las siguientes igualdades:

Facultad de Informática - UCM

10 Capítulo 1. Análisis de la eficiencia

a)∑n

i=1 i = n(n+ 1)/2.

b)∑n

i=1 i2 = n(n+ 1)(2n+ 1)/6.

c)∑n

i=1 2ii = (n− 1)2n+1 + 2.

9. Demostrar que∑n

i=1 ik ∈ Θ(nk+1).

10. Demostrar que log n ∈ O(√

(n)) pero que√

(n) 6∈ O(log n).

11. ¿Verdadero o falso?

a) 2n + n99 ∈ O(n99).

b) 2n + n99 ∈ Ω(n99).

c) 2n + n99 ∈ Θ(n99).

d) Si f(n) = n2, entonces f(n)3 ∈ O(n5).

e) Si f(n) ∈ O(n2) y g(n) ∈ O(n), entonces f(n)/g(n) ∈ O(n).

f ) Si f(n) = n2, entonces 3f(n) + 2n ∈ Θ(f(n)).

g) Si f(n) = n2 y g(n) = n3, entonces f(n)g(n) ∈ O(n6).

12. Comparar con respecto a O y Ω los siguientes pares de funciones:

a) 2n+1, 2n.

b) (n+ 1)!, n!.

c) log n,√n.

d) Para cualquier a ∈ R+, log n, na.

13. Supongamos que t1(n) ∈ O(f(n)) y t2(n) ∈ O(f(n)). Razonar la verdad o falsedadde las siguientes afirmaciones:

a) t1(n) + t2(n) ∈ O(f(n)).

b) t1(n) · t2(n) ∈ O(f(n2)).

c) t1(n)/t2(n) ∈ O(1).

14. (Martí Oliet et al. (2012)) Demostrar o refutar cada una de las siguientes afirmacio-nes:

a) n2 + n+ log n ∈ O(n2).

b) n2 + n+ log n ∈ Ω(n).

c) n2 + n+ log n ∈ Θ(log n).

d) 21n3 + 7n2 + n log n− 17n+ 8 ∈ O(n4).

e) 2n + 3n + n59 ∈ O(n59).

f ) 2n + 3n + n59 ∈ Ω(2n).

g) Si f(n) = n2, entonces f(n)3 ∈ Θ(f(n)3).

h) Θ(2n) = Θ(2n+2) = Θ(4n).

i) log2 n ∈ O(log3 n).

15. (Martí Oliet et al. (2012)) Para cada una de las siguientes funciones f(n), obtener elmenor número natural k tal que f(n) ∈ O(nk).

Estructura de Datos y Algoritmos

Ejercicios. . . 11

a) f(n) = 2n3 + n2 log n.

b) f(n) = 3n5 + (log n)4.

c) f(n) = (n4 + n2 + 1)/(n3 + 1).

d) f(n) = (n4 + n2 + 1)/(n4 + 1).

e) f(n) = (n4 + 5 log n)/(n4 + 1).

f ) f(n) = (n3 + 5 log n)/(n4 + 1).

16. (Martí Oliet et al. (2012)) Para cada una de las siguientes funciones f(n), encontraruna función g(n) del menor orden posible tal que f(n) ∈ O(g(n)).

a) f(n) = (n log n+ n2)(n3 + 2).

b) f(n) = (2n + n2)(n3 + 3n).

c) f(n) = n log(n2 + 1) + n2 log n.

d) f(n) = n2n + nn2

.

e) f(n) = (n! + 2n)(n3 + log(n2 + 1)).

17. (Martí Oliet et al. (2012)) Comparar con respecto a O y Ω los siguientes pares defunciones:

a) n2 + 3n+ 7, n2 + 10.

b) n2 log n, n3.

c) n4 + log(3n8 + 7), (n2 + 17n+ 3)2.

d) (n3 + n2 + n+ 1)4, (n4 + n3 + n2 + n+ 1)3.

e) log(n2 + 1), log n.

f ) 2n+3, 2n+7.

g) 22n

, 2n2

.

Facultad de Informática - UCM