Escuela Profesional de ingeniería de Sistemas

Trabajo: MergeSort vs InsertionSort

Nombre y Apellido: Joel Erick Gutiérrez Puma Grupo: “E”
Docente: Rolando Jesús Cárdenas Talavera
 MERGESORT VS INSERTIONSORT

1.IMPLEMENTACIÓN DE MERGESORT.
public class MergeSort {
public void sort(int arr[], int left, int right){
if(left < right){
//Encuentra el punto medio del vector.
int middle = (left + right) / 2;

//Divide la primera y segunda mitad (llamada recursiva).

sort(arr, left, middle);
sort(arr, middle+1, right);

//Une las mitades.

merge(arr, left, middle, right);
}
}
public void merge(int arr[], int left, int middle, int right) {
//Encuentra el tamaño de los sub-vectores para unirlos.
int n1 = middle - left + 1;
int n2 = right - middle;

//Vectores temporales.
int leftArray[] = new int [n1];
int rightArray[] = new int [n2];

//Copia los datos a los arrays temporales.

for (int i=0; i < n1; i++) {
leftArray[i] = arr[left+i];
}
for (int j=0; j < n2; j++) {
rightArray[j] = arr[middle + j + 1];
}
/* Une los vectorestemporales. */

//Índices inicial del primer y segundo sub-vector.

int i = 0, j = 0;

//Índice inicial del sub-vector arr[].

int k = left;

//Ordenamiento.
while (i < n1 && j < n2) {
if (leftArray[i] <= rightArray[j]) {
arr[k] = leftArray[i];
i++;
} else {
arr[k] = rightArray[j];
j++;
}
k++;
}//Fin del while.

/* Si quedan elementos por ordenar */

//Copiar los elementos restantes de leftArray[].
while (i < n1) {
 arr[k] = leftArray[i];
i++;
k++;
}
//Copiar los elementos restantes de rightArray[].
while (j < n2) {
arr[k] = rightArray[j];
j++;
k++;
}
}
public void printArray(int arr[]) {
int n = arr.length;
for (int i=0; i<n; ++i) {
System.out.println(arr[i] + " ");
}
System.out.println();
}
}

public class TestMergeSort{

public static void main(String[] args) {
long inicio = System.nanoTime(); //medición del tiempo
int arr[] = new int[30];
MergeSort mergeSort = new MergeSort();
for(int i = 0; i < arr.length; i++) {
arr[i] = (int)(Math.random()*(30)+1);
}
int n = arr.length;

System.out.println("Array original:");
for (int value : arr) {
System.out.print(value + " ");
}

System.out.println();

System.out.println("Array ordenado:");
mergeSort.sort(arr,0,n-1);
mergeSort.printArray(arr);

long fin = System.nanoTime();

double result = (double) (fin - inicio) * 1.0e-9;
System.out.print("El programa duró : " + result + " s.");
}
}
MODO CONSOLA(MergeSort):
Pdta.: prueba con 15 datos.

2.IMPLEMENTACIÓN DE INSERTIONSORT.
public class InsertionSort {
public void sort(int arr[]) {
int n = arr.length;
for (int i = 1; i < n; ++i) {
int key = arr[i];
int j = i - 1;

/* Mover elementos de arr [0..i-1],

que son mayores que "key", a una posición
por delante de su posición actual*/
while (j >= 0 && arr[j] > key) {
arr[j + 1] = arr[j];
j = j - 1;
}
arr[j + 1] = key;
}
}
/* Imprime el array Ordenado*/
public static void printArray(int arr[])
{
int n = arr.length;
for (int i = 0; i < n; ++i)
System.out.print(arr[i] + " ");

System.out.println();
}
}
public class TestInsertionSort {
public static void main(String args[]) {
long inicio = System.nanoTime();
int arr[] = new int[20];

InsertionSort ob = new InsertionSort();

for(int i = 0; i < arr.length; i++) {
arr[i] = (int)(Math.random()*(30)+1);
}
int n = arr.length;

System.out.println("Array original:");
for (int value : arr) {
System.out.print(value + " ");
}
System.out.println();
System.out.println("Array ordenado:");
ob.sort(arr);
InsertionSort.printArray(arr);
long fin = System.nanoTime();
double result = (double) (fin - inicio) * 1.0e-9;
System.out.print("El programa duró : " + result + " s.");
}
}

MODO CONSOLA(InsertionSort):
Pdta.: prueba con 20 datos.

3.COMPARACIONES: MERGESORT VS INSERTIONSORT.

Se realizó pruebas con 5, 10, 15, 20, 25 y 30 números, y se tomó el

tiempo de cada uno de ellos, tanto en MergeSort, como en InsertionSort.
Luego, se pasó los resultados de los tiempos a una hoja de cálculo. Donde
se realizó una gráfica comparando dichos datos.
Estos fueron los resultados:
4.Conclusión.
Como se sabe los tiempos en cada dato son promedios de diferentes
tiempos obtenidos.
Así, el gráfico nos muestra una diferencia mínima, en cuanto al tiempo
(segundos). Sin embargo, con datos muchos más grandes, se obtuvo que
el InsertionSort es menos eficiente que el MergeSort, ya que su tiempo
es mayor a medida que los datos aumentan. En cambio, el mergeSort es
menor.
Aquí un ejemplo de ello: