PORTADA

PORTADA

ESCUELA SUPERIOR POLITÉCNICA AGROPECUARIA DE MANABÍ

“MANUEL FÉLIX LÓPEZ”

CARRERA DE COMPUTACIÓN

NIVEL: QUINTO PERÍODO: ABRIL/SEPTIEMBRE 2019

INFORME

TEMA:

ALGORITMOS DE ORDENAMIENTO

AUTOR:
JESÚS A. GARCÍA MERA

FACILITADOR:
Dr. JORGE PÁRRAGA ÁLAVA

CALCETA, 06 JUNIO 2019

 2

CONTENIDO

PORTADA ....................................................................................................................................... 1
CONTENIDO ................................................................................................................................... 2
CONTENIDO DE IMÁGENES ........................................................................................................... 3
CONTENIDO DE ILUSTRACIONES ................................................................................................... 3
1. ALGORITMOS DE ORDENAMIENTOS ..................................................................................... 4
1.1 ORDENAMIENTO DE BURBUJA ...................................................................................... 4
1.1.1 DESCRIPCIÓN DEL ALGORITMO ............................................................................. 4
1.1.2 IMPLEMENTACIÓN DEL OREDENAMIENTO BURBUJA........................................... 5
1.1.3 ORDEN DE COMPLEJIDAD DEL ORDENAMIENTO DE BURBUJA............................. 5
1.2 ORDENAMIENTO POR SELECCIÓN................................................................................. 6
1.2.1 DESCRIPCIÓN DEL ALGORITMO ............................................................................. 7
1.2.2 IMPLEMENTACIÓN DEL ORDENAMIENTO POR SELECCIÓN .................................. 8
1.2.3 ORDEN DE COMPLEJIDAD DEL ORDENAMIENTO POR SELECCIÓN ....................... 9
1.3 ORDENAMIENTO POR INSERCIÓN............................................................................... 10
1.3.1 DESCRIPCIÓN DEL ALGORITMO ........................................................................... 10
1.3.2 IMPLEMENTACIÓN DE ORDENAMIENTO POR INSERCIÓN .................................. 12
1.3.3 ORDEN DE COMPLEJIDAD DEL ORDENAMIENTO POR INSERCIÓN ..................... 13
1.4 ORDENAMIENTO POR QUICKSORT ............................................................................. 14
1.4.1 DESCRIPCIÓN DEL ALGORITMO ........................................................................... 14
1.4.2 IMPLEMENTACIÓN DEL ORDENAMIENTO POR QUICKSORT ............................... 16
1.4.3 ORDEN DE COMPLEJIDAD DEL ORDENAMIENTO POR QUICKSORT .................... 16
1.5 ORDENAMIENTO DE MERGESORT .............................................................................. 17
1.5.1 DESCRIPCIÓN DEL ALGORITMO ........................................................................... 17
1.5.2 IMPLEMENTACIÓN DE ORDENAMIENTO MERGESORT. ...................................... 19
1.5.3 ORDEN DE COMPLEJIDAD DEL ORDENAMIENTO DE MERGESORT ..................... 20
1.6 ANÁLISIS DE LA EFICIENCIA DE LOS ALGORITMOS DE ORDENAMIENTO .................... 20
1.6.1 MEJOR CASO DE LOS ALGORITMOS DE ORDENAMIENTO .................................. 21
1.6.2 PEOR CASO DE LOS ALGORITMOS DE ORDENAMIENTOS ................................... 21
1.6.3 CASO PROMEDIO DE LOS ALGORITMOS DE ORDENAMIENTOS .......................... 22
2. CONCLUCIONES ................................................................................................................... 24
 3

CONTENIDO DE TABLAS

Tabla 1.- tiempo de ejecución mejor caso......................................................................................... 21

Tabla 2.- Tiempo de ejecución peor caso ......................................................................................... 22
Tabla 4.- tiempo de ejecución caso promedio ................................................................................... 23

CONTENIDO DE IMÁGENES

Imagen 1.-código de ordenamiento de burbuja en C++ ....................................................................... 5

Imagen 2.- código de ordenamiento por selección en C++ ................................................................... 8
Imagen 3.- código de ordenamiento por inserción en C++ ................................................................. 12
Imagen 4.- código de ordenamiento por quicksort en C++ ................................................................. 16
Imagen 5.- código de ordenamiento de mergesort en C++ ............................................................... 19

CONTENIDO DE ILUSTRACIONES

Ilustración 1.- grafica de comparación mejor caso ............................................................................ 21

Ilustración 2.- grafica de comparación peor caso ............................................................................. 22
Ilustración 3.- grafico de comparación caso promedio ...................................................................... 23
 4

1. ALGORITMOS DE ORDENAMIENTOS

1.1 ORDENAMIENTO DE BURBUJA

El funcionamiento de este algoritmo es ir revisando cada elemento de un vector

que va a ser ordenado con el siguiente, intercambiándolos de posición si están
en el orden equivocado. Es necesario revisar varias veces toda la lista hasta que
no se necesiten más intercambios, lo cual significa que el vector está ordenado.

1.1.1 DESCRIPCIÓN DEL ALGORITMO

El procedimiento del algoritmo de burbuja es el siguiente: Ir comparando desde

la posición 0 de un vector, número tras número hasta encontrar uno mayor, por
ejemplo, si el primer número del vector es el mayor de todos se lo llevará hasta
la última casilla del vector, si no es así, será reemplazado por uno mayor que él.
Este procedimiento seguirá así hasta que haya ordenado todas las casillas del
vector. Una de las deficiencias del algoritmo es que ya cuando ha ordenado parte
del vector vuelve a compararlo cuando esto ya no es necesario.

12 8 4 15 1 5 Hay cambio

8 12 4 15 1 5 Hay cambio

8 4 12 15 1 5 No hay cambio

8 4 12 15 1 5 Hay cambio

8 4 12 1 15 5 Hay cambio

8 4 12 1 5 15 El 15 ya está en su posición
 5

Las sucesivas operaciones en cada uno de los pasos necesarios hasta obtener
la clasificación final se muestran a continuación:

Vector
12 8 4 15 1 5
desordenado
iteración 1 8 4 12 1 5 15

iteración 2 4 8 1 5 12 15

Iteración 3 4 1 5 8 12 15

Iteración 4 1 4 5 8 12 15

Clasificación final 1 4 5 8 12 15

1.1.2 IMPLEMENTACIÓN DEL OREDENAMIENTO BURBUJA

Imagen 1.-código de ordenamiento de burbuja en C++

Fuente: Autor

1.1.3 ORDEN DE COMPLEJIDAD DEL ORDENAMIENTO DE

BURBUJA

Comenzando analizar el ordenamiento burbuja, se harán n−1 iteraciones para

ordenar una lista de tamaño n, El número total de comparaciones es la suma de
los primeros n−1.
 6

Inverso de las
Iteraciones Comparaciones comparaciones

1 n-1 1

2 n-2 2

3 n-3 3

… … ..

n-1 1 n-1

Recuerde que la suma de los primeros números enteros es:

𝑛
𝑛(𝑛 + 1)
∑=
2
1

Entonces para calcular el orden de complejidad remplazamos los datos que ya

tenemos que es la suma de los primeros n-1 enteros, son el total de
comparaciones, esto es:

𝑛−1
(𝑛 − 1)[(𝑛 − 1) + 1] 𝑛2 − 𝑛
∑= =
2 2
1

esto quiere decir que el orden de complejidad del ordenamiento de burbuja en

notación big-O es:

𝑂(𝑛2 )

1.2 ORDENAMIENTO POR SELECCIÓN

Algoritmo de ordenamiento por selección, consiste en encontrar el menor de

todos los elementos del vector e intercambiarlo con el que está en la primera
posición del vector. Luego el segundo más pequeño se lo intercambia con
segunda posición del vector y así sucesivamente hasta ordenarlo todo.
 7

1.2.1 DESCRIPCIÓN DEL ALGORITMO

Seguimos los siguientes pasos para realizar la selección: tenemos el siguiente

vector desordenado.

16 19 11 15 10 12 14

Ahora se busca el menor elemento de toda la lista y lo ubicamos en la primera

posición, todo esto sería en la primera iteración.

16 19 11 15 10 12 14

10 19 11 15 16 12 14

En la segunda iteración se comenzará a buscar el segundo menor elemento del

vector y se lo ubicará en la segunda posición.

10 19 11 15 16 12 14

10 11 19 15 16 12 14

Tercera iteración

10 11 19 15 16 12 14
10 11 12 15 16 19 14

Cuarta iteración

10 11 12 15 16 19 14
10 11 12 14 16 19 15

Quinta iteración

10 11 12 14 16 19 15

10 11 12 14 15 19 16
 8

Sexta iteración

10 11 12 14 15 19 16
10 11 12 14 15 16 19

Resultado

10 11 12 14 15 16 19

1.2.2 IMPLEMENTACIÓN DEL ORDENAMIENTO POR SELECCIÓN

Imagen 2.- código de ordenamiento por selección en C++

Fuente : Autor
 9

1.2.3 ORDEN DE COMPLEJIDAD DEL ORDENAMIENTO POR

SELECCIÓN

Para calcular el orden de complejidad, pensemos cuantas comparaciones tienes

que hacer, entonces en la primera iteración cuando se encuentra el menor de
todos los elementos, teniendo n elementos en el vector ¿Cuántas
comparaciones se tiene que hacer?, n-1, ya se tiene el primer elemento
ordenado, ahora en la segunda iteración se comienza desde la segunda posición
del vector, quiere decir que ya se harán n-2 comparaciones y así sucesivamente.

Inverso de las
Iteración Comparaciones Comparaciones
1 n-1 1

2 n-2 2

3 n-3 3

….. … …

n-1 1 n-1

Ahora para encontrar el número total de comparaciones hay que sumar los
primeros n-1 enteros. Recuerde que la suma de los primeros números enteros
es:
𝑛
𝑛(𝑛 + 1)
∑=
2
1

Por lo tanto, la suma de los primeros n-1 enteros es:

𝑛−1
(𝑛 − 1)[(𝑛 − 1) + 1] 𝑛2 − 𝑛
∑= =
2 2
1

En conclusión, el orden de complejidad está dada por la expresión anterior, pero

en notación big-O el orden de complejidad del ordenamiento por selección es:

𝑂(𝑛2 )
 10

1.3 ORDENAMIENTO POR INSERCIÓN

Este método consiste en insertar un elemento en el vector en una parte ya

ordenada de este vector y comenzar de nuevo con los elementos restantes. Es
una manera muy natural para un ser humano, y poder usarse fácilmente para
ordenar un mazo de cartas numeradas en forma arbitraria.

1.3.1 DESCRIPCIÓN DEL ALGORITMO

Como los ordenamientos anteriores vamos a tomar un vector desordenado como

ejemplo, el método se basa en comparaciones y desplazamientos sucesivo. El
recorrido se realiza desde el segundo elemento al n-ésimo, pero ¿porque desde
la segunda posición ?, la razón es porque el algoritmo va haciendo
comparaciones con un elemento de la posición p con otro de la posición p-1, y
cuando se compare el elemento de la primera posición del vector no se podrá
realizar la comparación ya que no existe otro elemento hacia la izquierda.

5 3 4 1 2

La condición que se evalúa para realizar intercambios será la siguiente;

Si (número izquierda > número actual) entonces hay cambio.

La flecha indicara en qué posición del vector vamos, comenzamos a comparar,

pero como se nota estamos en la primera posición, quiere decir que a la izquierda
del 5 no hay ningún valor más, por lo que la flecha avanza una posición.

5 3 4 1 2

Entonces comparamos ¿5 es mayor a 3?, si lo es, por lo tanto, hay un cambio.

5 3 4 1 2
 11

3 5 4 1 2

Ahora como ya de nuevo estamos en la primera posición no es necesario hacer

la comparación y avanza la flecha.

3 5 4 1 2

Otra vez hacemos la comparación, ¿5 es mayor a 4?, lo es, por lo tanto, hay
cambio.
3 4 5 1 2

ahora ¿3 es mayor a 4?, no por lo tanto esta ordenado y avanza la flecha

3 4 5 1 2

Comparamos ¿5 es mayor que 1?, lo es, por lo tanto, hay cambio

3 4 1 5 2

Ahora ¿4 es mayor que 1?, lo es, por lo tanto, hay cambio

3 1 4 5 2

Y ahora ¿3 es mayor que 1?, lo es, por lo tanto, hay cambio, y ahora como ya
está en la primera posición del vector no es necesario hacer la comparación y
avanza la flecha.
 12

1 3 4 5 2

1 3 4 5 2

Se realizarán comparaciones de la misma forma que realizaron anteriormente

para los otros valores, por lo tanto, el 2 llegará a la posición que le corresponde
y al realizar todas las iteraciones se obtendrá como resultado un vector
ordenado.

1 2 3 4 5

1.3.2 IMPLEMENTACIÓN DE ORDENAMIENTO POR INSERCIÓN

Imagen 3.- código de ordenamiento por inserción en C++

Fuente: Autor
 13

1.3.3 ORDEN DE COMPLEJIDAD DEL ORDENAMIENTO POR

INSERCIÓN

Este algoritmo al momento de ordenar un vector se dividirá las dos partes, la

parte ordenada y la parte no ordenada del vector. Comencemos con la parte
ordenada del vector que es donde el lado donde vamos a ordenar el vector, en
la primera iteración el número de comparaciones solo es 1, en la segunda
iteración hay 2 comparaciones y así sucesivamente esto quiere decir que el
número de comparaciones va hacer la suma de los primeros n-1 enteros. Y por
otro lado en la parte ordenada solo serán n-1 comparaciones.

Iteración No ordenado Ordenado

1 1 1

2 1 2

3 1 3

….. … …

n-1 n-1 n-1

Como en los ordenamientos anteriores la suma de los primeros n-1 entero es:

𝑛−1
𝑛(𝑛 − 1)
∑=
2
1

Esta parte seria de la parte ordenada, entonces para determinar el orden de

complejidad solo basta como sumar la parte no ordenada.

𝑛−1
𝑛(𝑛 − 1) 2(𝑛 − 1) + (𝑛 − 1)𝑛
∑= + (𝑛 − 1) =
2 2
1

2𝑛 − 2 + 𝑛2 − 𝑛
2
 14

Por lo tanto, el orden de complejidad en notación big-O del ordenamiento por inserción
es de:

𝑂(𝑛2 )

1.4 ORDENAMIENTO POR QUICKSORT

El método de ordenación por quicksort para ordenar un vector de elementos se

basa en el hecho de que es más rápido y fácil de ordenar dos listas pequeñas
que una lista grande. Se denomina método de ordenación rápida porque, en
general, puede ordenar una lista de datos mucho más rápidamente que
cualquiera de los métodos de ordenación ya estudiados.

El método se basa en la estrategia de “divide y vencerás”. El vector a ordenar se

divide en dos subvectores: una con todos los valores menores o iguales a un
cierto valor específico y otra con todos los valores mayores que ese valor. El
valor elegido puede ser cualquier valor arbitrario del vector. En este método de
ordenamiento se llama a este valor pivote.

1.4.1 DESCRIPCIÓN DEL ALGORITMO

El ordenamiento por quicksort tiene el siguiente funcionamiento: primero escoge

un pivote entre todo el elemento, luego coloca todos los elementos menores o
iguales al pivote al lado izquierdo y todos los valores mayores o iguales al lado
derecho del pivote, al hacer este procedimiento se obtiene la posición que le
corresponde al pivote que se a elegido.

Después se escoge la parte izquierda del vector, se elige otro pivote, y se lo

coloca en la posición que le corresponde, este procedimiento se realiza hasta
que el tamaño del subvector sea 1, porque cunando el vector es 1 quiere decir
que esta ordenado, luego se va por la parte derecha y se hace el mismo
procedimiento, escoger pivote colocarlo en la posición que le corresponde y
seguir dividiendo hasta que el subvector sea de tamaño 1.
 15

8 3 6 4 2 5 7 1

1 3 2 4 6 5 7 8

1 2 3 5 6 7 8

1 2 6 7 8

1 2 6 7 8

6 8

1 2 3 4 5 6 7 8

Todo esto se lo hace mediante la recursión, al final de todo el procedimiento tanto

de la parte izquierda como de la parte derecha, es ir uniendo lo elementos que
habían quedado ordenados. Una manera fácil de decir, es que cuando el tamaño
del subvector es uno, el elemento esta ordenado, desde ahí comienza a regresar
ese vector uniéndose con los que habían quedado ordenado obteniendo como
resultado el vector ordenado.
 16

1.4.2 IMPLEMENTACIÓN DEL ORDENAMIENTO POR QUICKSORT

Imagen 4.- código de ordenamiento por quicksort en C++

Fuente: Autor

1.4.3 ORDEN DE COMPLEJIDAD DEL ORDENAMIENTO POR

QUICKSORT

Si se elige como pivote el primer elemento del vector y además se considera que
el vector esta ordenado decrecientemente entonces, el bucle para cada
elemento se ejecutará en total:

(n − 1) + (n − 2) + (n − 3)+. . . . +1

Cada miembro de este sumando proviene de cada una de las sucesivas

ordenaciones recursivas.
 17

Este sumatorio da lugar a la siguiente expresión:

𝑛−1
[(𝑛 − 1) + 1](𝑛 − 1) 𝑛2 − 𝑛
∑= =
2 2
1

En conclusión, esto determina que el orden de complejidad en notación big-O es:

𝑂(𝑛2 )

1.5 ORDENAMIENTO DE MERGESORT

Es un algoritmo de ordenamiento externo estable basado en la técnica divide y

vencerás. Conceptualmente el ordenamiento por mezcla funciona de la siguiente
manera:

1. Si la longitud del vector es 0 o 1, entonces ya está ordenado.

2. Caso contrario, Dividir el vector al medio, formando dos subvectores de

aproximadamente el mismo tamaño cada una, hay que realizar el mismo
proceso para cada sublistas hasta que el tamaño de la sublistas sea de 1
o 0.

3. Ordenar cada subvector recursivamente aplicando el ordenamiento por

mezcla

1.5.1 DESCRIPCIÓN DEL ALGORITMO

Como en todos los algoritmos anteriores se comienza con un vector

desordenado.

8 3 6 4 2 5 7 1

Se realizarán dos fases para obtener el vector ordenado, la primera será dividir
todo el vector, ya la segunda será ordenar todo el vector.

Fase 1: dividir
 18

8 3 6 4 2 5 7 1

8 3 6 4 2 5 7 1

8 3 6 4 2 5 7 1

8 3 6 4 2 5 7 1

Hasta ahora se dividió todo el vector desordenado en 8 subvectores uno para

cada elemento, por lo tanto, ahora se tiene que comparar y ordenar de la misma
marera que fueron divididos cada subvector, los valores deben ser
intercambiados de menor a mayor, esto quiere decir que desde aquí comienza
la fase de ordenar el vector.

Fase 2: ordenar

8 3 6 4 2 5 7 1

3 8 4 6 2 5 1 7

3 4 6 8 1 2 5 7

1 2 3 4 5 6 7 8
 19

1.5.2 IMPLEMENTACIÓN DE ORDENAMIENTO MERGESORT.

Imagen 5.- código de ordenamiento de mergesort en C++

Fuente: Autor
 20

1.5.3 ORDEN DE COMPLEJIDAD DEL ORDENAMIENTO DE

MERGESORT

Este algoritmo para ordenar y mezclar el número de comparaciones es de n-1

por el número de subvectores, pero eso no es todo como sabemos cuántos
subvectores o niveles tiene que realizar el ordenamiento, se sabe que cada
subvector se divide en la mitad esto quiere decir que el tamaño del vector por
cada nivel lo dividimos para 2 hasta que solo quede un subvector de tamaño 1.

𝑛
𝑏𝑎𝑗𝑎𝑟𝑎 𝑘 𝑛𝑖𝑣𝑒𝑙𝑒𝑠 → → 𝑛 = 2𝑘
2𝑘

Para despejar los k niveles que bajará el ordenamiento aplicamos propiedad de

los logaritmos.

𝑏 𝑐 = 𝑎 < − > log 𝑏 𝑎 = 𝐶

2𝑘 = 𝑛 < − > log 2 𝑛 = 𝑘

Ahora que ya se sabe cuántos niveles bajará el ordenamiento, se puede calcular

el orden de complejidad multiplicando el número de comparaciones por en
número de niveles o subvectores.

(𝑛 − 1) ∗ ( log 2 𝑛)

Por lo tanto, el orden de complejidad en notación big-O de mergesort es:

O(n ∗ log 𝑛)

1.6 ANÁLISIS DE LA EFICIENCIA DE LOS ALGORITMOS DE

ORDENAMIENTO

A continuación, se mostrarán los tiempos de ejecución que dura cada algoritmo

para diferentes tamaños de entrada y además para el mismo tamaño se
evaluaran los tres casos básicos de los algoritmos que son, el mejor caso, el
peor caso, y el caso promedio.
 21

1.6.1 MEJOR CASO DE LOS ALGORITMOS DE ORDENAMIENTO

Para evaluar el tiempo de ejecución en el mejor caso se ha optado por llenar un

vector ordenado, a continuación, se muestra los tiempos y la gráfica de
comparación.

Tabla 1.- tiempo de ejecución mejor caso

Fuente: Autor

Ilustración 1.- grafica de comparación mejor caso

Fuente: Autor

1.6.2 PEOR CASO DE LOS ALGORITMOS DE ORDENAMIENTOS

Para el peor caso, el vector de tamaño n está completamente desordenado, esto

es que el vector está en el orden inverso a como se lo quiere ordenar, ahora se
mostraran los tiempos de ejecución y la gráfica.
 22

Tabla 2.- Tiempo de ejecución peor caso

Fuente: Autor

Ilustración 2.- grafica de comparación peor caso

Fuente: Autor

1.6.3 CASO PROMEDIO DE LOS ALGORITMOS DE

ORDENAMIENTOS

Respecto al caso promedio se optará por un vector de tamaño n con elementos

sin ningún orden en específico.
 23

Tabla 3.- tiempo de ejecución caso promedio

Fuente: Autor

Ilustración 3.- grafico de comparación caso promedio

Fuente: Autor
 24

2. CONCLUCIONES

 Se considera importante que siempre que se piense en un algoritmo, se

realice un análisis de complejidad del algoritmo, aunque no todos los
algoritmos son tan fáciles de analizar, para la mayoría es fácil determinar
la función de crecimiento del mismo.

 Calcular la complejidad de un algoritmo nos puede dar una idea de cuánto

tiempo va a tardar el mismo, y en base a los tamaños de la entrada podrán
determinar si nuestro programa correrá en tiempo optimo o no, por otra
parte, podemos concluir que el algoritmo más eficiente entre los que
estudiamos anteriormente es el mergsort.