ALGORITMO DE ORDENAMIENTO POR MEZCLA (MergeSort)

Este algoritmo fue desarrollado por el matemático húngaro John Von Neumann en 1945. Consiste en dividir en dos partes
iguales el vector a ordenar, ordenar por separado cada una de las partes, y luego mezclar ambas partes, manteniendo el
orden, en un solo vector ordenado.

El algoritmo MergeSort (u Ordenamiento por mezcla) es un algoritmo que sirve para ordenar secuencias de datos. Utiliza los
siguientes tres pasos:

1) DIVIDIR: divide la secuencia de "n" elementos a ordenar en dos subsecuencias de "n/2" elementos cada una.

2) VENCER: ordena las dos subsecuencias de manera recursiva mediante el algoritmo MERGESORT.

3) COMBINAR: combina las dos subsecuencias ordenadas para generar la solución.

FUNCIONAMIENTO

El proceso de este algoritmo es fusionar sucesivamente mitades ya ordenadas de datos:

El completo de ellos, grupo de datos a ordenar es dividido en sus dos mitades pues es más sencillo ordenar una parte de los
datos que el conjunto cuando quede un solo dato en un subgrupo se termina el proceso de división pues ese subgrupo ya
está ordenado. A continuación, se mezclan ambas mitades ordenando los datos a medida que se combinan, para ello se
emplea un algoritmo sencillo que requiere un espacio auxiliar del tamaño del grupo original para añadir el dato
correspondiente de cada subgrupo así:

Se comparan entonces los elementos de la mitad 1 en la posición pos1 y de la mitad 2 en la posición pos2, el
menor se copia en ‘mezcla’ en la posición posMezcla, se incrementan las posiciones del origen que se ha
copiado (pos1 o pos2) y la del espacio de destino (posMezcla) y se compara el nuevo par de elementos;
finalmente alguna de las dos mitades habrá sido copiada completamente, entonces se debe copiar en el
espacio de mezcla los elementos que hayan quedado sin copiar de la otra mitad.

El método de mezcla realiza un número de comparaciones que aumenta linealmente con el número de
elementos a intercalar

Supongamos que “A” es una lista ordenada de “NA”=500 elementos y “B” es otra lista ordenada de “NB”=600 elementos. La
operación que combina los elementos de “A” y “B” en una única lista ordenada de N=(NA+NB) elementos, se llama mezcla.
Una forma sencilla de mezclar es colocar los elementos de B tras los elementos de A y entonces hacer uso de algún algoritmo
de ordenación u ordenamiento (burbuja o inserción para la lista entera).

Este método no saca ventaja del hecho de que A y B estén ya individualmente ordenados. El algoritmo de mezcla permite
ordenar dichas listas ordenadas aprovechando o sacando ventaja que de manera individual ya estaban ordenados.

Este tipo de ordenamiento es útil cuando se tiene una estructura ordenada y los nuevos datos a añadir se almacenan
en una estructura temporal para después agregarlos a la estructura original de manera que vuelva a quedar
ordenada
Este tipo de ordenamiento es útil cuando se tiene una estructura ordenada y los nuevos datos a añadir
se almacenan en una estructura temporal para después agregarlos a la estructura original de manera
que vuelva a quedar ordenada.
INTERFASE DE ORDENAMIENTO POR MEZCLA

**************

Estrategia de Merge Sort

Merge Sort está basado en la técnica de diseño de algoritmos Divide y
Vencerás, de la cual se habló aquí mismo hace un tiempo. Recordando
un poco, esta técnica consiste en dividir el problema a resolver en
subproblemas del mismo tipo que a su vez se dividirán, mientras no sean
suficientemente pequeños o triviales.
 Veamos una panorámica de la estrategia que sigue este algoritmo para
ordenar una secuencia S de n elementos:
 Si S tiene uno o ningún elemento, está ordenada
 Si S tiene al menos dos elementos se divide en dos secuencias S1 y S2
 S1 contiene los primeros n/2 elementos y S2 los restantes
 Ordenar S1 y S2, aplicando recursivamente este procedimiento
 Mezclar S1 y S2 en S, de forma que ya S1 y S2 estén ordenados

Veamos ahora como sería la estrategia para mezclar las secuencias:

Se tienen referencias al principio de cada una de las secuencias a
mezclar (S1 y S2). Mientras en alguna secuencia queden elementos, se
inserta en la secuencia resultante (S) el menor de los elementos
referenciados y se avanza esa referencia una posición.
 PSEUDOCODIGO MEZCLAR
// Se asume que se tienen 2 vectores del mismo tipo de datos, previamente ordenados
// Vector A tiene NA elementos ordenados EJEMPLO  7
// Vector B tiene NB elementos ordenados EJEMPLO  9
// Este algoritmo, mezcla (SORT) estos 2 vectores, dejando un tercer vector C con el resultado, que va contener NA + NB elementos.

PA = 1 , PB = 1 , PC = 1 // Son las posiciones de los vectores

MIENTRAS (PA <= NA) Y (PB <= NB)

Si A(PA) < B(PB) Then // porque lo desean ascendente
C(PC) = A(PA) ******
PC = PC + 1
PA = PA + 1
De_lo_contrario
C(PC) = B(PB)
PC = PC + 1
PB = PB + 1
End If
FIN MIENTRAS
** Cuando se acaba este ciclo, es porque ya se vació uno de los vectores (A o B)
** A continuación preguntamos cuál de los vectores (A o B) es el que se terminó de pasar al vector C
** Y en base a eso… se requiere pasar los datos que faltan al vector C.. en la parte inferior…

Si PA > NA Entonces // que se vació fue conjunto “A”

Para k = 1 a (NB – PB)
C(PC + k) = B(PB + k)
Fin para K
De_lo_contrario
Para k = 1 a (NA – PA)
C(PC + k) = A(PA + k)
Fin para K
Fin SI
FIN DE ALGORITMO

PA=7 PB=10 & PC=17 ASCENDENTE

VA VB VC=MEZCLA
->1 10 1 15 ->1 10
-2 20 2 25 2 15
3 30 3 35 3
4 40 4 45 4
5 50 5 55 5
6 60 6 65 6
NA=7 120 7 75 7
8 85 8
NB=9 95 9
 10
11
12
13 70
14 75
15 85
 NC=16 95

Pseudocódigo
Como ven, la idea es bastante simple, pero programarla no tanto. Para
no dar de golpe la solución, veamos primero un pseudocódigo del
algoritmo:
function mergesort(array A[x..y])
begin
if (x-y > 1)):
array A1 := mergesort(A[x..(int( x+y / 2))])
array A2 := mergesort(A[int(1+(x+y / 2))..y])
return merge(A1, A2) /*** llamada recursiva
else:
return A
end

function merge(array A1[0..n1], array A2[0..n2])

begin
integer p1 := 0
integer p2 := 0
array R[0..(n1 + n2 + 2)]//suponiendo que n1 y n2 son las posiciones
//del array y no el length de este mismo, de otro modo seria (n1 + n2)
while (p1 <= n1 or p2 <= n2):
if (p1 <= n1 and A1[p1] <= A2[p2]):
R[p1 + p2] := A1[p1]
p1 := p1 + 1

else
if (p2 <= n2 and A1[p1] > A2[p2]):
R[p1 + p2] := A2[p2]
p2 := p2 + 1
return R
end
TAREA A REALIZAR DEL ALGORITMO MERGE-SORT…. C/U DEBE CREAR UN PROGRAMA:

PASO 1 EJECUTAR EL PGM.. Y … ORDENAR-SORT-MEZCLAR ---> MSG…

PASO 2 ORDENAR LOS NUMEROS DE EMPLEADOS…- MSG ERROR
PASO 3 GENERAR #700 EMPLEADOS DE PUERTA 1 ( PARES RANDOM )
PASO 4 GENERAR #600 EMPLEADOS DE PUERTA 2 (IMPARES RANDOM)
** RANGO 1 -- 499,999
PASO 5 ORDENAR LOS EMPLEADOS DE AMBAS PUERTAS…
PASO 6 EJECUTAR EL ORDENAMIENTO - SORT - MEZCLA
PASO 7 REVISAR Q EFECTIVAMENTE SE HAYAN PASADO TODOS DATOS 1300
PASO 8 REPETIR LOS PASOS DEL 2 AL 6….

FECHA LIMITE : MIERCOLES 10:00 PM