Tema1 Preliminares

Tema 1: Preliminares
Estructuras de Datos
Grado en Ingeniera de Computadores
Universidad Rey Juan Carlos
Jos Miguel Buenaposada Biencinto
Agradecimientos: a Ana Pradera y Juan Manuel Serrano por el planteamiento del curso, a Antonio Sanz y
a algunos otros profesores del DCC por muchas (o algunas transparencias) segn el caso -.
ndice
1.1 Conceptos previos
1.2 Punteros
1.3 Complejidad
22
URJC-ED-Introduccin
Qu debemos saber sobre Pascal?
Algn entorno de TurboPascal:
Borland Turbo Pascal o bien
Eclipse Gavab 2.0
(http://www.gavab.es/wiki/eclipsegavab/)
Instrucciones de control
URJC-ED-Introduccin 3
Instrucciones de control
Subprogramas
Arrays
Registros
Ficheros

Ciclo de vida del software
Planificacin (estimacin de recursos, coste, tiempo y
viabilidad)
Anlisis: Qu se hace
Diseo: Cmo se hace
Codificacin: Se hace
Codificacin: Se hace
Pruebas: se prueba y se corrige
Documentacin
Uso y mantenimiento: se mejora y ampla
Disear la solucin antes de
programar!
Problema
Algoritmo
Fase de diseo Fase de anlisis
Programa
Fase de implementacin
Atajo
tentador
Normas de estilo
Evitar varias instrucciones en una misma lnea
Tabular adecuadamente el anidamiento de sentencias.
Evitar escribir:
IF precio>MAXIMO THEN WriteLn(Precio abusivo);
Dar nombres nemotcnicos a los identificadores que
describan lo mejor posible su cometido o lo que
representan (subprogramas y variables).
Palabras reservadas: MAYUSCULAS
WHILE, FOR, RECORD,...
Normas de estilo (cont.)
Identificadores: descriptivos y minsculas
Palabras separadas, unidas por _ o utilizando primer
carcter de la palabra sufija mayscula o ambos
nombre_archivo, nombreArchivo, nombre_Archivo
Constantes: MAYUSCULAS Constantes: MAYUSCULAS
IVA, PI, NUMERO_E,...
Procedimientos: Empezando por letra MAYUS.
BusquedaBinaria, Apilar, PilaVacia,...
Tipos: Empezando por Tipo o T
TipoPila, TPila
Mdulos y Ficheros:
Los nombres de programas y mdulos (unidades):
Deben coincidir con los nombres de los ficheros que los
contienen, y
Deben empezar por MAYUSCULAS y resto minsculas
Mdulos y Ficheros:
Deben contener una cabecera de identificacin como esta:
{*************************************************************************************************
{*************************************************************************************************
* *
* Mdulo: Nombre *
* Fichero: ( ) Programa ( ) Espec. TAD ( ) Impl. TAD ( ) Otros *
* Autor(es): Nombre(s) *
* Fecha: Fecha de actualizacin *
* *
* Descripcin: *
* Breve descripcin del mdulo (prrafo corto) *
* *
*************************************************************************************************}
Se recomienda emplear subprogramas para tareas bien
identificadas (abstraccin procedimental).
Emplear sentencias de repeticin (especialmente bucles
FOR y WHILE) cuando sea posible.
Evitar variables globales en subprogramas. Evitar variables globales en subprogramas.
Uso adecuado de funciones (devuelven un valor).
Conceptos aprendidos: Arrays
Un tipo de dato ARRAY se define en la seccin de
declaracin de tipos TYPE
TYPE
ARRAY OF integer
Tipo1 = ARRAY [1..3] OF integer;
TipoVector = ARRAY [1..3] OF real;
TipoMatriz = ARRAY [1..3, 1..7] OF char;
TipoViviendas = ARRAY [1..3, 1..3, A..E] OF boolean;
VAR
var1: Tipo1;
Conceptos aprendidos: Arrays (cont.)
Son estructuras de datos:
De acceso directo: permiten almacenar y recuperar
directamente los datos especificando su posicin
dentro de la estructura.
Homogneas: sus elementos son TODOS del MISMO Homogneas: sus elementos son TODOS del MISMO
TIPO.
Estticas: su tamao se establece de forma FIJA
cuando se declara variable de este tipo y no puede
cambiar su tamao durante la ejecucin del
programa.
Conceptos aprendidos: Registros
Son estructuras de datos:
Heterogneas: sus elementos pueden ser de
DISTINTOS tipos.
Estticas: su tamao se establece de forma FIJA
cuando se declara variable de este tipo. cuando se declara variable de este tipo.
TYPE
TNombreReg = RECORD
idCampo1 : idTipo1;
idCampo2 : idTipo2;
...
idCampon : idTipon
END; {Fin de TNombreReg}
(cont.)
Las funciones no pueden devolver un registro.
Para acceder a un campo se usa el operador punto (.):
nombreVariableRegistro.nombreCampo
Tambin podemos acceder a los campos de un registro Tambin podemos acceder a los campos de un registro
abriendo el registro con la sentencia WITH:
WITH nombreVariableRegistro DO
Instruccin que con una expresin con nombreCampo
(cont.)
Con sentencia WITH:
VAR
profesor : TFicha;
...
BEGIN
writeln(profesor.nombre, profesor.edad, profesor.sueldo);
Con sentencia WITH:
VAR
profesor : TFicha;
...
BEGIN
WITH profesor DO
writeln(nombre,edad,sueldo);
ndice
1.2 Punteros
1.3 Complejidad
16 16
URJC-ED-Introduccin
Memoria dinmica y punteros
Las estructuras de datos que conocemos (ARRAY,
RECORD, integer, ) son de memoria esttica.
Cuando no se sabe cunta memoria se va a necesitar
para una estructura de datos en ejecucin, el programa
pedir (y devolver) al sistema memoria dinmicamente
para una estructura de datos en ejecucin, el programa
pedir (y devolver) al sistema memoria dinmicamente
(cuando sea necesario).
La gestin de memoria dinmica en muchos lenguajes
de programacin se realiza a travs de punteros.
Punteros
Una variable puntero sirve para albergar la direccin de
memoria de otra variable (es decir, apunta a otra
variable).
Utilizando punteros podremos:
Pedir (reservar) nueva memoria dinmica al sistema.
Liberar la memoria a la que se apunta. Liberar la memoria a la que se apunta.
Acceder al valor del dato al que se apunta.
Pascal (como C, C++, y otros lenguajes) posee
mecanismos para manejar memoria dinmica a travs
de punteros.
Declaracin de enteros en Pascal
Recordemos como declarar una variable entera x:
VAR
x: integer; { reserva memoria para un dato entero }
El compilador de Pascal reservar 2 bytes en una posicin de
memoria (podra ser un registro de la CPU) a la que llamar x.
Declaracin de punteros en Pascal
Declaracin de un tipo y una variable p puntero a un
entero:
TYPE
TipoPuntero = înteger; {tipo puntero a entero}
VAR
p: TipoPuntero; { reserva una celda de memoria que
El compilador de Pascal reservar N bytes (los necesarios para
almacenar una direccin de memoria) en una posicin de memoria
(podra ser un registro de la CPU) a la que llamar p.
p: TipoPuntero; { reserva una celda de memoria que
pueda contener la direccin de
memoria de una variable entera }
NIL, es una constante de tipo puntero que indica que
no apunta a ninguna celda de memoria.
El puntero a ninguna parte
TYPE
TipoPuntero = înteger; {tipo puntero a entero}
VAR
Grficamente: distinto de dir. no asignada:
VAR
p: TipoPuntero; { no est inicializada, contiene un
valor indeterminado que no es NIL }
BEGIN
p := NIL; { p no apunta a ninguna direccin }
p p ?
Operaciones con punteros
Comparacin ( = y <> ) y asignacin ( := ) de punteros.
Direccin de una variable v: @v
Se obtiene la direccin de memoria de una variable para
asignarla a un puntero a ese tipo de variable. asignarla a un puntero a ese tipo de variable.
Contenido de un puntero p: p^
Se accede a la variable apuntada por el puntero (a su
contenido).
Ejemplo de operaciones con punteros
TYPE
TipoPuntero = înteger;
VAR
i: integer;
p: TipoPuntero;
BEGIN
p := NIL;
i := 7;
p := @i; { Asignar la direccin de la variable i a p }
p^ := 3; { Cambiar el contenido de lo apuntado por p }
write(i); {escribe el valor 3}
TYPE
VAR
i: integer;
p: TipoPuntero;
BEGIN
p := NIL;
i := 7;
p ? ?
38 Dir. Memoria: 90
i
TYPE
VAR
i: integer;
p: TipoPuntero;
BEGIN
p := NIL;
i := 7;
p ? ?
38 Dir. Memoria: 90
i
TYPE
VAR
i: integer;
p: TipoPuntero;
BEGIN
p := NIL;
i := 7;
p ? 7
38 Dir. Memoria: 90
i ?
TYPE
VAR
i: integer;
p: TipoPuntero;
BEGIN
p := NIL;
i := 7;
p 38 7
38 Dir. Memoria: 90
i
Se dice que p apunta a i
TYPE
VAR
i: integer;
p: TipoPuntero;
BEGIN
p := NIL;
i := 7;
p 38 3
38 Dir. Memoria: 90
i
Se dice que p apunta a i
Ejemplo de operacin ilegal
p^ referencia la celda apuntada por p:
TYPE
VAR
i: integer;
p: TipoPuntero;
BEGIN
p := NIL;
p^:= 3; { almacena el valor 3 en la celda de
p^:= 3; { almacena el valor 3 en la celda de
memoria apuntada por p }
p := 3; { operacin ilegal: 3 es integer mientras que
p es TipoPuntero y slo puede contener una
direccin de memoria de una variable integer}
Operador contenido ^: ARRAY
Para un puntero a una variable ARRAY:
TYPE
TipoArray = ARRAY [1..2] OF integer;
TipoPuntero = ^TipoArray;
VAR
a: TipoArray;
a: TipoArray;
p: TipoPuntero;
BEGIN
p := @a;
p^[1] := 5;
p^[2] := 3;
Operador contenido ^: RECORD
Para un puntero a una variable registro:
TYPE
TipoRegistro = RECORD
dato: integer;
indice: integer
END;
END;
TipoPuntero = ^TipoRegistro;
VAR
r: TipoRegistro;
p: TipoPuntero;
BEGIN
p := @r;
p^.dato := 5;
Qu valores escribe el programa?
Ejercicio 1
PROGRAM Ejer1;
VAR
a, b: integer;
pb: înteger;
BEGIN
a := 10;
pb := @a;
b := pb^;
writeln(a, , b);
END.
Ejercicio 2
PROGRAM Ejer2;
VAR
a: string;
pa, pb: ^string;
BEGIN
a := Hola;
pa := @a;
pb := pa;
writeln(a);
pb^ := Adios;
writeln(a);
END.
Peticin de nueva memoria dinmica
new, procedimiento que reserva una nueva celda de
memoria dinmica e inicializa la variable puntero tal que
apunte a esta nueva celda.
TYPE
Si p es un puntero a integer reserva espacio para
contener un integer. Si p es un puntero a char
reserva espacio para albergar una valor de tipo char.
VAR
p: TipoPuntero;
BEGIN
new(p);
Semntica del procedimiento new
TYPE
VAR
p: TipoPuntero;
BEGIN
new(p);
p ?
Dir. Memoria: 90
Semntica del procedimiento new
TYPE
VAR
p: TipoPuntero;
BEGIN
new(p);
p 54 ?
Dir. Memoria: 90
Se dice que p apunta a un entero
54
Memoria dinmica
(del heap o montn)
Liberacin de memoria dinmica
dispose, procedimiento que libera el espacio de
memoria indicado por la variable puntero que se pasa
como parmetro.
TYPE
VAR
p: TipoPuntero;
BEGIN
new(p);
dispose(p);
{ Una referencia posterior a p^ puede ser desastrosa,
pues p apuntar a una celda que ya no est reservada.
Conviene asignarle NIL }
p = NIL;
Semntica del procedimiento dispose
TYPE
VAR
p: TipoPuntero;
BEGIN
new(p);
dispose(p);
p := NIL;
p := NIL;
p ?
Dir. Memoria: 90
TYPE
VAR
p: TipoPuntero;
BEGIN
new(p);
dispose(p);
p := NIL;
p := NIL;
p 54 ?
Dir. Memoria: 90
54
Memoria dinmica
(del heap o montn)
TYPE
VAR
p: TipoPuntero;
BEGIN
new(p);
dispose(p);
p := NIL;
p := NIL;
p 54 ?
Dir. Memoria: 90
54
Memoria dinmica
(del heap o montn)
marcada como libre
TYPE
VAR
p: TipoPuntero;
BEGIN
new(p);
dispose(p);
p := NIL;
p := NIL;
p
Dir. Memoria: 90
Al trabajar con punteros hay que
Declarar una variable de tipo puntero.
Si es necesario reservar memoria en tiempo de
ejecucin llamar a new.
Despus de llamar a new el valor del contenido del
puntero es indefinido (es necesario asignarle un valor). puntero es indefinido (es necesario asignarle un valor).
Variable_puntero es diferente de: Variable_puntero^
Es necesario liberar el espacio de memoria (dispose)
cuando no se vaya a utilizar ms el dato apuntado.
Qu hace el programa?
Ejercicio 3
PROGRAM Ejer3;
VAR
pa, pb: ^string;
BEGIN
BEGIN
new(pa);
pa^ := Hola;
pb := pa;
writeln(pa^);
pb^ := Adios;
writeln(pa^);
dispose(pb);
END.
Perdida de memoria (memory leak)
La memoria disponible en el heap es limitada y cada vez
que se llama a new una parte de esa memoria se marca
como ocupada.
Cada vez que se llama a dispose, la memoria ocupada
se marca como libre.
Cuando se pide memoria con new(p) y se asigna otra
direccin a p antes de hacer un dispose(p) se
produce una prdida de memoria (la memoria apuntada
por p queda ocupada e inaccesible).
Error de acceso
Cada vez que se llama a dispose(p), la memoria
ocupada se marca como libre pero p mantiene la
direccin anterior al dispose.
Inmediantamente despus de dispose(p)un acceso
al contenido de p, p^, producir un error de
ejecucin.
Qu hace el programa?
Ejercicio 4
PROGRAM Ejer4;
VAR
pa, pb: ^string;
BEGIN
BEGIN
new(pa);
pa^ := Hola;
new(pb);
pb := pa;
writeln(pa^);
pb^ := Adios;
writeln(pa^);
dispose(pb);
dispose(pa);
END.
Punteros en llamadas a subprogramas
Pueden ser parmetros por valor y por referencia de los
subprogramas:
FUNCTION F1 (VAR p1: înteger; p2: înteger): integer;
PROCEDURE F2 (VAR p1: înteger; p2: înteger);
Se pueden devolver como resultado de una funcin:
FUNCTION F2 (a: integer): înteger;
VAR
p: înteger;
BEGIN
p := F2(4);
Punteros en llamadas a subprogramas

(cont.)
El paso de punteros por valor equivale al paso por
referencia de la variable que apuntan.
El subprograma recibe una copia del puntero y apunta a la
misma informacin que el original,
Un cambio en esa informacin es un cambio en la apuntada por
el puntero original.
PROCEDURE Ej3 (p1: înteger);
BEGIN
END;
VAR
p: înteger; i: integer;
BEGIN
i := 2; p := @i;
Ej3(p);
p 23 2
23 Dir. Memoria: 129
i
p1 es copia de p
23 p1
Ejercicio 5
PROGRAM Ejer5;
TYPE
TPuntEnt = înteger;
PROCEDURE X( x: TPuntEnt;
VAR
a, b, c: integer;
BEGIN { Ejer5 }
a := 2;
PROCEDURE X( x: TPuntEnt;
y: integer;
VAR z: integer
);
BEGIN
x^ := x^ * x^;
y := y * y;
z := z * z;
END;
a := 2;
b := 3;
c := 4;
X(@a, b, c);
writeln(a, ,b, , c);
END. { Ejer 5 }
ndice
1.2 Punteros
1.3 Complejidad
50 50
URJC-ED-Introduccin
Definicin de la complejidad
La complejidad o eficiencia de un algoritmo se define
como el orden de magnitud de los recursos informticos
que requiere el algoritmo para ser ejecutado.
El estudio de la complejidad de los algoritmos permite
evaluar su coste, y as:
Comparar algoritmos entre s.
Averiguar si un algoritmo es factible.
Motivacin en Estructuras de Datos
Una estructura de datos:
Una especificacin nica (lo veremos).
Mltiples posibles implementaciones (lo veremos)
Cmo elegir entre las posibles implementaciones?
Evaluando su complejidad!
Aspectos que intervienen en el clculo
de complejidades
Cules son los recursos informticos que hay que
estimar.
En qu casos (para qu tipo de entradas) hay que
estimar la complejidad. estimar la complejidad.
Qu significa calcular el orden de magnitud.
Qu reglas prcticas existen para calcular
complejidades.
Recursos informticos
Los recursos informticos a evaluar son el tiempo (de
ejecucin) y/o el espacio (de memoria) requeridos por
los algoritmos.
Ambos dependen del tamao de la entrada. Se trata de Ambos dependen del tamao de la entrada. Se trata de
calcular las funciones T
A
y E
A
:
T
A
(n) = tiempo requerido para la ejecucin del algoritmo A con
una entrada de tamao n.
E
A
(n) = espacio de memoria requerido para la ejecucin del
algoritmo A con una entrada de tamao n.
Cmo estimar los recursos?
Mtodo emprico:
Programar el algoritmo y ejecutarlo en un ordenador.
Inconveninente: el resultado depende del programador, el
lenguaje elegido y la CPU.
Mtodo terico:
Calcular el nmero de operaciones bsicas que realiza el
algoritmo.
Ventajas: el resultado no depende ni del programador, ni del
lenguaje, ni de la CPU.
Cmo estimar los recursos (tiempo)?
Una operacin bsica es aquella cuyo tiempo de
T
A
(n) = nmero de operaciones bsicas que realiza el
algoritmo A con una entrada de tamao n
Una operacin bsica es aquella cuyo tiempo de
ejecucin se puede acotar superiormente por una
constante, independientemente del tamao de la
entrada, la CPU, el lenguaje de programacin, el
compilador, etc.
Casos para el estudio de la complejidad
Las funciones T
A
y E
A
no slo dependen del tamao de
la entrada, sino tambin de su contenido:
no se tarda lo mismo en ordenar 10 nmeros ya
ordenados que en ordenar 10 nmeros totalmente
desordenados ! desordenados !
Habr diferentes tipos de entradas unas ms difciles y
otras ms fciles para un algoritmo determinado.
Una estructura de datos:
El mejor caso, caso extremo en el que el nmero de
operaciones a ejecutar (o el espacio requerido) es el
menor posible
fin := FALSO;
k := 1;
MIENTRAS (k<=N) Y (NO fin) HACER
SI (V[k] == buscado)
fin := true;
k := k + 1;
Cmo es el array V (de
tamao N) que produce el
menor nmero de
iteraciones?
El caso medio o caso probabilstico, que representa
una situacin intermedia (su evaluacin suele
requerir tcnicas estadsticas).
fin := FALSO;
k := 1;
fin := true;
k := k + 1;
Nmero promedio de
iteraciones suponiendo
igual probabilidad de
encontrar buscado en
cualquier posicin de V
(de tamao N)?
El peor caso, caso extremo en el que el nmero de
mayor posible
fin := FALSO;
k := 1;
fin := true;
k := k + 1;
Cmo es el array V (de
tamao N) que produce el
mayor nmero de
iteraciones?
El clculo en el peor caso asegura que los recursos
El peor caso, caso extremo en el que el nmero de
mayor posible
El clculo en el peor caso asegura que los recursos
reales consumidos, sea cual sea el contenido de la
entrada, nunca rebasarn el valor calculado!
Medidas asintticas de complejidad
Si hay que ordenar un conjunto de 5 elementos, la
eficiencia del algoritmo no importa demasiado (en
cualquier caso el tiempo de ejecucin ser pequeo).
Para analizar las funciones T
A
y E
A
bastar con estudiar
su comportamiento asinttico (cmo se comportan
cuando el tamao de la entrada, n, es grande).
Medidas asintticas de complejidad
Existen varias medidas para estudiar el comportamiento
asinttico de una funcin:
Notacin O grande: O(f(n)) (cota superior: la ms
usada) usada)
Notacin Omega: (f(n)) (cota inferior)
Notacin Theta: (f(n)) (cota media)
Notacin asinttica O()
Dada una funcin f, queremos estudiar aquellas
funciones g que a lo sumo crecen tan deprisa como f.
Al conjunto de tales funciones se le llama cota superior
de f y lo denominamos O(f).
Definicin notacin asinttica O()
Se dice que f es del orden de g, f(n) O(g(n)), si y slo
si existen dos constantes positivas C y k tales que f(n)
Cg(n) para todo n k.
Algunas propiedades tiles
O(log
b
n) = O(log
c
n)
g(n) = a
m
n
m
+ a
m-1
n
m-1
+ ... + a
1
n + a
0
O(n
m
) si a
m
0
g(n) = = cn O(n)
=
n
1 i
c
g(n) =
g(n) =
=1 i
) O(n
2
n)n (1
2
trm ltimo)n (primero
i
2
n
1 i
+
=
+
=
=
) O(n
6
1) 1)(2n n(n
i
3
n
1 i
2
+ +
=
=
Conjuntos O(f) ms importantes y su
ordenacin
O(1)
complejidad constante
O(log n)
complejidad logartmica
O(n)
complejidad lineal
O(n
p
)
complejidad polinmica (p=2: cuadrtica, p=3: cbica)
O(n
p
)
complejidad polinmica (p=2: cuadrtica, p=3: cbica)
O(2
n
)
complejidad exponencial
O(n!)
complejidad factorial
O(1) O(log n) O(n) O(n log n) O(n
p
) O(2
n
) O(n!)
Conjuntos O(f) ms importantes y su
ordenacin (cont.)
El tamao de la entrada importa
Es mejor un algoritmo de O(n) que otro de O(n
2
)?
Depende del tamao de las entradas, n, que se espera
procesar.
Algoritmo 1: T
1
(n) = 5n
2
Algoritmo 2: T
2
(n) = 400n
5n
2
/400n = n/80
entradas n>80?
entradas n=80?
entradas n<80?
En resumen
Para calcular la complejidad de un algoritmo A:
Estudiar el comportamiento asinttico de las funciones T
A
/E
A
(dependientes del tamao n de la entrada al algoritmo) en el
peor caso o en un caso medio.
Encontrar una funcin f tal que en el peor caso/caso medio se
tenga T
A
/E
A
O(f ).
Los conjuntos O(f ) proporcionan cotas superiores. Se

tratar de encontrar la menor de todas las funciones f
tal que T
A
/E
A
O(f ).
Reglas prcticas para el clculo de la

complejidad
Todo algoritmo est compuesto por una secuencia de
instrucciones.
Existen unas reglas prcticas para calcular el coste de
cada uno de los posibles tipos de instrucciones.
La complejidad de un algoritmo se basa en el coste de La complejidad de un algoritmo se basa en el coste de
las instrucciones que lo componen pero el clculo
depende de si el algoritmo es o no recursivo.
Las reglas que se dan a continuacin permiten calcular
la complejidad en el peor caso de los distintos tipos de
instrucciones.
Regla 1: Instrucciones elementales
Se llama instruccin elemental a las operaciones de entrada/salida,
asignaciones y expresiones aritmticas en las que no est
involucrada ninguna variable que dependa del tamao de la entrada
del algoritmo..
[ ] ) 1 ( O T elemental n instrucci I
I

Regla 2: Secuencias de instrucciones
;
2 1
I I I

)) , ( (
) (
) (
2 1
2
1
2
1
f f mx O T
f O T
f O T
I
I
I

Regla 3: Instrucciones de seleccin

)) , , ( (
) (
) (
) (
2 1
2
1
2 1
2
1
f f f mx O T
f O T
f O T
f O T
I NO SI I ENTONCES B SI I
B I
I
I
B B

2
2
I
)) ,..., , ( (
} ,..., 1 { ), (
) (
: ... : 1
1
1
k E I
i I
E E
k
f f f mx O T
k i f O T
f O T
I k caso I caso EN E CASO I
i

Regla 4: Instrucciones de repeticin
) (
), (
) ( .
1
;
iter
f
i
i I
i J B
iter
f O T
i iteracin la en f O T
caso peor s iteracione nm f
J HACER B MIENTRAS I
La complejidad de un bucle
se calcula igual que la de un bucle MIENTRAS salvo que en el caso
PARA el coste de la condicin B se puede ignorar puesto que es
siempre constante.
PARA i DESDE a
1
HASTA a
2
HACER J
Ejemplos
PARA i DESDE 1 HASTA n HACER {1}
x := x + 1
PARA j DESDE 1 HASTA n HACER
x := x + 1
PARA j DESDE 1 HASTA i HACER
x := x + 1
i := 1 {4}
MIENTRAS i <= n HACER
x := x + 1
i := i + 2
Ejemplos (cont.)
PARA i DESDE 1 HASTA n-1 HACER {6}
PARA j DESDE i+1 HASTA n HACER
x := x + 1
x := 1 {5}
MIENTRAS x <= n HACER
x := x*2
x := x + 1
Regla 5: Llamadas a subprogramas
La complejidad de la instruccin que llama al
subprograma es equivalente a la complejidad que
resulta de ejecutar el subprograma
[ ] ) ( ) ( n T n T P a subprogram un a llamada I
p I
=
La complejidad depender de si el programa es o no
recursivo.
p I
Regla 5.1: Subprogramas no
recursivos
Su complejidad es el mximo de las complejidades de
las instrucciones que lo componen (la complejidad de
cada una de estas instrucciones se calcula aplicando las
reglas anteriores 1 a 4 -). reglas anteriores 1 a 4 -).
Regla 5.2: Subprogramas recursivos
Para calcular la complejidad de un algoritmo recursivo
es necesario realizar dos pasos:
1. Plantear la ecuacin recurrente asociada con el
tiempo de ejecucin, T(n), del subprograma. tiempo de ejecucin, T(n), del subprograma.
2. Resolver la ecuacin recurrente anterior (encontrar
una expresin no recursiva para el valor de T(n)). :
Paso 1: plantear la ecuacin recurrente
SUBPROGRAMA P( n ); { n = tamao entrada }
SI es_caso_sencillo(n) ENTONCES
instrucciones_caso_sencillo; { No recursivas }
SI NO { Caso recursivo }
P(reduccin(n));
Si a=1 recursividad lineal, si a>1 recursividad mltiple.

P(reduccin(n)); { a llamadas recursivas a P }

instrucciones_caso_resursivo; { No recursivas }
Paso 1: plantear la ecuacin recurrente
De la estructura general anterior podemos obtener la
ecuacin recurrente asociada a T(n):
+
=
c o e n g n reduccin T a
n sencillo caso es si n f
n T
. . ) ( )) ( (
) ( _ _ ) (
) (
Donde:
f(n): coste de las instrucciones_caso_sencillo
a: nmero de llamadas recursivas que se realizan
g(n): coste de las instrucciones_caso_recursivo
+ c o e n g n reduccin T a . . ) ( )) ( (
Ejemplo 1
FUNCIN Ejemplo1(num:Natural) DEVUELVE Natural
SI num < 1 ENTONCES
DEV 1
SI NO
DEV num * Ejemplo1(num-1);
Ejemplo 1
Tamao de la entrada
es_caso_sencillo(n)
instrucciones_caso_sencillo
SI num < 1 ENTONCES
DEV 1
SI NO
n llamadas recursivas
reduccin(n)
instrucciones_caso_recursivo
+
=
n T
. . ) ( )) ( (
) ( _ _ ) (
) (
Ejemplo 1
Tamao de la entrada parmetro entrada num
es_caso_sencillo(n)
SI num < 1 ENTONCES
DEV 1
SI NO
reduccin(n)
+
=
n T
. . ) ( )) ( (
) ( _ _ ) (
) (
Ejemplo 1
es_caso_sencillo(n) n<1
SI num < 1 ENTONCES
DEV 1
SI NO
reduccin(n)
+
<
=
n si n f
n T
. . ) ( )) ( (
1 ) (
) (
Ejemplo 1
instrucciones_caso_sencillo DEVOLVER 1, con coste O(1)
SI num < 1 ENTONCES
DEV 1
SI NO
reduccin(n)
+
<
=
n si
n T
. . ) ( )) ( (
1 1
) (
Ejemplo 1
SI num < 1 ENTONCES
DEV 1
SI NO
n llamadas recursivas 1
reduccin(n)
+
<
=
c o e n g n reduccin T
n si
n T
. . ) ( )) ( ( 1
1 1
) (
Ejemplo 1
SI num < 1 ENTONCES
DEV 1
SI NO
reduccin(n) n-1
+
<
=
c o e n g n T
n si
n T
. . ) ( ) 1 ( 1
1 1
) (
Ejemplo 1
SI num < 1 ENTONCES
DEV 1
SI NO
reduccin(n) n-1
instrucciones_caso_recursivo multiplicacin, con coste O(1)
+
<
=
c o e n T
n si
n T
. . 1 ) 1 ( 1
1 1
) (
Ejemplo 2
FUNCIN Ejemplo2(num1, num2: Natural) DEVUELVE Natural
SI num = 0 ENTONCES DEV num2;
SI NO
SI num1 = 1 ENTONCES DEV num2*num2;
SI NO
PARA i DESDE 1 HASTA num1 HACER
num2 := num2 + i;
DEV Ejemplo2(num1-2,num2)*Ejemplo2(num1-2,num2+num1);
Ejemplo 2
Tamao de la entrada
SI NO
SI NO
num2 := num2 + i;
Tamao de la entrada
es_caso_sencillo(n)
reduccin(n)
+
=
n T
. . ) ( )) ( (
) ( _ _ ) (
) (
Ejemplo 2
Tamao de la entrada num1
SI NO
SI NO
num2 := num2 + i;
es_caso_sencillo(n)
reduccin(n)
+
=
n T
. . ) ( )) ( (
) ( _ _ ) (
) (
Ejemplo 2
SI NO
SI NO
num2 := num2 + i;
es_caso_sencillo(n) n<2 (n=0 n=1)
reduccin(n)
+
<
=
n si n f
n T
. . ) ( )) ( (
2 ) (
) (
Ejemplo 2
SI NO
SI NO
num2 := num2 + i;
instrucciones_caso_sencillo multiplicacin y retorno valor, O(1)
reduccin(n)
+
<
=
n si
n T
. . ) ( )) ( (
2 1
) (
Ejemplo 2
SI NO
SI NO
num2 := num2 + i;
reduccin(n)
+
<
=
n si
n T
. . ) ( )) ( ( 2
2 1
) (
Ejemplo 2
SI NO
SI NO
num2 := num2 + i;
reduccin(n) n-2
+
<
=
c o e n g n T
n si
n T
. . ) ( ) 2 ( 2
2 1
) (
Ejemplo 2
SI NO
SI NO
num2 := num2 + i;
reduccin(n) n-2
instrucciones_caso_recursivo bucle O(n) y resto O(1) O(n)
+
<
=
c o e n n T
n si
n T
. . ) 2 ( 2
2 1
) (
Ejemplo 3
SI num < 2 ENTONCES
DEV num
SI NO
DEV 5 * Ejemplo3(num/2) + num;
Ejemplo 3
Tamao de la entrada
es_caso_sencillo(n)
SI num < 2 ENTONCES
DEV num
SI NO
reduccin(n)
+
=
n T
. . ) ( )) ( (
) ( _ _ ) (
) (
Ejemplo 3
es_caso_sencillo(n)
SI num < 2 ENTONCES
DEV num
SI NO
reduccin(n)
+
=
n T
. . ) ( )) ( (
) ( _ _ ) (
) (
Ejemplo 3
SI num < 2 ENTONCES
DEV num
SI NO
reduccin(n)
+
<
=
n si n f
n T
. . ) ( )) ( (
2 ) (
) (
Ejemplo 3
instrucciones_caso_sencillo DEVOLVER num, O(1)
SI num < 2 ENTONCES
DEV num
SI NO
reduccin(n)
+
<
=
n si
n T
. . ) ( )) ( (
2 1
) (
Ejemplo 3
SI num < 2 ENTONCES
DEV num
SI NO
reduccin(n)
+
<
=
n si
n T
. . ) ( )) ( ( 1
2 1
) (
Ejemplo 3
SI num < 2 ENTONCES
DEV num
SI NO
reduccin(n) n/2
+
<
=
c o e n g n T
n si
n T
. . ) ( ) 2 / ( 1
2 1
) (
Ejemplo 3
SI num < 2 ENTONCES
DEV num
SI NO
reduccin(n) n/2
instrucciones_caso_recursivo multiplicacin, suma, devolucin, O(1)
+
<
=
c o e n T
n si
n T
. . 1 ) 2 / ( 1
2 1
) (
Ejemplo 3
SI num < 2 ENTONCES
DEV num
SI NO
reduccin(n) n/2
instrucciones_caso_recursivo multiplicacin, suma, devolucin, O(1)
+
<
=
c o e n T
n si
n T
. . 1 ) 2 / ( 1
2 1
) (
Ejemplo 4
FUNCIN Ejemplo4(num, x: Natural) DEVUELVE Natural
SI num < 2 ENTONCES
DEV x
SI NO
PARA i DESDE 1 HASTA num HACER
x := x+1;
DEV Ejemplo4(num/2,x);
Ejemplo 4
Tamao de la entrada
es_caso_sencillo(n)
SI num < 2 ENTONCES
DEV x
SI NO
x := x+1;
es_caso_sencillo(n)
reduccin(n)
+
=
n T
. . ) ( )) ( (
) ( _ _ ) (
) (
Ejemplo 4
es_caso_sencillo(n)
SI num < 2 ENTONCES
DEV x
SI NO
x := x+1;
es_caso_sencillo(n)
reduccin(n)
+
=
n T
. . ) ( )) ( (
) ( _ _ ) (
) (
Ejemplo 4
es_caso_sencillo(n)
SI num < 2 ENTONCES
DEV x
SI NO
x := x+1;
reduccin(n)
+
<
=
n si n f
n T
. . ) ( )) ( (
2 ) (
) (
Ejemplo 4
es_caso_sencillo(n)
SI num < 2 ENTONCES
DEV x
SI NO
x := x+1;
reduccin(n)
+
<
=
n si
n T
. . ) ( )) ( (
2 1
) (
Ejemplo 4
es_caso_sencillo(n)
SI num < 2 ENTONCES
DEV x
SI NO
x := x+1;
reduccin(n)
+
<
=
n si
n T
. . ) ( )) ( ( 1
2 1
) (
Ejemplo 4
es_caso_sencillo(n)
SI num < 2 ENTONCES
DEV x
SI NO
x := x+1;
reduccin(n) n/2
+
<
=
c o e n g n T
n si
n T
. . ) ( ) 2 / ( 1
2 1
) (
Ejemplo 4
es_caso_sencillo(n)
SI num < 2 ENTONCES
DEV x
SI NO
x := x+1;
reduccin(n) n/2
instrucciones_caso_recursivo bucle O(n) y resto O(1) O(n)
+
<
=
c o e n n T
n si
n T
. . ) 2 / ( 1
2 1
) (
Paso 2: Resolver la ecuacin recurrente
En general, no es fcil. Existen algunos tipos de
ecuaciones recurrentes para los que s se conoce su
solucin:
1. Ecuaciones recurrentes obtenidas mediante
substraccin: substraccin:
Aquellas en las que reduccin(n) = n-b.
2. Ecuaciones recurrentes obtenidas mediante divisin:
Aquellas en las que reduccin(n) = n/b.
Ecuaciones recurrentes obtenidas
mediante substraccin
Son de la forma:
+
<
=
b n si n c b n T a
b n si n c
n T
k
k
) (
0
) (
Donde:
a = nmero de llamadas recursivas que se realizan
n - b = tamao de los sub-problemas generados
cn
k
= coste de las instrucciones que no son llamadas recursivas

mediante substraccin
Solucin mediante frmula cerrada:
>
=
+
1 ) (
1 ) (
) (
1
a si a O
a si n O
n T
b div n
k
Slo es aplicable para cuando f(n) y g(n) son potencias
de n.
Ejemplo 1: sol. expansin recurrencias
+
<
=
c o e n T
n si
n T
. . 1 ) 1 ( 1
1 1
) (
Ejemplo 1: sol. frmula cerrada
+
<
=
c o e n T
n si
n T
. . 1 ) 1 ( 1
1 1
) (
+
<
=
c o e n n T
n si
n T
. . ) 2 ( 2
2 1
) (
+
<
=
c o e n n T
n si
n T
. . ) 2 ( 2
2 1
) (
mediante divisin
Son de la forma:
+
<
=
b n si n c b n T a
b n si n c
n T
k
k
) / (
1
) (
Donde:
a = nmero de llamadas recursivas que se realizan
n /b = tamao de los sub-problemas generados
cn
k
= coste de las instrucciones que no son llamadas recursivas

mediante divisin
Solucin mediante frmula cerrada:
>
=
<
k a
k k
k k
b a si n O
b a si n n O
b a si n O
n T
b
) (
) log (
) (
) (
log
Slo es aplicable para cuando f(n) y g(n) son potencias
de n.
>
k a
b a si n O
b
) (
log
+
<
=
c o e n T
n si
n T
. . 1 ) 2 / ( 1
2 1
) (
+
<
=
c o e n T
n si
n T
. . 1 ) 2 / ( 1
2 1
) (
+
<
=
c o e n n T
n si
n T
. . ) 2 / ( 1
2 1
) (
+
<
=
c o e n n T
n si
n T
. . ) 2 / ( 1
2 1
) (

Tema1 Preliminares

Cargado por

Información del documento

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Tema1 Preliminares

Cargado por

Copyright:

Formatos disponibles

Tema 1: Preliminares

Punteros en llamadas a subprogramas

Los conjuntos O(f ) proporcionan cotas superiores. Se

Reglas prcticas para el clculo de la

Regla 3: Instrucciones de seleccin

Si a=1 recursividad lineal, si a>1 recursividad mltiple.

P(reduccin(n)); { a llamadas recursivas a P }

Ecuaciones recurrentes obtenidas

Ejemplo 1: sol. expansin recurrencias

Ecuaciones recurrentes obtenidas

También podría gustarte