Metodo de Ordenamiento

UNIVERSIDAD NACIONAL MAYOR DE
SAN MARCOS
Universidad del Perú, Decana de América
FACULTAD DE INGENIERIA INDUSTRIAL
Métodos de ordenación y
búsqueda
Monografía
Integrantes:
 Trujillo Castro, Franco Tomas

 Mejía Apaza, Fernando
 Ramos Trujillo, Ricardo Alexander
 Espinoza Pisconte, Piero Alexander
Profesor
Ruiz Lizama
LIMA – PERÚ
2019
INDICE
INTRODCUCCIÓN ......................................................................................................... 3
MÉTODO DE LA BURBUJA ......................................................................................... 4
La complejidad (matemática discreta)....................................................................... 7
MÉTODO SHAKE SORT ............................................................................................... 8
METODO DE INSERCÍON ............................................................................................ 9
METODO DE SELECCIÓN DIRECTA ...................................................................... 11
METODO DE DONALD SHELL ................................................................................. 13
METODO QUICK SORT .............................................................................................. 15
MÉTODO RADIX SORT .............................................................................................. 17
CONCLUSIONES........................................................................................................... 19
BIBLIOGRAFIA............................................................................................................. 20
ANEXOS .......................................................................................................................... 21
INTRODCUCCIÓN
Dentro del mundo de la programación, el ordenamiento tiene una utilidad práctica
y para ello existen diversos algoritmos o métodos con el fin de ordenar datos.
Estos algoritmos son diferentes con respecto a lógica y nivel de complejidad, los
algoritmos que desarrollaremos serán los siguientes:
 Método de la burbuja
 La complejidad (matemática discreta)
 Método shake sort
 Método de inserción
 Método de selección directa
 Método de Donald Shell
 Método Quick sort
 Método Radix sort
MÉTODO DE LA BURBUJA
Se basa en recorrer el array ("realizar una pasada") un cierto número de veces,
comparando pares de valores que ocupan posiciones adyacentes (0-1,1-2, ...). Si ambos
datos no están ordenados, se intercambian. Esta operación se repite n-1 veces, siendo n el
tamaño del conjunto de datos de entrada. Al final de la última pasada el elemento mayor
estará en la última posición; en la segunda, el segundo elemento llegará a la penúltima, y
así sucesivamente. Metodología de la programación (I) 16/27 Su nombre se debe a que el
elemento cuyo valor es mayor sube a la posición final del array, al igual que las burbujas
de aire en un depósito suben a la parte superior. Para ello debe realizar un recorrido paso
a paso desde su posición inicial hasta la posición final del array.
Ejemplo: Sea P[6] el array a ordenar
A [6] 15 4 19 32 21 2
0 1 2 3 4 5
Primera Iteración:
2 32
4 15 21 32
A [6] 15 4 19 32 21 2
0 1 2 3 4 5
P [Ø]> P [1] → cambio 4, 15, 19, 21, 32, 2
P [1]> P [2] → no cambio
P [3]> P [4] → cambio
P [4]> P [5] → cambio

A [6] 4 15 19 21 32 2
0 1 2 3 4 5
Segunda Iteración:
2 21
A [6] 4 15 19 21 2 32
0 1 2 3 4 5
P [Ø]> P [1] → no cambio
P [3]> P [4] → cambio 4, 15, 19, 2, 21,32
A [6] 4 15 19 2 21 32
0 1 2 3 4 5
Tercera Iteración:
2 19
A [6] 4 15 19 2 21 32
0 1 2 3 4 5

P [2]> P [3] → cambio 4, 15, 2, 19, 21, 32
A [6] 4 15 2 19 21 32
0 1 2 3 4 5
Cuarta Iteración:
2 15
A [6] 4 15 2 19 21 32
0 1 2 3 4 5
P [1]> P [2] → cambio 4, 2, 15, 19, 21,32
P [2]> P [3] → cambio 4, 2, 15, 19, 21,32
P [3]> P [4] → cambio 4, 2, 15, 19, 21,32
A [6] 4 2 15 19 21 32
0 1 2 3 4 5
Quinta Iteración:
2 4
A [6] 4 2 15 19 21 32
0 1 2 3 4 5
P [Ø]> P [1] → cambio 2, 4, 15, 19, 21,32
A [6] 2 4 15 19 21 32
0 1 2 3 4 5
El arreglo queda en completo orden ascendente, nos damos cuenta que el algoritmo es
más extenso, en comparación de otros algoritmos.
A [6] 2 4 15 19 21 32
0 1 2 3 4 5
La complejidad (matemática discreta)
Esto es, el número de comparaciones c(n) no depende del orden de los términos, si no del
número de términos.
Por lo tanto, la cota ajustada asintótica del número de comparaciones pertenece al orden
de n cuadrado. El número de intercambios i(n), que hay que realizar depende del orden
de los términos y podemos diferencia, el caso mejor, si el vector esta previamente
ordenado, y el caso peor, si el vector esta ordenado en orden inverso.

Por lo que no se puede determinar una cota ajustada asintótica del número de
intercambios, dado que este dependerá del orden del vector en cuestión.
MÉTODO SHAKE SORT
Este método consiste de 2 fases por cada pasada, en la primera se hace una comparación
de izquierda a derecha como en el método de la Burbuja y en la segundase compara de
derecha a izquierda, de allí su nombre “Shake” (sacudida). Para visualizar de mejor
manera este método, lo ejemplificaremos con un arreglo de 5 elementos:
A [5]: 3 2 1 5 4
0 1 2 3 4
Primera pasada:
Fase 1
1
2 3 3
A [5]: 3 2 1 5 4
0 1 2 3 4
Si: A [0] > A [1] entonces hay cambio.
Como: A [2] no es > A [3] no hay cambio.
Fase 2
4 5
A [5]: 2 1 3 5 4
0 1 2 3 4
Si: A [4] < A [3] entonces hay cambio.
Como: A [3] no es < A [2] no hay cambio.

Segunda Pasada:
Fase 1
1 2
A [5]: 2 1 3 4 5
0 1 2 3 4
Como: A [1] no es > A [3] no hay cambio.
Fase 2
A [5]: 1 2 3 4 5
0 1 2 3 4
Arreglo ordenado:
A [5]: 1 2 3 4 5
0 1 2 3 4
METODO DE INSERCÍON
En este método de muchos elementos pertenecientes a un arreglo, se compara el

elemento de lugar k+1 con el anterior de lugar k. Si: Ek+1 < Ek entonces se intercambian
lugares. Para visualizar mejor este método de ordenamiento podemos ejemplificar de la
siguiente manera.
A [6]: 6 4 2 3 1 5
0 1 2 3 4 5
Primera pasada:
4 6
A [6]: 6 4 2 3 1 5
0 1 2 3 4 5
Segunda pasada:
4
2 2 6
A [6]: 4 6 2 3 1 5
0 1 2 3 4 5
Tercera pasada:
4
3 3 6
A [6]: 2 4 6 3 1 5
0 1 2 3 4 5
Cuarta pasada:
1
2 3 4
1 1 1 1 6
A [6]: 2 3 4 6 1 5
0 1 2 3 4 5

Quinta pasada:
5 6
A [6]: 1 2 3 4 6 5
0 1 2 3 4 5
Arreglo ordenado:
A [6]: 1 2 3 4 5 6
0 1 2 3 4 5
(Ejemplo en Método Inserción.cpp)
METODO DE SELECCIÓN DIRECTA
Este método consiste en buscar el menor elemento del arreglo y colocarlo en la

primera posición. Después se busca el segundo elemento menor del arreglo y colocarlo
en dicha posición, y así a cada elemento, de tal forma que se realice k-1 iteraciones, donde
k es el número de elementos que tiene el arreglo.
Por ejemplo, tenemos el siguiente arreglo:

A [6]: 5 8 4 9 7 0
0 1 2 3 4 5
Primera iteración:
Se procede a buscar el menor elemento, al cual se le llamará “Menor”, partiendo
del primer elemento y se irá comparando con los siguientes elementos hasta encontrar al
menor y este se igualará a la variable “Menor”
Menor
A [6]: 5 8 4 9 7 0
0 1 2 3 4 5
Menor = A [0] = 5
Menor < A [1] (5 < 8) Sí
Menor < A [2] (5 < 4) No → Menor = A [2] = 4
Menor < A [3] (4 < 9) Sí

Menor < A [4] (4 < 7) Sí
Menor < A [5] (4 < 1) No → Menor = A [5] = 0

Menor
A [6]: 0 8 4 9 7 5
0 1 2 3 4 5
Segunda iteración:
Ahora se procede a buscar el segundo elemento menor para ubicarlo en la
segunda posición del arreglo, para ello la variable Menor iniciará siendo A [1] para
comparando con los siguientes elementos.
Menor
A [6]: 0 8 4 9 7 5
0 1 2 3 4 5
Menor = A [1] = 8
Menor < A [2] (8 < 4) No → Menor = A [1] = 4
Menor < A [3] (4 < 9) Sí
Menor < A [4] (4 < 7) Sí
Menor < A [5] (4 < 5) Sí
Menor
A [6]: 0 4 8 9 7 5
0 1 2 3 4 5
Tercera iteración:
Se realiza el mismo procedimiento, ahora iniciando desde el tercer elemento: A [2] como
“Menor” para realizar las comparaciones
Menor
A [6]: 0 4 8 9 7 5
0 1 2 3 4 5
Menor = A [2] = 8
Menor < A [3] (8 < 9) Sí
Menor < A [4] (8 < 7) No → Menor = A [4] = 7
Menor < A [5] (7 < 5) No → Menor = A [5] = 5

Menor
A [6]: 0 4 5 9 7 8
0 1 2 3 4 5
Cuarta iteración:
Menor
A [6]: 0 4 5 9 7 8
0 1 2 3 4 5
Menor = A [3] = 9
Menor < A [4] (9 < 7) No → Menor = A [4] = 7
Menor < A [5] (7 < 8) Sí

Menor
A [6]: 0 4 5 7 9 8
0 1 2 3 4 5
Quinta iteración:
Menor
A [6]: 0 4 5 7 9 8
0 1 2 3 4 5
Menor = A [4] = 9
Menor < A [5] (9 < 8) No → Menor = A [5] = 8

Menor
A [6]: 0 4 5 7 8 9
0 1 2 3 4 5
ARREGLO ORDENADO:
A [6]: 0 4 5 7 8 9
0 1 2 3 4 5
(Ejemplo en Método Selección.cpp)
METODO DE DONALD SHELL
También llamado método de incrementos decrecientes. Este es el mejor método

cuando se trata de arreglos de varios elementos.
Consiste en ir comparando elementos de manera alternada, en intervalos (saltos h), donde

estos intervalos toman la división por defecto, en base a esto se ordenan de forma
creciente, luego de esto, el intervalo va reduciéndose, dividiéndose nuevamente, hasta
comparar los elementos adyacentes, obteniendo así el arreglo ordenado, sin necesidad de
hacer un número extenso de iteraciones.
Ejemplo: Ordenar el siguiente arreglo por el método de incrementos decrecientes.
A [14]: 13 7 1 9 12 3 4 6 5 8 14 2 10 11
0 1 2 3 4 5 6 7 8 9 10 11 12 13
Primera iteración:
Ya que el arreglo tiene 14 elementos, el salto h para esta iteración será 14 / 2 = 7, es decir,
los elementos se compararán cada 7 para luego ordenarse de menor a mayor (en sus
respectivos intervalos), obteniéndose de la siguiente manera:
A [14]: 13 7 1 9 12 3 4 6 5 8 14 2 10 11
0 1 2 3 4 5 6 7 8 9 10 11 12 13
A [14]: 6 5 1 9 2 3 4 13 7 8 14 12 10 11
0 1 2 3 4 5 6 7 8 9 10 11 12 13
Segunda iteración:
Ahora el salto h será la división por defecto 7 / 2 = 3. Se procederá a hacer las
comparaciones de forma alternada de 3 en 3.
A [14]: 6 5 1 9 2 3 4 13 7 8 14 12 10 11
0 1 2 3 4 5 6 7 8 9 10 11 12 13
A [14]: 4 2 1 6 5 3 8 11 7 9 13 12 10 14
0 1 2 3 4 5 6 7 8 9 10 11 12 13
Segunda iteración:
Una vez que el salto h resulte 1 (de la división por defecto de 3 / 2 = 1), se dará por
entendido que se trata de la última iteración, pues la comparación será entre todos los
elementos, cabe resaltar que el número de intercambio de posición no será significativo,
ya que la mayoría de estos ya fue ordenada en las iteraciones anteriores.
A [14]: 4 2 1 6 5 3 8 11 7 9 13 12 10 14
0 1 2 3 4 5 6 7 8 9 10 11 12 13
A [14]: 1 2 3 4 5 6 7 8 9 10 11 12 13 14
0 1 2 3 4 5 6 7 8 9 10 11 12 13
ARREGLO ORDENADO:
A [14]: 1 2 3 4 5 6 7 8 9 10 11 12 13 14
0 1 2 3 4 5 6 7 8 9 10 11 12 13
(Ejemplo en Método Shell.cpp)
METODO QUICK SORT

Método creado por C.A. HOARE quien utiliza el principio divide y vencerás.
Consiste en dividir en dos partes el arreglo a ordenar eligiendo un término

cualquiera de este (generalmente el valor central) como pivote, y a partir de él, se
realiza una partición en dos subarreglos, de tal manera que a la izquierda del pivote se
ubiquen todos los elementos del arreglo menores o igual que el pivote y a la derecha
todos los elementos mayores que el pivote.
pivote
A:
A [0] A [n-1]
< pivote > pivote
Con la partición aún no se logra el ordenamiento, por ello se vuelve a aplicar el

método a cada subarreglo.
A:
A:
⋮ ⋮
Aplicando el método quick sort para el siguiente arreglo:
A [6]: 6 4 2 3 1 5
0 1 2 3 4 5
Primera pasada:
Pivote = 2
A [6]: 6 4 2 3 1 5
6 1
A [6]: 1 4 2 3 6 5
0 1 2 3 4 5
Segunda pasada:
Pivote = 2
A [6]: 1 4 2 3 6 5
4 >
A [6]: 1 2 4 3 6 5
0 1 2 3 4 5
Tercera pasada:
Pivote = 4
A [6]: 1 2 4 3 6 5
< 3
A [6]: 1 2 3 4 6 5
0 1 2 3 4 5
Cuarta pasada:
A [6]: 4 6 5
< 5
A [6]: 1 2 3 4 5 6
0 1 2 3 4 5
Arreglo ordenado:
A [6]: 1 2 3 4 5 6
0 1 2 3 4 5
MÉTODO RADIX SORT

Este ordenamiento se basa en los valores de los dígitos reales en las
representaciones de posiciones de los números que se ordenan. Por ejemplo, el número
123 se escribe 1 en la posición de centenas, un 2 en la posición de decenas y un 3 en la
posición de unidades.
Este método evalúa cada digito individualmente, teniendo en cuenta el digito

menos significativos o el más significativo, de esta manera para el numero 123 es digito
menos significativo es el 3 y el más significativo es el 1. Así el método Radix sort no
solo se puede usar en arreglos numéricos, sino también para arreglos alfabéticos.
Para arreglos numéricos la mejor forma de ordenar por Radix es por el digito
menos significativo, se recorre el arreglo ordenando los números del 0 al 9 según su
digito menos significativo, luego el arreglo se ordena en el orden que resulta de ordenar
los números por su digito menos significativo. teniendo el número de iteraciones igual a
la cantidad de dígitos del mayor de los números en el arreglo.
Aplicación de Radix Sort:
A [14]: 13 7 1 9 12 3 4 6 5 8 14 2 10 11
0 1 2 3 4 5 6 7 8 9 10 11 12 13
Primera pasada:
A [14]: 13 7 1 9 12 3 4 6 5 8 14 2 10 11
0 1 2 3 4 5 6 7 8 9 10 11 12 13
0: 10
1: 1 11
2: 12 2
3: 13 3
4: 4 14
5: 5
6: 6
7: 7
8: 8
9: 9
A [14]: 13
10 7
1 1
11 9
12 12
2 3
13 43 46 5
14 8
5 14
6 2
7 10
8 11
9
0 1 2 3 4 5 6 7 8 9 10 11 12 13
Segunda Pasada:
A [14]: 13
10 7
1 1
11 9
12 12
2 3
13 43 46 5
14 85 14
6 27 10
8 11
9
0 1 2 3 4 5 6 7 8 9 10 11 12 13
0: 01 02 03 03 05 06 07 08 09
1: 10 11 12 13 14
2: no hay números con este digito significativo
A [14]: 1 2 3 4 5 6 7 8 9 10 11 12 13 14
0 1 2 3 4 5 6 7 8 9 10 11 12 13
Arreglo ordenado:
A [14]: 1 2 3 4 5 6 7 8 9 10 11 12 13 14
0 1 2 3 4 5 6 7 8 9 10 11 12 13
CONCLUSIONES
A partir de los métodos aquí vistos podemos concluir que, si bien cada método es
diferente en sí mismo, es importante la cantidad de datos que debe tener el arreglo a
ordenar, ya que, dependiendo de la eficacia del método, el número de iteraciones será
mayor o menor, así como también la velocidad con la que se ejecuta el algoritmo.
De esto podemos decir que los que métodos Shell, Quick, y Radix, son los más
eficaces a la hora de ordenar un arreglo, cabe resaltar que el método usado para una
ordenación está restringido al programador, y al tipo de código que desee desarrollar.
BIBLIOGRAFIA
 USPCEU (S.A). Algoritmos de Ordenación y Búsqueda. Recuperado el 9 de
Mayo del 2019, de
http://biolab.uspceu.com/aotero/recursos/docencia/TEMA%208.pdf
 -Citado dentro del texto: Método de la Burbuja.
 ECURED. Ordenamiento del Burbuja. Recuperado el 9 de Mayo del 2019, de
https://www.ecured.cu/Ordenamiento_de_burbuja
Citado dentro del texto: Complejidad (matemática discreta)
 ICT. Ordenamiento de Raíz (Radix Sort). Recuperado el 9 de Mayo del 2019, de

http://ict.udlap.mx/people/ingrid/Clases/IS211/Radix.html
 Ruíz Lizama, E., (2018). Algoritmos y estructura de datos, algoritmos y

programación. Lima, Perú. ERL.
ANEXOS
Método Insercion.cpp
Método Selección.cpp

Metodo de Ordenamiento

Transféré par

Informations du document

Description originale:

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Metodo de Ordenamiento

Transféré par

Droits d'auteur :

Formats disponibles

UNIVERSIDAD NACIONAL MAYOR DE

FACULTAD DE INGENIERIA INDUSTRIAL

 Trujillo Castro, Franco Tomas

MÉTODO DE LA BURBUJA ......................................................................................... 4

La complejidad (matemática discreta)....................................................................... 7

MÉTODO SHAKE SORT ............................................................................................... 8

METODO DE INSERCÍON ............................................................................................ 9

METODO DE SELECCIÓN DIRECTA ...................................................................... 11

METODO DE DONALD SHELL ................................................................................. 13

METODO QUICK SORT .............................................................................................. 15

MÉTODO RADIX SORT .............................................................................................. 17

Se basa en recorrer el array ("realizar una pasada") un cierto número de veces,

estará en la última posición; en la segunda, el segundo elemento llegará a la penúltima, y

así sucesivamente. Metodología de la programación (I) 16/27 Su nombre se debe a que el

a paso desde su posición inicial hasta la posición final del array.

Ejemplo: Sea P[6] el array a ordenar

P [Ø]> P [1] → cambio 4, 15, 19, 21, 32, 2

P [1]> P [2] → no cambio

P [2]> P [3] → no cambio

P [3]> P [4] → cambio

P [4]> P [5] → cambio

P [Ø]> P [1] → no cambio

P [1]> P [2] → no cambio

P [2]> P [3] → no cambio

P [3]> P [4] → cambio 4, 15, 19, 2, 21,32

P [4]> P [5] → no cambio

P [Ø]> P [1] → no cambio

P [1]> P [2] → no cambio

P [3]> P [4] → no cambio

P [4]> P [5] → no cambio

P [Ø]> P [1] → no cambio

P [1]> P [2] → cambio 4, 2, 15, 19, 21,32

P [2]> P [3] → cambio 4, 2, 15, 19, 21,32

P [3]> P [4] → cambio 4, 2, 15, 19, 21,32

P [4]> P [5] → no cambio

P [1]> P [2] → no cambio

P [2]> P [3] → no cambio

P [3]> P [4] → no cambio

P [4]> P [5] → no cambio

más extenso, en comparación de otros algoritmos.

La complejidad (matemática discreta)

de los términos y podemos diferencia, el caso mejor, si el vector esta previamente

ordenado, y el caso peor, si el vector esta ordenado en orden inverso.

MÉTODO SHAKE SORT

Si: A [0] > A [1] entonces hay cambio.

Si: A [1] > A [2] entonces hay cambio.

Como: A [2] no es > A [3] no hay cambio.

Si: A [4] < A [3] entonces hay cambio.

Como: A [3] no es < A [2] no hay cambio.

Si: A [0] > A [1] entonces hay cambio.

Como: A [1] no es > A [3] no hay cambio.

Como: A [5] no es < A [4] no hay cambio.

En este método de muchos elementos pertenecientes a un arreglo, se compara el

Si: A [2] < A [1] entonces hay cambio.

Si: A [1] < A [0] entonces hay cambio.

Si: A [3] < A [2] entonces hay cambio.

Si: A [2] < A [1] entonces hay cambio.

Como: A [1] no es < A [0] no hay cambio.

Si: A [4] < A [3] entonces hay cambio.

Si: A [3] < A [2] entonces hay cambio.

Si: A [2] < A [1] entonces hay cambio.

Si: A [1] < A [0] entonces hay cambio.

Si: A [5] < A [4] entonces hay cambio.