Programacion 3

Metodos de ordenamiento (de nuevo)

dividir y combinar

Alejandro Mujica
Jes
us Perez

Semestre A2017

Programaci
on 3 Semestre A2017 1/1
Algoritmos dividir y combinar

Toma un problema grande y lo parte en n sub problemas mas

sencillos de resolver.
Halla la solucion de cada sub problema por separado.
Combina todas la peque
nas soluciones para crear una solucion general.

Programaci
on 3 Semestre A2017 2/1
Algoritmos dividir y combinar

Programaci
on 3 Semestre A2017 3/1
Ordenamiento por mezcla (mergesort)

Pseudo codigo
mergesort
input: S (desordenada)
output: S (ordenada)
Picar S en dos partes iguales (si se puede)
Sean S1 y S2 las dos particiones
Ordenar S1 y S2
Efectuar mezcla ordenada de S1 y S2

Programaci
on 3 Semestre A2017 4/1
Ordenamiento por mezcla (mergesort)

Codigo en C++
void mergesort(Dlink & l, Cmp cmp)
{
if (l.is unitarian or empty())
return;
auto p = l.split();
mergesort(p.first, cmp);
mergesort(p.second, cmp);
l = merge(p.first, p.second, cmp);
}

Programaci
on 3 Semestre A2017 5/1
Ordenamiento por mezcla (mergesort)

Mezcla ordenada
Dlink merge(Dlink & l1, Dlink & l2, Cmp cmp)
{
Dlink l;
while (not l1.is empty() and not l2.is empty())
{
if (cmp(l1.get next(), l2.get next())
l.append(l1.remove next());
else
l.append(l2.remove next());
}
Concatenar a l la lista no vaca
}

Programaci
on 3 Semestre A2017 6/1
Ordenamiento por mezcla (mergesort)

Codigo en C++
void mergesort(Dlink & l, Cmp cmp)
{
if (l.is unitarian or empty())
return;
auto p = l.split();
mergesort(p.first);
mergesort(p.second);
l = merge(p.first, p.second, cmp);
}

Programaci
on 3 Semestre A2017 7/1
Ordenamiento rapido (quicksort)

Primero ejemplifiquemos.

Programaci
on 3 Semestre A2017 8/1
Ordenamiento rapido (quicksort)
Particion
tuple<Dlink, Dlink *, Dlink> partition(Dlink & l, Cmp cmp)
{
Dlink * pivot = l.remove next();
Dlink ls, lg;
while (not l.is empty())
{
Dlink * current = l.remove next();
if (cmp(current, pivot))
ls.append(current);
else
lg.append(current);
}
return make tuple(ls, pivot, lg);
}

Programaci
on 3 Semestre A2017 9/1
Ordenamiento rapido (quicksort)

Quicksort
void quicksort(Dlink & l, Cmp cmp)
{
if (l.is unitarian or empty())
return;
auto p = partition(l, cmp);
quicksort(get<0>(p));
quicksort(get<2>(p));
l.concat(get<0>(p));
l.append(get<1>(p));
l.concat(get<2>(p));
}

Programaci
on 3 Semestre A2017 10 / 1
Quicksort sobre arreglos

Esquema de particion

Programaci
on 3 Semestre A2017 11 / 1
Quicksort sobre arreglos
Particion
int partition(T * a, int l, int r, Cmp cmp)
{
int p = select pivot(a, l, r, cmp);
swap(a[p], a[r]);
int i = l, j = r - 1;
while (i j)
{
while (cmp(a[i], a[r])) ++i;
while (j i and not cmp(a[j], a[r])) --j;
swap(a[i], a[j]);
}
swap(a[i], a[r]);
return i;
}

Programaci
on 3 Semestre A2017 12 / 1
Quicksort sobre arreglos

Quicksort
void quicksort(T * a, int l, int r, Cmp cmp)
{
if (l > r)
return;
int pivot = partition(a, l, r, cmp);
quicksort(a, l, pivot - 1);
quicksort(a, pivot + 1, r);
}

Programaci
on 3 Semestre A2017 13 / 1
Quicksort sobre arreglos
Mejora para el consumo de espacio.
Quicksort
void quicksort(T * a, int l, int r, Cmp cmp)
{
if (l > r)
return;
int pivot = partition(a, l, r, cmp);
if (pivot - l < r - pivot) {
quicksort(a, l, pivot - 1);
quicksort(a, pivot + 1, r);
}
else {
quicksort(a, pivot + 1, r);
quicksort(a, l, pivot - 1);
}
}
Programaci
on 3 Semestre A2017 14 / 1
Seleccion del pivote

Seleccion al azar
Seleccionar m elementos y tomar la mediana entre ellos.
Seleccionar la mediana entre el primer, el central y el u
ltimo.

Programaci
on 3 Semestre A2017 15 / 1
Seleccion aleatoria

Random select
T random select(T * a, int i, int l, int r, Cmp cmp)
{
int pivot = partition(a, l, r, cmp);
if (pivot == i)
return a[pivot];
if (i < pivot)
return random select(a, i, l, pivot - 1, cmp);
return random select(a, i, pivot + 1, r, cmp);
}

Programaci
on 3 Semestre A2017 16 / 1
Posicion aleatoria

Random position
int random position(T * a, T k, int l, int r, Cmp cmp)
{
int pivot = partition(a, l, r, cmp);
if cmp(k, a[pivot])
return random position(a, k, l, pivot - 1, cmp);
else if cmp(a[pivot], k)
return random position(a, k, pivot + 1, r, cmp);
return pivot;
}

Programaci
on 3 Semestre A2017 17 / 1
C
omo podemos hacer los dos algoritmos anteriores sobre listas?

Programaci
on 3 Semestre A2017 18 / 1
C
omo hacemos la b
usqueda binaria sobre listas?

Programaci
on 3 Semestre A2017 19 / 1
C
omo hacemos el algoritmo mergesort sobre arreglos?

Programaci
on 3 Semestre A2017 20 / 1
Resumen

AD AO LD LO
Inserci
on O(1) O(n) O(1) O(n)
Busqueda O(n) O(lg n) O(n) O(n)
Eliminaci on O(n) O(lg n) + O(n) O(n) O(n)
Uni
on O(n2 ) O(n) O(n2 ) O(n)
Interseccion O(n2 ) O(n) O(n2 ) O(n)
Partici
on O(n) O(n) O(n) O(n)
Selecci
on O(n) O(1) O(n) O(n)
Posici
on O(n) O(lg n) O(n) O(n)

Programaci
on 3 Semestre A2017 21 / 1