Escuela Instituto Politécnico Nacional – IPN
Plantel: Escuela Superior de Ingeniería Mecánica y
Eléctrica
Unidad: ESIME Culhuacán
Carrera: Ingeniería Mecánica
Materia: Fundamentos de Programación
Grupo: 1MV25
Nombre: Moises Leonardo Patlán Luna
Tema: Diagrama de Flujo
Descripción : Diagrama de flujo
Realizar una investigación sobre los siguientes métodos de
ordenamiento:
1. Burbuja
2. Shell
3. Inserción
4. Selección
Además, el trabajo deberá contener los siguientes
elementos:
1. Caratula (nombre de la materia, grupo, nombre de los
integrantes, etc.),
2. Teoría,
3. Explicación,
4. Diagrama de flujo y
5. Bibliografías en formato APA.
1. Burbuja (Buble Short)
Descripción:
El algoritmo de ordenamiento por burbuja es uno de los más simples. Funciona iterando
repetidamente a través de la lista, comparando elementos adyacentes y permutándolos si
están en el orden incorrecto. Este proceso se repite hasta que no se requieran más
permutaciones, lo que indica que la lista está ordenada.
Funcionamiento:
1. Comparar el primer elemento con el segundo; si el primero es mayor que el
segundo, intercambiarlos.
2. Continuar comparando y permutando elementos adyacentes hasta el final de la
lista.
3. Repetir el proceso para todos los elementos, disminuyendo en cada iteración el
rango de comparación.
Complejidad:
Peor caso: O(n2)O(n^2)O(n2)
Mejor caso: O(n)O(n)O(n) (cuando la lista ya está ordenada)
Promedio: O(n2)O(n^2)O(n2)
2. Shell (Shell Short)
Descripción:
El algoritmo de ordenamiento Shell es una mejora sobre el ordenamiento por inserción.
Utiliza una secuencia de intervalos decrecientes para comparar y ordenar elementos.
Inicialmente, los elementos lejos unos de otros son comparados e intercambiados, y con
el tiempo los intervalos se reducen hasta que el último pase es un ordenamiento por
inserción simple.
Funcionamiento:
1. Elegir una secuencia de incrementos.
2. Para cada incremento, ordenar los elementos que están a esa distancia uno del
otro.
3. Reducir el incremento y repetir el proceso hasta que el incremento sea 1.
Complejidad:
Peor caso: Depende de la secuencia de incrementos, puede ser hasta
O(n2)O(n^2)O(n2), pero con incrementos óptimos es O(nlog 2n)O(n \log^2
n)O(nlog2n).
Mejor caso: O(nlog n)O(n \log n)O(nlogn)
Promedio: Depende de la secuencia de incrementos
3. Inserción (Inserción Short)
Descripción:
El ordenamiento por inserción construye la lista ordenada de uno en uno, tomando un
elemento de la lista no ordenada y colocándolo en la posición correcta en la lista
ordenada. Es eficiente para listas pequeñas o listas que ya están parcialmente ordenadas.
Funcionamiento:
1. Comenzar con el segundo elemento de la lista.
2. Compararlo con los elementos de la lista ordenada a su izquierda.
3. Insertarlo en la posición correcta.
4. Repetir el proceso para todos los elementos de la lista.
Complejidad:
Peor caso: O(n2)O(n^2)O(n2)
Mejor caso: O(n)O(n)O(n) (cuando la lista ya está ordenada)
Promedio: O(n2)O(n^2)O(n2)
4. Selección (Selection Sort)
Descripción:
El algoritmo de ordenamiento por selección divide la lista en dos partes: la sublista de
elementos ya ordenados y la sublista de elementos no ordenados. En cada iteración,
selecciona el elemento más pequeño (o más grande) de la sublista no ordenada y lo
intercambia con el primer elemento de la sublista no ordenada, extendiendo así la
sublista ordenada.
Funcionamiento:
1. Encontrar el elemento mínimo en la lista no ordenada.
2. Intercambiarlo con el primer elemento de la lista no ordenada.
3. Mover el límite entre la lista ordenada y no ordenada un elemento a la derecha.
4. Repetir hasta que toda la lista esté ordenada.
Complejidad:
Peor caso: O(n2)O(n^2)O(n2)
Mejor caso: O(n2)O(n^2)O(n2)
Promedio: O(n2)O(n^2)O(n2)
Comparación
Burbuja: Fácil de entender e implementar, pero ineficiente para listas grandes.
Shell: Más eficiente que la inserción y la burbuja, especialmente con una buena
secuencia de incrementos.
Inserción: Eficiente para listas pequeñas y casi ordenadas.
Selección: Simple de implementar, pero generalmente ineficiente comparado con
otros algoritmos.
Estos algoritmos tienen diferentes ventajas y desventajas dependiendo del contexto en el
que se utilicen. La elección del algoritmo adecuado depende del tamaño de la lista y de
las condiciones iniciales de los datos.
1. Ordenamiento por Burbuja
void burbuja(){
int a[]={3,2,1,1,4,5,6,21,9};
int aux;
int n = (sizeof(a)/sizeof(a[0]));
for(int i=0; i<=n; i++){
for(int j=0; j<n-1; j++){
if(a[j]>a[j+1]){
aux=a[j];
a[j]=a[j+1];
a[j+1]=aux;
}
}
}
for(int i=0; i<n; i++){
printf("%d | ",a[i]);
}
}
Explicación:
1. Inicialización:
o int a[]={3,2,1,1,4,5,6,21,9};: Se define un arreglo a con los
valores a ordenar.
oint aux;: Variable auxiliar para realizar los intercambios.
oint n = (sizeof(a)/sizeof(a[0]));: Se calcula el tamaño del
arreglo a.
2. Bucle exterior:
o for(int i=0; i<=n; i++): Itera sobre el arreglo a para realizar las
pasadas necesarias.
3. Bucle interior:
o for(int j=0; j<n-1; j++): Itera a través del arreglo, comparando e
intercambiando elementos adyacentes si están en el orden incorrecto.
4. Intercambio de elementos:
o if(a[j]>a[j+1]): Si el elemento actual es mayor que el siguiente, se
intercambian.
o aux=a[j]; a[j]=a[j+1]; a[j+1]=aux;: Realiza el intercambio
utilizando una variable auxiliar aux.
5. Impresión del resultado:
o for(int i=0; i<n; i++){ printf("%d | ",a[i]); }: Imprime el
arreglo ordenado
o
. 2. Ordenamiento Shell
void shell(){
int a[]={31,12,11,11,41,53,66,21,9};
int n = (sizeof(a)/sizeof(a[0]));
int inter=(n/2),j=0,k=0,aux;
while(inter>0){
for(int i=inter; i<n; i++){
j=i-inter;
while(j>=0) {
k=j+inter;
if(a[j]<=a[k]){
j--;
else{
aux=a[j];
a[j]=a[k];
a[k]=aux;
j=j-inter;
}
inter=inter/2;
for(int i=0; i<n; i++){
printf("%d | ",a[i]);
Explicación:
1. Inicialización:
o int a[]={31,12,11,11,41,53,66,21,9};: Se define un arreglo a con
los valores a ordenar.
int n = (sizeof(a)/sizeof(a[0]));: Se calcula el tamaño del
o
arreglo a.
o int inter=(n/2),j=0,k=0,aux;: Inicializa el intervalo inter, los
índices j y k, y la variable auxiliar aux.
2. Bucle while:
o while(inter>0): Ejecuta el bucle mientras inter sea mayor que 0.
3. Bucle for:
o for(int i=inter; i<n; i++): Itera desde inter hasta el final del
arreglo.
4. Bucle interno while:
o while(j>=0): Compara e intercambia elementos a intervalos de inter.
5. Intercambio de elementos:
o if(a[j]<=a[k]){ j--; }: Si el elemento actual es menor o igual que
el siguiente, decrece j.
o else{ aux=a[j]; a[j]=a[k]; a[k]=aux; j=j-inter; }: Si no,
intercambia los elementos.
6. Reducción del intervalo:
o inter=inter/2;: Reduce el intervalo a la mitad.
7. Impresión del resultado:
o for(int i=0; i<n; i++){ printf("%d | ",a[i]); }: Imprime el
arreglo ordenado.
3.Ordenamiento por Inserción
void insercion(){
int a[]={4,1,7,2,6,7,89,1};
int j,aux;
int n = (sizeof(a)/sizeof(a[0]));
for(int i=1; i<n; i++){
j=i;
aux=a[i];
while(j>0 && aux<a[j-1]){
a[j]=a[j-1];
j--;
a[j]=aux;
for(int i=0; i<n; i++){
printf("%d | ",a[i]);
Explicación:
1. Inicialización:
o int a[]={4,1,7,2,6,7,89,1};: Se define un arreglo a con los valores
a ordenar.
o int n = (sizeof(a)/sizeof(a[0]));: Se calcula el tamaño del
arreglo a.
2. Bucle for:
o for(int i=1; i<n; i++): Itera desde el segundo elemento hasta el
final del arreglo.
3. Asignación de valores:
o j=i; aux=a[i];: Inicializa j y aux con el índice y el valor del elemento
actual.
4. Bucle while:
o while(j>0 && aux<a[j-1]): Mientras j sea mayor que 0 y el valor
actual sea menor que el elemento anterior.
oa[j]=a[j-1]; j--;: Desplaza los elementos hacia la derecha.
5. Inserción del valor:
o a[j]=aux;: Inserta el valor aux en su posición correcta.
6. Impresión del resultado:
o for(int i=0; i<n; i++){ printf("%d | ",a[i]); }: Imprime el
arreglo ordenado.
4.Ordenamiento por Selección
void seleccion(){
int x[]={1,4,8,6,1,3,4,5,6};
int temp=0,minimo=0;
int n = (sizeof(x)/sizeof(x[0]));
for(int i=0; i<n-1; i++){
minimo=i;
for(int j=i+1; j<n; j++){
if(x[minimo] > x[j]){
minimo=j;
temp=x[minimo];
x[minimo]=x[i];
x[i]=temp;
for(int i=0; i<n; i++){
printf("%d | ",x[i]);
Explicación:
1. Inicialización:
o int x[]={1,4,8,6,1,3,4,5,6};: Se define un arreglo x con los
valores a ordenar.
int n = (sizeof(x)/sizeof(x[0]));: Se calcula el tamaño del
o
arreglo x.
2. Bucle for:
o for(int i=0; i<n-1; i++): Itera a través del arreglo x.
3. Asignación del mínimo:
o minimo=i;: Inicializa minimo con el índice actual.
4. Bucle interno for:
o for(int j=i+1; j<n; j++): Busca el elemento mínimo en la sublista
no ordenada.
5. Intercambio de elementos:
o if(x[minimo] > x[j]){ minimo=j; }: Actualiza minimo si encuentra
un valor menor.
o temp=x[minimo]; x[minimo]=x[i]; x[i]=temp;: Intercambia el
valor mínimo con el primer elemento no ordenado.
6. Impresión del resultado:
o for(int i=0; i<n; i++){ printf("%d | ",x[i]); }: Imprime el
arreglo ordenado.
Cada uno de estos métodos utiliza diferentes enfoques para ordenar los elementos de un
arreglo, proporcionando opciones variadas según el contexto y las necesidades
específicas de rendimiento.
