Teoría 9 PDF

ALGORITMOS Y
PROGRAMACIÓN
Clase 9
Ordenación y búsqueda
Dr. Lic. Waldo Hasperué

Temario
• Ordenación
• Ordenación por intercambio
• Ordenación por selección
• Ordenación por inserción
• Ordenación por burbuja
• Ordenación rápida (quicksort).
• Búsqueda
• Búsqueda secuencial
• Búsqueda binaria
Ordenación
• Muchos problemas de la vida real requiere que los datos
utilizados se encuentren en un determinado orden.
• La ordenación de datos es una operación que consiste

en disponer un conjunto de datos en algún orden
específico.
• El tener una colección de datos ordenada facilita las

tareas de búsqueda de elementos e inserción de nuevos
datos a la colección.
Ordenación
• Si la colección de elementos es:
int [] datos = new datos[] { 4, 7, 5, 1, 3 };
• Se espera que el arreglo quede de esta forma:
1 3 4 5 7
• Notar que una colección se puede ordenar de manera

ascendente o descendente.
Ordenación por intercambio
• Se basa en la lectura sucesiva de la colección a ordenar,
comparando el elemento que se encuentra en cada
posición de la colección con los elementos restantes y
efectuando intercambio de elementos cuando el orden
resultante de la comparación no sea el correcto.
• Este algoritmo necesita realizar n−1 pasadas para

finalizar la tarea, donde n es la cantidad de elementos de
la colección.
• El elemento que está en la primer posición se compara
contra todos los restantes
4 7 5 1 3
Se compara el 4 con el 7. Como 4 es menor no

se realiza el intercambio
4 7 5 1 3

se realiza el intercambio
4 7 5 1 3
Se compara el 4 con el 1. En este caso, 1 es

menor que 4. Se realiza el intercambio
1 7 5 4 3
Se compara el 4 con el 1. En este caso, 1 es

menor que 4. Se realiza el intercambio
1 7 5 4 3

se realiza el intercambio.
Notar que siempre se compara el elemento que
está en la primera posición del arreglo (sin
importar cual sea).
1 7 5 4 3
Finalizó la primer vuelta. ¿Qué se logró?

1 7 5 4 3
El elemento más chico está en la primer

posición del arreglo.
• El elemento que está en la segunda posición se compara
1 7 5 4 3
Ahora se compara el elemento de la segunda

posición contra los restantes (elementos 5, 4 y
3). La posición 1 ya no se revisa, tiene el
elemento que debe ir en dicha posición.
1 7 5 4 3
Se compara el 7 con el 4. Se realiza el

intercambio
1 5 7 4 3

intercambio
1 5 7 4 3

intercambio
1 4 7 5 3

intercambio
1 4 7 5 3

intercambio
1 3 7 5 4

intercambio
• El elemento que está en la tercera posición se compara
1 3 7 5 4

intercambio
1 3 5 7 4

intercambio
1 3 5 7 4

intercambio
1 3 4 7 5

intercambio
• El elemento que está en la cuarta posición se compara
1 3 4 7 5

intercambio
• El elemento que está en la cuarta posición se compara
1 3 4 5 7

intercambio
• Fin del algoritmo
1 3 4 5 7
El arreglo está ordenado

private static void ordenarPorIntercambio(int [] datos){
int n = datos.Length;
for(int i=0; i<(n-1); i++)
for(int j=i+1; j<n; j++)
if(datos[i] > datos[j]){
int swap = datos[i];
datos[i] = datos[j];
datos[j] = swap;
cswap++;
}
}
for(int i=0; i<(n-1); i++)
datos[j] = swap;
cswap++; ¿Qué modificación
} hay que hacerle al
algoritmo para
} ordenar de mayor a
menor?
for(int i=0; i<(n-1); i++)
if(datos[i] < datos[j]){
datos[j] = swap;
cswap++; Simplemente cambiar
} la condición de
} comparación.
Cambiar el ">" por "<"
Ordenación por selección
Este algoritmo realiza los siguientes pasos:
1. Seleccionar el elemento más pequeño de la lista;
intercambiarlo con el primer elemento. Ahora la entrada
más pequeña está en la primera posición.
2. Considerar las posiciones restantes de la lista y
seleccionar el elemento más pequeño e intercambiarlo
con el segundo elemento.
Ahora las dos primeras entradas están en orden.
3. Continuar este proceso seleccionando los elementos
más pequeño de los restantes elementos de la lista e
intercambiándolos adecuadamente.
• Buscar el elemento más chico y ponerlo en la
primer posición
4 7 5 1 3
El elemento más chico es el 1.

primer posición
1 7 5 4 3
Se coloca en la primer posición haciendo el

intercambio de elementos.
segunda posición
1 7 5 4 3

segunda posición
1 3 5 4 7
Se coloca en la segunda posición haciendo el

tercera posición
1 3 5 4 7

tercera posición
1 3 4 5 7
Se coloca en la tercera posición haciendo el

cuarta posición
1 3 4 5 7
Notar que, más allá de que el arreglo ya quedó

ordenado con el último intercambio, el
algoritmo no lo sabe.
La búsqueda del elemento más chico se hace
igual (el 5) y se coloca en la cuarta posición.
1 3 4 5 7

private static void ordenarPorSeleccion(int [] datos){
for(int i=0; i<(n-1); i++){
int menor = i;
if(datos[j] < datos[menor])
menor = j;
if(menor != i){
datos[i] = datos[menor];
datos[menor] = swap;
cswap++;
}
}
}
Ordenación por inserción
El algoritmo realiza los siguientes pasos:
1. El primer elemento se considera ordenado; es decir, la
colección inicial consta de un elemento.
2. Se inserta el segundo elemento en la posición correcta,
delante o detrás del primero, dependiendo de que sea
menor o mayor.
3. Por cada bucle o iteración se explora la subcolección
buscando la posición correcta de inserción; a la vez se
mueve hacia abajo (a la derecha en la subcolección)
una posición todos los elementos mayores que el
elemento a insertar, para dejar vacía esa posición.
4. Insertar el elemento a la posición correcta.
• Elementos a insertar: 4, 7, 5, 1 y 3 (en ese orden)
Se inicializa un nuevo arreglo vacío.

• Elementos a insertar: 7, 5, 1 y 3
4 .
El primer elemento se inserta en el arreglo en la

primer posición.
• Elementos a insertar: 5, 1 y 3
4 7 .
El valor 7 se inserta en el arreglo de manera

ordenada
• Elementos a insertar: 5, 1 y 3
4 7 .
Se corren los elementos mayores que 5 una

posición.
• Elementos a insertar: 1 y 3
4 5 7 .

ordenada
• Elementos a insertar: 1 y 3
4 5 7 .

posición
• Elementos a insertar: 3
1 4 5 7 .

ordenada
• Elementos a insertar: 3
1 4 5 7

posición
• Elementos a insertar:
1 3 4 5 7

ordenada
1 3 4 5 7

private static int ordenarPorInsercion(int [] datos){
int [] datos2 = new int[n];
for(int i=0; i<n; i++){
int j = i;
while((j>0) && (datos[i]<datos2[j-1])){
datos2[j] = datos2[j-1];
j--;
}
datos2[j] = datos[i];
}
}
Ordenación por burbuja
• En el caso de una colección con n elementos, la
ordenación por burbuja requiere hasta n − 1 pasadas.
• Por cada pasada se comparan elementos adyacentes y

se intercambian sus valores cuando el primer elemento
es mayor que el segundo elemento.
• Al final de cada pasada, el elemento mayor ha

«burbujeado» hasta la cima de la subcolección actual.
• Llevar a la quinta posición el elemento más
grande.
4 7 5 1 3
Se compara 4 con 7. 7 es más grande, no se

realiza intercambio.
grande.
4 7 5 1 3
Se compara 7 con 5. Se realiza intercambio.

grande.
4 5 7 1 3

grande.
4 5 7 1 3

grande.
4 5 1 7 3

grande.
4 5 1 7 3

grande.
4 5 1 3 7

grande.
4 5 1 3 7
El elemento más grande quedó en el final del

arreglo.
• Llevar a la cuarta posición el elemento más
grande.
4 5 1 3 7
Se compara 4 con 5. 5 es más grande, no se

realiza intercambio.
grande.
4 5 1 3 7

grande.
4 1 5 3 7

grande.
4 1 5 3 7

grande.
4 1 3 5 7

• Llevar a la tercera posición el elemento más
grande.
4 1 3 5 7

grande.
1 4 3 5 7

grande.
1 4 3 5 7

grande.
1 3 4 5 7

• Llevar a la segunda posición el elemento más
grande.
1 3 4 5 7
Se compara 1 con 3. No es necesario el

intercambio.
1 3 4 5 7

• El algoritmo tiene una mejora, el proceso de ordenación
puede terminar antes de las n-1 pasadas.
• Si en una pasada no se produce intercambio alguno entre

elementos a ordenar es porque ya está ordenado,
entonces no es necesario más pasadas.
• Ejemplo de fin de algoritmo al darse cuenta que
el arreglo ya está ordenado.
1 3 5 4 7

Finaliza una pasada
1 3 4 5 7

Finaliza una pasada
1 3 4 5 7
La próxima parada es en la tercer posición

1 3 4 5 7
Compara 1 con 3 y no hay intercambio

1 3 4 5 7
Compara 3 con 4 y no hay intercambio.

1 3 4 5 7
Se realizó una pasada sin intercambios. Eso

ocurre cuando el arreglo está ordenado.
Fin del algoritmo
private static int ordenarPorBurbuja(int [] datos){
int i = 0;
bool ordenado = false;
while((i<(n-1)) && (! ordenado)){
ordenado = true;
for(int j=0; j<(n-i-1); j++){
if(datos[j] > datos[j+1]){
ordenado = false;
int swap = datos[j];
datos[j] = datos[j+1];
datos[j+1] = swap;
}
}
}
}
Ordenación Rápida (Quicksort)
• La idea del algoritmo es simple, se basa en la división en
particiones de la colección a ordenar.
• El método se basa en dividir los n elementos de la colección a

ordenar en dos particiones separadas por un elemento: una
partición izquierda, un elemento central denominado pivote o
elemento de partición, y una partición derecha. Las dos
subcolecciones se ordenan por separado independientemente
una de la otra.
• El primer problema a resolver es seleccionar el pivote. Aunque

la posición del pivote, en principio, puede ser cualquiera, una
de las decisiones más ponderadas es aquella que considera el
pivote como el elemento central o próximo al centro de la
colección.
Los pasos que sigue el algoritmo quicksort son:
1. Seleccionar el elemento central como pivote
2. Dividir los elementos restantes en particiones izquierda y
derecha, de modo que ningún elemento de la izquierda
tenga una clave (valor) mayor que el pivote y que ningún
elemento a la derecha tenga una clave más pequeña que la
del pivote.
3. Ordenar la partición izquierda utilizando quicksort
recursivamente.
4. Ordenar la partición derecha utilizando quicksort
recursivamente.
5. La solución es partición izquierda (ordenada) seguida por el
pivote y a continuación partición derecha (ordenada).
• Se elige como pivote del arreglo aquel que está en la
posición central.
Pivote
3 9 1 5 4 6 2 7 8
• Se busca desde el comienzo del arreglo aquel elemento
más grande que el pivote.
• Se busca desde el fin del arreglo aquel elemento más
chico que el pivote
3 9 1 5 4 6 2 7 8
chico que el pivote
3 9 1 5 4 6 2 7 8
Se intercambian ambos
elementos
chico que el pivote
3 2 1 5 4 6 9 7 8
Se intercambian ambos
elementos
chico que el pivote
3 2 1 5 4 6 9 7 8
Se
Se continúa con la
intercambian búsqueda.
ambos
Un índice se detiene en 5 que es mayor que el pivote.
elementos
El otro se detiene en el propio pivote
chico que el pivote
3 2 1 5 4 6 9 7 8
Se intercambian
intercambian ambos
ambos
Se
elementos
elementos
chico que el pivote
3 2 1 4 5 6 9 7 8
Se intercambian
intercambian ambos
ambos
Se
elementos
elementos
• Lo logrado hasta ahora es tener: por un lado, en un
subconjunto todos los elementos menores que el pivote.
• Por otro lado todos los elementos mayores que el pivote.
3 2 1 4 5 6 9 7 8
• Lo logrado hasta ahora es tener: por un lado, en un
subconjunto todos los elementos menores que el pivote.
• Por otro lado todos los elementos mayores que el pivote.
3 2 1 4 5 6 9 7 8
Se continúa con el mismo

procedimiento, de manera
recursiva.
• Se elige el pivote del arreglo aquel que está en la
posición central.
3 2 1 4 5 6 9 7 8
chico que el pivote
3 2 1 4 5 6 9 7 8
Se intercambian Se intercambian
ambos elementos ambos elementos
chico que el pivote
1 2 3 4 5 6 8 7 9
Se intercambian Se intercambian
ambos elementos ambos elementos
chico que el pivote
1 2 3 4 5 6 8 7 9
Se llegó al final de Se intercambian

la búsqueda ambos elementos
chico que el pivote
1 2 3 4 5 6 7 8 9
Se llegó al final de Se intercambian

la búsqueda ambos elementos
chico que el pivote
1 2 3 4 5 6 7 8 9

recursiva.
chico que el pivote
1 2 3 4 5 6 7 8 9

Colección de un elemento:
Es el caso base
recursiva.
• Se elige el pivote del arreglo aquel que está en la
posición central.
1 2 3 4 5 6 7 8 9
chico que el pivote
1 2 3 4 5 6 7 8 9
En este caso, no se lleva a cabo

ningún intercambio.
chico que el pivote
1 2 3 4 5 6 7 8 9
Caso base
• Al ir volviendo de la recursión, el algoritmo hace la unión
de los arreglos junto con el elemento que eligió como
pivote.
1 2 3 4 5 6 7 8 9
Se unen los arreglos ordenados

pivote.
1 2 3 4 5 6 7 8 9

pivote.
1 2 3 4 5 6 7 8 9

1 2 3 4 5 6 7 8 9

private static void ordenarRapido(int [] datos, int primero, int ultimo){
int central = (ultimo+primero) / 2, pivote = datos[central], i = primero, j = ultimo;
bool salir = false;
while (! salir){
while(datos[i] < pivote)
i++;
while(datos[j] > pivote)
j--;
if(i<=j){
datos[j] = swap;
i++;
j--;
}
else
salir = true;
}
if(primero < j)
ordenarRapido(datos, primero, j);
if(i < ultimo)
ordenarRapido(datos, i, ultimo);
}
Búsqueda secuencial
• La búsqueda secuencial busca un elemento de una
colección utilizando un valor destino llamado clave. En
una búsqueda secuencial (a veces llamada búsqueda
lineal), los elementos de una lista o vector se exploran
(se examinan) en secuencia, uno después de otro.
• El algoritmo de búsqueda secuencial compara cada

elemento de la lista con la clave de búsqueda y dado que
la lista no está en un orden prefijado, es probable que el
elemento a buscar pueda ser el primer elemento, el
último elemento o cualquier otro.
Búsqueda secuencial
private static bool busquedaSecuencial(int [] datos, int elemento){
foreach(int e in datos)
if(elemento == e){
return true;
}
return false;
}
Búsqueda binaria
• Si la colección en donde buscar se encuentra ordenada
entonces es posible utilizar la búsqueda binaria que
permite encontrar un elemento de forma más rápida que
la secuencial.
• Se sitúa la lectura en el centro de la colección y se

comprueba si la clave coincide con el valor del elemento
central. Si no se encuentra el valor de la clave, se sigue
la búsqueda en la mitad inferior o superior del elemento
central de la colección.
Búsqueda binaria
• Se desea saber si el valor 8 se encuentra en la colección
• Si primero es el índice más bajo a buscar y ultimo el más
alto, el índice central se calcula como:
• (primero + ultimo) / 2
primero = 0 1 2 3 4 5 6 7 8 9
ultimo = 8
central 
(0+8)/2 = 4
La búsqueda comienza en la
mitad del arreglo
Búsqueda binaria
primero = 0 1 2 3 4 5 6 7 8 9
ultimo = 8
central 
(0+8)/2 = 4
El valor 8 es más grande que el

valor central (5), se busca en la
mitad superior
Búsqueda binaria
primero = 5 1 2 3 4 5 6 7 8 9
ultimo = 8
central 
(5+8)/2 = 6
Se calcula el nuevo centro (de la

subcolección a buscar)
Búsqueda binaria
primero = 5 1 2 3 4 5 6 7 8 9
ultimo = 8
central 
(5+8)/2 = 6
El valor 8 es más grande que el

mitad superior
Búsqueda binaria
primero = 7 1 2 3 4 5 6 7 8 9
ultimo = 8
central 
(7+8)/2 = 7

Búsqueda binaria
1 2 3 4 5 6 7 8 9
Se encontró el elemento buscado

Búsqueda binaria
• Se desea saber si el valor 3.4 se encuentra en la
colección
primero = 0 1 2 3 4 5 6 7 8 9
ultimo = 8
central 
(0+8)/2 = 4
La búsqueda comienza en la
mitad del arreglo
Búsqueda binaria
colección
primero = 0 1 2 3 4 5 6 7 8 9
ultimo = 8
central 
(0+8)/2 = 4
El valor 3.4 es más chico que el

mitad inferior
Búsqueda binaria
colección
primero = 0 1 2 3 4 5 6 7 8 9
ultimo = 3
central 
(0+3)/2 = 1

Búsqueda binaria
colección
primero = 0 1 2 3 4 5 6 7 8 9
ultimo = 3
central 
(0+3)/2 = 1
El valor 3.4 es más grande que el

mitad superior
Búsqueda binaria
colección
primero = 2 1 2 3 4 5 6 7 8 9
ultimo = 3
central 
(2+3)/2 = 2

Búsqueda binaria
colección
primero = 2 1 2 3 4 5 6 7 8 9
ultimo = 3
central 
(2+3)/2 = 2
El valor 3.4 es más grande que el

mitad superior
Búsqueda binaria
colección
primero = 3 1 2 3 4 5 6 7 8 9
ultimo = 3
central 
(3+3)/2 = 3

Búsqueda binaria
colección
primero = 3 1 2 3 4 5 6 7 8 9
ultimo = 3
central 
(3+3)/2 = 3
El valor 3.4 es más chico que el

mitad inferior
Búsqueda binaria
1 2 3 4 5 6 7 8 9
Caso base: colección vacía.

El elemento a buscar no se
encuentra en la colección.
Búsqueda binaria
private static bool busquedaBinaria(int [] datos, int elemento, int primero, int ultimo){
int central = (primero + ultimo) / 2;
if(datos[central] == elemento){
return true;
}
else{
if(datos[central] > elemento){
ultimo = central - 1;
if(ultimo < primero){
return false;
}
}
else{
primero = central + 1;
if(primero > ultimo){
return false;
}
}
return busquedaBinaria(datos, elemento, primero, ultimo);
}
}
• En problemas reales se puede necesitar ordenar colecciones
de objetos.
• Por ejemplo, supongamos que tenemos la clase alumno con el

promedio de cada alumno de una universidad
public class Alumno {

private double promedio;
public Alumno(double p)
{
promedio = p;
}
public double Promedio { get { return promedio; } }
}
• Y tenemos un ArrayList con alumnos
public static void Main(string[] args) {

ArrayList alumnos = new ArrayList();
alumnos.Add(new Alumno(4.89));
}
• ¿Cómo podemos ordenar esa colección para imprimir un

listado de los alumnos ordenados por promedio?
• Podríamos tener una versión del algoritmo de ordenación que
realiza la propia ordenación sobre los elementos de un
ArrayList
private static void ordenarPorIntercambio(ArrayList datos){

int n = datos.Count;
for(int i=0; i<(n-1); i++)
object swap = datos[i];
datos[j] = swap;
}
}
• Este algoritmo serviría para cualquier tipo de objetos, ya que
en un ArrayList se guardan objetos.

for(int i=0; i<(n-1); i++)
datos[j] = swap;
}
}
• El problema es que C# no permite la comparación por mayor o
menor entre datos de tipo object.

for(int i=0; i<(n-1); i++)
datos[j] = swap; El compilador no
} permite hacer
} esto entre
variables object.
Hay que hacer algunas adaptaciones.

• Almacenar nuestros objetos en un List<IComparable>
public static void Main(string[] args) {

List<IComparable> alumnos = new List<Icomparable>();
}
• Definir nuestra función de ordenación para que ordene objetos del
tipo IComparable.
• Además de utilizar el método CompareTo() para realizar las
comparaciones entre objetos
private static void ordenarPorIntercambio(List<IComparable> datos)

{
for(int i=0; i<(n-1); i++)
if(datos[i].CompareTo(datos[j]) > 0){
IComparable swap = datos[i];
datos[j] = swap;
}
}
• Y en la clase Alumno …
public class Alumno : IComparable {

public Alumno(double p) {
promedio = p;
}
public double Promedio { get { return promedio } }
public int CompareTo(object c1){

if(this.Promedio < ((Alumno)c1).Promedio)
return -1;
else
if(this.Promedio > ((Alumno)c1).Promedio)
return 1;
else
return 0;
}
}
public class Alumno : IComparable { Decir que la clase

implementa la
public Alumno(double p) { interface
promedio = p; IComparable
}

if(this.Promedio < ((Alumno)c1).Promedio)
return -1;
else
if(this.Promedio > ((Alumno)c1).Promedio)
return 1;
else
return 0;
}
}
Ordenación y búsqueda Implementar el
• Y en la clase Alumno … método CompareTo()
que realiza la
public class Alumno : IComparable { comparación de la
private double promedio; instancia que recibe
public Alumno(double p) { el mensaje (this)
promedio = p; contra la instancia
} que recibe como
parámetro (otro)
public int CompareTo(object otro|){

if(this.Promedio < ((Alumno) otro).Promedio)
return -1;
else
if(this.Promedio > ((Alumno) otro).Promedio)
return 1;
else
return 0;
}
}
• Y en la clase Alumno … En el método
CompareTo() se
public class Alumno : IComparable { establece cual es la
private double promedio; condición para
public Alumno(double p) { comparar, en este
promedio = p; ejemplo, dos
} alumnos

return -1;
else
return 1;
else
return 0;
}
}
El método
public class Alumno : IComparable { CompareTo() debe
private double promedio; devolver un valor
public Alumno(double p) { negativo si this es
promedio = p; menor que otro
}

return -1;
else
return 1;
else
return 0;
}
}
El método
private double promedio; devolver un valor
public Alumno(double p) { positivo si this es
promedio = p; mayor que otro
}

return -1;
else
return 1;
else
return 0;
}
}
El método
devolver cero si this
public Alumno(double p) { es igual que otro
promedio = p;
}

return -1;
else
return 1;
else
return 0;
}
}
• Vea el proyecto OrdenacionYBusqueda para ver el

funcionamiento de los algoritmos de ordenación y
búsqueda vistos en clase aplicados a la comparación
entre alumnos según su promedio.

Teoría 9 PDF

Загружено:

Сведения о документе

Оригинальное название

Авторское право

Доступные форматы

Поделиться этим документом

Поделиться или встроить документ

Параметры публикации

Этот документ был вам полезен?

Это неприемлемый материал?

Авторское право:

Доступные форматы

Teoría 9 PDF

Загружено:

Авторское право:

Доступные форматы

ALGORITMOS Y

Dr. Lic. Waldo Hasperué

• Ordenación por selección

• Ordenación por inserción

• Ordenación por burbuja

• Ordenación rápida (quicksort).

• La ordenación de datos es una operación que consiste

• El tener una colección de datos ordenada facilita las

int [] datos = new datos[] { 4, 7, 5, 1, 3 };

• Se espera que el arreglo quede de esta forma:

• Notar que una colección se puede ordenar de manera

• Este algoritmo necesita realizar n−1 pasadas para

Se compara el 4 con el 7. Como 4 es menor no

Se compara el 4 con el 5. Como 4 es menor no

Se compara el 4 con el 1. En este caso, 1 es

Se compara el 4 con el 1. En este caso, 1 es

Se compara el 1 con el 3. Como 1 es menor no

Finalizó la primer vuelta. ¿Qué se logró?

El elemento más chico está en la primer

Ahora se compara el elemento de la segunda

Se compara el 7 con el 4. Se realiza el

Se compara el 7 con el 4. Se realiza el

Se compara el 5 con el 4. Se realiza el

Se compara el 5 con el 4. Se realiza el

Se compara el 4 con el 3. Se realiza el

Se compara el 4 con el 3. Se realiza el

Se compara el 7 con el 5. Se realiza el

Se compara el 7 con el 5. Se realiza el

Se compara el 5 con el 4. Se realiza el

Se compara el 5 con el 4. Se realiza el

Se compara el 7 con el 5. Se realiza el

Se compara el 7 con el 5. Se realiza el

El arreglo está ordenado

El elemento más chico es el 1.

Se coloca en la primer posición haciendo el

El elemento más chico es el 3.

Se coloca en la segunda posición haciendo el

El elemento más chico es el 4.

Se coloca en la tercera posición haciendo el

Notar que, más allá de que el arreglo ya quedó

El arreglo está ordenado

Se inicializa un nuevo arreglo vacío.

El primer elemento se inserta en el arreglo en la

El valor 7 se inserta en el arreglo de manera

Se corren los elementos mayores que 5 una

El valor 5 se inserta en el arreglo de manera

Se corren los elementos mayores que 1 una

El valor 1 se inserta en el arreglo de manera

Se corren los elementos mayores que 3 una

El valor 3 se inserta en el arreglo de manera

El arreglo está ordenado

• Por cada pasada se comparan elementos adyacentes y

• Al final de cada pasada, el elemento mayor ha

Se compara 4 con 7. 7 es más grande, no se

Se compara 7 con 5. Se realiza intercambio.

Se compara 7 con 5. Se realiza intercambio.

Se compara 1 con 7. Se realiza intercambio.

Se compara 1 con 7. Se realiza intercambio.

Se compara 7 con 3. Se realiza intercambio.

Se compara 7 con 3. Se realiza intercambio.

El elemento más grande quedó en el final del

Se compara 4 con 5. 5 es más grande, no se

Se compara 5 con 1. Se realiza intercambio.