Вы находитесь на странице: 1из 8

1) Partiendo del cdigo fuente visto para la funcin Insertar sobre las listas

(Tema 5 de la asignatura), se pide obtener la complejidad temporal de la


funcin para las versiones de lista enlazada esttica y dinmica doblemente
enlazada. Qu versin de la n funcin es ms eficiente?

ESTTICA
void insertar(tipo_lista *l, int v, int p){
int i; 1
if (p-1 > l->p_libre || p < 1){ ( 1 )
printf(Error: posicin fuera de lista\n); (O 1) ( 1 )
return; (O 1) ( 1 )
}

if (l->libre == MAX_ELEMS){ ( 1)
printf(Error: lista llena\n); (O 1) ( 1 )
return; ((O 1) ( 1 )
}
TODOS ESTOS VALORES ANTERIORES SON DESPRECIABLES, YA QUE COMO MUCHOS
SE EJECUTAN UNA VEZ
for(i=l->p_libre; i>=p;i--){ (O n )
l->valores[i] = l->valores[i-1]; 1(O n )
l->valores[p-1]=v; 1(O n )
++l->p_libre; 1(O n )
}
}
El coste de este algoritmo es O (N) siendo n = p;

DINMICA
P_NODO_LISTA insertar (P_NODO_LISTA lst, int valor, int pos){
P_NODO_LISTA laux, lsgte; 1

int i; 1

if (pos < 1) return lst; 1

if ((pos == 1) || esVacia(lst)){ (O 1)
laux = (P_NODO_LISTA) malloc (sizeof(NODO_LISTA)); 1 (O 1)
laux->valor = valor; 1 (O 1)
laux->anterior = NULL; 1 (O 1)
laux->siguiente = lst; 1 (O 1)
if(esVacia(lst)) lst->anterior = laux; 1 (O 1)
return laux; 1 (O 1)
}

TODOS ESTOS VALORES ANTERIORES SON DESPRECIABLES, YA QUE COMO MUCHOS


SE EJECUTAN UNA VEZ
for (i = 1, laux = lst; (i<pos-1)&&(laux != NULL);i++){ (O n)
laux = laux->siguiente; 1 (O 1) (O n)
}

if (laux != NULL){ ( 1 )
lsgte = laux -> siguiente; (O 1) ( 1 )
laux->siguiente = (P_NODO_LISTA)malloc(sizeof(NODO_LISTA)); (O 1) ( 1 )
laux->siguiente->valor = valor; (O 1) ( 1 )
laux->siguiente->siguiente = lsgte; (O 1) ( 1 )
laux->siguiente->anterior = laux; (O 1) ( 1 )
if (lsgte != NULL){ O 1) ( O 1)
lsgte->anterior = laux->siguiente; ){ O 1) ( O 1) )( O 1)

}
}
return lst; 1
}

El coste de este algoritmo es O (N) siendo n = Pos-1;

El gasto de ambos algoritmos es el mismo

2) Estudiar la complejidad temporal de los algoritmos de Dijkstra y Floyd sobre


clculo de caminos mnimos sobre grafos con pesos (Tema 9 de la asignatura).
Qu algoritmo es ms eficiente?

DIJKSTRA

void Dijkstra(unsigned int c[][], unsigned int d[], unsigned int nNodos){
ConjuntoDeEnteros U; //conjunto universal de nodos 1
ConjuntoDeEnteros S; //Conjunto universal de nodos 1
int v, w; //Nmeros de nodos 1
U={}; 1
for (i = 1; i< nNodos; i++){ ( n )
D[i] = C[0,i]; 1( n )
}
repetir (nNodos -1) veces{ ( n )
w = elegir un nodo en U-S sea mnimo 1( n )
S = S { w }; 1( n )
D[v] = min(D[v], D[w] + C[w,v]); 1( n )
}
}
El coste de este algoritmo es ( n ) siendo n = nmero de nodos -1;

FLOYD

void mas_corto(unsigned int c[][], unsigned int a[][], int P[][], unsigned int nNodos){
int i,j,k; 1
for (i = 0; i < nNodos; i++){( n )
for(j=0; j < nNodos; j++){ // Inicializamos con el coste de los caminos
directos ( n ) ( n )
A[i][j] = C[i][j]; 1( n ) ( n )
P[i][j] = -1; 1( n ) ( n )
}

}
for (k = 0; k < nNodos; k++) ( n )
for (i = 0; i < nNodos; i++) ( n ) ( n )
for (j=0; j< nNodos; j++) ( n )
if (A[i][k]+A[k][j] < A[i][j]){

( n ) ( n )

1 ( n ) ( n ) ( n )

A[i][j] = A[i][k] + A[k][j]; O n


P[i][j] = k; O n

( n ) ( n ) ( n )

}
}
El coste de este algoritmo es ( n ^3) siendo n = nmero de nodos -1;

El gasto de FLOYD es claramente superior.

( n ) ( n ) ( n )

3) Calcular el coste de complejidad de la siguiente funcin:


double elevado (double a, int n) {
int i; 1
double r; 1
if (n==0){ ( 1)
return 1; 1 (O 1)
}
if (n==1){ ( 1)
return a; 1 (O 1)
}
r = elevado(a, n/2); ( 1)
if (n%2 == 0){ ( 1)
return r * r; (O 1) ( 1)
}
else{( 1)
return a * r * r; (O 1) ( 1)
}
}
El coste de este algoritmo es fijo es 1.

4) Calcular el coste de complejidad de la siguiente funcin recursiva:


int producto_recursivo (int a, int b) {
if (b==1) { 1
return a;1
}
else
return a + producto_recursivo(a, b-1); T=O( n-1);
}
Coste O(n-1)(1*O(n-1), siendo n el valor de B

5) Calcular el coste de complejidad de la siguiente funcin recursiva:

double elevado (double a, int n) {


int i; 1
double r; 1
if (n==0) 1
return 1; O 1
if (n==1) 1
return a; O 1
r = elevado(a, n/2); t=log n
if (n%2 == 0) 1
return r * r; O 1
else
return a * r * r; O 1
}
}
Tamao log n siendo n el valor de n