Bienvenido al Curso

1

Introducci贸n al curso b谩sico de algoritmos y estructuras de datos

Introducci贸n a los algoritmos

2

驴Qu茅 entiende una computadora?

3

Lenguajes de programaci贸n

4

Estructuras de datos

5

驴Qu茅 es un algoritmo?

6

Metodolog铆a para la construcci贸n de un algoritmo

7

Variables y tipos de datos

8

User defined data types

9

Instalando Ubuntu Bash en Windows

10

Creando nuestro user defined data type

11

Abstract Data Types b谩sicos: Lists, Stacks, Queues

12

Explicaci贸n gr谩fica Data Types b谩sicos

13

Glosario de funciones para Abstract Data Types

14

Clases y objetos

15

Creando tu primera Queue: Arrays

16

Creando tu primera Queue: implementaci贸n.

17

Creando tu primera Queue: implementar la funci贸n enQueue

18

Creando tu primera Queue: implementar la funci贸n deQueue

19

Creando tu primera Queue: main code

Algoritmos de ordenamiento

20

Algoritmos de ordenamiento

21

Bubble sort

22

Bubble sort: implementaci贸n

23

Bubble sort: main code

24

Insertion sort

25

Desaf铆o: implementa un algoritmo de ordenamiento

Recursividad

26

Recursividad

27

La funci贸n Factorial, calculando el factorial recursivamente

28

Manejo de cadenas de caracteres

29

Arte: Generando arte recursivo

Divide and conquer y programaci贸n din谩mica

30

Divide and Conquer (divide y vencer谩s)

31

Qu茅 es la programaci贸n din谩mica (divide y vencer谩s v2.0)

32

MergeSort

33

Desaf铆o: Buscar el algortimo m谩s r谩pido de sort

34

Implementando QuickSort con Python

35

Implementando QuickSort con Python: main code

Algoritmos 'Greedy'

36

Qu茅 son los Greedy Algorithm

37

Ejercicio de programaci贸n greedy

38

Ejercio de programaci贸n greedy: main code

Grafos y 谩rboles

39

Grafos y sus aplicaciones

40

脕rboles

驴C贸mo comparar Algoritmos?

41

C贸mo comparar algoritmos y ritmo de crecimiento

驴Qu茅 sigue?

42

Cierre del curso y siguientes pasos

No tienes acceso a esta clase

隆Contin煤a aprendiendo! 脷nete y comienza a potenciar tu carrera

Algoritmos de ordenamiento

20/42
Recursos

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).
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.

Aportes 47

Preguntas 2

Ordenar por:

驴Quieres ver m谩s aportes, preguntas y respuestas de la comunidad?

o inicia sesi贸n.

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鈥揺ven 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 鈥淏attleship鈥 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