Algoritmo burbuja (C++)

Hola,

El algoritmo es muy sencillo.
Consiste en ir comparando cada número con el siguiente.
si el primer número es < segundo, lo dejo y sigo con el segundo.
si el primer número > segundo, los cambio de posición y sigo comparando, ahora el segundo con el tercero.
Este algoritmo hay que repetirlo hasta que no se produzca ningún cambio en la lista.

En la wikipedia tienes el algoritmo y el código en C, C++ y Java. Más no se puede pedir

Regards(las plantas)

Ordenación por intercambio directo. Método de la Burbuja.

Este método tiene dos versiones basados en la misma idea, que consiste en recorrer sucesivamente el vector comparando los elementos consecutivos e intercambiándolos cuando esten descolocados. El recorrido se puede hacer de izquierda a derecha o de derecha a izquierda.

Lo vemos con un ejemplo:

#include #define N 5 /* tamaño del vector */ * void main()* { int v[N]={2,3,4,5,6}; int aux,p,i;

for (p=1; p < N; p++)
{
	for (i=0; i< N - p; i++)
	{
		if (v* > v[i+1])
		{
			aux = v*;
			v* = v[i+1];
			v[i+1] = aux;
		}
	}
}

for (i=0;i<N;i++){
	printf("\n%d",v*);
} }

No me deja tabularlo bien**

Comentario #2 por bloodeR_:
Ordenación por intercambio directo. Método de la Burbuja.

Este método tiene dos versiones basados en la misma idea, que consiste en recorrer sucesivamente el vector comparando los elementos consecutivos e intercambiándolos cuando esten descolocados. El recorrido se puede hacer de izquierda a derecha o de derecha a izquierda.

Lo vemos con un ejemplo:

#include #define N 5 /* tamaño del vector */ * void main()* { int v[N]={2,3,4,5,6}; int aux,p,i;

for (p=1; p < N; p++)
{
	for (i=0; i< N - p; i++)
	{
		if (v* > v[i+1])
		{
			aux = v*;
			v* = v[i+1];
			v[i+1] = aux;
		}
	}
}

for (i=0;i<N;i++){
	printf("\n%d",v*);
} }

No me deja tabularlo bien**

acabas de enseñarle esos ejemplos que no entiende

soz,

Comentario #3 por dadito:
#2 acabas de enseñarle esos ejemplos que no entiende

tiene razón, el copypaste de blooder no me sirve, estoy buscando algo concreto, Sinsa, tu respuesta es demasiado general, lo que busco es algo así como el código que viene en la wiki pero comentado, porque al no estar comentado no lo entiendo

que suba a ver si responde alguien

Yo no sé nada de programación… pero que alguien me explique por qué la x’D de #no se transforma en carita automáticamente y yo tengo que poner la ‘ pa que se vea la x y la D, por favor.

Hola,

ups, se me ha pasado lo siento

Mañana te explico el algoritmo pasito a pasito (mándame un priv para recordármelo )

Hola,

A ver ahora….

Tenemos una lista de números: 7, 4, 3, 8, 1, 6
Queremos ordenarlos de menor (el 1) a mayor (el .
Utilizamos la burbuja.
Cojemos el primero (7) y lo comparamos con el siguiente (4). Posición(1) > posición(2)
Como es mayor los intercambiamos (4,7,3,8,1,6)
Sigo comparando, ahora comparo posición(2) con posición(3) – >el 7 con el 3 y vuelvo a cambiarlos (4,3,7,8,1,6)
Ahora posición (3) con posición(4) no hago cambio ya que 8<7
Ahora posición(4) con posición(5) – > cambio el 8 con el 1 (4,3,7,1,8,6)
Posición (5) y posición(6) – > cambio el 8 con el 6 (4,3,7,1,8,6)
Volvemos a empezar….
Posición(1) con posición(2) – > cambio el 4 con el 3 (3,4,7,1,8,6)
Posición(2) y posición(3) – > no hay cambio
Posición (3) y posición(4) – > cambio 7 por 1 (3,4,1,7,8,6)
Posición (4) y posición (5) – > sin cambio
Pos(5) y pos(6) – > cambio (3,4,1,7,6,8)
Volvemos a empezar:
Pos(1) y pos(2)– > no cambio
Pos(2) y pos (3) – > (3,1,4,7,6,8)
Pos (3) y pos(4) – > no cambio
Pos(4) y pos(5) – > (3,1,4,6,7,8)
Volvemos a empezar…
Pos(1) y pos(2)– >(1,3,4,6,7,8)
Hemos acabado.

El bucle es:

Mientras hay intercambios
Comparo pos(i) con pos(i+1)
Si hay intercambio, sumo i=i+1
Cuando no hay más intercambios, vuelvo a empezar

en pseudocódigo:

Intercambio= FALSO

Para i= 0 hasta n-2

—- Si pos(i) > pos(i+1) entonces:

——– Intercambiar pos(i) con pos(i+1)

——– Intercambio = VERDADERO

—- Fin Si

Repite mientras intercambio=VERDADERO

Ahora el código:

void ordenamientoBurbuja(int v[ ], int util_v) {·······<— recibe la lista y el número de elemntos que tiene
__ int temp;

__ for (int i = 0; i <= util_v - 2; i++) { ········· **<—- Para i= 0 hasta n-2**
____ for (int j = i + 1; j <= util_v - 1; j++) { ·········· **<—- selecciona el siguiente para poder comparar pos(i) con pos(i+1)**
______ if (v[ i ] > v[ j ]) { ·········· <— compara
______ temp = v[ i ]; ··········**<— cambia los elementos**
______ v[ i ] = v[ j ];
______ v[ j ] = temp;
______ }
____ }
__ }
}

Regards(las plantas)

Comentario #9 por SinSa:
Hola,

A ver ahora….

Tenemos una lista de números: 7, 4, 3, 8, 1, 6
Queremos ordenarlos de menor (el 1) a mayor (el .
Utilizamos la burbuja.
Cojemos el primero (7) y lo comparamos con el siguiente (4). Posición(1) > posición(2)
Como es mayor los intercambiamos (4,7,3,8,1,6)
Sigo comparando, ahora comparo posición(2) con posición(3) – >el 7 con el 3 y vuelvo a cambiarlos (4,3,7,8,1,6)
Ahora posición (3) con posición(4) no hago cambio ya que 8<7
Ahora posición(4) con posición(5) – > cambio el 8 con el 1 (4,3,7,1,8,6)
Posición (5) y posición(6) – > cambio el 8 con el 6 (4,3,7,1,8,6)
Volvemos a empezar….
Posición(1) con posición(2) – > cambio el 4 con el 3 (3,4,7,1,8,6)
Posición(2) y posición(3) – > no hay cambio
Posición (3) y posición(4) – > cambio 7 por 1 (3,4,1,7,8,6)
Posición (4) y posición (5) – > sin cambio
Pos(5) y pos(6) – > cambio (3,4,1,7,6,8)
Volvemos a empezar:
Pos(1) y pos(2)– > no cambio
Pos(2) y pos (3) – > (3,1,4,7,6,8)
Pos (3) y pos(4) – > no cambio
Pos(4) y pos(5) – > (3,1,4,6,7,8)
Volvemos a empezar…
Pos(1) y pos(2)– >(1,3,4,6,7,8)
Hemos acabado.

El bucle es:

Mientras hay intercambios
Comparo pos(i) con pos(i+1)
Si hay intercambio, sumo i=i+1
Cuando no hay más intercambios, vuelvo a empezar

---

en pseudocódigo:

Intercambio= FALSO

Para i= 0 hasta n-2

—- Si pos(i) > pos(i+1) entonces:

——– Intercambiar pos(i) con pos(i+1)

——– Intercambio = VERDADERO

—- Fin Si

Repite mientras intercambio=VERDADERO

Ahora el código:

void ordenamientoBurbuja(int v[ ], int util_v) {·······<— recibe la lista y el número de elemntos que tiene
__ int temp;

__ for (int i = 0; i <= util_v - 2; i++) { ········· **<—- Para i= 0 hasta n-2**
____ for (int j = i + 1; j <= util_v - 1; j++) { ·········· **<—- selecciona el siguiente para poder comparar pos(i) con pos(i+1)**
______ if (v[ i ] > v[ j ]) { ·········· <— compara
______ temp = v[ i ]; ··········**<— cambia los elementos**
______ v[ i ] = v[ j ];
______ v[ j ] = temp;
______ }
____ }
__ }
}

Regards(las plantas)

es mas facil aun creo yo. No necesitas el meteodo de la burbuja para esta chorrada

mirate esto:

#include #include

int main(void)
{
int i,j;
int tiempo[5]={4,9,7,2,1};
j=0;

for (i=0;i<5;i++)
{
    if(tiempo*>j)j=tiempo*;
}

printf("Tiempo mayor es %d",j);

getch();
return 0; }

si le pones esto al profesor en teoria te a de puntuar mejor puesto que el programa esta optimizado… si no entiendes esto enviame un privado o deja respuesta aki y te contestare encantado

**

Editado: mmmm si necesitas obtener el tiempo que tu quieras tienes que añadir un for y borrar el 5 del vector y la enumeracion que lo sigue. Espero haberte ayudado

Comentario #6 por Unk:
Yo no sé nada de programación… pero que alguien me explique por qué la x’D de #0 no se transforma en carita automáticamente y yo tengo que poner la ‘ pa que se vea la x y la D, por favor.

Porque en #ha puesto , (equisde seguido de coma, luego seguido de parentesis) —> ) hay que dejar espacios como si fuera una palabra para que se vea el smiley:
…bla bla bla .xD , )… <—
En la descripcion de las imagenes subidas en una galeria me parece que no se ven los smileys asi que si en la descripcion de tus fotos de tu galeria pones algo como: ‘‘esta se ve mal ‘’ en vez de la carita se te veria .xD (sin el punto)
Editado: Ahh, pues no que raro, igual en las preguntas no se ven las caritas, como tampoco se ven las firmas.

Comentario #11 por 2_Face:
#6 Porque en #0 ha puesto , (equisde seguido de coma, luego seguido de parentesis) —> ) hay que dejar espacios como si fuera una palabra para que se vea el smiley:
…bla bla bla .xD , )… <—
En la descripcion de las imagenes subidas en una galeria me parece que no se ven los smileys asi que si en la descripcion de tus fotos de tu galeria pones algo como: ‘‘esta se ve mal ‘’ en vez de la carita se te veria .xD (sin el punto)
Editado: Ahh, pues no que raro, igual en las preguntas no se ven las caritas, como tampoco se ven las firmas.

Igual es por la coma , Tú has puesto un punto .xD y tampoco se ha transformado en carita.

Editado: Ah, pues no. Tampoco es la coma… pero el punto si que va. ¡Que lio!

Comentario #12 por Unk:
#11 Igual es por la coma , Tú has puesto un punto .xD y tampoco se ha transformado en carita.

Editado: Ah, pues no. Tampoco es la coma… pero el punto si que va. ¡Que lio!

Te ha pasado lo mismo que a mi, pero por lo visto si lo pones detras del equisde no sirve, la cara sale de todos modos, tienes que ponerlo delante —> ,xD ,

Gracias sinsa y kaito por responder, la de Sinsa fue especialmente explicativa por lo que le he dado la mejor respuesta a él.

Ahora a ver si consigo aplicar el algoritmo burbuja a una tabla en lugar de un array, que en realidad es lo que tengo que hacer , llevo 3 dias con ello y me trae de cabeza

JAJAJA SinSa, pensaba que le estabas explicando a Unk lo del “x’D”.
Necesito descansar .

Hola,

Para la tabla es igual, simplemente añadir una nueva dimensión al array

__ for (int i = 0; i <= util_v - 2; i++) { ········· <—- Para i= 0 hasta n-1 trato las columnas
———- for (int F = 0; F <= util_v - 2; F++) { ········· <—- para cada columna avanzo en el array

____ for (int FJ = F + 1; j <= util_v - 2; FJ++) { ·········· <—- selecciona el siguiente para poder comparar pos(i)(j) con pos(i)(j+1)

____ if (v[ i ] [ j ]> v[i ][ j+1 ]) { ·········· <— compara

______ temp = v[ i ] [ j ]; ··········<— cambia los elementos

______ v[ i ][ j ] = v[ i ][ j+1 ];

______ v[ i ][ j +1] = temp;

____ }

____ }

__ } cuando acabo, i=i+1 y paso a la siguiente columna.

gracias otra vez sinsa, en esta ocasión con la explicación que diste al principio conseguí aplicarlo a la matriz