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

Adquiere por un a帽o todos los cursos, escuelas y certificados por un precio especial.

Antes: $249

Currency
$219/a帽o

Paga en 4 cuotas sin intereses

Paga en 4 cuotas sin intereses
Comprar ahora

Termina en:

0D
16H
6M
30S

Bubble sort

21/42
Recursos

Bubble Sort es el algoritmo de ordenamiento m谩s r谩pido de implementar.

Se ordena por pares y se va repitiendo de 1 a 1 hasta que queda totalmente ordenado, es muy iterativo y muy poco eficiente (por la cantidad de iteraciones), pero al entenderlo estar谩s listo para poder pasar a algoritmos un poco m谩s complejos.

Aportes 51

Preguntas 2

Ordenar por:

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

o inicia sesi贸n.

Dato Curioso:
En el a帽o 2007, el ex CEO de Google, Eric Schmidt, le pregunt贸 al candidato presidencial Barack Obama una vez durante una entrevista sobre la mejor manera de ordenar un mill贸n de enteros, y Obama, haciendo una pausa por un momento, respondi贸: 鈥淐reo que el algoritmo de Bubble sort ser铆a el camino equivocado鈥

Aqui les comparto el ejercicio de la clase

Array = [5,2,4,2,7]

Primer recorrido

	Iteracion #1: Index 0 con Index 1
		5 < 2 = False, hacemos cambio entre 5 y 2
		Array = [2,5,4,2,7]

	Iteracion #2: Index 1 con Index 2
		5 < 4 = False, hacemos cambio entre 5 y 4
		Array = [2,4,5,2,7]

	Iteracion #3: Index 2 con Index 3
		5 < 2 = False, hacemos cambio entre 5 y 2
		Array = [2,4,2,5,7]

	Iteracion #4: Index 3 con Index 4
		5 < 7 = True, no hacemos ningun cambio
		Array = [2,4,2,5,7]


Segundo recorrido

	Iteracion #5: Index 0 con Index 1
		2 < 4 = True, no hacemos ningun cambio
		Array = [2,4,2,5,7]

	Iteracion #6: Index 1 con Index 2
		4 < 2 = False, hacemos cambio entre 4 y 2
		Array = [2,2,4,5,7]

	Iteracion #7: Index 2 con Index 3
		4 < 5 = True, no hacemos ningun cambio
		Array = [2,2,4,5,7]

	Iteracion #8: Index 3  con Index 4
		5 < 7 = True, no hacemos ningun cambio
		Array = [2,2,4,5,7]

BUBBLE SORT: IMPLEMENTACI脫N
Es un algoritmo de b煤squeda y uno de los mas simples. Este algoritmo funciona cambiando las celdas de los n煤meros en caso de que no est茅n ordenadas y va de par en par.
Debe quedar muy bien ordenado de mayor a menor, recordando que se repite el ciclo hasta que quede totalmente ordenado.
Excelente explicaci贸n, muchas gracias!!

脡stos son los pasos de la burbuja del ejercicio de hoy

  1. [5, 2, 4, 2, 7]
    (5 <- 2)
  2. [2, 5, 4, 2, 7]
    ***(5<-4)
  3. [2, 4, 5, 2, 7]
    ******(5<-2)
  4. [2, 4, 2, 5, 7]
    ***(4<-2)
  5. [2, 2, 4, 5, 7]

es uno de los mas simples y f谩ciles de implementar pero es uno de los menos eficientes teniendo una complejidad de o(n^2) siendo su peor de los casos n*(n-1)/2

as铆 se ve facil, quiero ver la implementaci贸n en c贸digo.

El algoritmo en python:

** Mi aporte con JavaScrip**

const bubbleSort = [7, 3, 5, 6, 8, 0, 4]

let bubbleSortF = (inputArr) => {
  let len = inputArr.length;
  let swapped;
  do {
      swapped = false;
      for (let i = 0; i < len; i++) {
          if (inputArr[i] > inputArr[i + 1]) {
              let tmp = inputArr[i];
              inputArr[i] = inputArr[i + 1];
              inputArr[i + 1] = tmp;
              swapped = true;
          }
      }
  } while (swapped);
  console.log(inputArr);
  return inputArr;
};

bubbleSortF(bubbleSort);

Recuerdo cuando mi profe de progra 2 nos pidio crear un algoritmo de nuestra imaginaci贸n para ordenar un arreglo, y al hacer mi propia implementaci贸n resulto que era exactamente igual a este 馃槃

Bubble sort, Es un algoritmo de ordenamiento rapido de implementar pero ineficiente para cantidad de datos grandes. Se ordena por pares y se va repitiendo de 1 a 1 hasta que queda totalmente ordenado, es muy iterativo y muy poco eficiente (por la cantidad de iteraciones)

Lo que entonces sucede, es que el va ordenando por cada uno de los indices del array los valores que posee hasta ordenarlos correctamente, por ejemplo:

array = [9, 2, 4, 5, 1]

primero compararia el 9 con el 2 y asi sucesivamente hasta ordenar todos los elementos del array```

Bubble Sort is the simplest sorting algorithm that works by repeatedly swapping the adjacent elements if they are in wrong order.
Example:
First Pass:
( 5 1 4 2 8 ) 鈥> ( 1 5 4 2 8 ), Here, algorithm compares the first two elements, and swaps since 5 > 1.
( 1 5 4 2 8 ) 鈥> ( 1 4 5 2 8 ), Swap since 5 > 4
( 1 4 5 2 8 ) 鈥> ( 1 4 2 5 8 ), Swap since 5 > 2
( 1 4 2 5 8 ) 鈥> ( 1 4 2 5 8 ), Now, since these elements are already in order (8 > 5), algorithm does not swap them.

Second Pass:
( 1 4 2 5 8 ) 鈥> ( 1 4 2 5 8 )
( 1 4 2 5 8 ) 鈥> ( 1 2 4 5 8 ), Swap since 4 > 2
( 1 2 4 5 8 ) 鈥> ( 1 2 4 5 8 )
( 1 2 4 5 8 ) 鈥> ( 1 2 4 5 8 )
Now, the array is already sorted, but our algorithm does not know if it is completed. The algorithm needs one whole pass without any swap to know it is sorted.

Third Pass:
( 1 2 4 5 8 ) 鈥> ( 1 2 4 5 8 )
( 1 2 4 5 8 ) 鈥> ( 1 2 4 5 8 )
( 1 2 4 5 8 ) 鈥> ( 1 2 4 5 8 )
( 1 2 4 5 8 ) 鈥> ( 1 2 4 5 8 )

Mi aporte en JavaScript.
Se que no es la manera m谩s corta pero fue totalmente desde cero 馃槃

Muy buenos ejemplos ,
Demasiado claro, no conoc铆a este tipo de ordenadores y es la primera vez que veo esta informaci贸n

Pizarr贸n de la clase:

mi propuesta para el bubble sort
![](

#include <stdio.h>
#include <stdlib.h>
#include <time.h>

void bubbleSort(int *arreglo,const short tam){
    short i,j;
    for(i = 0; i < tam; ++i){
        for(j = 0; j < tam -1; ++j){
            if(arreglo[j] > arreglo[j + 1]){
                arreglo[j] = arreglo[j] ^ arreglo[j + 1];
                arreglo[j + 1] = arreglo[j] ^ arreglo[j + 1];
                arreglo[j] = arreglo[j] ^ arreglo[j + 1];}}}}

void imprime (int *arreglo,const short dimencion){
    short i;
    for(i = 0;i <dimencion; ++i)
        printf(" %d |",arreglo[i]);
    printf("\n");}
int main(void)
{
    srand(time(NULL));
    short dimencion = 20;
    short i;
    int arreglo[dimencion];
    for(i = 0; i < dimencion; ++i)
        arreglo[i] = rand()%100+0;
    printf("Sin ordenar:\n\n");
    imprime(arreglo,dimencion);
    bubbleSort(arreglo,dimencion);
    printf("\n");
    printf("Ya ordenado:\n\n");
    imprime(arreglo,dimencion);
    return 0;
}

El Bubble sort nos servir谩 solo para entender un algoritmo relativamente sencillo, as铆 poder pasar a estudiar otro con dificultad media, porque para grandes cantidades de informacion, no es eficiente.

El curso se ve largo, pero de verdad es muy bueno como profundiza los temas.

隆Genial! Entend铆 el algoritmo perfecto y lo realic茅 en JS.
Te lo comparto Platzinauta:

let numbers = [1,4,3,5,6,2,7,425,23,4,35,76,457,4,587,435,2352,35,123,4443,3,23,536,6754,7];

const bubbleSortAlgorithm = (arr) => {
    let sortedElementsCounter = 0;

    for (let position in arr) {
        let currentValue = arr[position];
        let adyacentValue = arr[parseInt(position) + 1];

        if (currentValue < adyacentValue){
            arr[position] = adyacentValue;
            arr[parseInt(position) + 1] = currentValue;
        }else{
            sortedElementsCounter++;
        }
    }

    if(sortedElementsCounter == arr.length) 
        return [arr, true];
    else
        return [arr, false];
}

const bubbleSort = (arr) => {
    let counterIteration = 0;
    let finalSortedArray = [];
    while(true){
        [arr, isSorted] = bubbleSortAlgorithm(arr);
        if(!isSorted){
            finalSortedArray = arr;
            counterIteration++;
        }else{
            return [finalSortedArray,counterIteration];
        }
    }
}

let [sortedNumbers, iterations] = bubbleSort(numbers);

console.log('Iterations:', iterations);
console.log(sortedNumbers);

Cualquier sugerencia es bienvenida 馃槉馃憣

  • Buble Sort, ordena por pares de 1-1 y se va repitiendo hasta que este ordenado. Es sencillo pero poco eficiente cuando se tiene una gran cantidad de elementos a a comparar.

Bubble Sort es el algoritmo m谩s simple que hay

Excelente explicaci贸n de la clase, muy clara la manera de explicar del profesor.

que buena explicaci贸n, excelente.

Buena esa.

Bien claro!

Claro el tema鈥 vamos al </>

Es la mejor explicaci贸n de Bubble sort. Me qued贸 super claro

Entendido鈥

Este curso lo habias impartido como algoritmos con C? Creo haber estudiado esto antes xD

F谩cil de entender pero como comentas es un algoritmo algo tardado jaja

Excelente explicaci贸n.

馃槂 en pocos minutos y ya aprend铆 un algoritmo

Aqu铆 la soluci贸n en TypeScript:

estuvo muy f谩cil de entender

Con esta explicaci贸n es f谩cil de entender el m茅todo de ordenamiento Bubble sort. Muchas gracias.

Muy buen explicaci贸n

Excelente, ya me quedo m谩s claro, y super bien explicado!

muchas gracias

En el Bubble sort, si se aplica un ordenamiento de menor a mayor, el elemento mayor siempre queda al final del vector desde el primer recorrido, y si es de mayor a menor, el elemento menor siempre queda al final del vector desde el primer recorrido, por lo cu谩l se puede decir que el 煤ltimo elemento est谩 completamente ordenado, por lo cual en cada iteraci贸n se obtiene un elemento completamente ordenado, haciendo una mejora al algoritmo se puede evitar comparar los elementos completamente ordenados.

Metodo Burbujaaa 馃槂

Lo hice as铆, a ver c贸mo lo hace 茅l en la siguiente clase鈥

#include <stdio.h>
  
#define SIZE 7

int array[SIZE], buffer;


void ordenar()
{
        for( int i = 0; i < SIZE; i++ )
        {
                for(int j = 0; j < SIZE; j++ )
                {
                        if( array[j] < array[j + 1] )
                        {
                                buffer = array[j];
                                array[j] = array [j + 1];
                                array[j + 1] = buffer;
                        }
                }
        }
}

int main( int argc, const char *argv[] )
{
        for( int i = 0; i < SIZE; i++ )
        {
                printf("ingrese un numero: ");
                scanf( "%d", &buffer );
                array[i] = buffer;
        }

        ordenar();

        for ( int i = 0; i < SIZE; i++)
        {
                printf("%d\n", array[i] );
        }

        return 0;
}```
#include <iostream>

using namespace std;
//bubble sort
int main ()
{
    int i, j, datos[5] = {2,5,1,7,9}, siguiente;
    for ( i = 0; i < 5; i++ )
    {
        for ( j = 0; j < 5; j++ )
        {
            siguiente = datos[j + 1];
            if ( datos[j] > siguiente )
            {
                datos[j + 1] = datos[j];
                datos[j] = siguiente;
            }
        }
    }
    for ( i = 0; i < 5; i++ )
    {
        cout << datos[i] << endl;
    }
}

C#

using System;
using System.Collections.Generic;
using System.Linq;



    class Class1
    {
         static void Main(string[] args)
        {


            int[] aray = { 1, 4, 5, 2, 8, 7, 6, 3, 9 };
            var variable = 0;
            for (var i = 0; i < aray.Length; i++)
            {
                for (var j = 0; j < aray.Length; i++)
                {
                    if (aray[i] > aray[i + 1])
                    {
                        variable = aray[i];
                        aray[i] = aray[i + 1];
                        aray[i + 1] = variable;
                    }
                }
            }

            

            Console.WriteLine(aray);

        }
    }

``

Me imagino que aunque sea el sort m谩s b谩sico, es aplicable en muy pocos casos.

Este es mi c贸digo propio luego de ver esta clase. Solo con el mecanismo en mente.

#include <stdio.h>
#include <string.h>
#define SIZE 5

int values[SIZE], cell = -1;
int firstCell;

void createBubble (int number)
{
  if(cell == -1)
  {
    cell ++;
  }
  values[cell] = number;
  cell++;
}

void swapValues(int *previous1, int *previous2)
{
  //This function swap values using a buffer
  //to temporarely allocate the value of an element
  int buffer = *previous1;
  *previous1 = *previous2;
  *previous2 = buffer;
}

void sort ()
{
  for (int i = 0; i < cell-1; i++)
  {
    if(values[i] > values[i+1])
    {
      swapValues(&values[i], &values[i+1]);
    }
  }
}

void printBubble ()
{
  printf("[");
  for (int i = 0; i < 5; i++)
  {
    printf("%d ", values[i]);
  }
  printf("]\n");
}

int main(int argc, char const *argv[]) {
  int goON;

  createBubble(1);
  createBubble(5);
  createBubble(3);
  createBubble(7);
  createBubble(4);

  printBubble();

  printf("Sort...\n");

  sort();
  sort();

  printBubble();

  return 0;
}

genial!! retroalimentandome 馃槈

++Bubble Sort: ++

El mas r谩pido
Muy iterativo
Poco Eficiente

Amigos, hice un ejemplo de Bubble Sort en donde se muestra cada uno de los aterradores
https://platzi.com/tutoriales/1469-algoritmos/9226-mi-ejemplo-de-bubble-sort/

ac谩 les dejo dos links que pueden interesarles sobre como funciona el Bubble Sort Ac谩 hay otro asegurence de bajarle el volumen antes de abrir el 煤ltimo que tiene el audio alto.

Ya quiero ver c贸mo se implementar铆a.