ORDENACIÓN POR BURBUJA

El método de ordenación por burbuja es el más conocido y popular entre estudiantes y

aprendices de programación, por su facilidad de comprender y programar; por el
contrario, es el menos eficiente y por ello, normalmente, se aprende su técnica pero no
suele utilizarse.
La técnica utilizada se denomina ordenación por burbuja u ordenación por
hundimiento debido a que los valores más pequeños “burbujean” gradualmente (suben)
hacia la cima o parte superior del array de modo similar a como suben las burbujas en
el agua, mientras que los valores mayores se hunden en la parte inferior del array. La
técnica consiste en hacer varias pasadas a través del array. En cada pasada, se comparan
parejas sucesivas de elementos. Si una pareja está en orden creciente (o los valores son
idénticos), se dejan los valores como están. Si una pareja está en orden decreciente, sus
valores se intercambian en el array.

Algoritmo de la burbuja

En el caso de un array (lista) con n elementos, la ordenación por burbuja requiere hasta
n-1 pasadas. Por cada pasada se comparan elementos adyacentes y se intercambian sus
valores cuando el primer elemento es mayor que el segundo elemento. Al final de cada
pasada, el elemento mayor ha “burbujeado” hasta la cima de la sublista actual. Por
ejemplo, después que la pasada 0 está completa, la cola de la lista a[n-1] está ordenada
y el frente de la lista permanece desordenado. Las etapas del algoritmo son :

• En la pasada 1 se comparan elementos adyacentes

(a[0],a[1]),(a[1],a[2]),(a[2],a[3]),...(a[n-2],a[n-1])

Se realizan n-1 comparaciones, por cada pareja (a[i],a[i+1]) se intercambian

los valores si a[i+1] < a[i].
Al final de la pasada, el elemento mayor de la lista está situado en a[n-1] .
• En la pasada 2 se realizan las mismas comparaciones e intercambios, terminando
con el elemento de segundo mayor valor en a[n-2] .
• El proceso termina con la pasada n-1, en la que el elemento más pequeño se
almacena en a[0] .

El algoritmo tiene una mejora inmediata, el proceso de ordenación puede terminar en la

pasada n-1, o bien antes, si en un una pasada no se produce intercambio alguno entre
elementos del array es porque ya está ordenado, entonces no es necesario mas pasadas.
El ejemplo siguiente ilustra el funcionamiento del algoritmo de la burbuja con un array
de 5 elementos (A = 50, 20, 40, 80, 30) donde se introduce una variable
interruptor para detectar si se ha producido intercambio en la pasada.

Pasada 1 50 20 40 80 30 Intercambio 50 y 20

20 50 40 80 30 Intercambio 50 y 40
 20 40 50 80 30 50 y 80 ordenados

20 40 50 80 30 Intercambio 80 y 30

• Elemento mayor es 80
20 40 50 30 80 • interruptor = TRUE

Pasada 2

20 40 50 30 80 20 y 40 ordenados

20 40 50 30 80 40 y 50 ordenados

20 40 50 30 80 Se intercambian 50 y 30

• 50 y 80 elementos mayores y ordenados

20 40 30 50 80 • interruptor = TRUE

Pasada 3

20 40 30 50 80 20 y 40 ordenados

• Se intercambian 40 y 30
20 30 40 50 80 • interruptor = TRUE

Pasada 4

20 30 40 50 80 20 y 30 ordenados

• Lista ordenada
20 30 40 50 80 • interruptor = FALSE

En consecuencia, el algoritmo de ordenación de burbuja mejorado contempla dos

bucles anidados: el bucle externo controla la cantidad de pasadas (al principio de la
primera pasada todavía no se ha producido ningún intercambio por tanto la variable
interruptor se pone a valor falso(false); el bucle interno controla cada pasada
individualmente y cuando se produce un intercambio, cambia el valor de interruptor
a verdadero (true).
 El algoritmo terminará, bien cuando se termine la última pasada (n-1) o bien cuando el
valor del interruptor sea falso, es decir no se haya hecho ningún intercambio.

Codificación del algoritmo de la burbuja

El método ordBurbuja() implementa el algoritmo de ordenación de la burbuja, tiene

como argumento el array que se va a ordenar crecientemente. El intercambio de dos
elementos se realiza llamando al método void intercambiar(long []a, int i,
int j). Se ha elegido entero largo (long) como tipo de los elementos del array.

public static void ordBurbuja (long a[])

{
boolean interruptor = true;
int pasada, j;
int n = a.length;
// bucle externo controla la cantidad de pasadas
for (pasada = 0; pasada < n-1 && interruptor; pasada++)
{
interruptor = false;
for (j = 0; j < n-pasada-1; j++)
if (a[j] > a[j+1])
{
// elementos desordenados, se intercambian
interruptor = true;
intercambiar(a, j, j+1);
}
}
}

Una mejora del algoritmo anterior consiste en utilizar, en lugar de una variable
bandera interruptor, una variable indiceIntercambio que se inicie a 0 al principio
de cada pasada y se establezca al índice del último intercambio, de modo que cuando al
terminar la pasada el valor de indiceIntercambio siga siendo 0 implicará que no se ha
producido ningún intercambio (o bien, que el intercambio ha sido con el primer
elemento) , y, por consiguiente, la lista estará ordenada. En caso de no ser 0, el valor de
indiceIntercambio representa el índice del array a partir del cual los elementos están
ordenados. La codificación de esta alternativa:
public static void ordBurbuja2 (long a[])
{
int i, j;
int indiceIntercambio;
int n = a.length;
i = n-1;
while (i > 0)
{
indiceIntercambio = 0;
// explorar la sublista a[0] a a[i]
for (j = 0; j < i; j++)
if (a[j+1] < a[j])
{
indiceIntercambio = j;
intercambiar(a, j, j+1);
}
i = indiceIntercambio;
}
}
Análisis del algoritmo de la burbuja

¿Cuál es la eficiencia del algoritmo de ordenación de la burbuja ? Dependerá de la

versión utilizada. En la versión más simple se hacen n-1 pasadas y n-1 comparaciones
en cada pasada. Por consiguiente, el número de comparaciones es (n-1) * (n-1) = n2 - 2n
+ 1, es decir la complejidad es 0(n2).
Si se tienen en cuenta las versiones mejoradas, haciendo uso de las variables
interruptor o indiceIntercambio, entonces se tendrá una eficiencia diferente a cada
algoritmo. En el mejor de los casos, la ordenación de burbuja hace una sola pasada en el
caso de una lista que ya está ordenada en orden ascendente y por tanto su complejidad
es 0(n). En el caso peor se requieren (n-i-1) comparaciones y (n-i-1) intercambios. La
n( n − 1)
ordenación completa requiere comparaciones y un número similar de
2
intercambios. La complejidad para el caso peor es 0(n2) comparaciones y 0(n2)
intercambios.
De cualquier forma, el análisis del caso general es complicado dado que alguna de las
pasadas pueden no realizarse. Se podría señalar que el número medio de pasadas k es
0(n) y el número total de comparaciones es 0(n2). En el mejor de los casos, la
ordenación por burbuja puede terminar en menos de n-1 pasadas pero requiere,
normalmente, muchos más intercambios que la ordenación por selección y su prestación
media es mucho más lenta, sobre todo cuando los arrays a ordenar son grandes.

A tener en cuenta
Los algoritmos de ordenación interna: intercambio, selección, inserción y burbuja son
fáciles de entender y de codificar, sin embargo poco eficientes y no recomendables para
ordenar listas de muchos elementos. La complejidad de todos ellos es cuadrática, 0(n2).

EJERCICIO 1

Con el fin de medir el tiempo en milisegundos que emplea en ordenar un computador

utilizando los métodos: intercambio, selección, inserción y burbuja, se desea escribir
un programa que genere un array de 1000 elementos obtenidos al azar, se ordene
aplicando cada uno de los algoritmos y mida el tiempo empleado por el computador.

La clase MetodosBasicosOrdenacion dispone de los métodos de ordenación que han

sido implementados, todos para arrays de tipo int. Al ser métodos static no se crea un
objeto de la clase, directamente se llama al método con el cualificador de la clase.
El método main() define el array, asigna elementos aleatorios llamando al método
Math.random(), llama a cada método de ordenación. Para determinar el tiempo de
ordenación se utiliza System.currentTimeMillis()(devuelve tiempo en
milisegundos) antes y después de cada llamada al método de ordenación, la diferencia
es el tiempo transcurrido.

import ordenainterna.MetodosBasicosOrdenacion;
import java.io.*;

public class OrdenaInterna

{
 public static void main(String args[])
{
final int M = 10000;
int [] v = new int [M];
int [] c = new int [M];
long k1, k2;

entrada(v);
System.arraycopy(v,0,c,0,v.length);
k1 = System.currentTimeMillis();
OrdenacBasica.ordIntercambio(c);
k2 = System.currentTimeMillis();
System.out.println("\nTiempo ordenación por intercambio: "
+ (k2 - k1));
System.arraycopy(v,0,c,0,v.length);
k1 = System.currentTimeMillis();
OrdenacBasica.ordInsercion(c);
k2 = System.currentTimeMillis();
System.out.println("\nTiempo ordenación por inserción: "
+ (k2 - k1));
System.arraycopy(v,0,c,0,v.length);
k1 = System.currentTimeMillis();
OrdenacBasica.ordBurbuja(c);
k2 = System.currentTimeMillis();
System.out.println("\nTiempo ordenación por burbuja: "
+ (k2 - k1));
System.arraycopy(v,0,c,0,v.length);
k1 = System.currentTimeMillis();
OrdenacBasica.ordBurbuja2(c);
k2 = System.currentTimeMillis();
System.out.println("\nTiempo ordenación por burbuja(2): "
+ (k2 - k1));

System.arraycopy(v,0,c,0,v.length);
k1 = System.currentTimeMillis();
OrdenacBasica.ordSeleccion(c);

k2 = System.currentTimeMillis();
System.out.println("\nTiempo ordenación por seleccion: "
+ (k2 - k1));
}
static void entrada(int [] w)
{
int SUP =9999;
for (int i = 0; i< w.length; i++)
w[i] = (int)(Math.random() * SUP + 1);
}
}
MÉTODOS DE ORDENACIÓN BINSORT Y RADIXSORT

Estos métodos de ordenación utilizan urnas para depositar en ellas los registros en el
proceso de ordenación. En cada recorrido de la lista a ordenar se deposita en una urnai
aquellos registros cuya clave tienen una cierta correspondencia con el índice i .

Método de ordenación Binsort (ordenación por urnas)

Este método, también llamado clasificación por urnas, se propone conseguir funciones
tiempo de ejecución de complejidad menor de O(n log n) para ordenar una lista de n
elementos, siempre que se conozca alguna relación del campo clave de los elementos
respecto de las urnas.
Dado un array v[]de registros, se desea ordenar respecto un campo clave de tipo
entero, además se sabe que los valores de las claves se encuentran en el rango de 1 a n,
sin claves duplicadas y siendo n el número de elementos. En estas circunstancias
ideales es posible ubicar los registros ordenados en un array auxiliar t[] mediante este
único bucle:
for i = 1 to n do
t[v[i].clave]= v[i];

Sencillamente, determina la posición del registro que le corresponde según el valor

del campo clave. El bucle lleva un tiempo de ejecución de complejidad lineal O(n).
Esta ordenación tan sencilla que se ha expuesto es un caso particular del método de
ordenación por urnas (binsort). Este método utiliza urnas, cada urna contiene todos los
registros con una misma clave.
El proceso consiste en examinar cada registro r a clasificar y situarle en la urna i,
coincidiendo i con el valor del campo clave de r. En la mayoría de los caso en que se
utilice el algoritmo será necesario guardar más de un registro en una misma urna por
tener claves repetidas. Entonces estas urnas hay que concatenarlas en el orden de menor
índice de urna a mayor, así quedará el array en orden creciente respecto al campo clave.
En la Figura 6.3 se muestra un vector de m urnas. Las urnas están representadas por
listas enlazadas.

Urnas

1 R1 R1 R1

2 R2 R2 R2

R3 R3 R3

m Rm Rm Rm

Figura 6.3 Estructura formada por m urnas

Algoritmo de ordenación Binsort.

El algoritmo se aplica sobre listas de registros con un campo clave cuyo rango de
valores es relativamente pequeño respecto al número de registros. Normalmente el
campo clave es de tipo entero, en el rango 1 .. m. Son necesarias m urnas por ello se
declara un vector de m urnas. Las urnas se representan mediante listas enlazadas, cada
elemento de la lista contiene un registro cuyo campo clave se corresponde con el índice
de la urna en la que se encuentra, normalmente la clave será igual al índice de la urna.
Así en la urna 1 se sitúan los registros cuyo campo clave es 1, en la urna 2 los registros
cuyo campo clave es 2, y así sucesivamente en la urna i se sitúan los registros cuyo
campo clave es igual a i .
La primera acción del algoritmo consiste en distribuir los registros en las diversas
urnas. Una vez realizada la distribución, es necesario concatenar las listas enlazadas
para formar un única lista con los registros en orden creciente; por último, se recorre la
lista asignando cada nodo al vector, y de esa manera el vector de registros queda en
orden respecto al campo clave. La Figura 6.4 se muestra cómo realizar la
concatenación.

R1 R1 R1

R2 R2 R2

R3 R3 ... R3

Rm Rm Rm

Figura 6.4 Concatenación de urnas representadas por listas enlazadas.

Los pasos que sigue el algoritmo expresado en seudocódigo para un vector de n

registros:
OrdenacionBinsort(vector, n)
inicio
CrearUrnas(Urnas);
{Distribución de registros en sus correspondientes urnas}
desde j = 1 hasta n hacer
AñadirEnUrna(Urnas[vector[j].clave], vector[j]);
fin_desde
{Concatena las listas que representan a las urnas
desde Urnai hasta Urnam}
i = 1; {búsqueda de primera urna no vacía}
mientras EsVacia(Urnas[i]) hacer
i = i+1
fin_mientras
desde j = i+l a m hacer
EnlazarUrna(Urnas[i], Urnas[j]);
fin_desde
{recorre las lista(urnas) resultado de la concatenación}
j = 1;
dir = <frente Urnas[i]>;
 mientras dir <> nulo hacer
vector[j] = <registro apuntado por dir>;
j = j+i;
dir = Sgte(dir)
fin_mientras
fin

Método de ordenación RadixSort (ordenación por residuos)

Este método de ordenación es un caso particular del algoritmo de clasificación por

urnas. La idea intuitiva de método de ordenación por residuos se encuentra en los pasos
que se siguen a la hora de ordenar, de forma manual, un conjunto de fichas; consiste en
formar diversos montones de fichas, cada uno caracterizado por tener sus componentes
un mismo dígito (letra, si es ordenación alfabética) en la misma posición, inicialmente
primera posición que son las unidades; estos montones se recogen en orden ascendente,
desde el montón del dígito 0 al montón del dígito 9. Entonces las fichas están ordenadas
respecto a las unidades. A continuación se vuelve a distribuir las fichas en montones,
según el dígito que esté en la segunda posición (decenas). El proceso de distribuir las
fichas por montones y posterior acumulación en orden se repite tantas veces como
número de dígitos tiene la ficha de mayor valor.
Se desea ordenar la siguiente lista de fichas, aplicando los pasos del algoritmo
RadixSort; las fichas están identificadas por un campo entero de tres dígitos:

345, 721, 425, 572, 836, 467, 672, 194, 365, 236, 891, 746, 431,

834, 247, 529, 216, 389

Atendiendo al dígito de menor peso (unidades) las fichas se distribuyen en montones

del 0 al 9:
216
431 365 746
891 672 834 425 236 247 389
721 572 194 345 836 467 529
1 2 4 5 6 7 9

Recogiendo los montones en orden ascendente la lista de fichas es la siguiente:

721, 891, 431, 572, 672, 194, 834, 345, 425, 365, 836, 236, 746, 216,
467, 247, 529, 389

Esta lista ya está ordenada respecto al dígito de menor peso, respecto a las unidades.
Pues bien, ahora de nuevo se distribuye la secuencia de fichas en montones respecto al
segundo dígito:

236
529 836 247
425 834 746 467 672 194
216 721 431 345 365 572 389 891
1 2 3 4 6 7 8 9

Recogiendo los montones en orden ascendente, la lista de fichas es la siguiente:

 216, 721, 425, 529, 431, 834, 836, 236, 345, 746, 247, 365, 467, 572,
672, 389, 891, 194

En este momento las fichas ya están ordenadas respecto a los dos últimos dígitos, es
decir respecto a las decenas. Por último, se distribuye las fichas en montones respecto
al tercer dígito:

247 389 467 891

236 365 431 572 746 836
194 216 345 425 529 672 721 834
1 2 3 4 5 6 7 8

Recogiendo de nuevo los montones en orden ascendente, la lista de fichas ya está

ordenada:
194, 216, 236, 247, 345, 365, 389, 425, 431, 467, 529, 572, 672, 721,
746, 834, 836, 891

Algoritmo de ordenación RadixSort.

La idea clave de la ordenación RadixSort es clasificar por urnas, primero respecto al

dígito de menor peso, (unidades); después respecto al dígito del siguiente peso
(decenas), y así sucesivamente se continúa hasta alcanzar el dígito más significativo.
Una vez terminada la clasificación respecto al dígito mas significativo la lista está
ordenada. En cada paso hay que unir las urnas en orden ascendente, desde la urna 0 a la
urna 9; consiste, simplemente, en enlazar el final de una urna con el frente de la
siguiente.
Al igual que en el método de BinSort, las urnas se representan mediante un array de
listas enlazadas. Se ha de disponer de tantas urnas como dígitos, 10 urnas, numeradas
de 0 a 9. Si la clave respecto a la que se ordena es alfabética, habrá tantas urnas como
letras distintas, desde la urna que representa a la letra a hasta la z.
El algoritmo que se escribe, en primer lugar determina el número máximo de dígitos
que puede tener una clave. Un bucle de tantas iteraciones como el máximo de dígitos,
realiza las acciones de distribuir por urnas los registros, concatenar...
La distribución por urnas exige obtener el dígito del campo clave que se encuentra en la
posición definida por el bucle externo, dicho dígito será el índice de la urna.

OrdenacionRadixsort(vector, n)
inicio
{ cálculo el número máximo de dígitos: ndig }
ndig = 0;
temp = maximaClave;
mientras (temp > 0) hacer
ndig = ndig+1
temp = temp / 10;
fin_mientras
peso =1 { permite obtener los dígitos de menor a mayor peso}
desde i = 1 hasta ndig hacer
CrearUrnas(Urnas);
desde j = 1 hasta n hacer
d = (vector[j] / peso) modulo 10;
AñadirEnUma(Urnas[d], vector[j]);
fin_desde
{ búsqueda de primera urna no vacía: j }
desde r = j+1 hasta M hace { M: número de urnas }
 EnlazarUma(Urnas[r], Urnas[j]);
fin_desde
{Se recorre la lísta-urna resultante de la concatenación}
r = 1;
dir = frente(Urna[j]);
mientras dir <> nulo hacer
vecto[r] = dir.registro;
r = r+1;
dir = siguiente(dir)
fin_mientras
peso = peso * 10;
fin_desde
fin_ordenacion
Métodos de ordenación básicos

package ordenainterna;

public class MetodosBasicosOrdenacion

{
public static void intercambiar(int []a, int i, int j)
{
int aux = a[i];
a[i] = a[j];
a[j]= aux ;
}
public static void intercambiar(long []a, int i, int j)
{
long aux = a[i];
a[i] = a[j];
a[j]= aux ;
}
public static void intercambiar(double[]a, int i, int j)
{
double aux = a[i];
a[i] = a[j];
a[j]= aux ;
}

public static void ordIntercambio (int a[])

{
int i, j;

for (i = 0 ; i < a.length-1; i++)

// sitúa mínimo de a[i+1]...a[n-1] en a[i]
for (j = i+1 ; j < a.length; j++)
if (a[i] > a[j])
{
intercambiar(a, i, j);
}
}

public static void ordInsercion (int [] a)

{
int i, j;
int aux;

for (i = 1; i < a.length; i++)

{
/* indice j es para explorar la sublista a[i-1]..a[0]
buscando la posicion correcta del elemento destino*/
j = i;
aux = a[i];
// se localiza el punto de inserción explorando hacia abajo
while (j > 0 && aux < a[j-1])
{
// desplazar elementos hacia arriba para hacer espacio
a[j] = a[j-1];
j--;
}
a[j] = aux;
}
}
 public static void ordBurbuja (int a[])
{
boolean interruptor = true;
int pasada, j;
int n = a.length;
// bucle externo controla la cantidad de pasadas
for (pasada = 0; pasada < n-1 && interruptor; pasada++)
{
interruptor = false;
for (j = 0; j < n-pasada-1; j++)
if (a[j] > a[j+1])
{
// elementos desordenados, se intercambian
interruptor = true;
intercambiar(a, j, j+1);
}
}
}

public static void ordBurbuja2 (int a[])

{
int i, j;
int indiceIntercambio;
int n = a.length;

i = n-1;
while (i > 0)
{
indiceIntercambio = 0;
// explorar la sublista a[0] a a[i]
for (j = 0; j < i; j++)
if (a[j+1] < a[j])
{
indiceIntercambio = j;
intercambiar(a, j, j+1);
}
i = indiceIntercambio;
}
}

public static void ordSeleccion (int a[])

{
int indiceMenor, i, j, n;

n = a.length;
// ordenar a[0]..a[n-2] y a[n-1] en cada pasada
for (i = 0; i < n-1; i++)
{
// comienzo de la exploración en índice i
indiceMenor = i;
// j explora la sublista a[i+1]..a[n-1]
for (j = i+1; j < n; j++)
if (a[j] < a[indiceMenor])
indiceMenor = j;
// sitúa el elemento mas pequeño en a[i]
if (i != indiceMenor)
intercambiar(a, i, indiceMenor);
}
}

}
Métodos de ordenación Shell
public static void ordenacionShell(double a[])
{
int intervalo, i, j, k;
int n= a.length;

intervalo = n / 2;
while (intervalo > 0)
{
for (i = intervalo; i < n; i++)
{
j = i - intervalo;
while (j >= 0)
{
k = j + intervalo;
if (a[j] <= a[k])
j = -1; // par de elementos ordenado
else
{
intercambiar(a, j, j+1);
j -= intervalo;
}
}
}
intervalo = intervalo / 2;
}
}
Método de ordenación quicksort
public static void quicksort(double a[])
{
quicksort(a, 0, a.length-1);
}

private static void quicksort(double a[], int primero, int ultimo)

{

int i, j, central;
double pivote;

central = (primero + ultimo)/2;

pivote = a[central];
i = primero;
j = ultimo;

do {
while (a[i] < pivote) i++;
while (a[j] > pivote) j--;

if (i <= j)
{
intercambiar(a, i, j);
i++;
j--;
}
}while (i <= j);

if (primero < j)
quicksort(a, primero, j); // mismo proceso con sublista izqda

if (i < ultimo)
quicksort(a, i, ultimo); // mismo proceso con sublista drcha
}

Capítulo 6, Ordenación de un vector de números racionales

class Racional implements Comparador

{
int numerador, denominador;
public boolean igualQue(Object op2)
{
Racional n2 = (Racional) op2;

return ((double)numerador / (double)denominador) ==

((double)n2. numerador / (double)n2. denominador );
}

public boolean menorQue(Object op2)

{
Racional n2 = (Racional) op2;

return ((double)numerador / (double)denominador) <

((double)n2. numerador / (double)n2. denominador );
}
 public boolean menorIgualQue(Object op2)
{
Racional n2 = (Racional) op2;
return ((double)numerador / (double)denominador) <=
((double)n2. numerador / (double)n2. denominador );
}
public boolean mayorQue(Object op2)
{
Racional n2 = (Racional) op2;
return ((double)numerador / (double)denominador) >
((double)n2. numerador / (double)n2. denominador );
}
public boolean mayorIgualQue(Object op2)
{
Racional n2 = (Racional) op2;
return ((double)numerador / (double)denominador) >=
((double)n2. numerador / (double)n2. denominador );
}

}
private static void intercambiar (Vector v, int i, int j)
{
Object aux = v.elementAt(i);
v.setElementAt(v.elementAt(j), i);
v.setElementAt(aux, j);
}
public static void ordVector (Vector v)
{
boolean interruptor = true;
int pasada, j;
int n = v.size();
// bucle externo controla la cantidad de pasadas
for (pasada = 0; pasada < n-1 && interruptor; pasada++)
{
interruptor = false;
for (j = 0; j < n-pasada-1; j++)
{
Racional r;
r = (Racional)v.elementAt(j);
if (r.mayorQue(v.elementAt(j+1)))
{
// elementos desordenados, se intercambian
interruptor = true;
intercambiar(v, j, j+1);
}
}
}
}
Búsqueda binaria

public int busquedaBin(int a[],int clave)

{
int central, bajo, alto;
int valorCentral;

bajo = 0;
alto = a.length - 1;
while (bajo <= alto)
{
central = (bajo + alto)/2; // índice de elemento central
valorCentral = a[central]; // valor del índice central
if (clave == valorCentral)
return central; // encontrado, devuelve posición
else if (clave < valorCentral)
alto = central -1; // ir a sublista inferior
else
bajo = central + 1; // ir a sublista superior
}
return -1; //elemento no encontrado
}