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: main code

23/42
Recursos

Ya que tenemos lista nuestra funci贸n de ordenamiento bubbleSort(). Ahora, debemos aprender a implementarla para imprimir los resultados usando algunos ciclos for.

Recuerda que debes evitar algunos nombres especiales para tus funciones porque ya fueron definidos por defecto en nuestros lenguajes de programaci贸n. Por ejemplo, nuestra funci贸n print va a mostrar error y m谩s bien podemos llamarla print_array.

El desaf铆o de esta clase es realizar el ordenamiento pero, al rev茅s: de mayor a menor. Recuerda dejarlo en la secci贸n de comentarios.

Aportes 287

Preguntas 18

Ordenar por:

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

o inicia sesi贸n.

Reto :

Simplemente cambie el > a <

Mayor: 
if(entry_array[j] > entry_array[j+1])

Menor:
if(entry_array[j] < entry_array[j+1])

Me di cuenta de que en la terminal, al imprimir el array nos salen solo 9 numeros a pesar de que hay 10.

Para que se impriman los 10 simplemente cambie esto en la funcion print_array

Cambie el n-1
for(i = 0; i < n - 1; i++)
Por:
solamente n
for(i = 0; i < n; i++)

Reto cumplido 馃挭

#include <stdio.h>

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

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

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

main(int argc , char const *argv[])
{
	int vectorEntrada[]={100,1992,0,5,-1,60,70,15,14,10};
	int n = sizeof(vectorEntrada)/sizeof(vectorEntrada [0]);
	bubbleSort(vectorEntrada,n);
	printarray(vectorEntrada,n);
	return 0;
}

Hola a todos y al profesor @ricadocelis encontr茅 un error en la funci贸n print de esta clase! en la secci贸n de c贸digo en la que imprimimos el arreglo, osea la funci贸n print, hay un error de c贸digo, ya que al poner en el ciclo la condici贸n siguiente:

for(i=0; i < n-1; i++)

se est谩 perdiendo la impresi贸n de la ultima posici贸n del arreglo. La soluci贸n es muy simple, cual es sustituy茅ndola por alguna de estas dos:

for(i=0; i < =n-1; i++)

o

for(i=0; i < n; i++)

Suerte a todos y que les vaya bien por el curso!

Aqu铆 est谩 cortito en JS:

Tambi茅n se puede dividir el tama帽o del arreglo entre el tama帽o de bytes del tipo de dato del arreglo, en este caso int:

int n = sizeof(vector_entrada) / sizeof(int);

Dejo el reto de esta clase:

#include <stdio.h>

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

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

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

int main(int argc, char const *argv[])
{
    int vector_entrada[] = {100, 1992, 0, 5, -1, 60, 70, 14, 15, 10};
    int n = sizeof(vector_entrada) / sizeof(int);
    bubbleSort(vector_entrada, n);
    print_array(vector_entrada, n);
    printf("\n");
    return 0;
}

Resultado

1992 ,100 ,70 ,60 ,15 ,14 ,10 ,5 ,0 ,-1 ,
 fin del ordenamiento

Mi aporte
.
Tiempo de procesamiento del algoritmo bubble sort:
para 10 elementos = 8.153915405273438e-05 [s]
para 100 elementos = 0.001003265380859375 [s]
para 1k elementos = 0.12418365478515625 [s]
para 10k elementos = 12.578235149383545 [s]
para 100k elementos = 1438.1797306537628 [s]
.
C贸digo escrito en python3 te invito a que pases a verlo y corroborar los resultados en colab
-> https://colab.research.google.com/drive/1H7WzH2AtZjKJbeoULSjKqjVeCaP8OdO3
.
.
Pd: No lo intenten con 100k amigos acabo de hacer una fusi贸n nuclear en mi cpu

Implementacion en Python:

def bubbleSort(array: list):
    array_length = len(array)
    for _ in range(array_length - 1):
        for i in range(array_length - 1):
            temp = array[i]
            if (array[i] > array[i + 1]):
                array[i] = array[i + 1]
                array[i + 1] = temp
    return array


lista = [24, 80, 120, 412, 381, 48, 52]
bubbleSort(lista)
print(lista)```

La l铆nea:

int n = sizeof(vector_enterda) / sizeof(vector_entrada[0]);

se puede cambiar por:

int n = sizeof(vector_enterda) / sizeof(int);

Una manera m谩s corta.

A continuaci贸n env铆o el main code del Bubble Sort en c贸digo Java.
He tenido que modificar levemente el funcionamiento del m茅todo de ordenamiento puesto que necesitaba almacenar el nuevo orden de los elementos y a帽adirlos al array original.

Ahora en un momento subir茅 el c贸digo con el reto propuesto.

public class BubbleSort {
	 
	 public static int[] rdo=new int[2];

	
	public static int[] cambiarPosicion(int n1, int n2) {
		
		int temp = n1;
		n1 = n2;
		n2 = temp;
		
		rdo[0]=n1;
		rdo[1]=n2;
		
		return rdo;
	}
	
	public static void bubbbleSort(int[] arrayEntrada, int n) {
		int i, j;
		
		for(i=0; i <n-1; i++) {
			
			for(j=0; j<n-i-1; j++) {
			
				if(arrayEntrada[j] > arrayEntrada[j+1]) {
					cambiarPosicion(arrayEntrada[j], arrayEntrada[j+1]);
					arrayEntrada[j]=rdo[0];
					arrayEntrada [j+1]=rdo[1];
				}
			}
		}
		
	}
	
	public static int print( int[] arrayEntrada, int n) {
		
		int i;
		
		for(i=0; i<n; i++) {
			
			System.out.print(arrayEntrada[i]+" ");
		}
		
		System.out.println("\n Fin del ordenamiento");
		
		return 0;
	}
	
	
	public static void main(String[] args) {
	
		
		  int[] arrayEntrada= { 58258 ,100, 1992, -1, 60, 70, 14, 15, 10, 6591};
		 
		  int n=arrayEntrada.length;
		
		bubbbleSort(arrayEntrada, n);
		
		print(arrayEntrada, n);
		
		

	}

}

Tengo una duda.
驴Porque la funci贸n print_array es de tipo int, cuando no estamos retornando nada?.
Gracias!

Reto cumplido!
Le hice una modificaci贸n al c贸digo. Ahora este puede hacerlo en menos vueltas. Cambie el primer for por un un while con una bandera que este activa mientras se realice alg煤n intercambio en el segundo for . De no hacerse ninguno, significa que el vector ya esta ordenado y el procedimiento termina.

#include <stdio.h>

void swap(int *, int *);
void bubbleSort(int[], int);
void printVector(int[], int);

int main(int argc, const char *argv)
{
    int vector[] = {100, 1992, 0, 5, -1, 60, 70, 14, 15, 10};
    int n = sizeof(vector) / sizeof(vector[0]);

    bubbleSort(vector, n);
    printVector(vector, n);

    return 0;
}

void swap(int *a, int *b)
{
    int temp = *a;
    *a = *b;
    *b = temp;
}

void bubbleSort(int vector[], int n)
{
    int flag = 1;
    int i = 0;

    while (flag)
    {
        flag = 0;

        for (int j = 0; j < n - i - 1; j++)
        {
            if (vector[j] < vector[j + 1])
            {
                swap(&vector[j], &vector[j + 1]); 
                flag = 1;
            }   
        }

        i++;
        
        if (!flag) 
            printf("Numero de vueltas: %d\n", i);
    }
}

void printVector(int vector[], int n)
{
    for (int i = 0; i < n; i++)
        printf("%d ", vector[i]);

    printf("\n");
}

Entrada:

100 1992 0 5 -1 60 70 14 15 10

Salida:

Numero de vueltas: 5
1992 100 70 60 15 14 10 5 0 -1

por qu茅 no est谩 imprimiendo el 1992?

reto hecho para ordenar de mayor a menor solo se cambia el signo en el if que esta dentro del for

Reto.

Para ordenar de mayor a menor debemos cambiar la comparaci贸n que realizamos e intercambiar los argumentos del swap, de modo que ahora sean los elementos de menor valor los que se desplacen hacia la derecha.

Dejo el fragmento de c贸digo que use, donde agrege un argumento que indica la opci贸n de ordenamiento.

void bubbleSort(int vector_entrada[], int n, int OPCION)
{
	int i, j;

	for (i=0; i < n-1; i++) 
	{
		for (j=0; j < n-i-1; j++)
		{
			if ( OPCION == 0 && (vector_entrada[j] > vector_entrada[j+1]))
			{
				swap(&vector_entrada[j], &vector_entrada[j+1]);
				continue;
			}
			if (OPCION != 0 && (vector_entrada[j] < vector_entrada[j+1]))
			{
				swap(&vector_entrada[j+1], &vector_entrada[j]);
			}
		}
	}
}

Buenas!
Yo lo hice en JS profe jaja, aqu铆 esta el c贸digo, si existe alguna forma de hacerlo mas eficiente pongan me su c贸digo en una respuesta ya que estoy buscando la manera de mejorar mi time y space complexity

let arr = [5, 2, 4, 2, 7]
const bubleshort = arr => {
    let temp = 0
    let changes = false
    for (let i = 0; i <= arr.length; i++) {
        if (i === arr.length) { // Revisamos si i es igual al tama帽o del array entonces ya termino de hacer el recorrido
            (changes) ? //si changes es verdadero quiere decir que se hizo alg煤n movimiento en el recorriendo pasado
                (changes = false, i = 0) // volvemos a asignarle 0 a i para que vuelva e empezar el recorrido y cambiamos changes a false
                : console.log(arr)
        }
        if (i === 0) {
            temp = arr[i] //Si es el primer item del array, asignalo a temp para poder comprarlo contra el siguiente            
        }
        else {
            (temp > arr[i]) ?
                (arr[i - 1] = arr[i], arr[i] = temp, temp = arr[i - 1], changes = true)
                : temp = arr[i]
        }

    }
}

bubleshort([9, 9, 1, 7, 2])

Y para el reto solo se debe cambiar (temp > arr[i]) ? por (temp < arr[i]) ? y eliminar temp = arr[i - 1] por lo tanto quedar铆a as铆.

let arr = [5, 2, 4, 2, 7]
const bubleshort = arr => {
    let temp = 0
    let changes = false
    for (let i = 0; i <= arr.length; i++) {
        if (i === arr.length) { // Revisamos si i es igual al tama帽o del array entonces ya termino de hacer el recorrido
            (changes) ? //si changes es verdadero quiere decir que se hizo algun movimiento en el recorriendo pasado
                (changes = false, i = 0) // volvemos a asignarle 0 a i para que vuelva e empezar el recorrido y cambiamos changes a false
                : console.log(arr)
        }
        if (i === 0) {
            temp = arr[i] //Si es el primer item del array, asignarle a temp para poder comprarlo contra el siguiente            
        }
        else {
            (temp < arr[i]) ?
                (arr[i - 1] = arr[i], arr[i] = temp, changes = true)
                : temp = arr[i]
        }

    }
}

bubleshort([9, 9, 1, 7, 2])

Respuesta al reto, solo se cambia de > ha < para que imprima los numero de mayor a menor.


#include<stdio.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]);

        }
    }
}
int print_array(int vector_entrada[], int n)
{
    int i;
    for(i=0; i<n-1; i++)
        printf("%d,", vector_entrada[i]);
    printf("\n fin del ordenamiento");
}
int main(int argc, 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);
    printf("\n");
    return 0;
}

Yo lo hice de esta manera con Python. Y en el caso para ordenarlos para mayor a menor s贸lo se trata de cambiar el > por un < y queda listo. Aunque yo prefer铆 hacerlo con recursividad ya que as铆 fue m谩s entendible para m铆, 驴es correcto hacerlo de esta manera o tiene alguna deficiencia de esta manera?

def bubblesort(numbers):
    counter = 0
    n = len(numbers)
    for idx in range(n):
        if idx == n-1:
            break
        if numbers[idx] > numbers[idx + 1]:
            counter += 1
            temp = numbers[idx]
            numbers[idx] = numbers[idx + 1]
            numbers[idx + 1] = temp

    if counter > 0:
        bubblesort(numbers)
    
    return numbers


if __name__ == "__main__":
    numbers = [1, 3, 47, 2, 12, 58, 7, 10, 25, 37, 45, 193, 28, 478, 128, 491239, -10]
    print('')
    print(numbers)
    ordered_numbers = bubblesort(numbers)
    print('')
    print(ordered_numbers)

me costo trabajo entenderlo me sal铆an muchos errores pero lo logre

C贸digo para el reto en Java:

public class BubbleSort
{
	public static void main(String[] args)
	{
		BubbleSort bs = new BubbleSort();
		int arreglo [] = {6, 8, 1, 4, 7, -5, 0, 50, 42, 100};
		bs.BubbleSort(arreglo);
	}
	
	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;
				}
		
		for (int i=0; i<arreglo.length; i++)
			System.out.print(arreglo[i] + " ");
	}
}

Yo hice el reto en python, comopara no solo cambiar el < por >:

Mi implementaci贸n en Java Script:

function bubbleSort(data, orderBy){
    let swapGlobal = false;
    let i = 0, j = 0;
    for(i = 0; i < data.length; i++){
        swapGlobal = false;
        for(j = 0; j < (data.length -1 - i); j++){
            let swap = false;
            if(orderBy == "asc" || orderBy == "ASC"){ //Ascendente - de menor a mayor.
                if(data[j] > data[j+1]){                    
                    swap = true;
                }
            }else if(orderBy == "desc" || orderBy == "DESC"){ //Descendente - de mayor a menor.
                if(data[j] < data[j+1]){
                    swap = true;
                }
            }
            if(swap){ //Si alg煤n elemento fu茅 mayor o menor al elemento de su derecha, hace el cambio.
                change(data,j,j+1);
                swapGlobal = true;
            }
        }
        if(!swapGlobal){ //Si no se realiz贸 alg煤n intercambio, significa que el vector est谩 completamente ordenado.
            return data;
        }        
    }
    return data;
}


function change(data,starPosition,finalPosition){
    var tempValue = data[finalPosition];
    data[finalPosition] = data[starPosition];
    data[starPosition] = tempValue;
}

let vector = [4,3,0,-1,100,55];
bubbleSort(vector,"asc");

Bubble Sort al ser uno de los algortimos mas facil, para poder invertir su funcionamiento solo debes invertir la condicion, que es la que nos indica como va ordenar los datos, en el ejemplo al poner,
->> si j es mayor a j+ 1
basicamente dices ordename de menor a mayor
//entonces si invertimos esto a:
->> si j es menor a j +1
estamos diciendo ordename de mayor a menor

#include<stdio.h>

void change_Pos(int *n1, int *n2)//funcion encargada del permutamiento de los valores recividos
{
	int temp = *n1;//ayuda a almacenar el dato termporalmente en lo que lo movemos.
	*n1 = *n2;
	*n2 = temp;
	//triangulacion para mover los datos
}
void bubbleSort(int vector_entrada[], int  n)//Encargada del Algoritmo de Ordenamiento
{
	// Aqui requerimo N[Total datos ordenar] y S[Los Datos a ordenar]
	for(int i=0 ; i < n-1; i++) //lee el tama帽o del array
	{
		for(int j=0; j < n-i-1; j++) 
		{
		 	if(vector_entrada[j] < vector_entrada[j+1] )
		 	{
		 		change_Pos(&vector_entrada[j], &vector_entrada[j+1]);
			}
		}
	}
}

int print_vector(int vector_entrada[], int n)
{
	for(int i = 0; i < n; i++ )
	{
		printf("[ %d ],  ",vector_entrada[i]);
	}
	printf("\n Ordenamiento Finalizado");
}

main(int argc, char const *argv[])
{
	int vector_entrada[] = {100,1997, 0 ,5 , -1, 62, 70 ,15 ,-5, 10};
	// sizeof() devuelve el tama帽o de bits de lo que le ingreses.
	int n = sizeof(vector_entrada) / sizeof(vector_entrada[0]); // Aqui basicamente obtenemos el tama帽o en bits y lo dividomos por una posicion X del array, segun las veces que se divida es el tama帽o de nuestro array
	bubbleSort(vector_entrada, n);
	print_vector(vector_entrada, n);
	printf("\n");
	
	return 0;
}```

para el desafi贸 solo cambias en la funci贸n bubbleSort el sentido de > a < y listo los organiza en orden descendente.

Por cierto si no quieren que les salga el warning de 鈥淣o se ha definido main鈥, solo definan a main como int

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

Soluci贸n al reto

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

Versi贸n JavaScript

const dataColection = [100, 1992, 14];
const n = dataColection.length;

const changePosition = (enterPoint, position1, position2) => {
    let temp = enterPoint[position1];
    enterPoint[position1] = enterPoint[position2];
    enterPoint[position2] = temp;
};

const bubbleSort = (enterPoint, n) =>{
    for(let i = 0; i < n-1; i++){
        for(let j = 0; j < n-i-1; j++){
            if(enterPoint[j] > enterPoint[j+1]){
                changePosition(enterPoint, j, j+1);
            };
        };
    };

const printData = (enterPoint, n) => {
    // console.log(enterPoint)
    for(let i=0; i<=n-1; i++){
        // console.log(enterPoint[i] + ", ");
    };
    console.log(enterPoint)
    console.log("Colection ordered");
};

bubbleSort(dataColection, n)
printData(dataColection, n)

Creo que cambiando el naming de las variables (y un poco el como se recorren los valores) se hace mas auto explicativo el c贸digo. Que les parece? igual si creen que otros nombres estar铆an mejor comenten.
Se entiende lo que hace el c贸digo?

#include <stdio.h>

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

void bubbleSort(int vector[], int n)
{
    int upperLimit, currentIndex;
    int lastIndex = n-1;
    for (upperLimit = lastIndex -1; upperLimit >= 1; upperLimit--)
    {
        for (currentIndex = 0; currentIndex < upperLimit; currentIndex++)
        {
            if (vector[currentIndex] > vector[currentIndex + 1])
                swapValues(&vector[currentIndex], &vector[currentIndex + 1]);
        }
    }
}

int print_array(int vector[], int n)
{
    int i;
    for (i = 0; i < n - 1; i++)
        printf("%d ", vector[i]);
}

main(int argc, char const *argv[])
{
    int vector[] = {100, 1992, 0, 5, -1, 60, 70, 14, 15, 10};
    int n = sizeof(vector) / sizeof(vector[0]);
    bubbleSort(vector, n);
    print_array(vector, n);
    printf("\n fin del ordenamiento");
    printf("\n");
    return 0;
}```

C en Python

Con Python y con su function sorted() que hace lo mismo que un BubbleSort

Despu茅s de realizar la implementaci贸n del profe, pens茅 en la definici贸n original, 鈥渃omparar los elementos adyacentes y hacer swaps hasta que no se puedan realizar m谩s鈥 entonces creo que el ciclo while aplicar铆a bastante bien ya que por ejemplo:

[1, 3, 2, 4, 5] nos hace 5 iteraciones cuando solo tenemos un swap y en la primer iteraci贸n (de las i) queda ordenado.

Reemplazando con un while quedaria resuelto en dos iteraciones:

void bubleSort(int arr[], int n)
{
    int i, j, swaps_in_iteration;
    swaps_in_iteration = 1;
    i = 0;
    while (swaps_in_iteration > 0)
    {
        printf("Cantidad de iteraciones: %d\n", i + 1);
        swaps_in_iteration = 0;
        // j va a ser el indice que
        // compara las posiciones adjacentes
        for (j = 0; j < n - i - 1; j++)
        {
            if (arr[j] > arr[j + 1])
            {
                changePosition(&arr[j], &arr[j + 1]);
                swaps_in_iteration++;
            }
        }
        printf("Cantidad de swaps: %d\n", swaps_in_iteration);
        i++;
    }

<code>

Comparto mi implementaci贸n en python

vector=[3,4,2,12,34,5,4,32,3,6,5,38,545,423,3434,232]
def bubble_sort(vector):
  n_iter=len(vector)-1
  changes=1
  while changes>0:
    changes=0
    for i in range(n_iter):
      if vector[i]>vector[i+1]:
        high=vector[i]
        low=vector[i+1]
        vector[i]=low
        vector[i+1]=high
        changes+=1
  return vector
print(bubble_sort(vector))
  • Otra alternativa mas legible para no crear 2 ciclos anidados, es crear una variable contador++, que la cantidad de posiciones correctas sea igual a la cantidad de elemetnos del array, quiere decir que en una secuancia si no hubo ningun ordenamiento, puede imprimir

  • Con un solo ciclo for es suficiente comparar las posiciones [0] y [0+1]

  • Tampoco es necesario sacar en una variable aparte la cantidad de elemetnos con metodos como length() o size(), nuestro for en la condicion quedaria asi i <vector.length-1; || i < vector.size()-1;

import java.util.ArrayList;
import java.util.List;

public class BubbleSortImpl {

	public void bubbleSort(String index){
		
		List<Double> toList = new ArrayList<>();
		String[] array;
		
		array = index.split(",");
		
		for(int i=0; i<array.length; i++) {
		toList.add(Double.valueOf(array[i]));
		}
		
			int count =0;
			do{
			
			for(int j=0; j < toList.size()-1; j++) {
	
				if(toList.get(j) > toList.get(j+1)) {
					double temp = toList.get(j);
					toList.set(j,toList.get(j+1));
					toList.set(j+1,temp);
					count= 0;
				}else {
					count++;
				}
			}
			}while(count <= toList.size());	
				
		toList.forEach(x -> System.out.println(x));	
	}

Main

import java.util.Scanner;

public class Main {
	
	public static void main(String[] args) {
		
		Scanner sc = new Scanner(System.in);
		BubbleSortImpl bsort = new BubbleSortImpl();
		
		System.out.println("Inserte numeros");
		String index = sc.next();
		bsort.bubbleSort(index);
	}

}

Algo que quiero aportar, que supongo que para algunos fue obvio pero no fue mencionado es que:
Imaginemos el caso de un byte, 8 bites, entonces s贸lo abarca valores desde 0 hasta 255 peero si abarca negativos s贸lo acoge desde -128 hasta 127

Por eso si vemos que aunque el ingreso el 1995, no fue podido ser acogido dentro del tipo de variable que defini贸 y no apareci贸 cu谩ndo ordeno.

Alguien corr铆jame por favor si me equivoco.

  • Solucion con operaciones Stream, metodos min() max() get() para hallar obtener en una variable el valor
    Menor o mayor
  • Despues de obtener el elemento menor o mayor ,lo agrego a una coleccion ,busco la posicion en la que estaba ubicado, con el metodo indexOf() , y para borrarlo con el metodo remove() mando como parametro el indice obtenido con el metodo indexOf() todo esto dentro de un ciclo hasta que la coleccion quede sin elementos.

BubbleSort Impl

import java.util.ArrayList;
import java.util.List;

public class BubbleSortImpl {

	List<Double> toList = new ArrayList<>();
	List<Double> result = new ArrayList<>();
	String[] array;
	
	public void bubbleSort(String index) {
		
		array = index.split(",");
		
		for(int i=0; i<array.length; i++) {
		toList.add(Double.valueOf(array[i]));
		}
		
		while(!toList.isEmpty()) {
			
		double min = toList.stream()
                       //.min((x,y)-> x.compareTo(y))  -> Para obtener el menor
						   .max((x,y)-> x.compareTo(y))// Para obtener el mayor
						   .get();
		result.add(min);
		int indice = toList.indexOf(min);
		toList.remove(indice);
	}
		
		result.forEach(System.out::println);
}
}

Main

import java.util.Scanner;

public class Main {
	
	public static void main(String[] args) {
		
		Scanner sc = new Scanner(System.in);
		BubleSortImpl bsort = new BubleSortImpl();
		
		System.out.println("Inserte numeros");
		String index = sc.next();
		bsort.bubbleSort(index);
	}

}

Reto: Ordenar de Mayor a menor
La rutina bubbleSort quedar铆a

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

De mayor a menor con solo 2 cambios:

1.- En funci贸n bubble sort se cambia en el if la comparaci贸n pasa de > a <

2.- En la funci贸n de impresi贸n, en el for i < n-1 se cambia a i<=n-1

voala

Ac谩 tengo la versi贸n en Python:

def bubble(list_a):
    indexing_length = len(list_a) - 1 
    sorted = False 

    while not sorted:  
        sorted = True  
	for i in range(0, indexing_length): 
            if list_a[i] > list_a[i+1]: 
                sorted = False 
                list_a[i], list_a[i+1] = list_a[i+1], list_a[i] 
    return list_a 


print(bubble([100, 85, 33, 49, -1, 10, 0, 24]))

Python con el reto incluido:

def bubble(list_a):
    indexing_length = len(list_a) - 1 

    sorted = False 

    while not sorted:  
        sorted = True  

        for i in range(0, indexing_length): 
            if list_a[i] < list_a[i+1]: 
                sorted = False 
                list_a[i], list_a[i+1] = list_a[i+1], list_a[i] 
    return list_a 

print(bubble([100, 85, 33, 49, -1, 10, 0, 24]))

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++)
{
// [10, 5, 3, 333]
if(vector_entrada[j]<vector_entrada[j+1]) /// Si solo cambiar la expresi贸n.
cambiar_pos(&vector_entrada[j],&vector_entrada[j+1]);

    }

}

}

El codigo tiene un peque帽o bug en las declaraciones: en el codigo ejemplo el vector de entrada se define en dos partes igual, primero en la funcion

void bubbleSort(int vector_entrada[], int n)

y luego en el main en

main(int argc, char const *argv[])
{
    int vector_entrada[]={100, 1992, 0, 5, -1, 60, 70, 14, 15, 10};

como resultado el codigo funciona pues en la funcion bubbleSort internamente la asignacion de valor se hace hacia el mismo vector, pero si se modifica la funcion bubbleSort para otro vector la asignacion no tiene lugar,

void bubbleSort(int any_vector_entrada[], int n)

por consiguiente esta funcion no sive para cualquier vector. Una solucion es simplemente declarar la variable global entre otras mejoras que le har铆a al codigo. Aqui les dejo mi version:

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

int input_vector[]={1,10,8,3,5,2,6,7,4,3,9};//vector de entrada para ordenar
int size_vector;//stores the size of the vector
char flag_ordenar=1;


void print_vector(int vector_imp[]){
    int i;
   // int size_vector_aux=sizeof vector_imp / sizeof *vector_imp;
    printf("{ ");
    for(i=0; i<size_vector; i++)
    {
    printf("%d ",vector_imp[i]);
    }
    printf("}\n");
}

void change_pos(int *n1, int *n2){//pointer declaration to the address of the vector to sort out
    int temp = *n1;//saves temporarily one of the variables
    *n1=*n2;
    *n2=temp;
    flag_ordenar=1; //indicates that this code has been at least executed once
}



void buble_sort(){
int i;
while(flag_ordenar==1){
    flag_ordenar=0;//reset the flag
    for (i=0;i<size_vector-1;i++){//the last position is checked before in pairs
        if(input_vector[i]>input_vector[i+1]){
            change_pos(&input_vector[i],&input_vector[i+1]);//change position
            //input_vector[i]=vector_imp[i];
        }
    }
}
//input_vector[size_vector-1]=input_vector[size_vector-1];

}


int main()
{
    size_vector=sizeof input_vector / sizeof *input_vector;
    printf("Initial Vector\n");
    print_vector(input_vector);
    buble_sort(input_vector);
    printf("Organized Vector\n");
    print_vector(input_vector);
    printf("Vector size is %d\n", size_vector);
    return 0;
}

Listo el codigo con el ordenamiento de mayor a menor

#include <stdio.h>


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

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

void print(int vectorEntrada[], int n)
{
    int i;
    for(i = 0; i < n; i++)
    {
        printf("%d, ", vectorEntrada[i]);
    }
    printf("\nFin del ordenamiento\n");
}

int main(int argc, char const *argv[])
{
    int vectorEntrada[]={100, 1992, 0, 5, -1, 60, 70, 14, 15};
    int n = sizeof(vectorEntrada) / sizeof(vectorEntrada[0]);
    bubbleSort(vectorEntrada, n);
    print(vectorEntrada, n);
    printf("\n");

    return 0;
}```

Mi c贸digo menor a mayor en Python 3.7:

"""
Lista de Pasos de nuestro Algoritmo Bubble-Sort:
鈥	Crear un array de determinado tama帽o indicado por el usuario.
鈥	Llenar el array con los respectivos elementos dados por el usuario.
鈥	Comparar de dos en dos los elementos del array, empezando desde el 铆ndice cero hasta el 铆ndice final.
鈥	Comparar y preguntar cual es mas grande entre el primero y segundo elemento, si el segundo es mayor se deja igual en las mismas posiciones, 
    pero si el primero es mayor se cambian las posiciones entre los dos elementos, esto se repite hasta recorrer todos los elementos del array.
鈥	Detener el ciclo cuando en un iteraci贸n del ciclo no existan cambios, por lo tanto podemos romper el ciclo para terminar las iteraciones.
鈥	Mostrar al usuario el array ordenado.
"""
import copy

flag = True    #Bandera para indicar si ya quedo ordenada la lista

def order_List(lista1,n):    #Funcion para ordenar el Array o Lista    
    lista2 = copy.copy(lista1)
    while True:     #Loop infinito
        flag = True        
        for i,v in enumerate(lista1):   #La i representa el indice y la v respresenta el valor de ese indice
            if(i < n -1):  #Si no ha llegado al indice final
                if(lista2[i] > lista2[i+1]):     #Valida si el primer valor es mayor que el segundo valor
                    flag = False
                    elemento = lista2[i]
                    lista2[i] = lista2[i+1]
                    lista2[i+1] = elemento                    
        if(flag):
            break
    return lista2

def get_List(n = 0):  #Funci贸n para crear el Array o Lista
    lista1 = []
    for i in range(n):
        elemento = int(input("Ingrese el entero en el indice {}:".format(i)))
        lista1.append(elemento)
    return lista1

    
size_list = int(input("Ingrese el tama帽o del Array:"))
lista = get_List(size_list)
lista_ordenada = order_List(lista,size_list)
print("Array original: {}".format(lista))
print("Array ordenada: {}".format(lista_ordenada))```

Para todos los que se preguntan para que sirve el

for(j=0;j<n-i-1;j++)

lo que hace es que:

  • en la primera iteraci贸n recorre todo el array
  • en la segunda iteraci贸n recorre todo el array menos el 煤ltimo elemento
  • en la tercera iteraci贸n recorre todo el array menos los dos 煤ltimos elementos
    y as铆 sucesivamente hasta que llegue a recorrer ning煤n elemento

esto es porque en el bubble sort te asegura que en la primera iteraci贸n el n煤mero m谩s grande est茅 al final del array y es por esto que ya no es necesario compararlo, de esta manera hacemos el algoritmo m谩s eficiente


Cumpliendo el reto 馃槂

#include<stdio.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]);
        }
    }
}

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");
}

main(int argc, 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);
    printf("\n");
    return 0;   
}

En Python:

# Bubble Sort algorithm in Python
# From highest to lowest

def bubble_sort(list, n):
    for i in range(n-1):
        for j in range(0, n-i-1):
            if list[j] < list[j+1]:
                list[j], list[j+1] = list[j+1], list[j]
                print(f"Round {i}: {list}")
    
def run():
    list = [60, 30, 20, 10, 50, 1, 90] 
    n = len(list)
    bubble_sort(list, n)
    print(list)

if __name__ == "__main__":
    run()```

Reto completado

#include<stdio.h>
void cambiar_pos(int *n1, int *n2){
    int temp = *n1;
    *n1 = *n2;
    *n2 = temp;
}
void bubbleSort(int array[], int n){
    int i;
    int j;
    for(i = 0; i < n-1; i++){
        for(j = 0; j < n-i-1; j++){
            if(array[j]>array[j+1]){
                cambiar_pos(&array[j], &array[j+1]);
            }
        }
    }
}
int printe(int array[], int n){
    int i;
    for (i = 0; i < n; i++)
        printf("%d ,", array[i]);
    printf("\n Fin del ordenamiento Acsendente \n");
}
int printa(int array[], int n){
    int i;
    for (i = 4; i >= 0; i--)
        printf("%d ,", array[i]);
    printf("\n Fin orden Descendente");
}
main(int argc, char const *argv[])
{
    int array[]= {1, 2 ,3 ,4 ,5};
    int n = sizeof(array)/sizeof(array[0]);
    bubbleSort(array, n);
    printe(array, n);
    printa(array, n);
    printf("\n");
    return 0;
}```

Comparto codigo en Python

import random


def change_pocision(n1, n2):
    return n2, n1


def bubble_sort(array, n, asc=True):
    if asc:
        for i in range(n):
            for j in range(n-i-1):
                if array[j] > array[j+1]:
                    array[j], array[j+1] = change_pocision(array[j], array[j+1])
        return array
    elif not asc:
        for i in range(n):
            for j in range(n-i-1):
                if array[j] < array[j+1]:
                    array[j], array[j+1] = change_pocision(array[j], array[j+1])
        return array
    else:
        print('Error with parameter asc')


def main():
    array = [random.randint(-1000, 1000) for i in range(100)]
    n = len(array)
    bubble_sort(array, n)
    print(array)

    bubble_sort(array, n, asc=False)
    print(array)


if __name__ == "__main__":
    main()
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]);
        }
    }
}```

Cambiando
print_array

int print_array(int vector_entrada[], int n){
    int i;
    for(i=n-1; i>-1; i--)
        printf("%d  ,", vector_entrada[i]);
    printf("\n fin del ordenamiento");

}```

Listo hice el cambio para ordenar de mayor a menor.

/* 1.- Comenzamos a hacer la comparaci脙模n de elementos adyacentes
2.- repetimos hasta tener una pasada completa sin ning脙拧n swap
 */
#include<stdio.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++)
        {
            //[10, 5, 3, 3333]
            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");
}

int main(int argc, 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);
    printf("\n");
    return 0;
}

Para ordenar el array al rev茅s, simplemente debemos cambiar la comparacion entre los elementos del vector de entrada, en lugar de colocar un mayor, debemos colocar un menor:

if(vector_entrada[j] > vector_entrada[j + 1]) #lo cambiamos por 
if(vector_entrada[j] < vector_entrada[j + 1])

Les dejo mi c贸digo completo:

#include <stdio.h>

void cambiarPos(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]){
				cambiarPos(&vector_entrada[j], &vector_entrada[j + 1]);
			}
		}
	}
}

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

main(int argc, 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);
	printf("\n");
	return 0;
}

Para los que est谩n enfocando este curso a python. Encontr茅 esta p谩gina que explica el bubble sort https://runestone.academy/runestone/books/published/pythonds/SortSearch/TheBubbleSort.html
El c贸digo que plantean es

def bubbleSort(alist):
# Lo que le estamos diciendo ac谩 es que por cada elemento
# en el rango que sea en el largo de la lista menos uno,
# hasta cero y que vaya retrocediendo
  for passnum in range(len(alist)-1,0,-1):
    for i in range(passnum):
      if alist[i]<alist[i+1]:
        temp = alist[i]
        alist[i] =alist[i+1]
        alist[i+1] = temp

alist = [6719,9135013,9842396,189266924,6248623,8968496,912869412681216,196814691,18690814]
bubbleSort(alist)
print(alist)```

Pregunta: Alguien sabe donde esta el error.
Lo he revisado 5 veces y lo compare con el c贸digo del profesor que esta en archivos y enlaces y esta tal cual.
Resulta que no me imprime los diez n煤meros, solo el 煤ltimo.

Para que ordene los n煤meros de mayor a menor solo basta con cambiar el > por un < en el condicional dentro de los for asi:

if (vector_entrada[j] < vector_entrada[j + 1])

Me percat茅 que en el ejercicio, la salida no nos arroja el 煤ltimo valor en el 煤ltimo 铆ndice del array que en este caso es 1992
y quitando el -1 en 鈥減rint_array鈥 ya muestra el todos los valores-

#include <stdio.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]);
    }
  }
}

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");
}

main(int argc, 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);
  printf("\n");
  return 0;
}```

Para resolver el reto, cambi茅 esta l铆nea:

if(vector_entrada[j]>vector_entrada[j+1])

Por esta otra:

if(vector_entrada[j]<vector_entrada[j+1])

Algo que not茅, es que ya sea que el algoritmo ordene de forma ascendente o descendente siempre falta un n煤mero.

Al modificar la l铆nea:

for(i = 0; i < n - 1; i++)

Por esta otra:

for(i = 0; i < n; i++)

Lo que entiendo que pasa es que el n煤mero de elementos en el array, al restarle 1 el ciclo solo recorre 9 posiciones.

驴Qu茅 opinan? Saludos!

Implemente el ordenamiento de Mayor a Menor y viceversa en un mismo codigo con unicamente otra funcion:

void bubbleSortMin(int vector_entrada[], int n) //Mayor a menor
{
  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 bubbleSortMay(int vector_entrada[], int n) //Menor a mayor
{
  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]);
      }
    }
  }
}

mi soluci贸n:

#include "stdio.h"
#include "stdbool.h"

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

void bubble_sort(int vector_entrada[], int n, bool acc){
    int i,j;
    for(int i=0; i< n-1; i++){
        for(int j=0; j<n-i-1; j++){
            if(acc){
                if (vector_entrada[j]>vector_entrada[j+1]) {
                cambio_numero(&vector_entrada[j],&vector_entrada[j+1]);
                }
            }else{
                if (!vector_entrada[j]<vector_entrada[j+1]) {
                cambio_numero(&vector_entrada[j],&vector_entrada[j+1]);
                
                }
            }
            
        }
    }
}

int print_arr(int vector_entrada[], int n){
    for(int i=0; i<n-1; i++){
        printf("%d, ", vector_entrada[i]);
    }
    printf("\n");
}

int main(int argc, 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]);

    bubble_sort(vector_entrada,n, true);
    print_arr(vector_entrada,n);
    bubble_sort(vector_entrada,n, false);
    print_arr(vector_entrada,n);

    return 0;
}```

Algunas correcciones del codigo inicial, puesto que en el video solo deja ver 9 resultados. Y solucion al reto

#include <stdio.h>

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

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

int print_result(int secuencia[], int n)
{
  int i;
  for(i = 0; i < n; i++)
  {
      printf("%i, ", secuencia[i]);
  }
  printf(".\nFin del ordenamiento bubble.");

}

int main(int argc, char const *argv[])
{
    int secuencia[] = {100, 1992, 5, 0, -1, 60,70,
    14, 15, 10, -65, -7- 67, 23, -1345};
    int n = sizeof(secuencia)/sizeof(secuencia[0]);
    bubbleSort(secuencia, n);
    print_result(secuencia, n);

    return 0;
}```

Les comparto mi soluci贸n en python

<code>
#Comenzamos a hacer la comparacion de elementos adyacentes
#Repetimos hasta tener una pasada completa sin ningun swap

def bubble_sort(array):

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

array = [1,3,5,1,4,3,0,10]
print(array)
bubble_sort(array)
print(array)

Reto:

Inclui la funcion:

scanf ("%d", &Opcion);

Para que el usuario escoja la opcion de ordenar Descendente o Ascendente

Aqui les dejo mis apuntes de la clase en conjunto con el desafio

/*Pasos
1. Comparacion de elementos adyacentes
2. Repetir hasta tener una pasada completa sin ningun swap*/

#include <stdio.h> //Libreria para poder imprimir el resultado final

/*Primera Funcion: Se encarga de cambiar de posicion los numeros menores 
que estan despues de un numeros mayor, es una funcion de tipo void porque no retorna ningun valor*/
void cambiar_pos(int *n1, int *n2) 
{
	int temp =*n1;//Variable temporal que almacena un dato mientras hacemos el cambio
	*n1 = *n2;
	*n2 = temp;
}


//Segunda Funcion: Recorre el array y hace las comparaciones
void bubbleSort(int vector_entrada[], int n)
{
	int i, j, Opcion; 
	printf("Digite la opcion que desea ejecutar: \n 1.Descendente \n 2.Ascendente \n");
	scanf ("%d", &Opcion); //Funcion que nos permite pedir datos al usuario
	if(Opcion==1) //Descendente
	{	
		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]);
			}
		}
	}
	if(Opcion==2) //Ascendente
	{
		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]);
			}
		}
	}
	if(Opcion != 1 && Opcion != 2)
	{
		printf("No es un opcion valida, el array no ha cambiado \n");
	}

}
//Tercera Funcion: Imprimir el resultado del array ordenado, es una funcion de tipo int

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");
}

int main(int argc, 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]);  //sizeof es una funcion que da el tamano de bites de lo que necesitemos
	bubbleSort(vector_entrada, n);
	print_array(vector_entrada, n);
	printf("\n");
	return 0;
}

La funcion print_arrar no esta mostrando todos los elementos del array, aqui les comparto el codigo para corregirlo

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");
}

Reto finalizado!

#include <stdio.h>

void cambiar_pos(int *n1, int *n2)
{
	int temp = *n1;		// Almacena el numero mayor de la comparaci贸n 
	*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++)
		{
			//[10, 5, 3, 3333]
			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");
}

main(int argc, char const *argv[])
{
	int vector_entrada[]={100,1992,0,5,-1,60,15,39};
	int n = sizeof(vector_entrada)/sizeof(vector_entrada[0]);
	bubbleSort(vector_entrada,n);
	print_array(vector_entrada,n);
	printf("\n");
	return 0;
}```

Reto resuelto

void bubbleSort(int vectorEntrada[], int n){

    int i,j;
    for(i=0; i<n-1; i++){
       // [10,5,3,33]
        for(j=0; j < n-i-1; j++){
            if(vectorEntrada[j]<vectorEntrada[j+1]){ //Solo cambie ">" por "<" para que ordenara 	 
                                                                           //los nuemeros de mayor a menor 
                cambiarPos(&vectorEntrada[j], &vectorEntrada[j+1]);
            }
        }
    }
}

Comparto una versi贸n en Java. Tiene una peque帽a mejora que ayuda a evitar iterar cuando el arreglo ya se encuentra ordenado.

public class BubbleSort {
	
	public void bubbleSort(int[] arr, int n) {
		
		//n-1 evita evaluar el ultimo elemento, que por definici贸n es el mayor
		for(int i = 0; i < n-1 ; i++) {
			
			//-i evita evaluar los elementos ya ordenados, pues est谩n a la derecha
			boolean swapped = false;
			for(int j = 0; j < n-1-i ; j++) {
				
				if(arr[j] < arr[j+1]) {
					int temp = arr[j];
					arr[j] = arr[j+1];
					arr[j+1] = temp;
					swapped = true;
				}
				
				printArray(arr, n);
			}	
			//Si no se cambian elementos, ya se encuentra ordenado y se sale del ciclo
			if(!swapped) 
				break;
		}
		
	}
	
	public static void printArray(int[] arr, int n) {
		StringBuilder sb = new StringBuilder();
		for(int i=0; i < n ; i++) {
			sb.append(arr[i]);
			sb.append(",");
		}
		
		System.out.println(sb.toString());
		
	}
	
	public static void main(String[] args) {
		//int[] arr = {568,23,-55,6,5,-22,4,8,144,0};
		//int[] arr = {144,44,0,-55};
		int[] arr = {-55,0,44,144};
		int arrSize = arr.length;
		
		System.out.println("El arreglo es:");
		printArray(arr, arrSize);
		
		System.out.println("\nInicia Bubble Sort");
		BubbleSort sorter = new BubbleSort();
		sorter.bubbleSort(arr, arrSize);
		
		System.out.println("\nEl arreglo ordenado es:");
		printArray(arr, arrSize);
	}
	
}

Reto cumplido:

//Algoritmo de bubbleSort

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

void swap(int *x, int *y){
    int aux = *x;
    *x = *y;
    *y = aux;
}

void bubbleSort(int v[], int n){
    int i, j;
    int hasChanged = 1;
    for(i = 0; i < n-1 && hasChanged == 1; i++){
        hasChanged = 0;
        for(j = 0; j < n-i-1; j++){
            if(v[j]<v[j+1]){
                swap(&v[j], &v[j+1]);
                hasChanged = 1;
            }
        }
    }
}

void printArray(int v[], int n){
    int i = 0;
    for(i = 0; i < n; i++){
        printf("%i ",v[i]);
    }
}

int main(int argc, char const *argv[]){
    int n, i;
    printf("Ingresa el tama帽o del vector: ");
    scanf("%d", &n);
    int v[n];
    
    srand(time(NULL));
    for(i = 0; i < n; i++){
        v[i] = (rand()%100)+1;
    }

    bubbleSort(v, n);
    printArray(v, n);
    
    return 0;
}

Para el ordenamiento de menor a mayor, solo hay que cambiar el 鈥>鈥 por el 鈥<鈥 en la comparaci贸n y listo.

Tengo la soluci贸n del reto pero tambi茅n una pregunta, por si alguno me puede ayudar!

La pregunta es, por qu茅 no puedo en vez de tener que enviarle la variable n a la funci贸n bubbleSort o a la funci贸n print simplemente dentro de ellos realizar la misma operaci贸n que hicimos en el main? A esta operaci贸n me refiero:

int sizeOf = sizeof(intArray) / sizeof(intArray[0]);

Gracias para el que me pueda responder.

La soluci贸n del reto es simple compa帽eros!

Lo 煤nico que hay que hacer es cambiar esta secci贸n del c贸digo dentro de la funci贸n bubbleSort:

if (S[j] > S[j+1])

por esto:

if (S[j] < S[j+1])

De esta forma se ordenar谩 en el sentido inverso, ya que los mayores ser谩n corridos hacia la izquierda en vez de la derecha, saludos a todos!

Reto cumplido!, solamente intercambie el signo de comparaci贸n adentro del condicional del bubble Sort, a seguirle dando compa帽eros

// 1.- Comenzamos a hacer la comparaci贸n de elementos adyacentes
//2.- Repetimos hasta tener un pasada completa sin ning煤n swap

#include <stdio.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 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");
}

void main(){
	
	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);
	printf("\n");
}```

Reto ordenamiento

<#include<stdio.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]);
        }

    }
}

int print(int vector_entrada[],int n)
{
    int i;
    for(i=0; i<n-1; i++)
    printf("%d ,",vector_entrada[i]);
    printf("\n fin de el  ordenamiento");

}


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

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


    return 0;
}
>

Adjunto c贸digo del reto:

#include <stdio.h>


void intercambio(int *dato1, int *dato2)
{
    int temp = *dato1;
    *dato1 = *dato2;
    *dato2 = temp;
}

void bubbleSort(int arreglo[], int e)
{
   int i, j;
   for(i=0; i < e-1; i++)
   {
      for(j=0; j < e-i-1; j++)
      {
         if(arreglo[j] < arreglo[j+1])
            intercambio(&arreglo[j], &arreglo[j+1]);
      }
   }
   printf("\nArreglo ordenado: \n");
}

void imprimirArreglo(int arreglo[], int e)
{
   int i;
   for(i=0; i<e; i++)
      printf("%d  ,", arreglo[i]);
}

void main()
{
    int arreglo[] = {3, 27, 42, 1, 0, 34, 12, 90, 33, 44};
    int elementos = sizeof(arreglo)/sizeof(arreglo[0]);
    imprimirArreglo(arreglo, elementos);
    bubbleSort(arreglo, elementos);
    imprimirArreglo(arreglo, elementos);
    printf("\nFin del ordenamiento");
}

隆Hola!
Observ茅 que s贸lo se imprimen 9 n煤meros en ves de los 10 n煤meros, a mi parecer, solo es porque al momento de imprimir el arreglo ya ordenado, no se recorren todos los elementos.

Hola, muy interesante este m茅todo de ordenamiento, a partir de este lo intente programar en java y me funciono perfectamente, aunque tuve que hacer unos cambios. Gracias, buen curso.

public class OrdBurbuja {

public void orBurbuja(int array[]) {
    int aux;
    for (int i = 0; i < array.length - 1; i++) {
        for (int j = 0; j < array.length - 1; j++) {
            if (array[j] > array[j + 1]) {
                aux = array[j + 1]; // Se intercambian los elementos
                array[j + 1] = array[j]; // de las posiciones j y j+1
                array[j] = aux;
                //cambiarDato(array[j], array[j + 1]);
            }
        }
    }
}

public String imprimir(int array[]) {
    orBurbuja(array);
    String dato = " ";
    for (int i = 0; i <= array.length - 1; i++) {
        dato = dato + array[i] + ", ";
    }
    return dato;
}

public static void main(String[] args) {
int array[] = {40, 21, 4, 9, 10, 35};
OrdBurbuja obj1 = new OrdBurbuja();
obj1.imprimir(array);
System.out.println("El arreglo ordenado es: " + obj1.imprimir(array));
}
}

SALIDA

run:
El arreglo ordenado es: 4, 9, 10, 21, 35, 40,
BUILD SUCCESSFUL (total time: 0 seconds)

Listo

#include <stdio.h>

void cambiar_posicion(int *n1, int *n2) {

      int aux;

      // La variable auxiliar coge el valor de n1 para conservar el valor
      aux = *n2;
      // El valor de n1 se reemplaza con el de n2
      *n2 = *n1;
      // El valor de n2 se reemplaza con el de n1, que estaba guardado en la variable auxiliar
      *n1 = aux;

}

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]) {

                // Si el valor j del array es menor que el siguiente, hace el cambio de posicion entre el valor j del array y lo reemplaza con el siguiente, lo mismo con el valor del array j + 1
                cambiar_posicion(&vector_entrada[j], &vector_entrada[j+1]);

             }

          }// fin for j

      } //fin for i

}

int printArray(int vector_entrada[], int n) {

    int i;

    for (i = 0; i < n-1; i++) {

        printf("%d, ", vector_entrada[i]);

    }

    printf("\nFin del ordenamiento.");

}

void main() {

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

    bubbleSort(vector_entrada, n);
    printArray(vector_entrada, n);
    printf("\n");

    return 0;

}

Para ordenar de mayor a menor, en la funi贸n 鈥渋f鈥, lo 煤nico que hay que cambiar es el s铆mbolo 鈥>鈥 por 鈥<鈥.

A leer muuuucho.

Para resolver el reto 煤nicamente debemos modificar el condicional que determina la ejecuci贸n del m茅todo de ordenamiento. A continuaci贸n tienen el m茅todo modificado que acciona el ordenamiento de mayor a menor.

No se modifica ninguno de los otros dos m茅todos.

Un saludo.

public static void bubbbleSort(int[] arrayEntrada, int n) {
		int i, j;
		
		for(i=0; i <n-1; i++) {
			
			for(j=0; j<n-i-1; j++) {
			
				if(arrayEntrada[j] < arrayEntrada[j+1]) {
					cambiarPosicion(arrayEntrada[j], arrayEntrada[j+1]);
					arrayEntrada[j]=rdo[0];
					arrayEntrada [j+1]=rdo[1];
				}
			}
		}
		
	}
	

Adjunto el c贸digo en Dart por si alguien tiene curiosidad de como seria el algoritmo en este lenguaje

P.D: Tambi茅n a帽ad铆 comentarios para intentar explicar un poco como funciona y como resolver el reto

void main(){
 var buble = BurbujaDireccional();

  List arrayNumeros = [15, 20, 3, 10, -5, 8, 40];
  buble.bubbleSort(arrayNumeros);

}

class BurbujaDireccional {

  void bubbleSort(List list){

    int n = list.length;
    int i, step;

    // Metodo Burbuja
    // El primer for son las vueltas que daremos.
    for(step = 0; step < n ; step++){
      // El segundo es para odenar este arreglo
      // Prueba a cambiar el < por > y veras como se desordena
      for(i = 0; i < n - step - 1; i++){
        // Condicional si numeroActual > numeroSiguiente.
        // Para invertir el orden solo es necesario cambiar el > por <
        if(list[i] > list[i + 1]){
          swap(list,i);
        }
      }
    }
    // Mostrando el arreglo ordenado en forma creciente
    print("\n Arreglo ordenado de forma creciente: ");
    for(i = 0; i < step ; i++){
      print("${list[i]}");
    }

  }

  void swap(List list, int i){
    int temp = list[i];
    list[i] = list[i+1];
    list[i+1] = temp;
  }

}

`#include<stdio.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]);
        }
    }
}

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

main(int argc, char const *argv[])
{
    int vector_entrada[]={100,1992,0,5,-1,60,70,14,15};
    int n = sizeof(vector_entrada)/sizeof(vector_entrada[0]);
    bubbleSort(vector_entrada, n);
    print_array(vector_entrada, n);
    printf("\n");
    return 0;
}


Bubble sort ascendente en Python

#! /usr/bin/python


def bubble_sort(lista):
    for i, value in enumerate(lista):
        try:
            lista[i + 1]
            if lista[i] <= lista[i+1]:
                continue
            lista[i], lista[i+1] = lista[i+1], lista[i]
        except:
            pass
    return lista


def check_order(lista):
    print('check order')
    check_list = []
    for i, value in enumerate(lista):
        try:
            lista[i + 1]
            if lista[i] <= lista[i+1]:
                check_list.append(True)
            else:
                check_list.append(False)
        except:
            pass
    return check_list

if __name__ == '__main__':
    lista = [100, 1992, 0, 5, -1, 60, 70, 14, 15, 10]
    check_list = [False]
    print('inicial', lista)
    while not all(check_list):
        lista = bubble_sort(lista)
        check_list = check_order(lista)
        print('ordenado', lista)

Es s贸lo cambiar una linea de c贸digo
if(vector_entrada[j] > vector_entrada[j+1])
por la siguiente
if(vector_entrada[j] < vector_entrada[j+1])
Cambiando el signo de mayor que.

Tambi茅n funciona colocando la siguiente
if(vector_entrada[j] < vector_entrada[j+1])
es intercambiar j por j+1.

El algoritmo del profesor Ricardo tiene un error en la linea 30
for(i=0; i<n-1; i++)
toca cambiar por la siguiente
for (i = 0; i < n; i++)
para que recorra todo el vector a la hora de imprimir de lo contrario no imprime el 煤ltimo valor.
for(i=1; i<n-1; i++).

Reto completado:

#include <stdio.h>

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

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

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

int main(int argc, char const *argv[])
{
    int array[] = {100,1992,0,5,-1,60,70,14,15,10};
    int n = sizeof(array)/sizeof(array[0]);
    bubblesort(array,n);
    print_array(array,n);
    printf("\n");
    return 0;
}
#include <stdio.h>

void cambiar_pos( int *n1, int *n2 ) {

  int temp = *n1;
  *n1 = *n2;
  *n2 = temp;
}

void bubbleSort( int vector_entrada[], int n) {
  for ( int i = 0; i < n-1; i++) {
      for ( int j = 0; j < n-i-1; j++ ) {
      if ( vector_entrada[j] < vector_entrada[ j + 1 ] ) {
        printf("antes vector_entrada[%d]:%d y vector_entrada[%d]:%d\n",j,vector_entrada[j],j+1,vector_entrada[j+1]);
        cambiar_pos( &vector_entrada[j], &vector_entrada[ j + 1 ] );
        printf("despues vector_entrada[%d]:%d y vector_entrada[%d]:%d\n",j,vector_entrada[j],j+1,vector_entrada[j+1]);
      }
    }
  }
}

int print(int vector_entrada[],int n){
    for(int i =0;i<n;i++){
            printf("vector_entrada[%d]: %d , \n",i,vector_entrada[i]);
    }
    printf("Ordenamiento Finalizado");
}

int main(int argc,const char *argv[]){
    int vector_entrada[]={100,-2,5,29,35,9};
    int n = sizeof(vector_entrada)/sizeof(vector_entrada[0]);
    printf("Size vector_entrada: %d\n",sizeof(vector_entrada));
    printf("Size vector_entrada[0]: %d\n",sizeof(vector_entrada[0]));
    printf("Valor n: %d\n",n);
    bubbleSort(vector_entrada,n);
    print(vector_entrada,n);
    return 0;
}

Guau, es una locura, me puse a hacer el codigo en c++, que es muy similar a c, en lugar de c# que es el que habitualmente uso, y estuve como 2 horas porque no me funcionaba un bloque de codigo muy muy sencillo:

void printBubble(int vector[], int n)
{
	int i;
	for (i = 0; i < n-1;i++);
	{
		std::cout << vector[i] << ", ";
		
	}
}

Esto solo me imprimia un numero, el ultimo del array.
Me di贸 un dolor de cabeza increible, porque ni el compilador me daba error, ni al ejecutar me salia ning煤n error.

驴Podeis ver el error del codigo? ( para los que no sepan c++, el cout << es similar al printf de c y est谩 todo correcto, no van por ah铆 los tiros).

Es increible que una cosa tan simple te vuelva loco por dos horas, tube que usar el depurador por instrucciones, hasta ver que el bucle for no funcionaba.
Sabiendo que era el bucle for, seguia sin saber que era lo que no funcionaba.

Al final descubr铆 que puse un punto y coma despues de los parantesis del for, dios mio, jam谩s pens茅 que esto no daria un error de compilaci贸n.
Seran muy similares, c, c++,c#,java y todo lo que querais, pero los nuevos lenguajes han facilitado de una manera brutal la forma en escribir codigo sobre todo por sus ide.

Hoy en dia lo tenemos muy facil para hacer una aplicacion con tantas herramientras a nuestro alcance. Solo necesitamos tiempo 馃槈.

El reto:

#include <iostream>
#include <cstdlib>

using namespace std;

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

void bubble_sort(int vector[], int n) {
  for(int i = 0; i < n - 1; i++) {
    for(int j = 0; j < n - i - 1; j++) {
      if(vector[j] < vector[j+1])
        cambiar_posicion(&vector[j], &vector[j+1]);
    }
  }
}

void print_vector(int vector[], int n) {
  for(int i = 0; i < n; i++) {
    cout << vector[i] << ",  ";
  }
  cout << endl;
  cout << "Lo logramos :D" << endl;
}

int main() {
  int vector[] = {100, 23, -4, 5, 8, 3, 91, 34};
  int n = sizeof(vector) / sizeof(vector[0]);
  cout << n << endl;
  bubble_sort(vector, n);
  print_vector(vector, n);
  cout<<endl;
}

Spoiler Alert:
Simplemente es invertir la comparaci贸n en la funci贸n bubble sort

Les comparto la implementaci贸n con ordenamiento ascendente y descendente con C#:

using System;

namespace bubble_sort
{
  public class BubbleSort
  {
    public void Sort(ref int[] target, short order = 1)
    {
      bool swap;
      int first, second = 0;

      do
      {
        swap = false;

        for (int index = 0; index < target.Length - 1; index++)
        {
          first = target[index];
          second = target[index + 1];

          if ((order == 1 && first > second) || (order == -1 && first < second))
          {
            swap = true;
            target[index] = second;
            target[index + 1] = first;
          }
        }
      } while (swap);
    }
  }
}

C贸digo Fuente

Les comparto mi implementacion en C#

using System;
using System.Collections.Generic;

namespace bubble_sort
{
    class Program
    {
        static List<int> values = new List<int> { 20, 1, -4, 5, 90, 700, 338, 0 };
        static void Main(string[] args)
        {
            Console.WriteLine("Arreglo original");
            printValues();
            Console.WriteLine("Iteraciones de ordenamiento");
            bubble_sort();
            Console.WriteLine("DONE");
        }

        static void bubble_sort(){
            int leftVal, rightVal, temp;
            bool swap;
            do
            {
                swap = false;
                for (int i = 0; i < values.Count - 1; i++)
                {
                    leftVal = values[i];
                    rightVal = values[i + 1];
                    if (rightVal < leftVal)
                    {
                        temp = leftVal;
                        values[i] = rightVal;
                        values[i + 1] = temp;
                        swap = true;
                    }
                }
                printValues();
            } while (swap);
        }

        static void printValues()
        {
            foreach (var item in values)
            {
                Console.Write(item + " ");
            }
            Console.WriteLine();
        }
    }
}

aporte en python, al no existir punteros en python tuve que prescindir de la funci贸n para cambiar de posici贸n y hacerlo directo dentro del if

<code>vectorIn = [100, 1992, 0, 5, -1, 60, 70, 14, 15, 10]
n = len(vectorIn)
    
def bubbleSort(vectorIn , n):
    for i in range (n-1):
        for j in range(n-i-1):
            if vectorIn[j]>vectorIn[j+1]:
                aux = vectorIn[j]
                vectorIn[j] = vectorIn[j+1]
                vectorIn[j+1] = aux
                
def result(vectorIn , n):
    for i in range (n):
        print('El n煤mero ' + str(i+1) + ' es: ' + str(vectorIn[i]))
        
bubbleSort(vectorIn,n)
result(vectorIn,n)
</code>

BubbleSort con ArrayList en Java:

public void bubbleSort(ArrayList<Integer> arrayList, int arraySize) {
        for (int i=1; i<= arraySize-1; i++){
            for (int j=0; j<= arraySize-i-1; j++) {
                if (arrayList.get(j) > arrayList.get(j+1)) {
                    temp = arrayList.get(j);
                    arrayList.set(j,arrayList.get(j+1));
                    arrayList.set(j+1,temp);
                }
            }
        }
        System.out.println();
        System.out.print("[");
        printBubbleSort(arrayList, arraySize);
        System.out.print("]");
    }

    public void printBubbleSort(ArrayList<Integer> arrayList, int arraySize){
        for (int i=0; i<arraySize;i++){
            System.out.print(arrayList.get(i) + ",");
        }
    }

    public void mainBubbleSort() {
        /*Declaraci贸n de variables*/
        Scanner scanner = new Scanner(System.in);
        ArrayList<Integer> arrayBubble = new ArrayList();
        int tamanoArray;
        int datoArray;

        System.out.println("驴Cu谩ntos elementos tendr谩 tu arreglo de datos?");
        tamanoArray = scanner.nextInt();

        for (int i=0; i<tamanoArray; i++) {
            System.out.print("Ingresa un n煤mero: ");
            System.out.println();
            arrayBubble.add(datoArray = scanner.nextInt());
        }

        System.out.print("El array qued贸 de la siguiente manera: [");
        for (int i=0; i<tamanoArray; i++){
            System.out.print(arrayBubble.get(i) + ", ");
        }

        System.out.print("]");
        System.out.println();
        System.out.println("El array ordenado queda de la siguiente manera:");
        bubbleSort(arrayBubble,tamanoArray);
    }

Repositorio

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

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

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

int imprimir(int vector_entrada[],int n)
{
    for(int i=0;i<n-1;i++)
    {
        printf("%i ,",vector_entrada[i]);
    }
    printf(" \n Fin del ordenamiento");
}


int main()
{

   int vector_entrada[]={20,50,10,522,125,265,321,-1,56,57};
    int n=sizeof(vector_entrada)/sizeof(vector_entrada[0]);
    bubbleSort(vector_entrada,n);
    imprimir(vector_entrada,n);
    printf("\n");
    return 0;
}```

Bastante simple la forma de cambiar como hace el ordenamiento el algoritmo

/* Ordenamiento de MAYOR A MENOR

1. Comenzamos a hacer la comparaci贸n de elemtos adyacentes.
2. Repetimos hasta tener una pasada completa sin ningun swap. */

#include <stdio.h>

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

void bubbleSort(int vectorEntrada[], int n){
    int i, j;
    for( i = 0 ; i < n-1 ; i++){
        for( j = 0 ; j < n - i - 1 ; j++){

            //Solo es cuestion de cambiar el simbolo de mayor que a menor que
            if(vectorEntrada[j] < vectorEntrada[j + 1]){
                cambiarPos(&vectorEntrada[j], &vectorEntrada[j+1]);
            }
        }
    }
}

int print(int vectorEntrada[], int n){
    for(int i = 0 ; i < n ; i++){
        printf("%d ", vectorEntrada[i]);
    }
    printf("\nFin del ordenamiento");
}

int main (){
    int vectorEntrada[] = {100, 1992, 0, 5, -1, 60, 70, 15, 14, 10};
    int n = sizeof(vectorEntrada)/sizeof(vectorEntrada[0]);

    bubbleSort(vectorEntrada, n);
    print(vectorEntrada, n);
    printf("\n");

    return 0;
}
def bubble(lista):
    fin = len(lista)
    temp = 0
    for n in range(2, fin):
        for j in range(0, fin - 1):
            if lista[j] > lista[j + 1]:
                temp = lista[j]
                lista[j] = lista[j + 1]
                lista[j + 1] = temp
        
if __name__ == '__main__':
    lista = [4,27,2,31,95,3,6,12,7]
    print(lista)
    bubble(lista)
    print(lista)```

Aqu铆 les dejo una implementacion de bubble sort en python https://www.geeksforgeeks.org/python-program-for-bubble-sort/

void bubbleSort(int vectorEntrada[], int n){
int i, j;
for (i=0; i<n-1; i++){
for (j=0; j<n-i-1; j++){
if (vectorEntrada[j]<ectorEntrada[j+1]){
cambiarPos(&vectorEntrada[j], &vectorEntrada[j+1]);
}
}
}
}

Solo tengo el problema que no salen todos los caracteres ingresados:

#include <stdio.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-1; j++)
        {
            //[10, 5, 3, 333]
            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-1; i++)
    {
        printf("%d ,", vector_entrada[i]);
    }
    printf("\n fin del ordenamiento");
}

main (int argc, char const *argv[])
{
    int vector_entrada[]={100,1992,0,5,-1,60,70,15,14};
    int n = sizeof(vector_entrada)/sizeof(vector_entrada[0]);
    bubbleSort(vector_entrada, n);
    print_array(vector_entrada, n);
    printf("\n");
    return 0;
}

Cambiando nuestra condicion de > a < y鈥 Bingooo

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-1; j++)
        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]);
  }
}

He escrito todo igual al c贸digo de Ricardo pero cuando lo ejecuto no me imprime nada. Alguien sabe por qu茅?

#include <stdio.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((int*)vector_entrada[j], (int*)vector_entrada[j+1]);
			}
		}
	}
}

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

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

	return 0;
}
#include <stdio.h>

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


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

void print_ASC(int arr[], int n){
	printf("ASC ");
	for(int i = 0; i < n; i++){
		printf("%d, ", arr[i]);
	}
}

void print_DESC(int arr[], int n){
	printf("DESC ");
	for(int i = n - 1; i >=0; i--){
		printf("%d, ", arr[i]);
	}
}

int main(){
	int arr[] = {5,3,6,1,4,8};
	int n = sizeof(arr)/sizeof(arr[0]);
	bubbleSort(arr,n);
	print_ASC(arr, n);
	print_DESC(arr,n);
	return 0;
}
int print_array(int vector_entrada[],int n)
{
    int i;
    for (i = 0; i < n-1; i++)
        printf("%d , ", vector_entrada[i]);s
    printf("\n fin del Ordenamiento");
}

main(int argc, 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 int print(<error-type> [], int n)
    print(vector_entrada,n);
    printf("\n");
    return 0;
}

Solucione el reto cambiando la condicion del if > ----- <

    for(j=0; j < n - i - 1; j++)
        {
            if(vectorEntrada[j] < vectorEntrada[j + 1])
            cambiarPos(&vectorEntrada[j], &vectorEntrada[j + 1]);
        }```