Professional Documents
Culture Documents
Divide y vencerás.
Introducción
Método divideYVenceras(x)
Si (x es suficientemente pequeño) entonces
retornar soluciónInmediata(x)
Sino
descomponer x en {x1,…, xk}
Para i desde 1 hasta k hacer
yi divideYVenceras(xi)
Fin Para
y recombinar (y1, …, yk)
retornar y
Fin Si
Fin Método
Esquema General
t ( n) k * t ( n / k ) g ( n)
Algoritmo recursivo
División del problema en subproblemas y combinación
eficiente de las soluciones parciales.
Los subproblemas deben tener, aproximadamente, el
mismo tamaño.
Algoritmo específico
Para resolver problemas de tamaño pequeño.
Determinación del umbral
Para decidir cuando finalizar la descomposición
recursiva del problema y aplicar el algoritmo
específico.
Algoritmos de simplificación
Hallar elemento 22
Búsqueda binaria
Clase BusquedaBinaria
Método BusBin (a, prim, ult, val )
Si (prim > ult) entonces
retornar -1
Sino
medio (prim + ult) div 2
Si (val = a[medio])
retornar medio
Sino
Búsqueda binaria
Eficiencia
O(log n), en todos los casos.
Ejemplo: Multiplicación de enteros
grandes
Multiplicación de enteros de n cifras
Algoritmo clásico
1234*5678 = 1234* (5*1000 + 6*100+7*10+8)
= 1234*5*1000 + 1234*6*100 + 1234*7*10 +
1234*8
Operaciones básicas:
Multiplicaciones de digitos: O(1)
Sumas de digitos: O(1)
Desplazamientos: O(1)
1234 = 12*100 + 34
5678 = 56*100 + 78
1. Dividir
X = 12345678 = xi*104 + xd xi=1234, xd=5678
Y = 24680135 = yi*104 + yd yi=2468, yd=0135
2. Combinar
X*Y = (xi*104 + xd) * (yi*104 + yd)
= xi*yi*108 + (xi*yd+xd*yi)*104 + xd*yd
Multiplicación de enteros de n cifras
X = xi*10s + xd
Y = yi*10s + yd
Eficiencia
Multiplicación de enteros de n cifras
Comparación de la eficiencia
Ejemplo. Ordenación por fusión
(MergeSort)
MergeSort
Dividir O(1)
Ordenar 2t*O(n/2)
Fusionar O(n)
MergeSort
F H
B M C N D
E P R
Terminología de árboles
raíz Nivel 0
Padre
de y
Nodo x int int Nivel 1
Hijo de x
ter Nivel 3
A
subárbol
F H
B M C N D
P R
Árboles Binarios
A A
Árbol
B degenerado
B C
D E F
D
G H E
Representación mediante punteros
struct nodo{
float datos;
nodo *hijo_izdo;
nodo *hijo_dcho;
};
typedef nodo *pnodo;
Árboles binarios mediante punteros
A
A
B C
N
B C
E F
D
N N N
D E F N
G H
G H N N N N
Declarar nodo de un árbol binario
struct nodo{
float dato;
nodo *izdo;
nodo *dcho;
};
typedef nodo *pnodo;
7 11
I D
Recorrido pre orden - NID
B C
2 5
D E F G
3 4 6 7
A, B, D, E, C, F, G
Recorrido pre orden - NID
15 2
5 9 19
17 3 23
25
2 3
Recorrido pre orden en C++
struct nodo{
float dato;
nodo *hijo_izdo, *hijo_dcho;
};
typedef nodo *pnodo;
void preorden (pnodo raiz)
{
if (raiz!=NULL){
cout<<raiz->datos;
preorden(raiz->hijo_izdo);
preorden(raiz->hijo_dcho);
}
}
Recorrido In Orden - IND
I D
Recorrido in orden - IND
B C
2 6
D E F G
1 3 5 7
D, B, E, A, F, C, G
Recorrido In Orden - IND
15 2
5 9 19
17 3 23
25
1 3
Recorrido in orden en C++
struct nodo{
float dato;
nodo *hijo_izdo, *hijo_dcho;
};
typedef nodo *pnodo;
void inorden (pnodo raiz)
{
if (raiz!=NULL){
inorden(raiz->hijo_izdo);
cout<<raiz->datos;
inorden(raiz->hijo_dcho);
}
}
Recorrido Post Orden - IDN
I D
Recorrido Post Orden - IDN
B C
3 6
D E F G
1 2 4 5
D, E, B, F, G, C, A
Recorrido Post Orden - IDN
15 2
5 9 19
17 3 23
25
1 2
Recorrido post orden en C++
struct nodo{
float dato;
nodo *hijo_izdo, *hijo_dcho;
};
typedef nodo *pnodo;
void postorden (pnodo raiz)
{
if (raiz!=NULL){
postorden(raiz->hijo_izdo);
postorden(raiz->hijo_dcho);
cout<<raiz->datos;
}
}