Métodos de Búsqueda en Java-Secuencial y binario

FUE IMPLEMENTADO POR IVAN LUIS JIMENEZ (IVANOVICHACKER)
EL CÓDIGO CONSISTE EN UN MENÚ, ANTES DE ESTO PIDE LOS DATOS, LO BUENO DE ESTO ES QUE LO IMPLEMENTE CON ENTEROS Y CADENAS DE CARACTERES ASÍ QUE ESTA MUY BUENO.

EL MENÚ CONTIENE LA OPCIÓN DE ELEGIR ENTRE LOS MÉTODOS DE ORDENACIÓN QUE GUSTEN, YA SEA DE ENTEROS O CADENAS.
BUENO AQUÍ ALGUNAS CAPTURAS DEL PROGRAMA:










import java.util.Scanner;
//implementado por Ivan luis Jimenez (IvanovicHacker)
public class Metodos_Busqueda {

int[] arreglo = new int[5];
String[] cadena = new String[5];
int x;

public void M_Intercambio(int[] arreglo) {

{
int temp;
for (int i = 1; i < arreglo.length; i++) {
for (int j = 0; j < arreglo.length - 1; j++) {
if (arreglo[j] > arreglo[j + 1]) {
temp = arreglo[j];
arreglo[j] = arreglo[j + 1];
arreglo[j + 1] = temp;
}
}
}
}
}

public void Mostrar_Arreglo(int[] arreglo) {
for (int d = 0; d < arreglo.length; d++) {
System.out.print("[" + arreglo[d] + "] ";
}
System.out.println("n";
}

public int Busca_Cadena_Desordenado(String cadena[], String Buscar) {
System.out.println("====================================n"
+ "B. SECUENCIAL DESORDENADA DE CADENASn"
+ "====================================n";
for (int i = 0; i < cadena.length; i++) {

if (cadena.compareTo(Buscar) == 0) {

return i;
}
}
return -1;
}

void Secuencial_Ordenado_Cadenas(String cadena[], String Buscar) {
System.out.println("=================================n"
+ "B. SECUENCIAL ORDENADA DE CADENASn"
+ "=================================n";
int i = 0;
while ((i < cadena.length) && (cadena.compareTo(Buscar) != 0)) {
i++;
}
if ((i > cadena.length) || (cadena.compareTo(Buscar) != 0)) {
System.out.println("La nombre"+ Buscar +" no esta en el arreglo n";
} else {
System.out.println("El nombre " + Buscar + " se encuentra en la posicion: " + (i + 1) + "n";
}
}

public int Busqueda_Cadena_Binaria(String cadena[], String Buscar) {
System.out.println("===============================n"
+ " B. BINARIA DE CADENASn"
+ "===============================n";

int centro, inicio = 0, fin = cadena.length - 1;

while (inicio <= fin) {
centro = (fin + inicio) / 2;
if (cadena[centro].compareTo(Buscar) == 0) {
return centro;
} else if (cadena[centro].compareTo(Buscar) < 0) {
fin = centro - 1;
} else {
inicio = centro + 1;
}
}
return -1;
}

public void Secuencial_Desordenado(int arreglo[], int dato) {
System.out.println("====================================n"
+ "B. SECUENCIAL DESORDENADA DE ENTEROSn"
+ "====================================n";
int i;
for (i = 0; i < arreglo.length; i++) {
if (arreglo == dato) {
System.out.println("El elemento " + dato + " se encuentra en la posicion: " + (i + 1));
x = 1;
}
}
if (x == 0) {
System.out.println("El elemento no esta en el arreglo";
}
}


void Secuencial_Ordenado(int arreglo[], int dato) {
System.out.println("=================================n"
+ "B. SECUENCIAL ORDENADA DE ENTEROSn"
+ "=================================n";
int i = 0;
while ((i < arreglo.length) && (dato > arreglo)) {
i++;
}
if ((i > arreglo.length) || (dato < arreglo)) {
System.out.println("El elemento no esta en el arreglo n";
} else {
System.out.println("El elemento " + dato + " se encuentra en la posicion: " + (i + 1) + "n";
}
}

public int Busqueda_Binaria(int arreglo[], int dato) {
System.out.println("===============================n"
+ " B. BINARIA DE ENTEROSn"
+ "===============================n";
int n = arreglo.length;
int centro, inf = 0, sup = n - 1;
while (inf <= sup) {
centro = (sup + inf) / 2;
if (arreglo[centro] == dato) {
return centro;
} else if (dato < arreglo[centro]) {
sup = centro - 1;
} else {
inf = centro + 1;
}
}
return -1;
}

public void Perdir_Datos() {
Scanner datos = new Scanner(System.in);
System.out.println("TECLEE DATOS ENTEROS";
for (int i = 0; i < arreglo.length; i++) {
System.out.println("Teclee dato [" + (i + 1) + "] ";
int valor = datos.nextInt();
arreglo = valor;
}
}

public void Pedir_Cadena() {
Scanner cadenas = new Scanner(System.in);
System.out.println("TECLEE CADENA DE CARACTERES";
for (int p = 0; p < cadena.length; p++) {
try {
System.out.println("Teclee Cadena [" + (p + 1) + "] ";
String valor1 = cadenas.nextLine();
cadena[p] = valor1;
} catch (Exception e) {
e.printStackTrace();
}
}
}

public void Menu() {
Metodos_Busqueda call = new Metodos_Busqueda();
Scanner xor = new Scanner(System.in);
Scanner xar = new Scanner(System.in);
Scanner ready = new Scanner(System.in);
int respuesta, buscar;
int read;
String B_Cadena;
do {

System.out.println("SELECCIONE LA OPCION QUE DESEA REALIZAR";
System.out.println("1) B. Secuencial Desordenada de Enteros";
System.out.println("2) B. Secuencial Ordenada de Enteros";
System.out.println("3) B. Binaria de Enteros";
System.out.println("4) B. Secuencial Desordenada de Cadenas";
System.out.println("5) B. Secuencial Ordenada de Cadenas";
System.out.println("6) B. Binaria de Cadenas ";
System.out.println("7) Salir";
read = xor.nextInt();
switch (read) {
case 1:
call.M_Intercambio(arreglo);
System.out.println("Ordenando arreglo...n";
call.Mostrar_Arreglo(arreglo);
System.out.println("Teclee el numero a buscar:";
buscar = xor.nextInt();
call.Secuencial_Desordenado(arreglo, buscar);
break;
case 2:
call.M_Intercambio(arreglo);
System.out.println("Ordenando arreglo...n";
call.Mostrar_Arreglo(arreglo);
System.out.println("Teclee el numero a buscar:";
buscar = xor.nextInt();
call.Secuencial_Ordenado(arreglo, buscar);
break;
case 3:
call.M_Intercambio(arreglo);
System.out.println("Ordenando arreglo...n";
call.Mostrar_Arreglo(arreglo);
System.out.println("Teclee el numero a buscar:";
buscar = xor.nextInt();
int elem;
elem = Busqueda_Binaria(arreglo, buscar);
if (elem != -1) {
System.out.println("El elemento " + buscar + " se encuentra en la posición " + (elem+1));

} else {
System.out.println("El elemento no se encuentro en el arreglo ";
}
break;
case 4:
System.out.println(""
+ "Teclee la cadena a bucar:";
B_Cadena = ready.nextLine();
int c = Busca_Cadena_Desordenado(cadena, B_Cadena);
if (c != -1) {
System.out.println("El nombre " + B_Cadena + " se encuentra en la posición " + (c + 1));

} else {
System.out.println("El nombre "+B_Cadena+" no se encuentro en el arreglo ";
}
break;
case 5:
System.out.println(""
+ "Teclee la cadena a bucar:";
B_Cadena = ready.nextLine();
call.Secuencial_Ordenado_Cadenas(cadena, B_Cadena);
break;
case 6:
System.out.println(""
+ "Teclee la cadena a bucar:";
B_Cadena = ready.nextLine();
int h = Busqueda_Cadena_Binaria(cadena, B_Cadena);
if (h != -1) {
System.out.println("El nombre " + B_Cadena + " se encuentra en la posición " + (h + 1));

} else {
System.out.println("El nombre "+B_Cadena+" no se encuentro en el arreglo ";
}
break;
default:
System.out.println("Opcion Invalida!!!";
}
System.out.println("Deseas volver a consultar otro metodo? :1 = si, 2 = no";
respuesta = xar.nextInt();

} while (respuesta == 1);
System.out.println("Gracias por utilizar el programa ";
}

public static void main(String[] args) {
Metodos_Busqueda call2 = new Metodos_Busqueda();

call2.Perdir_Datos();
call2.Pedir_Cadena();
call2.Menu();

}
}