Saludos a todos.

Antes de iniciar, debemos familiarizarnos con el concepto de arreglo, he aqu la definicin

por Wikipedia:

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 informacion 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.

He aqu el cdigo:

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;
}
Este mtodo nos halla la posicin del elemento o dato buscado pero en su primero
coincidencia, si queremos que nos halle la posicin de la ultima coincidencia, lo nico que
tenemos que hacer es eliminar la linea donde aparece 'break'.
Si el resultado del mtodo anterior es -1, significa que el elemento no se encuentra en el
arreglo.
Ahora cabe la pregunta, y si el elemento que deseo buscar aparece varias veces en el
arreglo y yo deseo conocer cada una de estas posiciones, como hago?
Lo que hacemos es deshacernos de la linea 'break' para que el vector sea recorrido en su
totalidad, y de alguna forma ir almacenando cada una de las posiciones resultantes de las
comparaciones verdaderas.
He aqu el cdigo:

public String busquedaSecuencial2(int []arreglo,int valor){

String posicion = "";
for(int i = 0; i < arreglo.length; i++){
if(arreglo[i] == valor){
posicion += i+",";
}
}
return posicion;
}
Aunque pude haber usado un 'ArrayList' o 'Vector' prefer usar un 'String' porque asumo
que el lector de ste articulo est mas familiarizado con esta ultima que con los dos
primeros trminos.
Como siempre esperando que lo escrito les sea de utilidad.

http://usandojava.blogspot.com/2012/10/busqueda-secuencial-en-un-arreglo.html

Bsqueda binaria en un arreglo usando Java

Tal vez tambin te interese Bsqueda secuencial en un arreglo usando Java.

Saludos,

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.

He aqui el codigo de juego.

Si te has fijado, la tcnica para adivinar el nmero es dividiendo el rango en dos partes, si
el nmero a adivinar es mayor tomamos el rango que nos ha quedado a la derecha sino si
el nmero a adivinar es menor tomamos el rango que nos ha quedado a la izquierda sino
si el nmero es igual al nmero a adivinar, bingo hemos adivinado; si la primera vez no
adivinamos el nmero realizamos los pasos anteriores nuevamente hasta que adivinemos
(asumiendo que el nmero a adivinar existe).

La tcnica anteriormente descrita es anloga a la tcnica para la bsqueda binaria.

Como podemos observar y asumiendo la analoga, uno de los requisitos para el

algoritmo de bsqueda binaria es que los datos esten previamente ordenados.

Este algoritmo se utiliza cuando el vector en el que queremos determinar la existencia de

un elemento est previamente ordenado. El algoritmo reduce el tiempo de
bsqueda considerablemente, ya que disminuye exponencialmente el nmero de
iteraciones necesarias (wikipedia).

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 (wikipedia).

He aqu el cdigo que les ofrezco.

class BusquedaBinaria{
/**
* Busca un valor numerico dentro de un arreglo numerico...
* previamente ordenado usando el metodo de busqueda binaria
*
* @param arreglo con los elementos; dato a buscar
* @return posicion del elemento buscado, en caso de no existir retorna
-1
*/
public static int busquedaBinaria(int vector[], int dato){
int n = vector.length;
int centro,inf=0,sup=n-1;
while(inf<=sup){
centro=(sup+inf)/2;
if(vector[centro]==dato) return centro;
else if(dato < vector [centro] ){
sup=centro-1;
}
else {
inf=centro+1;
 }
}
return -1;
}

public static void main(String []args){

int[]vector
={1,4,7,8,9,14,23,47,56,60,61,63,65,66,68,69,70,73,76,77,79,80,82};
int valorBuscado = 70;
System.out.println(busquedaBinaria(vector,valorBuscado));
}
}

http://usandojava.blogspot.com/2012/11/busqueda-binaria-en-un-arreglo-usando.html

Buscar Datos en Arreglo (Metodo Busqueda Secuencial)

martes, 12 de junio de 2012

Bueno esta vez veremos un poco de java, en este articulo veremos como implementar
elmtodo de bsqueda secuencial para buscar un dato en un arreglo.

El mtodo de bsqueda secuencial es de los mas fciles que podemos utilizar para buscar datos(es
aconsejable utilizarlo cuando el vector no es de gran tamao), ya que no requiere que el vector este
ordenado, el mtodo consiste en recorrer el vector de manera secuencial hasta encontrar el dato a buscar.

El ejemplo lo desarrolle con Jcreator.

En el ejemplo creo un vector con 10 datos y luego hago la bsqueda de un dato para saber si esta o no en
el vector.

Veamos el cdigo y luego explicare lo mas importante.

/**
* 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 2parmetros, 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
delmtodo de bsqueda validando si encontr el dato o no, y le enviamos como argumentos, elvector que
contiene los datos y el dato a buscar.

http://cristiantorresalfaro.blogspot.com/2012/06/buscar-datos-en-arreglo-metodo-busqueda.html
Algoritmos de bsqueda-lineal, bsqueda-binaria y
ordenacin de burbuja
Los desarrolladores normalmente escribien cdigo para buscar datos en un
array y para ordenar ese array. Hay tres algoritmos muy comunes que se
utilizan para realizar estas tareas.

Bsqueda Lineal

El algoritmo de bsqueda lineal busca en un array uni-dimensional un dato

especfico. La bsqueda primero examina el elemento con el ndice 0 y
continua examiando los elementos sucesivos hasta que se encuentra el
tem o no quedan ms elementos que examinar. El siguiente pseudocdigo
demuestra este algoritmo:

DECLARE INTEGER i, srch = 72

DECLARE INTEGER x [] = [ 20, 15, 12, 30, -5, 72, 456 ]
FOR i = 0 TO LENGTH (x) - 1
IF x [i] IS srch THEN
PRINT "Found ", srch
END
END IF
NEXT i
PRINT "Did not find ", srch
END

El siguiente listado presenta el equivalente Java al pseudocdigo anterior:

// LSearchDemo.java

class LSearchDemo {

public static void main (String [] args) {

int i, srch = 72;
int [] x = { 20, 15, 12, 30, -5, 72, 456 };
 for (i = 0; i <= x.length - 1; i++)
if (x [i] == srch) {
System.out.println ("Found " + srch);
return;
}

System.out.println ("Did not find " + srch);

}
}

LSearchDemo produce la siguiente salida:

Found 72

Dos de las ventajas de la bsqueda lineal son la simplicidad y la habilidad

de buscar tanto arrays ordenados como desornedados. Su nica desventaja
es el tiempo empleado en examinar los elementos. El nmero medio de
elementos examinados es la mitad de la longitud del array, y el mximo
nmero de elementos a examinar es la longitud completa. Por ejemplo, un
array uni-dimensional con 20 millones de elementos requiere que una
bsqueda lineal examine una media de 10 millones de elementos y un
mximo de 20 millones. Como este tiempo de examen podra afectar
seriamente al rendimiento, utilice la bsqueda lineal para arrays uni-
dimensionales con relativamente pocos elementos.

Bsqueda Binaria

Al igual que en la bsqueda lineal, el algoritmo de bsqueda binaria busca

un dato determinado en un array uni-dimensional. Sin embargo, al contrario
que la bsqueda lineal, la busqueda binaria divide el array en seccin
inferior y superior calculando el ndice central del array. Si el dato se
encuentra en ese elemento, la bsqueda binaria termina. Si el dato es
numricamente menor que el dato del elemento central, la bsqueda binaria
calcula el ndice central de la mitad inferior del array, ignorando la seccin
superior y repite el proceso. La bsqueda continua hasta que se encuentre
el dato o se exceda el lmite de la seccion (lo que indica que el dato no
existe en el array). El siguiente pseudocdigo demuestra este algoritmo:

DECLARE INTEGER x [] = [ -5, 12, 15, 20, 30, 72, 456 ]

DECLARE INTEGER loIndex = 0
DECLARE INTEGER hiIndex = LENGTH (x) - 1
DECLARE INTEGER midIndex, srch = 72

WHILE loIndex <= hiIndex

midIndex = (loIndex + hiIndex) / 2

IF srch > x [midIndex] THEN

loIndex = midIndex + 1
ELSE
IF srch < x [midIndex] THEN
hiIndex = midIndex - 1
ELSE
EXIT WHILE
END IF
END WHILE

IF loIndex > hiIndex THEN

PRINT srch, " not found"
ELSE
PRINT srch, " found"
END IF

END

El siguiente cdigo representa el equivalente Java del pseudocdigo

anterior:

// BSearchDemo.java

class BSearchDemo {

public static void main (String [] args) {

int [] x = { -5, 12, 15, 20, 30, 72, 456 };
 int loIndex = 0;
int hiIndex = x.length - 1;
int midIndex, srch = 72;

while (loIndex <= hiIndex) {

midIndex = (loIndex + hiIndex) / 2;
if (srch > x [midIndex])
loIndex = midIndex + 1;
else if (srch < x [midIndex])
hiIndex = midIndex - 1;
else
break;
}
if (loIndex > hiIndex)
System.out.println (srch + " not found");
else
System.out.println (srch + " found");
}
}

BSearchDemo produce la siguiente salida:

72 found

La nica ventaja de la bsqueda binaria es que reduce el tiempo empleado

en examinar elementos. El nmero mximo de elementos a examinar
es log2n (donde n es la longitud del array uni-dimensional). Por ejemplo, un
array uni-dimensional con 1.048.576 elementos requiere que la bsqueda
binaria exmine un mximo de 20 elementos. La bsqueda binaria tiene dos
inconveniemtes; el incremento de complejidad y la necesidad de pre-ordenar
el array.

Ordenacin de Burbuja

Cuando entra en juego la ordenacin de datos, la ordenacin de burbuja es

uno de los algoritmos ms simples. Este algoritmo hace varios pases sobre
un array uni-dimensional. Por cada pase, el algoritmo compara datos
adyacentes para determinar si numricamente es mayor o menor. Si el dato
es mayor (para ordenaciones ascendentes) o menor (para ordenaciones
descendientes) los datos se intercambian y se baja de nuevo por el array. En
el ltimo pase, el dato mayor (o menor) se ha movido al final del array. Este
efecto "burbuja" es el origen de su nombre. El siguiente pseudocdigo
dumuestra este algoritmo (en un contexto de ordenacin ascendente):

DECLARE INTEGER i, pass

DECLARE INTEGER x [] = [ 20, 15, 12, 30, -5, 72, 456 ]

FOR pass = 0 TO LENGTH (x) - 2

FOR i = 0 TO LENGTH (x) - pass - 2
IF x [i] > x [i + 1] THEN
SWAP x [i], x [i + 1]
END IF
NEXT i
NEXT pass
END

La siguiente figura muestra una ordenacin de burbuja ascendente de un

array uni-dimensional de cuatro elementos. Hay tres pasos, el paso 0 realiza
tres comparaciones y dos intercambios, el paso 1 realiza dos
comparaciones y un intercambio y el paso realiza una comparacin y un
intercambio.

El siguiente listado presenta el equivalente Java del pseudocdigo anterior:

// BSortDemo.java

class BSortDemo {
 public static void main (String [] args) {
int i, pass;
int [] x = { 20, 15, 12, 30, -5, 72, 456 };

for (pass = 0; pass < = x.length - 2; pass++)

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

for (i = 0; i < x.length; i++)

System.out.println (x [i]);
}
}

BSortDemo produce la siguiente salida:

-5
12
15
20
30
72
456

Aunque la ordenacin de burbuja es uno de los algoritmos de ordenacin

ms simples, tambin es uno de los ms lentos. Entre los algoritmos ms
rpidos se incluyen la ordenacin rpida y la ordenacin de pila.

Truco:

Otro algoritmo muy utilizado para arrays uni-dimensionales copia los

elementos de un array fuente en otro array de destino. En vez de escribir su
propio cdigo para realizar esta terea puede utilizar el mtodo public
static void arraycopy(Object src, int srcindex, Object dst, int dstindex,
int length)de la clase java.lang.System, que es la forma ms rpida de
realizar la copia.

Buscar Datos en Arreglo

(Metodo Busqueda
Secuencial)
CompartirTwittear

Esta vez vengo con otro post que fue otra peticion de un usuario
de Codemania que nuevamente les ago una invitacion a que se registren
dejen sus dudas en los diferentes foros de programacion o simplemente
compartan sus codigos.

Esta vez veremos un poco de java(no lo manejo a gran nivel como c# pero
me defiendo xD), en este articulo veremos como implementar
el mtodo de bsqueda secuencial para buscar un dato en un arreglo.

El mtodo de bsqueda secuencial es de los mas fciles que podemos

utilizar para buscar datos(es aconsejable utilizarlo cuando el vector no es
de gran tamao), ya que no requiere que el vector este ordenado, el mtodo
consiste en recorrer el vector de manera secuencial hasta encontrar el dato
a buscar.

El ejemplo lo desarrolle con Jcreator.

En el ejemplo creo un vector con 10 datos y luego hago la bsqueda de un

dato para saber si esta o no en el vector.

Veamos el cdigo y luego explicare lo mas importante.

/**
* 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 venta
na
}

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 delmtodo 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.
Java Arreglos Bsqueda de un valor (int)
Algoritmo lineal
Busqueda de 125: true
Busqueda de 0: true
Busqueda de 400: false

1 /**

2 * ArrayDemo.java

*
3
* Ejemplo que muestra como buscar un valor en un arreglo de nmeros enteros. Se
4 utiliza el

5 * el algoritmo lineal (o secuencial).

*/
6

7
/**
8
*
9
* @author Dark[byte]
10
*/
11
class ArrayDemo {
12

13 //un arreglo de 10 nmeros enteros desordenados

14 private static int numeros[] = { 678, 0, 39, 125, 100, 478, 6, 540, 78, 28 };

15

16 /**

17 * Punto de entrada del programa.

*
18
* @param args argumentos de la lnea de comandos.
19
*/
20
public static void main(String[] args)
21
{
22
//imprimimos en pantalla el resultado de buscar 125, 0, y 400 en el
23 arreglo

System.out.println("Busqueda de \"125\": " + busquedaLineal(numeros, 125));

24
System.out.println("Busqueda de \"0\": " + busquedaLineal(numeros, 0));
25
System.out.println("Busqueda de \"400\": " + busquedaLineal(numeros, 400));
26
}
27

28
/**
29
* Se realiza una bsqueda lineal para encontrar un valor en un
30
* arreglo de nmeros enteros.
31
*
32
* @param arreglo el arreglo donde se realizara la bsqueda.
33
* @param dato el numero entero que se buscara.
34
* @return true si el valor es encontrado, false en caso contrario.
35 */

36 static boolean busquedaLineal(int[] arreglo, int dato) {

37 for (int i = 0 ; i < arreglo.length ; i++) {

38 if (arreglo[i] == dato) {

39 return true;

}
40
}
41

42
return false;
43
}
44
}
45
https://darkbyteblog.wordpress.com/2011/04/11/java-arreglos-busqueda-de-un-valor-int-algoritmo-
46 lineal/
47

Indice de Mtodos
Mtodo de Ordenamiento
Mtodo de Ordenacin
Ejemplos
1.Mtodo de ordenamiento
Es la operacin de arreglar los elementos de un determinado vector en
algn orden secuencial
de acuerdo a un criterio de ordenamiento.
El propsito principal de un ordenamiento es el de facilitar las bsquedas
de los miembros del conjunto ordenado.

Al hablar de ordenacin nos referimos a mostrar los datos en forma

ordenada de manera que tengan un mejor orden, ya que al momento
que
el usuario ingresa los datos estos pueden ser ingresados en forma
desordenada.

Metodos de Ordenacion

1. Ordenacion por Seleccion Ordenacion por Seleccion

2. Ordenacion por Insercion

3. Bsqueda Secuencial

4. Bsqueda Binaria

5. Metodo de Intercambio Burbuja

Ordenacin por Seleccin

El proceso de la seleccin es el siguiente:

1)Captura el Nmero ms pequeo (si se desea ordenar los
elementos de
menor a mayor) o el nmero ms grande (si se desea ordenar de
mayor a menor).
2)El nmero capturado es colocado en la primera posicin,
teniendo en
cuenta que un Array empieza desde la posicin Cero.
3)El Proceso se repite para todos los datos sobrantes hasta llegar
al
ltimo de ellos.
4)Finalmente los datos quedan ordenados ya sea en forma
ascendente o
descendente..

Ordenacin por Insercin

El mtodo de ordenacin por insercin es similar al proceso tpico

de
ordenar tarjetas de nombres (cartas de una baraja) por orden
alfabtico
, que consiste en insertar un nombre en su posicin correcta dentro
de una
lista o archivo que ya est ordenado. Cada elemento a insertar es
considerado uno a la vez,
asimismo se insertan en su posicin correspondiente.

Bsqueda Secuencial

Consiste en ingresar un dato a buscar, por lo cual el programa

examina cada uno de los elementos del vector.
es decir, el elemento a buscar es comparado con cada uno de
los elementos que contiene el Array.
Si el Array tiene 100 elementos y el dato a Buscar esta en la
posicion 100, entonces se realizara 100 comparaciones puesto que
conparar hasta llegar al final del Array,
sin embargo existe la posivilidad que el elemento a buscar
no pertenesca al Array, y la busqueda sera en vano

Bsqueda Binaria

Para poder ejecutar el Mtodo de Bsqueda Binaria, se debe de

contar con un Array ordenado. El procedimiento que se realiza es el
siguiente:
EL Programa internamente selecciona el elemento central del
Array.
Si el elemento a buscar es el dato central el proceso termina. Si
el elemento a buscar no coincide con el elemento central, continua
la bsqueda:
Se subdivide en dos partes al Array.
Si el elemento a buscar es menor que el dato central, entonces
selecciona la mitad de la parte izquierda.
La parte seleccionada se subdivide nuevamente y se repite todo el
proceso.
El proceso termina cuando el dato es encontrado; teniendo en
cuenta que el dato a buscar no puede encontrarse en el Array.

Mtodo de Intercambio Burbuja

El mtodo de la Burbuja es menos eficiente puesto que realiza las

pasadas necesarias en un array hasta que el Array quede ordenado.
Su forma de ejecucin es:
En la primera pasada compara el primer elemento con el segundo
elemento.
En la misma pasada compara el segundo elemento con el tercer
elemento.
Se repite el mismo procedimiento hasta llegar al ltimo elemento.
Si una vez finalizada la primera pasada el Array sigue
desordenado, entonces se realiza una segunda pasada.
Se realiza el mismo procedimiento en la segunda pasada.
Se repiten las pasadas necesarias hasta que el Array quede
completamente ordenado.

Ejemplos
Ordenacion
int i,j,n;
double aux,x[];
System.out.println("Ingrese la cantidad de numeros a leer:");
n= Integer.parseInt(br.readLine());
x= new double[n];
for (i=0;i<n;i++){
System.out.println("Elemento["+i+"]:");
x[i]=Double.parseDouble(br.readLine());} for(i=1;i<n;i++){
for(j=n-1;j>=i;j--){
if (x[j-1]>x[j]){
aux=x[j-1];
x[j-1]=x[j];
x[j]=aux;}
}
}
System.out.println("Elemento Ordenado");
for (i=0;i<n;i++){
System.out.println("Elemento["+i+"]:"+x[i]);}
}
}</n;i++){
</n;i++){
</n;i++){

Metodo De Busqueda
int i,n,band;
double x[],elem;
System.out.println("Ingrese los numeros a leer:");
n=Integer.parseInt(br.readLine());
x=new double[n];
System.out.println("Ingrese los elementos del vector:");
for(i=0;i<n;i++){
System.out.println("Elemento["+i+"]:");
x[i]=Double.parseDouble(br.readLine());
} System.out.println("Ingrese el elemento a buscar:");
elem=Double.parseDouble(br.readLine());
band=0;
for(i=0;i<n;i++){
if(x[i]==elem){
System.out.println("El elemento encontrado:"+i);
band=1;
}
}
if(band==0){
System.out.println("No se encontro el elemento:");
}
}</n;i++){
</n;i++){

Media Geometrica
double media[]= new double[999];
double can,sum=1,resul=0;
can=Double.parseDouble(JOptionPane.showInputDialog(null,"Ingre
 se Cantida De Elementos: "));
for(int i=0;i<can;i++)
{
media[i]=Double.parseDouble(JOptionPane.showInputDialog(null,"I
ngrese Datos a la Media"));
sum=sum*media[i];
} resul=Math.pow(sum, 1.0/can);
System.out.println("La Media Es Geometrica :"+resul);
}}

</can;i++)

http://programandoconjava.es.tl/Metodos-De-Busqueda-y-Orenacion.htm

A lo largo del tiempo, varias tcnicas identificadas han llevado a proponer algoritmos eficientes para la
resolucin de problemas tpicos en el area de computacin. Entre esos problemas se encuentran el de
bsqueda en un conjunto de datos y el de ordenamiento. Es importante recalcar que cada algoritmo tiene un
nivel de eficiencia diferente, y es importante poder determinar, dadas las caractersticas de un problema en si,
y de las entradas que van a ser procesadas, cual es el algoritmo ms ptimo a ser utilizado.

1.5.1. Algoritmos de
Bsqueda
El ser humano desarrolla un sinnmero de actividades, muchas de las cuales requieren que la recopilacin
de elementos que en ellas se emplean esten ordenados de una determinada manera. Una empresa, por
ejemplo, constantemente necesita realizar bsquedas relacionadas con los datos de sus empleados o
clientes; buscar informacin de un elemento en una lista.

El problema de la bsqueda radica en la recuperacin de la informacin lo ms rpidamente posible.

Consiste en localizar un elemento en una lista o secuencia de elementos.

La operacin de bsqueda puede llevarse a cabo sobre elementos ordenados o sobre elementos
desordenados. En el primer caso, la bsqueda se facilita, y por lo tanto se ocupar menos tiempo que si se
trabaja con elementos desordenados.

Los mtodos de bsqueda pueden clasificarse en internos y externos, dependiendo el lugar donde estn
almacenados los datos sobre los cuales se har la bsqueda. Se denomina:

Bsqueda interna si todos los elementos se encuentran en memoria principal (por ejemplo, almacenados
en arreglos, vectores o listas enlazadas).

Bsqueda externa si los elementos se encuentran en memoria secundaria. (Ya sea disco duro, disquete,
cintas magnticas, CDs, memorias flash).

A continuacin nos centraremos en la bsqueda interna. As, la organizacin de los datos sobre la que
resolveremos el problema de la bsqueda consiste en un arreglo de n elementos de tipo elemento (valores
puntuales, registros, etc.); Es necesario que los n elementos sean distintos. Si existen elementos iguales, al
realizar la bsqueda se localiza nicamente uno de ellos, pudiendo dar lugar a errores al no contener la
informacin correcta que se quera recuperar.

Cada algoritmo de bsqueda procura localizar en un arreglo un elemento X. Una vez finalizada la bsqueda
puede suceder:

Que la bsqueda haya tenido xito, habiendo localizado la posicin donde estaba almacenado el
elemento X.
Que la bsqueda no haya tenido xito, concluyendo que no exista ningn elemento X.

Despus de la bsqueda sin xito, a veces es interesante introducir el elemento X. Un algoritmo con tal
objetivo se denomina de bsqueda e insercin

1.5.1.1. Bsqueda Secuencial

La bsqueda secuencial o lineal, consiste en recorrer y examinar cada uno de los elementos del arreglo,
mediante un bucle voraz de izquierda a derecha, hasta encontrar el o los elementos buscados, o hasta que se
han evaluado todos los elementos del arreglo.

El algoritmo implementado en java es el siguiente:

public class Busqueda {

/*** Busca secuencialmente un valor en el arreglo
* ORDEN(N) EN EL PEOR CASO
* @param valor
* valor a buscar
* @param arreglo
* arreglo de datos en cualquier orden
* @return true si lo encuentra, false si no encuentra el valor
*/
public boolean buscarSecuencial(int valor, int[] arreglo) {

boolean encontrado = false;

int i = 0;

int n = arreglo.length;

while (i < n && !encontrado) {

o if (arreglo[i] == valor)

encontrado = true;

o else {

i++;
 }

return encontrado;

El programa principal que invoca este mtodo de bsqueda sera:

public class ClienteMain {

public static void main(String[] args) {

o Busqueda b = new Busqueda();

o int[] arreglo = { 1, 2, 3, 4, 5, 6, 8, 9 };

o System.out.println(b.secuencial(5, arreglo));

Complejidad computacional de la bsqueda

secuencial
El mejor caso, se produce cuando el elemento a buscado sea el primero que se examina, de modo ques slo
se necesita una comparacin. En el peor caso, el elemento deseado es el ltimo que se examina, de modo
ques se necesitan n comparaciones. En el caso medio, se encontrar el elemento deseado
aproximadamente en el centro de la coleccin, haciendo n/2 comparaciones
Su complejidad es:

http://etherpad.proyectolatin.org/up/bb75f1bf793ae51ce57d5ceabb023f51.
complejidad_busqueda_lineal

Concluimos entonces que:

Para el mejor caso T(n) = O(1)

Para el caso Promedio y Peor caso T(n) = O(n)

1.5.1.2. Bsqueda Binaria
Si los elementos sobre los que se realiza la bsqueda estn ordenados, entonces podemos utilizar un
algoritmo de bsqueda mucho ms rpido que el secuencial: la bsqueda binaria. Consiste en reducir en cada
paso el mbito de bsqueda a la mitad de los elementos, basndose en comparar el elemento a buscar con el
elemento que se encuentra en la mitad del intervalo y con base en esta comparacin:

Si el elemento buscado es menor que el elemento medio, entonces sabemos que el elemento est en la mitad
inferior de la tabla.
Si es mayor es porque el elemento est en la mitad superior.
Si es igual se finaliza con xito la bsqueda ya que se ha encontrado el elemento.

Si se vuelve a repetir el mismo proceso anterior con la parte del arreglo que no hemos descartado, iremos
avanzando rpidamente hacia el valor que queremos localizar.
Puede darse el caso en el que el sub-arreglo a dividir est vaco y an no se a encontrado el elemento. Sobre
entendemos que el valor buscado no existe en el arreglo.

El algoritmo implementado en java es el siguiente:

public class Busqueda {

/*ORDEN (LOG N) EN EL PEOR CASO Y CASO MEDIO. ORDEN(1) EN EL MEJOR *CASO

* @param valor
* valor que estamos buscando
* @param arreglo
* arreglo ordenado de datos
* @return true cuando lo encuentra, false cuando no encuentra el dato a
* buscar
*/

public boolean binaria(int valor, int[] arreglo) {

boolean encontrado = false;
int inicio = 0;
int fin = arreglo.length - 1;
while (inicio <= fin && !encontrado) {
int medio = (inicio + fin) / 2;
if (arreglo[medio] == valor) {
encontrado = true;
}
else {
if (arreglo[medio] > valor)
fin = medio - 1;
else
inicio = medio + 1;
}
}
return encontrado;
}

El programa principal que invoca este mtodo de bsqueda sera:

public class ClienteMain {

public static void main(String[] args) {
Busqueda b = new Busqueda();
int[] arreglo = { 1, 2, 3, 4, 5, 6, 8, 9 };
System.out.println(b.binaria(5, arreglo));
}
}

Complejidad de la bsqueda binaria

El algoritmo determina en qu mitad est el elemento y descarta la otra mitad. En cada divisin, el algoritmo
hace una comparacin. El nmero de comparaciones es igual al nmero de veces que el algoritmo divide el
array por la mitad. Si se supone que n es aproximadamente igual a 2k entonces k k + 1 es el nmero de
veces que n se puede dividir hasta tener un elemento encuadrado en (k = log2 n). Su funcin de complejidad
es:

Por consiguiente el algoritmo es O(log2n) en el peor de los casos. En el caso medio O(log2n) en el caso
medio y O(1) en el mejor de los casos.

En general, este mtodo realiza log2 (n) comparaciones antes de encontrar el elemento, o antes de descubrir
que no est. Este nmero es muy inferior que el necesario para la bsqueda lineal para casos grandes.

Versin recursiva de la bsqueda binaria

Su nica novedad es que despus de comparar el elemento de bsqueda con el elemento de la mitad de la
tabla, se invoca recursivamente a realizar la bsqueda en uno de los dos posibles intervalos, el inferior o el
superior, finalizando en el momento en el que se encuentre el elemento o ya se tenga un nico elemento y no
coincida con el buscado.

public int BinariaRecursiva(int [] A, int X, int fin, int inicio)

{
int medio;
if (inicio > fin) return -1;
else{
medio = (inicio + fin) / 2;
if (A[medio] > X)
return BinariaRecursiva(A, X, medio+1, fin);
else
if (A[medio] > X)
return BinariaRecursiva(A, X, inicio, medio -1);
else
return medio;
}
}

Complejidad de la bsqueda binaria recursiva

Para medir la velocidad de clculo del algoritmo de bsqueda binaria, se debern obtener el nmero de
comparaciones que realiza el algoritmo, es decir, el nmero de vueltas del ciclo o el nmero de recursiones.
Aunque en principio puede parecer que ambas versiones invierten el mismo tiempo, la recursiva es ms lenta
a medida que se incrementa el nmero de elementos, ya que existirn ms llamadas a la funcin por resolver,
con el consiguiente gasto de tiempo de guardar y restaurar parmetros.

En el mejor caso, la bsqueda binaria podra toparse con el elemento buscado en el primer punto medio,
requirindose slo una comparacin de elementos. Esto equivale al mejor caso durante una bsqueda
secuencial, pero en el peor de los casos la bsqueda binaria es mucho ms rpida cuando N es grande.

El algoritmo de bsqueda binaria progresivamente va disminuyendo el nmero de elementos sobre el que

realizar la bsqueda a la mitad: n, (n/2), (n/4), ... As, tras log2(N) divisiones se habr localizado el elemento o
se tendr la seguridad de que no estaba.

Mejor Caso: En sus casos ptimos, tanto la bsqueda secuencial como la binaria requieren slo una
comparacin; esto significa que sus tiempos de ejecucin ptimos no dependen de la cantidad de datos: son
constantes y por tanto proporcionales a 1, es decir, son de O(1).

Peor Caso: En el peor caso, la bsqueda secuencial y la binaria s dependen de N. La primera recorre todo el
arreglo, requiriendo un tiempo de O(n); la binaria divide el arreglo, requiriendo slo un tiempo O(log n).

1.5.1.3. Bsqueda Hash

La bsqueda binaria proporciona un medio para reducir el tiempo requerido para buscar en una lista. Este
mtodo, sin embargo, exige que los datos estn ordenados y siempre depende del nmero n de elementos
que conforman el conjunto de datos.

Surge entonces una pregunta, es posible lograr una bsqueda de O(1)?, es decir, una bsqueda que tome
el mismo tiempo para buscar cualquier elemento de una lista. La respuesta es s. Para ello se utiliza la tcnica
hashing.Este mtodo se conoce como transformacin de claves (clave-direccin) y consiste en convertir el
elemento almacenado (numrico o alfanumrico) en una direccin (ndice) dentro de un arreglo, de manera
que se puede acceder al elemento directamente.

Ejemplo.

Vamos a partir de un sencillo ejemplo. Supongamos que tenemos una lista de empleados de una pequea
empresa. Cada empleado tiene asignado un nmero de identificacin de 0 hasta 99. Entonces se necesitara
un vector de tamao fijo de 100 posiciones para almacenar los empleados. Ahora, podramos tener una
relacin directa entre el valor clave de cada empleado con el ndice del arreglo. As:

De esta forma es posible acceder directamente a la informacin de cada empleado conociendo el nmero de
identificacin de cada empleado. Por ejemplo, si se quiere acceder al empleado con identificacin 3,
simplemente se utilizara la instruccin: arreglo[3].
Sin embargo, hacer esta correspondencia en la prctica no es posible, ya que generalmente los nmeros de
identificacin son nmeros largos como es el caso de los nmeros de cdula. Entonces, no sera posible
crear un arreglo tan grande para contener tal cantidad de elementos.

Qu alternativa entonces existe?

Una alternativa sencilla para no crear arreglos enormes, sera usar los dos ltimos campos del campo clave.
Por ejemplo, en el caso de la cdula utilizar los dos ltimos campos. As pues, si la cdula es 98393274, esta
cdula se almacenara en el arreglo en la posicin 74.

Para ello, se necesita tener una funcin hash, que determine, a partir del campo clave, en qu posicin del
arreglo estar cada objeto. La funcin hash, determinar el mtodo de acceso al arreglo.
En este caso, la funcin hash aplicar la operacin: CLAVE MOD 100. As por ejemplo, si la clave es
98393204, la funcin hash devolver que se debe acceder a la posicin 4 (98393204 MOD 100 = 4).

De la siguiente manera:

A continuacin se da el cdigo fuente en java de cmo sera la funcin hash:

public int funcionHash(int clave){
return clave%100;
}

El problema de esta tcnica son las colisiones, lo cual se explica a continuacin.

Colisiones
El esquema explicado anteriormente de la funcin hash, no garantiza direcciones nicas (colisiones). Por
ejemplo, para las claves 98393204 y 76236304, la funcin hash arrojara la misma posicin: 4.

Las colisiones son imposibles de evitar, lo que se debe tener en cuenta es que una buena funcin hash, debe
minimizar las colisiones extendiendo los registros uniformemente a travs de la tabla.

Existen varias alternativas para manejar las colisiones. Las cuales se explican a continuacin.

Mtodo 1: Hashing y bsqueda

Esta tcnica es sencilla, consiste en almacenar cada elemento colisionado en el siguiente espacio disponible.
Por ejemplo, si queremos almacenar nuevo registro con la clave 366702003, al aplicar la funcin hash dara la
posicin 3. Suponiendo que esta ya est ocupada, el algoritmo propone buscar el siguiente espacio disponible
(donde haya null) para poder almacenar el dato. Si la bsqueda llega al final y estn todas las posiciones
ocupadas, se debe buscar desde el principio. La Figura 3, ilustra este ejemplo, donde se puede apreciar que
la posicin 3 devuelta por la funcin hash ya est ocupada, por lo tanto, el nuevo dato debera almacenarse
en la siguiente posicin libre, en este caso, la posicin 4 (null).

Para buscar un elemento con esta tcnica, se aplica la funcin hash sobre la clave, luego se compara la clave
devuelta con la clave real. Si las claves no coinciden, se hace una bsqueda secuencial comenzando por la
siguiente posicin del array. Nuevamente, si se llega al final del vector, se sigue buscando desde el principio.

Mtodo 2: Rehashing
Si el primer clculo de la funcin hash produce una colisin, se usa la direccin transformada como entrada
para una funcin rehash y se calcula una nueva direccin. Un ejemplo de funcin rehash sencilla
sera: (Direccin ocupada + 1) mod 100. Si el resultado sigue siendo un espacio ocupado, se puede aplicar la
funcin rehashing hasta obtener un espacio disponible.

La clave 36670003 es pasada como entrada a la funcin hash, sta arroja la direccin 3, la cual en el caso
est ocupada; por lo tanto, tendra que pasar por la funcin rehashing. En este caso la funcin rehashing
devolvera la nueva direccin 4. Si el valor 4, est ocupado, se aplica la funcin rehashing hasta obtener un
espacio disponible.

Mtodo 3: mltiples espacios

Esta tercer tcnica, consiste en modificar la tabla de tal forma que en lugar de almacenar un objeto en cada
posicin, se pueda almacenar en cada espacio varios objetos. De esta forma, varias direcciones colisionadas
arrojadas por la funcin hash se pueden almacenar en el mismo espacio.
Se puede apreciar que la funcin hash devuelve la direccin 3. Como en la posicin 3 ya est almacenado
con un objeto empleado con cdula: 3353503, entonces, simplemente el nuevo objeto se encadena a ste.

La idea general de usar la clave para determinar la direccin del registro es una excelente idea, pero se debe
modificar de forma que no se desperdicie tanto espacio. Esta modificacin se lleva a cabo mediante una
funcin que transforma una clave en un ndice de una tabla y que se denomina funcin de Randomizacin o
Hash.

Si H es una funcin hash y X es un elemento a almacenar, entonces H(X) es la funcin hash del elemento y se
corresponde con el ndice donde se debe colocar X. En nuestro ejemplo, la funcin hash sera H(X)=X % 53
(funcin resto).

Los valores generados por H deben cubrir todo el conjunto de ndices de la tabla. Adems, el tamao de la
tabla debe ser un poco ms grande que el nmero de elementos que han de ser insertados, aunque queden
posiciones de la tabla sin uso.

El mtodo anterior tiene una deficiencia: suponer que dos elementos X e Y son tales que H(X) = H(Y).
Entonces, cuando un el elemento X entra en la tabla, ste se inserta en la posicin dada por su funcin Hash,
H(X). Pero cuando al elemento Y le es asignado su posicin donde ser insertado mediante la funcin hash,
resulta que la posicin que se obtiene es la misma que la del elemento X. Esta situacin se denomina colisin
o choque.

Una buena funcin Hash ser aquella que minimiza las colisiones, y que distribuya los elementos
uniformemente a travs del arreglo. Esta es la razn por la que el tamao del arreglo debe ser un poco mayor
que el nmero real de elementos a insertar, pues cuanto ms grande sea el rango de la funcin de
randomizacin, es menos probable que dos claves generen el mismo valor de asignacin o hash, es decir,
que se asigne una misma posicin a ms de un elemento.

Habr que llegar a un compromiso entre Eficiencia en Espacio-Tiempo: el dejar espacios vacos en la tabla es
una deficiencia en cuanto a espacio, mientras que reduce la necesidad de resolver los casos de choque en la
asignacin, y por lo tanto es ms eficiente en trminos de tiempo.

Una solucin al problema de las colisiones:

Zona de desbordamiento.
Se trata de mantener una zona reservada para aquellos elementos que llegan a colisionar, de manera que
cuando se produzca una colisin el elemento se va a localizar en esta zona de desbordamiento.

Al realizar la bsqueda y comprobar si el elemento buscado est en la posicin dada por su tabla hash, si esa
posicin ya est ocupada por otro elemento con el mismo valor de hashing, se seguir buscando a partir del
inicio de la zona de desbordamiento de manera secuencial, hasta encontrar el elemento o llegar al final de
dicha zona de desbordamiento.

Siguiendo con el ejemplo, para cada cdigo se obtena el residuo (resto) de su divisin por un nmero primo
(en este caso el 53). Es recomendable usar nmeros primos ya que que reduce la probabilidad de colisin al
establecer funciones del tipo: H(X) = (X % primo)

Ahora bien, cul valor primo escoger? En este ejemplo se manejan 30 cdigos, de modo que ese valor debe
ser superior a 30, y que su magnitud se acerque al doble de elementos, por ello una buena opcin era el 53 (o
tambin el 61). Valores primos muy cercanos a la cantidad original de datos da lugar a demasiadas colisiones
y un valor primo grande (por ejemplo, 97) da lugar a un considerable desperdicio de espacio (casillas vacas).

Cmo nos quedaran ubicados los elementos en el vector? Hay que tener en cuenta algo ms: como el valor
primo utilizado en la funcin de Hashing fue el 53, inicialmente el vector destino tendra 53 casillas, pero a eso
hay que agregarle las casillas de la zona de desbordamiento, de modo que habra que aumentar esas casillas
alrededor de un 25%, y en ese caso nuestro vector quedara con 53 * 1.25 = 66.25, o sea 66 casillas en total.
Las 53 primeras almacenarn los cdigos segn la posicin que resulte al aplicar la funcin de Hashing, las
13 restantes representan la zona de desbordamiento a donde irn los cdigos que colisionen.

Veamos un grfico de cmo quedaran los cdigos en ese vector:

 1.

Mostra
a) 18
b) 3
c) 100
d) 2
 ubl

/**

* Despus de la primera iteracin el elemento menor queda en la primera

*posicin del arreglo. Para ello busca el menor valor de todo el arreglo

* lo intercambia con el que queda en la primera posicin. Luego repite

* mismo proceso pero comenzando desde el segundo elemento del arreglo,

* busca el menor y lo intercambia con

*/

o public int[] Seleccion(int[] arregloSinOrdenar) {

o int[] arreglo = darCop

o intn = arreglo.length;

o // lleva la parte sin ordenar d

for(inti = 0; i < n -

intmenor = arregl

int posMenor = i;

// busca el menor de la parte s

 for(intj = i + 1; j < n;

if(arreglo[j] < men

menor = arreg

o }

o }

o // despues de haber encontrado el dato lo intercambia con

o // el que se encuentr

o inttemp = arreglo[i

o arreglo[i] = menor;

/
*
*
*/

ublic int[] darCopiaValores(int[] arreglo) {

int[] arregloNuevo = new int[arreglo.len

o for(inti = 0; i < arreglo.len

ar

*
 ublic class ClienteMain {

o public static voidmain(String[] arg

o Ordenamiento o = newOrdenamiento(

o int[] arreglo = {

o mostrar(arreglo);

o // Cambiar aqui por el algorit

/**

* @param arreglo

*/

o public static voidmostrar(int[] arreglo)

for(inti = 0; i < arreglo.length;

o Sy

o }

El algoritmo anterior funciona de la siguiente manera:

Tene
Luego, repetimos el mismo proceso pero comenzando desde el segundo elemento del arreglo.

Estudio de la complejidad:

public class Ordenamiento

/**

* Burbuja u ordenamiento por in

* @param arreglo a ser ord

*/

o public int[] burbuja(int[] arregloSinOrdenar) {

o int[] arreglo = darCop

o intn = arreglo.length;

o // controla el punto hasta el cual lleva

o // Termina cuando queda un s

for (inti = n; i > 1; i--) {

// lleva el proceso de intercambio empezando en 0 hasta

 // al punto anterior al lmite

for(intj = 0; j < i - 1; j++) {

if (arreglo[j] > arreg

int temp = arreglo[j];

arreglo[j] = arreglo[j

o }

o }

*/

o public int[] darCopiaValores(int[] arreglo) {

o int[] arregloNuevo = new int[arreglo.len

for(inti = 0; i < arreglo.len

o ar

o }

El programa principal que

 ublic classClienteMain {

o public static voidmain(String[] args

o Ordenamiento o = new Ordenamient

o int[] arreglo = {

o mostrar(arreglo);

o // Cambiar aqu por el algor

/**

* @param arreglo

*/

o public static voidmostrar(int[] arreglo)

for(inti = 0; i < arreglo.length;

o Sy

o }

*
}
El algoritmo anterior funciona de la siguiente manera:
En esta segunda iteracin podemos ver que varios elementos del arreglo han cambiado
El proceso termina cuando solo quede un elemento e

Estudio de la complejidad

El algoritmo implementado

ubl

/**

* Este metodo separa la secuencia en dos grupos: una parte con los valores

* ordenados (inicialmente con un solo elemento) y otra con los valores po

* ordenar (inicialmente todo el resto). Luego vamos pasando uno a u

* valores a la par

* @param arregloSinOrdenar

* arreglo sin ordenar. ORD

*/

o public int[] insercion(int[] arregloSinOrdenar) {

o int[] arreglo = darCopi

o int n = arreglo.length;

o // i seala la posicion del elemento que va a insertar,

o // va desplazando hacia la izquierda, casilla a cas

 o // el elemento que se encontraba inicialmen

o // hasta que encuentra la pos

for (int i = 1; i < n; i++) {

for(int j = i; j > 0

inttemp = arreglo[j];

arreglo[j] = arreglo[j

o }

o }

ublic class ClienteMain {

o public static void main(String[] ar

o Ordenamiento o = newOrdenamiento()

o int[] arreglo = {

o mostrar(arreglo);

o // Cambiar aqu por el algorit

/**

* @param arreglo

*
 */

o public static void mostrar(int[] arreglo)

o for (inti = 0; i < arreglo.length;

o Sy

o }

El algoritmo anterior funciona de la siguiente manera:

Tene

prim

segu

*Estudio de la complejidad:
El bucle externo se ejecuta
1 + 2 + + (n-1) = n(n-1)/2
pub
/**
* Realiza comparaciones entre elementos NO consecutivos, separados por u
* distancia salt El valor salt al principio es n/2 y va decreciendo en
* cada iteracin hasta llegar a valer 1. Cuando salt vale 1 se compar
* elementos consecutivos. El valor se encontrar ordenado cuando salto
* valga 1
*
*
* @param arregloSinOr
* arreglo sin ordenar
*
*/

ublic int[] shell(int[] arregloSinOrdenar) {

int[] arreglo = darCopi

int n = arregl

int salto = n;

booleanordenado;

o while(salto > 1) {

o sal

do{

ordenado = true;

for(intj = 0; j <

intk = j + salto;

if(arreglo[j] > arre

intaux = arreglo[j];

arreglo[j] = arre

arreglo[k] = aux;
 o

o }

El programa principal que

ublic class ClienteMain {

o public static void main(String[] ar

o Ordenamiento o = newOrdenamiento();

o int[] arreglo = {

o mostrar(arreglo);

o // Cambiar aqu por el alg

/**

* Muestra por co

* @param arreglo

*/

o public static voidmostrar(int[] arreglo)

for(int i = 0; i < arreglo.length;

o Sy

o }

S
*
}

*Estudio de la complejidad

El Shell sort
observaciones:
1. El ordenamiento por insercin es eficiente si la entrada est "casi ordenada".
2. El ordenamiento
El algoritmo Shell sort mejora el ordenamiento por insercin comparando elementos separados por un espacio
de varias posiciones. Esto permite que un elemento

ubl

/**

* Este mtodo de ordenacin divide el vector por la posicin central,

* ordena cada una de las mitades y despus realiza la mezcla ordenada de

* las dos mitades. El caso base es aquel que recibe un vector con ningn

* elemento,

* @param arreglo

* , arreglo

* @param ini

* , posicion

* @param fin

*/

o public vo

o intm = 0;

if(ini < fin) {

m = (ini + fin) / 2;

mergeSort(arreglo, ini, m);

 mergeSort(arreglo, m + 1, fi

o m

/**

* @param arreglo

* arreglo de

* @param ini

* posicin

* @param m

* posicin i

* @param fin

*/

o private v

o intk = 0;

o inti = ini;

o intj = m + 1;

o int n = fin - ini +

o intb[] = new int[n];

while(i <= m && j <= fin) {

if (arreglo[i] < a

b[k]

i++;
 k++;

}else {

b[k]

j++;

o }

while(i<= m) {

b[k]

i++;

o k

while(j<= fin) {

b[k]

j++;

o k

o }

for(k=0; k<n; k++) {

o a

/**

* Toma los datos para invo

 * @param

*/

o public int[] mergeSortTomaDatos(intarregloSinOrdena

o int[] arreglo = darCop

o intn = arreglo.length;

o mergeSort(arre

ublic classClienteMain {

o public static voidmain(String[] ar

o Ordenamiento o =newOrdenamiento();

o int[] arreglo = {

o mostrar(arreglo);

o // Cambiar aqu por el algoritmo de ord

/**

* @param arreglo

o public static voidmostrar(int[] arreglo)

o for(inti = 0; i < arreglo.length;

o Sy

o }

Tene
*Estudio de la complejidad
El algoritmo es recursivo esa razn que se quiere determinar el tiempo empleado por cada una de las 3 fases
del algoritmo divide y vencers. Cuando se llama a la funcin mezclista se deben mezclar las dos listas mas
pequeas en una nueva lista con n elementos. la

T(n) = n + 2T(n/2) si n>1 y 1 en otro caso. De esta forma, aplicando expansin de recurrencia se tiene:
pub
/
*
* Este algoritmo divide en array en dos subarray, que se pueden orde
* modo independiente. Se selecciona un elemento especfico del array
* arreglo[centro] llamado pivote y se divide el array original en do
* subarrays que se ordenar
*
*
* @param arreglo
* arreglo que s
* @param inicio
*posicin de inicio - ORDEN(
* ORDEN(N*N)
* @param fin
*
*/

ublic voidquickSort(int[] arreglo, intinicio,intfin) {

inti = inicio;// i siempre avanza en el arreglo ha

intj = fin; // j siempre avanza hacia la

int

o do{

while (arreglo[i] < pivote)

// s

o i++;

while (pivote < arreglo[j])

// s

o j--;

if(i <= j) {// Hace e

int aux = arreglo[i];

arreglo[i] = arre

arre

i++;

o j

}
 }

o if (inicio < j)

quickSort(a

o if(i < fin)

*
}
/**
*
*
* @param arregloSinOr
* arreglo sin ordenar
*
*/
public int[] quickSortTomaDatos(int[] arregloSinOrd
int[] arreglo = darCopiaValores(arregloSi
quickSort(arreg
re
}
/
*
*
*/
public int[] darCopiaValores(int[] arreglo) {
int[] arregloNuevo = new int[arreglo.len
for(inti = 0; i < arreglo.len
arregloNuevo[i] = arr
}
}

ublic classClienteMain {

o public static voidmain(String[] arg

o Ordenamiento o = newOrdenamiento();

o int[] arreglo = {

o mostrar(arreglo);

o // Cambiar aqui por el algoritmo de ord

m
 }

/**

* @param arreglo

*/

o public static voidmostrar(int[] arreglo)

for(inti = 0; i < arreglo.length; i

o Sy

o }

*
Estabilidad: NO es estable.
Requerimientos de Me
Tiempo de Ejecucin:
*Caso pro
f(1) = 1
f(n) = n + 2 f(n/2)
La forma cerrada de esta expresin es: f(n) = n log2n Es decir, la complejidad es O(n log2n).
*El peor
Ventajas:
El ms rpido
No requiere
Desventajas:
Implementacin un poco ms complicada.
Mucha diferencia entre el peo

Respecto al nmero de comparaciones, si el tama

Considerando que el nmero de trminos de la sumatoria(m) es igual al n

1. Dada la siguiente secuenci
a) Ordenam
b) Burbuja
c) Orden
d) Shell
e) QuickSort

2. Cuando tod
a) Inser
b) Shell
c) MergeSort

3. Cuando la
a) Inser
b) Shell
c) MergeSort

4. Cuando la
a) Inser
b) Shell
c) MergeSort

5. A continuacin se desc

a) Se recorre el vector

Primero se compara V[i] con V[i+1] para todos los valores de i pares

Luego se compara V[i] con V[i+1] para todos los valores de i impar

*Cada vez que V[i] es mayor que V[i+1] se intercambian los valores.
http://escritura.proyectolatin.org/estructura-de-datos/algoritmos-de-ordenamiento-y-busqueda/

MTODOS DE BSQUEDA

Encontrar informacin en un arreglo desordenado requiere una bsqueda secuencial

comenzando en el primer elemento y parando cuando se encuentra el elemento
buscado o cuando se alcanza el final del arreglo. Este mtodo es el que se tiene que
utilizar con datos desordenados aunque tambin se puede aplicar a datos ordenados.
Si la datos ya han sido ordenados, es ms aconsejable utilizar el algoritmo de
bsqueda binaria, que incrementa ampliamente la velocidad de bsqueda.

La bsqueda secuencial es fcil de codificar. El siguiente algoritmo busca el valor x en

el arreglo a de n elementos, retornando la ubicacin del elemento buscado o 1 si el
elemento no existe en el arreglo.
BuscaSec (a, n, x)
{
for(i=0; i <n; ++i)
if(x==a[i]) return(i);
return(-1);

La bsqueda secuencial no es la ms eficiente pero es la nica alternativa si el arreglo

se encuentra desordenado. Si los datos del arreglo se encuentran ordenados, entonces
se puede usar el mtodo de bsqueda binaria. Para encontrar el elemento buscado
se compara con el de la mitad del arreglo. Si es igual, se encontr. Si es mayor que el
elemento buscado, entonces se compara con el elemento de la mitad de la primera
mitad; en caso contrario, se comprueba el elemento de la mitad de la segunda mitad.
Este proceso se repite hasta encontrar el elemento o no queden elementos por
comprobar.

Ejemplo: Se busca 4.

Se compara con el elemento medio (5) y se descarta la segunda mitad.

1 2 3 4 5 6 7 8 9

Se compara con el elemento medio de la primera mitad (3) y s descarta la primera

mitad.

1 2 3 4 5

Se compara con el elemento medio de la segunda mitad (4) y encuentra el valor

buscado.

3 4 5
Bsqueda Hashing
El tiempo ocupado en ordenar un arreglo y buscar un elemento mediante la bsqueda
binaria es similar al de buscar secuencialmente en un arreglo desordenado, por lo cual
se cre un mtodo alternativo para trabajar con las operaciones bsicas para los datos
(ingresar, eliminar y buscar), el Hashing. Su principal caracterstica es que ingresa
cada elemento en un lugar especfico determinado por el mdulo de ste, por lo cual
cada vez que se necesite buscar un elemento slo bastar calcular su posicin por el
mismo mtodo.

Existen dos formas de Hashing distintas. El primero, llamado Hashing Cerrado, es una
estructura de datos esttica por lo cual usa un tamao fijo para el almacenamiento,
por lo que limita el tamao de los conjuntos. El segundo, llamado Hashing Abierto, es
una estructura de datos dinmica por lo cual no impone un lmite al tamao del
conjunto.

HASHING CERRADO

Existen distintos tipos de Hashing cerrados. Los ms comunes son el lineal, el doble y
el directo, y se diferencian unos de otros por la forma de resolver las colisiones.

El Hashing lineal resuelve el problema de las colisiones asignando el primer lugar

disponible recorriendo circularmente la tabla. Cuando elimina recorre toda la tabla para
asegurarse de que lo elimin. Sufre de agrupamiento primario, dado que cuando
existen colisiones la tabla crece por su corrimiento y luego cualquier insercin tendr
colisin.

El Hashing doble aplica una segunda funcin Hashing cuando se produce una colisin,
para determinar el incremento con el cual buscar la prxima posicin. Esta alternativa
requiere tablas con nmeros primos de elementos para asegurar el recorrido de todos
los lugares posibles.

El Hashing directo trabaja con un almacn auxiliar, tambin llamado OVERFLOW, en

el cual se almacenan las colisiones.

A continuacin se presentan las funciones para un Hashing lineal.

#define TRUE 1
#define FALSE 0
#define VACIO 1
struct tabla{

int llave;
int libre;
};
struct tabla tabhash[10];

int hashing(int dato)

{
return(dato%MAX);
}

void insertar (int dato)

{
int p, i;
p=hashing(dato);
if(tabhash[p].libre == VACIO)
{
tabhash[p].llave = dato;
tabhash[p].libre = !VACIO;
}
else{
i= (p+1)%MAX;
while(i!=p && i != -1)
if(tabhash[i].libre == VACIO)
{
tabhash[i].llave = dato;
tabhash[i].libre = !VACIO;
i=-1;
}
else i = ++i % MAX;
if(i==p) printf("Overflow");
}
}

int pertenece(int dato)

{
int p, i;
p=hashing(dato);
if(tabhash[p].libre != VACIO && tabhash[p].llave == dato)
return(TRUE);
else{
i= (p+1)%MAX;
while(i!=p)
if(tabhash[i].llave == dato) return(TRUE);
else i = ++i % MAX;
return(FALSE);
}
}

void eliminar(int dato)

{
int p,i;
p=hashing(dato);
if(tabhash[p].libre != VACIO && tabhash[p].llave == dato)
tabhash[p].libre = VACIO;
else{
i= (p+1)%MAX;
while(i!=p && i != -1)
if(tabhash[i].libre != VACIO && tabhash[i].llave == dato)
{
tabhash[i].libre = VACIO;
i=-1;
}
else i = ++i % MAX;
}
}

HASHING ABIERTO

El Hashing abierto maneja las colisiones generando una lista enlazada en cada una de
las posiciones de la tabla, es decir, si dos valores poseen un mismo valor para Hashing
estarn dentro de una misma lista enlazada.

Las funciones para un Hashing abierto son las siguientes.

struct nodo {
int dato;
struct nodo *sgte;
};

struct nodo *tabla[TAM];

void inittab(int talla)
{
int i;
for(i=0;i< talla;i++)
tabla[i]=NULL;
}

struct nodo *insertar(struct nodo *head, int data)

{
if(head==NULL) {
head=( struct nodo *)malloc(sizeof(struct nodo));
head->dato=data;
head->sgte=NULL;
}
else
head->sgte=insertar(head->sgte,data);
return(head);
}

hashing(int val,int largo)

{
return(val%largo);
}

http://www.angelfire.com/my/jimena/estructuras/materia6.htm