Você está na página 1de 15

Estructura de datos y

algoritmos
Unidad 05 Recursividad y
Ordenamiento

Profesores

Alfredo Granda
Juan Ramrez

Unidad 05 Ordenamiento
Avanzado
Objetivos

Tcnicas de Diseo:
Algoritmos Incrementales: alg. de insercin
Algoritmos Divide y Vencers
Hay muchos mas...

Ordenamientos
Merge Sort
Quicksort

TDA: Divide y Vencers


(Divide and Conquer)
Un problema se divide en partes mas
pequeas para su solucin.
En el caso de la recursin, siempre se
trata de llamar a la funcin con un
parmetro mas chico.
El proceso continua hasta que se obtiene
el caso mas bsico que es de fcil solucin
(caso base).
Es comn encontrar este mtodo usado
con funciones recursivas, pero tambin
puede usarse sin ella (ejemplo : bsqueda

Ejemplo D&C: Bsqueda


Binaria
La bsqueda binaria recursiva es un
ejemplo del mtodo divide y vencers.
Usualmente se trata de un mtodo que
contiene DOS llamadas recursivas a si
mismo, para cada mitad del problema.
En la bsqueda binaria, hay dos llamadas,
sin embargo solo una se ejecuta debido a
la condicin.
Hay algoritmos que necesitaran que se
ejecutan ambas mitades y luego el
resultado se combina

TDA Divide and Conquer


Tiene 3 pasos en cada nivel:
Dividir
Conquistar
los
subproblemas
resolvindolos recursivamente. Si ya son
lo suficientemente pequeos, entonces
resolverlos fcilmente.
Combinar
las
soluciones
de
los
subproblemas.

MergeSort
Divide la lista en dos sublistas de longitud
la mitad de la lista original (aprox.)
Divide cada sublista recursivamente hasta
que tengamos listas de longitud 1, en
cuyo caso se devuelve la propia lista
Mezcla las dos sublistas en una nueva lista
ordenada

MergeSort
void mergeSort(int *vec, int ne)
{
__mergeSort(vec, 0, ne-1);
}
void __mergeSort(int *vec, int izq, int der)
{
if (izq >= der) return;
int medio = (izq + der)/2;
__mergeSort(vec, izq, medio);
__mergeSort(vec, medio+1, der);
__merge(vec, izq, medio+1, der);
}

MergeSort
void __merge(int *vec, int izq, int medio, int der)
{
int h = izq;
int k = medio;
int n = der - izq + 1;
int *vecAux = new int[n];
for (int i=0; i<n; i++)
{
if (h >= medio)
{ vecAux[i] = vec[k]; k++; continue; }
if (k > der)
{ vecAux[i] = vec[h]; h++; continue; }
if (vec[h] < vec[k])
{ vecAux[i] = vec[h]; h++; }
else
{ vecAux[i] = vec[k]; k++; }
}
for (int i=0; i<n; i++)
vec[i+izq] = vecAux[i];
delete[] vecAux;
}

MergeSort

QuickSort
Inventado por CAR Hoare, 1960
Elige un dato, el pivote, de la lista
Reordena la lista de forma que
todos los datos menores que el pivote estn a
la izquierda del pivote y
los datos mayores a su derecha.

Ordena recursivamente
la sublista de los datos menores y
la sublista de los datos mayores

QuickSort
Eleccin del pivote
Encontrar el pivote ptimo llevara demasiado
tiempo
Se toma uno cualquiera

No usa mucho espacio auxiliar y en


promedio requiere N log N operaciones.
Es recursivo y en el peor caso usa N2
operaciones
QuickSort
es
una
versin
del
ordenamiento
en
un
rbol
binario
optimizada respecto del espacio

QuickSort
void quickSort(int *vec, int n)
{
__quickSort(vec, 0, n-1);
}
void __quickSort(int *vec, int left, int right)
{
if (right <= left) return;
int posPivote = particion(vec, left, right);
__quickSort(vec, left, posPivote-1);
__quickSort(vec, posPivote+1, right);
}

QuickSort
int particion(int *vec, int left, int right)
{
int pivote = vec[left];
int h = left + 1;
int k = right;
while (h <= k)
{
if (vec[h] < pivote)
h++;
else {
if (vec[k] < pivote) {
int aux = vec[h];
vec[h] = vec[k];
k--;
}
else
k--;
}
}
vec[left] = vec[k];
vec[k] = pivote;
return k;
}

vec[k] = aux;

QuickSort

Animaciones - Comparaciones
http://www.sorting-algorithms.com/
www.coderaptors.com/?All_sorting_algorithms
http://www.sorting-algorithms.com/random-initial-order