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

Bubble sort: implementaci贸n

22/42
Recursos

Para esta clase prepararemos las funciones que nos sirvan para hacer nuestro ordenamiento de burbuja dise帽ando tambi茅n la funci贸n que cambie la posici贸n de un elemento en el array.

Aportes 71

Preguntas 9

Ordenar por:

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

o inicia sesi贸n.

Ac谩 una prueba de escritorio de la implementaci贸n del doble for en la funci贸n bubbleSort(): Lo que hace esta implementaci贸n es ubicar los elementos de mayor valor al extremo del arreglo en cada iteraci贸n del for anidado.

La condici贸n del segundo for j < n - i - 1 reduce el n煤mero de comparaciones en cada iteraci贸n. Con esto ya no se comparan los elementos ya ordenados a la derecha del arreglo, es decir, los elementos mayores. En cada iteraci贸n, el elemento mayor de la parte del arreglo que a煤n no est谩 ordenada se coloca en su posici贸n.

Fue util haber hecho el curso de Introducci贸n a Lenguaje C antes de venir aqu铆.

IMPORTANTE AL HABLAR DE BURBUJA recuerden que para el ordenamiento de la burbuja vamos a tener que guardar el valor cada que hagamos una iteraci贸n en una variable temporal porque necesitamos poder guardarlo mientras hacemos el cambio.

En bubble sort cuando estamos ordenando de forma asc, despues de cada recorrido completo del array tendremos al menos el ultimo valor de la lista ordenado. Es por esto que en el segundo ciclo no se debe recorrer hasta el final sino hast final-numeroDeIteracionesAnteriores.

function bubbleSort(sortedList = []) {
    const length = sortedList.length;
    
    for (let i = 0; i< length - 1; i++) {
        for (let j=1; j<length-i; j++) {
            if (sortedList[j-1] > sortedList[j]) {
                const swap = sortedList[j-1];
                sortedList[j-1] = sortedList[j];
                sortedList[j] = swap;
            }
        }
    }

    return sortedList;
}

function sort() {
    let list = [4,2,6,8,1,5];
    console.log(`Unsorted List: ${list}`);
    // Desordered List: 4,2,6,8,1,5
    console.log(`Sorted List: ${bubbleSort([...list])}`);
    // Sorted List: 1,2,4,5,6,8
}

sort();

Ejemplo realizado con Angular, que muestra en pantalla el proceso que se llev贸 a cabo para ordenar el array.

https://stackblitz.com/edit/vgmva1-bubble-order

Lo hice antes de ver el video, y con un men煤. Me qued贸 as铆:
bubblesort.c

#include <stdio.h>
#include "bubblesort-func.h"

void menu(){
	int option=0;
    do{
        printf("\n-------------------------------\n");
        printf("            BUBBLE SORT :D\n");
        printf("1. Llenar o sobreescribir el array\n");
        printf("2. Imprimir el contenido del array\n");
        printf("3. Organizar el array\n");
        printf("4. Salir\n");
        printf("-------------------------------\n");
        printf("Digite su opci贸n:");
        scanf("%i", &option);
		printf("\n");
		
        switch(option){
            case 1:
                getArray();
            break;
            case 2:
                printArray();
            break;
            case 3:
                bubbleSort();
            break;
            case 4:
                printf("Gracias por usar :D");
            break;
            default:
                printf("Opci贸n inv谩lida");
        }
		if((option != 1) && (option != 2)){
			printf("\n");
		}
    }while(option != 4);
}

int main(){
    menu();

    return 0;
}

bubblesort-func.h

int array[0];
int sizeArray=0;

void printArray(){
	if(sizeArray == 0){
		printf("Array vac铆o, no se puede imprimir :c\n");
	}else{
		for(int i=0; i<sizeArray; i++){
			printf("Array[%i] = %i\n", i, array[i]);
		}
	}
}

void getArray(){
    printf("Digite el tama帽o de su array: ");
    scanf("%i", &sizeArray);
    
    for(int i=0; i<sizeArray; i++){
        printf("Digite el valor de la posici贸n %i en su array: ", i);
        scanf("%i", &array[i]);
    }
}

void mayorMenor(){
    int casos=1;
    while(casos != 0){
        casos=0;
    	for(int i=0; i<sizeArray-1; i++){     //Se recorre hasta sizeArray-1 porque si llega hasta sizeArray se compara con sizeArray+1 (que ser铆a un espacio vac铆o, un 0)
    	    if(array[i+1] < array[i]){
    	        int temp = array[i];
    	        array[i] = array[i+1];
    	        array[i+1] = temp;
    	        casos++;
    	    }
    	}
    }
}

void menorMayor(){
	int casos=1;
    while(casos != 0){
        casos=0;
    	for(int i=0; i<sizeArray-1; i++){
    	    if(array[i+1] > array[i]){
    	        int temp = array[i];
    	        array[i] = array[i+1];
    	        array[i+1] = temp;
    	        casos++;
    	    }
    	}
    }
}

void bubbleSort(){
	if(sizeArray == 0){
		printf("Array vac铆o, no se puede organizar :c");
	}else{
		int option=0;
		printf("1. De mayor a menor\n");
		printf("2. De menor a mayor\n");
		printf("Opci贸n:");
		scanf("%i", &option);
		
		switch(option){
			case 1:
				mayorMenor();
			break;
			case 2:
				menorMayor();
			break;
			default:
				printf("Opci贸n inv谩lida");
		}
	}
}

El mejor porfesor para explicar es Freddy, por lejos!

For comparison purposes in an array, two adjacent cells are needed; in an array of 6 elements, only 5 comparisons take place; in an array of 10 elements, 9 comparisons, and so on.

So for 7 elements, just 6 comparisons are done, hence the general rule of n-1 in the outer for loop

About the n-1-i expression, remember that the highest (or lowest, depending on the ordering criterion) value in the bubble sort goes to the last position in the array after the first cycle, so there is no need to compare that value with anything else, therefore the array has to be 鈥渟hortened鈥 1 cell at a time, and the value of i in the outer loop is the counter responsible for that in the inner loop:

5 | 3 | 9 | 20 | elements (n) = 4

after first cycle (i = 0), 20 has reached its correct position within the array (using an ascending order), leaving us with an array of 3 elements; in next cycle, i will be equal to 1, and as n-1 remains the same, we need to substract 1 in that expression to 鈥渟horten鈥 the array:
n-1-i = 4-1-1 = 2, which is the index of the last element in that new array as well as the quantity of comparisons needed.

aqu铆 esta mi solucion en python

# Definicion de variables
numbers_array = [4, 2, 3, 6, 1, 5]
esta_ordenado = False


def ordenar_array(list):
    global esta_ordenado
    # imprime el arreglo original
    print("Arreglo original\n")
    for x in list:
        print(x, end=' ')
    print("\n")

    # algoritmo de ordenamiento
    while not esta_ordenado:
        # ciclo de ordenamiento
        for x in range(0, 5):
            if list[x] > list[x + 1]:
                temp = list[x]
                list[x] = list[x + 1]
                list[x + 1] = temp
        # ciclo de verificacion
        for x in range(0, 5):
            if list[x] > list[x + 1]:
                esta_ordenado = False
                break
            else:
                esta_ordenado = True

    print("Arreglo ordenado\n")
    for x in list:
        print(x, end=' ')
    print("\n")


if __name__ == "__main__":
    ordenar_array(numbers_array)

Resultado

Arreglo original

4 2 3 6 1 5 

Arreglo ordenado

1 2 3 4 5 6 

Mi implementaci贸n en Java

class Main {
  public static void main(String[] args) {
    int[] array = {5,8,9,2,1};
    for(int i=0; i<array.length; i++)
      for(int j=0; j<array.length; j++)
        if(j+1<array.length)
          if(array[j]>array[j+1]){
            int temp = array[j];
            array[j] = array[j+1];
            array[j+1] = temp;
          }
    
    for(int x=0; x<array.length; x++)
      System.out.println(array[x]);
  }
}

Bien pobre la explicacion del profesor sobre como funciona la logica del j < n - i - 1 en el for anidado. 馃憥

Aqu铆 mi c贸digo en python:

def bubbleSort(messy_list):
  print("Ordenando..")
  for _ in range(len(messy_list)):
    for i in range(len(messy_list)-1):
        left = messy_list[i]
        right = messy_list[i+1]
        if left > right:
          messy_list[i] = right
          messy_list[i+1] = left

  return messy_list


if __name__ == '__main__':
  messy_list = [5,9,2,6,1,3,7,8]
  print(messy_list)
  ordered_list = bubbleSort(messy_list)
  print(ordered_list)

La explicaci贸n del bubblesort se me hizo muy enredada por lo que ayud谩ndome con este video y probando pude entenderlo a la perfecci贸n. Si alguien quiere que lo ayude con gusto estoy 馃槈

https://www.youtube.com/watch?v=Jdtq5uKz-w4&t=430s

Les comparto un video de bubble sort, muy practico y entendible tambien para reforzar la clase: https://www.youtube.com/watch?v=P_xNb8nFgmA&ab_channel=Programaci贸nATS

excelente, el curso, con cierto grado de dificultad para los novatos como uno. Se presuponen muchos a-prioris que para la gente formada en otras 谩reas del conocimiento (lengua y literatura hisp谩nica, que es mi caso), que deben ser dilucidados antes de continuar. Todo este proceso me encanta, pero me confronta y me reta a llenar esos vac铆os de conocimiento. D铆as pasan para que en algunos cursos pueda seguir avanzando. Mi poca experiencia la he adquirido en excel: tablas, funciones, datos, macros, y un poco de VB, y en este curso de algoritmos comienzo a entender el pleno funcionamiento de la ofim谩tica de excel. Gracias

C贸digo en JavaScript

let array = [2,4,1,5,3];
let aux;

//Booble sort
for(let i = 0; i<5; i++){
  for(let j = 0; j<5; j++){
    if(array[j]>array[j+1]){
      aux = array[j];
      array[j] = array[j+1];
      array[j+1] = aux;
    }
  }
  console.log(`Iteracion ${i+1}: ${array}`);
}
console.log(`Resultado final -> ${array}`);

Esta es mi implementaci贸n en JS

function bubbleSort(array){
    let n=array.length;
    console.log(n);

    for(let i=0;i<n-1;i++){
        for(let j=0;j<n-1-i;j++){
            [array[j],array[j+1]]=compare(array[j],array[j+1]);
        }
    }
    
}
function compare(num1, num2){
    if(num1<=num2){
        return [num1,num2]
    } else{
        return [num2,num1]
    }
}```
#include <stdio.h>

void cambiar_posicion(int *n1, *n2)
{
    int temp = *n1;
    *n1 = *n2;
    *n2 = temp;
}

void bubblesort(int vector_entrada[], n)
{
    int i, j;
    for(i=0; i < n-1; i++)
    {
        for (j = 0; j < n-i-1; j++)
        {
            if (vector_entrda[j]>vector_entrada[j+1])
            {
                cambiar_posicion(&vector_entrada[j],&vector_entrada[j+1]);
            }
            
        }
        
    }
}```

Mi soluci贸n

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

void sort(int array[]){
    int cantidadEspacios = sizeof(array);
    bool completado = false;

    for(int i = 0;i < cantidadEspacios;i++){
        printf(" [%d] ",array[i]);
    }
    int cantidadEspaciosParaImprimir = cantidadEspacios;
    printf("\n");
    int contador = 1;
    int temp;
    do{
        for(int i = 0;i < cantidadEspacios - 1;i++){
            if(array[i] > array[i + 1]){
                temp = array[i];
                array[i] = array[i+1];
                array[i+1] = temp;
            }
        }
        printf("Vuelta n掳 %d", contador);
        for(int i = 0;i < cantidadEspaciosParaImprimir;i++){
            printf(" [%d] ",array[i]);
        }
        printf("\n");
        cantidadEspacios--;
        contador ++;
    }while(cantidadEspacios > 0);
}

int main(){
    int array[] = {1,5,3,8,9,3,1,4};
   sort(array);
    int cantidadEspacios = sizeof(array)/sizeof(array[0]);
    printf("Array ordenado\n");
    for(int i = 0;i < cantidadEspacios;i++){
        printf(" [%d] ",array[i]);
    }
    return 0;
}

En python3.

import random

def cambiar_pos(x,y):

	temp = x
	n1 = y
	n2 = temp
	return n1, n2


def bubble_sort(array):
	n = len(array)

	for i in range(n):
		for j in range(n-i-1):
			if array[j] > array[j+1]:
				array[j], array[j+1] = array[j+1], array[j]

lista = [x for x in range(100)]
random.shuffle(lista)
print(lista)

bubble_sort(lista)
print(lista)```
#include <stdio.h>


// Funcion que hace swap a dos dirreciones enteras de memoria
void cambiar_pos( int *n1, int *n2 ) {
  // Almacenar un cambio
  int temp = *n1;
  *n1 = *n2;
  *n2 = temp;
}

// Implementacion del algoritmo de bubble sorrt
void bubbleSort( int vector_entrada[], int n) {
  // Para que no lo calcule cada vez que entra al ciclo
  int tamano = n - 1;

  // Por cada valor del arreglo
  for ( int i = 0; i < tamano; i++) {
    int ciclos = n - i - 1;

    // Recorriendo, menos los ultimos porque
    // esos ya estan ordenados
    for ( int j = 0; j < ciclos; j++ ) {

      // Hacer swap en caso de que dos valores esten en desorden
      if ( vector_entrada[j] > vector_entrada[ j + 1 ] ) {
        cambiar_pos( &vector_entrada[j], &vector_entrada[ j + 1 ] );
      }
      
    }
  }

}

Una version diferente en C
Con Do-While y que permite recibir los numeros del array mediante standard input por consola

Muy bien detallado.

Mi implementaci贸n con Javascript.

function orderNumbers(inputs){
    let isInOrder = true
    do{
        isInOrder = true
        for(let i=0; i<inputs.length; i++){
            if(inputs[i]> inputs[i+1]){
                let aux = inputs[i]
                inputs[i] = inputs[i+1]
                inputs[i+1] = aux
                isInOrder = false
            }
        }
    }while(isInOrder === false)
}

Aqu铆 les va mi c贸digo en python! A mi se me ocurri贸 utilizar un While y un For 馃槂

def interchange(array_entrada, num_1, num_2):
    """This function executes and interchange of values of a given array.    

    Args:
        array_entrada ```list``` : The array in which the movements are to be made.
        num_1 ```int``` : The first position of the array to be interchanged.
        num_2 ```int``` : The second position of the array to be interchanged.
    
    Returns:
        array_entrada ```list``` : The array with interchanged positions
    
    Example:
    
    >>> array_entrada = [4, 2, 32, 1], num_1 = 0, num_2 = 1
    array_salida = [2, 4 , 32, 1]
    """

    temp = array_entrada[num_1]    
    array_entrada[num_1] = array_entrada[num_2]
    array_entrada[num_2] = temp
    return array_entrada

def bubble_sort(array_entrada):
    """
    This function executes the Bubble Sort algorithm on the given array.    

    Args:
        array_entrada: ```list``` = An unordered List of floating or integer numbers.
    
    Returns:
        array_salida: ```list``` = A sorted List of floating or integer numbers
    
    Example:
    
    >>> array_entrada = [4, 7, 32, 1]
    array_salida = [1, 4, 7, 32]
    """
    array_salida = array_entrada
    # is_sorted serves as a flag for our algorithm to exti the sroting function inside the while.
    is_sorted = False
    while is_sorted == False:
        # is_sorted flag will stay True if there are no needd
        is_sorted = True
        n = len(array_salida)
        for i in range(0, n-1):
            print("Checando la posicion: " + str(i))
            if array_salida[i] > array_salida[i+1]:
                is_sorted = False   
                print("Reacomodando... ")
                array_salida = interchange(array_salida, i , i + 1)
            print(array_salida)
    return array_salida 


def main():
    array_entrada = [5,34,23,3,2,8,8]
    bubble_sort(array_entrada)

if __name__ == '__main__':
    main()```


Buena clase!

Explicacion de codigo:

Codigo:



#include<stdio.h>
void cambiar_pos(int *n1, int *n2){#Funcion de cambio de valores
    int temp = *n1;
    *n1 = *n2;
    *n2 = temp;
}
void bubbleSort(int array[], n){
    int i;
    int j;
    for(i = 0; i < n-1; i++){#Ciclos totales
        for(j = 0; j < n-i-1; j++){#Recorrido del array
            if(array[j]>array[j+1]){
                cambiar_pos(&array[j], &array[j+1])#Comparacion de numeros
            }
        }
    }
}
#j+1, significa el numero siguiente en el array
#n -i -1 Es para ubicarse en la posicion correcta del array deacuerdo a su posici贸n```

Interesante como estructur贸 las funciones! 馃く

#include<stdio.h>

void cambiar_pos(int *n1, int *n2)
{
    int temp = *n1;
    *n1 = *n2;
    *n2 = temp;
}

void bubbleSort(int vector_entrada[], n)
{
    int i,j;
    for (i=0; i < n-1; i++)
    {
        for(j=0; j < n-i-1; j++)
        {
            if(vector_entrada[j]>vector_entrada[j+1])
            cambiar_pos(&vector_entrada[j],&vector_entrada[j+1])
        }
    }
}```

C贸digo en JS:

Realize mi ejemplo con un ejercicio de java que trabaje en la escuela, aun no domino los t茅rminos correctos pero espero a alguien le pueda servir y claro, puedan hacer mejoras 馃榿馃憤

//clase main
 Busqueda<Integer> busqueda2 = new Busqueda<>();
        System.out.println(Arrays.toString(arreglo));
        busqueda2.bubbleSort(arreglo);
        System.out.println(Arrays.toString(arreglo));

//clase de busqueda
public class Busqueda<T extends Comparable> {
public void bubbleSort(T[] array) {
        T valor_temp;
        for (int i = 0; i < array.length; i++) {
            for (int j = 0; j < array.length; j++) {
                if (j + 1 < array.length) {
                    if (array[j].compareTo(array[j + 1]) > 0) {
                        valor_temp = array[j];
                        array[j] = array[j + 1];
                        array[j + 1] = valor_temp;
                    }
                }
            }
        }
    } 
}

Con python Me base en la respuesta de aarongabriel420, con un par de mejoras al momento de imprimir el array desordenado y el ordenado. Tambi茅n coloque una mejora para que el ciclo for se ejecute dependiendo del largo de la lista, ya no es necesario colocar el dato de range de forma manual:

<array = [2,8,1,6,3,9]
esta_ordenado= False

def ordenar_lista(lista):
    # imprimir arreglo original
    print("arreglo original\n")
    print(lista,"\n")

    global esta_ordenado

    #algoritmo de ordenamiento
    while not esta_ordenado:  

        for n in range(0, len(lista) - 1):
            if lista[n] > lista[n + 1]:
                vtemp = lista[n]
                lista[n] = lista[n + 1]
                lista [n + 1] = vtemp

        for n in range(0, len(lista) - 1):
            if lista[n] > lista[n + 1]:
                esta_ordenado = False
                break
            else:
                esta_ordenado = True

    print("arreglo ordenado\n")
    print(lista,"\n")

ordenar_lista(array)>

Resultado :

arreglo original

[2, 8, 1, 6, 3, 9]

arreglo ordenado

[1, 2, 3, 6, 8, 9]

Ejemplo en javascript

este es mi bubble sort:

import logging
logging.basicConfig(level=logging.INFO)
#lista=[5,4,3,2,1,7,19,2,100,4,22,11,15]
lista=[13,12,11,10,9,8,7,6,5,4,3,2,1]
def order(lista,first):
    if lista[first]>lista[first+1]:
        menor=lista[first+1]
        mayor=lista[first]
        lista[first]=menor
        lista[first+1]=mayor
        return lista
    else:
        return lista
def bubble_bucle(lista):
    for a in range(len(lista)-1):
        logging.info('entrando a order')
        for first in range(len(lista)-1):
            lista=order(lista,first)
            logging.info(str(lista))
    return lista
lista=bubble_bucle(lista)
logging.info('la lista es {}'.format(str(lista)))```

Siento que entiendo pero no con totalidad, creer铆a que es porque debo seguir practicando.

Buena explicaci贸n, es complejo al comienzo pero con pr谩ctica y analizando cada procedimiento cada vez es m谩s entendible.

creo que se debe seguir practicando ya que es la primera vez que interactuo con este procedimiento

Creo que para el ejemplo se debe de dejar una lectura para entender lo que es el paso por valor y el paso por referencia porque en la implementaci贸n se usa directamente sin explicar el porqu茅.

def bubble_sort(size):
    list = [random.randint(0, 1000) for n in range(size)]
    n = len(list)

    for i in range(n):
        for j in range(0, n - 1):
            if list[j] > list[j + 1]:
                list[j], list[j + 1] = list[j + 1], list[j]
        return list

me perd铆 un poco, por qu茅 las variables n1 y n2 van con un * antes?

ordenamientos directos(basicos)
selecci贸n, inserci贸n, burbuja (ineficientes para grandes cantidades de datos)
ordenamientos indirectos(avanzados)
shell, quick sort, merge sort, radix sort.

un peque帽o aporte que no dicen en este curso

Mi versi贸n.

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

void sort(int array[], size_t size)
{
	unsigned short sorted = 0;
	int tmp = 0;

	for (int x = 0; x < size - 1; x++)
	{
		for (int i = 0; i < size - x - 1; i++)
		{
			if (array[i] > array[i + 1])
			{
				tmp = array[i];
				array[i] = array[i + 1];
				array[i + 1] = tmp;
				sorted = 1;
			}
		}

		// Break the loop if no swaps has been performed
		if (!sorted)
			break;
		sorted = 0;
	}
}

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


int main(const int argc, const char *argv[])
{
	int a[] = {11, 5, 4, 1, 3, 200, 6, 600, 1, 7, 29, 22, 9, 300};
	size_t size = sizeof(a)/sizeof(a[0]);

	display_array(a, size);
	sort(a, size);
	display_array(a, size);

	return 0;
}

Mi ejemplo de bubble sort en JavaScript

const items = [5, 2, 4, 2, 100, 7, 1, 3, 50]

for (let i = 0; i < items.length; i++) {
  for (let j = 0; j < items.length - 1; j++) {
    if (items[j] > items[j + 1]) {
      const element = items[j]
      items[j] = items[j + 1]
      items[j + 1] = element
    }
  }
}

No me queda del todo claro porque hace n-i-1

C贸digo en Java:

public void BubbleSort(int arreglo[])
{
	for (int i=0; i<arreglo.length-1; i++)
		for (int j=0; j<arreglo.length-i-1; j++)
			if (arreglo[j] > arreglo[j+1])
			{
				int temp = arreglo[j];
				arreglo[j] = arreglo[j+1];
				arreglo[j+1] = temp;
			}
}
void BubbleSort(int* numeros){

    int continueLoop = 1;
    for(int i = 0; i < MAX; i++){
            if(continueLoop){
                continueLoop = 0;
                for(int y = 0; y < MAX - 1; y++){
                    if(numeros[y] > numeros[y + 1]){
                        swapNumbers(numeros[y], numeros[y + 1]);
                        continueLoop = 1;
                    }
                }
            }
            else{
                return;
            }
    }
}

void swapNumbers(int a, int b){
    int aux = 1;
    aux = a;
    a = b;
    b= aux;
}

I鈥檓 using the variable continueLoop because I want to know if there are not changes into a loop, if there are not I don鈥檛 want to continue looping the double for, that means that my array is sorted

Todo esto funciona exactamente igual si uso n煤meros flotantes?

muy entendible.

Comparto otra propuesta para implementar el algoritmo bubble sort con una sola funci贸n. Uso una variable para detectar cuando se dejan de producir cambios (es decir la secuencia ya est谩 en orden) y un ciclo do while que se ejecute mientras encuentre alg煤n cambio. Lo dem谩s es una simple comparaci贸n de los datos del vector mediante un ciclo for

#include <stdio.h>
#include <string.h>
#define size 10

int vector[size]={2,43,45,87,9,0,-2,34,-10,-10};

void bubbleSort(int array[]){
  int change=0;
  int aux=0;
  do{
    change=0;
    for (int i=1;i<size;i++){
      if(array[i-1]>array[i]){
        aux=array[i];
        array[i]=array[i-1];
        array[i-1]=aux;
        change=1;
      }
    }
  }while (change!=0);
}

Comparto uno que hice en javascript. Salu2

var values = [7,2,3,2,5,4,5,9,8,1,2,6,8,4]


function bubblesort(numberOfValues){
  for(i=0;i<numberOfValues;i++){
    var p = 0;
    while(p<numberOfValues){
      var firstCounter=p;
      var secondCounter=p+1;
      var firstValue=values[firstCounter];
      var secondValue=values[secondCounter];
      if(firstValue>secondValue){
        values[firstCounter]=secondValue;
        values[secondCounter]=firstValue;
      }
      p++;
    }
  }
  return values;
}

console.log(bubblesort(values.length));

thanks!

Alguien lo hizo en Python?

Graxias

Importante saber hacer c贸digo en varios lenguajes.

#Codigo en Python
def cambiar_pos(n1,n2):
	n1,n2 = n2,n1

def bubble_sort(vector):
	n = len(vector)
	for i in range(n):
		for j in range(n-i-1):
			if vector[j] > vector[j+1]:
				cambiar_pos(vector[j],vector[j+1])

Muy bien!

![](

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

void cambiar(int *a, int *b){
    *a = *a ^ *b;
    *b = *a ^ *b;
    *a = *a ^ *b;}

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])
                cambiar(&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\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("Ya ordenado:\n\n");
    imprime(arreglo,dimencion);
    return 0;
}```

Me gustaron este tipo de ejercicios, sobre todo para entender la l贸gica del proceso.

var numbersArray = [9,5,4,6,7,2,1,10,0,5];

let bubbleSort = (newArray) => {
    let position = newArray.length;
    for (let i = 0; i < position; i++) {
        for (let j = 0; j < position; j++) {
            if (newArray[j] > newArray[j + 1]) {
                let tmp = newArray[j];
                newArray[j] = newArray[j + 1];
                newArray[j + 1] = tmp;
            }
        }
    }
    return newArray;
};

console.log(bubbleSort(numbersArray));```

Lo intent茅 implementar para que no fuera necesario pasarle el tama帽o del array en la variable n.

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

void changePos(int *n1, int *n2){
	int temp = *n1;
	*n1 = *n2;
	*n2 = temp;
}

void bubblesort(int array[]){
	int isSorted = 0;
	int i = 0;
	int lenght = sizeof(array) / sizeof(array[0]);
	while(isSorted == 0){
		isSorted = 1;
		for(i = 0; i < lenght - 1; i++){
			if(array[i] > array[i + 1]){
				changePos(&array[i], &array[i + 1]);
				isSorted = 0;
			}
		}
	}
}
int main(){
	int array[] = {5,6,9,5,69,15,36,25,14,25,23};
	int lenght = sizeof(array) / sizeof(array[0]);
	int i;

	bubblesort(array1);

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

	return 0;
}

La funci贸n sizeof() te devuelve el tama帽o en bytes del dato que le pases. Por ejemplo en la funci贸n main para hallar el lenght se debe dividir el tama帽o (en bytes) de todo el array entre el tama帽o de lo que ocupa cada posici贸n del array. Entonces, sizeof(array) = 44 y sizeof(array[0]) = 4, por lo que lenght = 11, lo cual es correcto.
Pero en la funci贸n bubblesort() sizeof(array) = 8, lo que hace que falle todo el programa. No s茅 por qu茅 pasa esto 馃槙
As铆 que por el momento lo dejar茅 de esta forma



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

void changePos(int *n1, int *n2){
	int temp = *n1;
	*n1 = *n2;
	*n2 = temp;
}

void bubblesort(int array[], int n){
	int isSorted = 0;
	int i = 0;
	while(isSorted == 0){
		isSorted = 1;
		for(i = 0; i < n - 1; i++){
			if(array[i] > array[i + 1]){
				changePos(&array[i], &array[i + 1]);
				isSorted = 0;
			}
		}
	}
}
int main(){
	int array[] = {5,6,9,5,69,15,36,25,14,25,23};
	int lenght = sizeof(array) / sizeof(array[0]);
	int i;

	bubblesort(array, lenght);

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

	return 0;
}

Amigos, yo hice un ejercicio de Bubble Sort incluso antes de siquiera saber que esa era su nombre. El c贸digo esta en el siguiente enlace
https://platzi.com/tutoriales/1469-algoritmos/9226-mi-ejemplo-de-bubble-sort/

驴Que para que sriven los asterizcos?
Se llaman punteros y guardan o 鈥渁puntan鈥 a una direccion en memoria.
驴Porque no usar simples referencias como: int a?
Imagina la siguiente funcion:

int suma(int a, int b){
	return a + b;
}
int resultado = suma (20, 6);

Cuando llames a esta funcion tendras que asignar el valor devuelto a una variable.

En cambio con los punteros puedes operar directamente en el espacio de memoria al que apuntan. Ejemplo:

void suma (int* a, int* b, int* c){
	*c = (*a + *b);
}

De este modo no tienes que retornar nada, ni asignarle el valor devuelto a una nueva variable.
驴Cual es exactamente la diferencia entre un puntero y una variable?
Las variables tienen una direccion fija; es decir no cambian.

int x = 20;
int y = 10;
int * puntero;
x = y;
//el operador & devuelve una direccion en memoria
//aqui puntero apunta a la direcci贸n de x
puntero = &x;
printf("Direcci贸n de memoria de x: %p\n", puntero);
//ahora puntero no cambio de valor, "salt贸" a otra direcci贸n
puntero = &y;
printf("Direcci贸n de memoria de y: %p\n", puntero);

si ejecutas el codigo anterior en main, veras que imprimira 2 direcciones de memoria diferentes.

Por el momento este es el c贸digo que tengo del programa (prefiero poner todo en ingl茅s como mejor pr谩ctica:

#include <stdio.h>

void change_pos(int *n1, int *n2)
{
    int temp=*n1;
    *n1=*n2;
    *n2=temp;
}

void bubbleSort(int entry_Vector[],n)
{
    int i, j;
    for(i=0;i<n-1;i++)
    {
        for(j=0;j<n-i-1;j++)
        {
            if(entry_Vector[j]>entry_Vector[j+1])
            {
                change_pos(&entry_Vector[j],&entry_Vector[j+1]);
            }
        }
    }
}

mi peque帽o aporte, implementacion en pyton:

<code>
## ordena burbuja::
def burbuja(vct):
    cambios=1 # inicializo/ simula un do-while
    while cambios>0: # repite hasta que no haya cambios de posicion en el vector
        cambios=0
        for i in range(len(vct)-1):
            #print("pares a comparar:" ,vct[i],vct[i+1])
            if vct[i]>vct[i+1]:
                cambios += 1
                swap_element(vct,i)
            #print('swaped paris:',vct[i],vct[i+1] )

def swap_element(vct,i):
    mayor=vct[i] # mayor a variable auxiliar
    vct[i]=vct[i+1] # menor a posicion antes
    vct[i+1]=mayor # mayor a posicion despues

Este es mi c贸digo en Python

#include<iostream>
#include<conio.h>

using namespace std; 

int main() {

	int numeros[5] = {4,1,2,3,5};
	int j, i, cambio;

	//algoritmo burbuja
	for ( i=0; i<5; i++)
	{
		for (j=0; j<4; j++) {
				//4 > 1 
			if (numeros[j] > numeros[j + 1]) {
				cambio = numeros[j]; //4
				numeros[j] = numeros[j + 1]; //1
				numeros[j + 1] = cambio;
			}
		}
	}

	for (int m = 0; m < 5; m++) {
		cout << numeros[m] << " ";
	}
	
	return 0;
}


les dejo el algoritmo por burbuja de una forma mas sencilla 

Reto Solucionado

<code>
//Bubble sort
//1-Comencamos a hacer la coparacion de elementos adyacentes
//2-Repetimos hasta tener una pasada completa sin ningun swap


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

void cambiar_pos(int *n1, int *n2){
    int temp = *n1;
    *n1 = *n2;
    *n2 = temp;
}

 void bubbleSort(int vector_entrada[],int n){
    int i, j;
    for(i=0; i<n-1; i++){
        for(j=0; j<n -i-1;j++){
            if(vector_entrada[j]>vector_entrada[j+1]){
                cambiar_pos(&vector_entrada[j],&vector_entrada[j+1]);
            }
        }
    }
}

 void bubbleSortMayor(int vector_entrada[],int n){
    int i, j;
    for(i=0; i<n-1; i++){
        for(j=0; j<n -i-1;j++){
            if(vector_entrada[j]<vector_entrada[j+1]){
                cambiar_pos(&vector_entrada[j],&vector_entrada[j+1]);
            }
        }
    }
}

int print_array(int vector_entrada[], int n){
    int i;
    for(i=0; i<n; i++){
        printf("%d ,", vector_entrada[i]);
    }
    printf("\n fin del ordenamiento\n");
}

int main(int arrg, char const *argv[]){

int vector_entrada[]={100, 1992, 0, 5, -1, 60, 70, 14, 15, 10};
int n = sizeof(vector_entrada)/sizeof(vector_entrada[0]);
bubbleSort(vector_entrada, n);
print_array(vector_entrada, n);
bubbleSortMayor(vector_entrada, n);
print_array(vector_entrada, n);
printf("\n");


return 0;
}