WW

Mtodo de Bsqueda Secuencial:

Se utiliza cuando el vector no est ordenado o no puede ser ordenado previamente.
Consiste en buscar el elemento comparndolo secuencialmente (de ah su nombre) con
cada elemento del arreglo hasta encontrarlo, o hasta que se llegue al final. La existencia
eese puede asegurar cuando el elemento es localizado, pero no podemos asegurar la no
existencia hasta no haber analizado todos los elementos del arreglo.
Arreglo: Es una zona de almacenamiento continuo, que contiene una serie de elementos
del mismo tipo.
Para efectos de sta explicacin visualice el arreglo como una serie de cajas unidas
donde podemos almacenar datos del mismo tipo, los arreglos estn indexados con una
serie de nmeros de van de menor a mayor y que sirven para hacer referencia a cada uno
de las cajas dentro del arreglo, en java esta indices comienzan en 0.



Los arreglos y en general las estructuras de datos nos permiten almacenar informacin o
datos, pero ahora nos seria de utilidad hallar la forma de encontrar los datos que
almacenamos en las mismas, para tal fin se han diseados algoritmo de bsquedas.
Como el titulo lo sugiere trataremos el mtodo de bsqueda secuencial.
Los dos elementos fundamentales a tener en cuentas son: un arreglo con datos objeto de
la bsqueda y un elemento o criterio de bsqueda.
El mtodo de bsqueda secuencial consiste en ir comparando el elemento o criterio
de bsqueda con cada uno de los elementos en el arreglo, esto se hace recorriendo el
arreglo y detenindose en cada elemento y hacer la comparacin, en caso de ser
verdadera la comparacin, guardar la posicin el elemento o dato.







Cdigo Java:
public int busquedaSecuencial(int []arreglo,int dato){
int posicion = -1;
for(int i = 0; i < arreglo.length; i++){//recorremos todo el arreglo
if(arreglo[i] == dato){//comparamos el elemento en el arreglo con el buscado
posicion = i;//Si es verdadero guardamos la posicion
break;//Para el ciclo
}
}
return posicion;
}

Bsqueda dicotmica (binaria)
Se utiliza cuando el vector en el que queremos determinar la existencia de un elemento
est previamente ordenado. Este algoritmo reduce el tiempo de bsqueda
considerablemente, ya que disminuye exponencialmente el nmero de iteraciones
necesarias.
Est altamente recomendado para buscar en arrays de gran tamao. Por ejemplo, en uno
conteniendo 50.000.000 elementos, realiza como mximo 26 comparaciones (en el peor
de los casos).
Para implementar este algoritmo se compara el elemento a buscar con un elemento
cualquiera del array (normalmente el elemento central): si el valor de ste es mayor que el
del elemento buscado se repite el procedimiento en la parte del array que va desde el
inicio de ste hasta el elemento tomado, en caso contrario se toma la parte del array que
va desde el elemento tomado hasta el final. De esta manera obtenemos intervalos cada
vez ms pequeos, hasta que se obtenga un intervalo indivisible. Si el elemento no se
encuentra dentro de este ltimo entonces se deduce que el elemento buscado no se
encuentra en todo el array.


Antes de iniciar con la explicacin hagamos un ejercicio mental, imaginemos que un
amigo desea que adivinemos un nmero que tiene en un papel anotado y que solo l
conoce, antes que empecemos nos advierte que el nmero est comprendido del 0 al
100, y por ltimo por cada intento que hagamos el nos dir si el nmero es mayor, menor
o igual al nmero que tiene anotado en el papel.

Digamos que el nmero secreto a adivinar es el 81.
Bueno si eres sistemtico empezaras intentando con el 50.
[1,2,3,.......,58,59,50,51,52,.......,98,99,100]
Tu amigo te dir que el nmero que deseas adivinar es mayor que 50.
A ste punto ya debes deducir que el nmero est entre el 51 y el 100.
Observa como ya no tienes que gastar intentos con los nmeros comprendidos de 0 a 50.

Ahora intentemos con el 75.
[51,52,53,.......,73,74,75,76,77,.......,98,99,100]
Tu amigo te dir que el nmero que deseas adivinar es mayor que el 75.
A ste punto ya debes deducir que el nmero est entre el 76 y el 100.
Observa como ya no tienes que gastar intentos con los nmeros comprendidos de 0 a 75.

Ahora intentemos con el 87.
[76,77,78,.......,85,86,87,88,89,.......,98,99,100]
Tu amigo te dir que el nmero que deseas adivinar es menor que el 87.
A ste punto ya debes deducir que el nmero est entre el 76 y el 86.
Observa como ya no tienes que gastar intentos con los nmeros comprendidos de 0 a 75
y 87 a 100.

Ahora intentemos con el 81.
[76,77,78,79,80,81,82,83,84,85,86]
Tu amigo te dir que has acertado.













Cdigo Java:
Un pequeo juego de azar.
import java.util.Scanner;
public class JuegoAzar{
public static void main(String args[]){
Scanner in = new Scanner(System.in);
int numero;
int valor;
int contador=0;
boolean ganar=false;
System.out.println("--------------------------------------");
System.out.println("| Bienvenido al juego |");
System.out.println("--------------------------------------");
numero=1+(int)(Math.random()*100);
System.out.println("En estos momentos se ha generado un numero comprendido entre-
\n"+
"1 y 100, que usted debe adivinar");
System.out.println("--------------------------------------");
do{//este ciclo es tambien llamado repeat en otros lenguajes
contador++;
System.out.print("-Digite el numero ");
valor = in.nextInt();//capturamos en numero digitado
if(valor==numero){
System.out.println("Felicitaciones, GANASTES con "+contador+" intentos");
ganar=true;
}else{
String temp="";
if(numero>valor){
temp="mayor";
}else{
temp="menor";
}
System.out.println("El numero que intentas adivinar es "+temp+" que "+valor);
}
}while(contador<6 && ganar==false);//cerramos el ciclo 'do'
//'contador<6' representa el numero de oportunidades del jugador
if(ganar==false){
System.out.println("Lo siento, no has adivinado, el numero era el "+numero);
}
}
}






Arboles AVL

Un rbol AVL (llamado as por las iniciales de sus inventores: Adelson-Velskii y Landis) es
un rbol binario de bsqueda en el que para cada nodo, las alturas de sus subrboles
izquierdo y derecho no difieren en ms de 1.
No se trata de rboles perfectamente equilibrados, pero s son lo suficientemente
equilibrados como para que su comportamiento sea lo bastante bueno como para usarlos
donde los ABB no garantizan tiempos de bsqueda ptimos.
El algoritmo para mantener un rbol AVL equilibrado se basa en reequilibrados locales, de
modo que no es necesario explorar todo el rbol despus de cada insercin o borrado.
Ejemplo:
P11.1. Para el siguiente rbol AVL

a) Indique los factores de balance de cada nodo.
b) Dibujar el rbol AVL, despus de la insercin de un nodo con valor 2. Qu
operaciones se
efectan?.
c) Habiendo ya insertado el nodo con valor 2, dibujar el rbol AVL, despus de la
insercin de
un nodo con valor 6. Qu operaciones se efectan?.
Solucin.
a) Los factores de balance:





b) Luego de insertar el 2, no queda AVL. Con una rotacin simple a la derecha, se
reestablece
la propiedad AVL.


c) La insercin del 6, no requiere rotaciones para mantener la propiedad AVL.

Cdigo Java:
public class Nodo {
int numMat;
Nodo izqda, drcha;
public Nodo(int mat){
numMat = mat;
izqda = drcha = null;
}
public void re_enorden(){
if(izqda != null)
izqda.re_enorden();
System.out.println("Matricula: " +numMat);
if(drcha != null)
drcha.re_enorden();
}
}

public class ABB {
private Nodo raz;
public ABB(){
raz = null;
}
public void insertar(int nuevoM){
if(raz==null){
raz = new Nodo(nuevoM);
}
else{
insertar(raz,nuevoM);
}
}
private void insertar(Nodo rz, int nm){
if (rz == null)
rz = new Nodo(nm);
else if(nm < rz.numMat)
insertar(rz.izqda,nm);
else if(nm > rz.numMat)
insertar(rz.drcha,nm);
else
System.out.println("Numero Duplicados");
}
public void visualizar(){
if(raz!=null)
raz.re_enorden();
}
}

public class Ejecutar {
public static void main(String []args){
ABB rbol = new ABB();
rbol.insertar(6);
rbol.insertar(3);
rbol.insertar(7);
rbol.visualizar();
}
}












Arboles ABB:

Se trata de rboles de orden 2 en los que se cumple que para cada nodo, el valor de la
clave de la raz del subrbol izquierdo es menor que el valor de la clave del nodo y que el
valor de la clave raz del subrbol derecho es mayor que el valor de la clave del nodo.
Operaciones en ABB
El repertorio de operaciones que se pueden realizar sobre un ABB es parecido al que
realizbamos sobre otras estructuras de datos, ms alguna otra propia de rboles:
Buscar un elemento.
Insertar un elemento.
Borrar un elemento.
Movimientos a travs del rbol:
Izquierda.
Derecha.
Raiz.
Informacin:
Comprobar si un rbol est vaco.
Calcular el nmero de nodos.
Comprobar si el nodo es hoja.
Calcular la altura de un nodo.
Calcular la altura de un rbol.







Este es un caso algo complejo, tenemos que tomar el hijo derecho del Nodo que
queremos eliminar y recorrer hasta el hijo ms a la izquierda ( hijo izquierdo y si este
tiene hijo izquierdo repetir hasta llegar al ltimo nodo a la izquierda), reemplazamos el
valor del nodo que queremos eliminar por el nodo que encontramos ( el hijo ms a la
izquierda ), el nodo que encontramos por ser el ms a la izquierda es imposible que
tenga nodos a su izquierda pero si que es posible que tenga un subrbol a la derecha,
para terminar solo nos queda proceder a eliminar este nodo de las formas que conocemos
( caso 1, caso 2 ) y tendremos la eliminacin completa.




Cdigo Java:

public boolean removeNodo( Nodo nodo ) {

/* Creamos variables para saber si tiene hijos izquierdo y derecho */
boolean tieneNodoDerecha = nodo.getHojaDerecha() != null ? true : false;
boolean tieneNodoIzquierda = nodo.getHojaIzquierda() != null ? true : false;

/* Verificamos los 3 casos diferentes y llamamos a la funcin correspondiente */

/* Caso 1: No tiene hijos */
if (!tieneNodoDerecha && !tieneNodoIzquierda) {
return removeNodoCaso1( nodo );
}

/* Caso 2: Tiene un hijo y el otro no */
if ( tieneNodoDerecha && !tieneNodoIzquierda ) {
return removeNodoCaso2( nodo );
}

/* Caso 2: Tiene un hijo y el otro no */
if ( !tieneNodoDerecha && tieneNodoIzquierda ) {
return removeNodoCaso2( nodo );
}

/* Caso 3: Tiene ambos hijos */
if ( tieneNodoDerecha && tieneNodoIzquierda ) {
return removeNodoCaso3( nodo );
}

return false;
}