Apuntes Algoritmos

COMPILANDO-ES
ALGORITMOS
APUNTES 2 CURSO GRADO EN INGENIERA INFORMTICA
UDC (UNIVERSIDAD DE LA CORUA)
(AO 2016-2017)
TEMAS Y ALGORITMOS:
TEMA 1: ANLISIS DE ALGORITMOS . 2-4
ANLISIS 2
EJEMPLO DETALLADO 3
RECURRENCIAS 4
TEMA 2: ESTRUCTURAS DE DATOS ......5-19
PILA 5
COLA 6
LISTA 7
RBOL BINARIO BSQUEDA 8
MONTCULOS 11
TABLAS DISPERSIN 13
INTRODUCCIN A GRAFOS 16
CONJUNTOS DISJUNTOS 17
TEMA 3: ALGORITMOS SOBRE SECUENCIAS Y CONJUNTOS DE DATOS......20-26
ORDENACIN:
INSERCIN 20
SELECCIN 20
SHELL 21
ORDENACIN POR MONTCULO 22
MERGESORT 23
QUICKSORT 24
OTROS:
SUMA SUBSECUENCIA MXIMA 25
BSQUEDA BINARIA 26
TEMA 4: ALGORITMOS VORACES........27-32
PROBLEMA DE LA MOCHILA (VORAZ) 27
ORDENACIN TOPOLGICA 28
RBOL EXPANDIDO MNIMO (KRUSKAL Y PRIM) 29
CAMINOS MNIMOS (DIJKSTRA) 31
TEMA 5: ALGORITMOS DIVIDE-VENCERS Y PROGRAMACIN DINMICA....33-34
TEMA 6: EXPLORACIN SOBRE GRAFOS (RECORRIDOS PROFUNDIDAD Y ANCHURA)....35-36
TEMA 7: COMPLEJIDAD COMPUTACIONAL..37
TABLA RESUMEN COMPLEJIDADES....38
http://compilando-es.blogspot.com.es/ & FIC (UDC)
TEMA 1: ANLISIS DE ALGORITMOS

PARA EL CLCULO DE LAS COMPLEJIDADES TERICAS NECESITAMOS REALIZAR
UNA APROXIMACIN QUE CONSTA EN COGER SIEMPRE EL ORDEN SUPERIOR
(IGNORANDO LOS DEMS) Y IGNORAR FACTORES CONSTANTES.
PARA EL ANLISIS ALGORTMICO PODEMOS TOMAR COMO REFERENCIA EL MEJOR
CASO, EL PEOR CASO (MS USADO) O EL CASO MEDIO (MS REPRESENTATIVO).
REGLAS DE CLCULO PARA ANALIZAR LA COMPLEJIDAD DE UN ALGORITMO
EN PSEUDOCDIGO:
1. LA OPERACIN ELEMENTAL ES O(1).
OPERACIONES: + - * / SQRT ...

ASIGNACIONES A VARIABLES
ACCESO A PUNTEROS O A ELEMENTOS DE ARRAY
2. UNA SECUENCIA SE TRATA COMO EL MXIMO DE LAS COMPLEJIDADES DE

VARIAS SUBSECUENCIAS
3. CONDICIONES: SU COMPLEJIDAD SE CALCULA ESTABLECIENDO COMO
COMPLEJIDAD TOTAL LA MXIMA DE ESTAS TRES SECUENCIAS
LA CONDICIN: si i<n y j<k entonces
CONDICIN VERDADERA: SI SE CUMPLE LA(S) CONDICIN(ES),

EFECTUAMOS EL ANLISIS DE LA SECUENCIA DE LA RAMA
CONDICIN FALSA: SI NO SE CUMPLE EL SI, EFECTUAMOS (SI EXISTE) EL

ANLISIS DE LA SECUENCIA DE ESA RAMA
*comparaciones (operaciones elementales), O(1)*
4. BUCLES:
I. PARA: para i=1 hasta n hacer secuencia fin para
HAYAMOS LA COMPLEJIDAD DE LA SECUENCIA INTERNA DEL

BUCLE
MULTIPLICAMOS POR EL NUMERO DE INTERACCIONES
*caso del ejemplo= O(O(secuencia) * n)*
II. MIENTRAS: mientras i<n hacer secuencia fin mientras
HAYAMOS LA CONDICIN *caso del ejemplo= operacin elemental O(1)*

HAYAMOS LA SECUENCIA INTERNA *caso del ejemplo= O(secuencia)*
MXIMO ENTRE CONDICIN Y LA SECUENCIA INTERNA
MULTIPLICAMOS POR EL NMERO DE INTERACCIONES
*caso del ejemplo= O(O(max(secuencia,condicin))*n)
partiendo de i=1*
Ejemplo de anlisis de un pseudocdigo:

{1}procedimiento Ordenacin por Insercin (var T[1..n])
{2}
{3}
{4}
{5}
{6}
{7}
{8}
{9}
{10}
para i:=2 hasta n hacer

x:=T[i];
j:=i-1;
mientras j>0 y T[j]>x hacer
T[j+1]:=T[j];
j:=j-1
fin mientras;
T[j+1]:=x
fin para
{11}fin procedimiento
ANLISIS DETALLADO:
COMENZAMOS POR LA SECUENCIA INTERIOR DEL BUCLE MS INTERNO, {6} Y {7}. LA
SECUENCIA ES DE COMPLEJIDAD O(1) DEBIDO A QUE AMBAS SON OPERACIONES
ELEMENTALES DE ASIGNACIN CON VALOR CONSTANTE (REGLA 1).
EL BUCLE MAS INTERNO, {5}, TIENE COMO MTODO DE COMPROBACIN 2
COMPARACIONES LAS CUALES SIGUEN COMPLEJIDAD CONSTANTE, O(1). EL NMERO
DE INTERACCIONES DE ESTE BUCLE ES n POSIBLES. POR TANTO, LA COMPLEJIDAD DEL
BUCLE INTERNO ES O(1) * n = O(n) (REGLA 4).
EL RESTO DE LINEAS DEL BUCLE MAS EXTERIOR, {3},{4},{9}, SON DE NUEVO
ASIGNACIONES DE COMPLEJIDAD CONSTANTE Y, POR LA REGLA 2, TODAS ELLAS
SUMAN TIEMPO CONSTANTE. POR ESTO, EL INTERIOR DEL BUCLE PARA SIGUE EL
ORDEN DE O(n), EL MXIMO DE SUS SUBSECUENCIAS (REGLA 2).
PARA FINALIZAR, EL NMERO DE INTERACCIONES DEL BUCLE PARA, {2}, ES DE n-1
INTERACCIONES (DE 2 A N) Y POR LA REGLA 4, O(n) * n = O(n2).
PODEMOS CONCLUIR QUE EL ALGORITMO PRESENTADO ES DE COMPLEJIDAD DE
O(n2).
5. RECURSIVIDAD:
APLICANDO EL TEOREMA DE RECURRENCIAS:
DISTINGUIMOS VARIOS TIPOS:
HOMOGNEAS DE COEFICIENTES CONSTANTES

NO HOMOGNEAS
DE CAMBIO DE VARIABLE
RECURRENCIAS PARA DIVIDE Y VENCERS
LAS PRESENTADAS EN LOS APUNTES Y LAS MS INTERESANTES SON LAS DIVIDE

VENCERS QUE SE RESUELVEN SIGUIENDO LA SIGUIENTE FRMULA:
PARA LA RECURRENCIA:
T(n) = T(n/b)+cnk;
n>n0
TEMA 2: ESTRUCTURAS DE DATOS

1. PILAS:
SE IMPLEMENTAN EN BASE A VECTORES, DE FORMA ESTTICA, DE TRES
FUNCIONES BSICAS (APILAR, DESAPILAR Y CIMA):
PSEUDOCDIGO:
tipo
Pila = registro
Cima_de_pila : 0..Tamano_maximo_de_pila
Vector_de_pila : vector [1..Tamano_maximo_de_pila]
de Tipo_de_elemento
fin registro
procedimiento Crear Pila ( P )
P.Cima_de_pila := 0
fin procedimiento
funcin Pila Vaca ( P ) : test
devolver P.Cima_de_pila = 0
fin funcin
procedimiento Apilar ( x, P )
si
P.Cima_de_pila = Tamano_maximo_de_pila entonces
error Pila llena
sino
P.Cima_de_pila := P.Cima_de_pila + 1;
P. Vector_de_pila[P.Cima_de_pila] := x
fin procedimiento
funcin Cima ( P ) : Tipo_de_elemento
si Pila Vaca (P) entonces
error Pila vaca
sino
devolver P. Vector_de_pila[P.Cima de Pila]
fin funcin
procedimiento Desapilar ( P )
si Pila Vaca (P) entonces
error Pila vaca
sino
P.Cima_de_pila := P.Cima_de_pila - 1
fin procedimiento
COMPLEJIDAD
LA COMPLEJIDAD DE ESTE ALGORITMO ES CONSTANTE, YA QUE EN TODAS SUS
FUNCIONES SOLO EXISTEN OPERACIONES ELEMENTALES EN SUS SUBSECUENCIAS.
POR TANTO LA IMPLEMENTACIN DE UNA PILA ES DE ORDEN O(1).
2. COLAS:
DENUEVO SU IMPLEMENTACIN REQUIERE 3 FUNCIONES BSICAS DE INSERTAR,
ELIMINAR Y CABEZA.
SU IMPLEMENTACIN EN BASE A VECTORES ES ESTA:
PSEUDOCDIGO
tipo
Cola = registro
Cabeza_de_cola, Final_de_cola:1..Tamano_maximo_de_cola
Tamano_de_cola : 0..Tamano_maximo_de_cola
Vector_de_cola : vector [1..Tamano_maximo_de_cola] de
Tipo_de_elemento
fin registro
procedimiento Crear_Cola ( C )
C. Tamano_de_cola := 0;
C. Cabeza_de_cola := 1;
C. Final_de_cola := Tamano_maximo_de_cola
fin procedimiento
funcin Cola_Vaca ( C ) : test
devolver C. Tamano_de_cola = 0
fin funcin
procedimiento incrementar ( x ) (* privado *)
si x = Tamano_maximo_de_cola entonces
x := 1
sino
x := x + 1
fin procedimiento
procedimiento Insertar_en_Cola ( x, C )
si
C. Tamano_de_Cola = Tamano_maximo_de_cola entonces
error Cola llena
sino
C. Tamano_de_cola := C. Tamano_de_cola + 1;
incrementar(C. Final_de_cola);
C. Vector_de_cola[C. Final_de_cola] := x;
fin procedimiento
funcin Quitar_Primero ( C ) : Tipo_de_elemento
si Cola_Vaca ( C ) entonces
error Cola vaca
sino
C. Tamano_de_cola := C. Tamano_de_cola - 1;
x := C. Vector_de_cola[C. Cabeza_de_cola];
incrementar(C. Cabeza_de_cola);
devolver x
fin funcin
funcin Primero ( C ) : Tipo_de_elemento

si Cola_Vaca ( C ) entonces
error Cola vaca
sino
devolver C. Vector_de_cola[C. Cabeza_de_cola]
fin funcin
COMPLEJIDAD
DE NUEVO, LA COMPLEJIDAD DE LA IMPLEMENTACIN DE LAS COLAS ES DE O(1),
COMPLEJIDAD CONSTANTE.
3.
LISTAS:
SUS OPERACIONES ELEMENTALES SON LAS DE VISUALIZAR LA LISTA, BUSCAR UN

ELEMENTO EN ELLA, ELIMINAR UNA POSICIN, INSERTAR EN UNA POSICIN Y
BUSCAR UNA POSICIN DETERMINADA. ESTA LISTA SE ENCARGA DE, MEDIANTE
UNA IMPLEMENTACIN DINMICA A BASE DE PUNTEROS CON NODO CABECERA,
MANTENER UN CONJUNTO DE DATOS ALMACENADOS POR POSICIONES.
PSEUDOCDIGO:
tipo
PNodo = puntero a Nodo
Lista = PNodo
Posicion = PNodo
Nodo = registro
Elemento : Tipo_de_elemento
Siguiente : PNodo
fin registro
procedimiento Crear Lista ( L )
nuevo( tmp );
si tmp = nil entonces
error Memoria agotada
sino
tmp.Elemento := {nodo cabecera};
tmp.Siguiente := nil;
L := tmp
fin procedimiento
funcin Lista Vaca ( L ) : test
devolver L.Siguiente = nil
fin funcin
funcin Buscar ( x, L ) : posicion de la 1a ocurrencia o nil

p := L.Siguiente;
mientras p <> nil y p.Elemento <> x hacer
p := p.Siguiente;
devolver p
fin funcin
funcin Ultimo Elemento ( p ) : test

devolver p.Siguiente = nil
fin funcin
(* privada *)
funcin Buscar Anterior ( x, L ) : posicion anterior a x o a nil

(* privada *)
p := L;
mientras p.Siguiente <> nil y p.Siguiente.Elemento <> x hacer
p := p.Siguiente;
devolver p
fin funcin
procedimiento Eliminar ( x, L )
p := Buscar Anterior ( x, L );
si Ultimo Elemento ( p ) entonces
error No encontrado
sino
tmp := p.Siguiente;
p.Siguiente := tmp.Siguiente;
liberar ( tmp )
fin procedimiento
procedimiento Insertar ( x, L, p )
nuevo ( tmp ); { Inserta despus de la posicion p }
si tmp = nil entonces
error Memoria agotada
sino
tmp.Elemento := x;
tmp.Siguiente := p.Siguiente:
p.Siguiente := tmp
fin procedimiento
COMPLEJIDAD
LA COMPLEJIDAD DE ESTA ESTRUCTURA ES LINEAL EN VISUALIZAR, BUSCAR
POSICIN Y BUSCAR ELEMENTO, DEBIDO A QUE EN VISUALIZAR HACE FALTA
MOSTRAR LOS n NODOS DE LA LISTA Y EN BUSCAR, EN SU PEOR CASO, HABRIA QUE
RECORRER LOS n NODOS Y, EN EL CASO MEDIO, n/2. POR TANTO COMPLEJIDAD O(n).
LAS DEMS FUNCIONES Y PROCEDIMIENTOS SON DE ORDEN CONSTANTE YA QUE
NEW Y DISPOSE SON DE COMPLEJIDAD O(1), AUNQUE CABE DESTACAR QUE
ELIMINAR TIENE O(n) YA QUE LLAMA A LA FUNCIN PRIVADA BUSCAR_ANTERIOR
QUE ES DE ORDEN LINEAL.
4.
RBOL BINARIO DE BSQUEDA:
CAMINO: ES LA SECUENCIA DE NODOS QUE SE RECORREN PARA LLEGAR A OTRO K,

DE TAL FORMA QUE ni ES EL PADRE DE ni+1 Y AS SECUENCIAL MENTE.
PROFUNDIDAD: ES LA LONGITUD ENTRE UN NODO Y LA RAZ DEL RBOL. PARA UN
RBOL BINARIO DE BSQUEDA, LA PROFUNDIDAD MEDIA DE UN NODO ES DE
O(logn).
ALTURA: EL CAMINO MAS LARGO DE LA RAZ A UNA HOJA.

LAS OPERACIONES BSICAS EN UN RBOL SON BUSCAR EN EL RBOL UNA CLAVE X,
INSERTAR UNA CLAVE X (O ACTUALIZARLA) Y ELIMINAR LA CLAVE.
ELIMINAR: SU PROCEDIMIENTO ES BUSCAR LA CLAVE Y DISTINGUIR CASOS:
HOJA: ELIMINARLA
1 NICO HIJO: AJUSTAR EL APUNTADOR Y ELIMINAMOS
2 HIJOS: SUSTITUIMOS LA CLAVE POR LA CLAVE MS PEQUEA DENTRO DEL
HIJO DERECHO, Y FINALMENTE SE ELIMINA LA POSICIN ANTES OCUPADA
POR ESTE.
PARA ESTE PROCEDIMIENTO SE USA LA LLAMADA ELIMINACIN PEREZOSA,
SIMPLEMENTE SE MARCA LA POSICIN COMO ELIMINADA, SIN HACER NADA MS.
PSEUDOCDIGO:
tipo
PNodo = Nodo
Nodo = registro
Elemento : TipoElemento
Izquierdo, Derecho : PNodo
fin registro
ABB = PNodo
procedimiento CrearABB ( var A)
A := nil
fin procedimiento
funcin Buscar (x, A) : PNodo
si A = nil entonces
devolver nil
sino
si x = A.Elemento entonces
devolver A
sino
si x < A.Elemento entonces
devolver Buscar (x, A.Izquierdo)
sino
devolver Buscar (x, A.Derecho)
fin funcin
funcin BuscarMin (A) : PNodo
si A = nil entonces
devolver nil
sino
si A.Izquierdo = nil entonces
devolver A
sino
devolver BuscarMin (A.Izquierdo)
fin funcin
procedimiento Insertar (x, var A)

si A = nil entonces
nuevo (A);
si A = nil entonces
error sin memoria
sino
A.Elemento := x;
A.Izquierdo := nil;
A.Derecho := nil
sino
si x < A.Elemento entonces
Insertar (x, A.Izquierdo)
sino
si x > A.Elemento entonces
Insertar (x, A.Derecho)
{ si x = A.Elemento : nada }
fin procedimiento
procedimiento Eliminar (x, var A)
si A = nil entonces
error no encontrado
sino si x < A.Elemento entonces
Eliminar (x, A.Izquierdo)
sino si x > A.Elemento entonces
Eliminar (x, A.Derecho)
sino
{ x = A.Elemento }
si A.Izquierdo = nil entonces
tmp := A; A := A.Derecho; liberar (tmp)
sino si A.Derecho = nil entonces
tmp := A;
A := A.Izquierdo;
liberar (tmp);
sino
tmp := BuscarMin (A.Derecho);
A.Elemento := tmp.Elemento;
Eliminar (A.Elemento, A.Derecho)
fin procedimiento
RECORRIDOS DE UN RBOL:
EN-ORDEN: HIJO IZDO RAZ HIJO DER
procedimiento Visualizar (A)
si A <> nil entonces
Visualizar (A.Izquierdo);
Escribir (A.Elemento);
Visualizar (A.Derecho)
fin procedimiento
POST-ORDEN: HIJO IZDO HIJO DER RAZ

Visualizar (A.Derecho);
fin procedimiento
10
PRE-ORDEN: RAZ HIJO IZDO HIJO DER

Visualizar (A.Derecho);
fin procedimiento
ALTURA DE UN RBOL:
funcin Altura (A) : numero
si A = nil entonces
devolver -1
sino
devolver (1 + max (Altura (A.Izquierdo),
Altura (A.Derecho)))
fin funcin
COMPLEJIDAD:
CREAR UN RBOL ES UNA OPERACIN, POR TANTO ES DE ORDEN CONSTANTE.
EN EL RESTO DE FUNCIONES DEL RBOL, EL CASO MEDIO DICTA QUE LA
COMPLEJIDAD ES O(logn), SIENDO EN EL PEOR CASO LINEAL.
5.
MONTCULOS:
SE UTILIZAN PARA ALMACENAR DATOS SOLO SIENDO RELEVANTE SU MXIMO O

MNIMO VALOR. EN UN MONTCULO DE MNIMOS SON RELEVANTES LAS FUNCIONES
INSERTAR Y ELIMINARMIN. UN MONTCULO SE PUEDE VER COMO UN RBOL
BINARIO DE BSQUEDA CON NIVELES COMPLETOS, POR TANTO TENDR DE ALTURA
ENTRE 2h y 2h+1-1, PUDIENDO ENCONTRAR AL PADRE DE UN NODO n EN n/2. SU
PROFUNDIDAD ES LA PARTE ENTERA DE logn. EN CASO DE MONTCULO DE MNIMOS,
LA RAZ ES EL MENOR VALOR Y SE CUMPLE QUE EL VALOR DE LOS PADRES ES
MENOR O IGUAL QUE EL DE SUS HIJOS.
PSEUDOCDIGO:
tipo
Montculo = registro
Tamanomonticulo : 0..Tamano maximo
Vectormontculo : vector [1..Tamano maximo]
de Tipo elemento
fin registro
11
procedimiento CrearMontculo ( V[1..n], M )

Copiar V en M.Vectormontculo;
M.Tamanomontculo := n;
para i := M.Tamanomontculo div 2 hasta paso -1
Hundir(M, i);
fin para
fin procedimiento
procedimiento Inicializar Montculo ( M )
M.Tamanomonticulo := 0
fin procedimiento
funcin MontculoVaco ( M ) : test
devolver M.Tamanomonticulo = 0
fin funcin
procedimiento Flotar ( M, i )
(* privado *)
mientras i > 1 y M.Vectormontculo[i div 2] < M.Vectormontculo[i] hacer
intercambiar M.Vectormontculo[i div 2] y M.Vectormontculo[i];
i := i div 2
fin mientras
fin procedimiento
procedimiento Insertar ( x, M )
si M.Tamanomonticulo = Tamanomaximo entonces
error Montculo lleno
sino
M.Tamanomonticulo := M.Tamanomonticulo + 1;
M.Vectormonticulo[M.Tamanomonticulo] := x;
Flotar ( M, M.Tamanomonticulo )
fin procedimiento
procedimiento Hundir (
repetir
HijoIzq :=
HijoDer :=
j := i;
si HijoDer
M, i )
(* privado *)
2*i;
2*i+1;
<= M.Tamanomonticulo y M.Vectormontculo[HijoDer] >

M.Vectormontculo[i] entonces
i := HijoDer;
si HijoIzq <= M.Tamanomonticulo y M.Vectormontculo[HijoIzq] >
M.Vectormontculo[i] entonces
i := HijoIzq;
intercambiar M.Vectormontculo[j] y M.Vectormontculo[i];
hasta j=i { Si j=i el nodo alcanzo su posicion final }
fin procedimiento
funcin EliminarMax ( M ) : Tipoelemento
si MontculoVaco ( M ) entonces
error Montculo vaco
sino
x := M.Vectormontculo[1];
M.Vectormontculo[1] :=
M.Vectormontculo[M.Tamanomonticulo];
M.Tamanomonticulo := M.Tamanomonticulo - 1;
si M.Tamanomonticulo > 0 entonces
Hundir ( M, 1);
devolver x
fin funcin
12
COMPLEJIDAD:
AMBAS OPERACIONES PRINCIPALES SE REALIZAN CON UNA COMPLEJIDAD DE
O(logn) EN EL PEOR CASO.
EJERCICIO: BUSCAR EL K-SIMO MAYOR DE n NMEROS

SOLUCIN:
Si k=n/2 CASO MEDIO entonces O (nlogn)
PASOS:
1.
2.
3.
4.
5.
Crear montculo de manimos con los k primeros nos

Para cada numero en ( k...n],
O((nk)logk)
Determinar si insertar en montculo O(1)
Eliminar mnimo O(logk)
Insertar nuevo numero
O(logk)
O(k)
funcin KesimoMayor ( V[1..n], k ): numero {1kn}

CrearMontculoMnimos ( V[1..k], M );
para i := k+1 hasta n hacer
si ObtenerMenor ( M ) < V[i] entonces
EliminarMin ( M );
Insertar ( V[i], M )
fin para
devolver ObtenerMenor ( M );
fin funcin
6.
TABLAS DE DISPERSIN
COMO HEMOS VISTO, LA COMPLEJIDAD MNIMA DE INSERCIONES Y ELIMINACIONES

DE UNA CLAVE ES DE O(logn) EN EL PEOR CASO EN MONTCULOS. INTENTAMOS PUES
HALLAR UNA MANERA DE OBTENER ESTAS OPERACIONES EN TIEMPO CONSTANTE
O(1).
AS APARECEN LAS TABLAS DE DISPERSIN, QUE CONTIENE UNA FUNCIN DE
DISPERSIN PARA PODER INTRODUCIR O SACAR DATOS DE LA PROPIA TABLA DE
UNA MANERA HOMOGNEA. SE BUSCA TENER EL MNIMO DE COLISIONES POSIBLE
DE TAL MODO QUE SE INTRODUZCAN RPIDAMENTE EN LA TABLA.
FUNCIN DE DISPERSIN:
13
FCIL Y RPIDA DE CALCULAR
DISTRIBUIR UNIFORMEMENTE LAS CLAVES
funcin Dispersion1 (Clave, TamanoClave):Indice

valor := ascii(Clave[1]);
para i := 2 hasta TamanoClave hacer
valor := valor + acii(Clave[i])
fin para
devolver valor mod N
(* FUNCIN DE DISPERSIN MDULO DE N *)
fin funcin
ESTA FUNCIN ES SENCILLA Y RPIDA DE EJECUTAR, PERO SI EL NMERO DE

VALORES ES ALTO NO SE DISTRIBUYE CORRECTAMENTE.
funcin Dispersion (Clave, TamanoClave):Indice
valor := ascii(Clave[1]);
para i := 2 hasta TamanoClave hacer
valor := (32*valor + acii(Clave[i])) mod N
fin para
devolver valor
fin funcin
EN ESTE CASO, LA DISPERSIN SE CALCULA MEDIANTE LA FRMULA MATEMTICA
Y OFRECE UNA DISPERSIN RPIDA Y HOMOGNEA.

EL FACTOR DE CARGA () ES EL NUMERO DE ELEMENTOS INSERTADOS EN UNA
TABLA ENTRE SU TAMAO.
POR ESTES MOTIVOS, USAMOS 2 TIPOS DE DISPERSIN DIFERENTES:
ABIERTA:
CONSISTE EN TENER EN UNA LISTA ELEMENTOS QUE SE DISPERSAN CON EL MISMO

VALOR, AUNQUE CUALQUIER ESTRUCTURA VALDRA PARA ALMACENARLOS.
PSEUDOCDIGO
tipo
Indice = 0..N-1
Posicion = Nodo
Lista = Posicion
Nodo = registro
Siguiente : Posicion
fin registro
TablaDispersion = vector [Indice] de Lista
procedimiento InicializarTabla (T)
para i := 0 hasta N-1 hacer
CrearLista(T[i])
fin para
fin procedimiento
14
funcin Buscar (Elem, Tabla): Posicion

i := Dispersion(Elem);
devolver BuscarLista(Elem, Tabla[i])
fin funcin
procedimiento Insertar (Elem, Tabla)
pos := Buscar(Elem, Tabla); {No inserta repetidos}
si pos = nil entonces
i := Dispersion(Elem);
InsertarLista(Elem, Tabla[i])
fin procedimiento
COMPLEJIDAD
EVALUAR LA FUNCIN DE DISPERSIN ES O(1), PERO LA LISTA SE RECORRE EN
TIEMPO LINEAL O() EN EL PEOR CASO.
CERRADA:
AL CONTRARIO QUE EN LA ABIERTA, SI SUCEDE UNA COLISIN SE BUSCA OTRO

SITIO EN LA TABLA DONDE COLOCAR LA CLAVE. COMO TODOS LOS ELEMENTOS SE
GUARDAN EN CELDAS DIFERENTES, EN LA DISPERSIN CERRADA NECESITAMOS
UNA TABLA DE MAYOR TAMAO Y, COMO NORMA GENERAL, EL FACTOR DE CARGA
DEBE SER MENOR DE 0.5. PARA QUE TODOS LOS ELEMENTOS PERMANEZCAN
ENLAZADOS, ES NECESARIO QUE LA ELIMINACIN SEA PERAZOSA (ANTES
EXPLICADA).
tipo
ClaseDeEntrada = (legtima, vaca, eliminada)
Indice = 0..N-1
Posicion = Indice
Entrada = registro
Informacion : ClaseDeEntrada
fin registro
TablaDispersion = vector [Indice] de Entrada
procedimiento InicializarTabla (D)
para i := 0 hasta N-1 hacer
D[i].Informacion := vaca
fin para
fin procedimiento
funcin Buscar (Elem, D): Posicion
i := 0;
x = Dispersion(Elem);
PosActual = x;
mientras D[PosActual].Informacion <> vaca y D[PosActual].Elemento <> Elem
hacer
i := i + 1;
PosActual := (x + FunResolucionColision(x, i)) mod N
fin mientras;
devolver PosActual
fin funcin
/*La busqueda finaliza al caer en una celda vaca o al encontrar el elemento
(legtimo o borrado)*/
15
procedimiento Insertar (Elem, D)

pos = Buscar(Elem, D);
si D[pos].Informacion <> legtima entonces {Bueno para insertar}
D[pos].Elemento := Elem;
D[pos].Informacion := legtima
fin procedimiento
procedimiento Eliminar (Elem, D)

pos = Buscar(Elem, D);
si D[pos].Informacion = legtima entonces
D[pos].Informacion := eliminada
fin procedimiento
PARA RESOLVER COLISIONES SE PUEDEN APLICAR 3 MTODOS DE EXPLORACIN

DEL SIGUIENTE ELEMENTO:
EXPLORACIN LINEAL: f(i)= i

TRATA DE COLOCAR LA CLAVE EN LA SIGUIENTE POSICIN (POS i)
EXPLORACIN CUADRTICA: f(i)= i2

TRATA DE COLOCAR LA CLAVE EN LA POSICIN i2
EXPLORACIN DOBLE: f(i)= i * h2 (x)

TRATA DE MULTIPLICAR LA POSICIN POR EL CDIGO HASH
7.
GRAFOS:
(MS ADELANTE)
UN GRAFO G ES UN PAR (V,A), SIENDO V EL CONJUNTO DE VRTICES/NODOS Y A EL

CONJUNTO DE ARISTAS QUE LOS UNEN MEDIANTE UN PESO. ESTE PESO PUEDE SER
MUY ELEVADO O MUY BAJO PARA EXPRESAR LA INEXISTENCIA DE ESTAS.
SI EL PAR EST ORDENADO ES UN GRAFO DIRIGIDO.
LOS GRAFOS SE SUELEN REPRESENTAR CON:
16
MATRIZ DE ADYACENCIA: MATRIZ BIDIMENSIONAL QUE EN CASO DE

EXISTIR ARISTA ENTRE LOS NODOS REPRESENTADOS POR FILA Y COLUMNA
SE COLOCA UN 1 Y, POR EL CONTRARIO, 0. NECESITAMOS UN ESPACIO DE V 2
PARA IMPLEMENTARLA, POR TANTO SE USA NORMALMENTE PARA GRAFOS
DENSOS.
7.
LISTAS DE ADYACENCIA: PARA CADA VRTICE TENEMOS UNA LISTA DE

VERTICES ADYACENTES Y LAS ARISTAS QUE LOS UNEN, IMPLEMENTADOS
POR UN VECTOR. NECESITAMOS UN ESPACIO DE V+A POR TANTO ES BUENA
IDEA PARA DISPERSOS, PERO EN GRAFOS NO DIRIGIDOS ESTO PUEDE HASTA
DUPLICARSE POR LA NECESIDAD DE TENER LA MISMA ARISTA EN 2
VRTICES IGUALES.
CONJUNTOS DISJUNTOS:
LOS ELEMENTOS SON ENUMERADOS DEL 1 A n, ESCOGIENDO A UNO DE CADA

CONJUNTO PARA QUE SEA EL REPRESENTANTE Y LE DE NOMBRE A ESTE. EL
CONJUNTO SER IMPLEMENTADO MEDIANTE UN VECTOR QUE RECOGER POR
CADA POSICIN EL NOMBRE DEL REPRESENTANTE
EXISTEN UNICAMENTE 2 OPERACIONES A REALIZAR CON CONJUNTOS, BSQUEDA

DE UN DATO PARA SABER EN QUE CONJUNTO EST Y UNIN DE CONJUNTOS.
PSEUDOCDIGO:
tipo
Elemento = entero;
Conj = entero;
ConjDisj = vector [1..N] de entero
funcin Buscar1 (C, x) : Conj
devolver C[x]
fin funcin
procedimiento Unir1 (C, a, b)
i := min (C[a], C[b]);
j := max (C[a], C[b]);
para k := 1 hasta N hacer
si C[k] = j entonces
C[k] := i
fin para
fin procedimiento
17
COMPLEJIDAD:
LA BSQUEDA ES EVIDENTEMENTE CONSTANTE O(1), MIENTRAS QUE LA UNIN ES
O(n) SEA CUAL SEA EL CONJUNTO, AUNQUE SI LA UNIN ES DE TODO EL CONJUNTO
LLEGARA A SER O(n2).
MODO RBOL:
SE PUEDE HACER UNA IMPLEMENTACIN DE RBOL, MANTENIENDO AL
REPRESENTANTE COMO RAZ Y PARTIENDO DE L EL RESTO DE ELEMENTOS.
Funcion Buscar2 (C, x) : Conj
r := x;
mientras C[r] <> r hacer
r := C[r]
fin mientras;
devolver r
fin funcin
procedimiento Unir2 (C, raz1, raz2)
si raz1 < raz2 entonces
C[raz2] := raz1
sino
C[raz1] := raz2
fin procedimiento
{supone que raz1 y raz2 son races}
COMPLEJIDAD:
LA BSQUEDA TIENE UNA COMPLEJIDAD DE O(n) EN SU PEOR CASO, MIENTRAS QUE
LA UNIN ES CONSTANTE.
UNIN POR ALTURAS COMPLEJIDAD O(logn)
procedimiento Unir3 (C, A, raz1, raz2)
{supone que raz1 y raz2 son races}
si A[raz1] = A[raz2] entonces
A[raz1] := A[raz1] + 1;
C[raz2] := raz1
sino
si A[raz1] > A[raz2] entonces
C[raz2] := raz1
sino
C[raz1] := raz2
fin procedimiento
18
COMPRESIN DE CAMINOS COMPATIBLE CON UNIN POR ALTURAS

funcin Buscar3 (C, x) : Conj
r := x;
mientras C[r] <> r hacer
r := C[r]
fin mientras;
i := x;
mientras i <> r hacer
j := C[i]; C[i]:= r; i := j
fin mientras;
devolver r
fin funcin
19
TEMA 3: ALGORITMOS SOBRE SECUENCIAS Y CONJUNTOS DE

DATOS:
ORDENACIN:
INSERCIN:
CONSISTE EN RECORRER TODOS LOS DATOS E IRLOS ORDENANDO 1 A 1 DESDE EL

COMIENZO, RECOLOCANDO TODOS LOS ANTERIORES SI HICIESE FALTA.
PEOR CASO: DATOS ORDENADOS AL REVS, ES DECIR, DE MAYOR A MENOR
CUANDO QUEREMOS ORDENARLOS DE MENOR A MAYOR Y VICEVERSA.
MEJOR CASO: DATOS YA ORDENADOS
PSEUDOCDIGO:
procedimiento Ordenacion por Insercion (var T[1..n])
x:=T[i];
j:=i-1;
mientras j>0 y T[j]>x hacer
T[j+1]:=T[j];
j:=j-1
fin mientras;
T[j+1]:=x
fin para
fin procedimiento
COMPLEJIDAD:
PEOR CASO= O(n2) debido a que recorre todo el array buscando el elemento a ordenar y
ordenando los elementos anteriores.
MEJOR CASO= O(n) debido a que comprueba que cada uno est en la posicin indicada
CASO MEDIO= O(n2)
SELECCIN:
CONSISTE EN RECORRER LOS DATOS BUSCANDO EL MNIMO DE LOS ELEMENTOS

NO ORDENADOS Y COLOCARLO EN LA PRIMERA POSICIN NO ORDENADA.
20
PSEUDOCDIGO:
procedimiento OrdenacinporSeleccin (var T[1..n])
para i:=1 hasta n1 hacer
minj:=i;
minx:=T[i];
para j:=i+1 hasta n hacer
si T[j]<minx entonces
minj:=j;
minx:=T[j]
fin si
fin para;
T[minj]:=T[i];
T[i]:=minx
fin para
fin procedimiento
COMPLEJIDAD:
SU COMPLEJIDAD ES O(n2)
SHELL:
GRACIAS A LA PROPIEDAD DE un vector hk-ordenado que se hk1-ordena sigue estando hkordenado PODEMOS ASEGURAR QUE ESTE ALGORITMO FUNCIONA.
TRATA DE, PARTIENDO DE UNOS INCREMENTOS PREVIAMENTE PACTADOS, IR
ORDENANDO SUBSECUENCIAS DE DATOS PARA, AL FINAL, OBTENER LA SECUENCIA
ORDENADA.
LOS INCREMENTOS MS FAVORABLES SON:
-
SHELL: n/2 SUCESIVAMENTE HASTA 1 PEOR CASO O(n2)
HIBBARD: 1,3,7 CASO MEDIO O(n5/4)
SEDGEWITCH: 1,5,19,41 CASO MEDIO O(n7/6)
21
PSEUDOCDIGO:
procedimiento OrdenaciondeShell (var T[1..n])
incremento := n;
repetir
incremento := incremento div 2;
para i := incremento+1 hasta n hacer
tmp := T[i];
j := i;
seguir := cierto;
mientras j-incremento > 0 y seguir hacer
si tmp < T[j-incremento] entonces
T[j] := T[j-incremento];
j := j-incremento
sino
seguir := falso ;
T[j] := tmp
fin mientras
fin para
hasta incremento = 1
fin procedimiento
COMPLEJIDAD:
DEPENDIENDO DE LOS INCREMENTOS: PARA INCREMENTOS SHELL O(n2) EN EL
PEOR CASO
MONTCULOS:
TRATA DE LA ORDENACIN DE UN VECTOR DE ELEMENTOS CONVIRTINDOLOS EN

UN MONTCULO. TRAS ESTO, IR SACANDO ELEMENTOS DE SU RAZ PARA
SACARLOS ORDENADOS Y ALMACENARLOS DE NUEVO EN EL ARRAY ORDENADOS.
PSEUDOCDIGO:
procedimiento OrdenacionporMontculos (var T[1..n])
Crear montculo (T, M);
para i := 1 hasta n hacer
T[n-i+1] := Obtener mayor valor (M);
Eliminar mayor valor(M)
fin para
fin procedimiento
PASAR VECTOR A MONTCULO:

procedimiento CrearMontculo (V[1..n], var M)
{ V[1..n]: entrada: vector con cuyos datos se construir a el montculo M:
entrada/salida: montculo a crear }
Copiar V[1..n] en M[1..n];
para i := n div 2 hasta 1 paso -1 hacer
hundir(M,i)
fin para
fin procedimiento
22
COMPLEJIDAD:
LA COMPLEJIDAD ES DE O(nlogn) DEBIDO A QUE ELIMINAR EN EL MONTCULO ES LA
OPERACIN CON LA COMPLEJIDAD MAYOR EN TODO ESTE ALGORITMO.
FUSIN O MERGESORT:
ES UN ALGORITMO DIVIDE Y VENCERS QUE SE BASA EN DIVIDIR UN CONJUNTO

DE DATOS A ORDENAR EN DOS CONJUNTOS IGUALES (O CASI IGUALES) PARA SER
ORDENADOS POR SEPARADO Y UNIRLOS AL FINAL.
PARA ESTO USAMOS LA RECURSIVIDAD, CON LA CUAL VAMOS DIVIDIENDO LOS
CONJUNTOS HASTA LLEGAR A UN UMBRAL MARCADO AL COMIENZO DEL
ALGORITMO, Y FUSIONA TODOS LOS CONJUNTOS. FINALMENTE APLICA UNA
ORDENACIN DIFERENTE CUANDO BAJA DEL UMBRAL.
PSEUDOCDIGO:
procedimiento OrdenacionporFusionRecursivo (var T[Izda..Dcha] )
si Izda+UMBRAL < Dcha entonces
Centro := ( Izda+Dcha ) div 2 ;
OrdenacionporFusionRecursivo ( T[Izda..Centro] ) ;
OrdenacionporFusionRecursivo ( T[Centro+1..Dcha] ) ;
Fusion ( T[Izda..Dcha], Centro )
sino
OrdenacionporInsercion ( T[Izda..Dcha] ) (* DEBAJO UMBRAL *)
fin procedimiento
procedimiento Ordenacion por Fusion (var T[1..n] )
Ordenacion por Fusion Recursivo ( T[1..n] );
fin procedimiento
COMPLEJIDAD:
POR SER RECURSIVA Y UN ALGORITMO DIVIDE Y VENCERS, SE APLICA LAS
RECURRENCIAS DIVIDE VENCERS.
T(n) = T([n/2]) + T([n/2]) + O(n) (* fusin de elementos *)
l=2; b=2; c=1; k=1; n0=1 O(nlogn)

IMPORTANTE: ALGORITMO BALANCEADO DE T(n/2) SINO SERA COMPLEJIDAD DE
O(n2) Y NO SERIA DIVIDE Y VENCERS.
23
ORDENACIN RPIDA O QUICKSORT:
EL MAYOR EJEMPLO DE DIVIDE Y VENCERS, CONSISTE EN USAR UN PIVOTE Y

COLOCARLO EN SU POSICIN CORRECTA Y, DESPUS APLICAR RECURSIVIDAD
SOBRE LOS ELEMENTOS MENORES QUE L Y MAYORES QUE L.
DEPENDIENDO DE LA ELECCIN DEL PIVOTE, OBTENDREMOS MEJOR EFICIENCIA
CUANTO MS BALANCEADO EST NUESTRO PIVOTE:
-
MEDIANA NADA EFICIENTE
EL PRIMER VALOR: SI LA ENTRADA ES ALEATORIA PUEDE SERVIR, PERO CON

ENTRADAS ORDENADAS O SEMI ORDENADAS ES MUY INEFICIENTE (O(n2)).
PIVOTE ALEATORIO: DEPENDE DEL GENERADOR DE NMEROS.
MEDIANA DE 3 VALORES: LOS EXTREMOS Y LA MEDIANA DEL VECTOR :

DESORDENADO.
PARA SELECCIONAR EL PIVOTE DE MEDIANA DE 3 VALORES:

procedimiento Mediana 3 (var T[i..j] )
centro := ( i+j ) div 2 ;
si T[i] > T[centro] entonces
intercambiar ( T[i], T[centro] ) ;
si T[i] > T[j] entonces
intercambiar ( T[i], T[j] ) ;
si T[centro] > T[j] entonces
intercambiar ( T[centro], T[j] ) ;
intercambiar ( T[centro], T[j-1] )
fin procedimiento
PSEUDOCDIGO:
procedimiento Qsort (var T[i..j] )
si i+UMBRAL <= j entonces
Mediana 3 ( T[i..j] ) ;
pivote := T[j-1] ; k := i ; m := j-1 ;
{solo con Mediana 3}
repetir
repetir k := k+1 hasta T[k] >= pivote ;
repetir m := m-1 hasta T[m] <= pivote ;
intercambiar ( T[k], T[m] )
hasta m <= k ;
intercambiar ( T[k], T[m] ) ;
{deshace el ultimo intercambio}
intercambiar ( T[k], T[j-1] ) ; {pivote en posicion k}
Qsort ( T[i..k-1] ) ;
Qsort ( T[k+1..j] )
fin procedimiento
procedimiento Quicksort ( var T[1..n] )
Qsort ( T[1..n] ) ;
Ordenacion por Insercion ( T[1..n] )
fin procedimiento
(* FUERA DE UMBRAL *)
/* ESTA IMPLEMENTACIN NO TIENE SENTIDO CON UMBRAL < 3. */

24
COMPLEJIDAD:
PEOR CASO: O(n2)
CASO MEDIO: O(nlogn)
MEJOR CASO: O(nlogn) NICO EN EL QUE PODEMOS APLICAR LA
RECURRENCIA DIVIDE VENCERS
SUMA SUBSECUENCIA MXIMA:

ALGORITMO QUE, PARTIENDO DE UNA SECUENCIA DE n NMEROS COLOCADOS
ALEATORIAMENTE SOBRE UNA SECUENCIA (VECTOR), CALCULA LA SUMA MXIMA
DE LAS POSIBLES SUBSECUENCIAS DE ESE VECTOR.
I. RECURSIVA
PSEUDOCDIGO:
funcin SSMrecursiva (var a[1..n], izq, der) : valor
si izq = der entonces
si a[izq] > 0 entonces
devolver a[izq] (* caso base: si >0, es SSM *)
sino
devolver 0
fin si
sino
Centro := (izq + der) div 2 ;
Primerasolucion := SSM recursiva (a, izq, Centro) ;
Segundasolucion := SSM recursiva (a, Centro + 1, der) ;
Sumamaximaizquierda := 0 ; Suma izquierda := 0 ;
para i := Centro hasta izq paso -1 hacer
Suma izquierda := Suma izquierda + a[i] ;
si Suma izquierda > Suma maxima izquierda entonces
Sumamaximaizquierda := Suma izquierda
fin para;
Sumamaximaderecha := 0 ; Suma derecha := 0 ;
para i := Centro + 1 hasta der hacer
Suma derecha := Suma derecha + a[i] ;
si Suma derecha > Suma maxima derecha entonces
Suma maxima derecha := Suma derecha
fin para;
devolver max (Primera solucion, Segunda solucion, Suma maxima
izquierda + Suma maxima derecha)
fin si
fin funcin
25
COMPLEJIDAD:
SI CALCULAMOS LA COMPLEJIDAD POR RECURRENCIAS DIVIDE Y VENCERS,

OBTENDREMOS UNA O(nlogn).
II. EN LINEA:
PSEUDOCDIGO:
funcin SSMenlnea ( a[1..n] ) : <i, j, valor>
i:=1 ; EstaSuma:=0 ; SumaMax:=0 ; MejorI:=0 ; MejorJ:=0 ;
para j := 1 hasta n hacer
EstaSuma := EstaSuma + a[j] ;
si EstaSuma > SumaMax entonces
SumaMax := EstaSuma ;
MejorI := i ;
MejorJ := j
sino si EstaSuma < 0 entonces
i := j+1 ;
EstaSuma := 0
fin si
fin para;
devolver < MejorI, MejorJ, SumaMax>
fin funcin
COMPLEJIDAD:
TIEMPO LINEAL O(n).

BSQUEDA BINARIA:
SE TRATA DE HACER LA BSQUEDA DE UN ELEMENTO POR DICOTOMA SOBRE UN
VECTOR ORDENADO. VAMOS PARTIENDO NUESTRO ARRAY EN MITADES Y
BUSCANDO EN EL TROZO DONDE SE SUPONE QUE ESTAR NUESTRO ELEMENTO.
PSEUDOCDIGO:
Funcion BusquedaBinaria (x, a[1..n]) : posicion { a: vector ordenado de modo

no decreciente }
i := 1 ; j := n ;
{ espacio de busqueda: i..j }
mientras i <= j hacer
medio := (i + j) div 2 ;
si a[medio] < x entonces i := medio + 1
sino si a[medio] > x entonces j := medio - 1
sino devolver medio
fin mientras;
devolver "elemento no encontrado"
fin funcin
COMPLEJIDAD:
MEDIANTE RECURRENCIAS DIVIDE Y VENCERS, O(logn)

26
TEMA 4: ALGORITMOS VORACES:

LOS ALGORITMOS VORACES SON UNA CLASE DE ALGORITMOS QUE TIENEN EN
COMN 6 CARACTERSTICAS FUNDAMENTALES QUE TODOS DEBEN CUMPLIR:
RESUELVE PROBLEMAS DE OPTIMIZACIN: DONDE SE ELIGE UN

CANDIDATO DE VARIOS QUE SATISFACE SER EL PTIMO A ELEGIR.
MANEJAN CONJUNTOS DE POSIBLES CANDIDATOS.
FUNCIN DE COMPROBACIN EL CONJUNTO ES SOLUCIN?
FUNCIN DE SELECCIN CUL ES EL MEJOR CANDIDATO?
FACTIBLE NOS LLEVA A ALGUNA SOLUCIN ESTE CONJUNTO?
OBJETIVO
ESQUEMA DE UN ALGORITMO VORAZ:

funcin Voraz (C:conjunto): conjunto
S := conjunto vaco;
{ la solucion se construye en S }
mientras C <> conjunto vaco y no solucion(S) hacer
{ bucle voraz }
x := seleccionar(C);
C := C- { x };
si factible (SU { x } ) entonces
S := SU { x }
fin mientras;
si solucion (S) entonces devolver S
sino devolver "no hay soluciones"
fin funcin
1) PROBLEMA DE LA MOCHILA
TRATA DE METER EN UNA MOCHILA CON DETERMINADO PESO MXIMO W EL
MAYOR VALOR DE LOS ELEMENTOS POSIBLE. CADA ELEMENTO TIENE UN VALOR V
Y UN PESO W.
EN ESTE CASO, LA MEJOR SOLUCIN ES QUE NUESTRA FUNCIN DE SELECCIN SEA
TENIENDO EN CUENTA EL MS RENTABLE, ES DECIR, V/W MXIMO.
27
PSEUDOCDIGO:
funcin MochilaVoraz ( w[1..n], v[1..n], W): objetos[1..n]

x[i] := 0;
{ la solucion se construye en x }
peso := 0;
mientras peso < W hacer
{ bucle voraz: }
i := el mejor objeto restante;
si peso+w[i] <= W entonces
x[i] := 1;
peso := peso+w[i]
sino
x[i] := (W-peso)/w[i];
peso := W
fin si
fin mientras;
devolver x
fin funcin
COMPLEJIDAD:
SU COMPLEJIDAD ES DE O(nlogn), PUDIENDO MEJORAR SUS TIEMPOS MEDIANTE

MONTCULOS.
ORDENACIN TOPOLGICA:
ES LA ORDENACIN DE LOS NODOS DE UN GRAFO DIRIGIDO ACCLICO.
EL ALGORITMO TRATA DE LA BSQUEDA DEL NODO CON GRADO 0, ENVIARLO A LA
SALIDA Y ELIMINAR LAS ARISTAS QUE PARTEN DE L.
PSEUDOCDIGO:
funcin Ordenaciontopologica (G:grafo): orden[1..n]

Grado Entrada [1..n] := CalcularGradoEntrada (G);
{ para i := 1 hasta n hacer Numero Topologico [i] := 0;}
Crear Cola (C); contador := 1 ;
para cada nodo v hacer
si Grado Entrada [v] = 0 entonces
Insertar Cola (v, C);
mientras no Cola Vaca (C) hacer
v := Eliminar Cola (C);
Numero Topologico [v] := contador; incrementar contador;
para cada w adyacente a v hacer
Grado Entrada [w] := Grado Entrada [w] - 1;
si Grado Entrada [w] = 0 entonces
Insertar Cola (w, C)
fin para
fin mientras;
si contador <= n entonces devolver error "el grafo tiene un ciclo"
sino devolver Numero Topologico
fin funcin
28
COMPLEJIDAD:
IMPLEMENTADO MEDIANTE LISTAS DE ADYACENCIA, O(n+m).

PEOR CASO: m n(n-1) = O(n2)
MEJOR CASO: m 0 , m n = O(n)
RBOL EXPANDIDO MNIMO:

SE UTILIZA PARA LA OPTIMIZACIN DE CAMINOS, POR EJEMPLO, BUSCAR EL
CABLEADO MNIMO NECESARIO PARA CONECTAR TODAS LAS CASAS DE UN PUEBLO
A LA CORRIENTE ELCTRICA.
1. KRUSKAL:
PARTE DE UN BOSQUE QUE FUSIONA PARA CREAR UN NICO RBOL.
FUNCIN SELECCIN ARISTA MS CORTA
FACTIBILIDAD UNE COMPONENTES CONEXAS DISTINTAS
TRATA DE IR UNIENDO CONJUNTOS DE NODOS PASO A PASO RELACIONADOS POR
ARISTAS.
FINALMENTE, LAS CONEXIONES ENTRE NODOS SELECCIONADAS FORMAN EL

LLAMADO RBOL DE RECUBRIMIENTO MNIMO POR ALGORITMO DE KRUSKAL.
29
PSEUDOCDIGO:
funcin Kruskal ( G =(N,A) ) : rbol

Ordenar A segn longitudes crecientes;
n := |N|;
T := conjunto vaco;
inicializar n conjuntos, cada uno con un nodo de N;
repetir
{ bucle voraz: }
a := (u,v) : arista mas corta de A aun sin considerar;
Conjunto U := Buscar (u);
Conjunto V := Buscar (v);
si Conjunto U <> Conjunto V entonces
Fusionar (Conjunto U, Conjunto V);
T := T U { a }
fin si
hasta |T| = n-1;
devolver T
fin funcin
COMPLEJIDAD:
PARA EL PEOR CASO, SU COMPLEJIDAD ES DE O(mlogn).

2.
PRIM:
AL CONTRARIO QUE KRUSKAL, PRIM PARTE DE UN RBOL QUE VA CRECIENDO.

FUNCIN SELECCIN ARISTA MS CORTA QUE PARTE DEL NODO B
PSEUDOCDIGO:
funcin Prim ( L[1..n,1..n] ) :rbol

Distancia Mnima [1] := -1;
T := conjunto vaco;
Mas Prximo [i] := 1;
Distancia Mnima [i] := L[i,1]
fin para;
repetir n-1 veces:
{ bucle voraz }
min := infinito;
si 0 <= Distancia Mnima [j] < min entonces
min := Distancia Mnima [j];
k := j
fin si
fin para;
T := T U { ( Mas Prximo [k], k ) };
Distancia Mnima [k] := -1;
{ aadir k a B }
si L[j,k] < Distancia Mnima [j] entonces
Distancia Mnima [j] := L[j,k];
Mas Prximo [j] := k
fin si
fin para
fin repetir;
devolver T
fin funcin
30
COMPLEJIDAD:
O(n2), debido a la inicializacin lineal * bucle voraz lineal.
COMPARACIN DE COMPLEJIDADES ALGORITMOS

RBOL EXPANDIDO MNIMO
CAMINOS MNIMOS:
ENCONTRAR LOS CAMINOS MNIMOS NECESARIOS PARA LLEGAR DESDE EL ORIGEN
A TODOS LOS NODOS.
ALGORITMO DE DIJKSTRA VORAZ
FUNCIN DE SELECCIN NODO CON MENOR DISTANCIA CONOCIDA DESDE 1
UN CAMINO ES ESPECIAL SI TODOS SUS NODOS INTERMEDIOS PERTENECEN A LA
SOLUCIN. POR TANTO, EL CAMINO ESPECIAL MNIMO = CAMINO MNIMO.
PSEUDOCDIGO:
funcin Dijkstra ( L[1..n,1..n] ) : vector[1..n]

C := { 2, 3, ..., n };
D[i] := L[1,i];
repetir n-2 veces: { bucle voraz: }
v := nodo de C que minimiza D[v];
C := C- { v };
para cada w en C hacer
D[w] := min ( D[w], D[v]+L[v,w] )
fin repetir;
devolver D
fin funcin
COMPLEJIDAD:
O(n2), MEJORANDO AL USAR LISTAS DE ADYACENCIA (GRACIAS A RECORRER LISTAS

Y NO FILAS/COLUMNAS) HASTA O((n+m)logn)
31
TEMA 5: ALGORITMOS DIVIDE Y VENCERS

Y PROGRAMACIN DINMICA:
DIVIDE Y VENCERS:
TRATA DE DESCOMPONER UN CASO EN SUBCASOS PARA SER RESUELTOS MEDIANTE
RECURSIVIDAD INDEPENDIENTEMENTE Y, FINALMENTE, COMBINARLOS PARA
OBTENER LA SOLUCIN DEL CASO ORIGINAL.
EJEMPLOS: QUICKSORT, MERGESORT, BUSQUEDA BINARIA, SUMA SUBSECUENCIA
MXIMA
ESQUEMA DE ALGORITMO DIVIDE-VENCERS:
funcin Divide y Venceras (x): solucion
si x es suficientemente pequenoentonces
devolver ad-hoc(x)
{ MTODO PARA RESOLVER CASOS BASE }
sino
descomponer x en casos mas pequeos x1, x2, ..., xa;
para i := 1 hasta a hacer
yi := Divide y Venceras (xi)
fin para;
combinar los yi para obtener una solucion y de x;
devolver y
fin si
fin funcin
EL NMERO DE SUBCASOS ES INDEPENDIENTE A LA ENTRADA, NORMALMENTE PEQUEO (2 EN
QUICKSORT, MERGESORT) Y EN CASO DE SER 1 ES DIRECTO POR AD-HOC.
ES IMPORTANTE AL APLICAR ESTE ESQUEMA SABER SI ES EFICIENTE DESCOMPONER Y COMBINAR
LOS SUBCASOS Y DESCOMPONERLOS DE UNA FORMA BALANCEADA.
PROGRAMACIN DINMICA:
DIVIDE-VENCERS TIENE UN PROBLEMA INEFICIENTE, LLEGAR A VARIOS SUBCASOS
IGUALES, EN CUYO CASO SE RESUELVEN POR SEPARADO PESE QUE LA SOLUCIN ES
IDNTICA: FIBONACCI, POR EJEMPLO.
LA PROGRAMACIN DINMICA GUARDA LOS RESULTADOS Y LOS CONTRASTA,
OPERANDO CADA CASO 1 NICA VEZ.
PROGRAMACIN DINMICA O(logn)
DIVIDE-VENCERS O(n)
funcion fibDV(n): valor

funcion fibPD(n): valor
i := 1; j := 0; k := 0; h := 1;
si n < 2 entonces
devolver n
mientras n > 0 hacer
si n es impar entonces
sino
devolver fib1(n-1) + fib1(n-2)
t := j*h;
j := i*h + j*k + t;
fin si
fin funcion
i := i*k + t
fin si;
t := h2;
h := 2*k*h + t;
k := k2 + t;
32
n := n div 2
fin mientras;
devolver j
fin funcion
LOS ALGORITMOS VORACES SON EFICIENTES, PERO EXISTEN CASOS EN LOS QUE NO
ENCUENTRAN LA SELECCIN PTIMA DE CANDIDATOS.
POR EJEMPLO, EN EL PROBLEMA DE DEVOLVER EL CAMBIO, EL ALGORITMO VORAZ
NO ES PTIMO SEGN EL SISTEMA MONETARIO QUE USEMOS. CON EL CONJUNTO DE
MONEDAS C={1,4,6} EL ALGORITMO VORAZ FALLA. POR ELLO USAMOS LA
PROGRAMACIN DINMICA DE LA SIGUIENTE MANERA:
DEVOLUCIN DEL CAMBIO PROGRAMACIN DINMICA:
PSEUDOCDIGO:
funcin monedas (n): numero de monedas

const v[1..m]=[1,4,6]
{ denominaciones de las monedas }
{ se construye una tabla c[1..m, 0..n] }
para i := 1 hasta m hacer
c [i,0] := 0;
para i := 1 hasta m hacer
si i = 1 y j < v[i] entonces
c[1,j] := infinito
sino si i = 1 entonces
c[1,j] := 1 + c[1, j-v[1] ]
sino si j < v[i] entonces
c[i,j] := c[i-1,j]
sino
c[i,j] := min ( c[i-1, j], 1 + c[i, j-v[i] ] )
fin si
fin para
fin para;
devolver c[m,n]
fin funcin
COMPLEJIDAD:
O(mn)
RESOLUCIN INTUITIVA:
CONSEGUIR EL VALOR 8 CON UN SISTEMA MONETARIO C={1,4,6}, SIENDO EL VORAZ 3
MONEDAS: {6,1,1}
2 MONEDAS (DESPLAZAMIENTOS HACIA LA IZQUIERDA), {4,4} (FILA DONDE SE

ENCUENTRA EL DESPLAZAMIENTO).
33
PROBLEMA DE LA MOCHILA PROGRAMACIN DINMICA:

PRECOND OBJETOS NO FRACCIONABLES
EL ALGORITMO VORAZ NO FUNCIONA EN ESTE CASO, AS QUE ASISTIMOS A LA
PROGRAMACIN DINMICA, QUE NOS OFRECE SOLUCIN OPTIMA.
EJEMPLO:
NUMERO OBJETOS INDIVISIBLES Y NICOS= 3
PESO MAX MOCHILA= 9
SON 2 OBJETOS, {2,3}.
PSEUDOCDIGO:
funcin MochilaPD ( M[1..n,0..W], w[1..n] ) : C[1..n]

C[i]:=false;
v:=M[n,W];
i:=n; j:=W;
mientras i>1 y v>0 hacer
si M[i,j] <> M[i-1,j] entonces
(* el objeto i est en la configuracin *)
C[i]:=true;
j:=j-w[i];
v:=M[i-1,j]
(* leer el valor de la tabla evita calcular v-v[i] *)
fin si;
i:=i-1
fin mientras;
si v>0 entonces
C[1]:=true;
(* caso particular: i=1 *)
devolver C
fin funcin
COMPLEJIDAD:
O(nW).
LA PROGRAMACIN DINMICA NO ES SIEMPRE APLICABLE, AUNQUE EN MUCHOS
CASOS AUMENTA LA OPTIMIZACIN DE PROBLEMAS.
34
TEMA 6: EXPLORACIN SOBRE GRAFOS:

RECORRIDOS:
I. PROFUNDIDAD:
SE VISITA EL PRIMER NODO Y SE PARTE A UNO ADYACENTE.
PSEUDOCDIGO:
procedimiento rp (v)
{ v no ha sido visitado anteriormente }
(*)
marca[v] := visitado;
para cada w adyacente a v hacer
si marca[w] != visitado entonces
rp(w)
fin procedimiento
COMPLEJIDAD:
O(n+m).
*
PARA NUMERAR EN PREORDEN:
visita := visita+1;
preorden[v] := visita;
RECORRER COMPLETAMENTE UN GRAFO:

procedimiento Recorridop (G=(N,A))
marca[v] := no visitado;
si marca[v] != visitado entonces
rp(v)
fin procedimiento
PARA UN USO NO RECURSIVO DE RECORRIDO EN PROFUNDIDAD SE USA UNA

PILA, PERO QUE NO MODIFICA LA COMPLEJIDAD ALGORTMICA DEL
RECORRIDO:
procedimiento rp2 (v)
Crear Pila (P); marca[v] := visitado; Apilar(v,P);
mientras no Pila Vaca (P) hacer
mientras exista w adyacente a Cima(P): marca[w] != visitado hacer
marca[w] := visitado; Apilar (w,P)
fin mientras;
Desapilar (P)
fin mientras
fin procedimiento
35
II.
ANCHURA:
SE VISITAN TODOS LOS NODOS ADYACENTES.

USAREMOS UNA COLA PARA ALMACENAR LOS NODOS
PSEUDOCDIGO:
procedimiento ra (v)
Crear Cola (C); marca[v] := visitado; Insertar Cola (v,C);
mientras no Cola Vaca (C) hacer
u := Eliminar Cola (C);
para cada nodo w adyacente a u hacer
si marca[w] != visitado entonces
marca[w] := visitado; Insertar Cola (w,C)
fin si
fin para
fin mientras
fin procedimiento
COMPLEJIDAD:
AL IGUAL QUE PROFUNDIDAD, O(n+m)
III.
PROFUNDIDAD (PILA) PARTIENDO DE NODO 1

(EN CASO DE RECURSIVIDAD, LA PILA DE
RECURSIVIDAD)
EJEMPLOS:
1
5
- APILAMOS EL 3
- APILAMOS EL 2
- APILAMOS EL 5
- APILAMOS EL 4
SOLUCIN: 1,3,2,5,4
ANCHURA (COLA) PARTIENDO DE NODO 1
4
2
36
- INTRODUCIMOS EN LA COLA EL 3 Y EL 5
(ORDEN DE MENOR A MAYOR, INDIFERENTE). VISITAMOS EL NODO 3 (PRIMERO DE LA COLA)
Y ALMACENAMOS EL 2.
- VISITAMOS EL NODO 5 (PRIMERO DE LA COLA)
Y ALMACENAMOS SUS ADYACENTES (4)
- VISITAMOS EL 2 SIN ADYACENTES
- VISITAMOS EL 4 SIN ADYACENTES
SOLUCIN: 1,3,5,2,4
TEMA 7: COMPLEJIDAD COMPUTACIONAL:

ALGORITMIA: DISEO DE ALGORITMOS ESPECFICOS, LO MAYOR EFICIENTES
POSIBLE.
COMPLEJIDAD COMPUTACIONAL: ESTUDIO DEL PROBLEMA, ESTUDIANDO LOS
POSIBLES ALGORITMOS PARA RESOLVERLOS (CONOCIDOS O NO).
PROBLEMA TRATABLE: SI SE PUEDE RESOLVER EN TIEMPO POLINOMICO nk
SIENDO K UN NUMERO REAL CUALQUIERA. DECIMOS QUE PERTENECE AL
CONJUNTO DE PROBLEMAS P. EJEMPLO: ENCONTRAR EL CAMINO MNIMO EN UN
MAPA.
PROBLEMA INTRATABLE: NO CONOCEMOS ALGORITMOS EN TIEMPO POLINMICO
QUE PUEDAN RESOLVERLO. DECIMOS QUE PERTENECE AL CONJUNTO NP, QUE NO SE
SABE SI PERTENECE O NO A P. EJEMPLO: SUMA DE SUBCONJUNTOS QUE DE UN
RESULTADO CONCRETO.
NP SUBCONJUNTO DE P? SE CREE QUE NO LO ES, PERO TODAVA NO SE SABE
CIERTAMENTE. SI SE SABE QUE P ES SUBCONJUNTO DE NP PORQUE SI TENEMOS UN
ALGORITMO POLINOMICO PARA OBTENER LA SOLUCIN, PODEMOS USARLO PARA
COMPROBARLA.
MQUINA DE TURING:
MODELO COMPUTACIONAL ABSTRACTO QUE SE USA PARA ESTUDIAR LA
COMPLEJIDAD. ESTA COMPUESTA POR UNA CINTA INFINITA, UN CABEZAL
LECTOR/ESCRITOR Y UN CONTROL DE ESTADOS FINITOS, EL CUAL ALMACENA EL
ESTADO ACTUAL Y LE APLICA UNAS REGLAS PARA OBTENER EL CAMBIO DE ESTADO.
MODIFICANDO ESTAS REGLAS ES COMO LA MQUINA DE TURING REALIZA
MLTIPLES FUNCIONES DISTINTAS.
PROBLEMA P EN MQUINA TURING: SE PUEDE RESOLVER EN TIEMPO
POLINMICO SOBRE UNA MQUINA TURING DETERMINISTA
PROBLEMA NP EN MQUINA TURING: SE PUEDE RESOLVER EN TIEMPO
POLINMICO SOBRE UNA MQUINA TURING NO DETERMINISTA, ES DECIR, CON
INFINITAS POSIBLES EJECUCIONES PARALELAS.
PROBLEMAS NP-COMPLETOS:
COMO SABEMOS QUE P ES SUBCONJUNTO DE NP? POR REDUCIBILIDAD
UN PROBLEMA P1 ES REDUCIBLE A P2 SI, DADO UN ALGORITMO A QUE RESUELVE P2
PODEMOS OBTENER OTRO PARA RESOLVER P1 AADIENDO COMO MUCHO UN
FACTOR POLINMICO A SU COMPLEJIDAD. POR EJEMPLO, SE HACE UNA LLAMADA
AL ALGORITMO DESDE OTRA FUNCIN QUE RESUELVE P2.
ES NP-COMPLETO CUALQUIER ALGORITMO SI EST EN NP Y CUALQUIER PROBLEMA
EN NP ES REDUCIBLE A L.
37
TABLA RESUMEN COMPLEJIDADES

ALGORITMO
CASO
EXPLICACIN
COMPLEJIDAD
INSERCIN
MEDIO/PEOR
MEJOR
DESORDENADO
ORDENADO
O(n2)
O(n)
SELECCIN
TODOS
SIEMPRE
O(n2)
SHELL
TODOS
CON INCREMENTOS DE SHELL
O(n2)
ORD. MONTCULO
TODOS
SIEMPRE
O(nlogn)
FUSIN
TODOS
SIEMPRE
O(nlogn) T(n)=2T(n/2)+n
QUICKSORT
MEJOR
PIVOTE =
MEDIANA EXACTA
NUNCA COINCIDE
COINCIDE A VECES
O(nlogn) T(n)=2T(n/2)+cn
PEOR
MEDIO
O(n2) *
O(nlogn) *
BUSQUEDA BIN.
PEOR
NO EST/LTIMA
LLAMADA REC.
O(logn) T(n)=T(n/2)+1
S.S.M
RECURSIVA
EN LNEA
------------
O(nlogn) T(n)=2T(n/2)+n
O(n)
ORDENACIN
TOPOLGICA
PEOR
MEJOR
MEDIO
------------
O(n2)
O(n)
O(n+m)
KRUSKAL
TODOS
SIEMPRE
O(mlogn)
PRIM
TODOS
SIEMPRE
O(n2)
DIJKSTRA
TODOS
SIEMPRE
O(n2)
MONEDAS P.D.
TODOS
SIEMPRE
O(n*m)
MOCHILA
VORAZ
P.D.
-------------
O(nlogn)
O(n*W)
EXPLORACIN DE GRAFOS
PROFUNDIDAD
TODOS
SIEMPRE
O(n+m)
ANCHURA
TODOS
SIEMPRE
O(n+m)
* NO POR RECURRENCIA DIVIDE-VENCERS!
38

Apuntes Algoritmos

Transféré par

Informations du document

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Apuntes Algoritmos

Transféré par

Droits d'auteur :

Formats disponibles

COMPILANDO-ES

http://compilando-es.blogspot.com.es/ & FIC (UDC)

TEMA 1: ANLISIS DE ALGORITMOS

OPERACIONES: + - * / SQRT ...

2. UNA SECUENCIA SE TRATA COMO EL MXIMO DE LAS COMPLEJIDADES DE

LA CONDICIN: si i<n y j<k entonces

CONDICIN VERDADERA: SI SE CUMPLE LA(S) CONDICIN(ES),

CONDICIN FALSA: SI NO SE CUMPLE EL SI, EFECTUAMOS (SI EXISTE) EL

*comparaciones (operaciones elementales), O(1)*

HAYAMOS LA COMPLEJIDAD DE LA SECUENCIA INTERNA DEL

II. MIENTRAS: mientras i<n hacer secuencia fin mientras

HAYAMOS LA CONDICIN *caso del ejemplo= operacin elemental O(1)*

http://compilando-es.blogspot.com.es/ & FIC (UDC)

Ejemplo de anlisis de un pseudocdigo:

para i:=2 hasta n hacer

http://compilando-es.blogspot.com.es/ & FIC (UDC)

APLICANDO EL TEOREMA DE RECURRENCIAS:

DISTINGUIMOS VARIOS TIPOS:

HOMOGNEAS DE COEFICIENTES CONSTANTES

LAS PRESENTADAS EN LOS APUNTES Y LAS MS INTERESANTES SON LAS DIVIDE

http://compilando-es.blogspot.com.es/ & FIC (UDC)

TEMA 2: ESTRUCTURAS DE DATOS

http://compilando-es.blogspot.com.es/ & FIC (UDC)

http://compilando-es.blogspot.com.es/ & FIC (UDC)

funcin Primero ( C ) : Tipo_de_elemento

SUS OPERACIONES ELEMENTALES SON LAS DE VISUALIZAR LA LISTA, BUSCAR UN

funcin Buscar ( x, L ) : posicion de la 1a ocurrencia o nil

http://compilando-es.blogspot.com.es/ & FIC (UDC)

funcin Ultimo Elemento ( p ) : test

funcin Buscar Anterior ( x, L ) : posicion anterior a x o a nil

RBOL BINARIO DE BSQUEDA:

CAMINO: ES LA SECUENCIA DE NODOS QUE SE RECORREN PARA LLEGAR A OTRO K,

http://compilando-es.blogspot.com.es/ & FIC (UDC)

ALTURA: EL CAMINO MAS LARGO DE LA RAZ A UNA HOJA.

http://compilando-es.blogspot.com.es/ & FIC (UDC)

procedimiento Insertar (x, var A)

POST-ORDEN: HIJO IZDO HIJO DER RAZ

http://compilando-es.blogspot.com.es/ & FIC (UDC)

PRE-ORDEN: RAZ HIJO IZDO HIJO DER

SE UTILIZAN PARA ALMACENAR DATOS SOLO SIENDO RELEVANTE SU MXIMO O

http://compilando-es.blogspot.com.es/ & FIC (UDC)

procedimiento CrearMontculo ( V[1..n], M )

<= M.Tamanomonticulo y M.Vectormontculo[HijoDer] >

http://compilando-es.blogspot.com.es/ & FIC (UDC)

EJERCICIO: BUSCAR EL K-SIMO MAYOR DE n NMEROS

Crear montculo de manimos con los k primeros nos

funcin KesimoMayor ( V[1..n], k ): numero {1kn}

COMO HEMOS VISTO, LA COMPLEJIDAD MNIMA DE INSERCIONES Y ELIMINACIONES

FCIL Y RPIDA DE CALCULAR

DISTRIBUIR UNIFORMEMENTE LAS CLAVES

http://compilando-es.blogspot.com.es/ & FIC (UDC)

funcin Dispersion1 (Clave, TamanoClave):Indice

ESTA FUNCIN ES SENCILLA Y RPIDA DE EJECUTAR, PERO SI EL NMERO DE

EN ESTE CASO, LA DISPERSIN SE CALCULA MEDIANTE LA FRMULA MATEMTICA

Y OFRECE UNA DISPERSIN RPIDA Y HOMOGNEA.

CONSISTE EN TENER EN UNA LISTA ELEMENTOS QUE SE DISPERSAN CON EL MISMO

http://compilando-es.blogspot.com.es/ & FIC (UDC)

funcin Buscar (Elem, Tabla): Posicion

AL CONTRARIO QUE EN LA ABIERTA, SI SUCEDE UNA COLISIN SE BUSCA OTRO

http://compilando-es.blogspot.com.es/ & FIC (UDC)

procedimiento Insertar (Elem, D)

procedimiento Eliminar (Elem, D)

PARA RESOLVER COLISIONES SE PUEDEN APLICAR 3 MTODOS DE EXPLORACIN

EXPLORACIN LINEAL: f(i)= i

comparaciones (operaciones elementales), O(1)

HAYAMOS LA CONDICIN caso del ejemplo= operacin elemental O(1)