Documentos de Académico
Documentos de Profesional
Documentos de Cultura
*
* 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
}
}
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.
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(){
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);
}
}
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
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
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
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
*/
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
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
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
NodosListaA (NodoBinario
datos =valor;
valor){
siguiente = null;
}
// 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
}
}
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;
}
}