You are on page 1of 10

Contenido

Método de Inserción ....................................................................................................................... 2
Método de la Burbuja ..................................................................................................................... 3
Método de Selección....................................................................................................................... 4
Método Shell ................................................................................................................................... 5
Método de Mezcla o Merge ............................................................................................................ 6
Método Rápido o Quick Sort ........................................................................................................... 7
Método del Montículo o Heap Sort ................................................................................................ 9

pág. 1

k > 1 and a[k] < a[k-1]. se utiliza como caso base de otros métodos de ordenación basados en divide y vencerás. Además casi no consume memoria extra. for (k = i.i] is sorted end pág. Su complejidad es de O(n^2) en el peor de los casos pero es adaptativo y cuando los elementos se encuentran casi ordenados se convierte en O(n). 2 .k-1] → invariant: a[1.. for i = 2:n. Se utiliza cuando el problema es pequeño y de hecho.Método de Inserción El método de inserción recorre una lista tomando el elemento actual e insertándolo donde toque entre los que ya ha recorrido. cuando los conjuntos en los que queda dividido el problema son pequeños. k--) swap a[k.

Esto nos lleva a un coste en O(n^2) pero cuando los elementos están casi ordenados. for i = 1:n. se les da la vuelta y se continúa. Para encontrar el más pequeño. Como recorremos la lista al revés. si nos damos cuenta. hablamos de un algoritmo adaptativo. Se llama de la burbuja porque los elementos flotan hasta su posición correcta como lo harían las burbujas de una bebida gaseosa. Aquí la cosa consiste en recorrer la lista al revés tratando de encontrar el elemento más bajo y dejarlo al principio de la lista. 3 . Así. Parte del hecho de que lo que lleva recorrido no sólo está ordenado sino que está en su posición final y no habrá que cambiarlo. el pequeño va flotando hasta el comienzo de la lista. es el mismo problema si ignoramos el primero) y así sucesivamente. Si no es así y tenemos actual=pequeño y siguiente=grande.Método de la Burbuja Este método se parece mucho al de inserción (mismas complejidades y adaptabilidad) pero es algo más complejo. el recorrido inverso toma un elemento y el siguiente. nos vamos a por el segundo (que. no se hace nada y el actual pasa a ser el pequeño. se espera que dos elementos estén ordenados si se encuentran como actual=grande y siguiente=pequeño. Ahora que ya tenemos el más bajo colocado. pág. los cambios extra producidos durante los sucesivos recorridos habrá tendido a colocar en su sitio los elementos desordenados por lo que la complejidad se reduce a O(n) y por tanto. Si es así.

swap a[j. k = i for j = i+1:n. y otra vez… El método de selección es el caso general del de la burbuja. se busca el menor entre todos y se coloca al principio.. y otra vez. La principal diferencia es que el algoritmo por selección no es adaptativo. for i = 1:n. 4 . k = j → invariant: a[k] smallest of a[i. luego se hace lo mismo con el resto..swapped = false for j = n:i+1. así como el de la burbuja al menos daba la vuelta a los pares desordenados.j-1] swapped = true → invariant: a[1. En su recorrido para seleccionar el más bajo. ¿En qué consiste? Bueno.n] swap a[i. if a[j] < a[j-1]. if a[j] < a[k].i] in final position break if not swapped end Método de Selección El primo tonto de los métodos de ordenación.i] in final position end pág. el algoritmo de seleccionar no hace nada y la complejidad siempre es O(n^2). Ahora bien (tenía que haber algo bueno) minimiza el número de cambios..k] → invariant: a[1.

Por ejemplo.5. 6. 12. 5. 4. 3. Cada paso dejará la lista original más ordenada y el último paso es una inserción normal y corriente con una lista casi ordenada (caso donde el algoritmo se comporta mejor). 4. Para seleccionar la sublista se cuenta cada h elementos donde h varía desde el número de elementos de la lista hasta 1. 15. 5 . considera la secuencia [5. 9. 15]. 15] y si h = 1 entonces la lista es la original. 12. h = 1 while h < n. consiste en aplicar el método de inserción sobre sublistas de la lista original.Método Shell Este método es muy ingenioso. La idea es utilizar el método de inserción para ordenar cada sublista. Ahora tomando h = 2. 6. Si h = 13. h = 3*h + 1 while h > 0. obtenemos [7. h = h / 3 pág. 7. cuenta 13 elementos y tendrás la sublista [17]. 6. Si h = 3. 3. cuenta cada 3 elementos y la sublista será [9. 8. 17]. 6. 6. comenzando por pocos elementos poco ordenados y terminando en muchos elementos pero casi ordenados.

for k = 1:h. pág. ordenarla y mezclar las sublistas ordenadas de nuevo en una sola.. Consiste en partir la lista en dos. No es adaptativo pero es estable. Entonces puedes decir que están (trivialmente) ordenadas. # split in half m = n / 2 # recursive sorts sort a[1. k = 1 while i <= m and j <= n. Su complejidad es siempre de O(n·log n) y requiere un espacio de O(log n)en memoria devido a la recursividad.m] i = 1. insertion sort a[k:h:n] → invariant: each h-sub-array is sorted end Método de Mezcla o Merge El método de mezcla es muy fácil de entender. 6 ..m] sort a[m+1.. Se vuelve a dividir hasta que las sublistas o sean vacías ([]) o sean de un sólo elemento ([42]). j = m+1. a[k++] = (a[j] < b[i]) ? a[j++] : b[i++] → invariant: a[1. Una forma es aplicando de nuevo el método de mezcla. ¿Cómo se ordena cada sublista? Como quieras. Lo bueno de la ordenación por mezcla es que es muy predictivo. De hecho es el único algoritmo en O(n·log n) que es estable.n] # merge sorted sub-arrays using temp array b = copy of a[1.. El método se convierte en recursivo porque aplica el mismo algoritmo a subproblemas más sencillos.k] in final position while i <= m.

. # choose pivot swap a[1. una solución recursiva y volver a elegir un pivote en cada una de las sublistas. if a[i] < a[1].rand(1. su complejidad está en O(n^2) y no es ni adaptativo ni estable.k] in final position Método Rápido o Quick Sort La ordenación rápida es “la panacea” de los algoritmos de ordenación pero hay que ser crítico con ella. ¿Cómo? De nuevo como quieras pero puedes usar. dejar los menores a un lado y los mayores a otro y repetir hasta que las listas sean de 1 o 0 elementos (momento en el cual están trivialmente ordenadas). El método recursivo necesita un espacio de memoria extra en el orden de O(log n). curiosamente. El truco aquí es que está en que es rápido en la mayoría de las veces y cuando es rápido es muy rápido y su complejidad está en O(n·log n). swap a[++k. Luego cada sublista resultado de dividir la original por el pivote se ordena recursivamente.n)] # 2-way partition k=1 for i = 2:n.i] pág. La idea es obtener un pivote y conseguir que todos los números a la izquierda del pivote sean menores que él y todos los números a la derecha del pivote sean mayores que él. En muchos cursos de ingeniería se nombra como el mejor de los algoritmos de ordenación cuando. 7 .a[k++] = b[i++] → invariant: a[1. al igual que en el método por mezcla.

Si el elemento es más alto. Al final tendremos el lugar dónde va el pivote y allí habrá un elemento menor que él por lo que bastará intercambiar este con el pivote para lograr la partición que nos proponíamos. mayores.n] # recursive sorts sort a[1. Este algoritmo tiene una variante con dos pivotes llamada 3-way quick sort o método rápido de 3 vías. Los principios son muy similares (pero la lista queda dividida en las dos sublistas anteriores y una tercera en medio con todos los elementos iguales) y se vuelve bastante adaptativo en listas con muchas repeticiones. pág.swap a[1. Las alternativas son tomar el elemento que realmente vaya a ir en medio o tomar varios pivotes.. La elección del pivote es importante pues es la que puede llevar la complejidad del algoritmo a O(n^2). Luego se establece que su posición temporal será esa y se comprueban el resto de elementos. 8 . Si uno de ellos es menor. se incrementa porque el elemento que hemos encontrado es menor y tenemos que dejar hueco para él) y se cambia el elemento a ese lugar (podríamos mover el pivote a su nueva posición y el elemento que hemos encontrado a la posición anterior del pivote pero esto es hacer cambios innecesarios como veremos poco después)..k-1] < a[k] <= a[k+1.n] La partición se hace eligiendo un pivote y trantando de colocarlo en el lugar adecuado habiendo hecho los cambios necesarios para que todos los elementos previos sean menores que él (ojo que no significa que estén ordenados) y los elementos posteriores.. hacer una media y elegir el que más se acerque a ella.k] → invariant: a[1. Esto sucede para pivotes elegidos al azar.k-1] sort a[k+1. se incrementa la posición en la que se colocará el pivote (tiene sentido. se deja donde está y la posición del pivote no se mueve. Para ello se elige un pivote al azar y se mueve al comienzo de la lista.

9 .1.n-i+1] sink(a.n) → invariant: a[1.n): # {lc.n] in final position end # sink from i in a[1.n] in heap order # sortdown for i = 1:n.i.. A continuación se regenera el heap y se vuelve a hacer lo mismo hasta que todos los elementos son extraídos del montículo. # heapify for i = n/2:1. Luego se extrae la raíz del árbol se coloca al final de la lista.mc} = {left.n-i) → invariant: a[n-i+1.right. sink(a.i.max} child index lc = 2*i if lc > n.Método del Montículo o Heap Sort El método del montículo consiste en utilizar esta estructura de datos como base para establecer el orden. Lo primero que se hace es transforma la lista en un montículo o heap.rc. return # heap ordered pág. Un montículo es un árbol binario dónde todo subárbol izquierdo es menor que la raíz y todo subárbol derecho es mayor que la raíz. return # no children rc = lc + 1 mc = (rc > n) ? lc : (a[lc] > a[rc]) ? lc : rc if a[i] >= a[mc].n] function sink(a. swap a[1.

n) Explicaremos cómo se crea un montículo en uno de los siguientes artículos. pág.mc.mc] sink(a. 10 . aunque las dos fases resultan adaptativas por sí solas.swap a[i. Por el momento basta saber que el algoritmo actúa siempre en O(n·log n) y no es realmente adaptativo ya que la conversión a montículo normalmente está reñida con la obtención del elemento superior y. juntas no producen ninguna mejora.