ORDENAMIENTO POR MEZCLA

Este algoritmo consiste basicamente en dividir en partes iguales la lista de numeros y luego mezclarlos comparandolos, dejandolos ordenados. Si se piensa en este algoritmo recursivamente, podemos imaginar que dividira la lista hasta tener un elemento en cada lista, luego lo compara con el que esta a su lado y segun corresponda, lo situa donde corresponde. En la siguiente figura podemos ver como funciona: El algoritmo de ordenamiento por mezcla (Mergesort) se divide en dos procesos, primero se divide en partes iguales la lista:
publ i c stat i c void mergesort( i n t [ ] matr ix , int in i t , { int n1; int n2; i f (n > 1) { n1 = n / 2; n2 = n - n1; mergesort(matr i x , in i t , n1); mergesort(matr i x , in i t + n1, n2); merge(matr ix , in i t , n1, n2); } } int n)

Y el algoritmo que nos permite mezclar los elementos segun corresponda:

pr ivate stat i c void merge(int [ ] matr ix , int in i t , int n1, int n2) { int [ ] buffer = new int [n1+n2]; int temp = 0; int temp1 = 0; int temp2 = 0; int i ; whi le (( temp1 < n1) && (temp2 < n2)) { i f (matr ix [ i n i t + temp1] < matr ix[ i n i t + n1 + temp2]) buffer [ temp++] = matr ix[ i n i t + (temp1++)]; else buffer [ temp++] = matr ix[ i n i t + n1 + (temp2++)]; } whi le (temp1 < n1) buffer [ temp++] = matr ix[ i n i t + (temp1++)]; whi le (temp2 < n2) buffer [ temp++] = matr ix[ i n i t + n1 + (temp2++)]; for ( i = 0; i < n1+n2; i++) matr ix[ i n i t + i ] = buffer [ i ] ; }

Merge sortEl algoritmo de ordenamiento por mezcla (merge sort en ingls) es un algoritmo de ordenamiento externo estable basado en la tcnica divide y vencers. Es de complejidad O(n log n).

Fue desarrollado en 1945 por John Von Neumann. Conceptualmente, el ordenamiento por mezcla funciona de la siguiente manera: 1. Si la longitud de la lista es 0 1, entonces ya est ordenada. En otro caso: 2. Dividir la lista desordenada en dos sublistas de aproximadamente la mitad del tamao. 3. Ordenar cada sublista recursivamente aplicando el ordenamiento por mezcla. 4. Mezclar las dos sublistas en una sola lista ordenada. El ordenamiento por mezcla incorpora dos ideas principales para mejorar su tiempo de ejecucin: 1. Una lista pequea necesitar menos pasos para ordenarse que una lista grande. 2. Se necesitan menos pasos para construir una lista ordenada a partir de dos listas tambin ordenadas, que a partir de dos listas desordenadas. Por ejemplo, slo ser necesario entrelazar cada lista una vez que estn ordenadas. A continuacin se describe el algoritmo en pseudocdigo (se advierte de que no se incluyen casos especiales para vectores vacos, etc.; una implementacin en un lenguaje de programacin real debera tener en cuenta estos detalles):
public class MergeSort{ private int A[]; public int[] OrdenaMerge(int[] L) { int n = L.length; if (n > int int int 1){ m = (int) (Math.ceil(n/2.0)); [] L1 = new int[m]; [] L2 = new int[n-m];

} return L;

for (int i = 0; i < m; i++){ L1[i] = L[i]; } for (int i = m; i < n; i++){ L2[i-m] = L[i]; } L = merge(OrdenaMerge(L1), OrdenaMerge(L2));

public int[] eliminar(int [] l){ int [] L = new int[l.length-1]; for(int i = 1; i < l.length; i++){

L[i-1] = l[i]; } return L; } public int[] merge(int[] L1, int[] L2) { int[] L = new int[L1.length+L2.length]; int i = 0; while ((L1.length != 0) && (L2.length != 0)) { if (L1[0] < L2[0]){ L[i++] = L1[0]; L1 = eliminar(L1); if (L1.length == 0){ while (L2.length != 0) { L[i++] = L2[0]; L2 = eliminar(L2); } } } else{ L[i++] = L2[0]; L2 = eliminar(L2); if (L2.length == 0) { while (L1.length != 0) { L[i++] = L1[0]; L1 = eliminar(L1); } } } } return L; } public void generarNumeros(){ Random ran = new Random(); int x; for(int i = 0; i < A.length; i++){ x = (int)(ran.nextDouble()*10000); A[i] = x; } } public void imprimir(){ for(int i = 0; i < A.length; i++){ System.out.println(A[i]); } } public int[] getA(){ return A; } public void setA(int []A){ this.A = A; } }