AppEjercicio3.java

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

public class AppEjercicio3
{
    private int[] arregloDatos;
    private int elementos;

    public int busquedaBinaria( int clave )
    {
        int bajo = 0; // parte inferior del área de búsqueda.
        int alto = arregloDatos.length - 1; // parte superior del área de búsqueda.
        int mitad = ( bajo + alto ) / 2; // elemento de la mitad
        int ubicacion = -1; // return valor; -1 si no fue encontrado

        do // empieza la búsqueda del elemento
        {
            // si el elemento es encontrado en la mitad del arreglo
            if( clave == arregloDatos[ mitad ] )
            {
                ubicacion = mitad; //
            }

            // elemento de la mitad es superior
            else if( clave < arregloDatos[ mitad ] )
            {
                alto = mitad - 1; // elimina la mitad mayor
            }
            else
            {
                bajo = mitad + 1; // elimina la mitad inferior
            }

            mitad = ( bajo + alto + 1 ) / 2; // recalcula la mitad del arreglo
        } while( ( bajo <= alto ) && ( ubicacion == -1 ) );

        return( ubicacion );
    } // fin del método búsqueda binaria

    /**
     * Lee los datos para el arreglo desde el teclado introducidos por el usuario de la aplicación.
     */
    public void insertarDatos()
    {
        InputStreamReader isr = new InputStreamReader( System.in );
        BufferedReader br = new BufferedReader( isr );

        for (int i = 1; i <= elementos; ++i )
        {
            System.out.print( "Dígite un número: " );

            try
            {
                arregloDatos[ i - 1 ] = Integer.parseInt( br.readLine() );
            }
            catch (NumberFormatException e) // formato de número inválido
            {
                e.printStackTrace();
            }
            catch (IOException e)
            {
                e.printStackTrace();
            }
        } // fin de for
    } // fin del método insertarDatos

    /**
     * Permite ingresar el número de elementos a ingresar.
     */
    public void numeroElementosAInserter()
    {
        InputStreamReader isr = new InputStreamReader( System.in );

        BufferedReader br = new BufferedReader( isr );

        try
        {
            System.out.print( "Digite el número de elementos a insertar: " );
            elementos = Integer.parseInt( br.readLine() );
        }
        catch( NumberFormatException nfe )
        {
            nfe.printStackTrace();
        }
        catch( IOException ioe )
        {
            ioe.printStackTrace();
        }

        // crea el arreglo de datos
        arregloDatos = new int[ elementos ];
    } // fin del método numeroElementosAInsertar

    /**
     * Ordena el arreglo de datos de menor a mayor.
     */
    public void ordenarAscendente()
    {
        int menor; // indice del elemento menor

        for (int i = 0; i < arregloDatos.length; i++)
        {
            menor = i;

            // ciclo para la búsqueda del índice menor
            for (int index = i + 1; index < arregloDatos.length; index++ )
            {
                if( arregloDatos[ index ] < arregloDatos[ menor ] )
                {
                    menor = index;
                }
            }

            intercambiar( i, menor ); //
        } // fin de for
    } // fin del método ordenarAscendente

    /**
     * Intercambia dos elementos del arreglo arregloDatos.
     * @param primeraPosicion Representa la primera posición a ser alternada.
     * @param segundaPosicion Representa la segunda posición a ser alternada.
     */
    private void intercambiar(int primeraPosicion, int segundaPosicion )
    {
        int temp = arregloDatos[ primeraPosicion ]; // almacena el primero en una variable temporal
        arregloDatos[ primeraPosicion ] = arregloDatos[ segundaPosicion ];
        arregloDatos[ segundaPosicion ] = temp; // asigna temp a la segunda posición
    } // fin del método intercambiar.

    /**
     * Imprime arreglo.
     */
    public void imprimirArreglo()
    {
        for (int i = 0; i < arregloDatos.length; i++ )
        {
            if( i < ( arregloDatos.length - 1 ) )
            {
                System.out.print( arregloDatos[ i ] + ", " );
            }
            else
            {
                System.out.print( arregloDatos[ i ] );
            }
        }
    } // fin del método imprimirArreglo.

    /**
     * Punto de inicio de la aplicación.
     * @param args Conjunto de argumentos procedentes desde la consola o terminal.
     */
    public static void main( String[] args )
    {
        // Instancia un objeto de tipo AppEjercicio3.
        AppEjercicio3 app3 = new AppEjercicio3();

        // especifica la cantidad de elementos que se intertaran en el arreglo de datos.
        app3.numeroElementosAInserter();

        // inserta datos en el arreglo.
        app3.insertarDatos();

        // imprime por primera vez el arreglo de datos:
        System.out.println();
        System.out.println();
        app3.imprimirArreglo();

        // realiza ordenamiento de los datos en modo ascendente.
        app3.ordenarAscendente();

        // vuelve a imprimir el contenido del arreglo.
        System.out.println();
        System.out.println();
        app3.imprimirArreglo();

        // búsqueda binaria en el contenido del arreglo de datos.
        if( app3.busquedaBinaria( 3 ) != -1 )
        {
            System.out.println( "\n\nEl dato 3 se se encontró en la posición: " + ( app3.busquedaBinaria( 3 ) + 1 ) );
        }
        else
        {
            System.out.println( "\n\nEl dato 3 no se encontró." );
        }
    } // fin de main
} // fin de la clase AppEjercicio3