Estrucdatos 001

Estructuras de Datos y Algoritmos Tema 1: Anlisis de Algoritmos
Departamento de Informtica Universidad de Valladolid
Curso 2011-12
Grado en Ingeniera Informtica Grado en Ingeniera Informtica de Sistemas
10 Sep. 2011
Csar Vaca Rodrguez, Dpto. de Informtica, UVa
1. MEDIDA DE ALGORITMOS
9 Feb. 2011
Csar Vaca Rodrguez, Dpto.Informtica, UVa
Anlisis de Algoritmos

Estudio terico de la eficiencia de un algortmo Eficiencia: Medida del coste en el uso de recursos que necesita el algoritmo para llevar a cabo su tarea. Recursos ms importantes:

Tiempo de ejecucin Espacio de almacenamiento
Valor
por defecto
La medida se denomina complejidad del algoritmo. Otros aspectos (contemplados en otras asignaturas):

Funcionalidad Robustez Modularidad Mantenibilidad
Facilidad de uso Extensibilidad Correccin

3
11 Feb. 2011
Bsqueda Secuencial
type TDato=...; //Arraydinmico(indices0based) TVector =arrayofTDato; {Devuelveelndicedondeseencuentralaprimera aparicindex enVo1sinoexiste} function Busqueda(const V:TVector;x:TDato):integer; var n,i:integer; begin i:=0;n:=length(V);{NdeelementosdeV } while (i<n)and(V[i]<>x)do i:=i+1; if i<nthen Busqueda:=ielse Busqueda:=1 end;
11 Feb. 2011 Csar Vaca Rodrguez, Dpto. de Informtica, UVa 4
Problemas con la medida (tpo)
Dependencia con el tamao de la entrada: No se

tarda lo mismo en buscar en un vector de 10 elementos que buscar en uno de 1.000.000
Dependencia de valores de la entrada: Aunque

fijemos el tamao del vector, no se tarda lo mismo en buscar un valor que est en la primera posicin que otro que no est en el vector.
Depencia del procesador: Aunque fijemos el tamao

y los valores concretos del vector y el valor buscado, el algoritmo tardar tiempos distintos en ordenadores diferentes.
11 Feb. 2011
Dependencia del procesador
Solucin: No medir tiempo (segundos, por ejemplo), sino

el nmero de operaciones elementales ejecutadas.
Operacin Elemental: Toda operacin que tarda un

tiempo constante en cualquier procesador razonable.
Tipicamente se consideran elementales las asignaciones, operaciones aritmticas y relacionales con tipos de datos de tamao fijo, acceso a arrays. En general se cuenta slo un tipo de operacin concreta (la ms relevante para la eficiencia del algoritmo) Conociendo el nmero de operaciones y lo que tarda cada una en procesador concreto, se puede hallar el tiempo para ese procesador. Medida independiente del procesador.
Csar Vaca Rodrguez, Dpto. de Informtica, UVa 6
11 Feb. 2011
Tamao de la entrada
Definicin estricta: El mnimo nmero de bits necesario

para representar la parte no precalculable de la entrada del algoritmo.
Definicin til: Uno o ms valores relacionados con los

datos de entrada que sirven de parmetros para expresar las funciones que miden el uso de recursos del algoritmo.
En el caso de algoritmos que trabajan sobre colecciones de datos, suele ser el nmero de datos que contienen. Para algoritmos de clculo con enteros de tamao arbitrario, se suele usar el nmero de bits de esos enteros (se tratan como arrays de bits). El tamao de la entrada puede indicarse por ms de un valor (siempre enteros positivos).
11 Feb. 2011
Dependencia con el tamao
Solucin: Expresar la complejidad no mediante un valor

sino por una funcin cuyo parmetro(s) es el tamao de la entrada.
El tamao de la entrada, si es un nico valor, se suele denominar n. La complejidad temporal se denominar mediante la funcin T(n), y la espacial por E(n).
De esa funcin nos interesa, ms que su forma concreta, su ritmo de crecimiento.
Nos da la idea de como escala un algoritmo: Cmo crece su complejidad cuando aumenta el tamao de la entrada.
11 Feb. 2011
Dependencia con los valores
Solucin: Dividir el anlisis en casos.
Analizar subconjuntos de las entradas cuya complejidad es la misma para todos las entradas de ese subconjunto. (anlisis de peor y mejor caso) Calcular un promedio, dada una distribucin estadstica de las entradas. Tipicamente se supone que todas las posibles entradas son equiprobables. (anlisis de caso promedio y de tiempo amortizado)
Nota: Estos anlisis trabajan sobre entradas de un tamao fijo (aunque no especificado).
Subnota: Aunque en el anlisis de tiempo amortizado realmente las entradas varan de tamao, el ignorar este hecho no suele tener consecuencias adversas.
11 Feb. 2011
Mejor y Peor Caso
Anlisis en el peor caso: Calcula la complejidad del

algoritmo para las entradas (del mismo tamao) que mximizan la complejidad.
Tpeor(n) = mx{ T(n, entrada) } para toda entrada de tamao n.

Suele ser el caso ms relevante (hay excepciones).
Anlisis en el mejor caso: Calcula la complejidad del

algoritmo para las entradas (del mismo tamao) que minimizan la complejidad.
Tmejor(n) = min{ T(n, entrada) }

No suele ser un caso relevante.
11 Feb. 2011
Bsqueda Secuencial
type TDato=...; //Arraydinmico(indices0based) TVector =arrayofTDato; {Devuelveelndicedondeseencuentralaprimera aparicindex enVo1sinoexiste} function Busqueda(const V:TVector;x:TDato):integer; var n,i:integer; begin i:=0;n:=length(V);{NdeelementosdeV } while (i<n)and(V[i]<>x)do i:=i+1; if i<nthen Busqueda:=ielse Busqueda:=1 end;
Bsqueda secuencial
Operacin elemental: Elegimos contar comparacines en las que intervenga un elemento del vector. Tamao de la entrada: Elegimos tomar como tamao
de entrada el nmero de elementos del vector.
Peor Caso: Para vectores de tamao n, las entradas que

hacen que el algoritmo trabaje ms son aquellas en que el valor buscado no se encuentra en el vector.
Tpeor(n) = n comparaciones
Mejor Caso: Las entradas que hacen que el algoritmo

trabaje menos son aquellas en que el valor buscado est en la primera posicin del vector.
Tmejor(n) = 1 comparacin
Caso Promedio (1)
Calcula el promedio de la complejidad del algoritmo para todas las entradas posibles (del mismo tamao).

Supondremos que todas las entradas son equiprobables Llamaremos s a una entrada cualquiera del algoritmo. Llamamos Sn al conjunto de todas las posibles entradas de tamao n.
| Sn | denota el nmero de elementos de Sn
11 Feb. 2011
13
Caso Promedio (2)
Suele ser mas sencillo agrupar las entradas en conjuntos de aquellas entradas para las que el algoritmo tarda lo mismo.
Suele pasar que las entradas para las que el algoritmo da la misma respuesta tardan lo mismo Llamamos Sn,t al subconjunto de entradas que tardan un tiempo t.
Sn formado por las
Llamamos R al conjunto de todos los tiempos posibles (valores enteros) que puede tardar el algoritmo con entradas de tamao n. Probabilidad de
que una entrada provoque t operaciones

14
11 Feb. 2011
Bsqueda secuencial
Elegimos restringir el anlisis a bsquedas exitosas (el valor buscado est en el vector). El conjunto R (nmero de posibles comparaciones que puede realizar el algoritmo) es [1..n]. El conjunto Sn,t es el conjunto de todos los vectores posibles de tamao n y de posibles valores de bsqueda para los que el algoritmo realiza t operaciones el valor buscado est en la posicin t-1. Todos los subconjuntos Sn,t tienen el mismo tamao (es equiprobable el encontrar el valor en cualquier posicin)
11 Feb. 2011
15
Caso Promedio
Da una idea mucho ms ajustada de cmo se comporta el algoritmo para entradas cualesquiera, o para muchas ejecuciones independientes del mismo. Pero puede ser muy difcil de analizar. Slo se indica para aquellos algoritmos en los que el caso promedio difiere significativamente del peor caso (ejemplo: quicksort). Cuando un algoritmo se ejecuta muchas veces, pero las ejecuciones no son independientes (se actualiza un conjunto de datos, por ejemplo) se suele usar el anlisis de tiempo amortizado.
11 Feb. 2011
Tiempo amortizado (1)
En vez de promediar sobre distintas entradas, se promedia sobre una serie de ejecuciones de un algoritmo.
Se utiliza cuando la entrada del algoritmo se modifica en cada ejecucin (ejemplo: operaciones de insercin en un conjunto de datos). Es importante cuando las entradas tienen slo peor y mejor caso, sin casos intermedios.. .. y la ejecucin de un peor caso garantiza que un determinado nmero de las siguientes ejecuciones pertenezcan al mejor caso. Si se da esta situacin, se promedia una serie de ejecuciones [peor caso + mejores casos garantizados].
11 Feb. 2011
Tiempo amortizado (2)
Sea un algoritmo con las siguientes caractersticas:
La aplicacin realiza una serie de ejecuciones, cada una de ellas tomando la entrada actualizada por la anterior. Un peor y mejor caso Tpeor(n) y Tmejor(n). La ejecucin del peor caso garantiza que las siguientes f(n) ejecuciones sern del mejor caso. El tiempo amortizado se calcula como:
Nota: En realidad, en un clculo riguroso se debera sustituir por un sumatorio que refleje el cambio de n en las subsiguientes operaciones.
11 Feb. 2011
Ejemplo: Insercin en vector
Se dispone de un array parcialmente lleno (capacidad m, nmero de elementos n) y se disean dos estrategias de insercin:
En ambos casos, si n < m (existe espacio libre), se inserta al final de los elementos existentes (una operacin) Si n = m (vector lleno) se crea un nuevo vector ms grande y se copian los n elementos del antiguo en l. La primera estrategia crea un vector con 100 posiciones extra. La segunda estrategia crea un vector con extra (duplica la capacidad del antiguo).
n posiciones
11 Feb. 2011
19
Anlisis
Peor caso: El peor caso se da cuando se inserta en un

vector lleno. En ambas estrategias, se deben copiar los n elementos existentes e insertar el antiguo, por lo que:
Tpeor(n) = n+1
Mejor caso: Cuando el vector no est lleno slo se debe

realizar una insercin:
Tmejor(n) = 1
Caso promedio: No es aplicable, ya que los valores de las

entradas no influyen en el tiempo, tan slo si el vector est lleno o no, y a priori no se puede saber la probabilidad de esa situacin para una ejecucin aislada.
11 Feb. 2011
20
Anlisis Tiempo Amortizado
Primer escenario: Si el algoritmo amplia el vector en 100

posiciones, esto garantiza que tras un insercin en un vector lleno las siguientes 99 inserciones caern en el mejor caso:
Segundo escenario: Si el algoritmo duplica la capacidad

del vector, esto garantiza que tras cada insercin en un vector lleno las siguientes n-1 inserciones caern en el mejor caso:
11 Feb. 2011
21
Primer escenario
11 Feb. 2011
22
Segundo escenario
11 Feb. 2011
23
Complejidad temporal
El anlisis de la complejidad temporal consiste en contar el nmero de operaciones elementales

El tiempo se acumula (a diferencia del espacio) Una secuencia de operaciones se computa sumando los tiempos de los bloques que la forman. Una bifurcacin requiere un anlisis por casos. Las iteraciones requieren el calcular el nmero de repeticiones (puede no ser sencillo o requirir anlisis por casos). Tambin hay que analizar si el tiempo de cada repeticin es constante o no:

Si Multiplicar. No Sumatorios.
11 Feb. 2011
Frmula para las iteraciones
11 Feb. 2011
25
Complejidad espacial
El anlisis de la complejidad espacial consiste en determinar el mximo espacio extra de almacenamiento que necesita el algoritmo.
No se tiene en cuenta el espacio que ocupan los datos de entrada (se supondr siempre paso por variable). Se cuenta el espacio necesario para las variables locales y los resultados. Tambien las operaciones de creacin de objetos, variables dinmicas y ampliacin de arrays (no suelen aparecer en los algoritmos que examinaremos) Las llamadas a subprogramas necesitan el espacio que dicte el subprograma como necesario para su ejecucin.
11 Feb. 2011
Llamadas a subprogramas
Supongamos un programa que llama en secuencia a 3 subprogramas A, B y C que necesitan un espacio de almacenamiento de EA, EB y EC, respectivamente.
Tras la ejecucin de cada subprograma la memoria extra que necesita se libera. Por lo tanto el espacio extra del algoritmo no es la suma de esos valores, sino su mximo. EL = Espacio vars. locales
11 Feb. 2011
27
Otros factores
Existen otros factores que se pueden tener en cuenta a la hora de valorar la eficiencia de algoritmos:
Localizacin: Un algoritmo hace uso localizado de memoria si tras cada acceso existe una gran probabilidad de que el siguiente acceso sea a una posicin cercana. Es importante en sistemas con memoria jerrquica (caches). Paralelizacin: Posibilidad de dividir un algoritmo en tareas independientes. Importante en sistemas con mltiples procesadores. Gestin de memoria: Secuencia que sigue un algoritmo a la hora de crear objetos. Importante en sistemas con recoleccin de basura (garbage collector).
11 Feb. 2011
2. NOTACIN ASINTTICA
9 Feb. 2011
29
Definicin matemtica
Dada una funcin f(n) la notacin O(f(n)) representa al conjunto de funciones con la siguiente propiedad:
El conjunto O(f(n)) se denomina conjunto de cotas superiores generado por f(n). Toda funcin que pertenece a O(f(n)) se dice que est acotada superiormente por f(n). Definicin alternativa:
g(n) mas lenta que f(n) g(n) mismo crecimiento que f(n)
11 Feb. 2011
30
Explicacin
El conjunto O(f(n)) representa a las funciones que:

Tienen un ritmo de crecimiento igual o menor que f(n) No importan las constantes de proporcionalidad (positivas) por las que est multiplicada la funcin (podemos ajustar el valor de c en la definicin) Solo importa el comportamiento para valores de n grandes, tendentes a infinito (podemos elegir n0 como queramos) Nota: Las funciones con las que tratamos son no decrecientes, positivas y con parmetros enteros positivos.
11 Feb. 2011
31
Representacin grfica
c se elige para que f(n) supere a g(n)
c f(n )
g(n)
cf(n) mayor que g(n) a partir de aqu
n0
11 Feb. 2011
32
Ejemplos
3n2 O(n2)?
Aplicando la definicin se debe cumplir: Es cierto, escogiendo n0 = 0, cualquier c > 3
n/10 O(n2)?
Es cierto escogiendo n0 = 0, cualquier c > 0.1
0.01n3 O(n2)?
11 Feb. 2011
33
Ejemplos
3n2 O(n2)? Si
Aplicando la definicin se debe cumplir: Es cierto, escogiendo n0 = 0, cualquier c > 3
n/10 O(n2)? Si
Es cierto escogiendo n0 = 0, cualquier c > 0.1
0.01n3 O(n2)? No Falso!
11 Feb. 2011
34
Utilidad
Sustituir en expresiones la funcin g(n) (complicada, detallada) por O(f(n)) (donde f(n) es ms sencilla)
En general f(n) y g(n) tendrn el mismo ritmo de crecimiento (cotas ajustadas). Perdemos precisin (constantes de proporcionalidad y trminos que crecen ms lentamente que el dominante) Ganamos generalidad: Muchas expresiones distintas pasan a estar representadas por una sola, usando el criterio de crecimiento de la funcin El clculo con notacin asinttica es mucho ms sencillo Las comparaciones (basadas en ritmo de crecimiento) entre funciones son inmediatas.
11 Feb. 2011
Propiedades

f(n) O(f(n)): Paso de expresin a notacin asinttica. O(kf(n)) O(f(n)): Las constantes de proporcionalidad
se omiten.
O(f(n) + g(n)) O(mx{f(n), g(n)}) : Slo importa el

trmino de mayor crecimiento.
O(f(n) - g(n)) O(f(n)) si g(n) crece ms lentamente que f(n), en caso contrario no se puede simplificar.
Los productos y divisiones pueden incorporarse a la notacin O-grande sin problemas. Dentro de la O-grande se debe usar la funcin ms sencilla posible!
11 Feb. 2011
Jerarqua de funciones
Clasificacin de funciones segn su crecimiento:
T(n) O(1) T(n) = cte: Funciones constantes,

que no dependen del tamao de la entrada.
T(n) O(n1/a), a : Funciones subpolinmicas,

crecen ms lentamente que cualquier polinomio.
T(n) O(na) : Funciones polinmicas, existe un

polinomio que las acota.
T(n) O(na), a : Funciones no polinmicas,

crecen ms rpido que cualquier polinomio.
11 Feb. 2011
37
Comparacin (I)
Un algoritmo resuelve un problema con n = 100 en 1 seg. Cambiamos el ordenador por uno 10 veces ms rpido. Cul es ahora el tamao para el que tardar 1 seg.?:
Tipo Constante Subpolinmico Orden O(1) O(log n) O(log2 n) O(n1/2) O(n) Polinmico O(nlog n) O(n2) O(n3) No polinmico
11 Feb. 2011
Tamao
Ejemplo
Ilimitado Acceso array 100 trillones Bsqueda binaria 2.111.136 Planos ocultos (Doom) 10.000 Test primalidad 1.000 Bsqueda secuencial 703 Ordenacin, FFT 316 Ordenacin (bsica) 215 Multiplicacin matrices 103 Problema SAT 101 Problema del viajante
38
O(2n) O(n!)
Comparacin (II)
Un algoritmo resuelve un problema con n = 1.000 en 1 seg. Cuanto tardar en resolver el problema para un tamao 10 veces mayor (n = 10.000)?:
Tipo Constante Subpolinmico Orden O(1) O(log n) O(log2 n) O(n1/2) O(n) Polinmico O(nlog n) O(n2) O(n3) No polinmico
11 Feb. 2011
Tiempo
Ejemplo
1 seg. Acceso array 1,3 seg. Bsqueda binaria 1,8 seg. Planos ocultos (Doom) 3,2 seg. Test primalidad 10 seg. Bsqueda secuencial 13,3 seg. Ordenacin, FFT 100 seg. Ordenacin (bsica) 17 min. Multiplicacin matrices Infinito Problema SAT Infinito Problema del viajante
39
O(2n) O(n!)
Uso habitual
La notacin asinttica se usa para trabajar con una expresin con el nivel de detalle adecuado:
Sea T(n)
= 3n2 - 5n + 34. Se puede convertir en:

Atencin: La O-grande siempre sumando
T(n) = 3n2 - 5n + O(1) T(n) = 3n2 + O(n) T(n) = O(n2) T(n) = O(n5) T(n) = 34 + O(n2)
Atencin: Correcto, pero cota no ajustada Mal: Los trminos exactos deben tener mayor crecimiento que la O-grande
Nota: Se debera usar en vez de =, pero la convencin matemtica permite este abuso de lenguaje.
11 Feb. 2011
Cotas ajustadas
Cuando sustituimos g(n) por O(f(n)), f(n) debe ser una funcin de igual o mayor crecimiento que g(n)
Salvo que se diga lo contrario, se supone que el crecimiento es igual. En ese caso se dice que la cota es ajustada. Puede haber situaciones (para simplificar clculos, sobre todo) en que la cota obtenida no tiene garantas de estar ajustada: En ese caso debe indicarse explcitamente. Tambin es posible que la cota no est ajustada porque se refiera al peor caso de un algoritmo.
11 Feb. 2011
41
Otras funciones de cota
(f(n)): Cota inferior. Funciones que crecen igual o ms

rpido que f(n). Cota estricta. Funciones que crecen al mismo ritmo que f(n).
(f(n)): (f(n)): o(f(n)):
Cota inferior exclusiva. Funciones que crecen ms rpido (no igual) que f(n).
Cota superior exclusiva (o-pequea). Funciones que crecen ms lentamente (no igual) que f(n).
11 Feb. 2011
42
Formulae
11 Feb. 2011
43
Ejemplo: Ord. por Insercin

type TVector =arrayofTDato; procedure OrdIns(var V:TVector); var n,i,j:integer; tmp:TDato; begin n:=length(V);{NdeelementosdeV } for i:=1ton2 do begin j:=i1;tmp:=V[i]; while(j>0)and (V[j]>tmp)do begin V[j+1]:=V[j]; j:=j1 end; V[j+1]:=tmp end end;

type TVector =arrayofTDato; procedure OrdIns(var V:TVector); var n,i,j:integer; tmp:TDato; begin n:=length(V);{NdeelementosdeV } for i:=1ton1 do begin Peor caso: j:=i1;tmp:=V[i]; i comp while(j>0)and (V[j]>tmp)do i+2 movs begin Mejor caso: V[j+1]:=V[j]; j:=j1 1 comp end; 2 movs V[j+1]:=tmp end end;
Movimientos, peor caso, exacto:
Movimientos, peor caso, notacin asinttica:
11 Feb. 2011
46
3. RELACIONES DE RECURRENCIA
9 Feb. 2011
47
Llamadas a subrutinas
functionEsPrimo(n:integer):boolean; var d:integer; begin d:=2; while (d*d<=n)and(nmodd<>0) dod:=d+1; EsPrimo:=d*d>n; end; functionNumPrimos(n:integer):integer; var sum,i:integer; begin sum:=0; for i:=1tondo ifEsPrimo(i)then sum:=sum+1; NumPrimos:=sum; end;
O(n1/2)
Llamadas recursivas
Queremos contar el nmero de productos en funcin del valor de n:
functionFact(n:integer):integer; begin if n<=1then Fact:=1 else Fact:=n*Fact(n1); end;
1 + ?
11 Feb. 2011
49
Arbol de llamadas
functionFact(4):integer; begin if 4<=1thenFact:=1 elseFact:=4* Fact(3); end;
if 3<=1thenFact:=1 elseFact:=3* Fact(2);
if 2<=1thenFact:=1 else Fact:=2* Fact(1);
if 1<=1thenFact:=1 elseFact:=2*Fact(1);
11 Feb. 2011
50
Arbol de llamadas
functionFact(4):integer; begin if 4<=1thenFact:=1 elseFact:=4* 6; end;
if 3<=1thenFact:=1 elseFact:=3* 2;
if 2<=1thenFact:=1 else Fact:=2* 1;
if 1<=1thenFact:=1 elseFact:=2*Fact(1);
11 Feb. 2011
51
Evaluacin con Recursividad
La solucin pasa por establecer una ecuacin donde la incognita sea la funcin de medida del tiempo o espacio: T(n) o E(n). Las ecuaciones donde las incognitas son funciones, no variables, se denominan relaciones de recurrencia. El tiempo o espacio de las llamadas recursivas se representan por T(n) o E(n) con el parmetro adecuado. Las resolveremos por sustitucin o aplicacin del teorema maestro.
11 Feb. 2011
Secuencia de Fibonacci
functionFib(n:integer):integer; begin if n=1thenFib:=1else if n=2thenFib:=1else Fib:=Fib(n1)+ Fib(n2); end;
11 Feb. 2011
53
Arbol de llamadas (Fibonacci)

Altura Espacio
Tiempo N de nodos
11 Feb. 2011
54
Teorema maestro
11 Feb. 2011
55
Cotas superiores e inferiores
Existen problemas a cuya relacin de recurrencia no se puede aplicar el teorema maestro (llamadas con parmetros distintos). Por ejemplo, la funcin Fibonacci: En estos casos, lo que podemos es resolver versiones de mayor y menor crecimiento de la relacin de recurrencia.
En este caso H(n) es mayor que T(n) por lo que actua como cota superior suya. L(n) es menor que T(n), y actua como cota inferior. Lo podemos expresar as:
11 Feb. 2011
56
4. ALGORITMOS DE ORDENACIN
9 Feb. 2011
57
Taxonoma
Algoritmos Directos:

Insercin Seleccin Intercambio (burbuja) Ordenacin por fusin (mergesort) Ordenacin rpida (quicksort)* Ordenacin por montculos (heapsort) Residuos-Recuento Radix sort
Algoritmos Avanzados:

Caso promedio
Algoritmos No Universales:

11 Feb. 2011
Caractersticas
Universal / Especfico: Un mtodo es universal si est

basado en comparaciones. Es especfico si se basa en propiedades especiales de los datos.
Tipo de acceso: Existen algoritmos que requieren

acceso indexado en O(1) a los elementos (arrays). Si tan slo se requiere acceso secuencial, el algoritmo se puede aplicar a otras estructuras de datos (listas enlazadas, etc.)
Sobre el propio vector: Algunos algoritmos actuan

sobre el propio vector y otros requieren que el resultado se proporcione sobre otro vector distinto del original.
Estabilidad: Una estrategia de ordenacin es estable si

mantiene el orden original de los elementos con claves iguales y ello no supone una prdida de eficiencia.
11 Feb. 2011
59
Estabilidad
Ordenacin de un vector por el campo clave Apellido:
Apellido Rodriguez Snchez Snchez Prez Rodrguez Prez Prez Nombre Angel Beatriz Javier Laura Miguel Nacho Roberto Apellido Prez Prez Prez Rodriguez Rodrguez Snchez Snchez Nombre Laura Nacho Roberto Angel Miguel Beatriz Javier Apellido Prez Prez Prez Rodriguez Rodrguez Snchez Snchez Nombre Nacho Roberto Laura Angel Miguel Javier Beatriz
Vector original
Ordenacin estable
Ordenacin no estable
11 Feb. 2011
60
Teorema de la ordenacin
No puede existir ningn algoritmo de ordenacin basado en comparaciones cuyo tiempo de ejecucin tenga una cota menor que O(n log n) El espacio de posibles soluciones tiene un tamao n!
(posibles permutaciones de un vector de n elementos)
De ese espacio el algoritmo debe encontrar el nico vector resultado (aquel que est ordenado) Cada comparacin proporciona un bit de informacin Un algoritmo perfecto usara cada comparacin para obtener un bit del ndice al espacio de permutaciones Ese ndice contiene log2(n!) bits.
11 Feb. 2011
61
Notacin
En los siguientes programas se usa la notacin:
Los arrays son dinmicos, indexados por 0.. y su nmero de elementos (longitud) se calcula con la funcin length. La operacin de intercambio entre elementos del vector (tmp := v[i]; v[i] := v[j]; v[j] := tmp) se representa de forma abreviada como v[i] v[j] Se marcan en rojo las comparaciones entre elementos del vector y en violeta los movimientos o intercambios entre elementos del vector. Las comparaciones se realizan entre los elementos, para simplificar la notacin. En la vida real se usaran campos clave de los elementos o funciones comparadoras.
11 Feb. 2011
Ordenacin por Insercin

type TVector =arrayofTDato; procedure OrdIns(var V:TVector); var n,i,j:integer; tmp:TDato; begin n:=length(V);{NdeelementosdeV } for i:=1ton2 do begin j:=i1;tmp:=V[i]; while(j>0)and (V[j]>tmp)do begin V[j+1]:=V[j]; j:=j1 end; V[j+1]:=tmp end end;
Propiedades (Ord. Insercin)
Eficiencia O(n2)

Espacio O(1) Peor caso (vector orden inverso): n2/2 + O(n) Mejor caso (vector ordenado): O(n) Promedio: n2/4 + O(n) Las frmulas son iguales para movimientos y comparaciones
Mtodo universal Acceso secuencial: Slo si el acceso es bidireccional

(por ejemplo listas doblemente enlazadas)
Estable Adaptativo Sobre el propio vector

11 Feb. 2011
Ordenacin por Seleccin

type TVector =arrayofTDato; procedure OrdSel(var V:TVector); var n,i,j,jmin:integer;{Tmp:TDato;} begin n:=lenght(V); {V:array[0..N1]ofTDato} for i:=0to n2do begin {Bsquedadelmenordezonanoordenada} jmin:=i; for j:=i+1to N1do if V[j]<V[jmin]then jmin:=j; {Intercambiomenor<>primerozonanoord.} V[i] V[jmin] end end;
11 Feb. 2011
65
Propiedades (Ord. Seleccin)
Eficiencia O(n2) [O(n2) comparaciones, O(n) movimientos]

Espacio O(1) Siempre hace el mismo nmero de operaciones Comparaciones: n2/2 + O(n) Movimientos: 3n
Mtodo universal Acceso secuencial: Slo si el acceso permite marcas

(marcar un punto y poder volver a l)
No Estable (V[I] puede saltar por delante de elementos iguales) No adaptativo Sobre el propio vector
11 Feb. 2011
Ordenacin burbuja
type TVector =arrayofTDato; procedure OrdBur(var V:TVector); var n,i,j:integer;{Tmp:TDato;} begin n :=Lenght(V); {V:array[0..N1]ofTDato} for i:=0to n2do for j:=n1downto i+1do if V[j]>V[j+1]then V[j] V[j+1] end;
11 Feb. 2011
67
Propiedades (Ord. Burbuja)
Eficiencia O(n2)

Espacio O(1) Comparaciones: n2/2 + O(n) Movimientos:

0 mejor caso 3n2/4 + O(n) promedio 3n2/2 + O(n) peor caso
Mtodo universal Acceso secuencial: Slo si el acceso es bidireccional Estable No adaptativo Sobre el propio vector
11 Feb. 2011
Ordenacin por Fusin

procedure OrdFus(var V:TVector); var W:TVector;{Vectortemporal} begin SetLength(W,Length(V)); {Crearvectorextra} OrdFusRec(V,W,0,Length(V)1) {Ordenarrecurs.todoelvector} end; procedure OrdFusRec(varV,W:TVector;Ini,Fin:integer); {OrdenaV[Ini..Fin]} var Med,I:integer; begin if Ini< Finthen begin Med:=(Ini+Fin)div 2; OrdFusRec(V,W,Ini,Med);{Ordenacinprimeramitad} OrdFusRec(V,W,Med+1,Fin);{Ordenacinsegundamitad} Fusion(V,W,Ini,Med,Fin);{FusionarmitadesenW} for I:=Inito Findo V[I]:=W[I]{CopiardeWaV} end {elsecaso_base} end;
Algoritmo de Fusin
procedure Fusion(varV,W:TVector;Ini,Med,Fin:integer);
{FusionaV[Ini..Med]yV[Med+1..Fin]enW[Ini..Fin]} var Ia,Ib,Ic:integer;
begin
{ExtraermnimosyllevarlosaW} Ia:=Ini;Ib:=Med+1;Ic:=Ini; while (Ia<= Med)and (Ib<= Fin)do if V[Ia]< V[Ib]then
begin W[Ic]:=V[Ia];Inc(Ia);Inc(Ic) end else begin W[Ic]:=V[Ib];Inc(Ib);Inc(Ic) end;

{CopiarzonanovacaaW} while Ia<= Meddo
begin W[Ic]:=V[Ia];Inc(Ia);Inc(Ic) end; while Ib<= Findo begin W[Ic]:=V[Ib];Inc(Ib);Inc(Ic) end; end;
Anlisis (Ord. Fusin)

V n/2
Ord.
n/2
Fus. T(n/2)
Ord.
Fus. T(n/2)
E(n/2)
+ n Fusin
+
movimientos n-1 comparaciones (peor caso) (n) espacio (vector extra)
Copiado
+
(n movimentos)
+
11 Feb. 2011
71
Propiedades (Ord. Fusin)
Eficiencia O(n log n)

2n log2 n movimientos n log2 n n comparaciones (peor caso caso promedio) n datos (vector extra) + O(log n) espacio adicional
Mtodo universal
ambas mitades en estructuras distintas)
Fcilmente adaptable a acceso secuencial (separando Estable No adaptativo Sobre el propio vector (no se puede usar el vector extra para
devolver el resultado)
Ordenacin rpida
procedure OrdRap(var V:TVector); var I,J:integer; begin
{Desordenarvector(Knuthshufflealgorithm)}
for I:=0to Lenght(V)1do V[I] V[Random(Length(V)I)]

{Ordenacinrecursivasobretodoelvector}
Opcional
OrdRapRec(V,0,Length(V)1) end; procedure OrdRapRec(varV:TVector;Ini,Fin:integer);

{OrdenaV[Ini..Fin]}
var Fin_Men,Ini_May:integer; begin if Ini< Finthen begin Particion(V,Ini,Fin,Fin_Men,Ini_May); {Redistribuirelems.} OrdRapRec(V,Ini,Fin_Men);{Ordenapartedemenores} OrdRapRec(V,Ini_May,Fin);{Ordenapartedemayores} end {elsecaso_base} end;
Particin (1er mtodo)

procedure Particin(var V:TVector;Ini,Fin:integer; var Fin_Men,Ini_May:integer); {ReorganizaV[Ini..Fin]demaneraquetermineorganizadoentreszonas: V[Ini..Fin_Men]contieneelementosmenoresoigualesalpivote. V[Fin_Men+1..Ini_May1]contieneelementosigualesalpivote. V[Ini_May..Fin]contieneelementosmayoresoigualesalpivote. NingunazonaseextiendeentodoV[Ini..Fin]} var Izda,Dcha:integer;Pivote:TDato; begin Pivote:=V[Ini];{Hayotrasalternativasaeleccindepivote} Izda:=Ini;Dcha:=Fin; while Izda<= Dchado begin {Invariante:V[Ini..Izda1]<=Pivote,V[Dcha+1..Fin]>=Pivote} while V[Izda]<Pivotedo Inc(Izda); while V[Dcha]>Pivotedo Dec(Dcha); if Izda<= Dchathen begin V[Izda] V[Dcha]; Inc(Izda);Dec(Dcha) end end; Fin_Men:=Dcha;Ini_May:=Izda end;
Particin (2 mtodo)
procedure Particin(var V:TVector;Ini,Fin:integer; var Fin_Men,Ini_May:integer); {ReorganizaV[Ini..Fin]demaneraquetermineorganizadoentreszonas: V[Ini..Fin_Men]contieneelementosmenoresqueelpivote. V[Fin_Men+1]contieneelpivote. V[Ini_May..Fin]contieneelementosmayoresoigualesalpivote. IniMay=Fin_Men+2} var I,Lim:integer; begin {Setomacomopivoteel1er elemento,V[Ini](hayotrasalternativas)} Lim:=Ini+1; for I:=Ini+1to Findo {Invariante:V[Ini+1..Lim1]<Pivote,V[Lim..I1]>=Pivote} if V[I]<V[Ini]then begin V[I] V[Lim]; Inc(Lim) end;{iffor} V[I] V[Lim1];{Pivoteentremenoresymayores/iguales} Fin_Men:=Lim2;Ini_May:=Lim end;
11 Feb. 2011
75
Anlisis (Ord. Rpida, 2 mt.)

n
Particin (pivote (m+1)-simo mayor) n-1 comparaciones m+1 intercambios O(1) espacio
< m
=
Ord. Rap. T(m)
n-m-1
Ord. Rap. T(n-m-1) mx{ E(m), E(n-m-1) }
11 Feb. 2011
<
+ = -
+
Mejor caso

Se da cuando las particiones son equilibradas (m n/2) T(n) = 2T(n/2) + O(n), E(n) = E(n/2) + O(1) Comparaciones: n log2n + O(n) [igual a ord. fusin] Movimientos: 1.5 n log2n + O(n) [mejor que ord. fusin] Espacio: O(log n) [mucho mejor que ord. fusin]
11 Feb. 2011
77
Peor caso
Se da cuando las particiones son desequilibradas: Una de las zonas est vaca (m = 0 m = n-1) T(n) = T(n-1) + O(n), E(n) = E(n-1) + O(1) Comparaciones: n2/2 + O(n) Movimientos: O(n) si m = 0, 1.5 n2 + O(n) si m = n-1 Espacio: O(n) La ordenacin rpida es un algoritmo O(n2) Tipos de vectores que provocan el peor caso:

Pivote primero o ltimo: Vector ordenado o en orden inverso Pivote elem. medio: Vector con elementos en orden creciente hasta la mitad y decreciente a partir de entonces, o al revs. Pivote al azar: La probabilidad de caer en el peor caso decrece exponencialmente.
11 Feb. 2011
Caso Promedio (I)
Relacin de recurrencia general (2 mtodo particin) T(n,m) = T(m,) + T(n-m-1,) + f(n,m) Donde m es el nmero de elementos menores que el pivote f(n,m) son las operaciones no recursivas (particin):

n-1 comparaciones m+2 intercambios
Si el pivote es un elemento cualquiera de la zona, entonces cualquier valor de m [0..n-1] es equiprobable. Nmero de operaciones promedio:
11 Feb. 2011
79
Caso Promedio (II)
Aplicandolo a la relacin de recurrencia (comparaciones):
Operando:
(eq. A)
(eq. B)
11 Feb. 2011
80
Caso Promedio (III)
Restando las ecuaciones A y B:
11 Feb. 2011
81
Propiedades (Ord. Rpida)
Eficiencia O(n2)

Peor caso: O(n2) tiempo, O(n) espacio. Mejor caso: O(n log n) tiempo, O(log n) espacio Promedio: O(n log n) tiempo, O(log n) espacio El tiempo promedio slo es un 40% mayor que el mejor
Mtodo universal Acceso secuencial: No. No Estable No adaptativo Antiadaptativo Sobre el propio vector
11 Feb. 2011
Ordenacin por montculos

procedure Monticulos(var V: TVector); var Lim,I,P,H : integer; begin Lim := Length(V)-1; for I := (Lim-1) div 2 downto 0 do begin P := I; H := 2*I+1; if (H < Lim) and (V[H] < V[H+1]) then Inc(H); while (H <= Lim) and (V[P] < V[H]) do begin V[P] V[H]; P := H; H := 2*P+1; if (H < Lim) and (V[H] < V[H+1]) then Inc(H) end end; for I := Lim-1 downto 0 do begin V[0] V[I+1]; P := 0; H := 1; if (H < I) and (V[H] < V[H+1]) then Inc(H); while (H <= I) and (V[P] < V[H]) do begin V[P] V[H]; P := H; H := 2*P+1; if (H < I) and (V[H] < V[H+1]) then Inc(H) end end 11 Feb. 2011 Csar Vaca Rodrguez, Dpto. de Informtica, UVa end;
83
Propiedades (Ord. Montculos)
Eficiencia O(n log n)

Espacio O(1) No recursiva Entre 2 y 5 veces ms lenta que la ordenacin rpida
Mtodo universal Acceso secuencial: No. No Estable No adaptativo Sobre el propio vector
11 Feb. 2011
84
Algoritmos no universales
Se basan en los valores de las claves, no en comparar unas claves con otras. Supondremos que los elementos tienen un campo clave:

Dividido en p subclaves (p puede ser 1) Organizadas en orden lexicogrfico Cada una de las cuales almacena (o se puede convertir en) un entero positivo en el rango 0..q-1
N de posibles valores distintos de cada clave:

type TDato =record clave:array[0..P1]of0..Q1; _ ... + Significativa end;
Constantes
11 Feb. 2011
85
Ordenacin por recuento

procedure Recuento(const V: TVector; var W: TVector; k: integer); {DevuelveenWunacopiadelvectorVordenadoporsubclavek} var c,i: integer; {Tabladerecuento.T[i]=NdeelementosenVconclave[k]=i} T : array[0..Q-1] of integer; begin n := length(V); {Inicializarlatabladerecuento} for c := 0 to Q-1 do T[c] := 0; {Contarndeelementosconcadaposiblevalordesubclavek} for i := 0 to n-1 do Inc(T[V[i].clave[K]]); {Convertirrecuentoenposicindelltimoelementoconesevalorde subclaveenelvectorordenado} T[0] := T[0]-1; for c := 1 to Q-1 do T[c] := T[c-1] + T[c]; {RellenarvectorordenadoWapartirdeV} for i := n-1 downto 0 do begin V c := V[i].clave[K]; W[T[c]] := V[i]; T[c] := T[c]-1 W end end;
Propiedades (Ord. Recuento)
Eficiencia (q: rango subclaves) : O(n + q)
Espacio O(q): Tabla de recuento. No se tiene en cuenta el tamao de los vectores de entrada y salida Slo es lineal si q es del mismo orden que n
Mtodo no universal: Las claves deben cumplir ciertos

requisitos (conversin a entero)
Acceso secuencial: No. Estable (crucial para el mtodo residuos-recuento) No adaptativo Devuelve el resultado en otro vector. Si se desea
ordenar sobre el propio vector hay que copiar el vector resultado sobre el original (espacio O(q + n))
11 Feb. 2011
87
Estrategia de residuos
Si se dispone de una ordenacin estable se puede ordenar por toda la clave mediante una secuencia de ordenaciones por subclaves (de - a + significativa)
911 099 905 009 901 910 115 190
Unidades
910 190 911 901 115 905 099 009

Decenas
901 905 009 910 911 115 190 099

Centenas
009 099 115 190 901 905 910 911
11 Feb. 2011
88
Residuos - Recuento
procedure ResiduosRec(var V: TVector); var k,i,n: integer; {Vectorextraparalasordenacionesporsubclave} W : TVector; begin {Dimensionarvectorextra} n := length(V); SetLength(W,n); {Ordenacionesparciales} for k := 0 to P-1 do begin Recuento(V,W,k); {CopiarWenV} for i := 0 to n-1 do V[i] := W[i] end end;
11 Feb. 2011
89
Propiedades (Ord. Res-Rec)
Eficiencia: O(pn + pq)

q: rango subclaves, p: nmero de subclaves Espacio O(n+q): Tabla de recuento y vector extra. Caso habitual: Sea m el nmero de claves posibles, y la clave se divide en bits. q = 2 y p = log2 m
T(n) = O(n log m), E(n) = O(n + log m)
Mtodo no universal: Las claves deben cumplir ciertos

requisitos (conversin a entero)
Acceso secuencial: No. Estable Sobre el propio vector.

11 Feb. 2011
Radix-sort

Inspirado en quicksort y residuos Clave dividida en bits Se realizan p = log2 m ordenaciones por el bit i-simo Pero desde el bit ms significativo al menos significativo (a la inversa que en residuos) No se ordena todo el vector, sino en zonas con el mismo valor del bit previo (recursivamente) Truco: Ordenar por un bit es equivalente a realizar una particin (sin pivote): los bits 0 a la izquierda y los bits 1 a la derecha.
11 Feb. 2011
91
Radix-sort
procedure Radix(varV:TVector); begin RadixRec(V,0,length(V)1,0) end; procedure RadixRec(varV:TVector;Ini,Fin,Bit:integer); {OrdenaV[Ini..Fin]} var Lim:integer; begin if (Ini< Fin)and (Bit<P)then begin ParticionBit(V,Bit,Ini,Fin,Lim); {Redistribuirelems.} RadixRec(V,Ini,Lim,Bit+1);{Ordenapartedebits0} RadixRec(V,Lim+1,Fin,Bit+1);{Ordenapartedebits1} end {elsecaso_base} end;
11 Feb. 2011
92
Particin por bits

procedure ParticionBit(var V:TVector;K,Ini,Fin:integer; var Lim:integer); {ReorganizaV[Ini..Fin]endoszonas: V[Ini..Lim]contieneelementosconelbitksimo=0. V[Lim+1..Fin]contieneelementosconelbitksimo=1.} var Izda,Dcha:integer; begin Izda:=Ini;Dcha:=Fin; while Izda<= Dchado begin {Invariante:V[Ini..Izda1]=bit0,V[Dcha+1..Fin]=bit1} while V[Izda].clave[k]=0do Inc(Izda); while V[Dcha].clave[k]=1do Dec(Dcha); if Izda<= Dchathen begin V[Izda] V[Dcha]; Inc(Izda);Dec(Dcha) end end; Lim:=Dcha; end;
11 Feb. 2011
93
Propiedades (Radix-sort)
Eficiencia: O(n log m)
m: nmero de claves posibles

Espacio O(log
m): Llamadas recursivas.
Mtodo no universal: Las claves deben poderse comparar

mediante su secuencia lexicogrfica de bits (contraejemplo: nmeros reales)
Acceso secuencial: No. No adaptativo No estable Sobre el propio vector.
11 Feb. 2011
94
Resumen final
Algoritmo Insercin Seleccin Burbuja Fusin Rpida Montculos ResiduosRecuento Radix-Sort
11 Feb. 2011
Tiempo O(n2) O(n2) O(n2) O(n log n) O(n2) [peor] O(n log n) [prom] O(n log n) O(pn + qn) O(n log m)
Espacio O(1) O(1) O(1) O(n) O(n) [peor] O(log n) [prom] O(1) O(n + q) O(log m)
Estable Si No Si Si No No Si No
95
A. APNDICE: ALGORITMOS DE ORDENACIN EN HASKELL
9 Feb. 2011
96
Ordenacin por Insercin

insertar::Orda=>a>[a]>[a] insertarx[]= [x] insertarx(y:ys)= if x<= y then x:y:ys else y:(insertarxys) ordIns::Orda=>[a]>[a] ordIns[]=[] ordIns(x:xs)=insertarx(ordInsxs)
11 Feb. 2011
97
Ordenacin por Seleccin

minLis::Orda=>[a]>a minLis[x]= x minLis(x:xs)=if x<ythen xelse y where y=minLisxs borraElem::Eqa=>a>[a]>[a] borraElemx[]=[] borraElemx(y:ys)=if x==y then xs else x:(borraElemxys) ordSel::Orda=>[a]>[a] ordSel[]=[] ordSellis=x:(ordSel(borraElemxlis)) where x=minLislis
11 Feb. 2011
98
Ordenacin por Intercambio (burbuja)

pasada::Orda=>[a]>[a] pasada[]=[] pasada[x]=[x] pasadax:xs=if x<ythen x:y:yselse y:x:ys where y:ys=pasadaxs ordInt::Orda=>[a]>[a] ordInt[]=[] ordInt[x]=[x] ordIntlis=y:(ordIntys) where y:ys=pasadalis
11 Feb. 2011
99
Ordenacin por Fusin

fusion::Orda=>[a]>[a]>[a] fusion[]l2=l2 fusionl1[]=l1 fusion(x:xs)(y:ys)=if x<y then x:fusionxs(y:ys) else y:fusion(x:xs)ys ordFus::Orda=>[a]>[a] ordFus[]=[] ordFus[x]=[x] ordFuslis=fusion(ordFusizda)(ordFusdcha) where mitad=(lengthlis)`div`2 izda=take mitadlis dcha=drop mitadlis
Ordenacin Rpida
ordRap::Orda=>[a]>[a] ordRap[]=[] ordRap[x]=[x] ordRap(x:xs)=(ordRapmenores)++[x]++(ordRapmayores) where menores=[y| y< xs,y<x] mayores=[z| z< xs,z>=x]
11 Feb. 2011
101
Radix-sort
importData.Bits ordRad::Bitsa=>[a]>Int>[a] ordRad[]_=[] ordRad[x]_=[x] ordRadlis(1)=lis ordRadlisbit=(ordRadceros(bit1))++(ordRadunos(bit1)) where ceros=[y| y< lis,testBit ybit==False] unos=[z| z< lis,testBit zbit==True]
11 Feb. 2011
102

Estrucdatos 001

Diunggah oleh

Informasi Dokumen

Judul Asli

Hak Cipta

Format Tersedia

Bagikan dokumen Ini

Bagikan atau Tanam Dokumen

Opsi Berbagi

Apakah menurut Anda dokumen ini bermanfaat?

Apakah konten ini tidak pantas?

Hak Cipta:

Format Tersedia

Estrucdatos 001

Diunggah oleh

Hak Cipta:

Format Tersedia

Estructuras de Datos y Algoritmos Tema 1: Anlisis de Algoritmos

Departamento de Informtica Universidad de Valladolid

Grado en Ingeniera Informtica Grado en Ingeniera Informtica de Sistemas

Csar Vaca Rodrguez, Dpto. de Informtica, UVa

Csar Vaca Rodrguez, Dpto.Informtica, UVa

Tiempo de ejecucin Espacio de almacenamiento

Funcionalidad Robustez Modularidad Mantenibilidad

Facilidad de uso Extensibilidad Correccin

Csar Vaca Rodrguez, Dpto. de Informtica, UVa

Problemas con la medida (tpo)

Dependencia con el tamao de la entrada: No se

Dependencia de valores de la entrada: Aunque

Depencia del procesador: Aunque fijemos el tamao

Csar Vaca Rodrguez, Dpto. de Informtica, UVa

Dependencia del procesador

Solucin: No medir tiempo (segundos, por ejemplo), sino

Operacin Elemental: Toda operacin que tarda un

Definicin estricta: El mnimo nmero de bits necesario

Definicin til: Uno o ms valores relacionados con los

Dependencia con el tamao

Solucin: Expresar la complejidad no mediante un valor

De esa funcin nos interesa, ms que su forma concreta, su ritmo de crecimiento.

Dependencia con los valores

Solucin: Dividir el anlisis en casos.

Mejor y Peor Caso

Anlisis en el peor caso: Calcula la complejidad del

Tpeor(n) = mx{ T(n, entrada) } para toda entrada de tamao n.

Anlisis en el mejor caso: Calcula la complejidad del

Tmejor(n) = min{ T(n, entrada) }

Peor Caso: Para vectores de tamao n, las entradas que

Mejor Caso: Las entradas que hacen que el algoritmo

Caso Promedio (1)

| Sn | denota el nmero de elementos de Sn

Csar Vaca Rodrguez, Dpto. de Informtica, UVa

Caso Promedio (2)

Sn formado por las

que una entrada provoque t operaciones

Csar Vaca Rodrguez, Dpto. de Informtica, UVa

Csar Vaca Rodrguez, Dpto. de Informtica, UVa

Tiempo amortizado (1)

Tiempo amortizado (2)

Sea un algoritmo con las siguientes caractersticas:

Ejemplo: Insercin en vector

Csar Vaca Rodrguez, Dpto. de Informtica, UVa

Peor caso: El peor caso se da cuando se inserta en un

Mejor caso: Cuando el vector no est lleno slo se debe

Caso promedio: No es aplicable, ya que los valores de las

Csar Vaca Rodrguez, Dpto. de Informtica, UVa

Anlisis Tiempo Amortizado

Primer escenario: Si el algoritmo amplia el vector en 100

Segundo escenario: Si el algoritmo duplica la capacidad

Csar Vaca Rodrguez, Dpto. de Informtica, UVa

Csar Vaca Rodrguez, Dpto. de Informtica, UVa

Csar Vaca Rodrguez, Dpto. de Informtica, UVa

El anlisis de la complejidad temporal consiste en contar el nmero de operaciones elementales

Frmula para las iteraciones

Csar Vaca Rodrguez, Dpto. de Informtica, UVa

Csar Vaca Rodrguez, Dpto. de Informtica, UVa

Csar Vaca Rodrguez, Dpto.Informtica, UVa

Csar Vaca Rodrguez, Dpto. de Informtica, UVa

Csar Vaca Rodrguez, Dpto. de Informtica, UVa

cf(n) mayor que g(n) a partir de aqu

Csar Vaca Rodrguez, Dpto. de Informtica, UVa