METODOS DE ORDENAMIENTO DE VECTORES/ARREGLOS

METODOS DE ORDENAMIENTO DE VECTORES/ARREGLOS

Los algoritmos de ordenamiento nos permiten, como su nombre lo dice, ordenar vectores
con valores asignados aleatoriamente. Para poder ordenar una cantidad determinada de
números almacenadas en un vector o matriz, existen distintos métodos (algoritmos) con
distintas características y complejidad.
Existe desde el método más simple, como el Bubblesort (o Método Burbuja), que son
simples iteraciones, hasta el Quicksort (Método Rápido), que al estar optimizado usando
recursión, su tiempo de ejecución es menor y es más efectivo.

A. METODOS ITERATIVOS
Estos métodos son simples de entender y de programar ya que son iterativos, simples ciclos
y sentencias que hacen que el vector pueda ser ordenado.
Dentro de los Algoritmos iterativos encontramos:

1. BURBUJA:
Es uno de los más simples, es tan fácil como comparar todos los elementos de una lista
contra todos, si se cumple que uno es mayor o menor otro, entonces los intercambia de
posición.
Por ejemplo, imaginemos que tenemos los siguientes valores:

1 8 9 3 25

Lo que haría una burbuja simple, seria comenzar recorriendo los valores de izq. a
derecha, comenzando por el 1. Lo compara con el 8, con el 8, con el 3 y con el 25, si es
mayor o menor (dependiendo si el orden es ascendiente o descendente) se
intercambian de posición. Luego continua con el siguiente, con el 8, y lo compara con todos
los elementos de la lista, esperando ver si se cumple o no la misma condición que con el
primer elemento. Así, sucesivamente, hasta el último elemento de la lista.

1.1 BURBUJA SIMPLE

 La burbuja más simple de todas es la que compara todos con todos, generando
comparaciones extras, por ejemplo, no tiene sentido que se compare con sigo mismo o que
se compare con los valores anteriores a él, ya que supuestamente, ya están ordenados.
1.2 BURBUJA MEJORADA
Una nueva versión del método de la burbuja seria limitando el número de comparaciones,
dijimos que era inútil que se compare consigo misma. Si tenemos una lista de 10.000
elementos, entonces son 10.000 comparaciones que están sobrando. Imaginemos si
tenemos 1.000.000 de elementos. El método sería mucho más óptimo con “n”
comparaciones menos (n = total de elementos).
2. INSERCIÓN:
El bucle principal de la ordenación por inserción va examinando sucesivamente todos los
elementos de la matriz desde el segundo hasta el n-ésimo, e inserta cada uno en el lugar
adecuado entre sus predecesoras dentro de la matriz.
3. SELECCIÓN:
La ordenación por selección funciona seleccionando el menor elemento de la matriz y
llevándolo al principio; a continuación selecciona el siguiente menor y lo pone en la segunda
posición de la matriz y así sucesivamente.
4. SHELLSORT:
Este método es una mejora del algoritmo de ordenamiento por Inserción (Insertsort).Si
tenemos en cuenta que el ordenamiento por inserción es mucho más eficiente si nuestra
lista de números esta semi-ordenada y que desplaza un valor una única posición a la vez.
Durante la ejecución de este algoritmo, los números de la lista se van casi-ordenando y
finalmente, el último paso o función de este algoritmo es un simple método por inserción
que, al estar casi-ordenados los números, es más eficiente.
B. METODOS RECURSIVOS

Estos métodos son aún más complejos, requieren de mayor atención y conocimiento para
ser entendidos. Son rápidos y efectivos, utilizan generalmente la técnica Divide y vencerás,
que consiste en dividir un problema grande en varios pequeños para quesea más fácil
resolverlos.
Mediante llamadas recursivas a sí mismos, es posible que el tiempo de ejecución y de
ordenación sea más óptimo. Dentro de los algoritmos recursivos encontramos:

1. ORDENAMIENTO POR MEZCLAS (MERGE):

Este algoritmo consiste básicamente en dividir en partes iguales la lista de números y luego
mezclarlos comparándolos, dejándolos ordenados. Si se piensa en este algoritmo
 recursivamente, podemos imaginar que dividirá la lista hasta tener un elemento en cada
lista, luego lo compara con el que está a su lado y según corresponda, lo sitúa donde
corresponde.
2. ORDENAMIENTO RÁPIDO (QUICK):
El algoritmo quicksort es quizá el más eficiente de los algoritmos de ordenamiento, debido
a que su complejidad es mínima y por lo tanto su tiempo de ejecución también es mínimo.
Se divide la lista en dos sub-listas y ordenarlas en forma independiente cada una. El
proceso de partición es repetido hasta llegar a listas de tamaño 1 (que están ordenadas).
Lo central en este método es encontrar un método eficiente para particionar la lista en dos
partes, tal que:
Todos los elementos de una sub-lista deben ser menores que un elemento llamado pivote.
Todos los elementos en la otra sub-lista deben ser mayores que el pivote.
Si asumimos que los elementos de la lista están almacenados en un arreglo, el método para
particionar el arreglo en dos es como sigue:

 Escoja un elemento en el arreglo como pivote. Por conveniencia, usaremos el primer

elemento del arreglo.

 Ponga un índice al segundo elemento del arreglo (i1) y otro al último elemento (i2).

 Decremente i2 hasta que encuentre un elemento con valor menor que el pivote o i2 llegue
a i1. Incremente i1 hasta que encuentre un elemento mayor que el pivote o hasta
que i1 llegue a i2. Llamaremos a este proceso “búsqueda”.

 Si los dos índices son distintos, los dos elementos del arreglo (los apuntados por i2 e i1)
están fuera de lugar, por lo que se intercambian. Repita el paso anterior de búsqueda,
resumiendo la operación donde se había quedado.

 Si los dos índices son iguales y el valor que ambos índices apuntan es menor que el pivote,
intercámbielos. El arreglo está ahora particionado por el elemento referenciado por i2 (o i1).
La localización del pivote separa el arreglo en una porción donde todos sus valores son
menores que el pivote, y otra porción donde todos sus valores son mayores que el pivote.
Ejemplo:
 Publicado

Ordenamiento de burbuja bidireccional

 Inicio
 Algoritmos
 Programas
 Descargas
 Blog
 Mapa

El ordenamiento de burbuja
bidireccional
El ordenamiento de burbuja bidireccional (también llamado "método de la sacudida"
o "coctail sort" o "shaker sort") es un algoritmo de ordenamiento que surge como
una mejora del algoritmo ordenamiento de burbuja.

Si ya habéis visto como funciona el algoritmo de ordenación por burbuja habréis

observado que los números grandes se están moviendo rápidamente hasta al final
de la lista (estas son las "liebres"), pero que los números pequeños (las "tortugas")
se mueven sólo muy lentamente al inicio de la lista.
 Una solución es de ordenar con el método de burbuja y cuando llegamos al final de
la primera iteración, no volver a realizar el cálculo desde el principio sino que
empezaremos desde el final hasta al inicio. De esta manera siempre se consigue que
tanto los números pequeños como los números grandes se desplacen a los extremos
de la lista lo más rápido posible.

Representación animada del algoritmo :

Representación animada del ordenamiento de burbuja bidireccional

3 Velocidad normal 3 Velocidad normal 3 Aleatorio 3
Aleatorio Ordenar

 Pseudocódigo
 Caml
 Pascal
 Python
 C
 Modelo gráfico
 Diagrama

1. PROCEDIMIENTO cocktail_sort ( VECTOR a[1:n])

2.
3. dirección ← 'frontal', comienzo ← 1, fin ← n-
1, actual ← 1
4.
5. REPETIR
6. permut ← FALSO
7. REPETIR
8. SI a[actual] > a[actual + 1] ENTONCES
9. intercambiar a[actual] Y a[actual +
1]
10. permut ← VERDADERO
11. FIN SI
12. SI (dirección='frontal') ENTONCES
13. actual ← actual + 1
14. SI NO
15. actual ←actual - 1
16. FIN SI
17. MIENTRAS
QUE ((dirección='frontal') Y (actual<fin)) OU
((dirección='final) O (actual>comienzo))
 18. SI (dirección='frontal') ENTONCES
19. dirección ← 'final'
20. fin ← fin - 1
21. SI NO
22. dirección ← 'frontal'
23. comienzo ← comienzo + 1
24. FIN SI
25. MIENTRAS permut = VERDADERO
26.
27. FIN PROCEDIMIENTO

Use este algoritmo para resolver el pequeño conjunto de la página anterior :

Comparaciones :
Movimientos :

Mezclar
Resolver

Los siguientes gráficos muestran el aumento en el número de transacciones en

relación con el número de elementos a ser ordenados.

Rendimiento del algoritmo

 Rendimiento en el caso óptimo
 Rendimiento en el caso desfavorable
 Rendimiento en el caso medio

En el caso óptimo, con los datos ya ordenados, el algoritmo sólo

effectura n comparaciones. Por lo tanto la complejidad en el caso óptimo es en Θ(n).

Número de operacionesNúmero de términosΘ(n)102030405003060

Superior Inicio Mapa

5.8. El ordenamiento por selección
El ordenamiento por selección mejora el ordenamiento burbuja haciendo un sólo
intercambio por cada pasada a través de la lista. Para hacer esto, un ordenamiento por
selección busca el valor mayor a medida que hace una pasada y, después de completar la
pasada, lo pone en la ubicación correcta. Al igual que con un ordenamiento burbuja, después
de la primera pasada, el ítem mayor está en la ubicación correcta. Después de la segunda
pasada, el siguiente mayor está en su ubicación. Este proceso continúa y
requiere n−1n−1 pasadas para ordenar los n ítems, ya que el ítem final debe estar en su lugar
después de la (n−1)(n−1)-ésima pasada.
La Figura 3 muestra todo el proceso de ordenamiento. En cada paso, el ítem mayor restante
se selecciona y luego se pone en su ubicación correcta. La primera pasada ubica el 93, la
segunda pasada ubica el 77, la tercera ubica el 55, y así sucesivamente. La función se
muestra en el ActiveCode 1.
 Figura 3: ordenamientoPorSeleccion
RunLoad HistoryShow CodeLens

1
def ordenamientoPorSeleccion(unaLista):
2
for llenarRanura in range(len(unaLista)-1,0,-1):
3
posicionDelMayor=0
4
 for ubicacion in range(1,llenarRanura+1):
5
if unaLista[ubicacion]>unaLista[posicionDelMayor]:
6
posicionDelMayor = ubicacion
7

8
temp = unaLista[llenarRanura]
9
unaLista[llenarRanura] = unaLista[posicionDelMayor]
10
unaLista[posicionDelMayor] = temp
11

12
unaLista = [54,26,93,17,77,31,44,55,20]
13
ordenamientoPorSeleccion(unaLista)
14
print(unaLista)
15

Ordenamiento por selección (lst_selectionsortcode)

Initialize Run Stop

Beginning Step Forward Step Backward End
Usted habrá notado que el ordenamiento por selección hace el mismo número de
comparaciones que el ordenamiento burbuja y por lo tanto también es O(n2)O(n2). Sin
embargo, debido a la reducción en el número de intercambios, el ordenamiento por selección
normalmente se ejecuta más rápidamente en pruebas de referencia. De hecho, para nuestra
lista, el ordenamiento burbuja hace 20 intercambios, mientras que el ordenamiento por
selección hace sólo 8.
Autoevaluación
Q-16: Suponga que usted tiene que ordenar la siguiente lista de números: [11, 7, 12, 14, 19, 1,
6, 18, 8, 20] ¿Cuál de las siguientes listas representa la lista parcialmente ordenada tras tres
pasadas completas del ordenamiento por selección?
(A) [7, 11, 12, 1, 6, 14, 8, 18, 19, 20]
(B) [7, 11, 12, 14, 19, 1, 6, 18, 8, 20]
(C) [11, 7, 12, 14, 1, 6, 8, 18, 19, 20]
(D) [11, 7, 12, 14, 8, 1, 6, 18, 19, 20]
Check MeCompare me


 Next Section - 5.9. El ordenamiento por inserción
user not logged in
Ordenamiento de burbuja
bidireccional – Algoritmos de
ordenamiento
Publicado por Andrea Navarro en 25 octubre, 2016

El algoritmo de ordenamiento de burbuja bidireccional también llamado

ordenamiento cocktail intenta mejorar el rendimiento del ordenamiento
burbuja realizando el recorrido de comparación en ambas direcciones, de esta
manera se puede realizar más de un intercambio por iteración.
De la misma manera que el algoritmo de burbuja no se utiliza excepto para
motivos pedagógicos por su falta de eficiencia pero sencillez de aplicación.
Estabilidad: Estable
Método: Intercambio
Comparativo: Si
Uso de memoria: 1
Complejidad computacional:

Mejor caso:

Caso promedio:

Peor caso:

Ordenamiento de burbuja bidireccional

Comenzamos con una lista de elementos no ordenados
Tomamos los primeros dos números y si no están ordenados se intercambian los
lugares

El proceso continua hasta llegar al final

Al llegar al final a diferencia del ordenamiento de burbuja se repite el proceso en
sentido inverso comenzando por el final de la lista hasta llegar al inicio.
Al terminar el proceso el último número y el primero ya quedan ordenados por lo
que en la siguiente iteración ya no se evalúan acortando el proceso.
Al finalizar la segunda iteración se marcan como ordenados el primer y último
número comparado.
No es posible realizar más iteraciones ya que no quedan dos números sin ordenar
para comparar, por lo tanto el algoritmo termina.
Código en C

1 #include<stdio.h>
2
3 #define N 5
4
5 int main(int argc, char** argv){
6
7 int lista[N]={5,2,4,1,3};
8
9 int inicioIndice=0;
10 int finIndice=N-1;
11 int i,aux,intercambio=0;
12
13 //Recorrer la lista hasta que no haya números para ordenar
14 while(inicioIndice<=finIndice){
15 int nuevoPrimerIndice=finIndice,nuevoInicioIndice;
16 int nuevoFinIndice=inicioIndice;
17
18 //Ordenado hacia adelante
19 for(i=inicioIndice;i<finIndice;i++){
20 //Comparando valores
21 if(*(lista+i)>*(lista+i+1)){
22 //Intercambio valores
23 aux=*(lista+i);
24 *(lista+i)=*(lista+i+1);
25 *(lista+i+1)=aux;
26 //Marcar que ha ocurrido un intercambio
27 intercambio=1;
28 //Marcar último número ordenado al final de la
29 *(lista
30 nuevoFinIndice=i;
31 }
32 }
33
34 if(!intercambio){
35 //Si no se ha realizado ningún cambio salir de la iteracion
36 break;
37 }
38
39 //Marcar el último número ordenado al final de la *(lista como
40 final para no evaluarlo la siguiente iteración
41 finIndice=nuevoFinIndice;
42 intercambio=0;
43
44 //Ordenado hacia atras
45 for(i=finIndice;i>=inicioIndice;i--){
46 //Comparando valores
47 if(*(lista+i)>*(lista+i+1)){
48 //Intercambio valores
49 aux=*(lista+i);
50 *(lista+i)=*(lista+i+1);
51 *(lista+i+1)=aux;
52 //Marcar que ha ocurrido un intercambio
53 intercambio++;
54 //Marcar último número ordenado al principio de la
55 *(lista
56 nuevoInicioIndice=i;
57 }
58 }
59
60 if(!intercambio){
61 //Si no se ha realizado ningún cambio salir de la iteracion
62 break;
63 }
64
65 //Marcar el último número ordenado al principio de la *(lista
66 como final para no evaluarlo la siguiente iteración
67 inicioIndice=nuevoInicioIndice+1;
68 }

return 0;

}
Código en PHP

1 <?php
2
3 $lista[0]=5;
4 $lista[1]=2;
5 $lista[2]=4;
6 $lista[3]=1;
7 $lista[4]=3;
8
9 $inicioIndice=0;
10 $finIndice=count($lista)-1;
11 $lon=count($lista);
12
13 //Recorrer la lista hasta que no haya números para ordenar
14 while($inicioIndice<=$finIndice)
15 {
16 $nuevoPrimerIndice=$finIndice;
17 $nuevoFinIndice=$inicioIndice;
18
19 //Ordenado hacia adelante
20 for($i=$inicioIndice;$i<$finIndice;$i++)
21 {
22 //Comparando valores
23 if($lista[$i]>$lista[$i+1])
24 {
25 //Intercambio valores
26 $aux=$lista[$i];
27 $lista[$i]=$lista[$i+1];
28 $lista[$i+1]=$aux;
29 //Marcar que ha ocurrido un intercambio
30 $intercambio=true;
31 //Marcar último número ordenado al final de la lista
32 $nuevoFinIndice=$i;
33 }
34 }
35
36 if($intercambio == false)
37 {
38 //Si no se ha realizado ningún cambio salir de la iteracion
39 break;
40 }
41
42 //Marcar el último número ordenado al final de la lista como final para
43 no evaluarlo la siguiente iteración
44 $finIndice=$nuevoFinIndice;
45 $intercambio=false;
46
47 //Ordenado hacia atras
48 for($i=$finIndice;$i>=$inicioIndice;$i--)
49 {
50 //Comparando valores
51 if($lista[$i]>$lista[$i+1])
52 {
53 //Intercambio valores
54 $aux=$lista[$i];
55 $lista[$i]=$lista[$i+1];
56 $lista[$i+1]=$aux;
57 //Marcar que ha ocurrido un intercambio
58 $intercambio=true;
59 //Marcar último número ordenado al principio de la lista
60 $nuevoInicioIndice=$i;
61 }
62 }
63
64 if($intercambio == false)
65 {
66 //Si no se ha realizado ningún cambio salir de la iteracion
67 break;
68 }
69
70 //Marcar el último número ordenado al principio de la lista como final
71 para no evaluarlo la siguiente iteración
72 $inicioIndice=$nuevoInicioIndice+1;

}
Espero que les sirva!

Algoritmos De Ordenamiento : Burbuja O

(Bubble Sort) Y Burbuja Mejorado
Implementados En C++
SOCIALIZA ESTO →
0

Aqui les comparto dos algoritmos: burbuja y burbuja

mejorado espero les sirva

Algoritmo de Ordenamiento Burbuja:

El algoritmo de Ordenamiento Burbuja o Bubblesort es

un algoritmo que trabaja sobre un arreglo de números,
tomando el ultimo elemento y comparándolo con su
anterior y si hubiese cambio los ordena, se le llama
burbuja por que hace las comparaciones de tal manera
que asemejan a burbujas subiendo desde el fondo del
agua.
 El esquema de la implementacion es esta:

1° Ingresa Arreglo de números

2° La función Burbuja los ordena
3° Se Muestra el Arreglo de números

El algoritmo burbuja en su implementacion usa una

variable auxiliar para hacer el intercambio en caso el
dato anterior sea mayor.

Su complejidad es de 0(n^2).

Implementación de Burbuja en C++

1. /*

2. Name: Algoritmo de Ordenacion Burbuja

3. Author: Joel Fernandez

4. Date: 13/06/2014 2:41 a.m.

5. Description: Implementacion de algoritmo Bubble Sort en C++

6. */

7.

8. #include<iostream>

9. #include<conio.h>

10. #define MAX 50

11.

12. using namespace std;

13. void LeerArreglo(int,float []);

14. void Burbuja(int,float []);

15. void MuestraArreglo(int,float []);

16.
17. int main(void)

18. {

19. system("color 0a");

20. float Numeros[MAX];

21. int n;

22. cout<<"\t****************************************************\n";

23. cout<<"\t*** ALGORITMO DE ORDENAMIENTO BURBUJA ***\n";

24. cout<<"\t*** ---------------------------------- ***\n";

25. cout<<"\t****************************************************\n\n\n";

26.

27. cout<<"\n\nNUMERO DE DATOS A LEER:"; cin>>n;

28.

29. LeerArreglo(n,Numeros); //ingreso de datos en array

30. Burbuja(n,Numeros); // ordena por burbuja

31. cout<<endl<<"\n\n LOS ELEMENTOS FUERON ORDENADOS \n\n"<<endl;

32. MuestraArreglo(n,Numeros); //muestra array ordenado

33.

34.

35. getch();

36. return 0;

37. }

38.

39. void Burbuja(int n, float x[])

40. {int i,j;

41. float aux;

42. for(i=1; i<n; i++)

43. for(j=n-1; j>=i; j--)

44. if(x[j-1]>x[j])

45. {aux = x[j-1];

46. x[j-1]=x[j];

47. x[j]=aux;

48. }

49.

50. }void LeerArreglo(int n,float array[])

51. { for(int i=0; i<n; i++)

52. {cout<<"\n INGRESE ELEMENTO ["<<i<<"]: "; cin>>array[i];}

53. }

54.

55. void MuestraArreglo(int n, float array[])

56. {int i;

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

58. cout<<"["<<array[i]<<"] ";

59. }

Algoritmo de Ordenamiento Burbuja Mejorado:

El algoritmo de burbuja mejorado es la optimizacion

del burbuja normal, este algoritmo es igual al burbuja
normal sino que tiene unas pequeñas modificaciones
para evitar que sus dos for sigan recorriendo cuando
los números ya están ordenados.

Para mejorar el algoritmo de burbuja usaremos una

Bandera iniciada en '0' que se activara cuando detecte
que hubo un cambio y pasara al valor '1' y luego con
una intruccion saldremos del for.
 Aqui la Implementacion del Burbuja Mejorado en C++

DATA HOSTED WITH ♥ BY PASTEBIN.COM - DOWNLOAD RAW - SEE ORIGINAL

1. /*
2. Ejercicio: Algoritmo de Ordenacion Burbuja Mejorado
3. Autor: Joel Fernandez
4. Fecha: 13/06/2014 8:45 p.m.
5. IDE: CodeBlocks
6. Pagina Web: http://codebotic.blogspot.com
7. Descripcion: Implementacion de algoritmo Bubble Sort Mejorado en C++
8. */
9.
10. #include<iostream>
11. #include<conio.h>
12. #include<cstdlib>
13. #define MAX 50
14.
15. using namespace std;
16. void LeerArreglo(int,float []);
17. void BurbujaMejorado(int,float []);
18. void MuestraArreglo(int,float []);
19.
20. int main(void)
21. {
22. system("color 0a");
23. float Numeros[MAX];
24. int n;
25. cout<<"\t****************************************************\n";
26. cout<<"\t*** ALGORITMO DE ORDENAMIENTO BURBUJA MEJORADO ***\n";
27. cout<<"\t*** ------------------------------------------ ***\n";
28. cout<<"\t****************************************************\n\n\n";
29.
30. cout<<"\n\nNUMERO DE DATOS A LEER:"; cin>>n;
31.
32. LeerArreglo(n,Numeros); //ingreso de datos en array
33. BurbujaMejorado(n,Numeros); // ordena por burbuja Mejorado
34. cout<<endl<<"\n\n LOS ELEMENTOS FUERON ORDENADOS \n\n"<<endl;
35. MuestraArreglo(n,Numeros); //muestra array ordenado
36.
37.
38. getch();
39. return 0;
40. }
41.
42. void BurbujaMejorado(int n, float x[])
43. {
44. int i,j, bandera;
45. float aux;
46. for(i=1; i<n; i++)
47. {bandera=0; //inciamos la bandera en 0
48. for(j=n-1; j>=i; j--)
49. {if(x[j-1]>x[j])
50. {aux = x[j-1];
51. x[j-1]=x[j];
52. x[j]=aux;
53. bandera=1; //si hubo cambio cambiamos la bandera a 1
54. }
55. }
56. if (bandera==0)
57. break; //si no hubo cambios entonces salir del for
58. }
59. }
60.
61. void LeerArreglo(int n,float array[])
62. { for(int i=0; i<n; i++)
63. {cout<<"\n INGRESE ELEMENTO ["<<i<<"]: "; cin>>array[i];}
64. }
65.
66. void MuestraArreglo(int n, float array[])
67. {int i;
68. for(i=0; i<n; i++)
69. cout<<"["<<array[i]<<"] ";
70. }

Espero que les sea de ayuda, y recuerden que

comentar es agradecer.

Tipos de ordenamiento
Ordenamiento por inserción
Para poder explicar lo haremos con un ejemplo simple. El arreglo tiene 10 elementos
desordenados como lo vemos aquí:

Lo que vamos a hacer es comparar el segundo elemento con el primero. Si es menor,

los intercambio y si no, lo dejo como está y avanzo al siguiente elemento. En este
caso 10 es mayor a 3 así que no hago nada. Esto se puede ver en esta figura:

Ahora va el tercer elemento. Lo comparo con el segundo y veo que es menor así que
los intercambio. Luego lo comparo con el primero y también es menor así que los
intercambio. Como ya es el primer elemento, ahí le paro (es el menor de todos los
que he revisado hasta ahorita). Este proceso lo pueden ver en estas figuras:

Ahora vamos con el cuarto elemento (el 8) y lo comparo con el tercero (10). Como
es menor los intercambio y lo comparo con el segundo (3). Como no es
menor, ahí se queda. Estas son las imágenes:

Ahora hago lo mismo con el quinto elemento (15) el cual no se mueve por ser mayor
que el cuarto (10) como se ve aquí:

REPORT THIS AD
Lo mismo con el sexto (5):

Ahora con el séptimo:

Y ahora el octavo:

Ahora el noveno. Fíjate que como el 5 está repetido en la posición 3, no lo sustituye

y se queda en la posición 4 como se ve en estas imágenes:
Y ahora con el último elemento:

Y al final queda el arreglo listo:

Ordenamiento Burbuja
Consiste en ciclar repetidamente a través de la lista, comparando elementos
adyacentes de dos en dos. Si un elemento es mayor que el que está en la
siguiente posición se intercambian.

Vamos a ver un ejemplo. Esta es nuestra lista:

4–3–5–2–1

Tenemos 5 elementos. Es decir, TAM toma el valor 5. Comenzamos comparando el

primero con el segundo elemento. 4 es mayor que 3, así que intercambiamos. Ahora
tenemos:

3–4–5–2–1
Ahora comparamos el segundo con el tercero: 4 es menor que 5, así que no hacemos
nada. Continuamos con el tercero y el cuarto: 5 es mayor que 2. Intercambiamos y
obtenemos:

3–4–2–5–1

Comparamos el cuarto y el quinto: 5 es mayor que 1. Intercambiamos nuevamente:

3–4–2–1–5

REPORT THIS AD

Repitiendo este proceso vamos obteniendo los siguientes resultados:

3–2–1–4–5

2–1–3–4–5

1–2–3–4–5

Ordenamiento por Selección

El algoritmo de ordenación por método de selección directa es relativamente sencillo
y fácil de recordar e implementar. Se basa en realizar varias pasadas, intentando
encontrar en cada una de ellas el elemento que según criterio de ordenación es
mínimo y colocando posteriormente en su sitio.

Este algoritmo se basa en hacer comparaciones, así que para que realice su trabajo
de ordenación son imprescindibles dos cosas: Un array o estructura similar de
elementos comparables y un criterio claro de comparación, ta que dados dos
elementos nos diga si están en orden o no.

Explicación:
Su funcionamiento es el siguiente:

 Buscar el mínimo o máximo elemento de la lista

 Intercambiarlo con el primero
 Buscar el mínimo o el máximo en el resto de la lista
 Intercambiarlo con el segundo
Y en general:

 Buscar el mínimo o máximo elemento entre una posición i y el final de la lista

 Intercambiar el mínimo o máximo con el elemento de la posición i.
 Ordenamiento QuickSort
Es el ordenamiento más veloz y eficiente de los métodos de ordenación interna, es
un algoritmo basado en la técnica divide y vencerás .

1. Elegir un elemento de la lista de elementos a ordenar, al que llamaremos pivote.

2. La idea central de este algoritmo consiste en los siguiente: Se toma un elemento x de una
posición cualquiera del arreglo. Se trata de ubicar a x en la posición correcta del arreglo,
de tal forma que todos los elementos que se encuentran a su izquierda sean menores o
iguales a x y todos los elementos que se encuentren a su derecha sean mayores o iguales
a x. Se repiten los pasos anteriores pero ahora para los conjuntos de datos que se
encuentran a la izquierda y a la derecha de la posición correcta de x en el arreglo.
3. Resituar los demás e elementos de la lista a cada lado del pivote, de manera que a un
lado queden todos los menores que él, y al otro los mayores. En este momento, el pivote
ocupa exactamente el lugar que le corresponderá en la lista ordenada.
4. Repetir este proceso de forma recursiva para cada sublista mientras éstas contengan más
de un elemento. Una vez terminado este proceso todos los elementos estarán ordenados.
5. Como se puede suponer, la eficiencia del algoritmo depende de la posición en la que
termine el pivote elegido.
REPORT THIS AD

Ordenamiento Shell Sort

El algoritmo de ordenación Shell Sort se basa en el algoritmo de ordenación por
inserción, el cuál tiene un muy buen desempeño si el vector está relativamente
ordenado. Entonces, teniendo esto como premisa, el Shell Sort, ordena por
inserción subconjuntos del vector que están separados entre sí por distancias
relativamente mayores (empezando con distancias iguales a la mitad del tamaño del
vector), la cuales se van reduciendo rápidamente.

Supongamos un vector de elementos

4 12 16 24 36 3
En el método de inserción directa, los saltos se hacen de una posición en una posición
y se necesitaran cinco comparaciones. En el método de Shell, si los saltos son de dos
posiciones, se realizaran comparaciones.

4 12 16 24 36 3

El método se basa en tomar como salto N/2 (siendo N el numero de elementos) y

luego reduciendo a la mitad en cada repetición hasta que el salto o distancia vale 1

Considerando la variable salto, se tendría para el caso de un determinado vector X

los siguientes recorridos:

Vector X [X[1], X[3], …,X[N]]

Vector X1 [X[1], X[1] + salto, X[2], …]

Vector XN [salto1, salto2, salto3, …]

EJEMPLO :

REPORT THIS AD

Deducir las secuencias parciales de clasificación por el método de Shell para

ordenar en ascendente la lista o vector.

6, 1, 5, 2, 3, 4, 0

RECORRIDO SALTO LISTA REORDENADA INTERCAMBIO

1 3 2,1,4,5,0,3,5,6 (6,2), (5,4), (6,0)

2 3 0,1,4,2,3,5,6 (2,0)

3 3 0,1,4,2,3,5,6 NINGUNO

4 1 0,1,2,3,4,5,6 (4,2),(4,3)

5 1 0,1,2,3,4,5,6 NINGUNO

Ordenamiento HeapSort.
Su desempeño es en promedio tan bueno como el Quicksort y se comporta mejor que
este último en los peores casos. Aunque el Heapsort tiene un mejor desempeño
general que cualquier otro método presentado de clasificación interna, es bastante
complejo de programar. El Heapsort fue desarrollado en 1964 por J. W. J. Williams.

El Heapsort está basado en el uso de un tipo especial de árbol binario (llamado

apilamiento) para estructurar el proceso de ordenamiento. La estructura de
ramificación del árbol conserva el número de comparaciones necesarias
en .

La estructura de este árbol tiene las siguientes características:

» Las llaves están acomodadas en los nodos de tal manera que, para cada nodo i,
Ki <= Kj donde el nodo j es el padre del nodo i. Es decir, al recorrer el camino desde
la raíz hacia abajo, las claves se encuentran en orden descendente.

»El árbol se llena de izquierda a derecha, lo que implica que si algún(os) nodo(s) no
está(n) en el mismo nivel que el resto, éste(os) estará(n) entonces lo más a la
izquierda posible del árbol.

Veamos gráficamente un ejemplo de este tipo de árbol:

Al enumerar los nodos por niveles, de izquierda a derecha (como se aprecia en la

figura), no es necesario usar punteros para almacenar el árbol.

En efecto, se puede usar un arreglo A[1..n], donde los hijos de A[i] son A[2*i] y
A[condición del Heap se puede re-formular:

A[i] > A[2*i]

A[i] > A[2*i+1]

Luego un vector con las llaves quedaría de la siguiente forma:

73 – 50 – 36 – 21 – 46 – 27 – 9 – 18 – 10 – 30
PUBLICIDAD

Ordenamiento de burbuja
Espacios de nombres
 Página

 Discusión

Acciones de página
 Ver
  Ver código

 Historial

Algoritmo de Ordenamiento de burbuja

ordenamiento.
Burbuja(Bubble Sort en
inglés) es un sencillo
algoritmo de ordenamiento.
Funciona revisando cada
elemento de la lista que va a
ser ordenada con el
siguiente, intercambiándolos
de posición si están en el
orden equivocado. Es
necesario revisar varias
veces toda la lista hasta que
no se necesiten más
intercambios, lo cual significa
que la lista está ordenada.
Este algoritmo obtiene su
Concepto: Algoritmo que pone elementos de una lista o
nombre de la forma con la
que suben por la lista los un vector, en una secuencia dada por una
elementos durante los relación de orden
intercambios, como si fueran
pequeñas burbujas. También es conocido como el método del intercambio directo.
Dado que solo usa comparaciones para operar elementos, se lo considera un
algoritmo de comparación, siendo el más sencillo de implementar.

Sumario
[ocultar]

 1 Descripción
 2 Análisis del Costo Computacional
 3 Aplicación
 4 Implementación
 5 Ver además
 6 Fuentes

Descripción
El procedimiento de la burbuja es el siguiente: § Ir comparando desde la casilla 0
número tras número hasta encontrar uno mayor, si este es realmente el mayor de
todo el vector se llevará hasta la última casilla, si no es así, será reemplazado por uno
mayor que él. § Este procedimiento seguirá así hasta que haya ordenado todas las
casillas del vector. § Una de las deficiencias del algoritmo es que ya cuando a
ordenado parte del vector vuelve a compararlo cuando esto ya no es necesario.

Dado un vector a1, a2, a3, ... an 1) Comparar a1 con a2 e intercambiarlos si a1>a2 (o
a12) 2) Seguir hasta que todo se haya comparado an-1 con an 3) Repetir el proceso
anterior n-1 veces
Algoritmo: Complejidad for(i=0; i < n-++){ T(n2)

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

if(vec[j] > vec[j+1]){ T(1)
aux=vec[j]; T(1)
vec[j]=vec[j+1]; T(1)
vec[j+1]=aux;} T(1)
} }

El siguiente ejemplo muestra el proceso de forma gráfica:

Análisis del Costo Computacional

Al algoritmo de la burbuja, para ordenar un vector de n términos, tiene que realizar
siempre el mismo número de comparaciones:
Esto es, el número de comparaciones c(n) no depende del orden de los términos, si
no del número de términos.

Por lo tanto la cota ajustada asintótica del número de comparaciones pertenece al

orden de n cuadrado. El numero de intercambios i(n), que hay que realizar depende
del orden de los términos y podemos diferencia, el caso mejor, si el vector esta
previamente ordenado, y el caso peor, si el vector esta ordenado en orden inverso.

Por lo que no se puede determinar una cota ajustada asintótica del número de
intercambios, dado que este dependerá del orden del vector en cuestión.
Rendimiento en el caso desfavorable
Si pasamos al algoritmo un vector ordenado en orden inverso realizara un número de
comparaciones:

Como ya hemos dicho anteriormente, y tendrá que realizar un número igual de

intercambios entre los términos del vector, dado que en cada comparación los
términos estarán desordenados, y se realizará el intercambio.

Por lo tanto en el caso más desfavorable tanto el número de comparaciones como el

de intercambios coinciden:
El número de comparaciones o de intercambios en el caso más desfavorable
pertenece al orden de n cuadrado.
Rendimiento en casos óptimos
En el caso óptimo, el más favorable, es la ordenación que un vector ya ordenado, en
este caso el número de comparaciones será el mismo que en cualquier otro caso:

La cota inferior asintótica del número de comparaciones pertenece al orden

de n cuadrado, como en los demás casos, pero en todas las comparaciones el orden
es el correcto y por tanto no se realiza ningún intercambio:

Por lo tanto el coste de intercambios no depende de n, y es constante:

El ordenamiento de burbuja tiene una complejidad Ω(n²) igual que ordenamiento por
selección. Cuando una lista ya está ordenada, a diferencia del ordenamiento por
inserción, que pasará por la lista una vez y encontrará que no hay necesidad de
intercambiar las posiciones de los elementos, el método de ordenación por burbuja
está forzado a pasar por dichas comparaciones, lo que hace que su complejidad sea
cuadrática en el mejor de los casos. Esto lo cataloga como el algoritmo más
ineficiente que existe, aunque para muchos programadores sea el más sencillo de
implementar.

Aplicación
A pesar de que el ordenamiento de burbuja es uno de los algoritmos más sencillos de
implementar, su orden O(n2) lo hace muy ineficiente para usar en listas que tengan
más que un número reducido de elementos. Incluso entre los algoritmos de
ordenamiento de orden O(n2), otros procedimientos como el ordenamiento por
inserción son considerados más eficientes. Dada su simplicidad, el ordenamiento de
burbuja es utilizado para introducir el concepto de algoritmo de ordenamiento para
estudiantes de ciencias de la computación. A pesar de esto, algunos investigadores
como Owen Astrachan han criticado su popularidad en la enseñanza de ciencias de la
computación, llegando a recomendar su eliminación de los planes de estudio. Sumado
a esto, Jargon File, un libro ampliamente citado en la cultura hacker, lo denomina "el
mal algoritmo genérico", y Donald Knuth, uno de los mayores expertos en ciencias de
la computación, afirma que el ordenamiento de burbuja "no parece tener nada para
recomendar su uso, a excepción de un nombre pegajoso y el hecho de que conlleva a
problemas teóricos interesantes". El ordenamiento de burbuja es asintóticamente
equivalente, en tiempos de ejecución, con el ordenamiento por inserción en el peor de
los casos, pero ambos algoritmos difieren principalmente en la cantidad de
intercambios que son necesarios. Resultados experimentales como los descubiertos
por Astrachan han demostrado que el ordenamiento por inserción funciona
considerablemente mejor incluso con listas aleatorias. Por esta razón, muchos libros
de algoritmos modernos evitan usar el ordenamiento de burbuja, reemplazándolo por
el ordenamiento por inserción. El ordenamiento de burbuja interactúa vagamente con
el hardware de las CPU modernas. Requiere al menos el doble de escrituras que el
ordenamiento por inserción, el doble de pérdidas de cache, y asintóticamente más
predicción de saltos. Varios experimentos de ordenamiento de cadenas en Java
hechos por Astrachan muestran que el ordenamiento de burbuja es 5 veces más lento
que el ordenamiento por inserción, y 40% más lento que el ordenamiento por
selección.

Implementación
A continuación se muestra el Ordenamiento de burbuja en algunos de los lenguajes
de programación más usados:

 C

//Ordenamiento por método de la Burbuja void ordenamientoBurbuja(int v[], int util_v) {

int temp, i, j;

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

for (j = i + 1; j < util_v ; j++) {
if (v[i] > v[j]) {
temp = v[i];
v[i] = v[j];
v[j] = temp;
}
}
} }

 C++

template<typename _Ty> void bubble_sort(vector<_Ty> & v){

 for (size_t i = 0; i < v.size() - 1; ++i){
for (size_t j = i + 1; j < v.size(); ++j){
if (v[i] > v[j])
swap(v[i], v[j]);
}
}

 C#

Public int[] OrdenarBurbuja(int[]x)

{
int t= x.Length, temp;
for(int i=1 ; i< t ; i++)
for(int j = t-1 ; j >= i; j--)
{
if(x[j] < x[j-1])
{
temp= x[j];
x[j]= x[j-1];
x[j-1]= temp;
}
}
return x;
}

 Java

//Ordenamiento por Burbuja

// by ramses2999
publicstatic int[] OrdenarBurbuja(int[] n){
int temp;
int t = n.length;
for (int i = 1; i < t; i++) {
for (int k = t- 1; k >= i; k--) {
if(n[k] < n[k-1]){
temp = n[k];
n[k] = n[k-1];
n[k-1]= temp;
}//fin if
}// fin 2 for
}//fin 1 for
 return n;
}//fin

 Perl

sub bubblesort {

# Ordena la lista pasada como argumento por valor

for my $i ( 0 .. @_-2 ) {
for my $j ( $i+1 .. @_-1 ) {
@_[ $i, $j ] = @_[ $j, $i ] if $_[$i] > $_[$j];
}}

 Visual Basic

Private Sub OrdenarBurbuja(ByRef VectorOriginal() As Integer)

Dim Temp, Longitud As Integer
Longitud = UBound(VectorOriginal) - 2
For b = 0 To Longitud
For a = 0 To Longitud
If VectorOriginal(a) > VectorOriginal(a + 1) Then
Temp = VectorOriginal(a + 1)
VectorOriginal(a + 1) = VectorOriginal(a)
VectorOriginal(a) = Temp
EndIf
Next
Next
End Sub

 PHP

<?php

//Ordenamiento por burbuja $numeros = array(9, 4, -1, 7, 8, 11, 6, 12, 10, 5);

$n = count($numeros);

for ($i = 1; $i<$n; $i++) {

for ($j = $n-1; $j >= $i; $j--) {

 echo "i: $i, j: $j\n";
echo "Comparando " . $numeros[$j-1] . " y " . $numeros[$j] .
"\n";
if ($numeros[$j-1] > $numeros[$j]) {
$aux = $numeros[$j];
$numeros[$j] = $numeros[$j-1];
$numeros[$j-1] = $aux;
}
}

print_r($numeros);

 Pascal

Procedure Burbuja(var lista:vector;size:integer); var i,j:integer;

begin

for i:=1 to size-1 do

for j:=1 to size-i do
begin
if lista[j]>lista[j+1] then
begin
aux:=lista[j];
lista[j]:=lista[j+1];
lista[j+1]:=aux
end;
end;

end;

Ver además
 Algoritmo de ordenamiento
 Algoritmo de búsqueda
 Algoritmo de Kruskal
 Algoritmo de Euclides
 Algoritmo de Prim
 Algoritmo de Boruvka
 Algoritmo de Gutmann
 Algoritmo criptográfico
  Algoritmo
 Algoritmo de Ordenamiento Shell
 Algoritmo genético
 Algoritmo de ordenamiento por selección
 Algoritmo de árboles de decisión de Microsoft
 Algoritmo de Búsqueda Heurística A*
 Algoritmo asimétrico

Fuentes
 Aprenda C/C++.
 Estructuras de datos.
 Wikipedia.

 Normativa de privacidad

 EcuRed

 Exoneraciones

 Inicio
 Tips and Tricks
 Ordenamiento por burbuja

Ordenamiento por burbuja

Es un sencillo algoritmo de ordenamiento. Funciona comparando cada elemento de la lista

que va a ser ordenada con el siguiente, intercambiándolos de posición si están en el orden
equivocado.

Es necesario recorrer varias veces toda la lista hasta que no se necesiten más intercambios,
es decir, la lista ya se ha ordenado. Este algoritmo obtiene su nombre de la forma con la que
suben por la lista los elementos durante los intercambios, como si fueran pequeñas
"burbujas". Como solo se usan comparaciones entre elementos, es considerado un
algoritmo de comparación, siendo uno de los más sencillos de implementar.

Aunque en JavaScript, los objetos arrays disponen del método sort() para ordenar
elementos, pero en esta ocasión no lo vamos a utilizar ya que lo que pretendemos es
mostrar como se implementa el algoritmo de burbuja en JavaScript.
En el ejemplo siguiente se declara un array de 15 números desordenados. Utilizando el
método de burbuja simple, se ordena la lista.

function Burbuja() {

var lista = [389, 703, 247, 563, 224, 714, 464, 953, 708, 201, 887, 550, 515, 206,
131];

var n, i, k, aux;

n = lista.length;

console.log(lista); // Mostramos, por consola, la lista desordenada

// Algoritmo de burbuja

for (k = 1; k < n; k++) {

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

if (lista[i] > lista[i + 1]) {

aux = lista[i];

lista[i] = lista[i + 1];

lista[i + 1] = aux;

}
 }

console.log(lista); // Mostramos, por consola, la lista ya ordenada

Burbuja Optimizado
Implementa una mejora al método de ordenamiento burbuja. Este método
recorre todo el arreglo comparando cada uno de los elementos con el
elemento siguiente e intercambiándolo de ser necesario. Al finalizar la
iteración el elemento mayor queda ubicado en la última posición, mientras
los elementos menores ascienden una posición.

La mejora es que, como al final de cada iteración el elemento mayor queda

situado en su posición, ya no es necesario volverlo a comparar con ningún
otro número, reduciendo así el número de comparaciones por iteración.

Ejemplo:
Algoritmo de burbuja optimizado
public static int[] ordenacionBurbuja(int vec[]){
final int N=vec.length;
for(int i=N-1;i>0;i--){
for(int j=0;j<i;j++){
if(vec[j]>vec[j+1]){
int temp=vec[j];
vec[j]=vec[j+1];
vec[j+1]=temp;
}
}
System.out.print("iteracion: "+(N-i)+":
");imprimirVector(vec);System.out.println();
}
return vec;
 }

Implementación
public class BurbujaOptimizado {

public static void main(String[] args) {

int vec[]={45,17,23,67,21};
System.out.println("Vector original");
imprimirVector(vec);
System.out.println("\n");
vec=ordenacionBurbuja(vec);
imprimirVector(vec);
}

public static int[] ordenacionBurbuja(int vec[]){

final int N=vec.length;
for(int i=N-1;i>0;i--){
for(int j=0;j<i;j++){
if(vec[j]>vec[j+1]){
int temp=vec[j];
vec[j]=vec[j+1];
vec[j+1]=temp;
}
}
System.out.print("iteracion: "+(N-i)+":
");imprimirVector(vec);System.out.println();
}
return vec;
}

public static void imprimirVector(int vec[]){

for(int i=0;i<vec.length;i++){
System.out.print(vec[i]+" ");
}
}

}
Método de Ordenamiento Burbuja en C#
Este método consiste en ir comparando cada par de elementos del array e ir moviendo el mayor
elemento hasta la última posición, comenzando desde la posición cero. Una vez acomodado el
mayor elemento, prosigue a encontrar y acomodar el segundo más grande comparando de
nuevo los elementos desde el inicio de la lista, y así sigue hasta ordenar todos los elementos
del arreglo. Al ser necesario revisar varias veces toda la lista hasta que no se necesiten más
intercambios, hace que el ordenamiento por burbuja sea uno de los algoritmos más ineficientes
que existen. Incluso entre los algoritmos de ordenamiento del mismo orden, otros como el
“Ordenamiento por inserción” son considerados más eficientes. Y lo más curioso es que este
procedimiento es uno de los más usados para ordenar listas en todos los lenguajes de
programación.

Estos serían los pasos a seguir por este algoritmo para ordenar una lista a1, a2, a3, … an
1) Comparar a1 con a2 e intercambiarlos si a1>a2
2) Seguir hasta que se haya comparado an-1 con an
3) Repetir el proceso anterior n-1 veces

Ejemplo:
 25 57 48 37 12 92 86 33

En el primer paso se realizan las siguientes operaciones:

x[0] con x[1] (25 con 57) no intercambio.

x[1] con x[2] (57 con 48) intercambio.
x[2] con x[3] (57 con 32) intercambio.
x[3] con x[4] (57 con 12) intercambio.
x[4] con x[5] (57 con 92) no intercambio.
x[5] con x[6] (92 con 86) intercambio.
x[6] con x[7] (92 con 33) intercambio.

Así después del primer paso, el arreglo está en el siguiente orden:

25 48 37 12 57 86 33 92

Observe que después del primer paso, el elemento mayor (en este caso 92) está en la posición
correcta dentro del arreglo. En general x[n-i] estará en su posición correcta después de la
iteración i. El método se lama ordenamiento de burbuja porque cada número “burbujea” con
lentitud hacia su posición correcta. El conjunto completo de iteraciones es:

iteración 0 : 25 57 48 37 12 92 86 33
iteración 1: 25 48 37 12 57 86 33 92
iteración 2: 25 37 12 48 57 33 86 92
iteración 3: 25 12 37 48 33 57 86 92
iteración 4: 12 25 37 33 48 57 89 92
iteración 5: 12 25 33 37 48 57 89 92

A continuación veamos un ejemplo en Pseudo-Código Para el Método Burbuja

Ejemplo del Método de Ordenamiento Burbuja en C#
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace Burbuja
{
class Burbuja
{
private int[] vector;

public void Cargar()

{
Console.WriteLine("Metodo de Burbuja");
Console.Write("Cuantos longitud del vector: ");
string linea;
 linea = Console.ReadLine();
int cant;
cant = int.Parse(linea);
vector = new int[cant];
for (int f = 0; f < vector.Length; f++)
{
Console.Write("Ingrese elemento "+(f+1)+": ");
linea = Console.ReadLine();
vector[f] = int.Parse(linea);
}
}

public void MetodoBurbuja()

{
int t;
for (int a = 1; a < vector.Length; a++)
for (int b = vector.Length - 1; b >= a; b--)
{
if (vector[b - 1] > vector[b])
{
t = vector[b - 1];
vector[b - 1] = vector[b];
vector[b] = t;
}
}
}

public void Imprimir()

{
Console.WriteLine("Vector ordenados en forma ascendente");
for (int f = 0; f < vector.Length; f++)
{
Console.Write(vector[f]+" ");
}
Console.ReadKey();
}

static void Main(string[] args)

{
Burbuja pv = new Burbuja();
pv.Cargar();
pv.MetodoBurbuja();
pv.Imprimir();
}
}
}

Al ejecutar el código muestra el siguiente resultado

Etiquetas: burbuja en c#, c#, c# burbuja, c# métodos de ordenamiento, ejemplo de burbuja en c#, método de
ordenamiento burbuja en c#, métodos de ordenamiento en c#

 Ejercicios
 Principal
 A2
 Acerca
 Acerca De
 Actualmente
 Alcohol Treatment
 Alcoholism
 Algoritmo
 Almacenar

4 comentarios:
1.

Unknown6 de noviembre de 2018, 13:37

Como mostrar en pantalla cada una de las pasadas?

Responder

2.

Hector rasura fragozo28 de marzo de 2019, 13:49

Pones un contador en cada uno de los For y luego los sumas, o bien puedes poner
uno como comparaciones y otro como intercambios.
Responder

3.

Unknown19 de abril de 2019, 20:32

porque me manda error en el numero 57

Responder

4.

Unknown23 de junio de 2019, 17:40

 buena pero el no ejecutar
Responder
Entrada más recienteEntrada antiguaPágina principal
Suscribirse a: Enviar comentarios (Atom)

Método de Ordenamiento Burbuja

Método de Ordenamiento Burbuja

La Ordenación de burbuja es un sencillo algoritmo de ordenamiento. Funciona revisando cada elemento de la lista que va a ser ordenada
con el siguiente, intercambiándolos de posición si están en el orden equivocado. Es necesario revisar varias veces toda la lista hasta que no
se necesiten más intercambios, lo cual significa que la lista está ordenada. Este algoritmoobtiene su nombre de la forma con la que suben
por la lista los elementos durante los intercambios, como si fueran pequeñas "burbujas". También es conocido como el método del
intercambio directo. Dado que solo usa comparaciones para operar elementos, se lo considera un algoritmo de comparación, siendo el más
sencillo de implementar.

'Esta es la estructura de burbuja en Visual Basic.

1. for (i=1; i<TAM; i++)

2. for j=0 ; j<TAM - 1; j++)
3. if (lista[j] > lista[j+1])
4. temp = lista[j];
5. lista[j] = lista[j+1];
6. lista[j+1] = temp;

Este es un programa de es uno de vectores que usa 10 números y los ordena depende su valor por
ejemplo si el "numero>0 o numero<0 o si numero=0" con el método de burbuja marcando el
resultado con distintos colores.

Module Module1

'declaramos los vectores como enteros "INTEGER"

Dim numeros(9) As Integer
Sub Main()
'mostramos un mensaje que nos pida los vectores con "WRITELINE"
Console.WriteLine("lenando vectores")
'Creamos una variable que represente a los números a ingresar en este caso "contador" y
la declaramos como entero dentro de la etiqueta "For" y decimos que contador = 0 asta 9.
For contador As Integer = 0 To 9 Step 1
' mostramos el mensaje que diga que ingrese un numero de esta
forma se guardaran los números de 0 a 5
Console.WriteLine("ingrese numero{0}", contador)
numeros(contador) = Console.ReadLine() => Guardamos los números ingresados.
'Serramos el For con un next.
Next
'creamos un "console.clear()" para declarar los "public sub()"
Console.Clear()
metodoseleccion()
ColorearNumeros()
Console.ReadLine()
'Cerramos el "sub main()"
 End Sub
'y abrimos un sub public() para clasificar los números por denominación >,<,= a 0
Public Sub ColorearNumeros()
'Para clasificar los números de (n>0)(n=0)(n<0) creamos condicionales pero
antes escribimos un mensaje que nos poda los números con un "WRITELINE" y creamos un
"FOR" para leer el contador ingresado.
Console.WriteLine("colorear numeros")
For contador As Integer = 0 To 9 Step 1
' Para crear una condicional bamos a utilizar un "IF" y colocamos si el (numero >0)
If numeros(contador) > 0 Then
'Con esta la etiqueta console.foregroundcolor, vamos a pintar de color los números y en el
"ConsoleColor" colocamos el color requerido, con el console.writeline seleccionara todos
los números >0
Console.ForegroundColor = ConsoleColor.Green
console.writeline seleccionara todos los números >0
Console.WriteLine("{0}", numeros(contador))
Si hay números que no cumplan con la condición anterior colocamos un "else if" y colocamos otro
if para que selecciones los (numero =0)
End If
If numeros(contador) = 0 Then
colocamos el color requerido para este tipo de valor numérico
Console.ForegroundColor = ConsoleColor.White
console.writeline seleccionara todos los números =0
Console.WriteLine("{0}", numeros(contador))
End If
If numeros(contador) < 0 Then
Si hay números que no cumplan con la condición anterior colocamos un "else if" y colocamos otro
if para que selecciones los (numero <0)
Console.ForegroundColor = ConsoleColor.Red
console.writeline seleccionara todos los números <0
Console.WriteLine("{0}", numeros(contador))
cerramos las condiciones y el public sub()
End If
Next
End Sub
Hora abrimos un public para colocar el proceso de ordenamiento de seleccion.
Public Sub metodoburbuja()
Declaramos los datos que vamos a usar
Dim aux As Double
Dim i, j As Integer
y colocamos el código de inserción de visual, ahora ya solo debemos llenar la formula con los datos del vector.
For i = 1 To numeros.Length - 1
For j = 0 To numeros.Length - i - 1
If (numeros(j) > numeros(j + 1)) Then
aux = numeros(j + 1)
numeros(j + 1) = numeros(j)
numeros(j) = aux
End If
Next
Next
End Sub
End Module

código:
le damos play y introducimos datos
NOTA :
Sino comprenden el funcionamiento de alguna etiqueta visita
Herramientas Básicas en buscador del sitio.
Publicado 12th May 2013 por Unknown

1
Ver comentarios