Algoritmos de Ordenamiento: Conceptos y Aplicaciones Básicas

ALGORITMOS DE ORDENAMIENTO:
Es un algoritmo que se encarga de colocar en orden una secuencia dada y pueden ser números o letras.
Un arreglo ordenado es un arreglo que tiene un orden específicamente definido. Ej. [a,b,c,d] = arreglo ordenado alfabéticamente, o [1,2,3,4,5] arreglo de números ordenados de menor a mayor.
Tu puedes programar el control y orden de mayor a menos o de la letra A – Z o viceversa.
Además, el algoritmo de ordenamiento te da unos pasos a seguir para que el orden que buscas se logre.
ALGORITMOS DE ORDENAMIENTO MAS UTILIZADOS:
MERGE SORT: principio divide y vencerás, este método agarra el array y los separa y va resolviendo problemas pequeños e individuales, después ordena y asegura de que halla quedado bien y es un proceso rápido.
Es convenible utilizarlo cuando se tienen demasiados datos y no pocos.
INSERTION SORT:
Es mas básico, va comparando valores y los va colocando lo valores mas pequeños al lado izquierdo. Este algoritmo es muy fácil de implementar.
BUBBLE SORT:
Es un elemento básico, se encarga de comparar por pares y repite la secuencia hasta terminar, se utiliza mas en pocos datos para que sea más eficiente.
QUICK SORT:
Va a dividir en problema en dos y así mismo va a ir ordenando el problema, es un algoritmo mas eficiente que la mayoría, es muy bueno en comparación de los demás.
S Y N:
Son datos que vamos a estar utilizando a menudo cuando estas leyendo o investigando.
S= va a ser la secuencia de objetos ordenables (los números a ordenar).
N= numero de elementos en S (secuencia de elementos a ordenar).

Algoritmos de Ordenamiento en C

Bubble Sort

#include <stdio.h>

void bubblesort (int s[], int n) {
	int i, j, temporal;

	for (i = 0; i < n - 1; i++) {
		for (j = 0; j < n - i - 1; j++) {
			if (s[j] > s[j + 1]) {
				temporal = s[j];
				s[j] = s[j + 1];
				s[j + 1] = temporal;
			}
		}
	}
}

void print_array (int s[], int n) {

	for (int i = 0; i < n; i++) {
		if (i == n - 1) {
			printf("%d.\n", s[i]);
		} else {
			printf("%d, ", s[i]);
		}
	}
}

int main () {
	
	int s[] = {6, 5, 3, 1, 8, 7, 2, 4};
	int n = sizeof(s) / sizeof(int);
	printf("Lista Desordenada\n");
	print_array(s, n);
	bubblesort(s, n);
	printf("\nLista Ordenada\n");
	print_array(s, n);

	return 0;
}

Insertion Sort

#include <stdio.h>

void bubblesort (int s[], int n) {
	int i, j, temporal;

	for (i = 0; i < n - 1; i++) {
		for (j = 0; j < n - i - 1; j++) {
			if (s[j] > s[j + 1]) {
				temporal = s[j];
				s[j] = s[j + 1];
				s[j + 1] = temporal;
			}
		}
	}
}

void print_array (int s[], int n) {

	for (int i = 0; i < n; i++) {
		if (i == n - 1) {
			printf("%d.\n", s[i]);
		} else {
			printf("%d, ", s[i]);
		}
	}
}

int main () {
	
	int s[] = {6, 5, 3, 1, 8, 7, 2, 4};
	int n = sizeof(s) / sizeof(int);
	printf("Lista Desordenada\n");
	print_array(s, n);
	bubblesort(s, n);
	printf("\nLista Ordenada\n");
	print_array(s, n);

	return 0;
}

Merge Sort

#include <stdio.h>

void merge (int l[], int nL, int r[], int nR, int s[]) {
	int i = 0, j = 0, k = 0;

	while (i < nL && j < nR) {
		if (l[i] <= r[j]) {
			s[k] = l[i];
			i++;
		} else {
			s[k] = r[j];
			j++;
		}
		k++;
	}
	while (i < nL) {
		s[k] = l[i];
		i++;
		k++;
	}
	while (j < nR) {
		s[k] = r[j];
		j++;
		k++;
	}
}

void mergesort (int s[], int n) {

	if (n < 2) return;

	int mid = n / 2, left[mid], right[n - mid];

	for (int i = 0; i < mid; i++) {
		left[i] = s[i];
	}

	for (int i = 0; mid < n; i++) {
		right[i] = s[mid];
		mid++;
	}

	int nL = sizeof(left) / sizeof(int);
	int nR = sizeof(right) / sizeof(int);
	mergesort(left, nL);
	mergesort(right, nR);
	merge(left, nL, right, nR, s);
}

void print_array (int s[], int n) {

	for (int i = 0; i < n; i++) {
		if (i == n - 1) {
			printf("%d.\n", s[i]);
		} else {
			printf("%d, ", s[i]);
		}
	}
}

int main () {

	int s[] = {6, 5, 3, 1, 8, 7, 2, 4};
	int n = sizeof(s) / sizeof(int);
	printf("Lista Desordenada\n");
	print_array(s, n);
	mergesort(s, n);
	printf("\nLista Ordenada\n");
	print_array(s, n);

	return 0;
}

Quick Sort

#include <stdio.h>

void quicksort (int s[], int limit_left, int limit_right) {
	int left, right, temporal, pivot;
	left = limit_left;
	right = limit_right;
	pivot = s[(left + right) / 2];

	do {
		while(s[left] < pivot && left < limit_right) left++;
		while(s[right] > pivot && right > limit_left) right--;

		if (left <= right) {
			temporal = s[left];
			s[left] = s[right];
			s[right] = temporal;
			left++;
			right--;
		}

	} while (left <= right);

	if (limit_left < right) {quicksort(s, limit_left, right);}
	if (limit_right > left) {quicksort(s, left, limit_right);}
}

void print_array (int s[], int n) {

	for (int i = 0; i < n; i++) {
		if (i == n - 1) {
			printf("%d.\n", s[i]);
		} else {
			printf("%d, ", s[i]);
		}
	}
}

int main () {

	int s[] = {6, 5, 3, 1, 8, 7, 2, 4};
	int n = sizeof(s) / sizeof(int);
    printf("Lista Desordenada\n");
	print_array(s, n);
	quicksort(s, 0, n - 1);
	printf("\nLista Ordenada\n");
	print_array(s, n);

	return 0;
}

Estoy aquí para resolver mi tarea de Estructura de Datos xD

¿Ricardo podrías compartirnos los GIF de cada algoritmo? Están buenos para entender el funcionamiento.

ALGORITMO DE ORDENAMIENTO
Tipos de algoritmo de ordenamiento:
Estos tipos de algoritmos dan mejores resultados de rendimiento y van a ser mas óptimos.
• Insertion sort
• Bubble sort
• Merge sort
• Quick sort

Que son estructuras de algoritmos de ordenamiento?
El algoritmo de ordenamiento coloca una secuencia en orden, las secuencias pueden ser de objetos, números o letras que van a ser colocadas en orden.
El resultado del algoritmo de ordenamiento sera un array o arreglo ordenado, y este orden debe ser específicamente definido, yo le puedo dar el orden, puede ir de mayor a menor, de A a Z, de Z a A, ademas el algoritmo de ordenamiento nos da un serie de pasos a seguir para que el orden que queremos implementar se cumpla.
Ejemplos:
[a,b,c,d,e]= ordenado de la A a la Z
[1,2,3,4,5,6]= ordenado de menor a mayor
Algoritmos de ordenamiento mas utilizados:
Merge sort
Principio: divide y vencerás
Este algoritmo separa en partes y va resolviendo problemas pequeños e individuales y lo ordenas y por ultimo te aseguras que allá quedado bien.
Va separando y ordenando individualmente de mayor a menor.
Se recomienda no usarlo en caso de tener pocos datos, pero si tienes demasiados datos, se va a volver mas eficiente.

Insertion sort
Este algoritmo compara valores y los va colocando, comparas los valores y el valor mas pequeño lo coloca al lado izquierdo para poder tener un orden de menor a mayor.
Es ul algoritmo muy fácil de implementar, su único inconveniente seria la velocidad de ejecución de la tarea.

Bubble sort
Este algoritmo es básico, se encarga de ordenar por pares y después va a ir repitiéndose varias veces hasta que quede perfectamente ordenado.

Quick sort
Este algoritmo va a dividir en problema en dos, y asi mismo va a ir ordenando cada parte del problema, hasta tenerlo resuelto completamente.
Es un algoritmo bastante bueno y mas eficiente que los demás

S y N, son datos que vamos a ir viendo a menudo
S = secuencia de objetos ordenables (Números a ordenar)
N = es el numero de elementos en S (Nuestra secuencia de elementos a ordenar)

En este curso he aprendido nuevos temas y he debido investigar por mi cuenta para entender un poco más.

No sabia que existian tantos lagoritmos de ordenamiento

muy claro!:

Les comparto la entrada al Blog de Platzi durante el reto #RoadToCode 🚀 donde se habla de los algoritmos clave y su importancia para la programación.

https://platzi.com/blog/road-to-code-algoritmos-claves/

Me ayudó mucho para entender más acerca de los algoritmos antes de adentrarme en las siguientes clases del curso 💚

Algoritmo de ordenamiento, es simple y sencillamente un algoritmo que se encargará de colocar en orden una secuencia dada convirtiendo un arreglo desordenado en un arreglo ordenado (Un arreglo que tiene un orden específicamente definido). Existen múltiples algoritmos de ordenamiento, y algunos de los más usados son:

• Merge Sort, Utiliza el paradigma divide y vencerás, Dividiendo los elementos para compararlos y posteriormente volverlos a unir ordenados de la manera correcta .Es un algoritmo eficiente para muchos datos, pero no lo es tanto para pocos

• Insertion Sort, Vas comparando los elementos hasta que encuentren su lugar en la serie de 1 a 1. Es un algoritmo eficiente para serie de datos cortas, pero no para largas.

• Bubble Sort, Se ordena por pares y se va repitiendo 1 a 1 hasta que queda totalmente ordenado, es muy iterativo, poco eficiente (por la cantidad de iteraciones), pero muy sencillo de ejecutar.

• Quick Sort, Utiliza el paradigma divide and conquer, y va comparando desde las esquinas al centro, es muy eficiente para serie de datos largos por lo que es de los más importantes.

Conceptos sobre algoritmos de ordenamiento:

S, Secuencia de objetos ordenables, por ejemplo los numeros a ordenar

N, Numero de elementos en S.

Ejemplo de arreglos ordenados:

• [a, b, c, d]; Es un arreglo ordenado alfabeticamente

Vengo del futuro para dejarles un video que mezcla música y video con los diferentes tipos de` ordenamientos pum!](https://www.youtube.com/watch?v=kPRA0W1kECg)

y acá otro con colores bang!

• Merge Sort
• Insertion Sort
• Bubble Sort
• Quick Sort

Muy buena explicación y con los GIF se entiende perfectamente.

wow, la verdad nunca habia estudiado estos conceptos, siempre los daba por hecho, awesome

buena explicación

Por favor todas las explicaciones de esa forma !!!

Estos algoritmos son muy interesantes y útiles.

Muy buena explicación, conceptos fáciles de recordar.

Ordenamiento de burbuja
Ordenamiento por selección
Ordenamiento por inserción
Ordenamiento de Batcher
(Batcher odd–even mergesort / Bitonic Sort)

¿Qué es?
Algoritmo que se encarga de ordenar los datos

- Merge Sort: Divide and Conquer
- Insertion: Valos a la izquierda se declaran como ordenados
- Selection: Pivote, ordenas los menores a la izq y mayores a la derecha
- Bubble: Por pares
- Quick Sort: Pivote, compara pares en los extremos 

Definiciones:
- S: Secuencia de objetos ordenables
- N: Numero de elementos en S

Entendido y pasemos a la implementación, lo que mas me gusta.

Merge Sort
Utiliza el paradigma divide y vencerás, Dividiendo los elementos para compararlos y posteriormente volverlos a unir ordenados de la manera correcta.
Es un algoritmo eficiente para muchos datos, pero no lo es tanto para pocos
Insertion Sort
Vas comparando los elementos hasta que encuentren su lugar en la serie de 1 a 1.
Es un algoritmo eficiente para serie de datos cortas, pero no para largas.
Bubble Sort
Se ordena por pares y se va repitiendo 1 a 1 hasta que queda totalmente ordenado, es muy iterativo, poco eficiente (por la cantidad de iteraciones), pero muy sencillo de ejecutar.
Quick Sort
Utiliza el paradigma divide and conquer, y va comparando desde las esquinas al centro, es muy eficiente para serie de datos largos por lo que es de los más importantes.

Excelente!! el Gif o video corto que se presenta es genial para ir entendiendo!

Qué bueno abarcar estos temas también

• Un algoritmo de ordenamiento es colocar una secuencia de objetos (números o letras) de manera ordenada.
• Un arreglo ordenado tiene un orden específicamente definido.
• Existen varios algoritmos como Merge Sort, que usa el principio de divide y venceras.
• Insertion Sort, que va ordenando los elementos en series de 1 - 1
• Buble Sort, ordena por pares de 1-1 y se va repitiendo hasta queeste ordenado.
• Quick Sort, utiliza el paradigma de divide y vencerás y va comparando desde las esquinas hasta el centro.

Hay funciones en cada lenguaje de programación que permiten ordenar como por ejemplo en python sort(), que diferencia hay en realizar un algoritmo de orden a mano que implementar uno ya disponible en el lenguaje ?, hay que confiar en lo que el lenguaje nos brinda ?

Buena explicación de los algoritmos de ordenamiento. A ver qué tal la implementación.

Para los que se quedaron con la curiosidad:

Shellsort
Mejora de la ordenación por inserción, donde se van comparando elementos distantes, al tiempo que se los intercambian si corresponde. A medida que se aumentan los pasos, el tamaño de los saltos disminuye; por esto mismo, es útil tanto como si los datos desordenados se encuentran cercanos, o lejanos.

Por ejemplo
Primer ordenamiento:

Segundo ordenamiento:

Me encanta… estos conceptos son geniales y profesionales… una lógica mas que interesante! Gracias y a seguir estudiando para ver mas!

La verdad desconocia por completo de estos algoritmos.Se ven muy interesantes

Volví 10 años a mi clase de estructuras de datos xD

Ilustracion correcta para representar los tipos

me está gustando mucho este curso, es muy divertido, planean sacar uno avanzado?

Muy interesante esta clase, principalmente después de ver el funcionamiento del merge sort, el cual nunca había terminado de entender.

Ok

Curso de algoritmos de ordenamiento
Siii

Merge Short: Divide y vencerás, tomas tu lista de valores, la partes a la mitad, y esa en otra, hasta que realices una comparación entre sus valores para ver cual es el menor y ordenando, NO RECOMENDADO cuando manejas pocas cantidades de datos. RECOMENDADO para muchos datos.

Insertion Shot: Comparas tus primeros 2 valores y vas colocando el mas pequeño de lado izquierdo, y así vas con cada valor. RECOMENDADO cuando se tiene pocos datos.

Bubble sort: Ordenamiento en pares, selecciona dos valores y coloca el menor de lado izquierdo, un poco lento y NO RECOMENDADO para grandes cantidades de datos.

Quick Sort: Toma los valores de los extremos y el menos lo coloca de lado izquierdo [intercambio]

Algoritmo de ordenamiento
Coloca en orden una secuencia
Merge Sort
Dividiendo los elementos para compararlos y posteriormente volverlos a unir ordenados de la manera correcta.
Insertion Sort
Vas comparando los elementos hasta que encuentren su lugar en la serie de 1 a 1.
Bubble Sort
Se ordena por pares y se va repitiendo 1 a 1 hasta que queda totalmente ordenado
Quick Sort
va comparando desde las esquinas al centro

Implementación para el reto:

/* 1 - Crear pointer para saber que hay en front y rear
2 - colocar estos valores en -1 al inicializar
3 - incrementar en 1 el valor de "rear"
    cuando agreguemos un elemento
4 - Retornar el valor de front al quitar un elemento 
    e incrementar en 1 el valor de
    front al usar dequeue,
5.- antes de agregar un elemento revisar si hay espacio
6.- antes de remover un elemento revisamos que existan elementos
7.- asegurarnos de que al remover todos los elementos 
    resetear nuestro front y rear a -1 
    y agregar el valor de 0 a Front al hacer nuestro primer enqueue 

 */
#include<stdio.h>
#define SIZE 5
int values[SIZE], front = -1, rear= -1;

void shift(){
    int val=0;
    //printf("%d %d",front, rear);
    //printf("DEBU[%d] [%d] [%d] [%d] [%d]\n",values[0],values[1],values[2],values[3],values[4]);
    for (int i=front;i<rear+1;i+=1) {
        values[val] = values[i];
        values[i]=-1;
        val+=1;
        //printf("FOR[%d] [%d] [%d] [%d] [%d]\n",values[0],values[1],values[2],values[3],values[4]);
    }
    front-=1;
    rear-=1;
    //printf("SHIFTED: [%d] [%d] [%d] [%d] [%d]\n",values[0],values[1],values[2],values[3],values[4]);
}

void enQueue(int value){
    if(rear == SIZE-1)
        printf("Nuestro Queue esta lleno\n" );
    else {
        if(front == -1)
            front = 0;
        rear++;
        values[rear] = value;
        printf("Se inserto el valor %d correctamente\n", value);
    
    }

    printf("[%d] [%d] [%d] [%d] [%d]\n",values[0],values[1],values[2],values[3],values[4]);
 
}

void deQueue(){
    if(front == -1)
        printf("Nuestro Queue esta vacio\n" );
    else{
        printf("se elimino el valor %d\n", values[front]);
        front++;
        if(front > rear)
        front = rear = -1;
        else {
            shift();
        }
    }
    printf("[%d] [%d] [%d] [%d] [%d]\n",values[0],values[1],values[2],values[3],values[4]);

}

main(int argc, char const *argv[])
{
    enQueue(1);
    enQueue(2);
    enQueue(3);
    enQueue(4);
    enQueue(5);
    deQueue();
    enQueue(13);
    deQueue();
    deQueue();
    deQueue();
    deQueue();
    enQueue(10);
    return 0;
}

Precisamente ayer implementé el algoritmo Bubblesort en un programa que simula un “Battleship” para organizar mis ships del mayor al menor según su tamaño.

boolean isSorted = false;
	while(isSorted == false) {
	    for (int i = 0; i < allMyShips.length - 1; i++) {
		isSorted = true;
		if (allMyShips[i].getLenght() > allMyShips[i + 1].getLenght()) {
		    Ship aux = allMyShips[i];
		    allMyShips[i] = allMyShips[i + 1];
		    allMyShips[i + 1] = aux;
		    isSorted = false;
		}
	    }
	}

El vídeo que me ayudó con esto fue -> este

Todo muy bien explicado.

Super interesante. Gracias!!

Les comparto un gráfico en el que se muestra un poco más en detalle como funciona Quick Sort ordenando grandes cantidades de datos. La altura de cada pico en el gráfico representa el valor de un número.

Algoritmos de ordenamiento

Es un algoritmo que se encarga de poner en orden una secuencia dada (de letras o números, pro ejemplo). Al final, obtenemos un arreglo ordenado.

Un arreglo ordenado, es un arreglo que tiene un orden específicamente definido.

Por ejemplo:

• [a, b, c, d] es un arreglo ordenado alfabéticamente.
• [1, 2, 3, 4, 5] es un arreglo de números enteros ordenados ascendentemente.

Existen múltiples algoritmos de ordenamiento, y algunos de los más usados son:

• Merge Sort

  Utiliza el paradigma divide y vencerás, Dividiendo los elementos para compararlos y posteriormente volverlos a unir ordenados de la manera correcta.

  Es un algoritmo eficiente para muchos datos, pero no lo es tanto para pocos

• Insertion Sort

  Vas comparando los elementos hasta que encuentren su lugar en la serie de 1 a 1.

  Es un algoritmo eficiente para serie de datos cortas, pero no para largas.

• Bubble Sort

  Se ordena por pares y se va repitiendo 1 a 1 hasta que queda totalmente ordenado, es muy iterativo, poco eficiente (por la cantidad de iteraciones), pero muy sencillo de ejecutar.

• Quick Sort

  Utiliza el paradigma divide and conquer, y va comparando desde las esquinas al centro, es muy eficiente para serie de datos largos por lo que es de los más importantes.

1. Mis apuntes sobre: "Algoritmos de ordenamiento"
   Es un algoritmo que colocará los objetos (números o letras) en orden.
   Un arreglo ordenado, es un arreglo que tiene un orden específicamente definido.
   Un algoritmo de ordenamiento es simple y sencillamente un algoritmo que se encargará de colocar en orden una secuencia dada convirtiendo un arreglo desordenado en un arreglo ordenado (Un arreglo que tiene un orden específicamente definido).

Por ejemplo:
[a,b,c,d] es un arreglo ordenado alfabéticamente
[1,2,3,4,5] es un arreglo de números enteros ordenados ascendentemente

Algoritmos de ordenamiento más utilizados:

Existen múltiples algoritmos de ordenamiento, y algunos de los más usados son:
Merge Sort
Utiliza el paradigma divide y vencerás, Dividiendo los elementos para compararlos y posteriormente volverlos a unir ordenados de la manera correcta.
Es un algoritmo eficiente para muchos datos, pero no lo es tanto para pocos
Insertion Sort
Vas comparando los elementos hasta que encuentren su lugar en la serie de 1 a 1.
Es un algoritmo eficiente para serie de datos cortas, pero no para largas.
Bubble Sort
Se ordena por pares y se va repitiendo 1 a 1 hasta que queda totalmente ordenado, es muy iterativo, poco eficiente (por la cantidad de iteraciones), pero muy sencillo de ejecutar.
Quick Sort
Utiliza el paradigma divide and conquer, y va comparando desde las esquinas al centro, es muy eficiente para serie de datos largos por lo que es de los más importantes.

**S: **Secuencia de objetos ordenables.
**N: **Número de elementos en S

Merge Sort y Insertion Sort