Bienvenido al Curso
Introducción al curso básico de algoritmos y estructuras de datos
Introducción a los algoritmos
¿Qué entiende una computadora?
Lenguajes de programación
Estructuras de datos
¿Qué es un algoritmo?
Metodología para la construcción de un algoritmo
Variables y tipos de datos
User defined data types
Instalando Ubuntu Bash en Windows
Creando nuestro user defined data type
Abstract Data Types básicos: Lists, Stacks, Queues
Explicación gráfica Data Types básicos
Glosario de funciones para Abstract Data Types
Clases y objetos
Creando tu primera Queue: Arrays
Creando tu primera Queue: implementación.
Creando tu primera Queue: implementar la función enQueue
Creando tu primera Queue: implementar la función deQueue
Creando tu primera Queue: main code
Algoritmos de ordenamiento
Algoritmos de ordenamiento
Bubble sort
Bubble sort: implementación
Bubble sort: main code
Insertion sort
Desafío: implementa un algoritmo de ordenamiento
Recursividad
Recursividad
La función Factorial, calculando el factorial recursivamente
Manejo de cadenas de caracteres
Arte: Generando arte recursivo
Divide and conquer y programación dinámica
Divide and Conquer (divide y vencerás)
Qué es la programación dinámica (divide y vencerás v2.0)
MergeSort
Desafío: Buscar el algortimo más rápido de sort
Implementando QuickSort con Python
Implementando QuickSort con Python: main code
Algoritmos 'Greedy'
Qué son los Greedy Algorithm
Ejercicio de programación greedy
Ejercio de programación greedy: main code
Grafos y árboles
Grafos y sus aplicaciones
Árboles
¿Cómo comparar Algoritmos?
Cómo comparar algoritmos y ritmo de crecimiento
¿Qué sigue?
Cierre del curso y siguientes pasos
No tienes acceso a esta clase
¡Continúa aprendiendo! Únete y comienza a potenciar tu carrera
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 288
Preguntas 18
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 “No 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;
}```
sorted() que hace lo mismo que un BubbleSortDespués de realizar la implementación del profe, pensé en la definición original, “comparar 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.
Stream, metodos min() max() get() para hallar obtener en una variable el valorindexOf() , 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.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:
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()```
#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 “print_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 “if”, 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);
}
}
}
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);
}
#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;
}
¿Quieres ver más aportes, preguntas y respuestas de la comunidad?