Intercalacion Directa Ernesto Rosales

/* Metodo de Intercalacion Directa.
 *
 * Fuente:   .....------          Conocimientos adquiridos e investigacion en distintas fuentes          ------.....

                                      *********************************************
                                      *  InGeNiErIa En SiStEmAs CoMpUtAcIoNaLeS   *
                                      *  InStItUtO tEcNoLoGiCo SuPeRiOr De JeReZ  *
                                      *  EsTrUcTuRa De DaToS                      *
                                      *  ErNeStO rOsAlEs CaRlOs                   *
                                      *  ernestorosales@live.com                  *
                                      *********************************************
*/

import java.io.*;
import java.awt.*;


public class IntercalacionDirectaErnestoRosales
{
       
private static void Inter(int[] Arreglo1, int[] Arreglo2, int[] Arreglo3) // Metodo Inter con tres arreglos.
{
int Indice1=0; // Declaracion de posiciones de arreglo.
int Indice2=0;
int Indice3=0;

while(Indice1<Arreglo1.length && Indice2<Arreglo2.length) // Mientras la variable Indice1 y 2 sean de menor longitud
{                                                         // que el tamano del arreglo 1 y 2.
if(Arreglo1[Indice1]<Arreglo2[Indice2])  // Si el arreglo en posicion 0 es menor que el arreglo 2 en posicion 0
{
Arreglo3[Indice3]=Arreglo1[Indice1] ;  // Almacena el dato del arreglo1 en el arreglo3.
Indice1++;
}

else
{
Arreglo3[Indice3]=Arreglo2[Indice2];      // Si no almacena el dato de arreglo2 en arreglo3.
Indice2++;
}
Indice3++;
}
if(Indice1<Arreglo1.length)  // Si valor de Indice1 es menor al tamano del arreglo1.
System.arraycopy(Arreglo1,Indice1,Arreglo3,Indice3,Arreglo1.length-Indice1);
/*
*Copiar dos arrays en uno con Java (arraycopy).
*
  Los parámetros que recibe el método Java .arrayCopy son:

* Array origen
* Posición inicial del array origen
* Array destino
* Posición incial en el array de destino
* Numero de elementos a copiar del array origen al array destino
*/
else
System.arraycopy(Arreglo2,Indice2,Arreglo3,Indice3,Arreglo2.length-Indice2);
}

public static void erc(int arre[]) // Metodo erc, con el argumento arre[](un arreglo).
{
if(arre.length<=1) // Si el tamano del arreglo es igual o mayor a 1.
return;

int tamano1=arre.length/2; // Divide el arreglo en dos partes.
int tamano2=arre.length-tamano1;

int PrimeraMitad[]=new int[tamano1]; // Declara dos arreglos con el tamano antes dividido.
int SegundaMitad[]=new int[tamano2];

System.arraycopy(arre,0,PrimeraMitad,0,tamano1); // Inserto primera mitad de datos en arreglo PrimeraMitad
System.arraycopy(arre,tamano1,SegundaMitad,0,tamano2); // Inserto segunda mitad de datos en arreglo SegundaMitad.

erc(PrimeraMitad);
erc(SegundaMitad);

IntercalacionDirectaErnestoRosales.Inter(PrimeraMitad,SegundaMitad,arre); // Relacion de metodo IDER e Inter. con
}  // atributos PM,SM y arre.

public static void main(String args[])throws IOException
{

BufferedReader erc=new BufferedReader(new InputStreamReader(System.in));

System.out.println("Tamano de vector"); // Pido tamano de vector desde teclado.
int t=Integer.parseInt(erc.readLine());

int[] v=new int[t];

System.out.println("\nIngresa datos\n"); // Solicito que usuario ingrese datos.
for(int i=0;i<t;i++)
{
try{

System.out.println("Dato "+(i+1)+ ":");
v[i]=Integer.parseInt(erc.readLine());
}

catch(Exception e) // Exepcion en caso de que no ingrese numero.
{
System.out.println("Numero");
}
}

IntercalacionDirectaErnestoRosales.erc(v);

System.out.println("Vector ordenado: "); // Imprimo datos ordenados.

for(int i=0;i<t;i++)
{
System.out.println(" " + v[i]);
}
}



}