Sie sind auf Seite 1von 16

ORDENACIN POR BURBUJA

El mtodo de ordenacin por burbuja es el ms conocido y popular entre estudiantes y


aprendices de programacin, por su facilidad de comprender y programar; por el
contrario, es el menos eficiente y por ello, normalmente, se aprende su tcnica pero no
suele utilizarse.
La tcnica utilizada se denomina ordenacin por burbuja u ordenacin por
hundimiento debido a que los valores ms pequeos burbujean! gradualmente "suben#
$acia la cima o parte superior del array de modo similar a como suben las burbu%as en
el agua, mientras que los valores mayores se $unden en la parte inferior del array. La
tcnica consiste en $acer varias pasadas a travs del array. En cada pasada, se comparan
pare%as sucesivas de elementos. &i una pare%a est en orden creciente "o los valores son
idnticos#, se de%an los valores como estn. &i una pare%a 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 ordenacin por burbu%a requiere $asta
n-1 pasadas. 'or cada pasada se comparan elementos adyacentes y se intercambian sus
valores cuando el primer elemento es mayor que el segundo elemento. (l final de cada
pasada, el elemento mayor $a burbujeado! $asta la cima de la sublista actual. 'or
e%emplo, despus que la pasada ) 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])
&e realizan n-+ comparaciones, por cada pare%a (a[i],a[i+1]) se intercambian
los valores si a[i+1] < a[i].
(l 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 ms pequeo se
almacena en a[0] .
El algoritmo tiene una me%ora inmediata, el proceso de ordenacin 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 e%emplo siguiente ilustra el funcionamiento del algoritmo de la burbu%a con un array
de 5 elementos "A = 50, 20, 40, 80, 30# donde se introduce una variable
interruptor para detectar si se $a producido intercambio en la pasada.
Pasada 1 ,) -) .) /) 0) 1ntercambio ,) y -)
-) ,) .) /) 0) 1ntercambio ,) y .)
-) .) ,) /) 0) ,) y /) ordenados
-) .) ,) /) 0) 1ntercambio /) y 0)
Elemento mayor es /)
-) .) ,) 0) /) interruptor = TRU
Pasada 2
-) .) ,) 0) /) -) y .) ordenados
-) .) ,) 0) /) .) y ,) ordenados
-) .) ,) 0) /) &e intercambian ,) y 0)
,) y /) elementos mayores y ordenados
-) .) 0) ,) /) interruptor = TRU


Pasada 3
-) .) 0) ,) /) -) y .) ordenados
&e intercambian .) y 0)
-) 0) .) ,) /) interruptor = TRU
Pasada 4
-) 0) .) ,) /) -) y 0) ordenados
Lista ordenada
-) 0) .) ,) /) interruptor = !A"#
En consecuencia, el algoritmo de ordenacin de burbu%a mejorado contempla dos
bucles anidados* el bucle externo controla la cantidad de pasadas "al principio de la
primera pasada todav2a no se $a producido ning3n intercambio por tanto la variable
interruptor se pone a valor falso($a%&e); 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 3ltima pasada "n-1# o bien cuando el
valor del interruptor sea falso, es decir no se $aya $ec$o ning3n intercambio.
Codificacin del algoritmo de la burbuja
El mtodo or'(ur)u*a() implementa el algoritmo de ordenacin de la burbu%a, tiene
como argumento el array que se va a ordenar crecientemente. El intercambio de dos
elementos se realiza llamando al mtodo +oi' inter,a-)iar(%on. []a, int i,
int *). &e $a elegido entero largo "%on.# como tipo de los elementos del array.
pu)%i, &tati, +oi' or'(ur)u*a (%on. a[])
/
)oo%ean interruptor = true0
int pa&a'a, *0
int n = a.%en.t10
22 )u,%e e3terno ,ontro%a %a ,anti'a' 'e pa&a'a&
$or (pa&a'a = 00 pa&a'a < n-1 44 interruptor0 pa&a'a++)
/
interruptor = $a%&e0
$or (* = 00 * < n-pa&a'a-10 *++)
i$ (a[*] 5 a[*+1])
/
22 e%e-ento& 'e&or'ena'o&, &e inter,a-)ian
interruptor = true0
inter,a-)iar(a, *, *+1)0
6
6
6
4na me%ora del algoritmo anterior consiste en utilizar, en lugar de una variable
bandera interruptor, una variable in'i,e7nter,a-)io que se inicie a 0 al principio
de cada pasada y se establezca al 2ndice del 3ltimo intercambio, de modo que cuando al
terminar la pasada el valor de in'i,e7nter,a-)io siga siendo 0 implicar que no se $a
producido ning3n intercambio "o bien, que el intercambio $a sido con el primer
elemento# , y, por consiguiente, la lista estar ordenada. En caso de no ser 0, el valor de
in'i,e7nter,a-)io representa el 2ndice del array a partir del cual los elementos estn
ordenados. La codificacin de esta alternativa*
pu)%i, &tati, +oi' or'(ur)u*a2 (%on. a[])
/
int i, *0
int in'i,e7nter,a-)io0
int n = a.%en.t10
i = n-10
81i%e (i 5 0)
/
in'i,e7nter,a-)io = 00
22 e3p%orar %a &u)%i&ta a[0] a a[i]
$or (* = 00 * < i0 *++)
i$ (a[*+1] < a[*])
/
in'i,e7nter,a-)io = *0
inter,a-)iar(a, *, *+1)0
6
i = in'i,e7nter,a-)io0
6
6
Anli!i! del algoritmo de la burbuja
56ul es la eficiencia del algoritmo de ordenacin de la burbu%a 7 8epender de la
versin utilizada. En la versin ms simple se $acen n-1 pasadas y n-1 comparaciones
en cada pasada. 'or consiguiente, el n3mero de comparaciones es (n-1 ! (n-1 9 n
2
- 2n
" 1, es decir la comple%idad es #(n
2
.
&i se tienen en cuenta las versiones me%oradas, $aciendo uso de las variables
interruptor o in'i,e7nter,a-)io, entonces se tendr una eficiencia diferente a cada
algoritmo. En el mejor de los casos, la ordenacin de burbu%a $ace una sola pasada en el
caso de una lista que ya est ordenada en orden ascendente y por tanto su comple%idad
es #(n. En el caso peor se requieren "n-i-1# comparaciones y "n-i-1# intercambios. La
ordenacin completa requiere
n n " # +
-
comparaciones y un n3mero similar de
intercambios. La comple%idad para el caso peor es #(n
2
comparaciones y #(n
2

intercambios.
8e cualquier forma, el anlisis del caso general es complicado dado que alguna de las
pasadas pueden no realizarse. &e podr2a sealar que el n3mero medio de pasadas $ es
#(n y el n3mero total de comparaciones es #(n
2
% En el me%or de los casos, la
ordenacin por burbu%a puede terminar en menos de n-1 pasadas pero requiere,
normalmente, muc$os ms intercambios que la ordenacin por seleccin y su prestacin
media es muc$o ms lenta, sobre todo cuando los arrays a ordenar son grandes.
A tener en cuenta
Los algoritmos de ordenacin interna: intercambio, seleccin, insercin y burbuja son
fciles de entender y de codificar, sin embargo poco eficientes y no recomendables para
ordenar listas de muchos elementos. La complejidad de todos ellos es cuadrtica, 0(n
2
).
EJERCICIO "
&on el fin de medir el tiempo en milise'undos (ue emplea en ordenar un computador
utili)ando los m*todos+ intercambio, seleccin, insercin y burbuja, se desea escribir
un pro'rama (ue 'enere un array de 1### elementos obtenidos al a)ar, se ordene
aplicando cada uno de los al'oritmos y mida el tiempo empleado por el computador.
La clase 9eto'o&(a&i,o&:r'ena,ion dispone de los mtodos de ordenacin que $an
sido implementados, todos para arrays de tipo int. (l ser mtodos &tati, no se crea un
ob%eto de la clase, directamente se llama al mtodo con el cualificador de la clase.
El mtodo -ain() define el array, asi'na elementos aleatorios llamando al m*todo
9at1.ran'o-(), llama a cada m*todo de ordenacin% Para determinar el tiempo de
ordenacin se utili)a #;&te-.,urrentTi-e9i%%i&()"devuelve tiempo en
milisegundos# antes y despus de cada llamada al mtodo de ordenacin, la diferencia
es el tiempo transcurrido.
i-port or'enainterna.9eto'o&(a&i,o&:r'ena,ion0
i-port *a+a.io.<0
pu)%i, ,%a&& :r'ena7nterna
/
pu)%i, &tati, +oi' -ain(#trin. ar.&[])
/
$ina% int 9 = 100000
int [] + = ne8 int [9]0
int [] , = ne8 int [9]0
%on. =1, =20

entra'a(+)0
#;&te-.arra;,op;(+,0,,,0,+.%en.t1)0
=1 = #;&te-.,urrentTi-e9i%%i&()0
:r'ena,(a&i,a.or'7nter,a-)io(,)0
=2 = #;&te-.,urrentTi-e9i%%i&()0
#;&te-.out.print%n(>?nTie-po or'ena,i@n por inter,a-)ioA >
+ (=2 - =1))0
#;&te-.arra;,op;(+,0,,,0,+.%en.t1)0
=1 = #;&te-.,urrentTi-e9i%%i&()0
:r'ena,(a&i,a.or'7n&er,ion(,)0
=2 = #;&te-.,urrentTi-e9i%%i&()0
#;&te-.out.print%n(>?nTie-po or'ena,i@n por in&er,i@nA >
+ (=2 - =1))0
#;&te-.arra;,op;(+,0,,,0,+.%en.t1)0
=1 = #;&te-.,urrentTi-e9i%%i&()0
:r'ena,(a&i,a.or'(ur)u*a(,)0
=2 = #;&te-.,urrentTi-e9i%%i&()0
#;&te-.out.print%n(>?nTie-po or'ena,i@n por )ur)u*aA >
+ (=2 - =1))0
#;&te-.arra;,op;(+,0,,,0,+.%en.t1)0
=1 = #;&te-.,urrentTi-e9i%%i&()0
:r'ena,(a&i,a.or'(ur)u*a2(,)0
=2 = #;&te-.,urrentTi-e9i%%i&()0
#;&te-.out.print%n(>?nTie-po or'ena,i@n por )ur)u*a(2)A >
+ (=2 - =1))0
#;&te-.arra;,op;(+,0,,,0,+.%en.t1)0
=1 = #;&te-.,urrentTi-e9i%%i&()0
:r'ena,(a&i,a.or'#e%e,,ion(,)0

=2 = #;&te-.,urrentTi-e9i%%i&()0
#;&te-.out.print%n(>?nTie-po or'ena,i@n por &e%e,,ionA >
+ (=2 - =1))0
6
&tati, +oi' entra'a(int [] 8)
/
int #UB =CCCC0
$or (int i = 00 i< 8.%en.t10 i++)
8[i] = (int)(9at1.ran'o-() < #UB + 1)0
6
6
#$%ODO& DE ORDENACIN BIN&OR% ' RADI(&OR%
Estos mtodos de ordenacin utilizan urnas para depositar en ellas los registros en el
proceso de ordenacin. En cada recorrido de la lista a ordenar se deposita en una urna
i

aquellos registros cuya clave tienen una cierta correspondencia con el 2ndice i .
#)todo de ordenacin Bin!ort *ordenacin por urnas+
Este mtodo, tambin llamado clasificacin por urnas, se propone conseguir funciones
tiempo de e%ecucin de comple%idad menor de :(n %o. n) para ordenar una lista de n
elementos, siempre que se conozca alguna relacin del campo clave de los elementos
respecto de las urnas.
8ado un array +[]de registros, se desea ordenar respecto un campo clave de tipo
entero, adems se sabe que los valores de las claves se encuentran en el rango de 1 a n,
sin claves duplicadas y siendo n el n3mero de elementos. En estas circunstancias
ideales es posible ubicar los registros ordenados en un array au:iliar t[] mediante este
3nico bucle*
$or i = 1 to n 'o
t[+[i].,%a+e]= +[i]0
&encillamente, determina la posicin del registro que le corresponde seg3n el valor
del campo clave. El bucle lleva un tiempo de e%ecucin de comple%idad lineal :(n).
Esta ordenacin tan sencilla que se $a e:puesto es un caso particular del mtodo de
ordenacin por urnas "binsort#. Este mtodo utiliza urnas, cada urna contiene todos los
registros con una misma clave.
El proceso consiste en e:aminar cada registro r a clasificar y situarle en la urna i,
coincidiendo i con el valor del campo clave de r. En la mayor2a de los caso en que se
utilice el algoritmo ser necesario guardar ms de un registro en una misma urna por
tener claves repetidas. Entonces estas urnas $ay que concatenarlas en el orden de menor
2ndice de urna a mayor, as2 quedar el array en orden creciente respecto al campo clave.
En la ;igura <.0 se muestra un vector de - urnas. Las urnas estn representadas por
listas enlazadas.
4rnas
+ =+ =+ =+
- =- =- =-
=0 =0 =0
m =m =m =m
,igura -./ Estructura formada por - urnas
Algoritmo de ordenacin Bin!ort.
El algoritmo se aplica sobre listas de registros con un campo clave cuyo rango de
valores es relativamente pequeo respecto al n3mero de registros. >ormalmente el
campo clave es de tipo entero, en el rango 1 .. -. &on necesarias - urnas por ello se
declara un vector de - urnas. Las urnas se representan mediante listas enlazadas, cada
elemento de la lista contiene un registro cuyo campo clave se corresponde con el 2ndice
de la urna en la que se encuentra, normalmente la clave ser igual al 2ndice de la urna.
(s2 en la urna 1 se sit3an los registros cuyo campo clave es 1, en la urna 2 los registros
cuyo campo clave es 2, y as2 sucesivamente en la urna i se sit3an los registros cuyo
campo clave es igual a i .
La primera accin del algoritmo consiste en distribuir los registros en las diversas
urnas. 4na vez realizada la distribucin, es necesario concatenar las listas enlazadas
para formar un 3nica lista con los registros en orden creciente; por 3ltimo, 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 ;igura <.. se muestra cmo realizar la
concatenacin.
=+ =+ =+
=- =- =-
=0 =0 ... =0

=m =m =m
,igura -.0 6oncatenacin de urnas representadas por listas enlazadas.
Los pasos que sigue el algoritmo e:presado en seudocdigo para un vector de n
registros*
:r'ena,ion(in&ort(+e,tor, n)
ini,io
DrearUrna&(Urna&)0
/Ei&tri)u,i@n 'e re.i&tro& en &u& ,orre&pon'iente& urna&6
'e&'e * = 1 1a&ta n 1a,er
AFa'irnUrna(Urna&[+e,tor[*].,%a+e], +e,tor[*])0
$inG'e&'e
/Don,atena %a& %i&ta& Hue repre&entan a %a& urna&
'e&'e Urna
i
1a&ta Urna
-
6
i = 10 /)I&Hue'a 'e pri-era urna no +a,Ja6
-ientra& &Ka,ia(Urna&[i]) 1a,er
i = i+1
$inG-ientra&
'e&'e * = i+% a - 1a,er
n%aLarUrna(Urna&[i], Urna&[*])0
$inG'e&'e
/re,orre %a& %i&ta(urna&) re&u%ta'o 'e %a ,on,atena,i@n6
* = 10
'ir = <$rente Urna&[i]50
-ientra& 'ir <5 nu%o 1a,er
+e,tor[*] = <re.i&tro apunta'o por 'ir50
* = *+i0
'ir = #.te('ir)
$inG-ientra&
$in
#)todo de ordenacin Radi1&ort *ordenacin por residuos+
Este mtodo de ordenacin es un caso particular del algoritmo de clasificacin por
urnas. La idea intuitiva de mtodo de ordenacin por residuos se encuentra en los pasos
que se siguen a la $ora de ordenar, de forma manual, un con%unto de fic$as; consiste en
formar diversos montones de fic$as, cada uno caracterizado por tener sus componentes
un mismo d2gito "letra, si es ordenacin alfabtica# en la misma posicin, inicialmente
primera posicin que son las unidades; estos montones se recogen en orden ascendente,
desde el montn del d2gito ) al montn del d2gito ?. Entonces las fic$as estn ordenadas
respecto a las unidades. ( continuacin se vuelve a distribuir las fic$as en montones,
seg3n el d2gito que est en la segunda posicin "decenas#. El proceso de distribuir las
fic$as por montones y posterior acumulacin en orden se repite tantas veces como
n3mero de d2gitos tiene la fic$a de mayor valor.
&e desea ordenar la siguiente lista de fic$as, aplicando los pasos del algoritmo
-adix.ort; las fic$as estn identificadas por un campo entero de tres d2gitos*
345, M21, 425, 5M2, 83N, 4NM, NM2, 1C4, 3N5, 23N, 8C1, M4N, 431,
834, 24M, 52C, 21N, 38C
(tendiendo al d2gito de menor peso "unidades# las fic$as se distribuyen en montones
del 0 al C*
21/
431 3/0 14/
231 /12 234 420 23/ 241 323
121 012 134 340 23/ 4/1 023
1 2 4 0 / 1 3
=ecogiendo los montones en orden ascendente la lista de fic$as es la siguiente*
M21, 8C1, 431, 5M2, NM2, 1C4, 834, 345, 425, 3N5, 83N, 23N, M4N, 21N,
4NM, 24M, 52C, 38C
Esta lista ya est ordenada respecto al d2gito de menor peso, respecto a las unidades.
'ues bien, a$ora de nuevo se distribuye la secuencia de fic$as en montones respecto al
segundo d2gito*
23/
023 23/ 241
420 234 14/ 4/1 /12 134
21/ 121 431 340 3/0 012 323 231
1 2 3 4 / 1 2 3
=ecogiendo los montones en orden ascendente, la lista de fic$as es la siguiente*
21N, M21, 425, 52C, 431, 834, 83N, 23N, 345, M4N, 24M, 3N5, 4NM, 5M2,
NM2, 38C, 8C1, 1C4
En este momento las fic$as ya estn ordenadas respecto a los dos 3ltimos d2gitos, es
decir respecto a las decenas. 'or 3ltimo, se distribuye las fic$as en montones respecto
al tercer d2gito*
241 323 4/1 231
23/ 3/0 431 012 14/ 23/
134 21/ 340 420 023 /12 121 234
1 2 3 4 0 / 1 2
=ecogiendo de nuevo los montones en orden ascendente, la lista de fic$as ya est
ordenada*
1C4, 21N, 23N, 24M, 345, 3N5, 38C, 425, 431, 4NM, 52C, 5M2, NM2, M21,
M4N, 834, 83N, 8C1
Algoritmo de ordenacin Radi1&ort.
La idea clave de la ordenacin =adi:&ort es clasificar por urnas, primero respecto al
d2gito de menor peso, "unidades#; despus respecto al d2gito del siguiente peso
"decenas#, y as2 sucesivamente se contin3a $asta alcanzar el d2gito ms significativo.
4na vez terminada la clasificacin respecto al d2gito mas significativo la lista est
ordenada. En cada paso $ay que unir las urnas en orden ascendente, desde la urna 0 a la
urna C; consiste, simplemente, en enlazar el final de una urna con el frente de la
siguiente.
(l igual que en el mtodo de 4in.ort, las urnas se representan mediante un array de
listas enlazadas. &e $a de disponer de tantas urnas como d2gitos, 10 urnas, numeradas
de 0 a ?. &i la clave respecto a la que se ordena es alfabtica, $abr tantas urnas como
letras distintas, desde la urna que representa a la letra a $asta la ).
El algoritmo que se escribe, en primer lugar determina el n3mero m:imo de d2gitos
que puede tener una clave. 4n bucle de tantas iteraciones como el m:imo de d2gitos,
realiza las acciones de distribuir por urnas los registros, concatenar...
La distribucin por urnas e:ige obtener el d2gito del campo clave que se encuentra en la
posicin definida por el bucle e:terno, dic$o d2gito ser el 2ndice de la urna.
:r'ena,ionRa'i3&ort(+e,tor, n)
ini,io
/ ,O%,u%o e% nI-ero -O3i-o 'e 'J.ito&A n'i. 6
n'i. = 00
te-p = -a3i-aD%a+e0
-ientra& (te-p 5 0) 1a,er
n'i. = n'i.+1
te-p = te-p 2 100
$inG-ientra&
pe&o =1 / per-ite o)tener %o& 'J.ito& 'e -enor a -a;or pe&o6
'e&'e i = 1 1a&ta n'i. 1a,er
DrearUrna&(Urna&)0
'e&'e * = 1 1a&ta n 1a,er
' = (+e,tor[*] 2 pe&o) -o'u%o 100
AFa'irnU-a(Urna&['], +e,tor[*])0
$inG'e&'e
/ )I&Hue'a 'e pri-era urna no +a,JaA * 6
'e&'e r = *+1 1a&ta 9 1a,e / 9A nI-ero 'e urna& 6
n%aLarU-a(Urna&[r], Urna&[*])0
$inG'e&'e
/#e re,orre %a %J&ta-urna re&u%tante 'e %a ,on,atena,i@n6
r = 10
'ir = $rente(Urna[*])0
-ientra& 'ir <5 nu%o 1a,er
+e,to[r] = 'ir.re.i&tro0
r = r+10
'ir = &i.uiente('ir)
$inG-ientra&
pe&o = pe&o < 100
$inG'e&'e
$inGor'ena,ion
#)todo! de ordenacin b!ico!
pa,=a.e or'enainterna0
pu)%i, ,%a&& 9eto'o&(a&i,o&:r'ena,ion
/
pu)%i, &tati, +oi' inter,a-)iar(int []a, int i, int *)
/
int au3 = a[i]0
a[i] = a[*]0
a[*]= au3 0
6
pu)%i, &tati, +oi' inter,a-)iar(%on. []a, int i, int *)
/
%on. au3 = a[i]0
a[i] = a[*]0
a[*]= au3 0
6
pu)%i, &tati, +oi' inter,a-)iar('ou)%e[]a, int i, int *)
/
'ou)%e au3 = a[i]0
a[i] = a[*]0
a[*]= au3 0
6

pu)%i, &tati, +oi' or'7nter,a-)io (int a[])
/
int i, *0

$or (i = 0 0 i < a.%en.t1-10 i++)
22 &itIa -Jni-o 'e a[i+1]...a[n-1] en a[i]
$or (* = i+1 0 * < a.%en.t10 *++)
i$ (a[i] 5 a[*])
/
inter,a-)iar(a, i, *)0
6
6
pu)%i, &tati, +oi' or'7n&er,ion (int [] a)
/
int i, *0
int au30

$or (i = 10 i < a.%en.t10 i++)
/
2< in'i,e * e& para e3p%orar %a &u)%i&ta a[i-1]..a[0]
)u&,an'o %a po&i,ion ,orre,ta 'e% e%e-ento 'e&tino<2
* = i0
au3 = a[i]0
22 &e %o,a%iLa e% punto 'e in&er,i@n e3p%oran'o 1a,ia a)a*o
81i%e (* 5 0 44 au3 < a[*-1])
/
22 'e&p%aLar e%e-ento& 1a,ia arri)a para 1a,er e&pa,io
a[*] = a[*-1]0
*--0
6
a[*] = au30
6
6

pu)%i, &tati, +oi' or'(ur)u*a (int a[])
/
)oo%ean interruptor = true0
int pa&a'a, *0
int n = a.%en.t10
22 )u,%e e3terno ,ontro%a %a ,anti'a' 'e pa&a'a&
$or (pa&a'a = 00 pa&a'a < n-1 44 interruptor0 pa&a'a++)
/
interruptor = $a%&e0
$or (* = 00 * < n-pa&a'a-10 *++)
i$ (a[*] 5 a[*+1])
/
22 e%e-ento& 'e&or'ena'o&, &e inter,a-)ian
interruptor = true0
inter,a-)iar(a, *, *+1)0
6
6
6
pu)%i, &tati, +oi' or'(ur)u*a2 (int a[])
/
int i, *0
int in'i,e7nter,a-)io0
int n = a.%en.t10

i = n-10
81i%e (i 5 0)
/
in'i,e7nter,a-)io = 00
22 e3p%orar %a &u)%i&ta a[0] a a[i]
$or (* = 00 * < i0 *++)
i$ (a[*+1] < a[*])
/
in'i,e7nter,a-)io = *0
inter,a-)iar(a, *, *+1)0
6
i = in'i,e7nter,a-)io0
6
6
pu)%i, &tati, +oi' or'#e%e,,ion (int a[])
/
int in'i,e9enor, i, *, n0
n = a.%en.t10
22 or'enar a[0]..a[n-2] ; a[n-1] en ,a'a pa&a'a
$or (i = 00 i < n-10 i++)
/
22 ,o-ienLo 'e %a e3p%ora,i@n en Jn'i,e i
in'i,e9enor = i0
22 * e3p%ora %a &u)%i&ta a[i+1]..a[n-1]
$or (* = i+10 * < n0 *++)
i$ (a[*] < a[in'i,e9enor])
in'i,e9enor = *0
22 &itIa e% e%e-ento -a& peHueFo en a[i]
i$ (i P= in'i,e9enor)
inter,a-)iar(a, i, in'i,e9enor)0
6
6
6
#)todo! de ordenacin &2ell

pu)%i, &tati, +oi' or'ena,ion#1e%%('ou)%e a[])
/
int inter+a%o, i, *, =0
int n= a.%en.t10

inter+a%o = n 2 20
81i%e (inter+a%o 5 0)
/
$or (i = inter+a%o0 i < n0 i++)
/
* = i - inter+a%o0
81i%e (* 5= 0)
/
= = * + inter+a%o0
i$ (a[*] <= a[=])
* = -10 22 par 'e e%e-ento& or'ena'o
e%&e
/
inter,a-)iar(a, *, *+1)0
* -= inter+a%o0
6
6
6
inter+a%o = inter+a%o 2 20
6
6
#)todo de ordenacin 3uic4!ort
pu)%i, &tati, +oi' Hui,=&ort('ou)%e a[])
/
Hui,=&ort(a, 0, a.%en.t1-1)0
6
pri+ate &tati, +oi' Hui,=&ort('ou)%e a[], int pri-ero, int u%ti-o)
/
int i, *, ,entra%0
'ou)%e pi+ote0
,entra% = (pri-ero + u%ti-o)220
pi+ote = a[,entra%]0
i = pri-ero0
* = u%ti-o0
'o /
81i%e (a[i] < pi+ote) i++0
81i%e (a[*] 5 pi+ote) *--0

i$ (i <= *)
/
inter,a-)iar(a, i, *)0
i++0
*--0
6
681i%e (i <= *)0
i$ (pri-ero < *)
Hui,=&ort(a, pri-ero, *)0 22 -i&-o pro,e&o ,on &u)%i&ta iLH'a
i$ (i < u%ti-o)
Hui,=&ort(a, i, u%ti-o)0 22 -i&-o pro,e&o ,on &u)%i&ta 'r,1a
6
Ca56tulo -7 Ordenacin de un 8ector de n9mero! racionale!

,%a&& Ra,iona% i-p%e-ent& Do-para'or
/
int nu-era'or, 'eno-ina'or0
pu)%i, )oo%ean i.ua%Que(:)*e,t op2)
/
Ra,iona% n2 = (Ra,iona%) op20

return (('ou)%e)nu-era'or 2 ('ou)%e)'eno-ina'or) ==
(('ou)%e)n2. nu-era'or 2 ('ou)%e)n2. 'eno-ina'or )0
6
pu)%i, )oo%ean -enorQue(:)*e,t op2)
/
Ra,iona% n2 = (Ra,iona%) op20

return (('ou)%e)nu-era'or 2 ('ou)%e)'eno-ina'or) <
(('ou)%e)n2. nu-era'or 2 ('ou)%e)n2. 'eno-ina'or )0
6
pu)%i, )oo%ean -enor7.ua%Que(:)*e,t op2)
/
Ra,iona% n2 = (Ra,iona%) op20
return (('ou)%e)nu-era'or 2 ('ou)%e)'eno-ina'or) <=
(('ou)%e)n2. nu-era'or 2 ('ou)%e)n2. 'eno-ina'or )0
6
pu)%i, )oo%ean -a;orQue(:)*e,t op2)
/
Ra,iona% n2 = (Ra,iona%) op20
return (('ou)%e)nu-era'or 2 ('ou)%e)'eno-ina'or) 5
(('ou)%e)n2. nu-era'or 2 ('ou)%e)n2. 'eno-ina'or )0
6
pu)%i, )oo%ean -a;or7.ua%Que(:)*e,t op2)
/
Ra,iona% n2 = (Ra,iona%) op20
return (('ou)%e)nu-era'or 2 ('ou)%e)'eno-ina'or) 5=
(('ou)%e)n2. nu-era'or 2 ('ou)%e)n2. 'eno-ina'or )0
6
6
pri+ate &tati, +oi' inter,a-)iar (Ke,tor +, int i, int *)
/
:)*e,t au3 = +.e%e-entAt(i)0
+.&et%e-entAt(+.e%e-entAt(*), i)0
+.&et%e-entAt(au3, *)0
6
pu)%i, &tati, +oi' or'Ke,tor (Ke,tor +)
/
)oo%ean interruptor = true0
int pa&a'a, *0
int n = +.&iLe()0
22 )u,%e e3terno ,ontro%a %a ,anti'a' 'e pa&a'a&
$or (pa&a'a = 00 pa&a'a < n-1 44 interruptor0 pa&a'a++)
/
interruptor = $a%&e0
$or (* = 00 * < n-pa&a'a-10 *++)
/
Ra,iona% r0
r = (Ra,iona%)+.e%e-entAt(*)0
i$ (r.-a;orQue(+.e%e-entAt(*+1)))
/
22 e%e-ento& 'e&or'ena'o&, &e inter,a-)ian
interruptor = true0
inter,a-)iar(+, *, *+1)0
6
6
6
6
B9!3ueda binaria

pu)%i, int )u&Hue'a(in(int a[],int ,%a+e)
/
int ,entra%, )a*o, a%to0
int +a%orDentra%0

)a*o = 00
a%to = a.%en.t1 - 10
81i%e ()a*o <= a%to)
/
,entra% = ()a*o + a%to)220 22 Jn'i,e 'e e%e-ento ,entra%
+a%orDentra% = a[,entra%]0 22 +a%or 'e% Jn'i,e ,entra%
i$ (,%a+e == +a%orDentra%)
return ,entra%0 22 en,ontra'o, 'e+ue%+e po&i,i@n
e%&e i$ (,%a+e < +a%orDentra%)
a%to = ,entra% -10 22 ir a &u)%i&ta in$erior
e%&e
)a*o = ,entra% + 10 22 ir a &u)%i&ta &uperior
6
return -10 22e%e-ento no en,ontra'o
6