Introducción a los algoritmos de clasificación de fusión en Java
Los algoritmos de clasificación de fusión son muy importantes en informática. El resultado de la clasificación es organizar los elementos de una lista en cierto orden (ya sea ascendente o descendente). La clasificación por fusión es uno de los algoritmos de clasificación más eficientes disponibles, ya que se basa en el concepto de división y conquista. Como su nombre indica, primero divida el problema más grande en problemas pequeños que resuelva los problemas más pequeños para resolver el problema más grande. En este artículo, analizaremos los algoritmos de clasificación de fusión en Java. Conceptualmente, Merge sort es una combinación de dos algoritmos básicos llamados MERGE y MERGE_SORT que funciona de la siguiente manera:
- Divida la lista sin ordenar en n cantidad de sublistas de un solo elemento (n es la cantidad total de elementos en la lista sin clasificar).
- Combine repetidamente sublistas en sublistas ordenadas hasta que solo haya una lista ordenada.
Implementación de algoritmos de clasificación de fusión en Java
El algoritmo MERGE es el procedimiento de combinar dos listas ordenadas en una lista ordenada.
Ejemplo: supongamos que hay dos listas, es decir, la Lista 1 (6, 3) y la Lista 2 (3, 1, 9).
1. Primero ordene ambas listas.
Lista 1
Lista 2
Ahora aplicaremos una técnica de fusión.
- Luego, crearemos una nueva lista de tamaño m + n donde m es el número de elementos en la Lista 1 yn es el número de elementos en la Lista 2.
Lista 3
En nuestro caso m = 2 yn = 3, entonces m + n = 5.
- Ahora, tenemos dos punteros. Un primer puntero apuntando a la primera posición de la Lista 1 y un Segundo puntero apuntando a la primera posición de la Lista 2.
4. Luego compararemos el valor de ambos punteros. El puntero con menor valor, copie ese elemento en la Lista 3 y mueva el puntero a la derecha de la lista con un valor menor y la lista resultante (es decir, Lista 1 y Lista 3).
5. Del mismo modo, realice el paso 4 una y otra vez.
Más recorrido …
NOTA: Si una de las listas (es decir, la lista 1 o la lista 2) se atraviesa por completo como en el caso anterior, copie todo el contenido de otras listas desde el puntero a la lista de resultados (es decir, la lista 3) de la siguiente manera.
Algoritmo y Pseudocódigo
Los dos algoritmos utilizados en Algoritmo de fusión son:
- El MERGE (ARR, F, M, L) es un proceso que supone lo siguiente:
- ARR (F… .M) y ARR (M + 1… .L) son listas ordenadas.
- Fusiona las dos sublistas ordenadas en una ARR (F… .L).
- SORT (ARR (), F, L) // aquí F es el primero y L es el último índice de la matriz.
Si (L> 1)
- Encuentre el punto medio para dividir la lista en dos mitades:
medio M = (F + L) / 2
- Llame a Merge Sort para la primera mitad:
Llamar a SORT (ARR, 1, M)
- Llame a Merge Sort para la segunda mitad:
Llamada SORT (ARR, M + 1, L)
- Combina las mitades ordenadas en los pasos 2 y 3:
Llamar a MERGE (ARR, L, M, R)
Ejemplo
Tomemos un ejemplo de una matriz ARR (10, 6, 8, 5, 7, 3, 4). Usaremos el Algoritmo de fusión para ordenar la matriz usando su técnica de división y conquista. Podemos ver la figura a continuación de que la matriz se divide recursivamente en dos mitades hasta que el tamaño se convierte en 1. Una vez que el tamaño se convierte en 1, llamamos a los procesos de fusión y comenzamos a fusionar las listas hasta que la lista completa se fusione.
NOTA: en la figura siguiente, los números en rojo indican el orden en que se procesan los pasos para formar la matriz ordenada.
Código de programa:
import java.util.Scanner;
public class mergeSort (
// merges two sublists of arr().
// first list is arr(l..m) // second list is arr(m+1..r) void mergeAlgo(int arr(), int l, int m, int r)
(
// find the sizes of two lists to be merged
int n1 = m - l + 1;
int n2 = r - m;
// create temp array
int L() = new int (n1);
int R() = new int (n2);
// copy data to temp arrays
for (int i=0; i L(i) = arr(l + i);
for (int j=0; j R(j) = arr(m + 1+ j);
/* merge the temp arrays */
// initial indexes of first and second list
int i = 0, j = 0;
// initial index of merged sub list
int k = l;
while (i < n1 && j < n2)
(
if (L(i) <= R(j))
(
arr(k) = L(i);
i++;
)
else
(
arr(k) = R(j);
j++;
)
k++;
)
// copy remaining elements of L() if any
while (i < n1)
(
arr(k) = L(i);
i++;
k++;
)
// copy remaining elements of R() if any
while (j < n2)
(
arr(k) = R(j);
j++;
k++;
)
)
// main function that sorts arr(l..r) using mergeAlgo()
void sort(int arr(), int l, int r)
(
if (l < r)
(
// find the middle index
int m = (l+r)/2;
// sort first and second halves
sort(arr, l, m);
sort(arr, m+1, r);
// merge the above two sorted halves
mergeAlgo(arr, l, m, r);
)
)
/* A function to print list of size n */
static void printArray(int arr())
(
int n = arr.length;
for (int i=0; i System.out.print(arr(i) + " ");
System.out.println();
)
public static void main(String args())
(
Scanner myObj = new Scanner(System.in);
System.out.println("Enter the size of list:");
int N = myObj.nextInt();
System.out.println("Enter the elements in list separated by space:");
int arr() = new int(N);
for(int i=0; i arr(i) = myObj.nextInt();
)
mergeSort mg = new mergeSort();
mg.sort(arr, 0, arr.length-1);
System.out.println("\nSorted list:");
printArray(arr);
)
)import java.util.Scanner;
public class mergeSort (
// merges two sublists of arr().
// first list is arr(l..m) // second list is arr(m+1..r) void mergeAlgo(int arr(), int l, int m, int r)
(
// find the sizes of two lists to be merged
int n1 = m - l + 1;
int n2 = r - m;
// create temp array
int L() = new int (n1);
int R() = new int (n2);
// copy data to temp arrays
for (int i=0; i L(i) = arr(l + i);
for (int j=0; j R(j) = arr(m + 1+ j);
/* merge the temp arrays */
// initial indexes of first and second list
int i = 0, j = 0;
// initial index of merged sub list
int k = l;
while (i < n1 && j < n2)
(
if (L(i) <= R(j))
(
arr(k) = L(i);
i++;
)
else
(
arr(k) = R(j);
j++;
)
k++;
)
// copy remaining elements of L() if any
while (i < n1)
(
arr(k) = L(i);
i++;
k++;
)
// copy remaining elements of R() if any
while (j < n2)
(
arr(k) = R(j);
j++;
k++;
)
)
// main function that sorts arr(l..r) using mergeAlgo()
void sort(int arr(), int l, int r)
(
if (l < r)
(
// find the middle index
int m = (l+r)/2;
// sort first and second halves
sort(arr, l, m);
sort(arr, m+1, r);
// merge the above two sorted halves
mergeAlgo(arr, l, m, r);
)
)
/* A function to print list of size n */
static void printArray(int arr())
(
int n = arr.length;
for (int i=0; i System.out.print(arr(i) + " ");
System.out.println();
)
public static void main(String args())
(
Scanner myObj = new Scanner(System.in);
System.out.println("Enter the size of list:");
int N = myObj.nextInt();
System.out.println("Enter the elements in list separated by space:");
int arr() = new int(N);
for(int i=0; i arr(i) = myObj.nextInt();
)
mergeSort mg = new mergeSort();
mg.sort(arr, 0, arr.length-1);
System.out.println("\nSorted list:");
printArray(arr);
)
)import java.util.Scanner;
public class mergeSort (
// merges two sublists of arr().
// first list is arr(l..m) // second list is arr(m+1..r) void mergeAlgo(int arr(), int l, int m, int r)
(
// find the sizes of two lists to be merged
int n1 = m - l + 1;
int n2 = r - m;
// create temp array
int L() = new int (n1);
int R() = new int (n2);
// copy data to temp arrays
for (int i=0; i L(i) = arr(l + i);
for (int j=0; j R(j) = arr(m + 1+ j);
/* merge the temp arrays */
// initial indexes of first and second list
int i = 0, j = 0;
// initial index of merged sub list
int k = l;
while (i < n1 && j < n2)
(
if (L(i) <= R(j))
(
arr(k) = L(i);
i++;
)
else
(
arr(k) = R(j);
j++;
)
k++;
)
// copy remaining elements of L() if any
while (i < n1)
(
arr(k) = L(i);
i++;
k++;
)
// copy remaining elements of R() if any
while (j < n2)
(
arr(k) = R(j);
j++;
k++;
)
)
// main function that sorts arr(l..r) using mergeAlgo()
void sort(int arr(), int l, int r)
(
if (l < r)
(
// find the middle index
int m = (l+r)/2;
// sort first and second halves
sort(arr, l, m);
sort(arr, m+1, r);
// merge the above two sorted halves
mergeAlgo(arr, l, m, r);
)
)
/* A function to print list of size n */
static void printArray(int arr())
(
int n = arr.length;
for (int i=0; i System.out.print(arr(i) + " ");
System.out.println();
)
public static void main(String args())
(
Scanner myObj = new Scanner(System.in);
System.out.println("Enter the size of list:");
int N = myObj.nextInt();
System.out.println("Enter the elements in list separated by space:");
int arr() = new int(N);
for(int i=0; i arr(i) = myObj.nextInt();
)
mergeSort mg = new mergeSort();
mg.sort(arr, 0, arr.length-1);
System.out.println("\nSorted list:");
printArray(arr);
)
)import java.util.Scanner;
public class mergeSort (
// merges two sublists of arr().
// first list is arr(l..m) // second list is arr(m+1..r) void mergeAlgo(int arr(), int l, int m, int r)
(
// find the sizes of two lists to be merged
int n1 = m - l + 1;
int n2 = r - m;
// create temp array
int L() = new int (n1);
int R() = new int (n2);
// copy data to temp arrays
for (int i=0; i L(i) = arr(l + i);
for (int j=0; j R(j) = arr(m + 1+ j);
/* merge the temp arrays */
// initial indexes of first and second list
int i = 0, j = 0;
// initial index of merged sub list
int k = l;
while (i < n1 && j < n2)
(
if (L(i) <= R(j))
(
arr(k) = L(i);
i++;
)
else
(
arr(k) = R(j);
j++;
)
k++;
)
// copy remaining elements of L() if any
while (i < n1)
(
arr(k) = L(i);
i++;
k++;
)
// copy remaining elements of R() if any
while (j < n2)
(
arr(k) = R(j);
j++;
k++;
)
)
// main function that sorts arr(l..r) using mergeAlgo()
void sort(int arr(), int l, int r)
(
if (l < r)
(
// find the middle index
int m = (l+r)/2;
// sort first and second halves
sort(arr, l, m);
sort(arr, m+1, r);
// merge the above two sorted halves
mergeAlgo(arr, l, m, r);
)
)
/* A function to print list of size n */
static void printArray(int arr())
(
int n = arr.length;
for (int i=0; i System.out.print(arr(i) + " ");
System.out.println();
)
public static void main(String args())
(
Scanner myObj = new Scanner(System.in);
System.out.println("Enter the size of list:");
int N = myObj.nextInt();
System.out.println("Enter the elements in list separated by space:");
int arr() = new int(N);
for(int i=0; i arr(i) = myObj.nextInt();
)
mergeSort mg = new mergeSort();
mg.sort(arr, 0, arr.length-1);
System.out.println("\nSorted list:");
printArray(arr);
)
)import java.util.Scanner;
public class mergeSort (
// merges two sublists of arr().
// first list is arr(l..m) // second list is arr(m+1..r) void mergeAlgo(int arr(), int l, int m, int r)
(
// find the sizes of two lists to be merged
int n1 = m - l + 1;
int n2 = r - m;
// create temp array
int L() = new int (n1);
int R() = new int (n2);
// copy data to temp arrays
for (int i=0; i L(i) = arr(l + i);
for (int j=0; j R(j) = arr(m + 1+ j);
/* merge the temp arrays */
// initial indexes of first and second list
int i = 0, j = 0;
// initial index of merged sub list
int k = l;
while (i < n1 && j < n2)
(
if (L(i) <= R(j))
(
arr(k) = L(i);
i++;
)
else
(
arr(k) = R(j);
j++;
)
k++;
)
// copy remaining elements of L() if any
while (i < n1)
(
arr(k) = L(i);
i++;
k++;
)
// copy remaining elements of R() if any
while (j < n2)
(
arr(k) = R(j);
j++;
k++;
)
)
// main function that sorts arr(l..r) using mergeAlgo()
void sort(int arr(), int l, int r)
(
if (l < r)
(
// find the middle index
int m = (l+r)/2;
// sort first and second halves
sort(arr, l, m);
sort(arr, m+1, r);
// merge the above two sorted halves
mergeAlgo(arr, l, m, r);
)
)
/* A function to print list of size n */
static void printArray(int arr())
(
int n = arr.length;
for (int i=0; i System.out.print(arr(i) + " ");
System.out.println();
)
public static void main(String args())
(
Scanner myObj = new Scanner(System.in);
System.out.println("Enter the size of list:");
int N = myObj.nextInt();
System.out.println("Enter the elements in list separated by space:");
int arr() = new int(N);
for(int i=0; i arr(i) = myObj.nextInt();
)
mergeSort mg = new mergeSort();
mg.sort(arr, 0, arr.length-1);
System.out.println("\nSorted list:");
printArray(arr);
)
)
Salida:
Conclusión - Combinar algoritmos de clasificación en Java
Combinar las complejidades de tiempo mejores, peores y de caso promedio son las mismas, lo que lo convierte en un algoritmo más eficiente. Funciona más rápido que otras técnicas de clasificación. La ordenación por fusión se puede aplicar a archivos de cualquier tamaño. Es altamente paralelizable debido al uso del método de divide y vencerás. Con el fin de desarrollar conceptos básicos sólidos en ciencias de la computación, se recomienda comprender a fondo diferentes algoritmos de clasificación.
Artículos recomendados
Esta es una guía para combinar algoritmos de clasificación en Java. Aquí discutimos la Implementación de Algoritmos de Clasificación de Fusión en Java y Algorithm & Pseudocode con ejemplo. También puede consultar nuestros otros artículos sugeridos:
- Selección Ordenar en Java
- Declaración de caso en Java
- Modificadores de acceso en Java
- Combinar Ordenar en JavaScript
- ¿Qué es la declaración de caso en JavaScript?
- Modificadores de acceso en PHP
- Algoritmos de clasificación rápida en Java
- Guía completa para ordenar en C # con ejemplos
- Función de clasificación en Python con ejemplos
- Los 6 mejores algoritmos de clasificación en JavaScript