* BusquedaSecuencial Application

*
* Author: Cristian Torres
*
* Pais: El Salvador
*/
import java.awt.*;
import javax.swing.*;
import java.awt.event.*;
public class BusquedaSecuencial extends JFrame implements ActionListener {
private JButton btnbuscar;
private JTextField num;
private Label lbl;
int[] valores = {20,10,100,5,30,0,3,500,50,1};//vector donde aremos la
busqueda
//metodo donde creo y aado los controles
public void Controles(){
//panel Contenedor
Container contenedor = getContentPane();
contenedor.setLayout( new FlowLayout(FlowLayout.CENTER) );
//agrego los controles al contenedor
lbl = new Label("Numero a Buscar");
contenedor.add(lbl);
num = new JTextField(10);
contenedor.add(num);
btnbuscar = new JButton("Buscar");
contenedor.add(btnbuscar);
btnbuscar.addActionListener(this);
}
//constructor
public BusquedaSecuencial(){
super("Busqueda Secuencial");
//cargo controles
Controles();
//tamao ventana y mostrar y centrar
setSize(350,120);
setLocationRelativeTo(null);//centrar
setVisible(true);
}
//evento del boton
public void actionPerformed(ActionEvent e){
if (e.getSource()==btnbuscar){
int x;
x = Integer.parseInt(num.getText());
if(BusquedaSecuencial(valores,x) !=-1){
JOptionPane.showMessageDialog(null,
"El Dato"+" "+ x + " "+ "Esta en la Posicion: "+
BusquedaSecuencial(valores,x),
"Busqueda",JOptionPane.INFORMATION_MESSAGE);
}
else
JOptionPane.showMessageDialog(null, "El Dato no se Encuentra",

"Error",JOptionPane.ERROR_MESSAGE);
}
}
//metodo de busqueda secuencial
public static int BusquedaSecuencial(int vector[], int Elem){
for (int i = 0; i < vector.length; ++i)
if (vector[i] == Elem)
return i;
return -1;
}
public static void main(String[] args) {
JFrame.setDefaultLookAndFeelDecorated(true);
BusquedaSecuencial busqueda = new
BusquedaSecuencial();//Instanciamos la clase que creamos
busqueda.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);//cerrar
ventana
}
}

Los 2 aspectos mas importantes del cdigo son los siguientes.

El mtodo que se encarga de hacer la bsqueda, que es el siguiente.

//metodo de busqueda secuencial

public static int BusquedaSecuencial(int vector[], int Elem){
for (int i = 0; i < vector.length; ++i)
if (vector[i] == Elem)
return i;
return -1;
}

Como puede verse se crea un mtodo que retornara un valor entero y que recibir 2 parmetros,
que sera el vector y el dato a buscar. El mtodo recorre el vector y va comparando los datos y si
encuentra el dato retorna la posicin en la que se encontr, si no se encuentra el dato retorna -1.
Y el otro aspecto importante es como implementar el mtodo.
int x;
x = Integer.parseInt(num.getText());
if(BusquedaSecuencial(valores,x) !=-1){
JOptionPane.showMessageDialog(null,
El Dato"+" "+ x + " "+ "Esta en la Posicion: "+
BusquedaSecuencial(valores,x),
"Busqueda",JOptionPane.INFORMATION_MESSAGE);
}

else
JOptionPane.showMessageDialog(null, "El Dato no se Encuentra",
"Error",JOptionPane.ERROR_MESSAGE);

Declaramos una variable que sera la que tendr el dato a buscar, y luego hacemos uso del
mtodo de bsqueda validando si encontr el dato o no, y le enviamos como argumentos,
el vector que contiene los datos y el dato a buscar.

6.1. Mtodo de bsqueda SECUENCIAL

Editar 0 5
INTEGRANTES DEL EQUIPO:
Italia Arango Roque
Berenice Snchez Garca
Cristian Mayoral Cruz
Oscar Ral Santiago Ortiz
Maximiliano Snchez Hernndez

Mtodo de Bsqueda Secuencial

La bsqueda es el proceso de localizar un registro (elemento) con un valor de
llave particular. La bsqueda termina exitosamente cuando se localiza el registro
que contenga la llave buscada, o termina sin xito, cuando se determina que no
aparece ningn registro con esa llave. Bsqueda secuencial, tambin se le conoce
como bsqueda lineal. Supongamos una coleccin de registros organizados como
una lista lineal. El algoritmo bsico de bsqueda secuencial consiste en empezar
al inicio de la lista e ir a travs de cada registro hasta encontrar la llave indicada
(k), o hasta al final de la lista.

image5_1.gif (4381 bytes)

La situacin ptima es que el registro buscado sea el primero en ser examinado.
El peor caso es cuando las llaves de todos los n registros son comparados con k
(lo que se busca). El caso promedio es n/2 comparaciones. Este mtodo de
bsqueda es muy lento, pero si los datos no estn en orden es el nico mtodo
que puede emplearse para hacer las bsquedas. Si los valores de la llave no son
nicos, para encontrar todos los registros con una llave particular, se requiere
buscar en toda la lista.

Mejoras en la eficiencia de la bsqueda secuencial

1)Muestreo de acceso
Este mtodo consiste en observar que tan frecuentemente se solicita
cada registro y ordenarlos de acuerdo a las probabilidades de acceso
detectadas. 2)Movimiento hacia el frente
Este esquema consiste en que la lista de registros se reorganicen
dinmicamente. Con este mtodo, cada vez que bsqueda de una llave
sea exitosa, el registro correspondiente se mueve a la primera posicin
de la lista y se recorren una posicin hacia abajo los que estaban antes
que el.
3)Transposicin
Este es otro esquema de reorganizacin dinmica que consiste en que,
cada vez que se lleve a cabo una bsqueda exitosa, el registro
correspondiente se intercambia con el anterior. Con este procedimiento,

entre mas accesos tenga el registro, mas rpidamente avanzara hacia la

primera posicin. Comparado con el mtodo de movimiento al frente, el
mtodo requiere mas tiempo de actividad para reorganizar al conjunto de
registros . Una ventaja de mtodo de transposicin es que no permite
que el requerimiento aislado de un registro, cambie de posicin todo el
conjunto de registros. De hecho, un registro debe ganar poco a poco su
derecho a alcanzar el inicio de la lista.
4)Ordenamiento
Una forma de reducir el numero de comparaciones esperadas cuando hay una
significativa frecuencia de bsqueda sin xito es la de ordenar los registros en
base al valor de la llave. Esta tcnica es til cuando la lista es una lista de
excepciones, tales como una lista de decisiones, en cuyo caso la mayora de las
bsquedas no tendrn xito. Con este mtodo una bsqueda sin xito termina
cuando se encuentra el primer valor de la llave mayor que el buscado, en lugar de
la final de la lista.

EJEMPLO DE BSQUEDA SECUENCIAL

El siguiente programa cumple con los siguientes requerimientos:

Crea un men de opciones (INSERTAR, CONSULTAR, ELIMINAR

Y FINALIZAR).
INSERTAR: almacena el nombre de personas en vectores estticos
tipo String de tamao 50.
CONSULTAR: Utilizando el algoritmo de bsqueda secuencial pide
el nombre y si lo encuentra imprime un mensaje de encontrado, en
caso contrario un mensaje de no localizado.
ELIMINAR: Utilizando el algoritmo de bsqueda secuencial pide el
nombre y si lo encuentra imprime un mensaje de encontrado y
elimina el nombre ajustando el vector para no dejar espacios en
blanco, en caso contrario un mensaje de no localizado.
FINALIZAR: Imprime los nombres almacenado y sale del programa.

import java.io.BufferedReader;
import java.io.InputStreamReader;
public class BusquedaSecuencial {
static BufferedReader br = null;static String N= "";static int
n=0;static String[] Nombre = new String[50];static String[]
APaterno = new String[50];static String[] AMaterno = new

String[50];
public static void main (String args[]){br = new
BufferedReader(new InputStreamReader(System.in));
do{menu();}while(Integer.parseInt(N)!=4);}
public static void menu(){do{System.out.println("Selecciona una de
las opciones del men: \n "+ "1- INSERTAR \n "+ "2- CONSULTAR "+
"\n 3- ELIMINAR \n "+ "4- FINALIZAR");try{N =
br.readLine();}catch(Exception
e){e.printStackTrace();}}while(!esEntero(N) || conversor(N)<=0 ||
conversor(N)>=5 );
switch(Integer.parseInt(N)){case 1:insertar();break;case
2:consultar();break;case 3:eliminar();break;case
4:imprimir();break;}}
public static void consultar(){if(n>0){String nombre="";int
eureka=0;
try{System.out.println("Ingresa el Nombre : ");nombre =
br.readLine();}catch(Exception e){e.printStackTrace();}
for(int i=0; i<n;
i++){if(Nombre[i].equals(nombre)){eureka=1;}}if(eureka==1){System.
out.println("Nombre encontrado!!!!!.
");}else{System.out.println("Nombre NO localizado!!!!!.
");}}else{System.out.println("No hay elementos en la lista. ");}
}
public static boolean esEntero(String cad) {for(int i = 0;
i<cad.length(); i++)if( !Character.isDigit(cad.charAt(i)) )return
false;
return true;}
public static int conversor(String x){int valor=0;
try{valor= Integer.parseInt(x);}catch(NumberFormatException
e){System.out.println("Valor invalido");}
return valor;}
public static void insertar(){

if(n<50){System.out.println("Leyendo datos de la persona: " +

(n+1));
try{System.out.println("Ingresa el Apellido Paterno:
");APaterno[n] = br.readLine();}catch(Exception
e){e.printStackTrace();}
try{System.out.println("Ingresa el Apellido Materno:
");AMaterno[n] = br.readLine();}catch(Exception
e){e.printStackTrace();}
try{System.out.println("Ingresa el nombre: ");Nombre[n] =
br.readLine();}catch(Exception e){e.printStackTrace();}
n++;}else{System.out.println("El vector esta lleno, elimina
personas para poder insertar");}
}
public static void eliminar(){String nombre="";int encontrados=0;
if(n>0){
try{System.out.println("Ingresa el Nombre : ");nombre =
br.readLine();}catch(Exception e){e.printStackTrace();}
for(int i=0; i<n;
i++){if(Nombre[i].equals(nombre)){encontrados++;for(int j=i; j<n;
j++){Nombre[j]=Nombre[j+1];APaterno[j]=APaterno[j+1];AMaterno[j]=A
Materno[j+1];}i--;n-;}}if(encontrados>0){System.out.println("Nombre encontrado,
procediendo a eliminar!!!!!. ");}else{System.out.println("Nombre
NO localizado!!!!!. ");}}else{System.out.println("No hay elementos
a eliminar.");}
}
public static void imprimir(){if(n>0){System.out.println("Apellido
paterno Apellido Materno Nombre");for(int i=0; i<n;
i++){System.out.print(i+1 + ".- " + APaterno[i] +
"\t");System.out.print(AMaterno [i] +
"\t");System.out.print(Nombre [i] + ".");System.out.println();}}}
}

Bsqueda Binaria
Escrito por javaheaven el 24-04-2011 en General. Comentarios (1)
El algoritmo de bsqueda binaria es un excelente mtodo para buscar datos dentro de una
estructura(generalmente un arreglo unidimencional). Se le da el nombre de bsqueda
binaria por que el algoritmo divide en dos el arregelo, aludiendo al concepto de bit, el cual
puede tener dos estados.
La nica condicin para usar este algoritmo es que los datos dentro del arreglo estn
ordenados de menor a mayor.
La solucin mas fcil para realizar una busqueda es por fuerza bruta, pero este mtodo
puede resultar bastante ineficiente cuando se tiene una gran cantidad de datos, ya que
habria que buscar posicin por posicin hasta encontrar el dato que queremos.
El cdigo por fuerza bruta es bastante sencillo:
for(int i=0; i<Arreglo.length; i++)
if(Arreglo[i] == elemento)
System.out.println("\nElemento encontrado en la posicion: " + i);
Solo se recorre todo el arreglo y verificamos si la posicin i es igual al dato que queremos
buscar, el cdigo anterior se puede mejorar simplemente agregandole una bandera, pero aun
asi no es lo suficientemente bueno.
El algoritmo de busqueda binaria es el siguiente:
1. Se declaran los ndices superior e inferior. El inferior en 0 y el superior con el
tamao del arreglo menos 1.
2. Se calcula el centro del arreglo con la siguiente formula:
centro = (superior + inferior) / 2
3. Verificamos si el arreglo en la posicin centro es igual al dato que buscamos. Si es
igual significa que encontramos el dato y retornamos centro.
4. Si son diferentes verificamos si el arreglo en la posicin centro es mayor al dato que
que queremos buscar. Si es mayor actualizamos superior: superior = centro - 1, si
no actualizamos inferior: inferior = centro + 1.
5. Volvemos al paso 2.
Si cuando ya no se cumpla la condicn del ciclo y no se encontro el dato retornamos -1
indicando que el dato no se encuentra en el arreglo.

Supongamos que tenemos el arreglo {2, 3, 5, 7, 9, 11, 14, 18, 22, 25} y queremos buscar el
dato 18, entonces el inferior toma el valor de 0 y superior el valor de 9 (ya que es tamao
del arreglo menos 1).
Calculamos el centro, centro = (superior + inferior) / 2
centro = (9 + 0) / 2
centro = 4
divisin entera(ignorando la parte decimal).
Arreglo en la posicin centro es 9 (Arreglo[centro] = 9) ya que se empieza a contar desde 0.
Comprobamos si arreglo en la posicin centro es igual al dato que queremos buscar
Arreglo[centro] = dato, como Arreglo[centro] = 9 y dato = 18. no son iguales por lo tanto
ahora verificamos si es mayor, en este caso no lo es entonces actualizamos inferior = centro
+ 1, esto hace que podamos descartar todos los datos del centro hacia atras, esto reduce
nuestro arreglo a {11, 14, 18, 22, 25}. Y as seguiremos hasta que Arreglo[centro] = dato.
Como se puede notar este mtodo es bastante eficiente en arreglos grandes, por ejemplo
supongamos que tenemos un arreglo de 10000 datos, y estamos buscando un dato que se
encuentra en la posicin 6000, solo en la primera vuelta del ciclo ya se pueden descartar los
primeros 5000 valores, en cambio por fuerza bruta se tendrian que realizar esos 6000 ciclos
para poder localizar el dato.
El cdigo completo quedara as:
public class BusquedaBinaria
{
public static int busquedaBinaria(int[] Arreglo, int elemento)
{
int i = 0, centro = 0, posicion = 0, inferior = 0, superior = Arreglo.length-1;
while(inferior <= superior)
{
centro = (superior + inferior) / 2;
if (Arreglo[centro] == elemento)
return centro;
else
if (Arreglo[centro] > elemento)
superior = centro - 1;
else
inferior = centro + 1;
}
return -1;

}
public static void main (String[] args)
{
java.util.Scanner Leer = new java.util.Scanner(System.in);
System.out.print("Tamao del arreglo: ");
int tamaoArreglo = Leer.nextInt();
int[] Arreglo = new int[tamaoArreglo];
for(int i=0; i<Arreglo.length; i++)
Arreglo[i] = Leer.nextInt();
System.out.print("Elemento a buscar: ");
int elemento = Leer.nextInt();
int posicion = busquedaBinaria(Arreglo, elemento);
if(posicion == -1)
System.out.println("\nElemento no encontrado");
else
System.out.println("\nElemento " + elemento + " encontrado en la posicin " +
posicion);
}
}

Tarea 3: Algoritmo de bsqueda en rbol binario

ACI710
Oscar Puentes Lagos

Introduccin
Los algoritmos de bsqueda nos permiten encontrar los resultados o valores de
una forma simplificada y acotando las iteraciones hasta encontrar el resultado,
siempre que est disponible.

Descripcin
El algoritmo presentado a continuacin est compuesto por cinco clases que nos
permitirn realizar la insercin de elementos, ordenarlo y buscar un elemento
dentro del rbol.
Las cinco clases son:

1. ArbolBinario
o

2. Arbol
o
o
o
o

3. Cola

Esta clase tiene la interfaz de ingreso de datos que permite la

entrada de la cantidad de elementos a contener, el valor a buscar
y posteriormente se solicita el ingreso de cada elemento hasta
completar la cantidad ingresada anteriormente.
Una vez ingresado los valores a contener, se invoca el mtodo
Inorden que nos mostrar los elementos ordenados de menor a
mayor.
Finalmente invocar el mtodo Busqueda que realiza la
bsqueda el elemento y retorna una respuesta de tipo boolean.
La clase Arbol contiene los mtodos Arbol, InsertarNodo, Inorden
y Busqueda.
El mtodo InsertarNodo inserta el valor en la raz o ramas.
El mtodo Inorden genera el ordenamiento del arbol a travs de
anlisis de las ramas binarias de izquierda o derecha.
El mtodo Busqueda realiza comparaciones utilizando tres Nodos,
uno actual, anterior y uno temporal, con la finalidad de identificar
la busqueda por la izquierda o derecha y manteniendo el valor
anterior y actual.

Esta clase genera la limpieza, insercin y eliminacin al inicio al

final por cada nodo cuando corresponda.
4. NodoBinario
o Esta clase genera el mtodo InsertarBinario que por cada nodo
determina la insercin de sus hijos a la derecha o izquierda.
5. NodosListaA
o Se crean los nodos con valor o nulo para el siguiente nodo.
o

Cdigo Java
package busquedabinaria;
import java.io.*;
/**
*
* @author Opuentes

*/
public class ArbolBinario{
public static void main (String[]args)throws IOException
{
BufferedReader
InputStreamReader(System.in));

entrada

=new

BufferedReader(new

//creando objeto del arbolito

Arbol A = new Arbol();
int cantidad, b, numero;
System.out.println("Digite cantidad de nmeros a ingresar
");
cantidad=Integer.parseInt(entrada.readLine());
System.out.println("Digite el nmero a buscar dentro de la
lista ");
numero=Integer.parseInt(entrada.readLine());
for(int j=0;j<cantidad;j++)
{
System.out.println("Ingrese

el

valor

"+j+"

de

"+cantidad);
b=Integer.parseInt(entrada.readLine());
A.InsertaNodo (b);
}
System.out.print("La lista ordenada qued: ");
A.Inorden (cantidad, numero, A.Raiz);
System.out.println();
if (A.Busqueda(cantidad, numero, A.Raiz) == true)
System.out.print("El nmero fue encontrado en la
Lista: " + numero + " ");
else

System.out.print("El nmero NO fue encontrado en la

Lista: " + numero + " ");
}
}
package busquedabinaria;
import java.io.*;
/**
*
* @author Opuentes
*/
class Arbol{
Cola Cola = new Cola();
NodoBinario Padre;
NodoBinario Raiz;
//Constructor
public Arbol(){
Raiz = null;
}
//Insercion de un elemento en el arbol
public void InsertaNodo(int Elem){
if(Raiz == null)
Raiz = new NodoBinario (Elem);
else
Raiz.InsertaBinario (Elem);
}
//Inorden Recursivo del arbol
public void Inorden (int cantidad, int numero, NodoBinario
Nodo){

if(Nodo == null)
return;
else{
Inorden(cantidad, numero, Nodo.Hizq);
System.out.print(Nodo.dato + " ");
Inorden(cantidad, numero, Nodo.Hder);
}
}
//Busca un elemento en el arbol
boolean Busqueda(int cantidad, int Elem, NodoBinario A){
NodoBinario actual=A;
NodoBinario anterior=A;
NodoBinario temp;
while(true){
if(actual==null)
break;
if(actual.dato==Elem)
break;
anterior=actual;
if(actual.dato<Elem)
actual=actual.Hder;
else
actual=actual.Hizq;
}
if(actual==null)
return false;
else {

if(actual==A){
temp=actual.Hizq;
A=A.Hder;
anterior=A;
}
else
if (anterior.Hder==actual){
temp=actual.Hizq;
anterior=actual.Hder;
}
else {
temp=actual.Hizq;
anterior.Hder=actual.Hizq;
}
actual=new NodoBinario();
while(actual.Hizq!=null)
actual=actual.Hizq;
actual.Hizq=temp;
}
return true;
}
}
package busquedabinaria;
/**
*
* @author Opuentes
*/

//Definicin de la Clase Cola

class Cola{
NodosListaA PrimerNodo;
NodosListaA UltimoNodo;
String Nombre;
//Constructor construye una lista vacia con un nombre de List
public Cola(){
this ("Lista");
}
//Constructor
public Cola (String s){
Nombre = s;
PrimerNodo = UltimoNodo =null;
}
//Retorna True si Lista Vaca
public boolean VaciaLista() {
return PrimerNodo == null;
}
//Inserta un Elemento al Frente de la Lista
public void InsertaInicio (NodoBinario ElemInser){
if(VaciaLista())
PrimerNodo = UltimoNodo = new NodosListaA (ElemInser);
else
PrimerNodo = new NodosListaA (ElemInser, PrimerNodo);
}
//Inserta al Final de la Lista
public void InsertaFinal(NodoBinario ElemInser){

if(VaciaLista())
PrimerNodo = UltimoNodo = new NodosListaA (ElemInser);
else
UltimoNodo=UltimoNodo.siguiente

=new

NodosListaA

(ElemInser);
}
//Eliminar al Inicio
public void EliminaInicio(){
if(VaciaLista())
System.out.println ("No hay elementos");
// Restablecer

las referencias de PrimerNodo y

UltimoNodo
if(PrimerNodo.equals (UltimoNodo))
PrimerNodo = UltimoNodo = null;
else
PrimerNodo = PrimerNodo.siguiente;
}
//Elimina al final
public void EliminaFinal (){
if(VaciaLista())
System.out.println ("No hay elementos");
// Restablecer

las referencias de PrimerNodo y

UltimoNodo
if (PrimerNodo.equals (UltimoNodo))
PrimerNodo = UltimoNodo = null;
else{
NodosListaA Actual =PrimerNodo;
while (Actual.siguiente != UltimoNodo)

Actual = Actual.siguiente;
UltimoNodo =Actual;
Actual.siguiente = null;
}
}
}

/*
*/
package busquedabinaria;
import java.io.*;
class NodoBinario{
int dato;
NodoBinario Hizq, Hder;
//Constructores
NodoBinario() {
}
NodoBinario (int Elem){
dato = Elem;
NodoBinario Hizq, Hder = null;
}
//Insercion de un elemento
public void InsertaBinario (int Elem){
if(Elem < dato){
if (Hizq == null)
Hizq = new NodoBinario(Elem);
else

Hizq.InsertaBinario(Elem);
}
else{
if (Elem > dato){
if (Hder == null)
Hder = new NodoBinario (Elem);
else
Hder.InsertaBinario(Elem);
}
}
}
}

/*
*/
package busquedabinaria;
/**
*
* @author Opuentes
*/
//Definicin de la Clase NodoLista
class NodosListaA{
NodoBinario datos;
NodosListaA siguiente;
//Construtor

Crea un nodo del tipo Object

NodosListaA (NodoBinario
datos =valor;

valor){

siguiente = null;

//siguiente con valor de nulo

}
// Constructor Crea un nodo del Tipo Object y al siguiente
nodo de la lista
NodosListaA (NodoBinario valor, NodosListaA signodo){
datos = valor;
siguiente = signodo; //siguiente se refiere al siguiente
nodo
}
}

Busqueda Binaria Resursiva

Publicado el Mircoles 03 de septiembre de 2008 a las 08:28:09 por libitzu
Votar:
1 voto, 100%
Descargas: 4,750
Nombre: busqueda Binaria Resursiva
Descargar
Descripcin:
la busqueda Binaria Recursiva si esta es la mejor forma de buscar un dato
URL:
http://mygnet.net/codigos/java/metodosdebusqueda/busqueda_binaria_resursiva.2753
Cdigo Fuente:
import java.util.*;
class programa11
{
public static void main(String[] args)
{
int a[],n,n1,indice,Iabajo,Iarriba;
Scanner sc=new Scanner(System.in);
System.out.print("Ingresa tamao de arreglo: ");
n=sc.nextInt();
a=new int[n];
a=inicializa(n);
a=ordenarArreglo(a,n);
muestra(a);
Iabajo=0;
Iarriba=n-1;
System.out.print("Ingresa numero a buscar: ");
n1=sc.nextInt();
indice=busquedaBinariaRecursion(a,n1,Iabajo,Iarriba);
if(indice==-1)
{
System.out.println("tu nmero no esta en la
lista");
}
else
{
System.out.println("tu nmero esta en el indice:
"+indice);
}
}

static int[] inicializa(int n)

{
int i,j,a[]=new int[n];
for(i=0;i<n;i++)
{
a[i]=randomxy(1,50);
}
return a;
}
static int busquedaBinariaRecursion(int a[],int n,int Iabajo,int
Iarriba)
{
int Icentro,indice=-1;
if(Iarriba<Iabajo)
{
return -1;
}
else
{
Icentro=(Iabajo+Iarriba)/2;
if (n<a[Icentro])
{
return(busquedaBinariaRecursion(a,n,Iabajo,Icentro-1));
}
else
{
if (n>a[Icentro])
{
return(busquedaBinariaRecursion(a,n,Icentro+1,Iarriba));
}
else
{
return Icentro+1;
}
}
}
}
static int[] ordenarArreglo(int a[], int n)
{
int i,j,t;
for(i=0;i<n-1;i++)
{
for(j=0;j<n-1;j++)
{
if(a[j]>a[j+1])
{

t=a[j];
a[j]=a[j+1];
a[j+1]=t;
}
}
}
return a;
}
static void muestra(int a[])
{
int n=a.length;
for(int i=0;i<n;i++)
{
System.out.print(a[i]+" ");
}
System.out.print("nn");
}
static int randomxy(int x,int y)
{
int ran=(int) (Math.floor(Math.random()*(y-x+1))+x);
return ran;
}
}