UNIVERSIDAD CENTRAL DEL ECUADOR

FACULTAD DE INGENIERÍA CIENCIAS
FÍSICAS
Y MATEMÁTICA

INGENIERÍA MATEMÁTICA

Integrantes:
 Espinoza Gabriela
 Guamán Bryan
 Meneses Fernanda
 Morocho Jeison

Asignatura: Programación I
Curso: Primer Semestre
Paralelo: 10

Tema:
Método de Ordenamiento por Selección Directa

1


Tabla de contenidos

INTRODUCCIÓN .................................................................................................... 2
OBJETIVOS DE LA INVESTIGACIÓN .................................................................... 3
MARCO TEÓRICO .................................................................................................. 4
CARACTERÍSTICAS: .............................................................................................. 5
PSEUDOCÓDIGO ................................................................................................... 6
EJEMPLOS. ............................................................................................................ 7
CONCLUSIONES .................................................................................................... 9
RECOMENDACIONES ........................................................................................... 9
BIBLIOGRAFÍA ..................................................................................................... 10












2

INTRODUCCIÓN

En computación y matemáticas un algoritmo de ordenamiento es un algoritmo que
pone elementos de una lista o un vector en una secuencia dada por una relación
de orden, es decir, el resultado de salida ha de ser una permutación o
reordenamiento de la entrada que satisfaga la relación de orden dada. Las
relaciones de orden más usadas son el orden numérico y el orden lexicográfico.
Ordenamientos eficientes son importantes para optimizar el uso de otros
algoritmos (como los de búsqueda y fusión) que requieren listas ordenadas para
una ejecución rápida. También es útil para poner datos en forma canónica y para
generar resultados legibles por humanos.


Se han desarrollado muchas técnicas a nivel de programación para clasificar
elementos, cada una con características específicas, y con ventajas y desventajas
sobre las demás. Las veremos a continuación.
Los algoritmos de ordenamiento se pueden clasificar de acuerdo a su
comportamiento como sigue:

Estable: Si el orden relativo de los elementos con la misma clave no se altera en
el proceso de ordenación

Natural: Si funciona óptimamente cuando los elementos ya están ordenados.

Antinatural: Si funciona peor cuando los elementos están ordenado




3


OBJETIVOS DE LA INVESTIGACIÓN


 Realizar una investigación detallada acerca del método de selección para
tener nociones claras sobre éste y poder así aplicarlo en la creación de
programas.

 Explicar la forma en que se aplica este método mediante un pseudocódigo
que indique cómo funciona.


 Ejecutar un video para reforzar los conocimientos adquiridos acerca de este
método.















4

MARCO TEÓRICO

Ordenación por selección directa (Selection Sort)
El algoritmo de ordenamiento por el método de selección directa es un algoritmo
relativamente sencillo y uno de los más fáciles de recordar e implementar.

Se basa en realizar varias pasadas, intentando encontrar en cada una de ellas el
elemento que según el criterio de ordenación es mínimo y colocándolo
posteriormente en su sitio.


A efectos prácticos, no suele dar resultados buenos si se compara con otros
métodos de ordenación. Realiza una enorme cantidad de comparaciones, pero en
contrapartida, muy pocos intercambios. Eso hace que su utilización se restrinja en
general a dos situaciones: o bien necesitamos un algoritmo sencillito para ordenar
unos pocos datos y cogemos éste mismo que no está mal y es facil de recordar, o
bien tenemos una situación en la cual escribir en el array es mucho más gravoso
que leer, como puede ser un escenario en el que intervengan determinados
dispositivos de almacenamiento o memorias tipo flash, eeprom, etc. para el
soporte de los datos.


Este algoritmo se basa en hacer comparaciones, así que para que realice su
trabajo de ordenación son imprescindibles dos cosas: un array o estructura similar
de elementos comparables y un criterio claro de comparación, tal que dados dos
elementos nos diga si están en orden o no.


Es un algoritmo no estable de ordenación interna y su complejidad temporal en el
peor caso es del orden de O(n
2
) y en el mejor caso -que el array ya esté
totalmente ordenado- pues también es Ω(n2) siendo n el tamaño del array a
ordenar... el caso es que éste algoritmo siempre hace el mismo número de
comparaciones e intercambios para un n dado... así que no aprovecha una posible
ordenación parcial del array. En cuanto a la complejidad espacial, es muy
ahorrativo: tan solo necesita una variable temporal para realizar los intercambios,
así que su gasto de memoria es constante, sea cual sea el tamaño del array.
Aunque se suele utilizar para ordenación interna, puede usarse para ordenación
externa si nos es imprescindible una complejidad espacial constante y muy baja.
Esa situación no suele darse, excepto, quizá, en pequeños dispositivos dotados de
una cantidad de memoria principal muy muy reducida y en los que además, los
datos estén en un soporte cuya lectura sea mucho más rápida que la escritura.



5

CARACTERÍSTICAS:


 El algoritmo ubica elementos de un arreglo, en una secuencia, dada por
una relación de orden.

 Buscar el mínimo elemento entre la posición i y el final de la lista.

 Intercambiar el mínimo con el elemento de la posición i.

 Su implementación es con ciclos anidados.
1




El algoritmo consiste en realizar varias pasadas sobre el array, logrando que en
cada pasada el elemento de menor valor se coloque al principio del array en un
solo intercambio. En cada pasada se recorre la parte no ordenada del array
realizando comparaciones con objeto de buscar el elemento de menor valor. Una
vez localizado, se intercambia por el primer elemento de la parte no ordenada, y
entonces ya está en orden. Por eso, se suele implementar con dos bucles, uno
anidado dentro del otro. El bucle exterior realiza las pasadas y el interior localiza el
menor elemento.


Vamos a intentar ver informalmente el funcionamiento del algoritmo. Supondremos
que el array tiene n elementos:

 Realizaremos n-1 pasadas. En cada una de ellas lograremos que el
elemento de menor valor se sitúe al principio. El motivo de realizar n-1
pasadas y no n es que si en cada pasada logramos ordenar un elemento,
cuando tengamos en orden los n-1 del principio del array el elemento que
queda al final del array es necesariamente el que nunca ha sido escogido
como más pequeño de todos... es decir, es el más grande, y directamente
se ha quedado el último.
 En cada pasada recorreremos el array empezando por el elemento que aún
no tengamos en orden (en la primera pasada lo revisamos todo, pero en la
segunda ya empezamos por el segundo elemento, ya que el primero estará
en orden... y así sucesivamente), buscando el menor de todos los
elementos que aún están sin ordenar. Cuando se haya localizado ese
elemento, se intercambia con el primero de la parte sin ordenar.
 En la primera pasada, buscaremos el mínimo entre los n elementos.
Cuando lo encontremos, lo ponemos en el primer lugar, y el elemento que

1
(Corrales, 1994)
6

había en primer lugar lo ponemos en el hueco que dejó ese. Como es el
mínimo, habremos logrado poner en orden un elemento y nos quedan los n-
1 siguientes.
 En la segunda pasada, buscaremos el mínimo entre los n-1 elementos que
nos quedan por ordenar. Cuando lo encontremos lo intercambiamos con el
elemento de la segunda posición. Ya tendremos ordenados dos elementos
y nos quedarán n-2 por ordenar.
 En la tercera pasada haremos lo mismo con los n-2 últimos elementos,
logrando colocar el tercer elemento en orden... y así sucesivamente, hasta
que tengamos colocados todos menos uno (n-1). Cuando estemos en esa
situación, el último elemento también estará en orden, ya que será el más
grande de todos, porque en ninguna de las n-1 pasadas ha sido escogido
como mínimo.

PSEUDOCÓDIGO

//método java de ordenación por selección
public static void seleccion(int A[])
{
int i, j, menor, pos, tmp;
for (i = 0; i < A.length - 1; i++) // tomamos como menor el primero
{
menor = A[i]; // de los elementos que quedan por ordenar
pos = i; // y guardamos su posición
for (j = i + 1; j < A.length; j++) // buscamos en el resto
{
if (A[j] < menor) // del array algún elemento
{
menor = A[j]; // menor que el actual
pos = j;
}
}
if (pos != i){ // si hay alguno menor se intercambia
tmp = A[i];
A[i] = A[pos];
A[pos] = tmp;
}
}

El tiempo de ejecución del algoritmo de ordenación por selección es del orden O(n
2
)
2



2
(Garcia, 2013)
7


EJEMPLOS:

Ejemplo 1:

Supongamos que queremos ordenar estos valores con el algoritmo de selección
directa: 45, 52, 21, 37, 49, así pues, n=5

1ª pasada: buscamos entre los últimos n (es decir, 5) elementos el menor de
todos, y lo intercambiaremos con la primera posición.
45, 52, 21, 37, 49 → Para buscar el menor, necesitaremos un bucle for que
recorra los n últimos elementos.
45, 52, 21, 37, 49 → El menor es el 21, colocado en tercera posición.
45, 52, 21, 37, 49 → Lo intercambiamos con el de la primera posición.
21, 52, 45, 37, 49 → Ya tenemos uno en orden. Nos quedan los n-1 últimos.
2ª pasada: buscamos entre los últimos n-1 (es decir, 4) elementos el menor de
todos, y lo intercambiaremos con la segunda posición.
21, 52, 45, 37, 49 → Recorremos los cuatro últimos y el menor es el 37.
21, 37, 45, 52, 49 → Lo intercambiamos con la segunda posición y ya hay dos en
orden.
3ª pasada: buscamos entre los últimos n-2 (es decir, 3) elementos el menor de
todos, y lo intercambiaremos con la tercera posición.
21, 37, 45, 52, 49 → El menor es el 45, en tercera posición.
21, 37, 45, 52, 49 → El 45 ya estaba en 3ª posición, así que al intercambiarlo con
él mismo, se queda donde está. Ya tenemos tres en orden.
4ª y última pasada: buscamos entre los últimos n-3 (es decir, 2) elementos el
menor de todos, y lo intercambiaremos con la cuarta posición.
21, 37, 45, 52, 49 → El menor es el 49, en quinta posición.
21, 37, 45, 49, 52 → Lo intercambiamos con la cuarta posición. Ya hay cuatro en
orden.
21, 37, 45, 49, 52 → El último está necesariamente en orden también.
3




3
(La Tecla de Escape, 2012)
8

Ejemplo 2:
Vector antes:
44, 55, 12, 42, 94, 18, 06, 67
Mínimo en posición 7 y tras intercambio: en posición 7 y tras intercambio:
intercambio:
06, 55, 12, 42, 94, 18, 44, 67
Mínimo en posición 3 y tras intercambio: 3 y tras intercambio:
06 12 55 42 94 18 44 67 06, 12, 55, 42, 94, 18, 44, 67
Mínimo en posición 6 y tras intercambio: 6 y tras intercambio:
06, 12, 18, 42, 94, 55, 44, 67
Mínimo en posición 4 y tras 4 y tras intercambio:
06, 12, 18, 42, 94, 55, 44, 67
Mínimo en posición 7 y tras intercambio: 7 y tras intercambio:
06, 12, 18, 42, 44, 55, 94, 67
Mínimo en posición 6 y tras intercambio: 6 y tras intercambio:
06, 12, 18, 42, 44, 55, 94, 67
Mínimo en posición 8 y tras intercambio: 8 y tras intercambio:
06, 12, 18, 42, 44, 55, 67, 94
Vector después:
06, 12, 18, 42, 44, 55, 67, 94
4





4
(Marroquin, 2010)
9

CONCLUSIONES

 Es un método lento ya que realiza numerosas comparaciones.
 Es un algoritmo sencillo y fácil de recordar e implementar ya que consiste
ordenar los elementos de menor a mayor.

RECOMENDACIONES


 Estructurar de manera correcta el algoritmo para que pueda ejecutarse
adecuadamente el método.
 Utilizar este método en caso de que no se tenga una cantidad de
elementos muy extensa ya que de lo contrario, al tener que realizar varios
cambios de posición puede resultar lento.





















10

BIBLIOGRAFÍA

Corrales, M. (1994). Metodo de Selección. En M. Corrales, Lenguaje Logo III (pág. 201). Costa Rica:
Editorial Universidad Estatal a distancia.

Garcia, E. (18 de Abril de 2013). Programación Java. Recuperado el 1 de Junio de 2014, de
http://puntocomnoesunlenguaje.blogspot.com/2012/12/java-metodo-ordenacion-
seleccion.html

La Tecla de Escape. (17 de Agosto de 2012). La tecla de Escape. Recuperado el 1 de Junio de 2014,
de
http://latecladeescape.com/t/Ordenaci%C3%B3n+por+selecci%C3%B3n+directa+(Selectio
nSort)

Marroquin, N. (2010). Metodo de seleccion. En N. Marroquin, Teas los pasos de un Hacker (pág.
719). Quito- Ecuador: NMC. Research Cia. Linitada.