import java.util.Scanner;
import java.io.*;

/**
 * Arreglo Unidimensional.
 *
 * Programa encargado de manejar un arreglo unidimensional para Numeros,
 * Cadenas y un tipo de dato abstracto, en este caso usaremos instancias de
 * la clase <b>Persona</b>.
 *
 * Las operaciones que podra realizar el programa son:
 *
 * - Agregar
 * - Modificar
 * - Eliminar
 * - Mostrar todos los elementos
 * - Mostrar un elemento
 * - Ordenar (Bubblesort)
 * - Busqueda sin ordenar (Lineal)
 * - Busqueda con ordenacion (Binaria)
 * - Guardar info. en un archivo
 * - Leer archivo
 * - Salir
 *
 * @see Persona
 * @version 2.1
 *
*/
public class ArregloUnidimensionalOrdenado {

   /**
   * Muestra el menu principal.
   */
   public void menuPrincipal() {
      System.out.println("");
      System.out.println("Con que quieres trabajar? Elige una opcion:\n");
      System.out.println("1) Arreglo de Numeros");
      System.out.println("2) Arreglo de Cadenas");
      System.out.println("3) Arreglo de Personas");
      System.out.println("0) Salir");
      System.out.println("");
   }

   /**
   * Muestra el menu de operaciones para cada arreglo.
   */
   public void visualizaMenu() {
      System.out.println("");
      System.out.println("Menu");
      System.out.println("");
      System.out.println("Elige una opcion:");
      System.out.println("1) Agregar");
      System.out.println("2) Modificar");
      System.out.println("3) Borrar");
      System.out.println("4) Visualizar todos");
      System.out.println("5) Ver un elemento");
      System.out.println("6) Guardar");
      System.out.println("7) Cargar");
      System.out.println("8) Ordenar Asc. (Burbuja)");
      System.out.println("9) Ordenar Des. (Burbuja)");
      System.out.println("10) Busqueda Lineal (no ordenado)");
      System.out.println("11) Busqueda Binaria (ordenado asc.)");
      System.out.println("0) Salir");
      System.out.println("");
   }

   /******* ESTE ALGORITMO NO DEBEN HACERLO, ESCOGAN OTRO *********/
   /*
   // ORDENAMIENTO DE NUMEROS:
   public void bubblesort(Integer [] arr) {

   	for(int i = 1; i < arr.length; i++) {
   	for(int j = 0; j < arr.length - i; j++) {
   		// INTERCAMBIO
   		if(arr[j].compareTo(arr[j+1]) > 0) {
   			Integer temp = arr[j+1];
   			arr[j+1] = arr[j];
   			arr[j] = temp;
   		}
   	}
   }
   }

   // ORDENAMIENTO DE CADENAS:
   	public void bubblesort(String [] arr) {

   		for(int i = 1; i < arr.length; i++) {
   		for(int j = 0; j < arr.length - i; j++) {
   			// INTERCAMBIO
   			if(arr[j].compareTo(arr[j+1]) > 0) {
   				String temp = arr[j+1];
   				arr[j+1] = arr[j];
   				arr[j] = temp;
   			}
   		}
   	}
   	}

   // ORDENAMIENTO DE PERSONAS:
   	public void bubblesort(Persona [] arr) {

   		for(int i = 1; i < arr.length; i++) {
   		for(int j = 0; j < arr.length - i; j++) {
   			// INTERCAMBIO
   			if(arr[j].compareTo(arr[j+1]) > 0) {
   				Persona temp = arr[j+1];
   				arr[j+1] = arr[j];
   				arr[j] = temp;
   			}
   		}
   	}
   	}
   	*/

   /**
    * Metodo encargado de ordenar de forma ascendente un arreglo de elementos
    * comparables. Este es un ejemplo mas general a diferencia de los ejemplos
    * de arriba, donde cada metodo era para un tipo de dato en espacial.
    * @param arr Arreglo a ordenar.
    *
    * IMPORTANTE: Para que este metodo funcione es importante que su clase
    * implemente la interfaz Comparable.
   */
   public void bubblesortAsc(Comparable [] arr) {

      for(int i = 1; i < arr.length; i++) {
         for(int j = 0; j < arr.length - i; j++) {
            if(arr[j].compareTo(arr[j + 1]) > 0) {
               // INTERCAMBIO
               Comparable temp = arr[j + 1];
               arr[j + 1] = arr[j];
               arr[j] = temp;
            }
         }
      }
   }

   /**
    * Metodo encargado de ordenar de forma descendente un arreglo de elementos
    * comparables.
    * @param arr Arreglo a ordenar.
    *
    * IMPORTANTE: Para que este metodo funcione es importante que su clase
    * implemente la interfaz Comparable.
   */
   public void bubblesortDes(Comparable [] arr) {

      for(int i = 1; i < arr.length; i++) {
         for(int j = 0; j < arr.length - i; j++) {
            if(arr[j].compareTo(arr[j + 1]) < 0) {
               // INTERCAMBIO
               Comparable temp = arr[j + 1];
               arr[j + 1] = arr[j];
               arr[j] = temp;
            }
         }
      }
   }

   /**
    * Metodo encargado de buscar un elemento dentro de un arreglo.
    * En busqueda lineal no importa si el arreglo esta ordenado o no ya que
    * este algoritmo se encarga de buscar posicion por posicion.
    * @param arr Arreglo de elememtos donde buscaremos.
    * @param elem Elemento que queremos buscar.
    * @return La posicion dentro del arreglo donde se encontro el elemento
    * buscado o -1 si el elemento no se encuentra en el arreglo.
   */
   public int busquedaLineal(Comparable [] arr, Comparable elem) {

      for(int i = 0; i < arr.length; i++) {
         if(arr[i].compareTo(elem) == 0)
            return i;
      }

      return -1;
   }

   /**
    * Metodo encargado de buscar un elemento dentro de un arreglo.
    * Para este algoritmo es NECESARIO que el arreglo este ordenado de forma ascendente.
    * @param arr Arreglo de elememtos donde buscaremos.
    * @param elem Elemento que queremos buscar.
    * @param ini Posicion inicial, donde empezaremos la busqueda.
    * @param fin Posicion final, hasta donde terminaremos la busqueda.
   */
   public int busquedaBinaria(Comparable [] arr, Comparable elem, int ini, int fin) {
      // Caso base
      // Si la posicion inicial llega a ser mayor que la posicion final es porque ya buscamos
      // en todo el arreglo y no se encontro el elemento.
      if(fin < ini) return -1;

      // Buscamos la mitad.
      int mitad = (ini + fin) / 2;

      // Si el elemento buscado es menor que el elemento que se encuentra en la mitad del subarreglo
      if(elem.compareTo(arr[mitad]) < 0) {
         return busquedaBinaria(arr, elem, ini, mitad - 1);
      } else
         // Si el elemento buscado es mayor que el elemento que se encuentra en la mitad del subarreglo
         if(elem.compareTo(arr[mitad]) > 0) {
            return busquedaBinaria(arr, elem, mitad + 1, fin);
         } else
            // Si el elemento buscado se encuentra en la mitad del subarreglo
         {
            return mitad;
         }
   }

   /**
   * Se en carga de guardar la informacion dentro de un archivo de texto
   * para posteriormente recuperar la informacion.
   *
   * @param o Un arreglo de objetos. Esta optimizado para guardar Double,
   * String, Persona.
   */
   public void guardar(Object [] o) {
      FileWriter fichero = null;
      PrintWriter pw = null;

      try {
         // Abrimos o creamos el archivo si no existe.
         fichero = new FileWriter("./ArrUniOr.txt");
         pw = new PrintWriter(fichero);

         for(int i = 0; i < o.length; i++) {
            // Ignoramos las posiciones que sean null.
            if(o[i] != null) {

               // DOUBLE:
               if(o[i] instanceof Double) {
                  // En primer lugar, guardamos la posicion del objeto
                  // dentro del arreglo y luego el valor numerico separados
                  // por una coma.
                  Double d_aux = (Double)o[i];
                  pw.println(i + "," + d_aux + ",d");
               } else
                  // STRING:
                  if(o[i] instanceof String) {
                     // En primer lugar, guardamos la posicion del objeto
                     // dentro del arreglo y luego cadena separados por una coma.
                     String s_aux = (String)o[i];
                     pw.println(i + "," + s_aux + ",s");
                  } else
                     // PERSONA:
                     if(o[i] instanceof Persona) {
                        // Como en este caso se trata de objetos Persona,
                        // debemos separar la informacion de alguna forma.
                        // En primer lugar, guardamos la posicion del objeto
                        // dentro del arreglo, luego su nombre, despues su
                        // apellido y por ultimo su edad. Todo esto separado
                        // por comas.
                        Persona p_aux = (Persona)o[i];
                        pw.println(i + "," + p_aux.getNombre() + "," + p_aux.getApellidos() + "," + p_aux.getEdad());
                     }
            }
         }
      } catch (Exception e) {
         e.printStackTrace();
      } finally {
         try {
            // Nuevamente aprovechamos el finally para
            // asegurarnos que se cierra el fichero.
            if (null != fichero)
               fichero.close();
         } catch (Exception e2) {
            e2.printStackTrace();
         }
      }
   }

   /**
    * Se en carga de leer la informacion dentro de un archivo de texto
    * y la carga en un arreglo.
    * Dependiendo de lo que lea sera el tipo del arreglo.
    *
    * @param o Arreglo de objetos donde se guardara la informacion leida.
    * Esta optimizado para guardar Double, String, Persona.
   */
   public void cargar(Object [] o) {
      File archivo = null;
      FileReader fr = null;
      BufferedReader br = null;

      try {

         // Apertura del fichero y creacion de BufferedReader para poder
         // hacer una lectura comoda (disponer del metodo readLine()).
         archivo = new File ("./ArrUniOr.txt");
         fr = new FileReader (archivo);
         br = new BufferedReader(fr);

         // Leemos la primera linea.
         String linea = br.readLine();
         // Debemos obtener la informacion de cada linea.
         String [] datos = null;
         // Indice de cada persona.
         int i = 0;

         // Mientras no lleguemos al final del archivo, seguimos trabajando.
         while(linea != null) {
            // Separamos la linea por cada coma y guardamos la info. en datos.
            datos = linea.split(",");
            // Convertimos el indice a un entero.
            i = Integer.parseInt(datos[0]);

            // PERSONA:
            if(datos.length == 4) {
               // Y guardamos a la persona en el indice que corresponde.
               // Tomamos el resto de los datos para crear a la persona.
               o[i] = new Persona(datos[1], datos[2], Integer.parseInt(datos[3]));
            } else
               // DOUBLE:
               if(datos[2].equals("d")) {
                  o[i] = Double.parseDouble(datos[1]);
               } else
                  // STRING:
                  if (datos[2].equals("s")) {
                     o[i] = datos[1];
                  }

            // Pasamos a la siguiente linea.
            linea = br.readLine();
         }

      } catch(Exception e) {
         e.printStackTrace();
      } finally {
         // En el finally cerramos el fichero, para asegurarnos
         // que se cierra tanto si todo va bien como si salta
         // una excepcion.
         try {
            if( null != fr ) {
               fr.close();
            }
         } catch (Exception e2) {
            e2.printStackTrace();
         }
      }
   }

   /**
    * Metodo encargado de manejar un arreglo Numerico.
   */
   public void arregloUnidimensionalDouble() {
      // Arreglo unidimensional
      Double [] arr;
      // Tamano arreglo unidimensional
      int tam;

      // objeto para trabajar con teclado
      Scanner teclado = new Scanner(System.in);

      // Pregunta sobre el tamaño del arrglo
      do {
         System.out.println("\nTamaño del arreglo? ");
         tam = Integer.parseInt(teclado.nextLine());
         if(tam <= 0 || tam > 10) {
            System.out.println("\nError en el tamaño, rango de 1 a 10");
         }
      } while(tam <= 0 || tam > 10);

      // Creamos el arreglo.
      arr = new Double[tam];

      // op - opcion que eliga el usuario.
      // pos - posiciones dentro del arrglo.
      // index - posicion donde se encontro un elemento.
      int op = 1, pos = 0, index;
      // Elemento a buscar.
      double elem;
      // Menu
      do {
         visualizaMenu();
         op = Integer.parseInt(teclado.nextLine());

         switch(op) {
         // Salir
         case 0:
            break;

         // Adicionar
         case 1:
            do {
               System.out.println("\nPosicion? ");
               pos = Integer.parseInt(teclado.nextLine());
               if(pos < 0 || pos >= tam) {
                  System.out.println("\nError en la posicion, rango de 0 a " + (tam - 1));
               }
            } while(pos < 0 || pos >= tam);
            System.out.println("\nValor? ");
            arr[pos] = Double.parseDouble(teclado.nextLine());
            break;

         // Modificar
         case 2:
            do {
               System.out.println("\nPosicion? ");
               pos = Integer.parseInt(teclado.nextLine());
               if(pos < 0 || pos >= tam) {
                  System.out.println("\nError en la posicion, rango de 0 a " + (tam - 1));
               }
            } while(pos < 0 || pos >= tam);
            System.out.println("\nValor actual: " + arr[pos]);
            System.out.println("\nNuevo valor: ");
            arr[pos] = Double.parseDouble(teclado.nextLine());
            break;

         // Borrar
         case 3:
            do {
               System.out.println("\nPosicion? ");
               pos = Integer.parseInt(teclado.nextLine());
               if(pos < 0 || pos >= tam) {
                  System.out.println("\nError en la posicion, rango de 0 a " + (tam - 1));
               }
            } while(pos < 0 || pos >= tam);
            arr[pos] = null;
            break;

         // Visualizar
         case 4:
            System.out.println("\nEl arreglo contiene:");
            for(pos = 0; pos < tam; pos++) {
               if(arr[pos] != null) {
                  System.out.println(pos + " --> " + arr[pos]);
               }
            }
            break;

         // Ver un elemento
         case 5:
            do {
               System.out.println("\nPosicion? ");
               pos = Integer.parseInt(teclado.nextLine());
               if(pos < 0 || pos >= tam) {
                  System.out.println("\nError en la posicion, rango de 0 a " + (tam - 1));
               }
            } while(pos < 0 || pos >= tam);
            if(arr[pos] != null) {
               System.out.println("\n" + pos + " --> " + arr[pos]);
            } else {
               System.out.println("\nNo hay nada en esta posicion");
            }
            break;

         // Guardar
         case 6:
            guardar(arr);
            System.out.println("Informacion guardada.");
            break;

         // Leer
         case 7:
            cargar(arr);
            System.out.println("Informacion leida y cargada.");
            break;

         // Ordenar Ascendente
         case 8:
            bubblesortAsc(arr);
            break;

         // Ordenar Descendente
         case 9:
            bubblesortDes(arr);
            break;

         // Busqueda Lineal (arreglo no ordenado)
         case 10:
            System.out.println("\nQue quieres buscar?");
            elem = Double.parseDouble(teclado.nextLine());

            index = busquedaLineal(arr, elem);

            if(index != -1) {
               System.out.println("\nEl elmento " + elem + " se encuentra en la posicion: " + index);
            } else {
               System.out.println("\nEl elemento " + elem + " no se encuentra en el arreglo");
            }

            break;

         // Busqueda Binaria (arreglo ordenado)
         case 11:
            System.out.println("\nQue quieres buscar?");
            elem = Double.parseDouble(teclado.nextLine());

            index = busquedaBinaria(arr, elem, 0, tam - 1);

            if(index != -1) {
               System.out.println("\nEl elmento " + elem + " se encuentra en la posicion: " + index);
            } else {
               System.out.println("\nEl elemento " + elem + " no se encuentra en el arreglo");
            }
            break;

         default:
            System.out.println("Opcion no reconocidad");
         }
      } while(op != 0);
      System.out.println("Fin del arreglo unidimensional");
   }

   /**
    * Metodo encargado de manejar un arreglo de cadenas.
   */
   public void arregloUnidimensionalString() {
      // Arreglo unidimensional
      String [] arr;
      // Tamano arreglo unidimensional
      int tam;

      // objeto para trabajar con teclado
      Scanner teclado = new Scanner(System.in);

      // Pregunta sobre el tamaño del arrglo
      do {
         System.out.println("\nTamaño del arreglo? ");
         tam = Integer.parseInt(teclado.nextLine());
         if(tam <= 0 || tam > 10) {
            System.out.println("\nError en el tamaño, rango de 1 a 10");
         }
      } while(tam <= 0 || tam > 10);

      // Creamos el arreglo.
      arr = new String[tam];

      // op - opcion que eliga el usuario.
      // pos - posiciones dentro del arrglo.
      // index - posicion donde se encontro un elemento.
      int op = 1, pos = 0, index;
      // Elemento a buscar.
      String elem;
      // Menu
      do {
         visualizaMenu();
         op = Integer.parseInt(teclado.nextLine());

         switch(op) {
         // Salir
         case 0:
            break;

         // Adicionar
         case 1:
            do {
               System.out.println("\nPosicion? ");
               pos = Integer.parseInt(teclado.nextLine());
               if(pos < 0 || pos >= tam) {
                  System.out.println("\nError en la posicion, rango de 0 a " + (tam - 1));
               }
            } while(pos < 0 || pos >= tam);
            System.out.println("\nValor? ");
            arr[pos] = teclado.nextLine();
            break;

         // Modificar
         case 2:
            do {
               System.out.println("\nPosicion? ");
               pos = Integer.parseInt(teclado.nextLine());
               if(pos < 0 || pos >= tam) {
                  System.out.println("\nError en la posicion, rango de 0 a " + (tam - 1));
               }
            } while(pos < 0 || pos >= tam);
            System.out.println("\nValor actual: " + arr[pos]);
            System.out.println("\nNuevo valor: ");
            arr[pos] = teclado.nextLine();
            break;

         // Borrar
         case 3:
            do {
               System.out.println("\nPosicion? ");
               pos = Integer.parseInt(teclado.nextLine());
               if(pos < 0 || pos >= tam) {
                  System.out.println("\nError en la posicion, rango de 0 a " + (tam - 1));
               }
            } while(pos < 0 || pos >= tam);
            arr[pos] = null;
            break;

         // Visualizar
         case 4:
            System.out.println("\nEl arreglo contiene:");
            for(pos = 0; pos < tam; pos++) {
               if(arr[pos] != null) {
                  System.out.println(pos + " --> " + arr[pos]);
               }
            }
            break;

         // Ver un elemento
         case 5:
            do {
               System.out.println("\nPosicion? ");
               pos = Integer.parseInt(teclado.nextLine());
               if(pos < 0 || pos >= tam) {
                  System.out.println("\nError en la posicion, rango de 0 a " + (tam - 1));
               }
            } while(pos < 0 || pos >= tam);
            if(arr[pos] != null) {
               System.out.println("\n" + pos + " --> " + arr[pos]);
            } else {
               System.out.println("\nNo hay nada en esta posicion");
            }
            break;

         // Guardar
         case 6:
            guardar(arr);
            System.out.println("Informacion guardada.");
            break;

         // Leer
         case 7:
            cargar(arr);
            System.out.println("Informacion leida y cargada.");
            break;

         // Ordenar Ascendente
         case 8:
            bubblesortAsc(arr);
            break;

         // Ordenar Descendente
         case 9:
            bubblesortDes(arr);
            break;

         // Busqueda Lineal (arreglo no ordenado)
         case 10:
            System.out.println("\nQue quieres buscar?");
            elem = teclado.nextLine();

            index = busquedaLineal(arr, elem);

            if(index != -1) {
               System.out.println("\nEl elmento " + elem + " se encuentra en la posicion: " + index);
            } else {
               System.out.println("\nEl elemento " + elem + " no se encuentra en el arreglo");
            }
            break;

         // Busqueda Binaria (arreglo ordenado)
         case 11:
            System.out.println("\nQue quieres buscar?");
            elem = teclado.nextLine();

            index = busquedaBinaria(arr, elem, 0, tam - 1);

            if(index != -1) {
               System.out.println("\nEl elmento " + elem + " se encuentra en la posicion: " + index);
            } else {
               System.out.println("\nEl elemento " + elem + " no se encuentra en el arreglo");
            }
            break;

         default:
            System.out.println("Opcion no reconocidad");
         }
      } while(op != 0);
      System.out.println("Fin del arreglo unidimensional");
   }

   /**
    * Metodo encargado de manejar un arreglo unidimensional de personas.
   */
   public void arregloUnidimensionalPersona() {
      // Arreglo unidimensional
      Persona [] arr;
      // Tamano arreglo unidimensional
      int tam;

      // objeto para trabajar con teclado
      Scanner teclado = new Scanner(System.in);

      // Pregunta sobre el tamaño del arrglo
      do {
         System.out.println("\nTamaño del arreglo? ");
         tam = Integer.parseInt(teclado.nextLine());
         if(tam <= 0 || tam > 10) {
            System.out.println("Error en el tamaño, rango de 1 a 10");
         }
      } while(tam <= 0 || tam > 10);

      arr = new Persona[tam];

      // op - opcion que eliga el usuario.
      // pos - posiciones dentro del arrglo.
      // index - posicion donde se encontro un elemento.
      int op = 1, pos = 0, index;
      // Elemento a buscar.
      Persona elem;
      // Variables para crear una persona.
      Persona p;
      String nombre, apellido;
      int edad;
      // Menu
      do {
         visualizaMenu();
         op = Integer.parseInt(teclado.nextLine());

         switch(op) {
         // Salir
         case 0:
            break;

         // Adicionar
         case 1:
            do {
               System.out.println("\nPosicion? ");
               pos = Integer.parseInt(teclado.nextLine());
               if(pos < 0 || pos >= tam) {
                  System.out.println("Error en la posicion, rango de 0 a " + (tam - 1));
               }
            } while(pos < 0 || pos >= tam);

            System.out.println("\nNombre(s)? ");
            nombre = teclado.nextLine();

            System.out.println("\nApellidos? ");
            apellido = teclado.nextLine();

            System.out.println("\nEdad? ");
            edad = Integer.parseInt(teclado.nextLine());

            p = new Persona(nombre, apellido, edad);
            arr[pos] = p;
            break;

         // Modificar
         case 2:
            do {
               System.out.println("\nPosicion? ");
               pos = Integer.parseInt(teclado.nextLine());
               if(pos < 0 || pos >= tam) {
                  System.out.println("\nError en la posicion, rango de 0 a " + (tam - 1));
               }
            } while(pos < 0 || pos >= tam);
            System.out.println("\nValor actual: " + arr[pos]);
            System.out.println("Nuevo valor: ");

            System.out.println("\nNombre(s)? ");
            nombre = teclado.nextLine();

            System.out.println("\nApellidos? ");
            apellido = teclado.nextLine();

            System.out.println("\nEdad? ");
            edad = Integer.parseInt(teclado.nextLine());

            p = new Persona(nombre, apellido, edad);
            arr[pos] = p;
            break;

         // Borrar
         case 3:
            do {
               System.out.println("\nPosicion? ");
               pos = Integer.parseInt(teclado.nextLine());
               if(pos < 0 || pos >= tam) {
                  System.out.println("\nError en la posicion, rango de 0 a " + (tam - 1));
               }
            } while(pos < 0 || pos >= tam);
            arr[pos] = null;
            break;

         // Visualizar
         case 4:
            System.out.println("\nEl arreglo contiene: ");
            for(pos = 0; pos < tam; pos++) {
               if(arr[pos] != null) {
                  System.out.println(pos + " --> " + arr[pos]);
               }
            }
            break;

         // Ver un elemento
         case 5:
            do {
               System.out.println("\nPosicion? ");
               pos = Integer.parseInt(teclado.nextLine());
               if(pos < 0 || pos >= tam) {
                  System.out.println("\nError en la posicion, rango de 0 a " + (tam - 1));
               }
            } while(pos < 0 || pos >= tam);
            if(arr[pos] != null) {
               System.out.println("\n" + pos + " --> " + arr[pos]);
            } else {
               System.out.println("\nNo hay nada en esta posicion");
            }
            break;

         // Guardar
         case 6:
            guardar(arr);
            System.out.println("Informacion guardada.");
            break;

         // Leer
         case 7:
            cargar(arr);
            System.out.println("Informacion leida y cargada.");
            break;

         // Ordenar Ascendente
         case 8:
            bubblesortAsc(arr);
            break;

         // Ordenar Descendente
         case 9:
            bubblesortDes(arr);
            break;

         // Busqueda Lineal (arreglo no ordenado)
         case 10:
            System.out.println("\nQue quieres buscar?");
            System.out.println("\nNombre(s)? ");
            nombre = teclado.nextLine();

            System.out.println("\nApellidos? ");
            apellido = teclado.nextLine();

            System.out.println("\nEdad? ");
            edad = Integer.parseInt(teclado.nextLine());

            elem = new Persona(nombre, apellido, edad);

            index = busquedaLineal(arr, elem);

            if(index != -1) {
               System.out.println("\nEl elmento " + elem + " se encuentra en la posicion: " + index);
            } else {
               System.out.println("\nEl elemento " + elem + " no se encuentra en el arreglo");
            }
            break;

         // Busqueda Binaria (arreglo ordenado)
         case 11:
            System.out.println("\nQue quieres buscar?");
            System.out.println("\nNombre(s)? ");
            nombre = teclado.nextLine();

            System.out.println("\nApellidos? ");
            apellido = teclado.nextLine();

            System.out.println("\nEdad? ");
            edad = Integer.parseInt(teclado.nextLine());

            elem = new Persona(nombre, apellido, edad);

            index = busquedaBinaria(arr, elem, 0, tam - 1);

            if(index != -1) {
               System.out.println("\nEl elmento " + elem + " se encuentra en la posicion: " + index);
            } else {
               System.out.println("\nEl elemento " + elem + " no se encuentra en el arreglo");
            }
            break;

         default:
            System.out.println("Opcion no reconocida");
         }
      } while(op != 0);
      System.out.println("Fin del arreglo unidimensional");
   }


   // Funcion Principal ....
   public static void main(String[] args) {

      ArregloUnidimensionalOrdenado auo = new ArregloUnidimensionalOrdenado();
      Scanner teclado = new Scanner(System.in);
      int op;

      do {
         auo.menuPrincipal();
         op = Integer.parseInt(teclado.nextLine());

         switch(op) {
         // Salir
         case 0:
            break;

         // Arreglo de numeros
         case 1:
            auo.arregloUnidimensionalDouble();
            break;

         // Arreglo de cadenas
         case 2:
            auo.arregloUnidimensionalString();
            break;

         // Arreglo de personas
         case 3:
            auo.arregloUnidimensionalPersona();
            break;
         }
      } while(op != 0);
   }
}