Edyai

Estructuras de Datos y Algoritmos I
Grado en Ingeniera Informtica
Ivn lvarez Navia

inavia@usal.es
M Jos Polo Martn
mjpolo@usal.es
Universidad de Salamanca
curso 2016-2017
Ivn lvarez Navia - M.J.Polo Martn (USAL) Estructuras de Datos y Algoritmos I curso 2016-2017 1 / 289
Contenidos
1 Introduccin a la Algoritmia
2 Notacin asinttica
3 Anlisis de Algoritmos
4 Algoritmos de bsqueda y ordenacin
5 Esquemas Algortmicos
6 Tipos Abstractos de Datos

Tema 1. Introduccin a la Algoritmia
Contenidos
Resolucin de problemas
La importancia de los algoritmos
Definiciones y conceptos bsicos
Algoritmo
Algoritmia
Dominio de definicin
La eficiciencia de los algoritmos
Operacin elemental
Introduccin a la Algoritmia Resolucin de problemas
Detalles del tema
Algoritmo
Algoritmia
Operacin elemental
1 Resolucin de Problemas
Informalmente, un algoritmo es el mtodo que, independientemente

del lenguaje de programacin, resuelve un problema o tipo de
problema
Un problema tiene infinitas formulaciones concretas, que se
denominan instancias
Disear un mtodo para resolver un problema, no significa resolver
una instancia del mismo, sino cualquier instancia
En esta asignatura nos centraremos en los algoritmos, su estudio, las
tcnicas de diseo, su anlisis y su implementacin
Resolviendo el problema
Mtodo cientfico Informtico

Observacin Anlisis del problema
Hiptesis Diseo del programa (algoritmos y
estructuras de datos)
Experimentacin Implementacin (programacin)
Verificacin Verificacin y pruebas
Refinamiento por pasos sucesivos
Escribir la estructura de la solucin en seudocdigo, de manera muy
genrica
Especificar los pasos de forma cada vez ms detallada y precisa
Repetir el refinamiento hasta llegar a una implementacin
Ms en las asignaturas de Ingeniera del Software...
Resolviendo el problema
Ms formalmente
Proceso de resolucin propuesto por Aho
Programas = Algoritmos + Estructuras de datos

No se pueden tomar decisiones sobre la estructuracin de los datos sin
tener conocimiento de los algoritmos que se aplican a los datos, y
viceversa, la estructura y seleccin de los algoritmos con frecuencia
dependen de la estructura de los datos subyacentes
Niklaus Wirth, Algoritmos y Estructuras de Datos,

Prentice Hall, 1993
Introduccin a la Algoritmia La importancia de los algoritmos
Detalles del tema
Algoritmo
Algoritmia
Operacin elemental
2 La importancia de los algoritmos

Como incrementar la velocidad
Tres formas de resolver un problema, mediante el uso de ordenadores, de

forma ms rpida
1 Disponer de ms ordenadores
2 Disponer de ordenadores ms rpidos
Proyecto TOP500, lista de los ordenadores ms potentes del mundo,
http://www.top500.org
Ranking de los ordenadores ordenados segn resultados obtenidos en la
ejecucin del LINPACK Benchmark
(http://www.top500.org/project/linpack,
http://es.wikipedia.org/wiki/Linpack)
3 Mejorar la eficiencia de la solucin construida, para que sea ms
rpida: mejorar los algoritmos
Los ordenadores ms rpidos del mundo (Junio 2015)

Los ms eficientes?
Localizacin Ordenador, fabricante Cores Pflop/s

1 National Super Com- Tianhe-2 (MilkyWay-2)-TH- 3.120.000 54,90
puter Center in IVB-FEP Cluster, Intel Xeon
Guangzhou. China E5-2692 12C 2.200GHz, TH
Express-2, Intel Xeon Phi 31S1P
NUDT
2 DOE/SC/Oak Ridge Titan - Cray XK7 , Opteron 560.640 27,11
National Laboratory. 6274 16C 2.200GHz, Cray Gem-
United States ini interconnect, NVIDIA K20x
Cray Inc.
3 DOE/NNSA/LLNL. Sequoia - BlueGene/Q, Power 1.572.864 20,13
United States BQC 16C 1.60 GHz, Custom
IBM.
... ... ... ... ...
77 Barcelona Super- MareNostrum - iDataPlex 48.896 1,01
computing Center. DX360M4, Xeon E5-2670 8C
Spain 2.600GHz, Infiniband FDR IBM
Mejorar la eficiencia de los algoritmos
En 1977 los inventores de RSA propusieron en Scientific American un reto

(http:
//es.wikipedia.org/wiki/The_Magic_Words_are_Squeamish_Ossifrage):
Pagaran $100 a quien descifrara un texto llano a partir de un texto cifrado

y una clave pblica. Involucraba la factorizacin de un nmero de 129
cifras decimales, RSA-129, para recuperar el texto llano
Estimacin: el ordenador ms rpido del momento, utilizando los

mejores algoritmos del momento, tardara el equivalente a muchos
millones de aos (cuatrillones, 1024 )
En 1994, ocho meses de clculo para resolver el reto!
La razn: mejora de los algoritmos de factorizacin
Introduccin a la Algoritmia Definiciones y conceptos bsicos
Detalles del tema
Algoritmo
Algoritmia
Operacin elemental
3 Definiciones y conceptos bsicos

Algoritmo
Definicin (DRAE)
Conjunto ordenado y finito de operaciones que permite hallar la solucin
de un problema
Definicin ms informtica
Secuencia finita de reglas que proporcionan una secuencia de operaciones
para la resolucin de un determinado tipo de problema, bien sea a mano o,
ms frecuentemente, en una mquina
La palabra algoritmo proviene del nombre de un matemtico persa del

siglo IX, Abu Abdallah Muhammad ibn Musa al-Khwarizmi, que
escribi tratados de aritmtica y lgebra
Literalmente significa hijo de Moiss, nativo de Khwarizm
Al-Khwarizmi se transform en algorismo y, posteriormente, en
algoritmo
Caractersticas de los algoritmos
Es finito: un algoritmo siempre finaliza tras la ejecucin de un nmero

finito de operaciones
Est bien definido: cada paso del algoritmo est definido con
precisin y sin ambigedad
Produce una o ms salidas a partir de cero o ms entradas
Es efectivo: cada operacin del algoritmo es lo suficientemente
elemental como para que podamos ejecutarla de modo exacto en un
tiempo finito. Consumo finito de recursos
Algoritmo determinista
Para los mismos datos de entrada producen los mismos datos de salida
Ejemplo
Algoritmo ms conocido
Algoritmo de Euclides Algoritmo 1.1 euclides(m,n)

Dados dos enteros Entrada: Enteros positivos, m y n
positivos, m y n, Salida: Mximo comn divisor de m y n
encontrar el mximo 1: mientras n > 0 hacer
comn divisor, es 2: temp n
decir, el entero 3: n m%n
positivo ms grande 4: m temp
que es divisor de m y 5: fin mientras
n 6: devolver m
Mtodo y Secuencia Computacional
Definicin: Mtodo computacional

Se define un mtodo computacional como una cuaterna (Q, I, , f ), en
la cual:
Q es el conjunto de estados de clculo (o estados de cmputo), que
contiene a los subconjuntos I y
I es el conjunto de estados de entrada
es el conjunto de estados de salida
f es una funcin que deja fijado punto a punto, es decir, que
f : Q Q y tal que f (q) = q; q . Tambin se denomina la
regla computacional
Definicin: Secuencia computacional

Cada entrada x en el conjunto I define una secuencia computacional,
x0 , x1 , x2 , ... de la siguiente manera: x0 = x y xk+1 = f (xk ) para k 0
Definicin formal de algoritmo
Se dice que una secuencia computacional termina en k pasos si k es

el entero ms pequeo para el cual xk , y en este caso se dice que
para la entrada x produce la salida xk
Algunas secuencias computacionales no terminan nunca
Definicin: Algoritmo
Un algoritmo es un mtodo computacional que termina en un nmero
finito de pasos para todo x en I
Donald E. Knuth, The Art of Computer Programming.

Ed Addison Wesley, 3 ed.
Definicin formal del algoritmo de Euclides

Sea Q el conjunto de todos valores individuales (n), todos los pares
ordenados (m, n), y todas las cuaternas ordenadas(m, n, r , 1),
(m, n, r , 2), y (m, n, p, 3), donde m, n, y p son enteros positivos y r es
un entero no negativo
Sea I el subconjunto de todos lo pares (m, n) y el subconjunto de
los valores individuales (n)
Se define la regla computacional, f , como sigue
f ((m, n)) = (m, n, 0, 1); f ((n)) = n;
f ((m, n, r , 1)) = (m, n, resto de dividir m por n, 2);
f ((m, n, r , 2)) = (n) si r = 0, (m, n, r , 3) en caso contrario
f ((m, n, p, 3)) = (n, p, p, 1).
The correspondence between this notation and Algorithm E (Euclides)
is evident
Donald E. Knuth, The Art of Computer Programming.
Ed Addison Wesley, 3 ed.
Diseo de algoritmos
Diseo del algoritmo a partir de la definicin del problema

Cada problema requiere una aproximacin particular
No hay frmula mgica
Se trata ms de un arte que de una tcnica: creatividad, experiencia, ...
La especificacin de un algoritmo no debe implicar ninguna
decisin subjetiva, ni tampoco debe hacer preciso el uso de la
intuicin ni de la creatividad
Abstraccin y modelado del problema
A veces es posible clasificar el problema como miembro de una familia
(Tema 5. Esquemas Algortmicos)
Seleccin de un esquema algortmico (algoritmo abstracto)
Instanciacin del esquema en un algoritmo concreto ( interpretacin del
esquema algortmico)
Verificacin, anlisis y refinamientos sucesivos del algoritmo
Algoritmia
Ciencia que estudia tcnicas para construir algoritmos eficientes y

tcnicas para medir la eficacia de los algoritmos
Para resolver un problema, varios algoritmos disponibles. Para decidir
cul se utiliza se debe considerar:
Los lmites de la mquina disponible
Cuestiones relacionadas con tiempos de ejecucin
Recursos de memoria
Complejidad a la hora de realizar la programacin
La algoritmia permite
El estudio de todos los factores sobre los algoritmos
Elegir el algoritmo que mejor se ajuste a unas circunstancias
particulares
Construir nuevos algoritmos para la realizacin de una tarea concreta
Ejemplo: Multiplicacin de dos nmeros enteros

Algoritmo clsico
2 5 9 6
x 1 2 3
Algoritmo 1.2 multiplicacinClsica(mo,mr) 7 7 8 8
Entrada: Enteros positivos, mo y mr 5 1 9 2
Salida: Producto de mo y mr 2 5 9 6
1: resultado 0 3 1 9 3 0 8
2: mientras mr tenga cifras hacer
3: sumando cifra_mr mo 2 5 9 6
4: resultado resultado + x 1 2 3
10posici on_cifra_mr sumando 2 5 9 6
5: fin mientras 5 1 9 2
6: devolver resultado 7 7 8 8
3 1 9 3 0 8

Multiplicacin "rusa"
Algoritmo 1.3 multiplicacinRusa(mo,mr)

Entrada: Enteros positivos, mo y mr 231 * 4567
Salida: Producto de mo y mr mo mr resultado
1: resultado 0 231 4567 4567
2: mientras mo 6= 0 hacer
115 9134 9134
3: si mo % 2 6= 0 entonces
4: resultado resultado + mr 57 18268 18268
5: fin si 28 36536
6: mo mo 2 14 73072
7: mr mr + 2
7 146144 146144
8: fin mientras
9: devolver resultado 3 292288 292288
1 584576 584576
1054977
Similar al que emplea el hardware
No es preciso recordar ninguna tabla de multiplicacin,
tan slo sumar y dividir por 2

Algoritmo "Divide y Vencers"
Algoritmo 1.4 multiplicacinDivide(mo, mr) Condiciones:

Entrada: Enteros positivos, mo y mr Multiplicando y multiplicador
Salida: Producto de mo y mr deben tener el mismo nmero
1: n maxCifras(mo, mr) de cifras
2: si n es pequeo entonces
3: devolver multiplicacinClsica(mo, mr) Este nmero de cifras debe
4: si no ser potencia de dos
5: sn2 (1,2,4,8,16,...)
6: w mo 10s 0231 * 4567
7: x mo %10s Multiplica Desplaza Resultado
8: v mr 10s 02 45 4 cifras 90 00 00
9: y mr %10s 02 67 2 cifras 1 34 00
10: fin si 31 45 2 cifras 13 95 00
11: devolver (multiplicacinDivide (w,v) * 102s + 31 67 0 cifras 20 77
multiplicacinDivide (w,y) * 10s + 105 49 77
multiplicacinDivide (x,v) * 10s +
multiplicacinDivide (x,y) )

Algoritmo evidente
Algoritmo 1.5 multiplicacin(mo,mr)

Entrada: Enteros positivos, mo y mr
Salida: Producto de mo y mr
1: resultado 0
2: i mr
3: mientras i 1 hacer
4: resultado resultado + mo
5: ii-1
6: fin mientras
7: devolver resultado
Multiplicacin de dos nmeros enteros

Conclusiones
Incluso en un problema tan sencillo y cotidiano como la aritmtica

elemental, puede haber disponibles varios algoritmos
Uno resultar atractivo por su familiaridad, otro por la naturaleza
elemental de los clculos y otro por su velocidad
Utilizando la algoritmia se puede tomar una decisin sabia acerca de
la tcnica que se debe utilizar en una situacin dada
Una buena eleccin puede ahorrar, a la vez, tiempo y dinero, y puede
ser la diferencia entre el xito y el fracaso al resolver un problema
grande y difcil
Dominio de definicin: conjunto de casos que deben considerarse a

la hora de especificar o definir un problema
En nuestros ejemplo: Los casos de multiplicacin que implican nmeros
enteros positivos
Un problema dado puede tener un nmero infinito de ejemplares o
finito
Un algoritmo debe funcionar correctamente en todos los
ejemplares o casos de un problema que manifiesta resolver
Si un algoritmo no funciona correctamente para un ejemplar, dicho
algoritmo ser incorrecto
No se debe confundir la correccin de un algoritmo con las
limitaciones de las mquinas o sistemas donde pueda ser ejecutado
La eficiencia de los algoritmos
Relacionado con el consumo de recursos computacionales,

generalmente tiempo y memoria
Se define como la relacin entre los recursos consumidos y los
productos conseguidos
Criterio empresarial maximizar la eficiencia
Ayuda a decidir: Un problema y varios algoritmos adecuados,
debemos seleccionar el mejor
La eleccin depender de diversos factores: no de casos, legibilidad,
eficiencia, ...
La legibilidad y simplicidad siguen siendo muy importantes
Enfoques para calcular la eficiencia de los algoritmos
Enfoque emprico o a posteriori: consiste en programar las tcnicas

competidoras e ir probndolas en distintos casos con ayuda del
ordenador
Enfoque terico o a priori: consiste en determinar matemticamente
la cantidad de recursos necesarios para cada uno de los algoritmos
como funcin del tamao de los casos considerados
Enfoque hbrido:
Determinar tericamente el tipo de funcin que describe la eficiencia
Evaluar, empricamente, ciertos parmetros numricos que dependen de
la implementacin concreta
Permite evaluar de antemano el tiempo de ejecucin de un programa
concreto para ejemplares de mayor tamao que los utilizados en la
evaluacin mediante la extrapolacin
Qu estrategia es mejor?
Estrategia ms ventajosa la terica:

No depende del ordenador, ni del lenguaje de programacin ni de la
habilidad del programador
No se pierde el tiempo programando algoritmos ineficientes y
probndolos
Permite conocer la eficiencia del algoritmo cualquiera que sea el
tamao del ejemplar
Recursos considerados
Tiempo de CPU o de clculo o de procesamiento (el fundamental)

Generalmente, algoritmo ms rpido algoritmo ms eficiente
Espacio de almacenamiento o tamao nmero de bits que se
necesitan para representar el ejemplar en el ordenador, aunque no es
necesario llegar a este nivel de detalle:
Ms habitualmente, tamao relacionado con el nmero de
elementos que constituyen el ejemplar (ordenacin de un vector de
nmeros enteros, nmero de filas y columnas de una matriz, ...)
En ocasiones la eficiencia se expresar en funcin de los propios valores
del ejemplar (multiplicacin de nmeros enteros el tamao de los
nmeros depender del nmero de cifras que contengan)
Para cada problema es necesario analizar la naturaleza de los datos
para determinar qu parmetro define el tamao de los ejemplares
La eficiencia de los algoritmos siempre vendr dada en funcin de
dichos tamaos de los datos de entrada
Principio de invariancia
Unidad de tiempo (segundos, etc.) se necesita disponer de un

ordenador de referencia
Principio de invariancia: La eficiencia de dos implementaciones del
mismo algoritmo difiere tan slo en una constante multiplicativa
no existe una unidad
Si un algoritmo escrito en C se compila en un i3 y en un i7 tendramos
dos implementaciones distintas
Si al ejecutar este algoritmo en el i7 para un ejemplar tarda 3 segundos
y en el i3 para el mismo ejemplar tarda 30 segundos, el principio de
invariancia nos dice que otro ejemplar que en el i7 requiera 1 minuto
necesitara en el i3 aproximadamente 10 minutos
Unidad de medida
Resumiendo
No habr unidad para medir la eficiencia, nos limitaremos a decir que
el tiempo de ejecucin de un algoritmo ser t(n), es decir, una
funcin del tamao de los ejemplares
En unas mquinas el tiempo de ejecucin ser a t(n) y en otras ser
b t(n), siendo a y b sendas constantes reales
Por tanto, hablaremos de un tiempo requerido, salvo una constante
multiplicativa tiempo del orden de t(n)
Y en particular, nos interesar la forma en que se comporta el
algoritmo, como aumenta su tiempo de ejecucin, al aumentar el
tamao de los datos
Funciones tpicas
Funciones tpicas que nos encontraremos:

Algoritmo lineal: tiempo de ejecucin del orden de n
Algoritmo logartmico: logn y nlogn
Algoritmo cuadrtico: tiempo de ejecucin del orden de n2
Algoritmo cbico: tiempo de ejecucin del orden de n3
Algoritmo polinmico: tiempo de ejecucin del orden de nk
Algoritmo exponencial: tiempo de ejecucin del orden de c n
A veces es importante tener en cuenta la constante multiplicativa
implcita. Ejemplo: dos algoritmos distintos ejecutndose en la misma
mquina
Algoritmo A: emplea n2 das
Algoritmo B: emplea n3 segundos
Casos mejor, medio y peor
No todos los ejemplares de un problema son iguales la eficiencia

del algoritmo puede variar en funcin del estado o del propio
contenido de los datos de entrada del ejemplar
Pueden darse tres casos, aunque no siempre:
Caso mejor: se trata de aquellos ejemplares del problema en los que el
algoritmo es ms eficiente
Caso peor: se trata de aquellos ejemplares del problema en los que el
algoritmo es menos eficiente. Nos interesa mucho.
Caso medio: se trata del resto de ejemplares del problema. Es el caso
que ms nos debera preocupar puesto que ser el ms habitual, sin
embargo no siempre se puede calcular (habra que saber cules son las
probabilidades de los distintos ejemplares)
Ejemplo de casos mejor, medio y peor
Algoritmo de bsqueda secuencial

Se recorre secuencialmente (linealmente) el vector buscando una clave
entre los valores del mismo. Dicho recorrido se detiene cuando se
localiza dicho valor
Caso mejor: La clave se encuentra en la primera posicin el bucle
ejecuta una nica iteracin
Caso peor: No se encuentra la clave o se encuentra en la ltima
posicin el bucle da n iteraciones, siendo n el tamao del vector
Caso medio: La clave buscada se encuentra en una posicin
intermedia del vector valor promedio
Ojo: El mejor caso no significa tamao pequeo
Operacin elemental
Es aquella cuyo tiempo de ejecucin se puede acotar superiormente

por una constante que:
Solamente depender de la implementacin particular usada
NO depender del tamao ni de los parmetros del ejemplar
considerado
El tiempo de ejecucin de un algoritmo, definido salvo una constante
multiplicativa, ser el nmero de operaciones elementales ejecutadas
El tiempo exacto de una operacin elemental no es relevante, se
ejecutan a coste unitario
Cuidado! No se debe identificar una lnea de programa (descripcin
del algoritmo) con una operacin elemental. Ejemplo:
x valorM inimo{T [i]k1 i n}
Operacin elemental
Problemas aadidos:
Suma, producto de nmeros enteros operacin elemental?. El
tiempo de ejecucin crece con el tamao de los operandos
Operaciones con nmeros reales: la precisin requerida. Problema
similar al anterior
No siempre operaciones aparentemente sencillas equivalen a
operaciones elementales. Puede haber dependencia de la
implementacin, tamao operandos, etc.
Sin embargo, generalmente, sumas, restas, multiplicaciones,
divisiones, operaciones mdulo, operaciones booleanas, comparaciones
y asignaciones se consideran operaciones elementales de coste unitario
Notacin
El lenguaje natural, el espaol en este caso, no est especialmente

adaptado para describir algoritmos
Tampoco vamos a utilizar el lenguaje C (PI y PII), as los extremos
esenciales del algoritmo no resultarn oscurecidos por detalles de
programacin poco importantes
Seudocdigo, lenguaje estructurado (como C) en espaol. Obsrvese
los ejemplos para quedarse con la sintaxis utilizada
Ojo, alguna instruccin en seudocdigo puede tener que traducirse en
varias en C
Cada autor tiene su propia sintaxis de seudocdigo, aunque suele haber
elementos comunes
Notacin
Identificacin de algoritmos: Algoritmo, Procedimiento, Funcin

Asignacin: resultado 0
Bloques: sangrado ms las palabras [inicio], fin [id estructura]
Condicional: si condicin entonces bloque [si no bloque fin [si]]
Bucles: para estadoInicial hasta estadoFinal hacer bloque, mientras
condicin hacer bloque, repetir bloque hasta condicin
Devolver: devolver
Punteros: identificadorPuntero[.campo]
Matrices: pueden ser dinmicas o estticas indistintamente, no
necesaria reserva de memoria
Nodos listas enlazadas: similar a lo conocido en C, incluyendo reserva
de memoria
Observaciones finales
Resulta muy til tener un conocimiento extenso de los algoritmos ms

eficientes para resolver problemas ejemplo: bsqueda, ordenacin, etc.
En EDyA I, estudiaremos estos algoritmos, desde los menos eficientes a

los ms eficientes
El estudiante debe comprender: operaciones fundamentales, cambios
de estrategia, mejora en el rendimiento, ...
No es cuestin de memorizar los algoritmos sino de comprender su
funcionamiento
Contenidos
2 Notacin asinttica

Tema 2. Notacin Asinttica
Contenidos
Introduccin
Notacin El orden de
Notacin Omega
Notacin Theta
Notacin asinttica Introduccin
Detalles del tema
2 Notacin asinttica
Introduccin
Notacin El orden de
Notacin Omega
Notacin Theta
1 Introduccin
Como se ha presentado en el tema anterior la eficiencia de un

algoritmo puede definirse como una funcin t(n)
A la hora de analizar un algoritmo interesa, principalmente, la forma
en que se comporta el algoritmo al aumentar el tamao de los datos,
es decir, cmo aumenta su tiempo de ejecucin
Esto se conoce como eficiencia asinttica de un algoritmo o
complejidad computacional o algortmica
Aspecto fundamental a la hora de elaborar algoritmos ya que permite
realizar la eleccin del algoritmo ms adecuado
Ojo!!, un algoritmo que sea superior asintticamente suele ser, aunque
no siempre, preferible en casos de tamao moderado
Un ejemplo
Sean dos algoritmos, A y B, que resuelven el mismo problema
A, requiere ejecutar ta (n) = 100n + 10 instrucciones
B, requiere ejecutar tb (n) = 2n2 instrucciones
Cul es mejor?
n ta (n) = 100n + 10 tb (n) = 2n2
1 110 2
2 210 8
3 310 18
4 410 32
5 510 50
6 610 72
... ... ...
50 5010 5000
51 5110 5202
52 5210 5408
Notacin asinttica
Recordando el tema anterior, utilizamos una funcin t(n) para

representar el tiempo requerido por el algoritmo salvo una constante
multiplicativa, debido a:
No existe un ordenador de referencia
Principio de invariancia
Notacin asinttica comportamiento de funciones en el lmite, es
decir, para valores suficientemente grandes de su parmetro
La notacin asinttica, permite representar:
El tiempo de ejecucin
El nmero de veces que se ejecuta una instruccin en un programa
Notacin asinttica Notacin El orden de
Detalles del tema
2 Notacin asinttica
Introduccin
Notacin El orden de
Notacin Omega
Notacin Theta
2 Notacin el orden de
Definicin del conjunto el orden de f (n)
Sea f : N R0 una funcin cualquiera. Se define:
O(f (n)) = {t : N R0 |(c R+ )(n0 N)(n n0 )[t(n) cf (n)]}
El orden de f (n), O(f (n)), es el conjunto de todas las funciones t(n)

acotadas superiormente por un mltiplo real positivo de f (n) para valores
de n suficientemente grandes, a partir de un valor umbral n0
Por t(n) O(f (n)) denotamos que la funcin t(n) es del orden
f (n) o que f (n) es una cota superior asinttica de t(n)
Podemos decir que t(n) est en el orden de f (n) incluso si:
t(n) es negativo: n3 3n2 n 8 < 0 para n 3
n
t(n) no est definido para un conjunto finito de valores: , para
log n
n=0yn=1
Grficamente
t(n) es del orden f (n)
t(n) O(f (n)) f (n) es cota superior asinttica de t(n)
Observaciones sobre esta notacin
El principio de invariancia garantiza que si la implementacin de un

algoritmo no emplea ms de t(n) segundos en el caso peor y para
ejemplares de tamao n, cualquier otra implementacin del algoritmo
emplear un tiempo del orden de t(n)
Si tenemos un algoritmo cuyo tiempo de ejecucin es t(n) podemos
encontrar otra funcin de n, f (n), y un tamao de problema n0 de tal
forma que f (n) acota superiormente al tiempo de ejecucin para
todos los problemas de tamao superior a n0
Se dice que el algoritmo emplea un tiempo del orden de f (n) ya que
t(n) O(f (n)). Y de hecho, dado que t(n) O(t(n)), el algoritmo
emplea un tiempo del orden de t(n)
En general, se tratar de encontrar la funcin f ms simple posible
tal que t(n) O(f (n)) para expresar el orden del algoritmo
Observaciones sobre nomenclatura
Resulta bastante natural utilizar el smbolo de teora de

conjuntos para denotar que n2 es del orden de n3 n2 O(n3 )
Algunos autores siguen utilizando la notacin tradicional
n2 = O(n3 )
Ojo que no es simtrica, esa igualdad es en un nico sentido, no es
cierto que O(n3 ) = n2
Tambin se suele utilizar la expresin n3 domina asintticamente
a n2
Definen el orden de complejidad como una funcin que domina la
ecuacin que expresa en forma exacta el tiempo de ejecucin del
algoritmo
Regla del mximo
Formalmente
Sean p, q : N R0 definidas para todo nmero natural n, y sea t(n) una
funcin arbitraria t : N R0
)
p(n) = f (n) + g(n)
t(n) O(p(n)) si y slo si t(n) O(q(n))
q(n) = max (f (n), g(n))
Regla til para demostrar que una funcin es del orden de otra
Sean f , g : N R0 dos funciones arbitrarias de los nmeros
naturales en los reales no negativos. Entonces:
O(f (n) + g(n)) = O(max (f (n), g(n)))
Regla del lmite
Sean dos funciones arbitrarias: f , g : N R0
f (n)
Si lim R+ entonces f (n) O(g(n)) y g(n) O(f (n))
n g(n)
f (n)
Si lim = 0 entonces f (n) O(g(n)) pero g(n)
/ O(f (n))
n g(n)
f (n)
Si lim = + entonces f (n)
/ O(g(n)) pero g(n) O(f (n))
n g(n)
La inversa de la regla del lmite no es necesariamente vlida
Herramienta potente y verstil para demostrar que algunas funciones estn

en el orden de otras, y para demostrar lo contrario
Ejemplo regla del lmite

Determinar el orden relativo de las funciones:
f (n) = log n

g(n) = n
Puesto que ambas tienden a infinito con n, utilizamos la regla de lHpital

1
f (n) log n 2
lim = lim = lim n1 = lim = 0 log n O( n)
n g(n) n n n n n
2 n

Regla del lmite log n O( n) mientras que n
/ O(log n)

n crece asintnticamente ms deprisa que log n
Observaciones
La notacin el orden de proporciona una cota superior asinttica

para una funcin
Ejemplo de algoritmos de ordenacin:
Insercin, seleccin O(n2 )
Ordenar-montculo O(n log n)
Pero n log n O(n2 ) ? Tiempo de ejecucin de ordenar-montculo
de O(n2 )
Cota inferior asinttica Notacin Omega
En el anlisis del comportamiento de un algoritmo el ideal sera
encontrar que su tiempo de ejecucin est acotado tanto por encima
como por debajo mediante mltiplos reales positivos de una misma
funcin Notacion Theta
Notacin asinttica Notacin Omega
Detalles del tema
2 Notacin asinttica
Introduccin
Notacin El orden de
Notacin Omega
Notacin Theta
3 Notacin Omega
Definicin del conjunto (f (n))

Sean dos funciones t, f : N R0 , diremos que t(n) (f (n)), si t(n)
est acotada inferiormente por un mltiplo real positivo de f (n), para todo
n suficientemente grande:
(f (n)) = {t : N R0 |(d R+ )(n0 N)(n n0 )[t(n) df (n)]}
Graficamente
Notacin Omega, empleada para

establecer las cotas inferiores sobre
la cantidad de recursos requeridos
Regla de la dualidad
Regla de la dualidad:
t(n) (f (n)) f (n) O(t(n))
La regla de dualidad se puede utilizar para transformar la regla del

lmite y la regla del mximo.
Ejemplo:
1
f (n) log n n 2
lim = lim = lim 1 = lim = 0 n (log n)
n g(n) n n n n n
2 n
La regla de dualidad invierte las expresiones

n (log n) mientras que log n
/ ( n)
Notacin asinttica Notacin Theta
Detalles del tema
2 Notacin asinttica
Introduccin
Notacin El orden de
Notacin Omega
Notacin Theta
4 Notacin Theta
t(n) (f (n)) si pertenece tanto a O(f (n)) como a (f (n))
(f (n)) = O(f (n)) (f (n))
Definicin del conjunto (f (n))

(f (n)) = {t : NR0 |(c, dR+)(n0N)(n n0 )[df (n) t(n) cf (n)]}
Graficamente
Reformulando las reglas del mximo y del lmite
La regla del mximo es igualmente aplicable en esta notacin

La regla del lmite se reformula de la siguiente manera:
Dadas dos funciones arbitrarias t, f : N R0
f (n)
Si lim R+ entonces f (n) (g(n))
n g(n)
f (n)
Si lim = 0 entonces f (n) O(g(n)) pero f (n)
/ (g(n))
n g(n)
f (n)
Si lim = + entonces f (n) (g(n)) pero f (n) / (g(n))
n g(n)
Grficas funciones tpicas
Sublineales Superlineales
Gficamente se observa la relacin de inclusin entre diferentes

rdenes

O(1) O(logn) O( n) O(n)
O(n log n) O(n2 ) O(n3 ) O(2n ) O(nn )
Otras propiedades y observaciones
Algunas propiedades de la notacin "orden de"

O(c g(n)) = O(g(n)), con c constante
O(f (n) g(n)) = O(f (n)) O(g(n)), y viceversa
O(f (n)/g(n)) = O(f (n))/O(g(n)), y viceversa
g(n) O(f (n)) O(g(n)) O(f (n))
f (n) = g(n) g(n) O(f (n)) y f (n) O(g(n))
Si f (n) O(g(n)) y g(n) O(h(n)) f (n) O(h(n))
Si f (n) O(g(n)) y f (n) O(h(n)) f (n) O(min(g(n), h(n)))
Teniendo en cuenta la regla de dualidad, las mismas propiedades

pueden plantearse para las otras dos notaciones
Observacin til: no es necesario especificar la base del logaritmo
dentro de la notacin asinttica
logb n
loga n =
logb a
loga n y logb n slo difieren en una constante real positiva, cuando a y
b son constantes reales mayores que uno
Contenidos
2 Notacin asinttica

Tema 3. Anlisis de Algoritmos
Contenidos
Introduccin
Operaciones elementales e instrucciones
Estructuras secuenciales
Estructuras alternativas
Estructuras repetitivas
Bucles para (for)
Bucles mientras (while) y repetir (repeat)
Algoritmos Recursivos y Recurrencias
Recursividad frente a Iteracin
Anlisis de Algoritmos Introduccin
Detalles del tema
Introduccin
Bucles para (for)
Introduccin
Ideas iniciales
Herramienta que permite decidir que algoritmo, de entre varios, es el

ms adecuado para resolver un determinado problema
No existe una frmula mgica, ms una cuestin de juicio, intuicin y
experiencia
Sin embargo existen algunas tcnicas bsicas que resultan ser tiles:
1 El anlisis de los algoritmos se suele efectuar de dentro hacia fuera
2 Se determina el tiempo requerido por instrucciones individuales (ojo, no
necesariamente operaciones elementales)
3 Se combinan estos tiempos de acuerdo con las estructuras de control
que enlazan las instrucciones del programa
Tcnicas para determinar el orden de un algoritmo
1 Contabilizar el nmero de operaciones elementales ejecutadas, no

instrucciones
2 Contabilizar el nmero de veces que se ejecuta la instruccin
barmetro
Una instruccin barmetro es aquella que se ejecuta, por lo menos,

con tanta frecuencia como cualquier otra instruccin en el algoritmo
Siempre que el tiempo requerido por cada instruccin est acotado
por una constante:
se pueden despreciar los tiempos exactos que requieren las distintas
instrucciones
el tiempo requerido por el algoritmo completo es del orden exacto del
nmero de veces que se ejecuta la instruccin barmetro
Problema: eleccin de la instruccin barmetro
Anlisis de Algoritmos Operaciones elementales e instrucciones
Detalles del tema
Introduccin
Bucles para (for)
Anlisis de Algoritmos Operaciones elementales e instrucciones
2 Operaciones e instrucciones elementales
Tiempo de ejecucin de O(1) para expresiones sencillas con

instrucciones y operaciones elementales
Para expresiones complejas el tiempo de ejecucin ser del orden de la
expresin
Ejemplo: asignacin
variable expresi on
Si la expresin es sencilla, es decir,es una operacin elemental,
entonces el tiempo de ejecucin de la asignacin es de coste unitario
variable 3.141592
variable a + b
variable a/b
...
Si la expresin es de O(n) la asignacin ser de ese orden!!!
variable buscar (x , T [n])
Anlisis de Algoritmos Estructuras secuenciales
Detalles del tema
Introduccin
Bucles para (for)
Anlisis de Algoritmos Estructuras secuenciales
3 Estructuras secuenciales
sentencia 1
sentencia 2
...
sentencia s
Sean f1 (n), f2 (n), ..., fs (n) las funciones que representan los tiempos
de ejecucin de cada una de dichas sentencias
Regla de la composicin secuencial:
El tiempo de ejecucin de la estructura estar en el orden de
O(f1 (n) + f2 (n) + ... + fs (n))
Por la regla del mximo, ese tiempo est en
O(max (f1 (n), f2 (n), ..., fs (n)))
Anlisis de Algoritmos Estructuras alternativas
Detalles del tema
Introduccin
Bucles para (for)
Anlisis de Algoritmos Estructuras alternativas
4 Estructuras alternativas
si expresin entonces
bloque de sentencias
si no
otro bloque de sentencias
fin si
o cualquier estructura alternativa en escalera
La expresin, el primer bloque de sentencias y el segundo
bloque de sentencias tendrn unos tiempos de ejecucin
representados que estn en el orden de
O(f1 (n)), O(f2 (n)), O(f3 (n)) respectivamente
El tiempo de ejecucin de la estructura ser el correspondiente a la

funcin de mayor orden
O(max (f1 (n), f2 (n), f3 (n)))

Anlisis de Algoritmos Estructuras repetitivas
Detalles del tema
Introduccin
Bucles para (for)
Bucles para (for)
para i 1 hasta m hacer

P(i)
fin para
Bucle parte de un algoritmo ms extenso m funcin de n
tp denota el tiempo para ejecutar P(i) y no depende del valor de i
existe un tiempo aadido relacionado con el control del bucle
(inicializacin, comprobacin condicin bucle, etc)
c para i 1
+ (m + 1)c para las comprobaciones i m
+ mtp para las m ejecuciones de P(i)
+ mc para las ejecuciones i i + 1
+ mc para las instrucciones de salto
TOTAL mtp + 3cm + 2c
Bucles para (for)

acotando tiempos
Si el bucle forma parte de un algoritmo ms extenso que trabaja con

un ejemplar de tamao n, el tiempo t(n) requerido para la ejecucin
del bucle est acotado superiormente e inferiormente:
mtP t(n) mtP + 3cm + 2c
Si tP est acotado inferiormente por alguna constante y existe un

umbral n0 tal que m 1 siempre que n n0 entonces
t(n) (mtP )
considerando m y tP funciones de n
t(n) (mtP )
Ejemplos bucles "para" iterando sobre el tamao del ejemplar(m = n)
para i 1 hasta n hacer )

m=n o
x x +i (n)
tP (1)
fin para
para i 1 hasta n hacer )

para j 1 hasta n hacer m=n o
(n2 )
x x +j tP (n)
fin para
fin para
Bucles para (for)

acotando tiempos
En general tP puede depender de i, n e incluso del propio caso,

tP (i)
Suponiendo que m 1 puede despreciarse el tiempo de control del
bucle y su tiempo de ejecucin viene dado por
m
X
t(n) tP (i)
i=1
Observaciones sobre el valor lmite de iteracin del bucle, m

En ocasiones coincide con el tamao del ejemplar (m = n)
De qu orden es un bucle si m es constante?
Pm
t(n) i=1 tP (i)
Ejemplos bucles "para" iterando sobre el tamao del ejemplar(m = n)
para i 1 hasta n hacer Pn

t(n) i=1 tP (i)
)
x x +i m=n
1 + 1 + ... + 1 = n
fin para tP (i) (1)
t(n) (n)
para i 1 hasta n hacer Pn

para j 1 hasta n hacer m=n
t(n) i=1 tP (i)

x x +j tP (j) (1) n + n + ... + n = n2
t (i) (n)
t(n) (n2 )
fin para P
fin para
Bucles para (for)

El orden de P(i) depende de "i"
Situacin tpica
El valor lmite de iteracin del bucle coincide con el tamao del
ejemplar (m = n)
El orden de P(i) depende de la variable con controla el bucle
tP (i) (i)
n n
X X (1 + n)n
t(n) tP (i) = i = 1 + 2 + ... + n = (n2 )
i=1 i=1
2
para i 1 hasta n hacer

m=n

para j 1 hasta i hacer o
tP (i) (i) t(n) (n2 )
x x +j

fin para
fin para
El nmero de iteraciones no es explcito como en los bucles "para"

Son ms difciles que los "para" ya que no se sabe, a priori, cuantas
veces se va a ejecutar
Tcnica para averiguar el nmero de iteraciones :
Definir una funcin de las variables implicadas en el bucle (cuerpo y
condicin del mismo)
Estudiar la evolucin de dicha funcin, desde el valor inicial de la
misma (estado antes de la primera iteracin) hasta el valor final
(estado despus de la ltima iteracin)
Sabiendo el estado inicial, el final y como evoluciona la funcin entre
iteracin e iteracin, podemos obtener el nmero de iteraciones
Ejemplo 1
Se define una funcin d, dependiente de las variables involucradas en el bucle
En el bucle de ejemplo esta funcin puede ser d = j i + 1

Antes de la primera iteracin su valor es d0 = n
entero i, j, k
i 1 Al final de la ltima iteracin su valor es dk = 1
Se debe estudiar la evolucin de d con la ejecucin del bucle:
j n inicio d0 = n = n0 Condicin FIN i = j
2
mientras i < j hacer iteracin 1
d
d1 = 20 = n1
2
dk = 1
k (i + j) 2 iteracin 2
d
d2 = 21 = n2
2
n
2k
=1
d2
j k iteracin 3 d3 = 2
= n
23

... ... 2k = n k = log2 n = lg n iteraciones
fin mientras dk1
iteracin k dk = 2
= nk t(n) O(lg n)
2
Resultado ejecucin para n variando en potencias de 2!!!
Ejemplo 2
Una nica variable de control, i: la funcin

Antes de la primera iteracin el valor de i es 1
entero i, x
Al final de la ltima iteracin es i > n
i 1
Se debe estudiar la evolucin de i con la ejecucin del bucle:
x 0 inicio i0 = 1 = 20 Condicin FIN i>n
mientras i n hacer iteracin 1 i1 = 2 i0 = 21 En la ltima Iteracin ik > n
iteracin 2 i2 = 2 i1 = 22
x x +1 iteracin 3 i3 = 2 i2 = 23 2k1 n
... ...
i 2i iteracin k-1 ik1 = 2 ik2 = 2k1 k 1 lg n k lg n + 1
fin mientras iteracin k ik = 2 ik1 = 2k t(n) O(lg n)
Ejemplo 3
x 0 Bucle "mientras" interno, anlogo al anterior:
i 1
repetir inicio j 0 = 1 = 20 Condicin FIN j>n
j 1 iteracin 1 j 1 = 21 En la ltima Iteracin jk > n
iteracin 2 j 2 = 22
mientras j n iteracin 3 j 3 = 23 2k1 n
... ... k 1 lg n k lg n + 1
hacer iteracin k j k = 2k t(i) lg n + 1 (lg n)
x x +1
j j 2 Bucle externo "repetir" equivale a bucle "para":
fin mientras
i i +1 t(n) =
Pn
t(i) =
Pn
(lg n + 1) = n(lg n + 1) (n lg n)
i=1 i=1
hasta que i > n
Eleccin de instruccin barmetro
En el caso particular de bucles anidados:

Instruccin barmetro toda instruccin que se encuentre en el bucle
ms interno
Qu sucede en el caso de bucles internos que se ejecutan pocas o
cero veces?
Instruccin que se ejecuta un mayor nmero de veces:
Una instruccin del cuerpo del bucle
La propia instruccin de comprobacin
Instruccin barmetro: la que se ejecuta un mayor nmero de veces
la propia comprobacin del bucle (en el caso de bucles internos
que se ejecuten pocas o ninguna vez)
Anlisis de Algoritmos Algoritmos Recursivos y Recurrencias
Detalles del tema
Introduccin
Bucles para (for)
6 Algoritmos Recursivos y Recurrencias

Definiciones
Se dice que un objeto es recursivo si forma parte de s mismo o se define

en funcin de s mismo
Wirth, N., Algoritmos Y Estructuras De Datos

Ed Adisson-Wesley
Un programa recursivo P puede expresarse como una composicin P

de un conjunto de proposiciones S (que no contienen a P) y el propio
P:
P P[S, P]
Directamente recursivo si P contiene una referencia explcita a s
mismo
Indirectamente recursivo si P contiene una referencia a Q, y Q
contiene (directa o indirectamente) a P
Construccin de algoritmos recursivos

Analoga con el razonamiento inductivo
Debe garantizarse que la sucesin de invocaciones rescursivas tiene fin

la llamada recursiva a un algoritmo P depende de una condicin B
que en algn momento no se satisfaga
P P[S, si B entonces P]
Su construccin no sigue una frmula concreta, pero se puede utilizar
la nocin de induccin de la siguiente forma:
Resolver el caso ms simple o caso base. Existen uno o mas casos
base, triviales o de final de recursin que resuleven el problema de
forma no recursiva
Descomponer el caso general en funcin de casos ms simples que
tiendan hacia el caso base. Conceptualmente se descompone en dos
partes:
Una parte que se sabe como resolver
Una parte que no se sabe como resolver pero que es muy parecida al
problema original aunque de menor tamao llamada recursiva o
paso de recursivdad
Esquema general de algoritmos recursivos
si caso base entonces

resolver
si no
descomponer el problema
invocacin o llamadas recursiva
resolver a partir de soluciones recursivas
fin si
Esta estructura general puede tener variaciones
Recursividad lineal si hay una nica invocacin recursiva
Recursivad mltiple si hay ms de una invocacin recursiva
Recursividad por cola si la ltima instruccin de la funcin es una
llamada recursiva
Ejemplo de algortimo recursivo

Factorial de un nmero
(
1, si n = 0
n! =
n(n 1)!, si n 1
Algoritmo 3.1 factorial(n)

Entrada: entero positivo n
Salida: factorial de n
1: si n 0 entonces
2: devolver 1
3: si no
4: devolver n factorial(n 1)
5: fin si
El tiempo de ejecucin viene dado por una ecuacin de recurrencia,

T (n) = E (n), donde en E (n) aparece la propia funcin T (). Son ms
dificiles de analizar pues es necesario obtener y resolver su ecuacin
de recurrencia
Anlisis de algortimos recursivos

Ecuaciones de Recurrencia
Una ecuacin de recurrencia, recursiva o relacin de recurrencia

es una ecuacin que describe una funcin en trminos del propio valor
de la funcin para argumentos ms cercanos a algn caso bsico, para
el que la funcin est definida explcitamente
Resolver este tipo de ecuaciones consiste en encontrar una expresin
no recursiva de T
Tcnica de expansin o desplegado: permite formular una conjetura
que, posteriormente, debe desmostrarse por induccin
Ecuaciones lineales homogneas:se resuleven aplicando el teorema
fundamental del algebra a su polinomio caracterstico. Tcnica sencilla
si las raices son todas diferentes
Ecuaciones lineales no homegeneas: encontrar su solucin resulta
complicado (Brassard, A.Vallecillo)
Ejemplo de Ecuacin de Recurrencia

Factorial
Algoritmo 3.2 factorial(n)

Salida: factorial de n
1: si n 0 entonces
2: devolver 1
3: si no
4: devolver n factorial(n 1)
5: fin si
En el caso base se ejecutan dos operaciones elementales: la condicin

del si y la asignacin (devolucin) del 1
Al caso general contribuyen cuatro operaciones elementales
(condicin del si, asignacin, producto y decremento de n 1) ms el
tiempo de ejecucin del algoritmo recursivo para el caso n 1
La recurrencia que expresa el consumo de tiempo:
(
2, si n = 0
T (n) =
4 + T (n 1), si n 1
Tcnica de expansin o desplegado

Resolviendo recurrencias
Tcnica que permite formular una conjetura que, posteriormente, se

debe demostrar por induccin
La idea consiste en:
1 Sustituir reiteradamente los trminos de la funcin por la expresin
especificada por la recurrencia
2 Deducir cuntas veces se precisa efectuar la sustitucin hasta llegar al
caso base y, as, especificar una expresin patrn que generalice todas
las sustituciones sucesivas
(
2, si n = 0
T (n) =
4 + T (n 1), si n 1
Comencemos con el despliegue
T (n) = 4 + T (n 1)
= 4 + (4 + T (n 2))
= 4 + (4 + (4 + T (n 3)))
...
= 4k + T (n k)
Siendo k el nmero de invocaciones recursivas

Se llega al caso base cuando: (n k) = 0 k = n
Sustituimos k por su valor
T (n) = 4k + T (n k)
= 4n + T (0)
= 4n + 2 O(n) por la regla del mximo
Ecuaciones lineales homogneas

Las recurrencias de la forma
a0 T (n) + a1 T (n 1) + ... + ak T (n k) = 0
donde las ai son nmeros reales y k es un nmero natural entre 1 y n

se denominan ecuaciones (recursivas) lineales homogneas:
lineales porque no hay trminos de la forma T (n i)m
homogneas porque la combinacin lineal es igual a cero
Se resuelven obteniendo su ecuacin caracterstica mediante el
cambio x n = T (n),
a0 x n + a1 x n1 + ... + ak x nk = 0
Eliminando la solucin x = 0
a0 x k + a1 x k1 + ... + ak = 0
obtenemos el polinomio caraterstico
p(x ) = a0 x k + a1 x k1 + ... + ak
Ecuaciones lineales homogneas

El teorema fundamental del lgebra afirma que todo polinomio p(x )

de grado k posee exactamente k races (no necesariamente distintas),
lo que implica que se puede factorizar como un producto:
k
Y
p(x ) = (x ri )
i=1
Suponemos que todas las races son distintas, es decir, ri 6= rj si i 6= j
Puesto que p(ri ) = 0, x = ri es una solucin de la ecuacin
caracterstica rin es una solucin de la recurrencia
Dado que toda combinacin lineal de soluciones es tambin una
solucin, entonces:
k
X
T (n) = c1 r1n + c2 r2n + ... + ck rkn = ci rin
i=0
donde los coeficientes ci se determinan a partir de los casos base
Ejemplo ecuaciones lineales homogneas

Clculo del trmino n-simo de la sucesin de Fibonacci
Mtodo general: Fn = Fn1 + Fn2

Casos base: F0 = 0 y F1 = 1
Definicin expresada en trminos recursivos:

0, si n = 0
Fn = 1, si n = 1
Fn1 + Fn2 , si n 2

Algoritmo 3.3 fibonacciRecursivo(n)

Salida: trmino n-simo de la sucesin de Fibonacci
1: si n 0 entonces
2: devolver 0
3: si no, si n = 1 entonces
4: devolver 1
5: si no
6: devolver fibonacciRecursivo(n 1) + fibonacciRecursivo(n 2)
7: fin si
La ecuacin de recurrencia que expresa el consumo de tiempo

0, si n = 0
T (n) = 1, si n = 1
T (n 1) + T (n 2), si n 2

Solucin de ecuaciones lineales homogneas

Ejemplo Sucesin de Fibonacci
Del caso general T (n) = T (n 1) + T (n 2), obtenemos la

ecuacin lineal homognea
T (n) T (n 1) T (n 2) = 0
con coeficientes a0 = 1 y a1 = a2 = 1
Mediante el cambio x n = T (n) la ecuacin caracterstica
x n x n1 x n2 = 0 x n2 (x 2 x 1) = 0
Eliminando la solucin x = 0 el polinomio caracterstico
x2 x 1 = 0
Las races de esta ecuacin son:

1+ 5 1 5
r1 = , r2 =
2 2
Por tanto r1n , r2n y cualquier combinacin lienal son soluciones de la
ecuacin de recurrencia
La solucin general a la ecuacin puede expresarse:
T (n) = c1 r1n + c2 r2n
Solucin de ecuaciones lineales homogneas
Los valores de c1 y c2 y se obtienen a partir de los casos base

)
T (0) = c1 r10 + c2 r20 = 0
T (1) = c1 r11 + c2 r21 = 1
Sustituyendo los valores de las races y resolviendo

!0 !0
1+ 5 1 5
c1 + c2 = c1 + c2 = 0

2 2 1
!1 !1 c1 = c2 =
1+ 5 1 5
5
c1 + c2 = 1

2 2

Sustituyendo en la solucin general resolvemos la recurrencia y

obtenemos el orden del algoritmo recursivo de Fibonacci
(exponencial!)
!n !n
1 1+ 5 1 1 5
T (n) = O(n )
5 2 5 2
Anlisis de Algoritmos Recursividad frente a Iteracin
Detalles del tema
Introduccin
Bucles para (for)
7 Recursividad frente a Iteracin
El poder de la recursividad radica en la posibilidad de definir un

conjunto infinito de objetos mediante una proposicin finita, sin
necesidad de repeticiones explcitas
Es una alternativa elegante a la utilizacin de la iteracin (bucles):
las recurrencias plantean una relacin entre un objeto e instancias
ms sencillas del mismo objeto
Los algoritmos recursivos son convenientes cuando el problema a
resolver o los datos que deben manipularse estn definidos en
trminos recursivos
Sin embargo, incluso en estos casos, la versin recursiva no es,
necesariamente, la mejor opcin. Debe tenerse en cuenta:
La pila del programa
El rbol de recusividad
El orden de la versin recursiva frente a la iterativa
Pila del programa

Cada vez que se activa una llamada recursiva se alamacena en la pila
del programa:
El estado actual de ejecucin, necesario para que se pueda recuperar
dicho estado cuando finalice la nueva invocacin que se va a realizar
Todos los objetos locales de la funcin: variables locales y parmetros
formales. Su nombre es el mismo que en la llamada anterior, sus
valores son especficos de la llamada y se distinguen por ser los de
creacin ms reciente
Puede dar lugar a un desbordamiento de pila (preferencia de paso por
referencia frente a paso por valor)
Una vez finalizada la ejecucin de una invocacin recursiva, se libera
el espacio reservado en pila, se recuperan de la pila las variables
locales y los parmetros antiguos y la ejecucin se reanuda
Factorial de un nmero versin recursiva

Pila del programa y rbol de recursividad
El grfico anterior reprensenta el rbol de recursividad

Cada nodo (caja) representa el estado para una invocacin a la funcin
Cada rama representa la realizacin de una invocacin a la funcin
Al leer el rbol en direccin ascendente y no en direccin descendente,
se obtiene el programa iterativo partiendo del recursivo
Versin iterativa versus recursiva de factorial(n)

Anlisis de algoritmos
Iterativo

resultado 1

Pn
t(n) i=2 1 (n)
resultado resultado i

fin para

devolver resultado
Recursivo

si n 0 entonces

devolver 1

t(n) 4n + 2 (n)
si no

devolver n factorial(n 1)

fin si
Sucesin de Fibonacci versin recursiva

rbol de recursividad para calcular quinto trmino
Se observa que, por cada nodo, hay dos nuevas ramas

el recorrido del rbol (se desciende ) se realiza por las ramas
izquierdas del mismo
cuando se alcanza el nodo hoja o final, se vuelve al nodo padre y, si
existe rama derecha, repite el proceso de bajada por dicha rama
Si nos fijamos en lo que se hace en cada una de las dos ramas:
En la rama de la derecha, para calcular F3 , se realizan clculos que se
haban realizado en la rama izquierda al calcular F4 , y se han olvidado
Todo el subrbol de la izquierda, a partir de F3 aparece replicado en la
rama derecha
Para obtener la versin iterativa:
Se utilizan dos variables, a, b, que almacenarn clculos intermedios
para evitar repeticiones
Se lee el rbol en direccin ascendente, estableciendo valores iniciales
de a y b los respectivos casos base (nodos hoja o finales del rbol)
Versin iterativa frente a recursiva de Fibonacci(n)

Anlisis de algortimos
Iterativo
a0
b1
c a+b

ab
Pn
t(n) c (n)
bc i=2
fin para

devolver c

Recursivo
si n 0 entonces
devolver 0
si no, si n = 1 entonces

devolver 1
si no t(n) O(n )
devolver fibonacciRecursivo(n 1) + fibonacciRecursivo(n 2)
fin si

Comportamiento LINEAL frente a EXPONENCIAL!!!!
Observaciones
Iteracin
Aportada a bajo nivel (instrucciones en cdigo mquina) por el propio
funcionamiento del ordenador. Secuencia de instrucciones que se
repiten atendiendo a un determinado criterio
En general es ms eficiente en trminos de tiempo de ejecucin y
memoria utilizada que la solucin recursiva
Para determinados problemas puede ser difcil encontrar la solucin
iterativa
Recursividad
Las definiciones recursivas y las demostraciones por induccin,
estrechamente relacionadas, existen desde antes de los ordenadores
En muchos casos es el mtodo ms natural y elegante de describir
funciones y tipos de datos
Menos eficiente que la solucin iterativa
Siempre se puede simular utilizando una pila
Generalmente, si la versin iterativa del algoritmo tiene una forma
simple, ser la opcin preferible
Anlisis del rbol de recursividad

Otros criterios a tener en cuenta
Si el rbol presenta una nica rama versin iterativa

Si el rbol de recursividad presenta muchas ramas pero repite
operaciones versin iterativa
Si el rbol de recursividad presenta muchas ramas sin repetir
operaciones y es poco profundo versin recursiva
Ejemplos de uso inadecuado de la recursividad:
Clculo del factorial: recursividad lineal al comienzo o al final de la
funcin
Clculo del trmino n-simo de la sucesin de Fibonacci: recursividad
mltiple con invocaciones repetidas
Ejemplos de uso adecuado de la recursividad que vamos a estudiar:
El problema de las torres de Hanoi
Algoritmo de ordenacin QuickSort
Contenidos
2 Notacin asinttica

Tema 4. Algoritmos de bsqueda y ordenacin
Contenidos
Introduccin
Algoritmos de bsqueda
Bsqueda secuencial
Bsqueda binaria
Algoritmos de ordenacin
Burbuja
Seleccin
Insercin
QuickSort
MergeSort
Distribucin
Algoritmos de bsqueda y ordenacin Introduccin
Detalles del tema

Introduccin
Bsqueda secuencial
Bsqueda binaria
Burbuja
Seleccin
Insercin
QuickSort
MergeSort
Distribucin
Algoritmos de bsqueda y ordenacin Introduccin
1 Introduccin
Como se indic en la introduccin de la asignatura, resulta muy til

tener un conocimiento extenso de algoritmos que permiten resolver
problemas ejemplo, de los menos eficientes a los ms eficientes
La bsqueda y la ordenacin son dos problemas sencillos de resolver
en programacin, para los que existen varias alternativas
El objetivo de este tema es comprender y analizar la evolucin de
estos algoritmos:
Operaciones fundamentales
Cambios de estrategia
Mejora en el rendimiento, ...
No hay que aprenderlos de memoria sino analizar su evolucin!
Algoritmos de bsqueda y ordenacin Algoritmos de bsqueda
Detalles del tema

Introduccin
Bsqueda secuencial
Bsqueda binaria
Burbuja
Seleccin
Insercin
QuickSort
MergeSort
Distribucin
2 Algoritmos de BSQUEDA
Enunciado del problema
Problema a resolver
Bsqueda en un conjunto de datos de un elemento especfico y la
recuperacin de alguna informacin asociada al mismo
Suposiciones que facilitan el anlisis, aunque no necesariamente se

contemplen en la implementacin de las soluciones
Todos los elementos son diferentes
El conjunto de datos donde se realiza la bsqueda est almacenado en
una lista
El valor buscado se encuentra en el la lista y el algoritmo devolver su
posicin en la misma
Normalmente las implementaciones de estos algoritmos contemplan el
caso en que la lista no contiene el elemento buscado
2.1 Bsqueda Secuencial

Dos soluciones
Recorrido de la lista desde el primer elemento al ltimo, de uno en uno:
Algoritmo 4.1 bsquedaSecuencial(T [1..n], valor )

Entrada: vector T [1..n], valor buscado valor
Salida: posicin de valor en T [1..n]
1: posici on 0
2: para i 1 hasta n hacer
3: si T [i] = valor entonces
4: posici on i
5: fin si
6: fin para
7: devolver posici on
Claramente requiere un tiempo en (n) siendo n el tamao de la lista.

Una versin un poco ms ptima:
Algoritmo 4.2 bsquedaSecuencial(T [1..n], valor )
Entrada: vector T [1..n], valor buscado valor

2: si T [i] = valor entonces
3: devolver i
4: fin si
5: fin para
6: devolver 0
Claramente requiere un tiempo en (r ) siendo r el ndice que se devuelve,

supuesto que el elemento est en la lista. Hay que analizar los casos
mejor, peor y medio
Anlisis de la bsqueda secuencial

Versin 4.2
Caso mejor est en O(1)

Caso peor est en O(n)
Caso medio:
A priori no se sabe cul es la posicin del elemento buscado y, por
tanto, el nmero de iteraciones que dar el bucle
nicamente se puede calcular el promedio de iteraciones que dar dicho
bucle
Suponemos que todas las posiciones son igualmente probables para el
elemento buscado
El promedio de iteraciones, considerando las n posibles posiciones, es:
Pn
1 + 2 + 3 + ... + n i n+1
= i=1 = O(n)
n n 2
Por lo que, tanto en el caso peor como en el caso medio, est en (n)
2.2 Bsqueda binaria o dicotmica

Idea bsica del algoritmo
Similar a la bsqueda en un diccionario o en una gua telefnica la

lista de valores debe estar ordenada
Se toma el elemento central de la lista y se compara con el valor
buscado. Si no se trata del elemento buscado se repite el proceso en
la sublista adecuada
Suponiendo orden creciente, T [i] T [j] con 1 i j n, tres
posibilidades
Que coincidan valor buscado y elemento central de la lista, entonces
termina el proceso de bsqueda devolviendo su posicin
Que el elemento central sea un valor mayor que el buscado, entonces el
valor buscado se debe encontrar en la sublista izquierda. Se repite este
proceso con dicha sublista
Que el elemento central sea un valor menor que el buscado, entonces el
valor buscado se debe encontrar en la sublista derecha. Se repite este
proceso con dicha sublista
Bsqueda binaria o dicotmica

Ejemplo del algoritmo
Bsqueda del valor 23 en la siguiente lista
2 5 7 9 13 14 23 34 56 67 Valor ><= T [k]

i k j Valor > T [k]
i k j Valor < T [k]
i,k j Valor > T [k]
i, j i = j : parada
Divide y vencers
La solucin de todo caso suficientemente grande se reduce a un caso ms
pequeo, en este caso de tamao la mitad
(Tema 5. Esquemas Algortmicos)
Bsqueda binaria o dicotmica

Versin iterativa de la bsqueda binaria
Algoritmo 4.3 bsquedaBinaria(T [1..n], valor )
Entrada: vector T [1..n] ordenado orden creciente, valor buscado valor

1: i 1
2: j n
3: mientras i < j hacer
4: k (i + j) 2
5: si valor < T [k] entonces
6: j k 1
7: si no, si valor > T [k] entonces
8: i k +1
9: si no, si valor = T [k] entonces
10: i k, j k
11: fin si
12: fin mientras
13: si valor = T [i] entonces
14: devolver i
15: si no
16: devolver 0
17: fin si
Anlisis
Para averiguar el nmero de iteraciones del bucle "mientras" se

considera la siguiente funcin decreciente de las variables que
intervienen en el bucle:
d =j i +1
Esta funcin representa el nmero de elementos que quedan por
examinar en la lista o vector T
Suponiendo que x s existe en el vector T , estudiamos la evolucin
de la funcin:
En el inicio del bucle: d = n
El bucle concluye: i j d 1
Para cada iteracin del bucle hay tres posibilidades:
j k 1, cuando x < T [k]
i k + 1, cuando x > T [k]
i k, j k, cuando x = T [k]
Sean:
d valor de j i + 1 antes de la iteracin considerada
d valor de j i + 1 despus de la iteracin considerada
i, j, iy j definidos de forma similar
Calculamos el valor de la funcin d despus cada iteracin del bucle y
para cada uno de los tres casos que se pueden dar:
( )
i = i d
Si x<T[k] j k 1 d
j = [(i + j) 2 1] 2
d = j i + 1 = [(i + j) 2 1] i + 1 = [(i + j) 2] i
i +j i + j 2i j i j i +1 d
i = = < =
2 2 2 2 2
( )
i = [(i + j) 2 + 1] d
Si x>T[k] i k + 1 d
j = j 2
Se demuestra de forma anloga al caso anterior

d
Si x=T[k] i, j k d = 1, pero como d era al menos 2 d
2
Evolucin de la funcin d = j i + 1
d

d
suceda lo que suceda
Conclusin: 2
d = n antes de la primera iteracin

d 1 despus de la ltima iteracin
Evolucin de la funcin d con la ejecucin del bucle:

inicio d0 =n = 2n0 Condicin FIN dk 1
d0
iteracin 1 d1 2 = 2n1 En la ltima iteracin dk 1
iteracin 2 d2 d21 2n2
n
... ... 2 k1 >1
iteracin k-1 dk1 dk2
2 n
2k1
n > 2 k1
k < lg n + 1
iteracin k dk dk1
2 n
2k
t(n) < lg n + 1 O(lg n)
Si cada iteracin necesita un tiempo constante la bsqueda binaria

necesita un tiempo en O(lg n)
Un razonamiento anlogo cota inferior en (lg n) en el caso peor
Por tanto la bsqueda binaria iterativa necesita un tiempo en (lg n)
Versin recursiva de la bsqueda binaria

Algoritmo 4.4 bsquedaBinariaRecursiva(T [i..j], valor )
Entrada: vector T [i..j] ordenado orden creciente, valor buscado valor

Salida: posicin de valor en T [i..j]
1: si i > j entonces
2: devolver 0
3: si no
4: k (i + j) 2
6: j k 1
8: i k +1
10: devolver k
11: fin si
12: devolver busquedaBinariaRecursiva(T [i..j], valor )
13: fin si
Invocacin de la funcin
posici on busquedaBinariaRecursiva(T [1..n], unValor )
Ecuacin de recurrencia que expresa el consumo de tiempo, suponiendo
que el valor buscado s est en la lista
(
a, si n = 1
T (n) =
T (n /2 ) + b, si n > 1
Anlisis
Ecuacin de recurrencia que expresa el consumo de tiempo
(
a, si n = 1
T (n) =
T (n /2 ) + b, si n > 1
Aplicamos la tcnica de expansin o despleguado:
T (n) = T ( n2 ) + b
= (T ( 2n2 ) + b) + b = T ( 2n2 ) + 2b
= (T ( 2n3 ) + b) + 2b = T ( 2n3 ) + 3b
...
= T ( 2nk ) + kb

Se llega al caso base cuando:
n
= 1 2k = n k = lg n
2k
Sustituimos k por su valor
T (n) = T ( 2nk ) + kb
= T (1) + b lg n
= a + b lg n O(lg n) por la regla del mximo
Faltara demostrar por induccin que la conjetura encontrada es cierta

Secuencial versus Binaria
Hemos analizado varios algoritmos de bsqueda

Bsqueda Secuencial en (n)
Bsqueda Binaria en (lg n), tanto en su versin recursiva como
iterativa
Algoritmos de bsqueda y ordenacin Algoritmos de ordenacin
Detalles del tema

Introduccin
Bsqueda secuencial
Bsqueda binaria
Burbuja
Seleccin
Insercin
QuickSort
MergeSort
Distribucin
3 Algoritmos de ORDENACIN
Problema a resolver
Ordenacin de un conjunto, vector o lista de datos de un determinado
tipo, simple o estructurado
O ms formalmente:
Problema a resolver
Dado un conjunto de n elementos a1 , a2 , ..., an y una relacin de orden
total () sobre ellos, el problema de la ordenacin consiste en encontrar
una permutacin de esos elementos ordenada de forma creciente
El problema de la ordenacin
Algunas consideraciones
Al igual que en la bsqueda, para facilitar el anlisis y/o la

implementacin haremos unas suposiciones:
Todos los elementos son nmeros enteros y no hay valores repetidos
Con objeto de facilitar tambin las implementaciones supondremos que
el conjunto de datos donde se realiza la bsqueda est almacenado en
un vector
Aunque existen distintos criterios para clasificar los algoritmos de
ordenacin, uno de los ms intuitivos es la eficiencia de los mismos.
Atendiendo a un orden creciente de complejidad algoritmica (consumo
de tiempo) en el caso medio, vamos a estudiar los siguientes
algoritmos:
(n2 ): Burbuja, seleccin, insercin
(n lg n): QuickSort, fusin (o merge sort)
(n): Ordenacin por distribucin, Radix Sort
3.1 Algortimo de Intercambio Directo o "Burbuja"

Idea bsica
Se basa en comparar pares de elementos adyacentes e intercambiarlos

entre s hasta que todos se encuentren ordenados
Puede trabajar de dos formas diferentes, llevando los elementos ms
pequeos hacia la parte superior de la lista o llevando los elementos
ms grandes hacia la parte inferior de la misma
Ser neceario revisar los elementos (n 1) veces colocando cada vez
el elemento menor (o mayor) en su posicin correcta
Los elementos ms pequeos/grandes de la lista "burbujean" hacia la
parte superior/inferior de la misma
En cada paso se tienen dos listas:
una lista ordenada (inicialmente vaca)
una lista desordenada (inicialmente completa)
al final todos los elementos estn en la lista ordenada y la lista
desordenada estar vaca
Ejemplo
1a iteracin b. externo: i = 1 (b. interno j varia de n 1 a 1)
i 1 23 1 23 1 23 j 1 23 1 7
2 12 2 12 j 2 12 j +1 2 7 2 23
3 42 j 3 42 j +1 3 7 3 12 3 12
j 4 7 j +1 4 7 4 42 4 42 4 42
j +1 5 15 5 15 5 15 5 15 5 15
2a iteracin b. externo: i = 2 (b. interno j vara de n 1 a 2)
1 7 1 7 1 7 1 7
i 2 23 2 23 j 2 23 2 12
3 12 j 3 12 j +1 3 12 3 23
j 4 42 j +1 4 15 4 15 4 15
j +1 5 15 5 42 5 42 5 42
1 7 1 7 1 7
2 12 2 12 2 12
i 3 23 j 3 23 3 15
j 4 15 j +1 4 15 4 23
j +1 5 42 5 42 5 42
1 7 1 7
2 12 2 12
3 15 3 15
i, j 4 23 4 23
j +1 5 42 5 42
Algoritmo y Anlisis
Se necesitan dos bucles:
Uno externo que indica la posicin hasta la que se realiza el intercambio (i
vara de 1 a (n 1))
Otro interno que va intercambiando ("burbujeando") el elemento ms
pequeo, entre los elementos desordenados, para situarlo en la posicin
adecuada de intercambio (j vara desde (n 1) hasta i)
Anlisis
Algoritmo 4.5 ordenacinBurbuja(T [1..n])

n1 n1 n1 n1
Entrada: vector T [1..n]
X X X X
t(n) = c =c 1
Salida: vector T [1..n] ordenado orden creciente
1: para i 1 hasta n 1 hacer i=1 j=i i=1 j=i
2: para j (n 1) hasta i incremento = -1 hacer
3: si T [j] > T [j + 1] entonces n1 n1
X X
4: temp T [j]
=c ((n 1) i + 1) = c (n i)
5: T [j] T [j + 1]
6: T [j + 1] x i=1 i=1
7: fin si
8: fin para = c((n 1) + (n 2) + ... + 2 + 1)
9: fin para (n 1) + 1 n(n 1) 2
=c (n 1) = c (n )
2 2
3.2 Algoritmo de Seleccin

Idea bsica
De nuevo se juega con dos listas:

una lista ordenada (inicialmente vaca)
una lista desordenada (inicialmente completa con los n elementos a
ordenar)
Se basa en localizar ("seleccionar") el elemento ms pequeo entre los
desordenados y colocarlo en la posicin correcta de los ordenados
Se elimina el "burbujeo" pues solo se hace el intercambio del
elemento seleccionado
Ser neceario revisar la lista desordenada (n 1) veces, para
seleccionar el valor ms pequeo en cada una de ellas y colocarlo al
final de la lista ordenada
Ejemplo
1a iteracin b. externo: i = 1 (b. interno j vara de 2 a n)
i 1 23 1 23 1 23 1 23 1 7
j 2 12 2 12 2 12 2 12 2 12
3 42 j 3 42 3 42 3 42 3 42
4 7 4 7 j 4 7 4 7 4 23
5 15 5 15 5 15 j 5 15 5 15
1 7 1 7 1 7 1 7
i 2 12 2 12 2 12 2 12
j 3 42 3 42 3 42 3 42
4 23 j 4 23 4 23 4 23
5 15 5 15 j 5 15 5 15
1 7 1 7 1 7
2 12 2 12 2 12
i 3 42 3 42 3 15
j 4 23 4 23 4 23
5 15 j 5 15 5 42
4a iteracion b. externo: i = 4 (b. interno j vara de 5 a n)
1 7 1 7
2 12 2 12
3 15 3 15
i 4 23 4 23
j 5 42 5 42
Algoritmo y Anlisis
Uno externo que indica la posicin de intercambio del elemento seleccionado (i vara de 1 a (n 1))
Otro interno que busca ("selecciona") el elemento ms pequeo entre los elementos desordenados para situarlo en la
posicin adecuada de intercambio (j vara desde i + 1 hasta n)
Anlisis exhaustivo
n1 n n1
X X X
t(n) = [b + c] = [b + (n (i + 1) + 1)c]
Algoritmo 4.6 ordenacinSeleccin(T [1..n]) i=1 j=i+1 i=1
n1 n1 n1
Entrada: vector T [1..n] X X X
Salida: vector T [1..n] ordenado orden creciente = [b + (n i)c] = b+ (n i)c
1: para i 1 hasta n 1 hacer
2: posSelecci on i i=1 i=1 i=1
3: valorSelecci on T [i] n(n 1)
4: para j (i + 1) hasta n hacer = b(n 1) + c
5: si T [j] < valorSelecci on entonces 2
6: posSelecci on j 1 2 1 2
= cn + (b c)n b (n )
7: valorSelecci on T [j] 2 2
8: fin si
9: fin para
10: T [posSelecci on] T [i] Anlisis utilizando instruccin baromtro: (T [j] < valorSelecci on)
11: T [i] valorSelecci on
12: fin para
n1 n n1
n(n 1)
X X X
2
t(n) = 1= (n i) = (n )
2
i=1 j=i+1 i=1
3.3 Algoritmo de Insercin

Idea bsica
De nuevo se juega con dos listas:

una lista ordenada (inicialmente formada con un elemento)
una lista desordenada (con los n 1 elementos que quedan por ordenar)
Se basa en colocar ("insertar") el primer elemento de la lista
desordenada, en el lugar que le corresponde de la lista ordenada que
se va formando
Hay que buscar la posicin de insercin en una lista ordenada y hacer
"hueco" en la lista para insertar el elemento (desplazamiento de
elementos en la lista)
Ejemplo
1a iteracin b. externo: i = 2 (b. interno j vara de 1 a 0; x = 12)
j 1 23 j +1 1 23 j +1 1 12
i, j + 1 2 12 2 23 2 23
3 42 3 42 3 42
4 7 4 7 4 7
5 15 5 15 5 15
2a iteracin b. externo: i = 3 (b. interno j = 2 no vara; x = 42)

1 12 1 12
j 2 23 2 23
i, j + 1 3 42 j +1 3 42
4 7 4 7
5 15 5 15
3a iteracin b. externo: i = 4 (b. interno j vara de 3 a 0;x = 7)
1 12 1 12 j 1 12 j +1 1 12 j +1 1 7
2 23 j 2 23 j +1 2 23 2 12 2 12
j 3 42 j +1 3 42 3 23 3 23 3 23
i, j + 1 4 7 4 42 4 42 4 42 4 42
5 15 5 15 5 15 5 15 5 15
4a iteracin b. externo: i = 5 (b. interno j vara de 4 a 2;x = 15)
1 7 1 7 1 7 1 7
2 12 2 12 j 2 12 j 2 12
3 23 j 3 23 j +1 3 23 j +1 3 15
j 4 42 j +1 4 42 4 23 4 23
i, j + 1 5 15 5 42 5 42 5 42
Algoritmo y Anlisis
Uno externo que indica el elemento de la lista desordenada que debe
insertarse en la lista ordenada (i vara de 2 a n)
Otro interno que busca la posicin de la lista ordenada donde debe
insertarse el elemento(cmo vara j? Depende del conjunto original!!!)
El tiempo de ejecucin depende del orden original de los elementos
Caso peor: j vara desde i 1 hasta 1
Caso mejor: j no vara (no entra en bucle!!!)
Caso medio: requiere suponer a priori una distribucin
Instruccin barmetro: condicin del bucle "mientras" (el cuerpo del bucle puede
que no se ejecute nunca!!!!)
Instruccin barmetro de orden constante((1))
Algoritmo 4.7 ordenacinInsercin(T [1..n])

1: para i 2 to n hacer
2: x T [i]
3: j i 1
4: mientras j > 0 and T [j] > x hacer
5: T [j + 1] T [j]
6: j j 1
7: fin mientras
8: T [j + 1] x
9: fin para
Anlisis CASO PEOR

42
23
Lista inicialmente clasificada en orden decreciente 15
12
7
El cuerpo del bucle mientras se ejecuta "i" veces:
T [j] > x j|1 j i 1
ordenacinInsercin(T [1..n])
Evolucin variable j que controla el bucle "mientras" (' "para")
Salida: vector T [1..n] ordenado orden creciente iteracin 1 j1 = i 1 Condicin FIN j 0
1: para i 2 to n hacer iteracin 2 j2 = i 2 jk = 0
2: x T [i] iteracin 3 j3 = i 3 i k =0
3: j i 1 ... ...
4: mientras j > 0 and T [j] > x hacer iteracin k jk = i k k = i nmero iteraciones
5: T [j + 1] T [j]
6: j j1 t(i) = i
7: fin mientras
8: T [j + 1] x
9: fin para
La instruccin barmetro bucle interno se ejecuta "i" veces por cada iteracin del bucle externo
n n
2+n n2 + n 2
X X
2
t(n) = ct(i) = c i = (n 1)c = (n )
2 2
i=2 i=2
Anlisis CASO MEJOR

Lista inicialmente clasificada en orden creciente
El cuerpo del bucle mientras se ejecuta 0 veces:
T [j] x j|1 j i 1
La instruccin barmetro del bucle interno se ejecuta "1" vez por cada iteracin
del bucle externo (t(i) = 1)
n n
X X
t(n) = ct(i) = c 1 = c(n 1) (n)
i=2 i=2
ordenacinInsercin(T [1..n])
Una iteracin cualquiera !!
1: para i 2 to n hacer 1 7
2: x T [i] 2 12
3: j i 1 j 3 15
4: mientras j > 0 and T [j] > x hacer i 4 23
5: T [j + 1] T [j] 5 42
6: j j1
7: fin mientras
8: T [j + 1] x
9: fin para
Anlisis CASO MEDIO
Requiere suponer a priori una distribucin de probabilidad para los casos de

ejecucin del algoritmo
El resultado del anlisis puede se errneo si no hay correspondencia entre la
suposicin y la realidad
El anlisis del algoritmo requiere razonar probabilsticamente a medida que
se avanza
En una iteracin "i" cualquiera del algoritmo tenemos:
ordenacinInsercin(T [1..n]) Rango parcial de T [i]: posicin k del valor T [i] en T [1..i] si
estuviera ordenado
Entrada: vector T [1..n] k determina las veces que se ejecuta la instruccin barmetro!!
Salida: vector T [1..n] ordenado orden creciente 1 k = 1 i veces
1: para i 2 to n hacer 2 k = 2 i 1 veces
2: x T [i] ... ... ...
3: j i 1 k k = k i k + 1 veces
4: mientras j > 0 and T [j] > x hacer ... ... ...
5: T [j + 1] T [j] i 1 k = i 1 2 veces
6: j j1 i k = i 1 vez
7: fin mientras ... ...
8: T [j + 1] x n
9: fin para
Anlisis CASO MEDIO

Si todas las posiciones posibles de k son igualmente probables, cada
valor de k entre 1 e i tiene una probabilidad de ocurrir de 1i
El nmero medio de veces que se ejecuta la instruccin barmetro
del bucle interno "mientras" es
i
1X 1i +1 i +1
t(i) = (i k + 1) = i=
i k=1 i 2 2
Para ordenar n elementos, el nmero total de veces que se ejecuta la
instruccin barmetro ser (bucle externo)
n n
X X i +1 1
t(n) = t(i) = = (3 + 4 + 5 + ... + (n + 1))
i=2 i=2
2 2
13+n+1 n2 + 3n 4
t(n) = (n 1) = (n2 )
2 2 4
En el caso medio hace, aproximadamente, la mitad de comparaciones
que en el caso peor
Observaciones
El algoritmo de insercin tiene un comportamiento natural:

Comportamiento lineal (el mejor) cuando el trabajo ya est hecho
(vector ordenado)
Comportamiento cuadrtico (peor) cuando el trabajo se debe realizar
(vector desordenado u ordenado en orden decreciente)
El bucle interno busca una posicin en una lista ordenada: se puede
sustituir la bsqueda secuencial por una bsqueda binaria!!!!
Algoritmo de INSERCIN BINARIA
Se propone como ejercicio escribir el pseudocdigo y realizar el
anlisis Supone realmente una mejora?
Otra mejora es el algoritmo de ordenacin por incrementos o
ShellSort que consiste en dividir el vector inicial en subvectores y
ordenar por insercin cada uno de estos subvectores
Algoritmo de ordenacin por incrementos o ShellSort

Seudocdigo
Algoritmo 4.8 shellSort(T [1..n])
Entrada: vector T [1..n], vector de incrementos inc[1..numIncrementos]

1: para k numIncrementos hasta 1 con incremento = 1 hacer
2: h inc[k]
3: para i h + 1 hasta n hacer
4: x T [i]
5: j i h
6: mientras j > 0 Y T [j] > x hacer
7: T [j + h] T [j]
8: j j h
9: fin mientras
10: T [j + h] x
11: fin para
12: fin para
Importante: inc[1..numIncrementos]) es una lista con los incrementos

crecientes. Obsrvese que para k = 1, h = inc[1] = 1, estamos en el
algoritmo de insercin
3.4 Algoritmo de ordenacin rpida o QuickSort

Idea bsica
Se basa en la tcnica "divide y vencers" sustituyendo el problema

inicial (ordenar una lista) en dos problemas ms sencillos de resolver
(ordenar dos listas ms pequeas)
Tcnica:
Escoger un elemento cualquiera de la lista, denominado pivote
Recolocar todos los elementos, incluido el pivote, de forma que todos
los valores a su izquierda son menores y todos los valores a su derecha
mayores
De esta forma el pivote queda colocado en su posicin definitiva
Se generan dos sublistas (derecha e izquierda del pivote) ms pequeas
que hay que ordenar
Se aplica la misma tcnica a las sublistas (recursividad) hasta que
tengan un solo elemento(caso base)
Algoritmo 4.9 quickSort(T [base . . . tope])
1: si base < tope entonces

2: iP colocar (T [base . . . tope])
3: quickSort(T [base . . . P 1])
4: quickSort(T [iP + 1 . . . tope])
5: fin si
Ejemplo: Invocaciones RECURSIVAS

Pivote el primer elemento de la lista
Ejemplo: Invocacin y Primeras llamadas RECURSIVAS

base tope

1 2 3 4 5 6 7 8 9 10 11 12
7 19 24 13 31 8 82 18 44 63 5 29

pivote
Primera invocacin: quickSort(T[1..12])

iP colocar (T [1 . . . 12]) sita pivote en posicin(devuelve 2)!!
base < tope quickSort(T [1 . . . 1]) 1a llamada rec.
quickSort(T [3 . . . 12]) 2a llamada rec.
base tope

1 2 3 4 5 6 7 8 9 10 11 12
5 7 24 13 31 8 82 18 44 63 19 29

iP 1 iP iP + 1
Traza de las sucesivas invocaciones (y vueltas!!!) recursivas
quickSort(T [base . . . tope])

2: iP colocar (T [base . . . tope])
3: quickSort(T [base . . . P 1])
4: quickSort(T [iP + 1 . . . tope])
5: fin si
Ejemplo
iP colocar (T [1, 12]) = 2

qSort(T [1, 1])

iP colocar (T [3, 12]) = 7
iP colocar (T [3, 6]) = 6



qSort(T [3, 2])

qSort(T [3, 6]) qSort(T [3, 5]) qSort(T [3, 4])
qSort(T [1, 12)
qSort(T [4, 4])
qSort(T [3, 12])

qSort(T [6, 5])

qSort(T [7, 6])

iP colocar (T [8, 12]) = 9

qSort(T [8, 8])

qSort(T [8, 12]) iP colocar (T [10, 11]) = 9

qSort(T [10, 12]) qSort(T [10, 10])
qSort(T [12, 12])
Ejemplo alg.colocar en 3a invocacin: colocar(T[3..12])

inicio 1a ite. i = 4 2a ite. i = 5 3a ite. i = 6 4a ite. i = 7
base, iP 3 24 base 3 24 base 3 24 base 3 24 base 3 24
i 4 13 i, iP 4 13 iP 4 13 4 13 4 13
5 31 5 31 i 5 31 iP 5 8 iP 5 8
6 8 6 8 6 8 i 6 31 6 31
7 82 7 82 7 82 7 82 i 7 82
8 18 8 18 8 18 8 18 8 18
9 44 9 44 9 44 9 44 9 44
10 63 10 63 10 63 10 63 10 63
11 19 11 19 11 19 11 19 11 19
tope 12 29 tope 12 29 tope 12 29 tope 12 29 tope 12 29
5a ite. i = 8 6a ite. i = 9 7a ite. i = 10 8a ite. i = 11 9a ite. i = 12 Fuera bucle
base 3 24 base 3 24 base 3 24 base 3 24 base 3 24 base 3 19
4 13 4 13 4 13 4 13 4 13 4 13
5 8 5 8 5 8 5 8 5 8 5 8
iP 6 18 iP 6 18 iP 6 18 6 18 6 18 6 18
7 82 7 82 7 82 iP 7 19 iP 7 19 iP 7 24
i 8 31 8 31 8 31 8 31 8 31 8 31
9 44 i 9 44 9 44 9 44 9 44 9 44
10 63 10 63 i 10 63 10 63 10 63 10 63
11 19 11 19 11 19 i 11 82 11 82 11 82
tope 12 29 tope 12 29 tope 12 29 tope 12 29 tope, i 12 29 tope, i 12 29
si T [i] < pivote entonces

iP++
intercambiar(T[iP],T[i])
fin si
Algoritmo COLOCAR
1 Escoger elemeno base como pivote
2 Buscar posicin definitiva avanzando e intercambiando elementos cada vez que se
encuentra uno menor que el pivote
3 Colocar pivote y devolver posicin
Es necesario un bucle para que busque la posicin del pivote y efecte los intercambios
necesarios (i vara de base + 1 hasta tope)
Algoritmo 4.10 colocar(T [base . . . tope])

1: iP base
2: pivote T [base]
3: para i (base + 1) to tope hacer
4: si T [i] < pivote entonces
5: iP iP + 1
6: intercambiar (T [iP], T [i])
7: fin si
8: fin para
9: intercambiar (T [base], T [iP])
10: devolver iP
Colocar es de orden lineal respecto al tamao de la lista o vector que inspecciona

Colocar recibe una lista de n-elementos, realiza n 1 iteraciones (n)
Anlisis
QuickSort es ineficiente si de forma sistemtica, en la mayora de las

llamadas recursivas, los subcasos estn fuertemente desequilibrados
Caso PEOR cuando el vector original ya est ordenado: el valor
elegido como pivote es el ms pequeo de la sublista (ya est
colocado!). Cada vez que se invoca colocar :
Recibe una sublista con k elementos (k 1) iteraciones
Produce una sublista vaca y otra cuyo tamao se reduce slo en una
unidad
Si se toma como instruccin barmetro el nmero de comparaciones, se
tiene la siguiente ecuacin de recurrencia

0 si n 1
T (n) =
(n 1) + T (n 1) + T (0) si n > 1
Anlisis caso PEOR

1 Resolviendo recurrencia mediante desplegado
T (n) = (n 1) + T (n 1)
= (n 1) + (n 2) + T (n 2)
n = (n 1) + (n 2) + (n 3) + T (n 3)
0 si n 1
T (n) = = (n 1) + (n 2) + + (n k) + T (n k)
(n 1) + T (n 1) + T (0) si n > 1
Caso base n k = 1 k = n 1
n(n 1)
T (n) = (n 1) + (n 2) + + 1 + 0 =
2
2 De forma grfica, mediante el rbol de recursividad
Anlisis caso MEDIO

Una invocacin cualquiera del algoritmo, distinta del caso base, recibe
una sublista a ordenar de k-elementos y ejecuta la funcin colocar
que:
Realiza k-1 comparaciones para situar el pivote en la posicin i
Produce dos sublistas a ordenar de i-1 y k-i elementos
Si todas las posiciones posibles del pivote son igualmente probables,
cada valor de i entre 1 y k tiene una probabilidad de ocurrir de k1
Y denotamos T(k) como el nmero promedio de comparaciones
realizadas para ordenar una lista de k elementos
El promedio de comparaciones para ordenar la lista inicial de
n-elementos vendr dado por
(
0 si n 1
T (n) = 1 Pn
(n 1) + n i=1 [T (i 1) + T (n i)] si n > 1
Anlisis caso MEDIO

Desplegando el sumatorio, teniendo en cuenta que T (0) = T (1) = 0 y que los trminos se repiten a ambos lados de la
suma:
n
X
[T (i 1) + T (n i)] = T (0) +T (n 1)
i=1
+ T (1) +T (n 2)
+ T (2) +T (n 3)
+ ... +...
+ T (n 2) +T (1)
n1 n1
X X
+ T (n 1) +T (0) = T (i) + T (i)
i=2 i=2
Puede simplificarse la ecuacin de recurrencia
0 si n 1
n1
X
T (n) =
(n 1) + n2 T (i) si n > 1

i=2
Ecuacin de recurrencia complicada de resolver. T(n) depende de todos los valores anteriores
Anlisis caso MEDIO simplificado!!!!

Simplificamos la ecuacin de recurrencia anterior suponiendo que la funcin colocar se comporta muy bien y genera,
cada vez que se invoca, dos listas del mismo tamao aproximadamente, es decir, divide por dos la lista inicial
n
0 si n 1
T (n) =
(n 1) + 2T ( n2 ) si n > 1
Se resuelve mediante desplegado como hemos visto en tema de anlisis de algortimos
T (n) = (n 1) + 2T ( n2 )
= (n 1) + 2[( n2 1) + 2T ( n2 )] = (n 1) + (n 2) + 22 T ( n2 )
2 2
= (n 1) + (n 2) + 22 [( n2 1) + 2T ( n3 )] = (n 1) + (n 2) + (n 22 ) + 23 T ( n3 )
2 2 2
...
= (n 20 ) + (n 21 ) + (n 22 ) + ...(n 2k1 ) + 2k T ( nk )
2
k1 k1 k1
n n n
X X X
i k i k k k
= (n 2 ) + 2 T ( )= n 2 + 2 T( ) = kn (2 1) + 2 T ( )
2k 2k 2k
i=0 i=0 i=0

Se llega al caso base cuando la sublista tiene longitud menor o igual que uno (cero comparaciones)
n k
= 1 2 = n k = lg n
2k
Sustituyendo para poner la expresin en funcin del tamao
k k
T (n) = kn (2 1) + 2 T (1) = n lg n (n 1) (n lg n)
Observaciones
QuickSort "rompe" con la filosofa de caso mejor, caso peor y caso
medio. El tiempo de ejecucin depende del orden inicial de los
elementos y tambin de la eleccin del pivote
La eleccin del pivote utilizada (primer elemento de la lista) lleva a
tres casos desfavorables: lista inicial con todos los elementos iguales y
lista clasificada en orden asecendente o descendente
Una mala eleccin del pivote adems agrava el coste de la
recursividad. Cada llamada recursiva supone consumo de memoria en
la pila del programa para almacenar objetos locales y estado de
ejecucin. Para un tamao pequeo puede resultar menos eficiente
que otros algoritmos de ordenacin
Mejoras
Elegir como pivote un valor aleatorio, el valor de la posicin mitad o la
mediana de los valores base, tope y mitad
Utilizar otro algortimo de ordenacin para listas de tamao pequeo
(caso base)
Mejora quickSort
Pivote elemeto mitad de la lista(T [(base + tope)/2])
1: i base
2: j tope
3: inidiceP (base + tope) 2
4: x T [indiceP]
5: repetir
6: mientras T [i] < x hacer
7: i i +1
8: fin mientras
9: mientras T [j] > x hacer
10: j j 1
11: fin mientras
12: si i j entonces
13: intercambiar(T [i], T [j])
14: i i +1
15: j j 1
16: fin si
17: hasta que i > j
18: si base < j entonces
19: quickSort(T[base..j])
20: fin si
21: si tope > i entonces
22: quickSort(T[i..tope])
23: fin si
Mejora quickSort
Utilizando otro algortimo de ordenacin para sublistas pequeas
1: si tope base < tamMnimo entonces

2: algoritmoOdenaci onX (T [base, tope])
3: si no
4: iP colocar (T [base..tope])
5: quickSort(T[base..iP-1])
6: quickSort(T[iP+1..tope])
7: fin si
Tamao mnimo depende de la implementacin

Para sublistas de tamao menor que el mnimo se invoca otro
algortimo de ordenacin: burbuja, seleccin, insercin,...
Mejora quickSort
Eliminado la recursividad de cola
Recordando que
Iteratividad y recursividad son dos formas de expresar lo mismo:
repeticin de un conjunto de instrucciones un cierto nmero de veces
Generalmente la iteratividad consume menos recursos (no es necesario
copiar valores a la pila de memoria)
Recursividad por cola cuando la ltima instruccin de la funcin
recursiva es una llamada recursiva
La recursividad por cola se puede eliminar fcilmente
En la pila se guardan valores intermedios (variables locales y
parmetros), pero como es la ltima instruccin y no van a ser
modificados posteriormente no es necesario guardarlos
Proceso
Sustituir ltima llamada recursiva por un bucle (recursin por
iteratividad)
Ajustar valores de acuerdo a la invocacin recursiva eliminada
Mejora quickSort
Eliminado la recursividad de cola
quickSort(T [base . . . tope])

si base < tope entonces
iP colocar (T [base..tope])
quickSort(T[base..iP-1])
quickSort(T[iP+1..tope])
fin si ->Recursividad de cola
1: mientras base < tope hacer

2: iP colocar (T [base..tope])
3: quickSort(T[base..iP-1])
4: base iP + 1
5: fin mientras ->Recursividad de cola eliminada
3.5 Algoritmo de ordenacin por fusin o MergeSort

Idea bsica
Se basa en la tcnica "divide y vencers" sustituyendo el problema

inicial (ordenar una lista) en dos problemas ms sencillos de resolver
(ordenar dos listas ms pequeas)
Tcnica:
Dividir la lista a ordenar en dos sublistas aproximadamente del mismo
tamao
Ordenar las dos sublistas generadas utilizando la misma
tcnica(recursividad) hasta que tengan un solo elemento(caso base)
Fusionar las sublistas ordenadas manteniendo el orden
Algoritmo 4.14 mergeSort(T [base . . . tope])

2: mergeSort(T [base . . . (base + tope) 2])
3: mergeSort(T [(base + tope) 2 + 1 . . . tope])
4: fusionar (T [base . . . (base + tope) 2], T [(base + tope) 2 + 1 . . . tope])
5: fin si
Ejemplo: Invocacin ... y ltima vuelta RECURSIVA

base tope

1 2 3 4 5 6 7 8 9 10 11 12
7 19 24 13 31 8 82 18 44 63 5 29
Primera invocacin: mergeSort(T[1..12])

mergeSort(T [1..6])
1a llamada rec.
base < tope mergeSort(T [7..12]) ... llamada rec.

fusionar (T [1..6], T [7..12])
Fusionar recibe dos sublistas ORDENADAS !!!!

base tope
1 2 3 4 5 6 7 8 9 10 11 12
7 8 13 19 24 31 5 18 29 44 63 82

baseA topeA baseB topeB
Ejemplo ltima invocacin fusionar(T[1..6],T[7..12])

inicio 1a iteracin 2a iteracin 3a iteracin 4a iteracin
A T A T A T A T A T
indA 1 7 indT 1 7 indA 1 7 1 5 1 7 1 5 1 7 1 5 1 7 1 5
2 8 2 8 2 8 indT 2 8 indA 2 8 2 7 2 8 2 7 2 8 2 7
3 13 3 13 3 13 3 13 3 13 indT 3 13 indA 3 13 3 8 3 13 3 8
4 19 4 19 4 19 4 19 4 19 4 19 4 19 indT 4 19 indA 4 19 4 13
5 24 5 24 5 24 5 24 5 24 5 24 5 24 5 24 5 24 indT 5 24
dimA 6 31 6 31 6 31 6 31 6 31 6 31 6 31 6 31 6 31 6 31
B 7 5 B 7 5 B 7 5 B 7 5 B 7 5
indB 1 5 8 18 1 5 8 18 1 5 8 18 1 5 8 18 1 5 8 18
2 18 9 29 indB 2 18 9 29 indB 2 18 9 29 indB 2 18 9 29 indB 2 18 9 29
3 29 10 44 3 29 10 44 3 29 10 44 3 29 10 44 3 29 10 44
4 44 11 63 4 44 11 63 4 44 11 63 4 44 11 63 4 44 11 63
5 63 12 82 5 63 12 82 5 63 12 82 5 63 12 82 5 63 12 82
dimB 6 82 6 82 6 82 6 82 6 82
5a iteracin 6a iteracin 7a iteracin 8a iteracin 9a iteracin y ltima!!!

A T A T A T A T A T
1 7 1 5 1 7 1 5 1 7 1 5 1 7 1 5 1 7 1 5
2 8 2 7 2 8 2 7 2 8 2 7 2 8 2 7 2 8 2 7
3 13 3 8 3 13 3 8 3 13 3 8 3 13 3 8 3 13 3 8
indA 4 19 4 13 4 19 4 13 4 19 4 13 4 19 4 13 4 19 4 13
5 24 5 18 indA 5 24 5 18 5 24 5 18 5 24 5 18 5 24 5 18
6 31 indT 6 31 6 31 6 19 indA 6 31 6 19 indA 6 31 6 19 6 31 6 19
B 7 5 B indT 7 5 B 7 24 B 7 24 indA=7 B 7 24
1 5 8 18 1 5 8 18 1 5 indT 8 18 1 5 8 29 1 5 8 29
2 18 9 29 2 18 9 29 2 18 9 29 2 18 indT 9 29 2 18 9 31
indB 3 29 10 44 indB 3 29 10 44 indB 3 29 10 44 3 29 10 44 3 29 indT 10 44
4 44 11 63 4 44 11 63 4 44 11 63 indB 4 44 11 63 indB 4 44 11 63
5 63 12 82 5 63 12 82 5 63 12 82 5 63 12 82 5 63 12 82
6 82 6 82 6 82 6 82 6 82
Algoritmo FUSIONAR
1 Copiar cada subvector ordenado a una variable local( vectores

A[1..dimA] y B[1..dimB]
2 Comparar elemento a elemento de ambos subvectores, empezando
por los primeros (los ms pequeos) y mientras haya elementos en los
dos (bucle mientras indA dimA Y indB dimB)
Si el elemento de A es ms pequeo, se sita en T y se avanza en A
Si el elemento de B es ms pequeo, se sita en T y se avanza en B
Se avanza en T para situar el siguiente elemento ordenado!!!
3 Si acaba bucle porque no hay ms elementos en B, aadir los
elementos que quedan de A
4 Si acaba bucle porque no hay ms elementos en B, aadir los
elementos que quedan de B
Pseudocdigo algoritmo fusionar

Algoritmo 4.15 fusionar(T [baseA . . . topeA], T [baseB . . . topeB])
1: indA 1
2: indB 1
3: indT baseA
4: dimA topeA baseA + 1
5: dimB topeB baseB + 1
6: A[1..dimA] T [baseA..topeA]
7: B[1..dimB] T [baseB..topeB]
8: mientras indA dimA and indB dimB hacer
9: si A[indA] < B[indB] entonces
10: T [indT ] A[indA]
11: indA indA + 1
12: si no
13: T [indT ] B[indB]
14: indB indB + 1
15: fin si
16: indT indT + 1
17: fin mientras
18: si indA > dimA entonces
19: T [indT ..topeB] B[indB..topeB]
20: si no
21: T [indT ..topeB] A[indA..topeA]
22: fin si
Fusionar es de orden lineal respecto a la suma de los tamaos de las listas que inspecciona
El tiempo para fusionar o intercalar dos vectores ordenados es lineal porque a lo sumo se hacen
n 1 comparaciones (Recibe dos sublistas ordenadas de n2 -elementos cada una) = (n)
Ejemplo completo
Las sucesivas invocaciones recursivas van produciendo dos subvectores aproximadamente del mismo tamao
Las sucesivas vueltas recursivas van fusionando (intercalando) los subvectores produciendo otros ms grandes ordenados
Observaciones
El algoritmo de ordenacin por fusin o intercalacin siempre divide

la sublista original en dos de tamao mitad(1), incluso en el caso
peor est en (n lg n)
Presenta como desventaja la memoria necesaria en el proceso de
fusin o intercalacin
Se propone como ejercicio realizar el anlisis
3.6 Algoritmos de ordenacin por distribucin

Idea bsica
Los algoritmos vistos hasta ahora suponen que los elementos a

ordenar pertenecen a un conjunto linealmente ordenado y se basan en
la comparacin de dos elementos
La familia de algoritmos que se presenta aqu se basa en que se debe
conocer algo ms sobre los elementos que se van a ordenar:
estructura o rango
Ejemplo. Ordenacin de fichas de alumnos
Alfabtica por apellidos y nombre
Por nmero de matrcula
Tres pasos para ordenar
Fase 1. Distribucin de los elementos en grupos (urnas) de acuerdo a
alguna caracterstica de los elementos
Fase 2. Ordenacin de cada grupo individual mediante algn algoritmo
conocido
Fase 3. Concatenacin adecuada de los grupos
Ejemplo
Ordenacin alfabtica de fichas de alumnos por Apellidos y Nombre
Fase 1. Distribucin en grupos
Grupo A: Apellidos que comienzan con la letra A

Grupo B: Apellidos que comienzan con la letra B
... ...
Grupo Z: Apellidos que comienzan con la letra Z
Ejemplo
Fase 2. Ordenacin individual de cada grupo
Ordenar Grupo A
Ordenar Grupo B
...
Ordenar Grupo Z
Fase 3. Concatenacin de grupos
Primer grupo: Grupo A

Segundo grupo: Grupo B
... ...
ltimo grupo: Grupo Z
Anlisis por fases

Ordenacin de un conjunto de n-elementos y k-grupos
Fase 1. Distribucin de los n-elementos en los k-grupos.

Se examina cada elemento individualmente (comparacin)
Se sita cada elemento en un grupo (copia o actualizacin
ndice|puntero)
Se recorre la lista una vez y se realizan operaciones elementales
Fase1 (n)
Fase 2. Ordenacin individual de cada grupo. Esta fase depende del
algoritmo de ordenacin empleado y del tamao de cada grupo.
Sea t(n) el orden del algoritmo de ordenacin empleado
Sea ni el tamao del grupo i Pk
El orden de esta fase vendr dado por i=1 t(ni )
Fase 3. Concatenacin de grupos
Se deben situar todos los elementos de los grupos en el conjunto final
ordenado
Copia o actualizacin de ndices|punteros
Fase3 (n)
Anlisis suponiendo que...

El orden del algoritmo elegido en la fase 2 es t(n) (n lg n)
Los n-elementos quedan uniformemente distribuidos en los k-grupos
ni ' kn
k k k
X X X n n n n n
t(ni ) = ni lg ni = lg( ) = k lg( ) = n lg( )
i=1 i=1 i=1
k k k k k
El tiempo de ejecucin para la ordenacin individual de todos los

grupos quedar acotado por la expresin anterior.
n
Fase2 (n lg( ))
k
Menor tiempo de ejecucin cuando aumenta el nmero de grupos (k)
Ejemplo. Para grupos de 10 elementos el tiempo de ejecucin
n
(k = 10 )
t(n) cn lg 10 (n)
Observaciones
Se tienen tres fases, dos de ellas con un comportamiento lineal

(distribucin y concatenacin) y la fase de ordenacin individual de
cada grupo, que es la que consume ms tiempo y determinar el
orden final del algoritmo
El caso PEOR se presentar cuando la fase 1 distribuya todos los
elementos del conjunto inicial en un nico grupo:
La segunda fase consumir el tiempo correspondiente al algoritmo de
ordenacin elegido
Las fases 1 y 3 suponen una sobrecarga en el tiempo de ejecucin
Si se sabe "algo" sobre el rango de los elementos, se puede ajustar la
distribucin de forma que todos los grupos reciban, aproximadamente,
el mismo nmero de elementos
Tambin debe tenerse en cuenta la cantidad de memoria consumida
para la representacin de los grupos!!!
Representacin de los grupos

Anlisis de las estructuras utilizadas para implementar los grupos
Memoria esttica: matrices

Cada grupo se almacena en una matriz
Deben ser capaces de almacenar el mximo nmero de elementos que
puede contener un grupo (n en el peor de los casos)
El espacio consumido por los k grupos kn
Al aumentar el nmero de grupos aumenta el espacio de memoria
consumido (Disminua el tiempo de ejecucin)
Memoria dinmica: lista enlazadas
Cada grupo ocupa un espacio de memoria proporcional al nmero de
elementos que tiene
El espacio consumido por los k grupos k + n
Se consume menos memoria pero...se "complican" los algoritmos de
ordenacin individual!!!!!1
1
No debera resultar complicado modificar los algoritmos presentados (burbuja,
seleccin, ...)para ordenar una lista enlazada en lugar de un vector
Algoritmo de ordenacin por base o RadixSort

Caso particular de algoritmo de ordenacin por distribucin
Se aplica a la ordenacin de nmeros enteros

Tcnicas para base 10
Se utilizan 10 grupos uno por cada cifra 0 a 9
Inicialmente se tiene una lista con todos los elementos a ordenar
Primera versin siguiendo paso a paso las tres fases:
1 Distribuir los elementos de la lista en los 10 grupos atendiendo a la
cifra ms significativa (primera por la izquierda)
2 Ordenar cada grupo individualmente aplicando mismo mecanismo
(recursivo) u otro algoritmo de ordenacin
3 Concatenar los grupos (complejidad manejo ndices|punteros segn se
sale de la recursividad !!!)
Segunda versin: Repetir para cada cifra, empezando por la menos
significativa (primera por la derecha)
Distribuir los elementos de la lista en el grupo correspondiente a la
cifra en proceso
Concatenar los grupos en un nica lista
Ejemplo Segunda Versin RadixSort
Lista inicial a ordenar

1 Iteracin correspondiente a unidades:
2 Iteracin correspondiente a decenas
3 Iteracin correspondiente a centenas
4 lista ordenada !! Solo dos fases: distribucin y concatenacin!
Observaciones
Ventajas segunda versin
Se mantiene el orden al pasar de cifras menos significativas a ms
significativas
Si la posicin del dgito en que difieren dos valores es la i-sima, ambos
valores tendrn y mantendrn el orden relativo correcto a partir del
i-sima iteracin
No hace falta ningn algoritmo de ordenacin adicional
No hay problemas de ndice|punteros pues la distribucin se realiza
siempre a partir de una nica lista
Implementacin
La estructura ms adecuada para representar el conjunto de elementos
a ordenar es una lista enlazada
En la fase de distribucin se forman 10 listas enlazadas extrayendo los
nodos de la lista inicial y aadindolos al grupo correspondiente (vector
de punteros a los primeros nodos de cada grupo)
En la fase de concatenacin se vacan los 10 grupos para formar de
nuevo una nica lista enlazada (un vector de punteros a los ltimos
nodos de cada grupo evita el recorrido de cada lista!!!!)
Ejemplo y Pseudocdigo
Inicio. Lista enlazada inicial y nGrupos vacos
Algoritmo 4.16 radixSort(ref lista:nodo,
nGrupos,nCifras:entero)
1: ptGrupos[0..nGrupos 1] :nodo
2: pt Ultimos[0..nGrupos 1] :nodo
3: para cifra 1 to nCifras hacer
4: para k 0 to nGrupos 1 hacer
5: ptGrupos[k] NULL
6: pt Ultimos[k] NULL
7: fin para
8: distribuir (cifra, lista, ptGrupos, pt Ultimos)
Cada grupo se implementa mediante una lista enlazada 9: concatenar (lista, ptGrupos, pt Ultimos)
10: fin para
Distribucin de los nodos en los diferentes grupos
Concatenacin de los grupos
Los nodos vuelven de los grupos a la lista inicial

Los
Ivn nodos Navia
lvarez pasan -de la lista aMartn
M.J.Polo los grupos.
(USAL)La lista queda vaca
Estructuras de Datos y Algoritmos I curso 2016-2017 177 / 289
Distribuir
Se distribuyen los nodos de la lista en los nGrupos y la lista, que se le pasa

por referencia, queda vaca despus de cada distribucin
Algoritmo 4.17 distribuir(cifra:entero,

ref lista:nodo,
ptGrupos[0 . . . nGrupos-1]:nodo,
ptltimos[0 . . . nGrupos-1]:nodo)
1: aux lista
2: mientras aux 6= NULL hacer
3: k extraer(cifra, aux.clave)
4: si ptGrupos[k] = NULL entonces
5: ptGrupos[k] aux
6: pt Ultimos[k] aux
7: si no
8: pt Ultimos[k] .sig aux
9: pt Ultimos[k] aux
10: fin si
11: aux aux.sig
12: fin mientras
13: lista NULL
Concatenar
Cada llamada a concatenar vuelve a llenar la lista con los nodos iniciales
pero ordenados segn la cifra en proceso!!!
Algoritmo 4.18 concatenar(ref lista:nodo,

ptGrupos[0 . . . nGrupos-1]:nodo,
ptltimos[0 . . . nGrupos-1]:nodo)
1: lista NULL
2: para k 0 hasta nGrupos-1 hacer
3: si ptGrupos[k] 6= NULL entonces
4: si lista = NULL entonces
5: lista ptGrupos[k]
6: si no
7: pt Ultimos[anterior ] .sig ptGrupos[k]
8: fin si
9: anterior k
10: fin si
11: fin para
12: pt Ultimos[anterior ] .sig NULL
Contenidos
2 Notacin asinttica

Esquemas Algortmicos
Tema 5. Esquemas Algortmicos

Contenidos
Algoritmo
Algoritmia
Operacin elemental
2 Notacin asinttica
Introduccin
Notacin El orden de
Notacin Omega
Notacin Theta
Introduccin
Operaciones elementales
Ivn lvarez Navia - M.J.Polo Martn (USAL)
e instrucciones
Estructuras de Datos y Algoritmos I curso 2016-2017 181 / 289
Esquemas Algortmicos Introduccin
Detalles del tema
Introduccin
Esquema Divide y Vencers
Esquema Voraz
Rastreo Inverso o Backtraking
Esquemas Algortmicos Introduccin
Introduccin a los Esquemas Algortmicos

Estrategias basadas en abstracciones muy potentes que permiten
agrupar en una misma familia de problemas lo que, en principio, son
problemas diferentes
Cada familia se caracteriza por las propiedades de su conjunto de
datos de entrada y/o solucin
Esquema Algortmico
Algoritmo abstracto que permite resolver los problemas de una familia
determinada
Se especifican como una plantilla con funciones no definidas que deben
garantizar el cumplimiento de ciertas propiedades
Proceso a seguir
1 Clasificacin del problema como miembro de una familia (se cumplen
propiedades?)
2 Seleccin del esquema algortmico (qu hacer!)
3 Instanciacin del esquema en un algoritmo concreto(cmo hacer!)
4 Verificacin, anlisis y refinamientos sucesivos del algoritmo
Esquemas Algortmicos Esquema Divide y Vencers
Detalles del tema
Introduccin
Esquema Voraz
1. Tcnica divide y vencers

Propiedades y esquema divide, resuelve y combina
Dividir o descomponer. El problema inicial puede dividirse fcilmente en subproblemas

del mismo tipo pero con una solucin ms simple (al menos dos subproblemas)
Resolver independiente. Cada subproblema puede resolverse independietemente de los
dems (no hay solapamiento)
Existe un mtodo directo para resolver problemas de tamao pequeo
Combinar. Una vez resueltos los subproblemas se necesita un mtodo para combinarlos y
obtener la solucin total (no siempre!!!)
Algoritmo 5.1 divideYVencers(P)
Entrada: ejemplar a resolver P

Salida: solucin S
1: si P es pequeo o simple entonces
2: devolver soluci onSimple(P)
3: si no
4: para i 1 hasta k hacer
5: S[i] divideYVencer as(P[i]) = Naturaleza recursiva
6: fin para
7: devolver combinaSoluciones(S[1, . . . , k])
8: fin si
Ejemplos
Algoritmo 5.2 mergeSort(T [base . . . tope])

2: mergeSort(T [base . . . (base + tope) 2])
3: mergeSort(T [(base + tope) 2 + 1 . . . tope])
4: fusionar (T [base . . . (base + tope) 2], T [(base + tope) 2 + 1 . . . tope])
5: fin si ->lnea 4: combinar soluciones

2: iP = colocar (T [base, tope])
3: quickSort(T [base..iP 1])
4: quickSort(T [iP + 1..tope])
5: fin si ->lnea 1: combinar soluciones!!
Problema tpico esquema Divide y Vencers
Las torres de Hanoi

En el gran templo de Benars, debajo de la cpula que marca el centro del mundo, yace una base de bronce, en donde se
encuentran acomodadas tres agujas de diamante, cada una del grueso del cuerpo de una abeja y de una altura de 50 cm
aproximadamente. En una de estas agujas, Dios, en el momento de la Creacin, coloc sesenta y cuatro discos de oro -el mayor
sobre la base de bronce, y el resto de menor tamao conforme se va ascendiendo-. Da y noche, incesantemente, los sacerdotes
del templo se turnan en el trabajo de mover los discos de una aguja a otra de acuerdo con las leyes impuestas e inmutables de
Brahma, que:
requieren que siempre haya algn sacerdote trabajando,
que no muevan ms de un disco a la vez y
que deben colocar cada disco en alguna de las agujas de modo que no cubra a un disco de radio menor.
Cuando los sesenta y cuatro discos hayan sido transferidos de la aguja en la que Dios los coloc, en el momento de la Creacin,
a otra aguja, el templo y los brahmanes se convertirn en polvo y, junto con ellos, el mundo desaparecer
De Parville, La Nature, 1884, part I, pp. 285286; traduccin en

http: // olmo. pntic. mec. es/ ~aserra10/ articulos/ hanoi. html
Otros enlaces
http://es.wikipedia.org/wiki/Torres_de_hanoi
Simulacin del juego para cuatro discos e implementacin en varios lenguajes de programacin
http://olmo.pntic.mec.es/~aserra10/articulos/hanoi.html
Descripcin ms matemtica del problema y la solucin
http://hanoitower.mkolar.org/Hanoi.html?English
Versin iterativa del juego, incluye una simulacin de la solucin
Solucin al problema de las torres de Hanoi
El paso clave es concentrarse en mover el ltimo disco (el mayor) no

el primero
Pasos del algoritmo:
mover, de alguna manera, 63 discos de 1 a 2, utilizando aguja 3
temporalmente (subproblema del mismo tipo pero con un disco menos)
mover disco 64 de 1 a 3 (caso base)
mover, de alguna manera, los 63 discos de 2 a 3, utilizando aguja 1
temporalmente (subproblema del mismo tipo pero con un disco menos)
Quedan por resolver dos subproblemas, del mismo tipo que el
problema original, pero con un disco menos, por lo que se pueden
resolver utilizando la misma tcnica: recursividad
Caso base: mover un disco
Solucin grfica para tres discos

Primera llamada, dos partes conceptuales:
Caso base: mover el disco 3 de la aguja 1 a la 3
Paso de recursividad: Mover dos discos (el 1 y el 2) de la aguja 1 a la 2, utilizando la 3
como auxiliar, y de la aguja 2 a la 3 utilizando la 1 como auxiliar
Pasos del algoritmo para tres discos

Invocacin recursiva Mover dos discos de aguja 1 a la 2, utilizando aguja 3
temporalmente
Caso base Mover disco 3 de 1 a 3
Invocacin recursiva Mover dos discos de aguja 2 a 3, utilizando aguja 1 temporalmente
Detalle de la primera invocacin recurisva

Primer interrogante transparencia anterior
Subproblema del mismo tipo ms simple: mover los discos 1 y 2 de la aguja 1 a la 2. De

nuevo dos partes conceptuales:
Paso de recursividad: Mover el disco 1 de la aguja 1 a la 3,utilizando la 2 como
auxiliar (si fuera preciso).
Caso base: mover el disco 2 de la aguja 1 a la 2
Paso de recursividad: Mover el disco 1 de la aguja 3 a la 2, utilizando la 1 como
auxiliar (si fuera preciso).
Ojo un nico disco a mover (el disco 1) caso base en la llamada recursiva siguiente
Las terceras llamadas recursivas (pasos de recursividad en las segundas) reciben como
subproblema mover un nico disco caso base
El segundo interrogante (mover discos 1 y 2 de 3 a 2) se resuelve de forma anloga

Seudocdigo y Anlisis
Algoritmo 5.4 hanoi(n, a, b, c)

Entrada: nmero de discos, n, aguja de origen, a, aguja de destino, b, y aguja auxiliar c
Salida: nada, presenta por pantalla los movimientos de los discos
1: si n > 0 entonces
2: hanoi(n 1, a, c, b)
3: escribirPantalla ("Mueve el disco ", n, " de la aguja", a, " a la aguja ", b)
4: hanoi(n 1, c, b, a)
5: fin si
Ecuacin de recurrencia que expresa el consumo de tiempo

n
0, si n = 0
T (n) =
2T (n 1) + 1, si n > 0
Aplicamos la tcnica de expansin o desplegado:
T (n) = 2T (n 1) + 1
= 2[2T (n 2) + 1] + 1 = 22 T (n 2) + 2 + 1
= 22 [2T (n 3) + 1] + 2 + 1 = 23 T (n 3) + 22 + 2 + 1
...
= 2k T (n k) + 2k1 + ... + 22 + 2 + 1
Siendo k el nmero de invocaciones recursivas. Se llega al caso base cuando: n k = 0 k = n Sustituimos k por su valor
k k1 2 k n
T (n) = 2 T (0) + 2 + ... + 2 + 2 + 1 = 2 1 = 2 1
Faltara demostrar por induccin que la conjetura encontrada es cierta

Seudocdigo y rbol de recursividad

Seudocdigo para una llamada inicial hanoi(n, 1, 3, 2):
Algoritmo 5.5 hanoi(n, a, b, c)

Entrada: nmero de discos, n, aguja de origen, a, aguja de destino, b, y aguja auxiliar c
Salida: nada, presenta por pantalla los movimientos de los discos
1: si n > 0 entonces
2: hanoi(n 1, a, c, b)
3: escribirPantalla ("Mueve el disco ", n, " de la aguja", a, " a la aguja ", b)
4: hanoi(n 1, c, b, a)
5: fin si
Cuando s utilizar la recursividad

El rbol de recursividad muestra la sucesin de llamadas recursivas. El
recorrido es, como ya hemos visto en otros ejemplos:
Se baja por la rama izquierda, hasta alcanzar un nodo hoja o nodo final
Alcanzado el nodo hoja, se sube al nodo padre y se imprime el
movimiento en pantalla
Si hay rama derecha, se recorre el subrbol de la misma manera
El rbol es totalmente balanceado y no repite operaciones
T (3) = 20 + 21 + 22 = 7
Anlisis usando el rbol de recursividad

La primera llamada se realiza con no de discos = n
Cada llamada recursiva reduce en 1 el no de discos
Excluyendo las llamadas con no de discos = 0, que no hacen nada, se
tiene una profundidad del rbol de recursividad de n
Excepto los nodos hoja, cada nodo realiza dos llamadas recursivas, y,
por ello, el nmero de nodos en cada nivel es exactamente el doble al
nmero de nodos del nivel anterior
El nmero de nodos no hoja es, por tanto:
1 + 2 + 4 + + 2n1 = 2n 1
Para n = 3: T (3) = 23 1 = 7
Para el caso de la leyenda, donde n = 64 tenemos:
2n 1 = 264 1 1, 8x 1019
Si un ao son, aproximadamente, 3.2x 107 segundos, y los monjes son
incansables y tan rpidos que realizan cada movimiento exactamente
en un segundo, entonces la tarea total tardara unos 5x 1011 aos
Variante tcnica divide y vencers

Propiedades y esquema divide, escoge y resuelve
Dividir o descomponer. El problema inicial puede dividirse fcilmente en

subproblemas del mismo tipo pero con una solucin ms simple
Escoger. Se escoge un subproblema de los resultantes de acuerdo a una
determinada condicin. Esquema "reduccin" o "simplificacin"
Resolver. Se resuelve el subproblema escogido
No hay combinacin de soluciones!!!!
Algoritmo 5.6 divideEscogeResuelve(P)
Entrada: ejemplar a resolver P

Salida: solucin S
1: si P es pequeo o simple entonces
2: devolver soluci onSimple(P)
3: si no
4: para i 1 hasta k hacer
5: P[i] divide(P)
6: fin para
7: devolver divideEscogeResuelve(escoge(P[1, . . . , k]))
8: fin si
La invocacin escoge(P[1, . . . , k]) devuelve un nico subproblema, de los k

resultantes de la divisin
Ejemplo
Versin recursiva de la bsqueda binaria
Algoritmo 5.7 bsquedaBinariaRecursiva(T [i..j], valor )
Entrada: vector T [i..j] ordenado orden creciente, valor buscado valor

Salida: posicin de valor en T [i..j]
1: si i > j entonces
2: devolver 0
3: si no
4: k (i + j) 2 ->Divide!
6: j k 1 ->Escoge!
8: i k +1
10: devolver k
11: fin si
12: devolver busquedaBinariaRecursiva(T [i..j], valor ) ->Resuelve!!!
13: fin si
Esquemas Algortmicos Esquema Voraz
Detalles del tema
Introduccin
Esquema Voraz
2. Tcnica Voraz
Idea bsica
Los algoritmos voraces, tal como su nombre indica, toman decisiones

basndose en la informacin disponible de modo inmediato, sin tener
en cuenta los efectos que estas decisiones puedan tener en el futuro
Son fciles de inventar, implementar y, cuando funcionan, son
eficientes. No hay necesidad de evaluar alternativas, ni requieren un
seguimiento que permita deshacer las decisiones anteriores
Cundo se utilizan?
Los algoritmos voraces, vidos o de avance rpido (greedy ) se utilizan en
problemas de optimizacin, donde debe elegirse una solucin entre un
conjunto de posibles soluciones
Sin embargo, hay problemas que no pueden resolverse con este
enfoque!!!
No siempre encuentran la solucion ptima
Puede que no encuentren solucin incluso cuando el problema s la tiene
Ejemplo: devolver cambio con nmero mnimo de monedas
Problema a resolver
Disear un algoritmo para pagar una cierta cantidad a un cliente utilizando
el menor nmero de monedas
Entrada: cantidad ilimitada de todas las monedas disponibles
{1ct, 2cts, 5cts, 10cts, 20cts, 50cts, 1, 2} y cantidad a pagar
Salida: conjunto de monedas que sumen la cantidad
Mejor solucin (voraz o vida) para abonar 3,49 es

1 moneda de 2
1 moneda de 1
2 monedas de 20 cntimos
1 moneda de 5 cntimos
2 monedas de 2 cntimos
7 monedas = Solucin ptima
Caractersticas generales de los algoritmos voraces

Instanciacin a un caso concreto
Se necesita resolver un problema de forma

ptima Particularizando al problema del cambio
Para construir la solucin se dispone de un Conjunto de Candidatos C =
conjunto de candidatos {1ct, 2cts, 5cts, 10cts, 20cts, 50cts, 1, 2}
El problema puede resolverse en fases, cada (monedas disponibles, cantidad ilimitada!!)
una aade un candidato a la solucin o lo Funcin de seleccin: el candidato ms
rechaza prometedor es la moneda de mayor valor
Existe una funcin de seleccin que indica en que ayude a conseguir el objetivo o acerca
cada momento cual es el candidato ms la solucin al objetivo
prometedor (el que optimiza funcin objetivo) Objetivo: minimizar el nmero de monedas
Existe una funcin que indica si el candidato Solucin factible: conjunto de monedas
elegido aadido a los ya seleccionados permite cuyo valor total no sobrepasa el cambio
obtener una solucin factible Solucin (si existe): conjunto de monedas
Existe una funcin que comprueba si esa que sumen cambio
solucin factible es solucin del problema
Esquema GENERAL
Los algoritmos voraces avanzan paso a paso hasta encontrar una solucin ptima (o no!)
Los algoritmos voraces avanzan paso a paso

1 Inicialmente el conjunto solucin est Algoritmo 5.8 algoritmoVoraz(C : conjunto)
vaco
Entrada: C el conjunto de candidatos
2 En cada paso se considera aadir al Salida: S el conjunto solucin
conjunto solucin el mejor candidato 1: S
(funcin seleccin), y se acepta o se 2: mientras C 6= y no soluci on(S) hacer
3: x seleccionar (C )
rechaza en ese momento:
4: C C {x }
Si la solucin obtenida es factible 5: si factible(S {x }) entonces
se aade el candidato actual al 6: S S {x }
conjunto solucin y se comprueba si 7: fin si
la solucin factible es solucin 8: fin mientras
Si la solucin obtenida no es 9: si soluci on(S) entonces
factible se rechaza el candidato 10: devolver S
11: si no
escogido y no se vuelve a considerar
12: devolver no hay solucin
en el futuro 13: fin si
Las decisiones tomadas nunca se revisan

Voracidad: se consume el mejor candidato lo antes posible sin pensar en futuras
consecuencias
A veces no se obtiene solucin y no siempre es la mejor !!
Formalizacin tcnica voraz

Definicin problema optimizacin
Bsqueda del elemento solucin x en el dominio X de forma que optimiza
el valor de cierta funcin objetivo
Formalizacin solucin
Obtencin de un ptimo global tomando decisiones localmente ptimas.
Si cada solucin x del dominio X puede descomponerse en un conjunto de
elementos ms simples x = {x1 , x2 , ..., xn }, para cada i se selecciona el
valor xi que resulta ms prometedor y que, unido a las decisiones ya
tomadas, permite seguir formando una solucin factible
Propiedad de eleccin voraz

El problema de optimizacin satisface la propiedad de eleccin voraz si la
toma de decisiones que ofrecen el mximo beneficio inmediato conduce al
mximo beneficio global
Particularizando el esquema al problema del cambio

Instanciacin del esquema general en un algoritmo concreto
C = {1..., 2..., 5..., 10..., 20..., 50..., 100..., 200...}
monedas disponibles(cantidad ilimitada!)
Algoritmo 5.9 algoritmoVoraz(C )

Algoritmo 5.11 devolverCambio(C , cambio )
Entrada: C el conjunto de candidatos
Salida: S el conjunto solucin Entrada: C el conjunto de monedas candidatas,
1: S cambio entero que indica la cantidad a devolver
2: mientras C 6= y no soluci on(S) hacer Salida: S el conjunto solucin
3: x seleccionar (C ) 1: S
4: C C {x } 2: suma 0
5: si factible(S {x }) entonces 3: mientras suma 6= cambio hacer
6: S S {x } 4: x seleccin(C) ->mayor moneda de C /suma + x cambio
7: fin si 5: si @x entonces
8: fin mientras 6: devolver "no hay solucin"
9: si soluci on(S) entonces 7: si no
10: devolver S 8: S S { una moneda de valor x}
11: si no 9: suma suma + x
12: devolver no hay solucin 10: fin si
13: fin si 11: fin mientras
12: devolver S
Refinando el ESQUEMA
Conjunto de candidatos: C = {c1 , c2 , c3 , c4 , c5 , c6 , c7 , c8 } = {1, 2, 5, 10, 20, 50, 100, 200} valor monedas ordenado creciente
Conjunto solucin: S = {x1 , x2 , x3 , x4 , x5 , x6 , x7 , x8 } donde xi es el nmero de monedas usadas de valor ci
P8 P8
Formulacin: minimizar xi tal que xi ci = cambio con xi 0
i=1 i=1
Representacin y pseudocdigo
1 2 3 4 5 6 7 8
Representacin conjunto de candidatos C 1 2 5 10 20 50 100 200

1 2 3 4 5 6 7 8
Representacin conjunto solucin X ? ? ? ? ? ? ? ?
Algoritmo 5.12 devolverCambio(cambio : entero; C : matriz[1, . . . , n] de enteros)

Entrada: cambio entero que indica la cantidad a devolver, C el conjunto de monedas candidatas con n = 8
Salida: X : matriz[1, . . . , n] el conjunto solucin, nmero de monedas de cada tipo
1: cambioAcumulado 0
2: j n
4: X [i] 0
5: fin para
6: mientras cambioAcumulado 6= cambio hacer
7: mientras C [j] > (cambio cambioAcumulado) Y (j > 0) hacer
8: j j1
9: fin mientras
10: si j = 0 entonces
11: devolver No existe solucin
12: fin si
13: X [j] (cambio cambioAcumulado) C [j]
14: cambioAcumulado cambioAcumulado + C [j] X [j]
15: fin mientras
16: devolver X
1 2 3 4 5 6 7 8
Solucin para cambio de 349 cntimos X 0 2 1 0 2 0 1 1

Particularizando el esquema al problema del cambio

Cuidado no siempre solucin ptima
No siempre produce solucin ptima

Mismo problema, mismo algoritmo, pero cambiando la base
monetaria: antiguo sistema monetario ingls
{ 1penique, 3p, 6p, 12p (cheln), 24p (florn), 30p (corona)}
Problema: abonar 48p
Solucin mediante esquema voraz para devolver 48p: 30p+12p+6p
Sin embargo, la solucin ptima: 24p+24p
El esquema voraz proporciona solucin pero no siempre ptima
Problema de la Mochila con fraccionamiento
Enunciado
Se dispone de una mochila de capacidad C y n objetos. Cada objeto ni
tiene un peso positivo pi y un valor positivo vi . El objetivo es llenar la
mochila maximizando el valor de los objetos transportados pero
respetando la limitacin de su capacidad C (peso mximo que puede
transportar).
Se supone que los objetos se pueden dividir en trozos ms pequeos, es
decir, se puede aadir a la mochila una fraccin xi del objeto ni siendo su
contribucin en peso xi pi y en valor xi vi
Formalizacin
Maximizar ni=1 xi vi tal que ni=1 xi pi C
P P
con pi > 0, vi > 0 y 0 xi 1 para 0 i n

Particularizando el esquema
Conjunto de candidatos: C = {(p1 , v1 ), (p2 , v2 ), .., (pn , vn )}

Solucin: vector x (x1 , x2 , ..., xn ) que indique que fraccin de cada
objeto hay que incluir en la mochila
Objetivo: Maximizar ni=1 xi vi tal que ni=1 xi pi C con
P P
pi > 0, vi > 0 y 0 xi 1 para 0 i n

Solucin ptima:
Pn
1 Si i=1 pi 6 C caben todos los objetos!!! x (1, 1, ..1) No
necesaria
Pn tcnica voraz!
2 Si i=1 pi > C No caben todos!! Buscamos una solucin voraz que
funcione
Todas las soluciones ptimas llenarn la mochila??
S, porque los objetos se pueden dividir
Funcin seleccin: elegir la mayor fraccin posible del candidato "ms
prometedor"
Cal es el candidato ms prometedor? Tres posibles funciones de
seleccin

Funcines de seleccin
Funcin Seleccin. Tres posibilidades:

1 Elegir en cada fase el objeto con ms valor, pues esto aumenta el valor
de la carga del modo ms rpido posible
2 Elegir el objeto ms ligero en cada fase, pues esto permite agotar la
capacidad de la forma ms lenta posible y podemos aadir ms objetos
3 Evitar las dos selecciones previas seleccionando en cada fase aquel
objeto cuyo valor por unidad de peso sea el mayor posible(vi /pi )
Se puede demostrar (Brassard,pg.229-230) que el tercer criterio
proporciona siempre una solucin ptima
El siguiente ejemplo muestra que las soluciones obtenidas
maximizando el valor de los objetos (caso1) o minimizando el peso de
los objetos (caso 2), no son necesariamente las soluciones ptimas
Ejemplo: mochila de capacidad 110 Kg y cinco objetos
C = {(25kg, 55), (40kg, 75), (35Kg, 76), (50kg, 55), (45Kg, 95)}

Ejemplo: representacin y solucin para cada posible funcin seleccin
1 Candidato ms prometedor objeto con mayor beneficio

ENTRADA
1 2 3 4 5
valor 55 55 75 76 95
peso 50 25 40 35 45
SALIDA o SOLUCIN
1 2 3 4 5 pesoMochila = 45 + 35 + 0, 75 40 = 110
X 0 0 0,75 1 1 valorMochila = 95 + 76 + 0, 75 75 = 227, 25
2 Candidato ms prometedor objeto con menor peso

ENTRADA
1 2 3 4 5
valor 55 95 75 76 55
peso 50 45 40 35 25
SOLUCIN
1 2 3 4 5 pesoMochila = 25 + 35 + 40 + 0, 22 45 = 109, 9 ' 110

X 0 0,22 1 1 1 valorMochila = 55 + 76 + 75 + 0, 2 95 '= 227, 11
3 Candidato ms prometedor objeto con mejor proporcin valor/peso

ENTRADA
1 2 3 4 5
valor 55 75 95 76 55
peso 50 40 45 35 25
valor/peso 1,10 1,87 2,11 2,17 2,20
SOLUCIN
1 2 3 4 5 pesoMochila = 25 + 35 + 45 + 0, 125 40 = 110

X 0 0,125 1 1 1 valorMochila = 55 + 76 + 95 + 0, 125 75 = 235, 38
Formalizando el algoritmo
Seudocdigo
Algoritmo 5.13 mochila(C : entero; p, v : matriz[1, . . . , n] de enteros)
Entrada: C entero que indica la capacidad mxima de la mochila, p y v

matrices de enteros con los pesos y los valores de los objetos ordenadas
en orden creciente de su ratio vi /pi
Salida: X : matriz[1, . . . , n] de nmeros reales, la matriz solucin, fraccin
de cada objeto
2: X [i] 0
3: fin para
4: pesoActual 0
5: j n
6: mientras pesoActual < C Y j > 0 hacer
7: si pesoActual + p[j] C entonces
8: X [j] 1.0
9: si no
10: X [j] (C pesoActual)/p[j]
11: fin si
12: pesoActual pesoActual + p[j] X [j]
13: j j 1
14: fin mientras
15: devolver X
Problema de la Mochila sin fraccionamiento
Enunciado
Se dispone de una mochila de capacidad C y n objetos. Cada objeto ni
tiene un peso positivo pi y un valor positivo vi . El objetivo es llenar la
mochila maximizando el valor de los objetos transportados pero
respetando la limitacin de su capacidad C (peso mximo que puede
transportar).
Se supone que los objetos no se pueden dividir en trozos mas pequeos, es
decir, o se aade el objeto entero a la mochila o no se aade
Formalizacin (0,1)
Maximizar ni=1 xi vi tal que ni=1 xi pi C
P P
con pi > 0, vi > 0 y xi = 1 o xi = 0 para 0 i 1
Problema de la Mochila sin fraccionamiento

El esquema voraz no funciona
Ejemplo: mochila de capacidad 6 Kg y tres objetos

C = {(5kg, 11), (3kg, 6), (3Kg, 6)}
Funcin de seleccin: elegimos en cada fase el objeto cuya relacin
valor/peso sea mejor
ENTRADA
1 2 3
p 3 3 5
v 6 6 11
v/p 2,0 2,0 2,2
SOLUCIN
pesoMochila = 5 < 6
1 2 3
valorMochila = 11
X 0 0 1
El algoritmo voraz solo incluir en la mochila el primer objeto con un

beneficio de 11.
Existe una solucin mejor! Introducir los dos ltimos (juntos no
superan la capacidad mxima de la mochila) y se obtiene un beneficio
mayor (12)
Esta ejemplo demuestra que no siempre se consigue una solucin
ptima!!
Observaciones
Si se utiliza un algortimo voraz para encontrar soluciones ptimas

Debe demostrarse que el algoritmo encuentra la solucin ptima en
todos los casos
La demostracin puede ser muy complicada
Se puede optar con contraejemplos para demostrar que no proporciona
la solucin ptima (ejemplo mochila sin fraccionamiento)
An no garantizando la mejor solucin, los algoritmos voraces pueden
ser tiles, pueden encontrar soluciones muy aproximadas a las ptimas
Esquemas Algortmicos Rastreo Inverso o Backtraking
Detalles del tema
Introduccin
Esquema Voraz
3. Tcnica de rastreo inverso

Propiedades y esquema Backtraking
Bsqueda sistemtica de una solucin en un espacio de propuestas

posibles de solucin
Permite generar todas las soluciones siempre que sean susceptibles de
resolverse en etapas. Muy ineficiente
Esquema opuesto al voraz
Voraz: un candidato se acepta o se rechaza y no se deshace ninguna
decisin tomada
Backtraking: se aaden y eliminan candidatos a la solucin probando
todas las combinaciones
El problema de las ocho reinas

Consiste en situar las ocho reinas en un tablero de ajedrez de modo que no
se amenacen entre ellas. Deben situarse en distinta fila, columna y
diagonal
12 soluciones distintas
El problema de las 8 reinas tiene 92
soluciones pero solo 12 de ellas son
distintas. El resto puede obtenerse
mediante simetras y rotaciones de
estas 12 soluciones
El problema de las 8 reinas

Posibles soluciones
Solucin evidente. Probar sistemticamente todas las formas de

colocar las ocho reinas en un tablero Nmero de ensayos a realizar
64
( 8 = 4.426.165.368)
Primera mejora. Colocar una reina por fila. Todava puede haber
dos reinas en la misma columna!
Segunda mejora. Colocar una reina por fila y columna Siguen
siendo demasiados ensayos a realizar(8! = 42.320)
Problema fundamental: no se comprueba si la situacin es correcta
hasta el final
Solucin. Rastreo inverso o backtraking
Cada reina en una columna (reina i en la columna i para 1 i 8)
En cada nivel probar las formas de colocar la i-sima reina de la
columna i, desde la primera fila hasta la octava
Si se encuentra una posicin vlida para situar la reina i en la columna
i se avanza para colocar la siguiente reina (siguiente nivel), en caso
contrario se retrocede al nivel anterior
Problema de las 8 reinas

Estrategia grficamente mediante backtraking
Problema de las ocho reinas

Observaciones
Se trata de encontrar soluciones a problemas especficos sin seguir

una regla fija de clculo, sino por ensayo y error (tanteo)
Proceso de ensayo y bsqueda que, poco a poco, construye y rastrea
un rbol de soluciones, descartando (podando) aquellas ramas que
no conducen a la solucin del problema global
Problema de las ocho reinas:
Se parte de un ensayo neutro (no hay reinas en el tablero)
Ensayar las formas de colocar la i-sima reina de la columna i, desde la
primera fila hasta una fila no amenazada o no ms filas
Si el ensayo encuentra posicin segura, colocar la reina i y ensayar con
la reina i+1. El ensayo se extiende al siguiente nivel
Si no se encunentra posicin segura para la reina i, retroceder y seguir
ensayando con la reina i-1. El ensayo retrocede al nivel anterior
Continuar ensayando hasta tener xito o hasta que no haya
posibilidades de extensin (no hay ms filas vlidas en columna i)
rbol de soluciones
Formalizacin tcnica backtraking

(rastreo inverso, vuelta atrs, bsqueda con retroceso )
Definicin
Consiste en construir la solucin de un problema mediante ensayos
parciales de solucin
Formalizacin solucin
Se parte del ensayo neutro [ ] o y se van construyendo ensayos
parciales
En cada etapa intermedia del proceso, se tiene un ensayo parcial
[x1 , x2 , ..., xi1 , xi ] y se tantea sistemticamente con cada posibilidad
xi+1 de extender el ensayo
Si [x1 , x2 , ..., xi1 , xi , xi+1 ] es un ensayo aceptable se extiende y se
contina con este ltimo ensayo parcial
Si ninguna de las posibilidades para xi+1 hacen que el ensayo
[x1 , x2 , ..., xi1 , xi , xi+1 ] sea aceptable, significa que [x1 , x2 , ..., xi ] no es
extensible a solucin y hay que retroceder al ensayo anterior, se retira
la ltima opcin xi y se contina con el ensayo parcial anterior
[x1 , x2 , ..., xi1 ]
Esquema general PRIMERA solucin vlida
Algoritmo 5.14 ensayar(referencia E : conjunto; referencia exito : l ogico)
Entrada: E estado actual de la solucin (ensayo parcial), exito fin de la recursividad

Salida: E conjunto solucin al problema
1: P soluciones parciales candidatas
2: xito falso
3: repetir
4: p siguienteSolucinParcial(P)
5: si esAceptable(E p) entonces
6: E E p ->Registrar solucin parcial
7: si solucin(E ) entonces
8: xitocierto ->Devuelve primera solucin
9: si no
10: ensayar(E,xito) ->Ensayar siguiente nivel
11: si not xito entonces
12: E E p ->Eliminar solucin arcial
13: fin si
14: fin si
15: fin si
16: hasta que xito OR P = ->Solucin o no mas parciales
El parmetro xito se actualiza a verdadero cuando se encuentra solucin (fin de la recursividad) y fin del blucle
Esquema general TODAS las soluciones vlidas

Puede utilizarse para encontrar la solucin ptima
Se elimina el parmetro xito (las vueltas recursivas y el bucle contina
para encontrar todas las soluciones!!! Si existen, claro!!!)
Algoritmo 5.15 ensayar(referencia E : conjunto)
Entrada: E estado actual de la solucin

1: P soluciones parciales candidatas
2: repetir
3: p siguienteSolucinParcial(P)
4: si esAceptable(E p) entonces
5: E E p ->Registrar solucin parcial
6: si solucin(E ) entonces
7: gestionar solucin E obtenida ->Optima?
8: si no
9: ensayar(E) ->Ensayar siguiente nivel
10: fin si
11: E E p ->Eliminar solucin parcial
12: fin si
13: hasta que P = ->No ms parciales
Instanciacin: PRIMERA solucin vlida problema ocho reinas

Cada ensayo coloca la reina i en una fila de la columna i
Algoritmo 5.16 ensayarReina(i : entero; referencia exito : l ogico)
Entrada: i reina a colocar, exito fin de la recursividad

Salida: exito pasado por referencia: fin de la recursividad
1: P fila 1 a fila 8 de la columna i
2: xito falso
3: repetir
4: fila siguiente fila en columna i
5: si esAceptable(fila,i) entonces
6: colocar Reina i en fila ->Extiende ensayo parcial
7: si i=8 entonces
8: xito cierto ->Devuelve primera solucin
9: si no
10: ensayarReina(i+1,xito) ->Ensayar siguiente nivel
12: eliminar Reina i de fila ->Retrocede ensayo anterior
13: fin si
14: fin si
15: fin si
16: hasta que xito OR (no ms filas en columna i) ->P =
Refinando el esquema
Cuestiones a resovler:
Representacin de los datos: tablero, reinas, posiciones y solucin
Implementacin de las reglas (depende de la represenacin de los
datos): posicin vlida o no, colocar o eliminar una reina de una
posicin,...
Primera idea, utilizar una matriz cuadrada para representar las ocho
reinas sobre el tablero. Esta alternativa "sencilla" complica las
operaciones de colocar|eliminar una reina en|de una posicin
Colocar una reina supone marcar como no vlidas todas las casillas que
amenza (columna, fila y diagonal que se cruzan con posicin reina)
Eliminar una reina de una posicin supone marcar vlidas todas las
posiciones que su colocacin hizo invlidas
Segunda idea, ms refinada, se basa en que cada reina debe ocupar
una fila y una columna que no puede coincidir con filas y columnas
ocupadas por otras reinas
Ocho Reinas. Representacin

Segunda alternativa
Para represenar la solucin basta con un vector de 8 celdas: el ndice

del vector representa la reina i de la columna i y el contenido de la
celda la fila que ocupa: x[1..8]. El ndice representa tanto a la reina
como a la columna del tablero
Para representar las filas ocupadas basta con una matriz de 8 celdas
de tipo lgico: a[1..8]
Para representar las 15 diagonales principales y las 15 diagonales
transversales, basta con dos matrices de 15 celdas de tipo lgico,
teniendo en cuentas que:
Si se restan las coordenadas de las celdas que forman una diagonal se
obtiene un valor entero igual para todas las celdas: b[-7,..,7]
Si se suman las coordenadas de las celdas que forman una diagonal
transversal se obtien un valor entero igual para todas ellas: c[2,..,16]
Representacin
Representacin SOLUCIN
1 2 3 4 5 6 7 8
x fila R1 fila R2 fila R3 fila R4 fila R5 fila R6 fila R7 fila R8 solucin

1 2 3 4 5 6 7 8
a V|F V|F V|F V|F V|F V|F V|F V|F filas libre|ocupadas
-7 -6 -5 -4 -3 -2 -1 0 1 2 3 4 5 6 7
b V|F V|F V|F V|F V|F V|F V|F V|F V|F V|F V|F V|F V|F V|F V|F
2 3 4 5 6 7 8 9 10 11 12 13 14 15 16
c V|F V|F V|F V|F V|F V|F V|F V|F V|F V|F V|F V|F V|F V|F V|F
Operaciones segn representacin

Reina i en casilla (j,i)?
(j,i) es posicin segura ? Ninguna reina en misma fila, columna o

digonal. Es segura si
a[j] verdadero Fila libre
b[i-j] verdadero Diagonal de la casilla (j,i) no amenazada
c[i+j] verdadero Diagonal transversal de la casilla (j,i) no amen
Si (j,i) es posicin segura, colocar la reina i-sima en la fila j:
x[i] j Colocar Reina i en casilla (j,i)
a[j] falso Ocupar fila
b[i-j] falso Ocupar diagonal de la casilla(j,i)
c[i+j] falso Ocupar diagonal transversal de la casilla(j,i)
Si retroceso, eliminar la reina i-sima de la fila j:
a[j] verdadero Liberar fila j
b[i-j] verdadero Liberar diagonal de la casilla(j,i)
c[i+j] verdadero Liberar diagonal transversal de la casilla(j,i)
Pseudocdigo 8 reinas Primera Solucin vlida
Algoritmo 5.17 ensayarReina(i:entero; referencia xito:lgico;

referencia x [1, . . . , 8] : entero;
referencia a[1, . . . , 8], b[7 . . . , 7], c[2..16]: lgico)
Entrada: i reina a colocar, exito fin de la recursividad, x matriz de soluciones, a, b, c matrices que representan filas y diagonales.
Salida: exito pasado por referencia: fin de la recursividad e indica si ha tenido xito o no en la bsqueda de la solucin,
x matriz con las soluciones
1: j 0
2: xito falso
3: repetir
4: j j+1 ->siguiente solucin parcial
5: si a[j] and b[i-j] and c[i+j] entonces
6: x[i] j ->Reina i en fila j
7: a[j] b[i-j] c[i+j] falso
8: si i=8 entonces
9: xitocierto ->Devuelve primera solucin
10: si no
11: ensayarReina(i+1,xito,x,a,b,c) ->Avanzar
13: a[j] b[i-j] c[i+j] cierto ->Retroceder
14: fin si
15: fin si
16: fin si
17: hasta que xito OR j = 8
Pseudocdigo 8 reinas TODAS las soluciones vlidas
Algoritmo 5.18 ensayarReina(i:entero; referencia x [1, . . . , 8] : entero;

referencia a[1, . . . , 8], b[7 . . . , 7], c[2..16]: lgico)
1: para j=1 hasta 8 hacer
2: si a[j] and b[i-j] and c[i+j] entonces
3: x[i] j ->Reina i en fila j
4: a[j] b[i-j] c[i+j] falso
5: si i=8 entonces
6: Gestionar solucin global obtenida
7: si no
8: ensayarReina(i+1,x,a,b,c) ->Avanzar
9: fin si
10: a[j] b[i-j] c[i+j] cierto ->Retroceder
11: fin si
12: fin para
rbol de expansin
La estrategia de backtraking equivale al recorrido en profundidad del
rbol expansin, rbol implcito (rbol de soluciones presentado en
transparencia 37) donde:
cada nodo se corresponde con un ensayo parcial
cada arista con una opcin de tanteo
cada nodo hoja con un ensayo NO extensible a solucin (poda) o
solucin
Aproximacin al anlisis de la eficiencia del algoritmo
Una aproximacin consiste en analizar el rbol de expansin obtenido

En un estado intermedio del proceso, depus de haber construido el
ensayo parcial [x1 , x2 , ..., xi1 , xi ], se tantea sistemticamente con
cada posibilidad xi+1 de extender el ensayo
1 Contar nmero de ensayos explorados
2 Analizar coste de calcular las posibilidades de extender cada ensayo y el
coste de generar cada nuevo ensayo
3 Analizar el coste de comprobacin de la aceptacin de un ensayo
El resultado ser una cota superior
Funcin de aceptacin de ensayos debe podar convenientemente
ramas del rbol de expansin para mejorar el rendimiento
La eficiencia y utilidad de estos algoritmos depende principalmente de
esta funcin (disminuye el nmero de ensayos explorados)
Observaciones sobre rastreo inverso y optimizacin
En el caso general del esquema de Rastreo Inverso o backtraking:

puede existir solucin o NO
la tcnica de todas soluciones (cuando hay varias) puede utilizarse para
resolver problemas de optimizacin (elegir la mejor de todas ellas)
El ejemplo de las ocho reinas es representativo de la tcnica de
backtraking en el cual se obtiene solucin (una o todas) pero NO es
un ejemplo de optimizacin (ninguna solucin es mejor que las dems)
Ejemplo de mochila sin fraccionamiento, capacidad 6 Kg y tres
objetos
C = {n1 , n2 , n3 } = {(5kg, 11), (3kg, 6), (3Kg, 6)}
Se propone como ejercicio generalizar el ejemplo a n-Reinas
Contenidos
2 Notacin asinttica

Tema 6. Tipos Abstractos de Datos
Contenidos
Introduccin
Listas
Nivel abstracto o de definicin
Nivel de representacin o de implementacin
Pilas
Colas
Tipos Abstractos de Datos Introduccin
Detalles del tema

Introduccin
Listas
Pilas
Colas
1 Introduccin
Dos conceptos fundamentales que comparten propiedades
Procedimiento, herramienta fundamental de la programacin

Generaliza el concepto de operador, aadiendo nuevos operadores a los
disponibles en el lenguaje de programacin utilizado
Encapsula partes de un programa, localizando en una seccin del
mismo todas las proposiciones que tienen importancia en relacin con
cierto aspecto de ste
Tipos Abstractos de Datos
Generalizacin de tipos bsicos o primitivos, de forma a anloga a
como los procedimientos son generalizaciones de los operadores bsicos
del lenguaje
Encapsulado de cierto tipo de datos, y de las operaciones disponibles
sobre los mismos, en una determinada seccin del programa
Fuera de la seccin donde se definen se utiliza como un tipo bsico
Un cambio en la implementacin del TAD slo implica la revisin de la
seccin donde est definido, junto con sus operaciones. Se evita que
otras partes del programa se vean afectados negativamene. Este
cambio, en un mundo perfecto, podra ser totalmente transparente
para el resto del programa
Tipo abstracto de datos (TAD)

Definicin y caractersticas
Definicin
Modelo matemtico con una serie de operaciones definidas sobre l
Ejemplo: Conjuntos de nmeros enteros con las operaciones de unin,

interseccin y diferencia
Se trata de una abstraccin, dado que en ningn momento se hace
referencia a cmo se implementan las operaciones. Se puede ver
como una extensin del diseo modular
Las operaciones pueden tener operandos que no pertenezcan al TAD
o incluso el resultado. Pero al menos un operando o el resultado de la
operacin pertenece al TAD
No hay ninguna regla que indique qu operaciones debe manejar cada
TAD, se trata de una decisin de diseo
Aspectos sobre la gestin de errores y excepciones son, tambin,
cuestiones a decidir en el diseo del TAD
Tipo de datos, TAD y Estructuras de datos

Tres trminos semejantes, con significado diferente
Tipo de datos
Define el conjunto de valores que puede tomar una variable
Los tipos de datos bsicos o primitivos son dependientes del lenguaje
de programacin
Tipo abstracto de datos (TAD)
Es un modelo matemtico, junto con varias operaciones definidas sobre
ese modelo
Generalmente, los algoritmos se implementan en funcin de los TAD,
sin embargo, el TAD se debe representar en funcin de los tipos y
operaciones bsicas del lenguaje de programacin
Para implementar el modelo matemtico de un TAD se emplean las
estructuras de datos
Estructuras de datos
Conjuntos de variables, del mismo o diferente tipo, conectadas entre s
de diferentes formas (matrices, registros, punteros, ...)
Creacin de Tipos Abstractos de Datos

Dos niveles:

Define el modelo matemtico del tipo de dato
Establece las propiedades que deben cumplir los elementos que
formarn parte del modelo
Define todas las operaciones que se podrn realizar sobre los elementos
del modelo. El nmero de operaciones, la naturaleza de las mismas y la
gestin de errores son decisiones que corresponden al diseador del
TAD
Representacin, realizacin o nivel de implementacin: codificacin
del TAD en el lenguaje de programacin escogido, teniendo en cuenta
aspectos como la eficiencia o el consumo de memoria
Elegir la estructura o estructuras de datos necesarias, que permitan
representar adecuadamente lo elementos del TAD, utilizando
adecuadamente los tipos y mecanismos proporcionados por el lenguaje
de programacin
Implementar las operaciones definidas en el nivel anterior. Cada
operacin se traduce, habitualmente, en un procedimiento o funcin
Especificacin e implementacin
Especificacin de un TAD: consiste en establecer las propiedades que

los definen, es decir, su modelo matemtico
Implementacin de un TAD:
determinar una representacin (estructura de datos) para los valores
del tipo
codificar sus operaciones a partir de esta representacin
El cambio de una implementacin por otra no debe cambiar la
especificacin
La manipulacin de los objetos de un tipo depende de su
especificacin no de su implementacin
Tipos Abstractos de Datos Listas
Detalles del tema

Introduccin
Listas
Pilas
Colas
2 TAD Listas
2.1 Nivel abstracto o de definicin
Definicin
Secuencia ordenada de cero o ms elementos de un determinado tipo de
dato a1 , a2 , a3 , . . . , an . El orden de los elementos est determinado por su
posicin en la secuencia, el elemento ai est en la posicin i
Propiedades:
El valor n representa el nmero de elementos de la lista, tamao o
longitud. Si n = 0 entonces la lista est vaca (lista nula)
a1 es el primer elemento
ai precede a ai+1 , para i = 1, 2, . . . , n 1
ai sucede a ai1 , para i = 2, 3, . . . , n
an es el ltimo elemento
Los elementos son accesibles y se pueden insertar y suprimir en
cualquier posicin de la lista
Conviene postular la existencia de una posicin que sucede a la del
ltimo elemento de la lista (funcin fin(l))
Caractersticas
Los elementos estn ordenados de forma lineal de acuerdo a sus

posiciones en la lista
Constituyen una estructura flexible, porque pueden crecer y decrecer
segn necesidades
Las listas se pueden dividir en sublistas o se pueden concatenar con
otras listas
Se presentan habitualmente en problemas de recuperacin de
informacin, traduccin de lenguajes de programacin, simulacin, ...
La definicin completa del TAD requiere la especificacin de las
operaciones que pueden realizarse con objetos del tipo
A continuacin se especifican las ms habituales (no se trata de un
listado completo ni genrico, ya que el conjuto adecuado de
operaciones depende de la aplicacin)
TAD Lista
Nivel abstracto o de definicin: especificacin de operaciones
inserta(x,p,l) Inserta el elemento x en la posicin p de la lista l, pasando los elementos de

la posicin p y siguientes a la posicin inmediata posterior
Si l es a1 , a2 , . . . , ap1 , ap , ap+1 , . . . , an pasa a ser
a1 , a2 , . . . , ap1 , x , ap , ap+1 , . . . , an
Si p es fin(l) entonces l se convierte en a1 , a2 , . . . , an , x
Si l no tiene posicin p, el resultado no est definido
localiza(x,l) Devuelve la posicin del elemento x en la lista l
Si aparece ms de una vez devuelve la posicin de la primera aparicin, y si no
aparece, devuelve fin(l)
recupera(p,l) Devuelve el valor almacenado en la posicin p de la lista l
El resultado no est definido si p es fin(l) o l no tiene posicin p
suprime(p,l) Elimina el elemento en la posicin p de la lista l, pasando los elementos de la
posicin p + 1 y siguientes a la posicin inmediata anterior
a1 , a2 , . . . , ap1 , ap+1 , . . . , an
Si p es fin(l) o l no tiene posicin p el resultado no est definido
primero(l) Devuelve la primera posicin de l
Si l est vaca, devuelve fin(l)
anula(l) Convierte la lista l en una lista vaca y devuelve la posicin fin(l)
Ms operaciones y Ejemplo de aplicacin del TAD Lista

Eliminacin de elementos repetidos en una lista
siguiente(p,l), anterior(p,l) Devuelven las posiciones siguiente y anterior,

respectivamente, a p en la lista l
Si p es la ltima posicin de l, siguiente(p,l) devuelve fin(l)
Si p es fin(l) siguiente(p,l) no est definida
Si p es la posicin 1 de l anterior(p,l) no est definida
Si no existe la posicin p en l, ambas funciones no estn definidas
imprimeLista(l) Imprime los elementos de l en su orden de aparicin
Algoritmo 6.1 purga(referencia l : tipoLista)

Entrada: l la lista de elementos
Salida: l la lista sin elementos repetidos
1: act, sig : tipoPosici on
2: act primero(l)
3: mientras act 6= fin(l) hacer
4: sig siguiente(act, l)
5: mientras sig 6= fin(l) hacer
6: si sonIguales(recupera(act, l), recupera(sig, l)) entonces
7: suprime(sig, l)
8: si no
9: sig siguiente(sig, l)
10: fin si
11: fin mientras
12: act siguiente(act, l)
13: fin mientras
2.2 Implementacin del TAD Lista

Nivel de representacin
Una vez se ha especificado el TAD, llega el momento de concretar

cmo se construye.
Se distinguen principalmente dos tipos de implementacin :
Mediante matrices o memoria contigua
Mediante punteros o memoria dinmica y dispersa
Listas enlazadas sin nodo ficticio (Programacin II)
Listas enlazadas con nodo ficticio
Listas doblemente enlazadas, circulares, ...
Se deben implementar todas las operaciones previamente a la
utilizacin del TAD en un programa como purga
La interfaz de tipoLista, es decir, las definiciones de las funciones,
debera, en un mundo perfecto, ser la misma para las distintas
implementaciones
2.2.1 Implementacin mediante matrices

Memoria contigua
Los elementos se almacenan en celdas contiguas de una matriz
Algoritmo 6.2 declaraciones bsicas

1: constantes
2: MAX = 100
3: tipos
4: tipoLista = registro
5: elementos : matriz[1, . . . , MAX ] de tipoElemento
6: ultimo : entero
7: fin registro
8: tipoPosici on = entero
Permite recorrer la lista con facilidad y agregar nuevos elementos al final

Insertar un nuevo elemento en mitad de la lista obliga a realizar un desplazamiento
de todos los elementos a partir de la posicin de insercin
Anlogo problema para suprimir un elemento, excepto el ltimo
Implementacin operacin inserta(x,p,l)

Recordamos la especificacin
Inserta el elemento x en la posicin p de la lista l, pasando los elementos de la posicin p y
siguientes a la posicin inmediata posterior
Si l es a1 , a2 , . . . , ap1 , ap , ap+1 , . . . , an pasa a ser a1 , a2 , . . . , ap1 , x , ap , ap+1 , . . . , an
Algoritmo 6.3 inserta(x:tipoElemento; p:tipoPosicin; referencia l:tipoLista)
Entrada: x valor a insertar y p la posicin en la lista l

Salida: la lista l con x insertado en la posicin p
1: q : tipoPosici on
2: si l.ultimo MAX entonces
3: implementar segn especificacin y diseo ->"lista llena"
4: si no, si p > l.ultimo + 1 O p < 1 entonces
5: implementar segn especificacin y diseo ->"la posicin no existe"
6: si no
7: para q l.ultimo hasta p con incremento = 1 hacer
8: l.elementos[q + 1] l.elementos[q]
9: fin para
10: l.ultimo l.ultimo + 1
11: l.elementos[p] x
12: fin si
Implementacin operaciones fin(l) y localiza(x,l)

Devuelve la posicin que sucede al ltimo elemento de la lista l
Algoritmo 6.4 fin(referencia l : tipoLista)
Entrada: la lista l
Salida: posicin que sucede a la del ltimo elemento de la lista
1: devolver l.ultimo + 1
Devuelve la posicin del elemento x en la lista l
Si aparece ms de una vez devuelve la posicin de la primera aparicin, y
si no aparece, devuelve fin(l)
Algoritmo 6.5 localiza(x : tipoElemento; referencia l : tipoLista)
Entrada: x valor a localizar en la lista l

Salida: la posicin del valor x en la lista l, y si no existe, fin(l)
2: para q 1 hasta l.ultimo hacer
3: si l.elementos[q] = x entonces
4: devolver q
5: fin si
6: fin para
7: devolver l.ultimo + 1
Implementacin operacin suprime(p,l)

Elimina el elemento en la posicin p de la lista l, pasando los elementos
de la posicin p + 1 y siguientes a la posicin inmediata anterior
a1 , a2 , . . . , ap1 , ap+1 , . . . , an
Si p es fin(l) o l no tiene posicin p el resultado no est definido
Algoritmo 6.6 suprime(p : tipoPosici on; referencia l : tipoLista)
Entrada: la posicin p del valor a suprimir de la lista l

Salida: la lista l sin el valor que estaba en la posicin p
2: si p l.ultimo + 1 O p < 1 entonces
3: implementar segn especificacin y diseo ->"la posicin no existe"
4: si no
5: l.ultimo l.ultimo 1
6: para q p hasta l.ultimo hacer
7: l.elementos[q] l.elementos[q + 1]
8: fin para
9: fin si
El resto de operaciones se implementan de manera anloga

2.2.2 Implementacin mediante punteros

Memoria dinmica dispersa
Los elementos se almacenan en nodos o celdas sencillas, utilizando

punteros para enlazar elementos consecutivos
Las celdas o nodos correspondientes a elementos consecutivos en la
lista no tienen que estar en posiciones consecutivas de memoria
Se evitan los desplazamientos de elementos de la lista en las
operaciones de insercin y supresin. El precio: la memoria adicional
ocupada por los punteros
En esta representacin, cada celda contiene:
un elemento de la lista
un apuntador a la celda con el siguiente elemento de la lista
Listas enlazadas simples

Dos opciones: sin|con nodo ficticio
Si la lista es a1 , a2 , . . . , an , la celda que contiene el elemento ai tiene la direccin a la

celda que contiene el elemento ai+1 , para i = 1, 2, . . . , n 1
La celda que contiene el ltimo elemento, an , posee un apuntador nulo (no apunta a celda
alguna)
El primer nodo de la lista enlazada puede ser:
el nodo que contiene el primer elemento de la lista sin nodo ficticio
un nodo que no contiene ningn elemento de la lista pero tiene la direccin del
primer elemento de la lista o direccin nula si la lista est vacia con nodo
ficticio, falso o de encabezamiento
En los dos casos las declaraciones bsicas son las mismas y cualquier variable de tipo lista
precisa la direccin de la primera celda: encabezamiento o raz
Declaraciones bsicas
Iguales se utilice o no nodo ficticio

1: tipos
2: tipoCelda = registro
3: elemento : tipoElemento
4: sig : tipoCelda
5: fin registro
6: tipoPosici on = tipoCelda
7: tipoLista = tipoCelda
La definicin de posicin cambia respecto a la representacin con matrices, no ser un

ndice, ser un puntero a la celda que contiene el elemento
La funcin fin(l) no puede seguir siendo como en la implementacin con matrices, ya
que no existe la posicin que sucede a la del ltimo elemento de la lista. Alternativas:
Devolver la direccin del ltimo nodo de la lista enlazada cambio de la interfaz
Devolver siempre el puntero NULO puede dar lugar a problemas de interpretacin
en otras funciones de la interfaz
Las declaraciones bsicas sin|con nodo ficticio son las mismas, sin embargo:
La lista vaca es diferente
El concepto de posicin es diferente
La implementacin de las operaciones vara ligeramente!!!
Diferencias sin|con nodo ficticio

Sin nodo ficticio
Posicin pi puntero a la celda que contiene el elemento ai de la lista (Definicin ambigua...que da lugar a diferentes
cosideraciones y quiz problemas ...insertar o suprimir antes o despus de pi )
Variable de tipoLista: puntero miLista a la celda que contiene el elemento a1 de la lista
Lista vaca (miLista = NULO)
Con nodo ficticio
Posicin pi puntero a la celda que contiene, en su campo sig, la direccin o puntero de la celda que almacena el
elemento ai de la lista
Variable de tipoLista: puntero miLista al nodo ficticio de la lista
Lista vaca (miLista .sig = NULO)
Operacin inserta sin nodo ficticio

Inserta en posicion anterior a p
Inserta el elemento x en la posicin p de la lista l, pasando los elementos de la posicin p y
siguientes a la posicin inmediata posterior
Si l es a1 , a2 , . . . , ap1 , ap , ap+1 , . . . , an pasa a ser a1 , a2 , . . . , ap1 , x , ap , ap+1 , . . . , an
Algoritmo 6.8 inserta(x:tipoElemento; p:tipoPosicin; referencia miLista:tipoLista)
1: temp nuevaCelda()
2: si temp = NULO entonces
3: tratar excepcin segn diseo ->no hay memoria!
4: si no
5: temp .elemento x
6: si p = miLista entonces
7: temp .sig = miLista ->la primera posicin es epecial!
8: miLista = temp
9: si no
10: previo miLista
11: mientras (previo 6= NULO) Y(previo .sig 6= p) hacer
12: previo previo .sig ->la ltima posicin es epecial!
13: fin mientras
14: si previo 6= NULO entonces
15: temp .sig = previo .sig
16: previo .sig = temp
17: fin si
18: fin si
19: fin si
Observaciones
Justificacin del nodo ficticio
Se corresponde con la especificacin dada para esta operacin

Pero ...
La primera posicin debe tratarse de forma especial y obliga a pasar
por referencia el parmetro lista!!!
Para poder aadir elementos al final de la lista, la ltima posicin se
trata de forma especial (NULO)!!!
La funcin fin(l) no se ajusta a la especificacin (el nivel de
abstraccin se resiente!)
Despus de la insercin del elemento x en la posicin p ...
el parmetro p ya no representa la posicin p!!!
Qu pasa si la posicion p no esta en la lista?
Soluciones
1 Descender un nivel de abstraccin y especificiar una interfaz con
funciones ms cercanas a la implementacin
(insertarAntesDePosicin, insertarDespuesDePosicion,
insertarComienzo, insertarFinal...visto en asignatura de Programacin
II)
2 Utilizar Nodo Ficticio
Operacin inserta con nodo ficticio

Nueva definicion de posicin: inserta en posicin p
Algoritmo 6.9 inserta(x : tipoElemento; p : tipoPosici on)

Entrada: x valor a insertar en la posicin p de la lista miLista
Salida: la lista miLIsta, con el valor ya insertado
1: temp : tipoPosici on
4: tratar excepcin segn diseo ->no hay memoria!
5: si no
6: temp .elemento x
7: temp .sig p .sig
8: p .sig temp
9: fin si
Observaciones
Definicin de posicin con nodo ficticio
Se corresponde con la especificacin dada para esta operacin

Despus de la insercin del elemento x en la posicin p el parmetro p sigue
representando la posicin p!!!
El nodo ficticio junto con la nueva definicin de posicin evita el tratamiento de
posiciones especiales (inicio y fin)
No es necesario pasar el parmetro tipoLista por referencia (nunca se modifica!!)
Se recupera la definicin de la posicin fin(l) dada en la especificacin
No es necesario el recorrido de la lista para insertar en la posicin p. Pero ...Qu pasa si
la posicin p no est en la lista? Depende de cmo el usuario utilice el TAD!
Importante nueva definicin de posicin

La posicin i es el puntero al nodo que contiene, en su campo sig, la direccin o puntero al
nodo que almacena el valor ai , es decir:
la posicin del valor ai ser el puntero al nodo que contiene ai1 para i = 2, 3, 4, . . . , n
la posicin de a1 ser el puntero al nodo cabecera o nodo ficticio
la posicin fin(l) es el puntero al ltimo nodo de la lista enlazada, es decir, el nodo que
contiene el valor an . Importante, la posicin del valor an es un puntero al nodo que
contiene an1 , por lo tanto, la posicin fin(l) no corresponden a valor alguno de la lista,
de forma anloga a como sucede con la implementacin mediante matrices. Se recupera
la definicin de la interfaz.
Si la lista est vaca fin(l) devolver la direccin del nodo ficticio
Con estas definiciones y consideraciones se consigue una implementacin ms fiel a la

definicin de la interfaz, similar a la que se realiz con matrices y se simplifica cdigo de
muchas de las funciones
Operacin suprime con nodo ficticio

Procedimiento suprime el valor en la posicin p
Algoritmo 6.10 suprime(p : tipoPosici on)

Entrada: posicin p del valor a eliminar de la lista miLista
Salida: la lista miLista, con el valor ya suprimido
1: aBorrar : tipoPosici on
2: aBorrar p .sig
3: p .sig aBorrar .sig
4: liberaNodo(aBorrar )
Las observaciones hechas en la operacin inserta pueden trasladarse a la

operacin suprime
Otras funciones de listas enlazadas con nodo ficticio

Algoritmo 6.11 localiza(x : tipoElemento; miLista : tipoLista)
Entrada: valor x a encontrar en la lista miLista
Salida: la posicin del valor x en miLIsta si existe, fin(miLista) si no est
2: q miLista
3: mientras q .sig 6= NULO hacer
4: si q .sig .elemento = x entonces
5: devolver q
6: fin si
7: fin mientras
8: devolver q
Algoritmo 6.12 anula(x : tipoElemento; miLista : tipoLista)

Entrada: la lista miLista
Salida: la lista miLista vaca, es decir, slo con nodo ficticio
1: q, aBorrar : tipoPosici on
2: q miLista .sig
3: miLista .sig NULO
4: mientras q 6= NULO hacer
5: aBorrar q
6: q q .sig
7: liberaNodo(aBorrar )
8: fin mientras
La operacin anula se simplifica con la utilizacin del nodo ficticio No es

necesario pasar por referencia el parmetro miLista! Nunca se modifica!
Implementacin funcin fin(l)

Listas simplemente enlazadas con nodo ficticio
Devuelve la posicin que sucede al ltimo elemento de la lista
Algoritmo 6.13 fin(miLista : tipoLista)
Entrada: Puntero al primer nodo, miLista, representa la lista

Salida: puntero ltimo nodo de la lista enlazada
1: aux : tipoPosici on
2: aux miLista
3: mientras aux .sig 6= NULO hacer
4: aux aux .sig
5: fin mientras
6: devolver aux
La funcin fin(l) implica un recorrido lineal de la lista enlazada (O(n)). Si se

observa el algoritmo purga ( 6.1 ) muy ineficiente

Ventajas del nodo ficticio junto con definicin de posicin
Se simplifica el cdigo de algunas operaciones

Facilita la insercin/supresin de valores en cualquier posicin de la lista, sin bajar
el nivel de abstraccin
inserta y suprime no necesitan el parmetro miLista de tipoLista
anula necesita el parmetro miLista pero no es necesario pasarlo por referencia
El argumento que se pasa a travs del parmetro p queda apuntando al valor
esperado de la lista en inserta y suprime
Se evitan recorridos innecesarios en las operaciones inserta y suprime (se pueden
incluir recorridos (algoritmo 6.14) para hacer estas operaciones ms robustas y no
depender del usuarios del TAD equilibrio entre eficiencia y seguridad!
Algoritmo 6.14 inserta(x : tipoElemento; p : tipoPosicion; miLista : tipoLista)

3: tratar excepcin
4: si no
5: temp .elemento x
6: aux miLista
7: mientras (aux 6= NULO AND aux 6= p) hacer
8: aux aux .sig
9: fin mientras
10: si aux = p entonces
11: temp .sig = p .sig
12: p .sig = temp
13: si no
14: tratar excepcin ->no hay posicion p en la lista l !!!
15: fin si
16: fin si

Observaciones
nico coste para obtener todos estos beneficios consumo extra de

memoria del nodo ficticio
Problema por resolver ineficiencia de la funcin fin(l) que
depende del tamao de la lista
Solucin: utilizar una estructura para representar el tipoLista con
dos punteros, uno al nodo ficticio, y otro al ltimo nodo de la lista
enlazada (fin(l)), pero esto complica ligeramente las operaciones
vistas
Observaciones
Qu implemetacin elegir?
El uso de listas enlazadas, en general, aporta flexibilidad, las listas

crecen o disminuyen segn vara su tamao. No es necesario decidir el
tamao mximo en momento de compilacin.
La eleccin entre una implementacin u otra (matricies, listas
simplemente enlazadas con|sin nodo ficticeo, doblemente enlazadas,
circulares ,...) depender de diversos factores:
Operaciones que se deben realizar
Operaciones que se van a utilizar ms frecuentemente
Tamao que puede alcanzar una variable de tipoLista. Se conoce el
tamao mximo en tiempo de compilacin? Diferencia entre este
tamao mximo y la ocupacin del mismo en promedio!
En general, se debe utilizar la implementacin que ofrezca una mayor
eficiencia, es decir, que evite recorridos en las operaciones utilizadas
(que sean de O(1)), aunque implique consumir algo ms de memoria
Tipos Abstractos de Datos Pilas
Detalles del tema

Introduccin
Listas
Pilas
Colas
3 TAD Pila
Tipo especial de lista con la restriccin de que

las inserciones y eliminaciones slo pueden
realizarse en una posicin, denominada tope o
cima de la lista
Se trata de una lista de tipo LIFO (Last In,
First Out):existe un elemento en la cima de la
pila que es el nico visible o accesible (siempre
que no est vaca)
Las operaciones bsicas que tipicamente
incluye un TAD pila son: inserta, suprime,
creaVaca, vaca y tope. Esta ltima a veces se
implementa dentro de suprime y en ese caso,
no se utiliza.
TAD Pila: epecificacin de operaciones
creaVaca(p) Inicia o crea la pila p como una pila vaca, sin ningn
elemento
tope(p) Devuelve el valor del elemento del tope o cima de la pila p.
No siempre utilizada
suprime(p) Elimina el elemento del tope o cima de la pila.
Generalmente, adems de eliminarlo, tambin devuelve el
valor almacenado en esa posicin. En este caso la operacin
tope(p) no se utiliza
inserta(x, p) Aade el elemento x en la posicin a continuacin del
tope o cima pasando a ser este el nuevo tope o cima de la
pila
vaca(p) Devuelve verdadero si la pila p est vaca, y falso en caso
contrario
Observaciones
Gestin de errores y uso
Eliminar un elemento de una pila vaca se considera un error en el uso

del TAD. Responsabilidad del usuario del TAD, debe utilizar la
funcin vacia(p)
Quedarse sin espacio al insertar un elemento es un error de
implementacin y no utilizacin del TAD. Responsabilidad del
programador que ha implementado el TAD
La poltica de insercin/extraccin de este TAD, resulta muy til para
resolver gran variedad de problemas de tratamiento de la informacin,
as como matemticos, estadsticos o financieros
Ejemplo de utilizacin de pilas: equilibrio de smbolos en el anlisis de
expresiones en los compiladores o intrpretes
Equilibrio de smbolos en expresiones matemticas
Se trata de comprobar que los smbolos que aparecen en la expresin estn
abiertos y cerrados y equilibrados. Para todo smbolo que abre debe
aparecer en el orden correcto el correspondiente smbolo que cierra:
la secuencia [[{()}]] es legal
la secuencia [[{(})]] es ilegal
Ejemplo de uso TAD pila definido

Equilibrio de smbolos
Algoritmo 6.15 Equilibrio de smbolos
1: miPila : tipoPila
2: car acter , car acter 2 : tipoCar acter
3: creaVacia(miPila)
4: car acter leerCar acter (fichero)
5: mientras car acter 6= EOF hacer
6: si car acter {0 [0 ,0 {0 ,0 (0 } entonces
7: inserta(car acter , miPila)
8: si no
9: si vac ia(miPila) entonces
10: error ("no hay correspondencia)
11: si no
12: car acter 2 suprime(miPila)
13: si car acter 6= cierre de car acter 2 entonces
15: fin si
16: fin si
17: fin si
18: car acter leerCar acter (fichero)
19: fin mientras
20: si NO vac ia(miPila) entonces
22: fin si
3.2 Implementacin TAD Pila

Mediante matrices
Los elementos se almacenan en celdas contiguas de una matriz
Todo lo visto en listas utilizando matrices para su implementacin es
vlido para pilas. Una pila no deja de ser caso particular de Lista
Esta reperesentacin requiere conocer el tamao de la matriz en
tiempo de compilacin
Es la mejor opcin si el tamao mximo de las variables pila no es muy
elevado. En caso contrario, la mejor opcin es una lista enlazada
Mediante punteros (listas enlazadas)
Si no se conoce en tiempo de compilacin la cantidad de memoria
necesaria, o el tamao mximo a ocupar
Si la diferencia entre el tamao mximo necesario y el ocupado
realmente es muy elevada
Al realizar las inserciones y supresiones de valores por un nico extremo
de la lista, la implementacin mediante listas simplemente enlazadas es
muy sencilla
Fundamental realizar comprobacin de errores, aunque resulten
redundantes y parezca que se consume ms tiempo en esta tarea que
en las propias de manipulacin de la pila:
Nunca se debera poder sacar un elemento de una pila vaca
Sera conveniente que no se produjese un desbordamiento de pila
3.2.1 Implementacin TAD pila mediante matrices

Declaraciones bsicas y operacin inserta

1: constantes
2: MAX = 100
3: tipos
4: tipoPila = registro
5: elementos : matriz[1, ..., MAX ] de tipoElemento
6: tope : entero
7: fin registro
Algoritmo 6.17 inserta(x : tipoElemento; referencia p : tipoPila)

Entrada: El valor x a insertar y la pila p, pasada por referencia, donde se insertar
Salida: La pila p con el valor x como nuevo tope de la misma
1: si p.tope = MAX entonces
2: implementar segn especifiacin y diseo ->pila llena
3: si no
4: p.tope p.tope + 1
5: p.elementos[p.tope] x
6: fin si
Implementacin operaciones creaVaca y vaca
Algoritmo 6.18 creaVaca(referencia p : tipoPila)
Entrada: La pila p, pasada por referencia

Salida: La pila p vaca, sin elementos
1: p.tope = 0
Algoritmo 6.19 vaca(referencia p : tipoPila)
Entrada: La pila p, pasada por referencia por cuestiones de eficiencia

Salida: valor lgico verdadero si p est vaca, y falso si no lo est
1: si p.tope = 0 entonces
2: devolver VERDADERO
3: si no
4: devolver FALSO
5: fin si
Implementacin operaciones tope y suprime

Opcin 1: suprime elimina el elemento del tope pero no lo devuelve
Algoritmo 6.20 tope(referencia p : tipoPila)

Salida: El valor situado en el tope o cima de p
1: si vac ia(p) = VERDADERO entonces
2: implementar segn especifiacin y diseo ->pila vaca"
3: si no
4: devolver p.elementos[p.tope]
5: fin si
Algoritmo 6.21 suprime1(referencia p : tipoPila)

Salida: La pila p sin el valor que estaba en el tope o cima de la misma. El nuevo tope
pasa a ser el elemento anterior
2: implementar segn especifiacin y diseo ->pila vaca"
3: si no
4: p.tope p.tope 1
5: fin si
Implementacin operacin suprime

Opcin 2: suprime elimina y devuelve el tope. No se necesita operacin tope
Algoritmo 6.22 suprime(referencia p : tipoPila)

Salida: El valor que estaba situado en el tope de p, y que se elimina,
pasando a ser en nuevo tope el elemento anterior.
1: valor : tipoElemento
3: implementar segn especifiacin y diseo ->pila vaca
4: si no
5: valor p.elementos[p.tope]
6: p.tope p.tope 1
7: devolver valor
8: fin si
3.2.2 Implementacin TAD pila mediante listas enlazadas

Memoria dinmica dispersa
La forma ms eficiente y sencilla de implementar una pila es mediante

listas enlazadas sin|con nodo ficticio:
Se inserta y extrae siempre por el mismo lugar (tope) de la lista

enlazada desaparece el concepto de posicn y puede evitarse el
nodo ficticio
La utilizacin de nodo ficticio evita el paso por referencia de
variablePila
Tipos Abstractos de Datos Colas
Detalles del tema

Introduccin
Listas
Pilas
Colas
4 TAD Cola
Tipo especial de lista con la restriccin de que las inserciones se

realizan por un extremo de la lista denominado fondo y las
eliminaciones por el otro extremo, denominado frente
Se trata de una lista de tipo FIFO (First In, First Out), en las que el
primer elemento que entra es el primero en salir
Las operaciones tpicas que incluye un TAD cola son creaVaca, vaca,
inserta, suprime y frente. Dependiendo de la especificacin de
suprime, frente puede que no se necesite
TAD Cola: especificacin de operaciones
creaVaca(c) Inicia o crea la cola c como una cola vaca, sin ningn
elemento
frente(c) Devuelve el valor del elemento del frente de la cola c. No
siempre utilizada
suprime(c) Elimina el elemento del frente o primer elemento de la cola,
pasando a ser el nuevo frente el siguiente elemento.
Generalmente, adems de suprimirlo, tambin devuelve el
valor almacenado en esa posicin y no se utiliza la funcin
frente(c)
inserta(x, c) Aade el elemento x en la posicin a continuacin del
fondo, o ltimo elemento de la cola, pasando a ser el nuevo
fondo de la misma
vaca(c) Devuelve verdadero si la cola p est vaca, y falso en caso
contrario
Gestin de errores y uso

Gestin de errores:
Sacar o suprimir un elemento de una cola vaca se considera un error
en el uso del TAD. Responsabilidad del usuario del TAD, debe utilizar
la funcin vacia(c)
Quedarse sin espacio al realizar una introduccin de un elemento es un
error de implementacin o representacin y no de utilizacin del TAD.
Responsabilidad del programador que ha implementado el TAD
Existen situaciones en las colas son necesarias o tiles:
En Sistemas Operativos:
Colas de procesos, para recibir tiempo de UCP
Colas de impresin, mantienen los trabajos para ser impresos
Servidor de archivos, gestin de acceso de usarios a archivos
compartidos
Simulacin: estudio del comportamiento de varias o una nica cola
atendida/s por varios operadores (cajeros supermercado, etc.)
Comunicaciones: llamadas telefnicas en cola si todas las operadoras
estn ocupadas
4.2 Implementacin TAD Cola

De nuevo dos alternativas principales:

Mediante matrices (cirulares)
Mediante punteros (listas enlazadas)
Todo lo visto para pilas en cuanto a cundo utilizar una u otra es
vlido en la implementacin de colas
Todo los visto en la implementacin de pilas referente a control de
errores tambin es vlido para colas
4.2.1 Implementacin TAD cola mediante matrices

Consideraciones previas
Primera solucin: extraer por el frente (principio de la matriz) y aadir por

el fondo (posiciones finales de la matriz). Dado que la matriz tiene un
tamao finito puede darse la paradoja de cola vaca sin estarlo realmente,
ya que segn se van aadiendo elementos por el fondo, ste puede alcanzar
el lmite mximo de la matriz reservada
Segundo intento: realizar las extraciones por el frente pero desplazando una
posicin de los restantes elementos. Coste inaceptable
Solucin: implementacin como matriz circular donde frente y fondo pasan
al comienzo de la matriz cuando alcanzan el final de la misma
Implementacin TAD colas mediante matrices circulares

Declaraciones bsicas

1: constantes
2: MAX = 100
3: tipos
4: tipoCola = registro
5: elementos : matriz[1, . . . , MAX ] tipoElemento
6: frente, fondo, tamano: entero
7: fin registro
Algoritmo 6.24 incrementaIndice(referencia z : entero)

Entrada: El valor entero que representa el ndice o posicin en la cola a incrementar, pasado por referencia
Salida: El valor del ndice incrementado, siempre teniendo en cuenta que si es igual al lmite superior de la matriz pasar a apuntar
a la primera posicin
1: si z = MAX entonces
2: z 1
3: si no
4: z z+1
5: fin si
Implementacin de creaVaca y vaca
Algoritmo 6.25 creaVaca(referencia c : tipoCola)

Entrada: La cola c, pasada por referencia
Salida: La pila c vaca, sin elementos
1: c.tamano = 0
2: c.frente = 1
3: c.fondo = MAX
Algoritmo 6.26 vaca(referencia c : tipoCola)

Entrada: La cola c, pasada por referencia por cuestiones de eficiencia
Salida: valor lgico verdadero si c est vaca, y falso si no lo est
1: si p.tamano = 0 entonces
2: devolver VERDADERO
3: si no
4: devolver FALSO
5: fin si
Implementacin de operacin inserta
Algoritmo 6.27 inserta(x : tipoElemento; referencia c : tipoCola)

Salida: La cola c con el valor x como nuevo fondo de la misma
1: si c.tamano = MAX entonces
2: implementar segn especificacin y diseo ->cola llena
3: si no
4: incrementarIndice(c.fondo)
5: c.elementos[c.fondo] x
6: c.tamano c.tamano + 1
7: fin si
Implementacin operaciones frente y surpime

Opcin 1: suprime elimina pero no devuelve frente
Algoritmo 6.28 frente(referencia c : tipoCola)

Salida: El valor colocado en el frente de la cola c
1: si vac ia(c) = VERDADERO entonces
2: implementar segn especificacin y diseo ->cola vaca
3: si no
4: devolver c.elementos[c.frente]
5: fin si
Algoritmo 6.29 suprime1(referencia c : tipoCola)

Salida: La cola c sin el valor que estaba en el frente de la misma. El nuevo
frente pasa a ser el elemento siguiente
3: si no
4: incrementaIndice(c.frente)
5: fin si
Implementacin operacin surpime

Opcin 2: suprime elimina y devuelve frente. No se necesita operacin frente
Algoritmo 6.30 suprime(referencia c : tipoCola)

Salida: El valor que estaba situando en el frente de c y sta sin dicho valor.
El nuevo frente pasa a ser el elemento siguiente
1: valor : tipoElemento
4: si no
5: valor c.elementos[c.frente]
6: incrementaIndice(c.frente)
7: devolver valor
8: fin si
4.2.2 Implementacin TAD cola mediante listas enlazadas
La forma ms eficiente y sencilla de implementar una cola es

mediante listas simplemente enlazadas sin nodo ficticio:
Se representa el tipoCola mediante un registros con dos campos,

uno apuntando al frente y otro al fondo
El concepto de posicin desaparece, por tanto, puede prescindirse del
nodo ficticio
Licencia
Ms info: http://creativecommons.org/licenses/by-sa/3.0/es/
Usted es libre de:
copiar, distribuir y comunicar pblicamente la obra
hacer obras derivadas
Bajo las condiciones siguientes:

Reconocimiento. Debe reconocer los crditos de la obra de la
manera especificada por el autor o el licenciador (pero no de una
manera que sugiera que tiene su apoyo o apoyan el uso que hace
de su obra).
Compartir bajo la misma licencia. Si transforma o modifica esta
obra para crear una obra derivada, slo puede distribuir la obra
resultante bajo la misma licencia, una similar o una compatible.

Edyai

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Edyai

Uploaded by

Copyright:

Available Formats

Estructuras de Datos y Algoritmos I

Grado en Ingeniera Informtica

Ivn lvarez Navia

4 Algoritmos de bsqueda y ordenacin

6 Tipos Abstractos de Datos

Detalles del tema

Informalmente, un algoritmo es el mtodo que, independientemente

Mtodo cientfico Informtico

Proceso de resolucin propuesto por Aho

Programas = Algoritmos + Estructuras de datos

Niklaus Wirth, Algoritmos y Estructuras de Datos,

Detalles del tema

2 La importancia de los algoritmos

Tres formas de resolver un problema, mediante el uso de ordenadores, de

Los ordenadores ms rpidos del mundo (Junio 2015)

Localizacin Ordenador, fabricante Cores Pflop/s

Mejorar la eficiencia de los algoritmos

En 1977 los inventores de RSA propusieron en Scientific American un reto

Pagaran $100 a quien descifrara un texto llano a partir de un texto cifrado

Estimacin: el ordenador ms rpido del momento, utilizando los

Detalles del tema

3 Definiciones y conceptos bsicos

La palabra algoritmo proviene del nombre de un matemtico persa del

Caractersticas de los algoritmos

Es finito: un algoritmo siempre finaliza tras la ejecucin de un nmero

Algoritmo de Euclides Algoritmo 1.1 euclides(m,n)

Mtodo y Secuencia Computacional

Definicin: Mtodo computacional

Definicin: Secuencia computacional

Definicin formal de algoritmo

Se dice que una secuencia computacional termina en k pasos si k es

Donald E. Knuth, The Art of Computer Programming.

Definicin formal del algoritmo de Euclides

Diseo del algoritmo a partir de la definicin del problema

Ciencia que estudia tcnicas para construir algoritmos eficientes y

Ejemplo: Multiplicacin de dos nmeros enteros

Entrada: Enteros positivos, mo y mr 5 1 9 2

Ejemplo: Multiplicacin de dos nmeros enteros

Algoritmo 1.3 multiplicacinRusa(mo,mr)

Ejemplo: Multiplicacin de dos nmeros enteros

Algoritmo 1.4 multiplicacinDivide(mo, mr) Condiciones:

Ejemplo: Multiplicacin de dos nmeros enteros

Algoritmo 1.5 multiplicacin(mo,mr)

Multiplicacin de dos nmeros enteros

Incluso en un problema tan sencillo y cotidiano como la aritmtica

Dominio de definicin: conjunto de casos que deben considerarse a

La eficiencia de los algoritmos

Relacionado con el consumo de recursos computacionales,

Enfoques para calcular la eficiencia de los algoritmos

Enfoque emprico o a posteriori: consiste en programar las tcnicas

Estrategia ms ventajosa la terica:

Tiempo de CPU o de clculo o de procesamiento (el fundamental)

Unidad de tiempo (segundos, etc.) se necesita disponer de un

Funciones tpicas que nos encontraremos:

Casos mejor, medio y peor

No todos los ejemplares de un problema son iguales la eficiencia

Ejemplo de casos mejor, medio y peor

Algoritmo de bsqueda secuencial

Es aquella cuyo tiempo de ejecucin se puede acotar superiormente

x valorM inimo{T [i]k1 i n}

El lenguaje natural, el espaol en este caso, no est especialmente

Identificacin de algoritmos: Algoritmo, Procedimiento, Funcin

Resulta muy til tener un conocimiento extenso de los algoritmos ms