MergeSort:

2 1 6 5

Se dividen en 2 subarrays

2 1 6 5

Esto se hace hasta que quede solo un elemento

2 1 6 5

Nuevo subarray:

Primero se trabaja con la rama izq. Luego, derecha. Entonces, comparamos si 2 es menor a 1
Entonces, se reemplazará ordenadamente este elemento en el array del que proviene:

Ahora, la rama derecha donde se compara si 6 es menor que 5, como es falso se reemplaza
ordenadamente el 5 en el array del que proviene y ya no se toma en cuenta al 5.

Se repite el proceso, comparamos si 1 es menor a 5, como esto es verdad, se reemplaza

ordenadamente el 1 en el array del que proviene, y ya no se toma en cuenta al 1:

Ahora, comparamos si 2 es menor a 5, como esto es verdad, se reemplaza ordenadamente

el 2 en el array del que proviene, y ya no se toma en cuenta al 2
Luego, comparamos si 5 es menor a 6, como esto es verdad, se reemplaza ordenadamente
el 5 en el array del que proviene, y ya no se toma en cuenta al 5:

Como ya solo queda un elemento y no se puede comparar con otro, entonces se

reemplaza ordenadamente este elemento en el array del que proviene:

Entonces, una vez que ya se ha comparado todo y ya no quedan subarrays, este último array
que se obtiene ya es el array ordenado mediante MergeSort.

 Ejemplo QuickSort:

Si se tiene un array: 2 1 6 5
p
Lo primero que se hace es establecer un pivote (p) al final del array: 2 1 6 5

Luego, declaramos dos índices: i y j, j va a iniciar al principio del array, e i va a

iniciar en un lugar antes del principio del array:
i j p
2 1 6 5

La idea general es verificar si el elemento en j es menor que el elemento en p. En

caso de que el elemento en j sea mayor o igual al elemento en p, simplemente se
lo ignora, y se suma 1 a j. Ahora, en caso de que el elemento en j sea menor al
elemento en p, se suma 1 a i, y se intercambia el elemento actual en i con el
elemento actual en j, y se suma 1 a j. Este proceso se repite hasta que j sea igual
a p.
Entonces, en este caso, verificamos si 2 es menor a 5, como esto es verdad, entonces
se suma 1 a i:
i,j p
2 1 6 5
Ahora lo que se hace es intercambiar el elemento actual en i con el elemento actual
en j, pero como en este caso i es igual a j, simplemente no se hace nada y se sigue
con el proceso, y se suma 1 a j.
i j p
2 1 6 5

Luego, verificamos si 1 es menor a 5, como esto es verdad, entonces se suma 1 a i:

i,j p
2 1 6 5
Se intercambia el elemento actual en i con el elemento actual en j pero como en
este caso i es igual a j, simplemente no se hace nada y se sigue con el proceso, y se
suma 1 a j:
i j p
2 1 6 5
Verificamos si 6 es menor a 5, como esto es falso, se ignora el elemento en j y se
suma 1 a j: i p,j
2 1 6 5

Ahora, una vez que j es igual a p, se suma 1 a i, y se intercambia el elemento actual

en i con el elemento en p; y ahora p pasa a estar en el nuevo lugar de su valor
original, es decir, p ahora tomará el valor de índice en donde se encuentra 5, que es
su valor original:
i p,j
2 1 6 5

i p,j
2 1 5 6

p
2 1 5 6
En este punto es importante que todos los elementos que se encuentren antes del
elemento en p, sean menores a ese elemento en p; y que todos los que estén
después, sean mayores o iguales a al elemento en p.

Ahora, lo que se hace es crear dos particiones. La primera partición será desde el
primer elemento del array hasta el último elemento antes del elemento en p; y la
segunda partición será desde el primer elemento después del elemento en p hasta
el último elemento del array:

p
2 1 5 6
Y en cada una de estas particiones se vuelve a realizar todo el proceso explicado
hasta que todo el array ya esté ordenado, ya que en QuickSort no se crean subarrays,
sino que se trabaja todo en el mismo array. Entonces, realizando el proceso en las
particiones, se tiene:

i j p p,i j,p
2 1 5 6

i p,j p i,j,p
2 1 5 6

i p,j p
2 1 5 6

i p,j p
1 2 5 6

p
1 2 5 6

1 2 5 6
 Una vez que ya se ha terminado de realizar el proceso en cada partición, se obtiene
el array ya ordenado mediante QuickSort.

Complejidad de QuickSort : O(n·log n).

 Ejemplo HeapSort:

Para trabajar con el algoritmo HeapSort, una manera intuitiva de representarlo

gráficamente es mediante un árbol binario, sin embargo, esto es solo gráficamente,
ya que en realidad todo se hace en el mismo array, solo que la lógica resulta más
comprensible al representarlo mediante un árbol binario.

Entonces, si se tiene un array: 2 1 6 5

La forma de representarlo mediante un árbol binario, es la siguiente: Se coloca en el

primer nodo padre al primer elemento del array, y luego para los demás, se los va
colocando de izquierda a derecha hasta acabar con un nivel, y de ahí los demás bajan
a otro nivel y se los sigue llenando de izquierda a derecha. Todo esto se hace
recordando las reglas de un árbol binario, es decir, que cada nodo padre tenga solo
dos nodos hijos. Entonces, la representación para el array que tenemos, es:

2 2

2 2

1 6 1 6
 5

Ahora, lo que se debe hacer es verificar que se cumpla que los nodos padres sean
mayores a sus nodos hijos. En caso de que un nodo padrea sea menor a su nodo hijo,
se intercambia posiciones con ese nodo hijo, de modo que ahora el padre sí sea
mayor al hijo. Para realizar esto, se va haciendo desde el fondo de la rama izquierda
del árbol; una vez ordenada esa rama, se hace lo mismo con la rama derecha.
Entonces, aplicando esto al árbol que tenemos:

Primero, verificamos si el nodo padre de 5 es mayor a este, como su nodo padre es

1, entonces cambiamos sus posiciones:

5 6

Seguimos subiendo, verificamos si el nodo padre de 5 es mayor a este, como su nodo

padre es 2, entonces cambiamos sus posiciones:

2 6

Como toda la rama izquierda está ordenada, se procede a realizar lo mismo con la
rama derecha. Verificamos si el nodo padre de 6 es mayor a este, como su nodo
padre es 5, entonces cambiamos sus posiciones:
 6

2 5

En este punto se observa que ya todo está ordenado. Ahora, el siguiente paso es
colocar al primer nodo padre en la posición más a la derecha del array que no se
haya reemplazado antes; esto se comprenderá mejor realizando la gráfica. Una vez
hecho eso, se coloca el último nodo hijo en la posición del primer nodo padre que
se acaba de colocar en el array, luego se vuelve a realizar la ordenación de nodos
para todo el árbol. Y después se vuelve a realizar este mismo proceso hasta que
quede un solo nodo en todo el árbol. El orden en el que se deben reemplazar el
último nodo hijo en la posición del primer nodo padre es desde abajo hacia arriba y
de derecha a izquierda. Entonces, realizando esto en el árbol que tenemos:

Primero, colocamos al primer nodo padre en la posición que esté más a la derecha
del array:

6
2 5

Ahora, se reemplaza en la posición del primer nodo padre al hijo que esté más abajo
y más a la derecha, en este caso, ese sería el 1; y el nodo que contenía al 1 ya no se
lo toma en cuenta:

1
6

2 5
Se vuelve a realizar el proceso de ordenación:

1 2 5

2 5 5 2
1 1

Se coloca el primer nodo padre en la posición más a la derecha del array en la que
no se haya colocado antes:

5 6

1 2

Se reemplaza en la posición del primer nodo padre al hijo que esté más abajo y más
a la derecha, en este caso, ese sería el 2; y el nodo que contenía al 2 ya no se lo toma
en cuenta:

2
5 6

Se vuelve a realizar el proceso de ordenación. Pero como el árbol ya se encuentra

ordenado, se procede con el siguiente paso: Se coloca el primer nodo padre en la
posición más a la derecha del array en la que no se haya colocado antes:

2 5 6

1
 Se reemplaza en la posición del primer nodo padre al hijo que esté más abajo y más
a la derecha, en este caso, ese sería el 1; y el nodo que contenía al 1 ya no se lo toma
en cuenta:

1 2 5 6

Cuando solo queda un nodo, simplemente se coloca el valor de ese último nodo en
el espacio sobrante del array:

1 2 5 6

Y este ya sería el array ordenado mediante HeapSort. Hay que recalcar que este
proceso de colocación de los valores del nodo en los espacios vacíos del array es solo
algo intuitivo, ya que en realidad todo el proceso se lleva a cabo en el mismo array.

Complejidad de Heap Sort: Es un algoritmo de ordenación no recursivo, no estable, con

complejidad computacional O (n log n)

 Ejemplo Búsqueda Binaria:

Por ejemplo: si se quiere buscar el 10 en el siguiente arreglo:

Paso 1: La búsqueda binaria busca la mitad:

Si es el resultado devuelve su posición, en otro caso busca de que lado esta el valor, y desecha la
mitad del arreglo

Paso 2: busca la mitad.

Si es el resultado devuelve su posición, en otro caso busca de que lado esta el valor, y desecha la
mitad del arreglo

Paso 3: busca la mitad.

Como se encontró el resultado, se regresa su posición que es la 3.

La complejidad de la búsqueda binaria de O( log2 n ).

Por ejemplo si se quiere buscar un numero en un arreglo de 1,000,000 de números, la búsqueda

binaria solo requerirá 20 pasos para encontrar el valor o determinar que no existe en el arreglo.