Trabajo Práctico 3 - Departamento de Ciencias e Ingeniería de la

TRABAJO PRÁCTICO Nº 3
ESTRUCTURAS DE DATOS Y ALGORITMOS
Licenciatura en Ciencias de la Computación - Primer cuatrimestre de 2008
Departamento de Ciencias e Ingeniería de la Computación - Universidad Nacional del Sur
Cálculo de tiempo de ejecución
Bibliografía:
Aho, Hopcroft y Ullman. Estructuras de datos y algoritmos. [A]
Ejercicio 1: "
Sean P1 y P2 dos programas cuyos tiempos de ejecución son T1(n) y T2(n) respectivamente, donde
n es el tamaño de la entrada. Determine para los siguientes casos en qué condiciones P2 se ejecuta
más rápido que P1.
a)
b)
c)
T2 ( n) = 1000. n
T2 ( n ) = 3. n 3
T2 ( n ) = 12. n 4
T1 ( n ) = 2. n 2
T1 ( n ) = 3. n 4
T1 ( n ) = 126. n 2
Ejercicio 2:
¿Qué significa que el tiempo de ejecución T(n) de un programa P sea O(f(n))? ¿Qué significado
tiene la función f(n)? ¿y la notación Ω(g(n))? Según su criterio, ¿cuál es la utilidad de este tipo de
cálculos?
Ejercicio 3: "
Considere las siguientes funciones f: N ∪ {0} Æ R+
f 1 ( n ) = 2 n 5 − 16 n 3
⎧n 4 si n > 40
f 3 ( n) = ⎨ 3
⎩n si 0 ≤ n ≤ 40
f 2 (n) = 2n5
⎧2n 3 si n es par
f 4 ( n) = ⎨ 4
⎩5n si n es impar
a) Muestre que f1 es O(f2), y que f4 es Ω(n4)
b) ¿ f3 es O(f4) ?
c) Calcule O(f3 + f4)
Ejercicio 4:
Calcule el orden del tiempo de ejecución para cada uno de los procedimientos implementados en el
Trabajo Práctico 2. Justifique sus respuestas.
Ejercicio 5: Determine el caso más desfavorable de los tiempos de ejecución de las siguientes rutinas como una
función de N:
a) Calculando el tiempo de ejecución T(n).
b) Calculando el orden del tiempo de ejecución. Asuma que el tiempo de ejecución de una
instrucción de asignación, comparación, RETURN, lectura o escritura, es una constante C.
1
TRABAJO PRÁCTICO Nº 3
ESTRUCTURAS DE DATOS Y ALGORITMOS
Licenciatura en Ciencias de la Computación - Primer cuatrimestre de 2008
Departamento de Ciencias e Ingeniería de la Computación - Universidad Nacional del Sur
Nota: Fórmulas útiles para el cálculo de T(n)
n
∑1=
i =1
n
∑
i =1
i2 =
n
n
∑
i =1
k = kn
n
∑1=
n − i+1
j=i
1
n ( n + 1 )( 2 n + 1 )
6
n
∑
i = ( a + n )( n − a + 1 )
i= a
n
∑
i 3 = n 2 ( n + 1) 2
i=1
1
4
Rutinas:
(* ……………………………………………………………………………………………………………… *)
PROCEDURE Ejemplo1(n : INTEGER);
VAR a,b,i,j: INTEGER;
BEGIN
i :=1; j := 2;
FOR a :=1 TO n DO
IF NumeroLindo(a) THEN
FOR b := a+1 TO n DO i := i*3 END;
FOR b := 1
TO a DO j := j-2 END;
ELSE
i := i*2
END
END
END Ejemplo1;
(* ……………………………………………………………………………………………………………… *)
PROCEDURE Muestra1 (VAR T : ARRAY [1..N] OF INTEGER);
VAR i:INTEGER;
BEGIN
For i:=1 TO N DO WrInt(T[I]); END;
END Muestra;
(* ……………………………………………………………………………………………………………… *)
PROCEDURE Imprime(i: INTEGER; T : ARRAY [1..N] OF INTEGER);
BEGIN
WrInt(T[i]);
END Mostrar;
(* ……………………………………………………………………………………………………………… *)
PROCEDURE Muestra2 (VAR T : ARRAY [1..N] OF INTEGER);
VAR i:INTEGER;
BEGIN
FOR i:=1 TO N DO Imprime(T[i]); END;
END Muestra;
(* ……………………………………………………………………………………………………………… *)
// Sea TABLA = ARRAY [1..N] OF INTEGER;
PROCEDURE Muestra2 (VAR UNO : TABLA);
VAR NUEVO : ARRAY [1..N] OF TABLA; I : INTEGER;
BEGIN
FOR I := 1 TO N DO NUEVO[I] := UNO; END;
END Muestra;
(* ……………………………………………………………………………………………………………… *)
// Sea: a es un arreglo ordenado
PROCEDURE Busqueda_Binaria(elem : TIPOe; VAR a : arreglo; n : INTEGER) : BOOLEAN;
VAR pri,ultimo,miro : INTEGER; lo_encontre : BOOLEAN;
BEGIN
pri
:= 1;
ultimo := n;
lo_encontre := FALSE;
REPEAT
miro := (pri + ultimo) DIV 2;
IF elem = a[miro] THEN
2
1
2
TRABAJO PRÁCTICO Nº 3
ESTRUCTURAS DE DATOS Y ALGORITMOS
Licenciatura en Ciencias de la Computación - Primer cuatrimestre de 2008
Departamento de Ciencias e Ingeniería de la Computación - Universidad Nacional del Sur
lo_encontre := TRUE
ELSIF elem < a[miro] THEN
ultimo:=miro-1
ELSE
pri:=miro+1
END;
UNTIL (pri>ultimo) OR lo_encontre;
RETURN(lo_encontre);
END Busqueda_Binaria;
(* ……………………………………………………………………………………………………………… *)
PROCEDURE Factorial(n:INTEGER):INTEGER;
BEGIN
IF n > 0
THEN RETURN (n * Factorial(n-1))
ELSE RETURN 1
END;
END Factorial;
(* ……………………………………………………………………………………………………………… *)
PROCEDURE POT1(n:INTEGER):INTEGER;
BEGIN
IF n <= 0
THEN RETURN 1
ELSE RETURN(POT1(n-1) + POT1(n-1))
END;
END POT1;
(* ……………………………………………………………………………………………………………… *)
PROCEDURE POT2(n:INTEGER):INTEGER;
BEGIN
IF n <= 0
THEN RETURN 1
ELSE RETURN (2 * POT2(n-1))
END;
END POT2;
(* ……………………………………………………………………………………………………………… *)
PROCEDURE POT3(n:INTEGER):INTEGER;
BEGIN
IF n <= 0
THEN RETURN 1
ELSE RETURN (exp(n * ln(2))) 1
END;
END POT3;
(*.......................................................................*)
PROCEDURE CUENTA (VAR A: ARCHIVO): INTEGER
// Dato de entrada: A, un archivo de texto.
// Dato de salida: cantidad de líneas del archivo con más de 10 palabras.
VAR
LINEA, PAL : INTEGER;
CH : CHAR;
BEGIN
LINEA := 0;
WHILE NOT EOF(A) DO
PAL:=0;
WHILE NOT EOF(A) AND NOT EOLN(A) DO
WHILE NOT EOF(A) AND NOT EOLN(A) AND CH <> ' ' DO
READ(A, CH);
END;
PAL := PAL + 1;
END; (* EOF (A) OR EOLN(A) *)
IF PAL > 10 THEN LINEA:= LINEA + 1; END;
END; (* EOF(A) *)
RETURN LINEA
END CUENTA
la función exp(n) es en y ln(n) es el logaritmo natural. En realidad esta sentencia en Modula-2 debe escribirse como:
RETURN(INTEGER(MATHLIB.Exp(LONGREAL(n) * MATHLIB.Log(2.0) )))
1Aquí
3