Algoritmos y Estructura de Datos.pdf

7/21/2019 Algoritmos y Estructura de Datos.pdf

1/303

Algoritmos y Estructuras de Datos

Mario Storti,Jorge DEla,Rodrigo Paz,Lisandro Dalcn, y Martn Pucheta ,

www: http://www.cimec.org.ar/aedFacultad de Ingeniera y Ciencias Hdricas

Universidad Nacional del Litoral http://fich.unl.edu.arCentro Internacional de Mtodos Computacionales en Ingeniera

http://www.cimec.org.ar

(Document version: aed-2.0.4-102-g184c1cd clean)

(Date: Sat Feb 25 15:25:54 2012 -0300)
http://www.cimec.org.ar/aedhttp://fich.unl.edu.ar/http://www.cimec.org.ar/http://www.cimec.org.ar/http://fich.unl.edu.ar/http://www.cimec.org.ar/aed


2/303

Indice

1. Diseo y anlisis de algoritmos 91.1. Conceptos bsicos de algoritmos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9

1.1.1. Ejemplo: Sincronizacin de acceso a objetos en clculo distribuido . . . . . . . . . . . 101.1.2. Introduccin bsica a grafos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 111.1.3. Planteo del problema mediante grafos . . . . . . . . . . . . . . . . . . . . . . . . . . 111.1.4. Algoritmo de bsqueda exhaustiva . . . . . . . . . . . . . . . . . . . . . . . . . . . . 121.1.5. Generacin de las coloraciones . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 131.1.6. Crecimiento del tiempo de ejecucin . . . . . . . . . . . . . . . . . . . . . . . . . . . 151.1.7. Bsqueda exhaustiva mejorada . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 161.1.8. Algoritmo heurstico vido . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 191.1.9. Descripcin del algoritmo heurstico en seudo-cdigo . . . . . . . . . . . . . . . . . . 211.1.10.Crecimiento del tiempo de ejecucin para el algoritmo vido . . . . . . . . . . . . . . . 261.1.11.Conclusin del ejemplo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27

1.2. Tipos abstractos de datos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 271.2.1. Operaciones abstractas y caractersticas del TAD CONJUNTO . . . . . . . . . . . . . 281.2.2. Interfase del TAD CONJUNTO. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 281.2.3. Implementacin del TAD CONJUNTO . . . . . . . . . . . . . . . . . . . . . . . . . . . 30

1.3. Tiempo de ejecucin de un programa . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 301.3.1. Notacin asinttica . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 321.3.2. Invariancia ante constantes multiplicativas . . . . . . . . . . . . . . . . . . . . . . . . 331.3.3. Invariancia de la tasa de crecimiento ante valores en un conjunto finito de puntos . . . 331.3.4. Transitividad . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 341.3.5. Regla de la suma. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 341.3.6. Regla del producto . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 34

1.3.7. Funciones tpicas utilizadas en la notacin asinttica . . . . . . . . . . . . . . . . . . . 341.3.8. Equivalencia . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 361.3.9. La funcin factorial . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 361.3.10.Determinacin experimental de la tasa de crecimiento . . . . . . . . . . . . . . . . . . 371.3.11.Otros recursos computacionales. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 381.3.12.Tiempos de ejecucin no-polinomiales . . . . . . . . . . . . . . . . . . . . . . . . . . 391.3.13.Problemas P y NP . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 391.3.14.Varios parmetros en el problema . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 40

1.4. Conteo de operaciones para el clculo del tiempo de ejecucin . . . . . . . . . . . . . . . . . 40

1


3/303

INDICE

INDICE

1.4.1. Bloques if. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 401.4.2. Lazos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41

1.4.3. Suma de potencias. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 451.4.4. Llamadas a rutinas. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 451.4.5. Llamadas recursivas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 46

2. Tipos de datos abstractos fundamentales 482.1. El TAD Lista . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 48

2.1.1. Descripcin matemtica de las listas . . . . . . . . . . . . . . . . . . . . . . . . . . . 492.1.2. Operaciones abstractas sobre listas. . . . . . . . . . . . . . . . . . . . . . . . . . . . 492.1.3. Una interfase simple para listas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 502.1.4. Funciones que retornan referencias . . . . . . . . . . . . . . . . . . . . . . . . . . . . 522.1.5. Ejemplos de uso de la interfase bsica . . . . . . . . . . . . . . . . . . . . . . . . . . 54

2.1.6. Implementacin de listas por arreglos . . . . . . . . . . . . . . . . . . . . . . . . . . . 582.1.6.1. Eficiencia de la implementacin por arreglos . . . . . . . . . . . . . . . . . . 63

2.1.7. Implementacin mediante celdas enlazadas por punteros . . . . . . . . . . . . . . . . 642.1.7.1. El tipo posicin . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 652.1.7.2. Celda de encabezamiento . . . . . . . . . . . . . . . . . . . . . . . . . . . . 662.1.7.3. Las posicionesbegin()y end() . . . . . . . . . . . . . . . . . . . . . . . 682.1.7.4. Detalles de implementacin . . . . . . . . . . . . . . . . . . . . . . . . . . . 69

2.1.8. Implementacin mediante celdas enlazadas por cursores . . . . . . . . . . . . . . . . 702.1.8.1. Cmo conviven varias celdas en un mismo espacio . . . . . . . . . . . . . . 722.1.8.2. Gestin de celdas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 732.1.8.3. Analoga entre punteros y cursores . . . . . . . . . . . . . . . . . . . . . . . 73

2.1.9. Tiempos de ejecucin de los mtodos en las diferentes implementaciones. . . . . . . . 762.1.10.Interfase STL . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 77

2.1.10.1. Ventajas de la interfase STL . . . . . . . . . . . . . . . . . . . . . . . . . . . 772.1.10.2. Ejemplo de uso. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 78

2.1.10.2.1. Uso de templates y clases anidadas . . . . . . . . . . . . . . . . . . 782.1.10.2.2. Operadores de incremento prefijo y postfijo: . . . . . . . . . . . . . . 79

2.1.10.3. Detalles de implementacin . . . . . . . . . . . . . . . . . . . . . . . . . . . 792.1.10.4. Listas doblemente enlazadas . . . . . . . . . . . . . . . . . . . . . . . . . . 82

2.2. El TAD pila . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 822.2.1. Una calculadora RPN con una pila . . . . . . . . . . . . . . . . . . . . . . . . . . . . 832.2.2. Operaciones abstractas sobre pilas . . . . . . . . . . . . . . . . . . . . . . . . . . . . 84

2.2.3. Interfase para pila . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 842.2.4. Implementacin de una calculadora RPN . . . . . . . . . . . . . . . . . . . . . . . . . 852.2.5. Implementacin de pilas mediante listas . . . . . . . . . . . . . . . . . . . . . . . . . 882.2.6. La pila como un adaptador. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 892.2.7. Interfase STL . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 90

2.3. El TAD cola. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 902.3.1. Intercalacin de vectores ordenados . . . . . . . . . . . . . . . . . . . . . . . . . . . 91

2.3.1.1. Ordenamiento por insercin . . . . . . . . . . . . . . . . . . . . . . . . . . . 912.3.1.2. Tiempo de ejecucin . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 93

((version aed-2.0.4-102-g184c1cd clean) (date Sat Feb 25 15:25:54 2012 -0300) (proc-date Sat Feb 25 15:26:39 2012 -0300)) 2


4/303

INDICE

INDICE

2.3.1.3. Particularidades al estar las secuencias pares e impares ordenadas . . . . . 932.3.1.4. Algoritmo de intercalacin con una cola auxiliar. . . . . . . . . . . . . . . . . 94

2.3.2. Operaciones abstractas sobre colas. . . . . . . . . . . . . . . . . . . . . . . . . . . . 952.3.3. Interfase para cola . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 952.3.4. Implementacin del algoritmo de intercalacin de vectores. . . . . . . . . . . . . . . . 96

2.3.4.1. Tiempo de ejecucin . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 972.4. El TAD correspondencia . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 97

2.4.1. Interfase simple para correspondencias . . . . . . . . . . . . . . . . . . . . . . . . . . 1002.4.2. Implementacin de correspondencias mediante contenedores lineales . . . . . . . . . 1022.4.3. Implementacin mediante contenedores lineales ordenados . . . . . . . . . . . . . . . 103

2.4.3.1. Implementacin mediante listas ordenadas . . . . . . . . . . . . . . . . . . . 1052.4.3.2. Interfase compatible con STL . . . . . . . . . . . . . . . . . . . . . . . . . . 1062.4.3.3. Tiempos de ejecucin para listas ordenadas . . . . . . . . . . . . . . . . . . 109

2.4.3.4. Implementacin mediante vectores ordenados . . . . . . . . . . . . . . . . . 1102.4.3.5. Tiempos de ejecucin para vectores ordenados . . . . . . . . . . . . . . . . 112

2.4.4. Definicin de una relacin de orden . . . . . . . . . . . . . . . . . . . . . . . . . . . . 113

3. Arboles 1143.1. Nomenclatura bsica de rboles . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 114

3.1.0.0.1. Altura de un nodo. . . . . . . . . . . . . . . . . . . . . . . . . . . . 1163.1.0.0.2. Profundidad de un nodo. Nivel.. . . . . . . . . . . . . . . . . . . . . 1163.1.0.0.3. Nodos hermanos . . . . . . . . . . . . . . . . . . . . . . . . . . . . 116

3.2. Orden de los nodos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1163.2.1. Particionamiento del conjunto de nodos . . . . . . . . . . . . . . . . . . . . . . . . . . 117

3.2.2. Listado de los nodos de un rbol . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1193.2.2.1. Orden previo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1193.2.2.2. Orden posterior. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1193.2.2.3. Orden posterior y la notacin polaca invertida . . . . . . . . . . . . . . . . . 120

3.2.3. Notacin Lisp para rboles. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1213.2.4. Reconstruccin del rbol a partir de sus rdenes . . . . . . . . . . . . . . . . . . . . . 122

3.3. Operaciones con rboles . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1243.3.1. Algoritmos para listar nodos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1243.3.2. Insercin en rboles . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 125

3.3.2.1. Algoritmo para copiar rboles . . . . . . . . . . . . . . . . . . . . . . . . . . 1263.3.3. Supresin en rboles . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 128

3.3.4. Operaciones bsicas sobre el tipo rbol. . . . . . . . . . . . . . . . . . . . . . . . . . 1293.4. Interfase bsica para rboles . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 129

3.4.1. Listados en orden previo y posterior y notacin Lisp . . . . . . . . . . . . . . . . . . . 1323.4.2. Funciones auxiliares para recursin y sobrecarga de funciones . . . . . . . . . . . . . 1333.4.3. Algoritmos de copia . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1333.4.4. Algoritmo de poda . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 133

3.5. Implementacin de la interfase bsica por punteros . . . . . . . . . . . . . . . . . . . . . . . 1343.5.1. El tipo iterator . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1343.5.2. Las clases cell e iterator_t . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 136



5/303

INDICE

INDICE

3.5.3. La clase tree . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1393.6. Interfase avanzada. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 141

3.6.1. Ejemplo de uso de la interfase avanzada . . . . . . . . . . . . . . . . . . . . . . . . . 1453.7. Tiempos de ejecucin . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1483.8. Arboles binarios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 148

3.8.1. Listados en orden simtrico . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1493.8.2. Notacin Lisp. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1493.8.3. rbol binario lleno . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1493.8.4. Operaciones bsicas sobre rboles binarios . . . . . . . . . . . . . . . . . . . . . . . 1503.8.5. Interfases e implementaciones. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 151

3.8.5.1. Interfase bsica . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1513.8.5.2. Ejemplo de uso. Predicados de igualdad y espejo . . . . . . . . . . . . . . . 1513.8.5.3. Ejemplo de uso. Hacer espejo in place . . . . . . . . . . . . . . . . . . . . 153

3.8.5.4. Implementacin con celdas enlazadas por punteros . . . . . . . . . . . . . . 1543.8.5.5. Interfase avanzada . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1593.8.5.6. Ejemplo de uso. El algoritmo apply y principios de programacin funcional. . 1603.8.5.7. Implementacin de la interfase avanzada . . . . . . . . . . . . . . . . . . . . 161

3.8.6. Arboles de Huffman . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1643.8.6.1. Condicin de prefijos. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1663.8.6.2. Representacin de cdigos como rboles de Huffman . . . . . . . . . . . . . 1663.8.6.3. Cdigos redundantes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1673.8.6.4. Tabla de cdigos ptima. Algoritmo de bsqueda exhaustiva. . . . . . . . . . 168

3.8.6.4.1. Generacin de los rboles . . . . . . . . . . . . . . . . . . . . . . . 1693.8.6.4.2. Agregando un condimento de programacin funcional . . . . . . . . 171

3.8.6.4.3. El algoritmo de combinacin . . . . . . . . . . . . . . . . . . . . . . 1723.8.6.4.4. Funcin auxiliar que calcula la longitud media . . . . . . . . . . . . 1743.8.6.4.5. Uso de comb y codelen. . . . . . . . . . . . . . . . . . . . . . . . . 175

3.8.6.5. El algoritmo de Huffman . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1763.8.6.6. Implementacin del algoritmo . . . . . . . . . . . . . . . . . . . . . . . . . . 1783.8.6.7. Un programa de compresin de archivos . . . . . . . . . . . . . . . . . . . . 181

4. Conjuntos 1904.1. Introduccin a los conjuntos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 190

4.1.1. Notacin de conjuntos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1904.1.2. Interfase bsica para conjuntos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 191

4.1.3. Anlisis de flujo de datos. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1924.2. Implementacin por vectores de bits . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 197

4.2.1. Conjuntos universales que no son rangos contiguos de enteros . . . . . . . . . . . . . 1984.2.2. Descripcin del cdigo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 198

4.3. Implementacin con listas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2004.3.0.1. Similaridad entre los TAD conjunto y correspondencia . . . . . . . . . . . . . 2004.3.0.2. Algoritmo lineal para las operaciones binarias . . . . . . . . . . . . . . . . . 2014.3.0.3. Descripcin de la implementacin . . . . . . . . . . . . . . . . . . . . . . . . 2034.3.0.4. Tiempos de ejecucin . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 206



6/303

INDICE

INDICE

4.4. Interfase avanzada para conjuntos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2064.5. El diccionario. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 209

4.5.1. La estructura tabla de dispersin . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2094.5.2. Tablas de dispersin abiertas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 210

4.5.2.1. Detalles de implementacin . . . . . . . . . . . . . . . . . . . . . . . . . . . 2104.5.2.2. Tiempos de ejecucin . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 213

4.5.3. Funciones de dispersin . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2144.5.4. Tablas de dispersin cerradas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 215

4.5.4.1. Costo de la insercin exitosa . . . . . . . . . . . . . . . . . . . . . . . . . . 2164.5.4.2. Costo de la insercin no exitosa . . . . . . . . . . . . . . . . . . . . . . . . . 2184.5.4.3. Costo de la bsqueda . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2194.5.4.4. Supresin de elementos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2194.5.4.5. Costo de las funciones cuando hay supresin . . . . . . . . . . . . . . . . . 220

4.5.4.6. Reinsercin de la tabla. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2204.5.4.7. Costo de las operaciones con supresin . . . . . . . . . . . . . . . . . . . . 2214.5.4.8. Estrategias de redispersin . . . . . . . . . . . . . . . . . . . . . . . . . . . 2224.5.4.9. Detalles de implementacin . . . . . . . . . . . . . . . . . . . . . . . . . . . 223

4.6. Conjuntos con rboles binarios de bsqueda . . . . . . . . . . . . . . . . . . . . . . . . . . . 2264.6.1. Representacin como lista ordenada de los valores . . . . . . . . . . . . . . . . . . . 2264.6.2. Verificar la condicin de ABB . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2274.6.3. Mnimo y mximo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2284.6.4. Buscar un elemento . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2284.6.5. Costo de mnimo y mximo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2284.6.6. Operacin de insercin . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 231

4.6.7. Operacin de borrado . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2314.6.8. Recorrido en el rbol . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2334.6.9. Operaciones binarias . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2334.6.10.Detalles de implementacin . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2344.6.11.Tiempos de ejecucin . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2394.6.12.Balanceo del rbol . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 239

5. Ordenamiento 2405.1. Introduccin . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 240

5.1.1. Relaciones de orden dbiles. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2405.1.2. Signatura de las relaciones de orden. Predicados binarios. . . . . . . . . . . . . . . . 241

5.1.3. Relaciones de orden inducidas por composicin . . . . . . . . . . . . . . . . . . . . . 2445.1.4. Estabilidad . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2455.1.5. Primeras estimaciones de eficiencia. . . . . . . . . . . . . . . . . . . . . . . . . . . . 2455.1.6. Algoritmos de ordenamiento en las STL. . . . . . . . . . . . . . . . . . . . . . . . . . 245

5.2. Mtodos de ordenamiento lentos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2465.2.1. El mtodo de la burbuja . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2465.2.2. El mtodo de insercin. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2475.2.3. El mtodo de seleccin . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2485.2.4. Comparacin de los mtodos lentos. . . . . . . . . . . . . . . . . . . . . . . . . . . . 249



7/303

INDICE

INDICE

5.2.5. Estabilidad . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2495.3. Ordenamiento indirecto . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 250

5.3.1. Minimizar la llamada a funciones . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2525.4. El mtodo de ordenamiento rpido, quick-sort . . . . . . . . . . . . . . . . . . . . . . . . . . 252

5.4.1. Tiempo de ejecucin. Casos extremos . . . . . . . . . . . . . . . . . . . . . . . . . . 2545.4.2. Eleccin del pivote . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2555.4.3. Tiempo de ejecucin. Caso promedio.. . . . . . . . . . . . . . . . . . . . . . . . . . . 2575.4.4. Dispersin de los tiempos de ejecucin . . . . . . . . . . . . . . . . . . . . . . . . . . 2595.4.5. Eleccin aleatoria del pivote . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2605.4.6. El algoritmo de particin . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2605.4.7. Tiempo de ejecucin del algoritmo de particionamiento . . . . . . . . . . . . . . . . . 2615.4.8. Bsqueda del pivote por la mediana. . . . . . . . . . . . . . . . . . . . . . . . . . . . 2625.4.9. Implementacin de quick-sort . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 263

5.4.10.Estabilidad . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2645.4.11.El algoritmo de intercambio (swap) . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2655.4.12.Tiempo de ejecucin del quick-sort estable . . . . . . . . . . . . . . . . . . . . . . . . 268

5.5. Ordenamiento por montculos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2695.5.1. El montculo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2705.5.2. Propiedades . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2715.5.3. Insercin . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2725.5.4. Costo de la insercin . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2735.5.5. Eliminar el mnimo. Re-heap. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2735.5.6. Costo de re-heap. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2755.5.7. Implementacin in-place . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 275

5.5.8. El procedimiento make-heap. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2765.5.9. Implementacin . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2785.5.10.Propiedades del ordenamiento por montculo . . . . . . . . . . . . . . . . . . . . . . . 279

5.6. Ordenamiento por fusin . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2805.6.1. Implementacin . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2815.6.2. Estabilidad . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2825.6.3. Versin estable de split. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2835.6.4. Merge-sort para vectores . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2835.6.5. Ordenamiento externo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 285

5.7. Comparacin de algunas implementaciones de algoritmos de ordenamiento . . . . . . . . . . 286

6. GNU Free Documentation License 288



8/303

Sobre este libro:

Este libro corresponde al cursoAlgoritmos y Estructura de Datosque se dicta en la currcula deIngenieraInformticay Analista en Informtica Aplicadade la Facultad de Ingeniera y Ciencias Hdricas(http://www.fich.unl.edu.ar) de laUniversidad Nacional del Litoral(http://www.unl.edu.ar).

Pgina web del curso: La pgina web del curso es http://www.cimec.org.ar/aed. En esa pginafunciona un wiki, listas de correo y un repositorio de archivos donde se puede bajar la mayor parte del cdigoque figura en el libro. Este libro se puede bajar en formato PDF de esa pgina tambin.

Licencia de uso: This book is Copyright (c) 2004-2007, Mario A. Storti, Jorge DEla, Rodrigo R. Paz,Lisandro Dalcn, Martn Pucheta. Permission is granted to copy, distribute and/or modify this document underthe terms of the GNU Free Documentation License, Version 1.1 or any later version published by the FreeSoftware Foundation; with no Invariant Sections, with no Front-Cover Texts, and with no Back-Cover Texts. Acopy of the license is included below in the section entitled GNU Free Documentation License.

Utilitarios usados: Todo este libro ha sido escrito con utilitarios de software libre, de acuerdo a los linea-mientos de laFree Software Foundation/GNU Project(http://www.gnu.org). La mayora de los utilita-rios corresponden a un sistema Fedora Core release 6 (Zod) Kernel 2.6.18-1.2798.fc6on an i686.

El libro ha sido escrito en LATEX y convertido a PDF con pdflatex. El libro est completamente inter-referenciado usando las utilidades propias de LATEX y el paquetehyperref.

Muchos de los ejemplos con un matiz matemticos han sido parcialmente implementados en Octave(http://www.octave.org). Tambin muchos de los grficos.

Los ejemplos en C++ han sidos desarrollados y probados con el compilador GCC 4.1.1 20061011(Red Hat 4.1.1-30)) (http://gcc.gnu.org) y con la ayuda de GNU Make 3.81 http://www.gnu.org/software/make/make.html.

Las figuras han sido generadas conXfig 3.2.4-21.1(http://www.xfig.org/).

El libro ha sido escrito en forma colaborativa por los autores usando Git 1.5.0.6. (http://git.or.cz/).

7
http://www.fich.unl.edu.ar/http://www.fich.unl.edu.ar/http://www.unl.edu.ar/http://www.unl.edu.ar/http://www.cimec.org.ar/aedhttp://www.gnu.org/http://www.gnu.org/http://www.octave.org/http://www.octave.org/http://www.octave.org/http://gcc.gnu.org/http://gcc.gnu.org/http://www.gnu.org/software/make/make.htmlhttp://www.gnu.org/software/make/make.htmlhttp://www.gnu.org/software/make/make.htmlhttp://www.xfig.org/http://www.xfig.org/http://git.or.cz/http://git.or.cz/http://git.or.cz/http://git.or.cz/http://git.or.cz/http://www.xfig.org/http://www.gnu.org/software/make/make.htmlhttp://www.gnu.org/software/make/make.htmlhttp://gcc.gnu.org/http://www.octave.org/http://www.gnu.org/http://www.cimec.org.ar/aedhttp://www.unl.edu.ar/http://www.fich.unl.edu.ar/http://www.fich.unl.edu.ar/


9/303

INDICE

INDICE

Errores Al final del libro hay un captulo dedicado a reportar los errores que se van detectando y corrigiendo.Este captulo se ir publicando en la pgina web por separado, de manera que si Ud. posee una versin

anterior del libro puede bajar las erratas y corregir su versin.Si encuentra algn error en el libro le agradecemos reportarlo a cualquiera de los autores, indicando la

versin del libro, tal como aparece en la portada.



10/303

Captulo 1

Diseo y anlisis de algoritmos

1.1. Conceptos bsicos de algoritmos

No existe una regla precisa para escribir un programa que resuelva un dado problema prctico. Al menospor ahora escribir programas es en gran medida un arte. Sin embargo con el tiempo se han desarrollado unvariedad de conceptos que ayudan a desarrollar estrategias para resolver problemas y comparar a priori laeficiencia de las mismas.

Por ejemplo supongamos que queremos resolver elProblema del Agente Viajero (TSP, porTravelingSalesman Problem) el cual consiste en encontrar el orden en que se debe recorrer un cierto nmero deciudades (esto es, una serie de puntos en el plano) en forma de tener un recorrido mnimo. Este problemasurge en una variedad de aplicaciones prcticas, por ejemplo encontrar caminos mnimos para recorridos

de distribucin de productos o resolver el problema de la vuelta del caballo en el tablero de ajedrez, esdecir, encontrar un camino para el caballo que recorra toda las casillas del tablero pasando una sola vezpor cada casilla. Existe una estrategia (trivial) que consiste en evaluar todos los caminos posibles. Pero estaestrategia debsqueda exhaustivatiene un gran defecto, el costo computacional crece de tal manera con elnmero de ciudades que deja de ser aplicable a partir de una cantidad relativamente pequea. Otra estrategiaheursticase basa en buscar un camino que, si bien no es el ptimo (el de menor recorrido sobre todos losposibles) puede ser relativamente bueno en la mayora de los casos prcticos. Por ejemplo, empezar en unaciudad e ir a la ms cercana que no haya sido an visitada hasta recorrerlas todas.

Una forma abstracta de plantear una estrategia es en la forma de un algoritmo, es decir una secuenciade instrucciones cada una de las cuales representa una tarea bien definida y puede ser llevada a cabo en unacantidad finita de tiempo y con un nmero finito de recursos computacionales. Un requerimiento fundamental

es que el algoritmo debe terminar en un nmero finito de pasos, de esta manera l mismo puede ser usadocomo una instruccin en otro algoritmo ms complejo.Entonces, comparando diferentes algoritmos para el TSP entre s, podemos plantear las siguientes pre-

guntas

>Da el algoritmo la solucin ptima?

Si el algoritmo es iterativo, >converge?

>Como crece el esfuerzo computacional a medida que el nmero de ciudades crece?

9


11/303

CAPTULO1 . DISEO Y ANLISIS DE ALGORITMOS

Seccin 1.1. Conceptos bsicos de algoritmos

1.1.1. Ejemplo: Sincronizacin de acceso a objetos en clculo distribuido

Consideremos un sistema de procesamiento con varios procesadores que acceden a un rea de memoriacompartida. En memoria hay una serie de objetos O0, O1, ... On1, con n = 10 y una serie de tareas arealizarT0,T1, ...Tm1conm= 12. Cada tarea debe modificar un cierto subconjunto de los objetos, segnla siguiente tabla

T0modificaO0,O1yO3.T1modificaO4yO5.T2modificaO4.T3modificaO2yO6T4modificaO1yO4.T5modificaO4yO7.T

6modificaO

0,O

2,O

3y O

6.

T7modificaO1,O7,O8.T8modificaO5,O7yO9.T9modificaO3.T10modificaO6,O8yO9.T11modificaO9.

Las tareas pueden realizarse en cualquier orden, pero dos tareasno pueden ejecutarse al mismo tiemposi acceden al mismo objeto, ya que los cambios hechos por una de ellas puede interferir con los cambios he-chos por la otra. Debe entonces desarrollarse un sistema que sincronice entre s la ejecucin de las diferentestareas.

Una forma trivial de sincronizacin es ejecutar cada una de las tareas en forma secuencial. Primero la

tareaT0luego laT1y as siguiendo hasta laT11, de esta forma nos aseguramos que no hay conflictos en elacceso a los objetos. Sin embargo, esta solucin puede estar muy lejos de ser ptima en cuanto al tiempode ejecucin ya que por ejemplo T0y T1pueden ejecutarse al mismo tiempo en diferentes procesadores yaque modifican diferentes objetos. Si asumimos, para simplificar, que todas las tareas llevan el mismo tiempode ejecucin, entonces la versin trivial consume una cantidad de tiempom, mientras que ejecutando lastareasT0y T1al mismo tiempo reducimos el tiempo de ejecucin a(m 1).

El algoritmo a desarrollar debeparticionarlas tareas en una serie depetapasE0, ...Ep. Las etapasson simplemente subconjuntos de las tareas y la particin debe satisfacer las siguientes restricciones

Cada tarea debe estar en una y slo una etapa. (De lo contrario la tarea no se realizara o se realizarams de una vez, lo cual es redundante. En el lenguaje de la teora de conjuntos, estamos diciendo que

debemos particionar el conjunto de etapas en un cierto nmero de subconjuntos disjuntos.)

Las tareas a ejecutarse en una dada etapa no deben acceder al mismo objeto.

Una particin admisiblees aquella que satisface todas estas condiciones. El objetivo es determinaraquella particin admisible que tiene el mnimo nmero de etapas.

Este problema es muy comn, ya que se plantea siempre que hay un nmero de tareas a hacer y conflic-tos entre esas tareas, por ejemplo sincronizar una serie de tareas con maquinaria a realizar en una industria,evitando conflictos en el uso del instrumental o maquinaria, es decir no agendar dos tareas para realizarsimultneamente si van a usar el microscopio electrnico.



12/303



1.1.2. Introduccin bsica a grafos

El problema se puede plantear usando una estructura matemtica conocida comografo. La base delgrafo es un conjunto finitoV de puntos llamadosvrtices. La estructura del grafo est dada por las conexio-nes entre los vrtices. Si dos vrtices estn conectados se dibuja una lnea que va desde un vrtice al otro.Estas conexiones se llamanaristas (edges) del grafo. Los vrtices pueden identificarse con un nmerode 0 anv 1dondenves el nmero total de vrtices. Tambin es usual representarlos grficamente con unletraa,b, c, ...encerrada en un crculo o usar cualquier etiqueta nica relativa al problema.

Desde el punto de vista de la teora de conjuntos un grafo es un subconjunto del conjunto Gde pares devrtices. Un par de vrtices est en el grafo si existe una arista que los conecta. Tambin puede representarsecomo una matriz A simtrica de tamao nvnvcon 0s y 1s. Si hay una arista entre el vrtice i y eljentoncesel elementoAijes uno, y sino es cero. Adems, si existe una arista entre dos vrticesiyjentonces decimosqueiesadyacenteaj .

ab

c

e

f

d

a fed

a

b

f

c

d

e

b c

0

1

1

1

0

1

1

0

0

1

0

0

1

0

0

1

1

1

1

1

1

0

1

1

1

1

1

0

0

0

0

1

1

0

0

0

Figura 1.1: Representacin grfica y matricial del grafoG

En la figura1.1vemos un grafo con 6 vrtices etiquetados de a a f, representado grficamente y comouna matriz de 0s y 1s. El mismo grafo representado como pares de elementos es

G= {{a, b}, {a, c}, {a, d}, {a, e}, {b, d}, {c, d}, {c, e}, {c, f}, {d, e}, {d, f}, } (1.1)

Para este ejemplo usaremosgrafos no orientados, es decir que si el vrtice i est conectado con eljentonces elj est conectado con eli. Tambin existengrafos orientadosdonde las aristas se representanpor flechas.

Se puede tambin agregar un peso (un nmero real) a los vrtices o aristas del grafo. Este peso puederepresentar, por ejemplo, un costo computacional.

1.1.3. Planteo del problema mediante grafos

Podemos plantear el problema dibujando un grafo donde los vrtices corresponden a las tareas y dibuja-remos una arista entre dos tareas si son incompatibles entre s (modifican el mismo objeto). En este caso elgrafo resulta ser como muestra la figura1.2.

La buena noticia es que nuestro problema de particionar el grafo ha sido muy estudiado en la teorade grafos y se llama el problema de colorearel grafo, es decir se representan grficamente las etapasasignndole colores a los vrtices del grafo. La mala noticia es que se ha encontrado que obtener el coloreadoptimo (es decir el coloreado admisible con la menor cantidad de colores posibles) resulta ser un problema



13/303



T0

T

1

T

2

T8

T7

T11

T10

T9

T6

T3

T4

T5

Figura 1.2: Representacin del problema mediante un grafo.

extremadamente costoso en cuanto a tiempo de clculo. (Se dice que es NP. Explicaremos esto en laseccin 1.3.12.)

C1

C2

C3

C4

C7 C

10

C9

C8

C5

C6

Figura 1.3: Coloracin de mapas.

El trminocolorear grafosviene de un problema que tambin se puede poner en trminos de coloreargrafos y es el de colorear pases en un mapa. Consideremos un mapa como el de la figura 1.3. Debemosasignar a cada pas un color, de manera que pases limtrofes (esto es, que comparten una porcin de fronterade medida no nula) tengan diferentes colores y, por supuesto, debemos tratar de usar el mnimo nmero decolores posibles. El problema puede ponerse en trminos de grafos, poniendo vrtices en los pases (Cj ,

j= 1..10) y uniendo con aristas aquellos pases que son limtrofes (ver figura1.4).

1.1.4. Algoritmo de bsqueda exhaustiva

Consideremos primero un algoritmo debsqueda exhaustivaes decir, probar si el grafo se puede colo-rear con 1 solo color (esto slo es posible si no hay ninguna arista en el grafo). Si esto es posible el problema



14/303



C1

C2

C3

C4

C7

C10

C9

C8

C5

C6

Figura 1.4: Grafo correspondiente al mapa de la figura1.3.

est resuelto (no puede haber coloraciones con menos de un color). Si no es posible entonces generamostodas las coloraciones con 2 colores, para cada una de ellas verificamos si satisface las restricciones o no,es decir si es admisible. Si lo es, el problema est resuelto: encontramos una coloracin admisible con doscolores y ya verificamos que con 1 solo color no es posible. Si no encontramos ninguna coloracin admisiblede 2 colores entonces probamos con las de 3 colores y as sucesivamente. Si encontramos una coloracindenccolores entonces ser ptima, ya que previamente verificamos para cada nmero de colores entre 1 ync 1que no haba ninguna coloracin admisible.

Ahora tratando de resolver las respuestas planteadas en la seccin 1.1, vemos que el algoritmo pro-puesto si da la solucin ptima. Por otra parte podemos ver fcilmente que s termina en un nmero finito depasos ya que a lo sumo puede habernc= nv colores, es decir la coloracin que consiste en asignar a cadavrtice un color diferente es siempre admisible.

1.1.5. Generacin de las coloraciones

En realidad todava falta resolver un punto del algoritmo y es cmo generar todas las coloraciones posiblesdenc colores. Adems esta parte del algoritmo debe ser ejecutable en un nmero finito de pasos as quetrataremos de evaluar cuantas coloracionesN(nc, nv)hay paranvvrtices connccolores. Notemos primeroque el procedimiento para generar las coloraciones es independiente de la estructura del grafo (es decir delas aristas), slo depende de cuantos vrtices hay en el grafo y del nmero de colores que pueden tener lascoloraciones.

a bR R

C0

ba

C1

ba

C2

a b

C3

coloracion=

R G G R G G

Figura 1.5: Posibles coloraciones de dos vrtices con dos colores

Paranc = 1es trivial, hay una sola coloracin donde todos los vrtices tienen el mismo color, es decirN(nc= 1, nv) = 1 para cualquiernv.



15/303



a b

ba

ba

ba

c

b c

c

c

c

a

ba

ba

ba

c

b cc

c

c

nc

=2

v=2n

N=4

nc=2

v=3n

N=8

+

+

a

ba

ba

ba

R R

R

RG

G

G

G

R

R R R

R R

R R

R

R R

R

R

G

G

G G

G

G G

G G

G G G

G

Figura 1.6: Las coloraciones de 3 vrtices y dos colores se pueden obtener de las de 2 vrtices.

Consideremos ahora las coloraciones de nc= 2colores, digamos rojo y verde. Si hay un slo vrtice enel grafo, entonces hay slo dos coloraciones posibles: que el vrtice sea rojo o verde. Si hay dos vrtices,entonces podemos tener 4 coloraciones rojo-rojo, rojo-verde, verde-rojo y verde-verde, es decir N(2, 2) = 4(ver figura1.5.Nota: Para que los grficos con colores sean entendibles en impresin blanco y negro hemosagregado una pequea letra arriba del vrtice indicando el color). Las coloraciones de 3 vrticesa, b, cy doscolores las podemos generar a partir de las de 2 vrtices, combinando cada una de las 4 coloraciones paralos vrticesaybcon un posible color parac(ver figura1.6,de manera que tenemos

N(2, 3) = 2 N(2, 2) (1.2)

Recursivamente, para cualquiernc, nv 1, tenemos queN(nc, nv) =ncN(nc, nv 1)

=n

2

cN(nc, nv 2)...=nnv1c N(nc, 1)

(1.3)

Pero el nmero de coloraciones para un slo vrtice connccolores esnc, de manera que

N(nc, nv) =nnvc (1.4)

Esto cierra con la ltima pregunta, ya que vemos que el nmero de pasos para cada uno de los colores esfinito, y hay a lo sumonvcolores de manera que el nmero total de posibles coloraciones a verificar es finito.



16/303



Notar de paso que esta forma de contar las coloraciones es tambinconstructiva, da un procedimiento paragenerar todas las coloraciones, si uno estuviera decidido a implementar la estrategia de bsqueda exhaustiva.

a b c

a b c

a b c

a b c

a b c

a b c

a b c

a b c

un solo color

===

R R R

R R

R R

R

R R

R

R

G

G

G G

G

G G

GG

G G G

Figura 1.7: Las 8 posibles coloraciones de un grafo de 3 vrtices con dos colores

Notemos que en realidad el conteo de coloraciones (1.4) incluye todas las coloraciones de nc o menoscolores. Por ejemplo sinv = 3ync = 2entonces lasnnvc = 2

3 = 8coloraciones son las que se pueden veren la figura1.7.En realidad hay dos (la primera y la ltima) que tienen un slo color y las 6 restantes slohay 3 esencialmente diferentes, ya que son equivalentes de a pares, por ejemplo la segunda y la sptima

son equivalentes entre s de manera que una de ellas es admisible si y solo si la otra lo es. De las 33 = 27coloraciones posibles para un grafo de 3 vrtices con 3 colores (o menos) en realidad 3 corresponden a unslo color, 18 a dos colores y 6 con 3 colores (ver figura1.8). Las 6 coloraciones de un slo color son variantesde la nica posible coloracin de un color. Las 18 de dos colores son variantes de las 3 nicas coloracionesde dos colores y las 6 de 3 colores son variantes de la nica coloracin posible de 3 colores. O sea que delas 27 coloraciones posibles en realidad slo debemos evaluar 5.

1.1.6. Crecimiento del tiempo de ejecucin

No consideremos, por ahora, la eliminacin de coloraciones redundantes (si quisiramos eliminarlas de-beramos generar un algoritmo para generar slo las esencialmente diferentes) y consideremos que para

aplicar la estrategia exhaustiva al problema de coloracin de un grafo debemos evaluarN = nnvv coloracio-

nes. Esto corresponde al peor caso de que el grafo necesite el nmero mximo de nc= nvcolores.Para verificar si una coloracin dada es admisible debemos realizar un cierto nmero de operaciones. Por

ejemplo si almacenamos el grafo en forma matricial, podemos ir recorriendo las aristas del grafo y verificarque los dos vrtices conectados tengan colores diferentes. Si el color es el mismo pasamos a la siguientearista. Si recorremos todas las aristas y la coloracin es admisible, entonces hemos encontrado la solucinptima al problema. En el peor de los casos el nmero de operaciones necesario para verificar una dadacoloracin es igual al nmero de aristas y a lo sumo el nmero de aristas es nv nv(el nmero de elementos



17/303



en la forma matricial del grafo) de manera que para verificar todas las coloraciones necesitamos verificar

Nbe = n2vnnv

v =nnv

+2v (1.5)

aristas. Asumiendo que el tiempo de verificar una arista es constante, este es el orden del nmero de opera-ciones a realizar.

El crecimiento de la funcinnnvv con el nmero de vrtices es tan rpido que hasta puede generar asom-bro. Consideremos el tiempo que tarda una computadora personal tpica en evaluar todas las posibilidadespara nv = 20 vrtices. Tomando un procesador de 2.4 GHz (un procesador tpico al momento de escribireste apunte) y asumiendo que podemos escribir un programa tan eficiente que puede evaluar una arista porcada ciclo del procesador (en la prctica esto es imposible y al menos necesitaremos unas decenas de ciclospara evaluar una coloracin) el tiempo en aos necesario para evaluar todas las coloraciones es de

T = 2022

2.4109 . 3600 . 24 . 365 = 5.541011 aos (1.6)Esto es unas 40 veces la edad del universo (estimada en 15.000.000.000 de aos).

Algo que debe quedar en claro es que el problema no esta en la velocidad de las computadoras, sino en laestrategia de bsqueda exhaustiva. Incluso haciendo uso de las ms sofisticadas tcnicas de procesamientoactuales los tiempos no bajaran lo suficiente. Por ejemplo usando uno de los clustersde procesadoresms grandes existentes actualmente (con ms de mil procesadores, ver http://www.top500.org) slopodramos bajar el tiempo de clculo al orden de los millones de aos.

Otra forma de ver el problema es preguntarse cul es el mximo nmero de vrtices que se puederesolver en un determinado tiempo, digamos una hora de clculo. La respuesta es que ya con nv = 15setienen tiempos de ms de 5 horas.

En la seccin siguiente veremos que si bien la eliminacin de las coloraciones redundantes puede reducirsignificativamente el nmero de coloraciones a evaluar, el crecimiento de la funcin sigue siendo similar y nopermite pasar de unas cuantas decenas de vrtices.

1.1.7. Bsqueda exhaustiva mejorada

Para reducir el nmero de coloraciones a evaluar podemos tratar de evaluar slo las coloraciones esen-cialmente diferentes. No entraremos en el detalle de cmo generar las coloraciones esencialmente diferentes,pero s las contaremos para evaluar si el nmero baja lo suficiente como para hacer viable esta estrategia.

Llamaremos entoncesNd(nc, nv)al nmero de coloraciones esencialmente diferentes para nv vrticesync colores. Observando la figura1.7vemos que el nmero total de coloraciones para 3 vrtices con 2 o

menos colores es23 = 2 + 6

Nmero decoloraciones connc= 2o menos

=

Nmero decoloraciones con

exactamentenc= 1

+

Nmero decoloraciones con

exactamentenc= 2

(1.7)

A su vez el nmero de coloraciones connc = 1, que es 2, es igual al nmero de coloraciones esencial-mente diferentesNd(1, 3) = 1que es, por las posibilidades de elegir un color de entre 2 que es 2. Tambin el

http://www.top500.org/http://www.top500.org/


18/303



a b c

a b c

a b c

n =1c a b c

a b c

a b c

a b c

a b c

a b c

a b c

a b c

a b c

a b c

a b c

a b c

a b c

a b c

a b c

a b c

a b c

a b c

a b c

a b c

a b c

a b c

a b c

a b c

nc=2 nc=3

rojo azul rojoverde

esencialmente

diferentes

R R R

R R

R R

R

R R

R

R

G G G

G

G

G G

G

G G

G G

B B B

GB B

B B

B

B B

B

B

G

G G

G

GG

G G

G

B B

B B

B

B B

B

B

R

R

R R

R

R R

R R

R

R

B

B

R

R

R

R

B

B

B

B

G

G

G

G

G

G

Figura 1.8: Todas las 27 coloraciones de 3 o menos colores son en realidad combinaciones de 5 esencial-mente diferentes.

nmero de coloraciones con exactamente 2 colores es igual al nmero de coloraciones esencialmente dife-rentesNd(2, 3)que es 3, por el nmero de posibles maneras de elegir 2 colores de dos, que es 2 (rojo-verde,

verde-rojo). En general, puede verse que la cantidad posible de elegirkcolores dencesNmero de formasde elegirkcolores

denc

=

nc!

(nc k)! (1.8)

de manera que tenemos23 = 2 . 1 + 2 . 3

23 = 2!

1! . Nd(1, 3) +

2!

0! . Nd(2, 3)

(1.9)

Supongamos que queremos calcular las coloraciones esencialmente diferentes para nv = 5 colores,



19/303



entonces plantemos las relaciones

15 = 1!0! Nd(1, 5)

25 = 2!

1!Nd(1, 5) +

2!

0!Nd(2, 5)

35 = 3!

2!Nd(1, 5) +

3!

1!Nd(2, 5) +

3!

0!Nd(3, 5)

45 = 4!

3!Nd(1, 5) +

4!

2!Nd(2, 5) +

4!

1!Nd(3, 5) +

4!

0!Nd(4, 5)

55 = 5!

4!Nd(1, 5) +

5!

3!Nd(2, 5) +

5!

2!Nd(3, 5) +

5!

1!Nd(4, 5) +

5!

0!Nd(5, 5)

(1.10)

o sea

1 = Nd(1, v)

32 = 2 Nd(1, 5) + 2 Nd(2, 5)

243 = 3 Nd(1, 5) + 6 Nd(2, 5) + 6 Nd(3, 5)

1024 = 4 Nd(1, 5) + 12 Nd(2, 5) + 24 Nd(3, 5) + 24 Nd(4, 5)

3125 = 5 Nd(1, 5) + 20 Nd(2, 5) + 60 Nd(3, 5) + 120 Nd(4, 5) + 120 Nd(5, 5)

(1.11)

Notemos que de la segunda ecuacin puede despejarse fcilmenteNd(2, 5)que resulta ser 15. De la tercerase puede despejar Nd(3, 5) ya que conocemos Nd(1, 5) y Nd(2, 5) y resulta ser Nd(3, 5) = 25 y as siguiendoresulta ser

Nd(1, 5) = 1Nd(2, 5) = 15

Nd(3, 5) = 25

Nd(4, 5) = 10

Nd(5, 5) = 1

(1.12)

de manera que el nmero total de coloraciones esencialmente diferentes es

Nd(1, 5) +Nd(2, 5) +Nd(3, 5) +Nd(4, 5) +Nd(5, 5) = 1 + 15 + 25 + 10 + 1 = 52 (1.13)

Es muy fcil escribir un programa (en C++, por ejemplo) para encontrar el nmero total de coloracionesesencialmente diferentes para un dado nmero de vrtices, obtenindose una tabla como la1.1

A primera vista se observa que eliminando las coloraciones redundantes se obtiene una gran reduccinen el nmero de coloraciones a evaluar. Tomando una serie de valores crecientes de nv y calculando elnmero de coloraciones diferentes como en la tabla1.1se puede ver que ste crece como

Nd(nv) =nv

nc=1

Nd(nc, nv) nnv/2v (1.14)

El nmero de aristas a verificar, contandon2varistas por coloracin es de

Nbem nnv/2v n2v =nnv/2+2v (1.15)



20/303



nv coloraciones coloraciones

diferentes

1 1 12 4 23 27 54 256 155 3125 526 46656 2037 823543 877

Tabla 1.1: Nmero de coloraciones para un grafo connv vrtices. Se indica el nmero de coloraciones totaly tambin el de quellas que son esencialmente diferentes entre s.

Sin embargo, si bien esto significa una gran mejora con respecto a nnvv , el tiempo para colorear un grafo de20 vrtices se reduce del tiempo calculado en (1.6) a slo 99 das. Est claro que todava resulta ser excesivopara un uso prctico.

Una implementacin en C++ del algoritmo de bsqueda exhaustiva puede encontrarse en el cdigo quese distribuye con este apunte en aedsrc/colgraf.cpp. La coloracin ptima del grafo se encuentra des-pus de hacer 1.429.561 evaluaciones en 0.4 secs. Notar que el nmero de evaluaciones baja notablementecon respecto a la estimacin nnv+2v 91012 ya que se encuentra una coloracin admisible para nc = 4con lo cual no es necesario llegar hasta nc = nv . De todas formas incluso si tomramos como cota inferiorpara evaluar los tiempos de ejecucin el caso en que debiermos evaluar al menos todas las coloraciones de2 colores, entonces tendramos al menos un tiempo de ejecucin que crece como 2nv evaluaciones. Incluso

con estepisopara el nmero de evaluaciones, el tiempo de clculo sera de una hora paranv = 33.

1.1.8. Algoritmo heurstico vido

Una estrategia diferente a la de bsqueda exhaustiva es la de buscar una solucin que, si bien no es laptima (es decir, la mejor de todas), sea aceptablemente buena, y se pueda obtener en un tiempo razonable.Si se quiere, sta es una estrategia que uno utiliza todo el tiempo: si tenemos que comprar una licuadora y nosproponemos comprar la ms barata, no recorremos absolutamente todos los bazares y supermercados detodo el planeta y revisamos todos las marcas posibles, sino que, dentro del tiempo que aceptamos dedicar aesta bsqueda, verificamos el costo de los artculos dentro de algunos comercios y marcas que consideramoslos ms representativos.

Un algoritmo que produce una solucin razonablemente buena haciendo hiptesisrazonablesse llamaheurstico. Del diccionario: heurstico: una regla o conjunto de reglas para incrementar la posibilidad deresolver un dado problema.

Un posible algoritmo heurstico para colorear grafos es el siguiente algoritmo "vido. Primero tratamosde colorear tantos vrtices como podamos con el primer color, luego con el segundo color y as siguiendohasta colorearlos todos. La operacin de colorear con un dado color puede resumirse como sigue

Seleccionar algn vrtice no coloreado y asignarle el nuevo color.

Recorrer la lista de vrtices no colorados. Para cada vrtice no coloreado determinar si est conectado



21/303



(esto es, posee algn vrtice en comn) con un vrtice del nuevo color.

Esta aproximacin es llamada vida ya que asigna colores tan rpido como lo puede hacer, sin tener encuenta las posibles consecuencias negativas de tal accin. Si estuviramos escribiendo un programa para

jugar al ajedrez, entonces una estrategia vida, sera evaluar todas las posibles jugadas y elegir la que da lamejor ventaja material. En realidad no se puede catalogar a los algoritmos como vidos en forma absoluta,sino que se debe hacer en forma comparativa: hay algoritmos ms vidos que otros. En general cuanto msvido es un algoritmo ms simple es y ms rpido es en cuanto a avanzar para resolver el problema, pero porotra parte explora en menor medida el espacio de bsqueda y por lo tanto puede dar una solucin peor queotro menos vida. Volviendo al ejemplo del ajedrez, un programa que, adems de evaluar la ganancia materialde la jugada a realizar, evale las posibles consecuencias de la siguiente jugada del oponente requerir mayortiempo pero a largo plazo producir mejores resultados.

c

d

a e b

Figura 1.9: Ejemplo de un grafo simple para aplicar el algoritmo vido.

Si consideramos la coloracin de un grafo como el mostrado en la figura1.9entonces empezando por elcolor rojo le asignaramos el rojo al vrtice a. Posteriormente recorreramos los vrtices no coloreados, quea esta altura son {b,c,d,e} y les asignamos el color rojo si esto es posible. Podemos asignrselo abpero noacyd, ya que estn conectados ab ni tampoco ae ya que est conectado a a. Pasamos al siguiente color,

digamos verde. La lista de vrtices no coloreados es, a esta altura {c,d,e}. Le asignamos verde acy luegotambin ad, pero no podemos asignrselo aeya que est conectado acyd. El proceso finaliza asignndoleel siguiente color (digamos azul) al ltimo vrtice sin colorear e. El grafo coloreado con esta estrategia semuestra en la figura1.10.

c

d

a be

c

d

a beR R

G

G

B

R

R G

R

G

Figura 1.10: Izquierda: El grafo de la figura1.9coloreado con la estrategia vida. Derecha: Coloracin ptima.

El algoritmo encuentra una solucin con tres colores, sin embargo se puede encontrar una solucin condos colores, como puede verse en la misma figura. Esta ltima es ptima ya que una mejor debera tener sloun color, pero esto es imposible ya que entonces no podra haber ninguna arista en el grafo. Este ejemploilustra perfectamente que si bien el algoritmo vido da una solucin razonable, sta puede no ser la ptima.

Notemos tambin que la coloracin producida por el algoritmo vido depende del orden en el que serecorren los vrtices. En el caso previo, si recorriramos los nodos en el orden {a,e,c,d,b}, obtendramosla coloracin ptima.



22/303



En el caso del grafo original mostrado en la figura1.2,el grafo coloreado resultante con este algoritmoresulta tener 4 colores y se muestra en la figura 1.11.

Notemos que cada vez que se agrega un nuevo color, por lo menos a un nodo se le asignar ese color, demanera que el algoritmo usa a lo sumonvcolores. Esto demuestra tambin que el algoritmo en su totalidadtermina en un nmero finito de pasos.

Una implementacin en C++del algoritmo vido puede encontrarse en el cdigo que se distribuye coneste apunte enaedsrc/colgraf.cpp.

T0

T1

T2

T8

T7

T11

T10

T9

T6

T3 T4 T5

R R

R

R

G

GG

B

B

B

Y

Y

Figura 1.11: Grafo coloreado.

1.1.9. Descripcin del algoritmo heurstico en seudo-cdigo

Una vez que tenemos una versin abstracta (matemtica) del modelo o algoritmo podemos empezara implementarlo para llegar a un programa real que resuelve el problema. Este proceso puede llevarse acabo en varias etapas empezando por una descripcin muy general en forma de sentencias vagas, llamadoseudo-cdigo, comoelegir un vrtice no coloreado. A veces es comn incluir este seudo-cdigo en formade comentarios seguidos por puntos suspensivos que indican que falta completar esa parte del programa.

Lo ideal es que estas sentencias sean suficientemente claras como para no dejar dudas de cual es latarea a realizar, pero tambin lo suficientemente generales como para no tener que entrar en detalles y poder

disear rpidamente una versin bsica del cdigo. Luego en un paso de refinamiento posterior estassentencias en seudo-cdigo son refinadas en tareas ms pequeas, las cuales pueden ser descriptas parteen lneas de seudo-cdigo ellas mismas y parte en sentencias vlidas del lenguaje, hasta que finalmenteterminamos con un cdigo que puede ser compilado y linkeditado en un programa.

Tomemos como ejemplo el algoritmo heurstico descripto previamente en 1.1.8. La rutina greedycmostrada en el cdigo1.1(archivo greedy.cpp) toma como argumentos un grafo G, el conjunto de vrticesno coloreados hasta el momento no_col y determina un conjunto de nodos nuevo_colorlos cualespueden ser coloreados con el nuevo color. Los vrtices son identificados por un entero de 0 a nv-1. Larutina adems mantiene una tabla tabla_colordonde finalmente quedarn los colores de cada vrtice.



23/303



El argumento de entrada color indica el color (un entero empezando desde 0 e incrementndose de a 1en cada llamada a greedyc) con el cual se est coloreando en esta llamada a greedyc. Notar que esta

rutina ser llamada posteriormente dentro de un lazo sobre los colores hasta colorear todos los vrtices.Los conjuntos son representados con el template setde la libreras STL (por Standard TemplateLibrary, hoy parte del C++ estndar). Falta todava implementar la clase graph. El lazo de las lneas 9-17es un lazo tpico para recorrer un set.

1 voidgreedyc(graph &G, set &no-col,2 set &nuevo-color,3 vector &tabla-color,int color) {4 // Asigna a nuevo-color un conjunto de vertices5 // de G a los cuales puede darse el mismo nuevo color6 // sin entrar en conflicto con los ya coloreados7 nuevo-color.clear();

8 set::iterator q;9 for (q=no-col.begin(); q!=no-col.end(); q++) {

10 if (/* *q no es adyacente a11 ningun vertice en nuevo-color . . . */) {12 // marcar a *q como coloreado13 // . . .14 // agregar *q a nuevo-color15 // . . .16 }17 }18 }

Cdigo 1.1:Rutina para la coloracin de un grafo. Determina el conjunto de vrtices que pueden ser colo-

reados con un nuevo color sin entrar en conflicto. Versin inicial. [Archivo: greedy.cpp]

Haciendo un breve repaso de lositeratorsde STL, el iterator q, declarado en la lnea 8 acta como unpuntero aint, de hecho*qes una referencia a un int. Al empezar el lazo apunta al primer elemento delno_coly en cada iteracin del lazo pasa a otro elemento, hasta que cuando se han acabado todos toma elvalorno_col.end(), con lo cual finaliza al lazo. Dentro del lazo faltan implementar 3 porciones de cdigo.La condicin del ifde las lneas 10-11, el cdigo para marcar al vrtice como coloreado en la lnea 13 ypara agregarlo anuevo_coloren la lnea 15.

Vamos ahora a refinar el algoritmo anterior, expandiendo ahora ms an la expresin condicional del if.Para verificar si *qes adyacente a algn vrtice de nuevo_colordebemos recorrer todos los nodos de

nuevo_colory verificar si hay alguna arista entre los mismos y *q. Para esto hacemos un lazo, definiendouna variableadyacente(ver cdigo1.2,archivogreedy2.cpp). Al llegar al comienzo del condicional enla lnea 10 la variableadyacentetiene el valor apropiado. Notar que si se detecta que uno de los vrticesdenuevo_colores adyacente a *q, entonces no es necesario seguir con el lazo, por eso el breakdela lnea 15. Adems hemos implementado las lneas 13 y lneas 15 del cdigo 1.1, resultando en las lneaslneas 20 y lneas 22 del cdigo 1.2.La lnea 20 simplemente registra el nuevo color asignado a la tablatabla_colory la lnea 22 inserta el vrtice que se termina de colorear *qal conjunto nuevo_color.Notar que deberamos eliminar los vrtices que coloreamos de no_col pero esto no lo podemos hacerdentro del lazo de las lneas 9-24 del cdigo1.2, ya que dentro del mismo se itera sobre no_col. Modificar



24/303



no_colconvertira en invlido el iterador qy por lo tanto despus no se podra aplicar el operador ++a qen la lnea 9.

1 voidgreedyc(graph &G, set &no-col,2 set &nuevo-color,3 vector &tabla-color,int color) {4 // Asigna a nuevo-color un conjunto de vertices5 // de G a los cuales puede darse el mismo nuevo color6 // sin entrar en conflicto con los ya coloreados7 nuevo-color.clear();8 set::iterator q,w;9 for (q=no-col.begin(); q!=no-col.end(); q++) {

10 intadyacente=0;11 for (w=nuevo-color.begin();12 w!=nuevo-color.end(); w++) {

13 if (/* *w es adyacente a *q . . . */) {14 adyacente = 1;15 break;16 }17 }18 if (!adyacente) {19 // marcar a *q como coloreado20 tabla-color[*q] =color;21 // agregar *q a nuevo-color22 nuevo-color.insert(*q);23 }24 }25 }

Cdigo 1.2:Rutina para la coloracin de un grafo. Versin refinada. [Archivo: greedy2.cpp]

Para refinar el condicional de la lnea 13 necesitamos definir la clase grafo, para ello utilizaremos unarepresentacin muy simple, til para grafos pequeos basada en mantener una tabla de unos y ceros comofue descripto en 1.1.2. Como el grafo no es orientado, la matriz es simtrica (Ajk = Akj ) de manera queslo usaremos la parte triangular inferior de la misma. La matriz ser almacenada por filas en un arreglovector gde manera que el elemento Ajk estar en la posicin g [nv j + k]. La clase grafo sepuede observar en el cdigo1.3.Los elementos de la matriz se acceden a travs de una funcin miembroedge(j,k)que retorna una referencia al elemento correspondiente de la matriz. Notar que si j < k,entonces se retorna en realidad el elemento simtrico A

kjen la parte triangular inferior. Como edge()

retorna una referencia al elemento correspondiente, puede usarse tanto para insertar aristas en el grafo

G.edge(j,k) = 1;

como para consultar si un dado par de vrtices es adyacente o no

if (!G.edge(j,k)) {

// no estan conectados

// ...

}



25/303



1 class graph {2 private:3 const int nv;4 vector g;5 public:6 // Constructor a partir del numero de vertices7 graph(int nv-a) : nv(nv-a) { g.resize(nv*nv,0); }8 // Este metodo permite acceder a una arista tanto para9 // agregar la arista (g.edge(i,j)=1) como para

10 // consultar un valor particular de la11 // arista. (adyacente = g.edge(i,j))12 int &edge(int j,int k) {13 if (k


26/303



Ahora falta definir el cdigo exterior que iterar los colores, llamando a greedyc. Un primer esbozopuede observarse en el cdigo1.5. La rutinagreedytoma como argumentos de entrada el grafo a colorear

G, el nmero de vrticesnvy devuelve la coloracin entabla_color. Internamente inicializa el conjuntode vrtices no coloreados insertando todos los vrtices del grafo en la lnea 8. A continuacin entra en unlazo infinito, del cual slo saldr cuando todos los vrtices estn coloreados, y por lo tanto no_col seavaco, lo cual todava debemos implementar en la lnea 19. (Notemos que es vlido utilizar un lazo infinito yaque hemos garantizado que el algoritmo se ejecuta a lo sumo un nmero finito de veces, ms precisamentea lo sumo nv veces. ) Dentro del lazo, se determina el conjunto de vrtices al cual se asignar el nuevocolor llamando a greedyc(...) (lnea 13). Luego debemos sacar los vrtices asignados al nuevo color deno_coly, despus de verificar la condicin de fin del algoritmo, incrementar el nmero de color.

1 voidgreedy(graph &G, int nv,2 vector &tabla-color) {

3 int color=0;4 setnuevo-color, no-col;5 set::iterator q;6 // Inicialmente ponemos todos los vertices en7 // no-col8 for (int k=0; k


27/303



7 for (int k=0; k


28/303


Seccin 1.2. Tipos abstractos de datos

nmero constante de operaciones. De manera que todo el bloque de las lneas 8-21 consume a lo sumon3voperaciones. Lo cual significa una dramtica reduccin con respecto a las estimaciones para los algoritmos

de bsqueda exhaustiva (1.5) y bsqueda exhaustiva mejorada (1.15).

1.1.11. Conclusin del ejemplo

En toda esta seccin 1.1.1hemos visto un ejemplo en el cual resolvemos un problema planteando unmodelo matemtico abstracto (en este caso las estructuras grafoy conjunto. Inicialmente el algoritmo esexpresado informalmente en trminos de operaciones abstractas sobre estas estructuras. Posteriormente segenera un primer esbozo del algoritmo con una mezcla de sentencias escritas en C++(u otro lenguaje) yseudo-cdigo, el cual es refinado en una serie de etapas hasta llegar a un programa que se puede compilar,linkeditar y ejecutar.

1.2. Tipos abstractos de datos

Una vez que se ha elegido el algoritmo, la implementacin puede hacerse usando las estructuras mssimples, comunes en casi todos los lenguajes de programacin: escalares, arreglos y matrices. Sin embargoalgunos problemas se pueden plantear en forma ms simple o eficiente en trminos de estructuras infor-mticas ms complejas, como listas, pilas, colas, rboles, grafos, conjuntos. Por ejemplo, el TSP se planteanaturalmente en trminos de un grafo donde los vrtices son las ciudades y las aristas los caminos que vande una ciudad a otra. Estas estructuras estn incorporadas en muchos lenguajes de programacin o bienpueden obtenerse de libreras. El uso de estas estructuras tiene una serie de ventajas

Se ahorra tiempo de programacin ya que no es necesario codificar.

Estas implementaciones suelen ser eficientes y robustas.

Se separan dos capas de cdigo bien diferentes, por una parte el algoritmo que escribe el programador,y por otro las rutinas de acceso a las diferentes estructuras.

Existen estimaciones bastante uniformes de los tiempos de ejecucin de las diferentes operaciones.

Las funciones asociadas a cada estructura son relativamente independientes del lenguaje o la imple-mentacin en particular. As, una vez que se plantea un algoritmo en trminos de operaciones sobreuna tal estructura es fcil implementarlo en una variedad de lenguajes con una performance similar.

UnTipo Abstracto de Datos(TAD) es la descripcin matemtica de un objeto abstracto, definido porlas operaciones que actan sobre el mismo. Cuando usamos una estructura compleja como un conjunto,lista o pila podemos separar tres niveles de abstraccin diferente, ejemplificados en la figura1.12,a saberlasoperaciones abstractassobre el TAD, la interfaseconcreta de una implementacin y finalmente laimplementacinde esa interfase.

Tomemos por ejemplo el TAD CONJUNTO utilizado en el ejemplo de la seccin 1.1.1. Las siguientesson las operaciones abstractas que podemos querer realizar sobre un conjunto



29/303



implementacin

operaciones abstractas

interfase

abstraccin

del TAD

Figura 1.12: Descripcin de lo diferentes niveles de abstraccin en la definicin de un TAD

1.2.1. Operaciones abstractas y caractersticas del TAD CONJUNTO

Contiene elementos, los cuales deben ser diferentes entre s.No existe un orden particular entre los elementos del conjunto.

Se pueden insertar o eliminar elementos del mismo.

Dado un elemento se puede preguntar si est dentro del conjunto o no.

Se pueden hacer las operaciones binarias bien conocidas entre conjuntos a saber, unin, intersecciny diferencia.

1.2.2. Interfase del TAD CONJUNTO

Lainterfasees el conjunto de operaciones (con una sintaxis definida) que producen las operaciones delTAD. Por supuesto depende del lenguaje a utilizar, si bien algunas veces es tambin comn que una librerapueda ser usada desde diferentes lenguajes y trate de mantener la interfase entre esos diferentes lenguajes.

Por ejemplo la implementacin del TAD CONJUNTO en la librera STL es (en forma muy simplificada) lasiguiente,

1 template2 class set {3 public:4 class iterator { /* . . . */ };5 voidinsert(T x);6 void erase(iterator p);7 void erase(T x);8 iterator find(T x);9 iterator begin();

10 iterator end();11 };

Cdigo 1.7:Interfase de la clase set[Archivo: stl-set.cpp]



30/303



Esta interfase tiene la desventaja de que no provee directamente las operaciones mencionadas previa-mente pero encaja perfectamente dentro de la interfase general de los otros contenedoresde STL. Recor-

demos que en STL los elementos de los contenedores, como en este caso set, se acceden a travs deiteradores(iterators). En la siguiente descripcinses un conjunto,xun elemento y pun iterador

s.insert(x)inserta un elemento en el conjunto. Si el elemento ya estaba en el conjunto s quedainalterado.

p=s.find(x) devuelve el iterador para el elemento x. Si xno est en s entonces devuelve uniterador especialend(). En consecuencia, la expresin lgica para saber si un elemento est enses

if(s.find(x)==s.end()) {

// x no esta en s

// ...

}

s.erase(p)elimina el elemento que est en el iterador pen s. s.erase(x)elimina el elementox(si est en el conjunto).

La unin de dos conjuntos, por ejemploC =A Bpodemos lograrla insertando los elementos deAyBenC:

set A,B,C;

// Pone elementos en A y B

// ...

C.insert(A.begin(),A.end());

C.insert(B.begin(),B.end());

Normalmente en C/C++ la interfase est definida en los headers de las respectivas clases.

Todas las operaciones binarias con conjuntos se pueden realizar con algoritmos genricos definidosen el headeralgorithm, usando el adaptadorinserter:

template


31/303


Seccin 1.3. Tiempo de ejecucin de un programa

set_difference(a.begin(),a.end(),b.begin(),b.end(),

inserter(c,c.begin()));

C=A Bset_intersection(a.begin(),a.end(),b.begin(),b.end(),

inserter(c,c.begin()));

1.2.3. Implementacin del TAD CONJUNTO

Finalmente laimplementacinde estas funciones, es decir el cdigo especfico que implementa cadauna de las funciones declaradas en la interfase.

Como regla general podemos decir que un programador que quiere usar una interfase abstracta como elTAD CONJUNTO, debera tratar de elaborar primero un algoritmo abstracto basndose en las operaciones

abstractas sobre el mismo. Luego, al momento de escribir su cdigo debe usar la interfase especfica paratraducir su algoritmo abstracto en un cdigo compilable. En el caso del TAD CONJUNTO veremos ms ade-lante que internamente ste puede estar implementado de varias formas, a saber con listas o rboles, porejemplo. En general, el cdigo que escribe no debera depender nuncade los detalles de la implementacinparticular que esta usando.

1.3. Tiempo de ejecucin de un programa

La eficiencia de un cdigo va en forma inversa con la cantidad de recursos que consume, principalmentetiempo de CPU y memoria. A veces en programacin la eficiencia se contrapone con la sencillez y legibilidad

de un cdigo. Sin embargo en ciertas aplicaciones la eficiencia es un factor importante que no podemos dejarde tener en cuenta. Por ejemplo, si escribimos un programa para buscar un nombre en una agenda personalde 200 registros, entonces probablemente la eficiencia no es la mayor preocupacin. Pero si escribimos unalgoritmo para un motor de bsqueda en un nmero de entradas > 109, como es comn en las aplicacio-nes para buscadores en Internet hoy en da, entonces la eficiencia probablemente pase a ser un conceptofundamental. Para tal volumen de datos, pasar de un algoritmoO(n log n)a unoO(n1.3)puede ser fatal.

Ms importante que saber escribir programas eficientemente es sabercundoydondepreocuparse porla eficiencia. Antes que nada, un programa est compuesto en general por varios componentes o mdulos.No tiene sentido preocuparse por la eficiencia de un dado mdulo si este representa un 5 % del tiempo totalde clculo. En un tal mdulo tal vez sea mejor preocuparse por la robustez y sencillez de programacin quepor la eficiencia.

El tiempo de ejecucin de un programa (para fijar ideas, pensemos por ejemplo en un programa queordena de menor a mayor una serie de nmeros enteros) depende de una variedad de factores, entre loscuales

La eficiencia del compilador y las opciones de optimizacin que pasamos al mismo en tiempo de com-pilacin.El tipo de instrucciones y la velocidad del procesador donde se ejecutan las instrucciones compiladas.Los datos del programa.En el ejemplo, la cantidad de nmeros y su distribucin estadstica: >son todosiguales?, >estn ya ordenados o casi ordenados?



32/303



La complejidad algortmica del algoritmo subyacente. En el ejemplo de ordenamiento, el lector yasabr que hay algoritmos para los cuales el nmero de instrucciones crece como n2, donden es la

longitud de la lista a ordenar, mientras que algoritmos como el de ordenamiento rpido (quicksort)crece como n log n. En el problema de coloracin estudiado en 1.1.1el algoritmo de bsqueda ex-haustiva crece comonnvv , dondenves el nmero de vrtices del grafo contran

3vpara el algoritmo vido

descripto en 1.1.8.

En este libro nos concentraremos en los dos ltimos puntos de esta lista.

1 int search(int l,int *a,int n) {2 int j;3 for (j=0; j


33/303



constante sin especificar en forma absoluta, es decir que de alguna forma estamos evaluando el tiempo deejecucin en trminos deunidades de trabajo, donde una unidad de trabajo c es el tiempo necesario para

ejecutar una vez el lazo.En general, determinar analticamente el tiempo de ejecucin de un algoritmo puede ser una tarea in-

telectual ardua. Muchas veces, encontrar el Tpeor(n) es una tarea relativamente ms fcil. Determinar elTprom(n)puede a veces ser ms fcil y otras veces ms difcil.

1.3.1. Notacin asinttica

Para poder obtener una rpida comparacin entre diferentes algoritmos usaremos lanotacin asintticaO(...). Por ejemplo, decimos que el tiempo de ejecucin de un programa es T(n) =O(n2)(se leeT(n)esordenn2) si existen constantesc, n0> 0tales que para

T(n) c n2

, para n n0 (1.18)La idea es que no nos interesa como se comporta la funcin T(n)para valores den pequeos sino slo latendencia paran .Ejemplo 1.1: SeaT(n) = (n+ 1)2, entonces si

Documents

Algoritmos y Estructura de Datos.pdf