|
| 1 | +# Bubble Sort |
| 2 | + |
| 3 | +#### Planteamiento del problema |
| 4 | + |
| 5 | +Dado un arreglo desordenado de n elementos, escribir una función que ordene el arreglo. |
| 6 | + |
| 7 | +#### Procedimiento |
| 8 | + |
| 9 | +- Seleccionar el primer elemento del arreglo. |
| 10 | +- Comparar con el elemento siguiente. |
| 11 | +- Si es más grande que el elemento siguiente se intercambian. |
| 12 | +- Sino no se hace nada. |
| 13 | +- Realizar las operaciones anteriores para cada elemento del arreglo. |
| 14 | +- Repetir el procedimiento descrito n veces. |
| 15 | + |
| 16 | +#### Complejidad en Orden de Tiempo |
| 17 | + |
| 18 | +O(n^2) Rendimiento en el peor de los casos |
| 19 | + |
| 20 | +O(n) Rendimiento en el mejor de los casos |
| 21 | + |
| 22 | +O(n^2) Rendimiento promedio |
| 23 | + |
| 24 | +#### Complejidad en Orden de Espacio |
| 25 | + |
| 26 | +O(1) Peor caso |
| 27 | + |
| 28 | +#### Nombre del creador del algoritmo |
| 29 | + |
| 30 | +- |
| 31 | + |
| 32 | +#### Ejemplo |
| 33 | + |
| 34 | +``` |
| 35 | +arreglo[] = {10, 80, 40, 30} |
| 36 | +Indices: 0 1 2 3 |
| 37 | +
|
| 38 | +1. Indice = 0, Numero = 10 |
| 39 | +2. 10 < 80, No se hace nada. Continuar |
| 40 | +
|
| 41 | +3. Indice = 1, Numero = 80 |
| 42 | +4. 80 > 40, intercambiar 80 y 40 |
| 43 | +5. El arreglo ahora es {10, 40, 80, 30} |
| 44 | +
|
| 45 | +6. Indice = 2, Numero = 80 |
| 46 | +7. 80 > 30, intercambiar 80 y 30 |
| 47 | +8. El arreglo ahora es {10, 40, 30, 80} |
| 48 | +
|
| 49 | + Repetir los pasos de arriba. |
| 50 | +
|
| 51 | +arreglo[] = {10, 40, 30, 80} |
| 52 | +Indices: 0 1 2 3 |
| 53 | +
|
| 54 | +1. Indice = 0, Numero = 10 |
| 55 | +2. 10 < 40, No se hace nada. Continuar |
| 56 | +
|
| 57 | +3. Indice = 1, Numero = 40 |
| 58 | +4. 40 > 30, intercambiar 40 y 30 |
| 59 | +5. El arreglo ahora es {10, 30, 40, 80} |
| 60 | +
|
| 61 | +6. Indice = 2, Numero = 40 |
| 62 | +7. 40 < 80, No se hace nada. Continuar |
| 63 | +8. El arreglo ahora es {10, 30, 40, 80} |
| 64 | +
|
| 65 | + Repetir los pasos de arriba. |
| 66 | +
|
| 67 | +arreglo[] = {10, 30, 40, 80} |
| 68 | +Indices: 0 1 2 3 |
| 69 | +
|
| 70 | +1. Indice = 0, Numero = 10 |
| 71 | +2. 10 < 30, No se hace nada. Continuar |
| 72 | +
|
| 73 | +3. Indice = 1, Numero = 30 |
| 74 | +4. 30 < 40, No se hace nada. Continuar |
| 75 | +
|
| 76 | +5. Indice = 2, Numero = 40 |
| 77 | +6. 40 < 80, No se hace nada |
| 78 | +
|
| 79 | + Como no hay intercambios en los pasos de arriba, el arreglo ya se ha ordenado y nos podemos detener. |
| 80 | +
|
| 81 | +
|
| 82 | + ``` |
| 83 | + |
| 84 | + |
| 85 | +#### Enlaces a implementaciones de código |
| 86 | + |
| 87 | +- [Java](https://github.com/TheAlgorithms/Java/blob/master/Sorts/BubbleSort.java) |
| 88 | +- [C++](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/Sorting/Bubble%20Sort.cpp) |
| 89 | +- [Python](https://github.com/TheAlgorithms/Python/blob/master/sorts/bubble_sort.py) |
| 90 | +- [C-Sharp](https://github.com/TheAlgorithms/C-Sharp/blob/master/sorts/bubble_sort.cs) |
| 91 | +- [Go](https://github.com/TheAlgorithms/Go/blob/master/sorts/bubble_sort.go) |
| 92 | +- [Ruby](https://github.com/TheAlgorithms/Ruby/blob/master/Sorting/bubble_sort.rb) |
| 93 | +- [C](https://github.com/TheAlgorithms/C/blob/master/sorting/BubbleSort.c) |
| 94 | +- [Scala](https://github.com/TheAlgorithms/Scala/blob/master/src/main/scala/Sort/BubbleSort.scala) |
| 95 | +- [Javascript](https://github.com/TheAlgorithms/Javascript/blob/master/Sorts/bubblesort.js) |
| 96 | + |
| 97 | + |
| 98 | +#### Explicación en video |
| 99 | + |
| 100 | +[Un video explicando el Algoritmo de Ordenamiento Burbuja](https://www.youtube.com/watch?v=EQMGabLO_M0) |
| 101 | + |
| 102 | +#### Otros |
| 103 | + |
| 104 | +El Ordenamiento Burbuja también es conocido como Sinking sort. |
| 105 | + |
| 106 | +#### Explicación animada |
| 107 | + |
| 108 | +- [Tablero Tute](https://boardhub.github.io/tute/?wd=bubbleSortAlgo2) |
| 109 | + |
0 commit comments