8000 feat: Translate some explanations to Spanish · JSSpagh/Algorithms-Explanation@7039715 · GitHub
[go: up one dir, main page]
Skip to content

Commit 7039715

Browse files
Panquesito7Panquesito7
committed
feat: Translate some explanations to Spanish
1 parent a9658f9 commit 7039715

9 files changed

+601
-0
lines changed

‎es/Algoritmos de Ordenamiento/Ordenamiento Radix.md

Lines changed: 48 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,48 @@
1+
# Ordenamiento Radix
2+
3+
El límite inferior para el algoritmo 8000 de ordenación basado en comparación (Orden de fusión, Ordenación de montón, Ordenación rápida, etc.) es `Ω(nlogn)`, es decir, no pueden hacerlo mejor que `nlogn`.
4+
5+
La ordenación del recuento es un algoritmo de ordenación de tiempo lineal que ordena en el tiempo `O(n+k)` cuando los elementos están en el rango de 1 a k.
6+
7+
¿Qué sucede si los elementos están en el rango de 1 a n2? No podemos usar la ordenación de recuento, porque la ordenación de recuento tomará `O(n2)`, que es peor que los algoritmos de clasificación basados en comparación. ¿Podemos ordenar una matriz de este tipo en tiempo lineal?
8+
9+
Radix Sort es la respuesta. La idea de Radix Sort es hacer orden dígito por dígito a partir de un dígito menos significativo a un dígito más significativo. La ordenación de radios utiliza la ordenación de recuento como subrutina para ordenar.
10+
11+
## El algoritmo de ordenación de radios
12+
13+
Haga lo siguiente para cada dígito i donde varía de un dígito menos significativo al dígito más significativo.
14+
Ordene la matriz de entrada mediante la ordenación de recuento (o cualquier ordenación estable) según el dígito i'th.
15+
16+
Ejemplo:
17+
18+
Lista original y no ordenada:
19+
`170, 45, 75, 90, 802, 24, 2, 66`
20+
21+
Ordenar por el dígito menos significativo (lugar 1s) da:
22+
23+
[*Observe que mantenemos el 802 antes de las 2, porque ocurrió el 802
24+
antes de 2 en la lista original, y de manera similar para los pares
25+
170 &90 y 45 &75.]
26+
27+
Ordenar por el siguiente dígito (lugar de los años 10) da:
28+
29+
[*Observe que 802 de nuevo viene antes de 2 como 802 viene antes de 2 en la lista anterior.]
30+
31+
`802, 2, 24, 45, 66, 170, 75, 90`
32+
33+
La clasificación por el dígito más significativo (lugar de los años 100) da:
34+
`2, 24, 45, 66, 75, 90, 170, 802`
35+
36+
## ¿Cuál es el tiempo de ejecución de Radix Sort?
37+
38+
Deje que haya dígitos `d` en los enteros de entrada. Radix Sort toma `O(d*(n+b))` tiempo donde `b` es la base para representar números, por ejemplo, para el sistema decimal, `b` es 10.
39+
¿Cuál es el valor de `d`? Si `k` es el valor máximo posible, entonces sería `O(logb(k))`. Así que la complejidad general del tiempo es `O((n+b) * logb(k))`. Lo que parece más que el
40+
complejidad horaria de algoritmos de ordenación basados en comparación para una `k` grande. Limitemos primero `k`. Deje `k <= nc` donde `c` es una constante. En ese caso, la complejidad se convierte en
41+
`O(n logb(n))`. Pero todavía no supera los algoritmos de clasificación basados en comparación.
42+
43+
## ¿Radix Sort es preferible a algoritmos de ordenación basados en comparación como Quick-Sort?
44+
45+
Si, tenemos bits `log2n` para cada dígito, el tiempo de ejecución de Radix parece ser mejor que la ordenación rápida para una amplia gama de números de entrada. Los factores constantes ocultos en la notación asintótica, son mayores para Radix Sort y Quick-Sort que utiliza cachés de hardware de forma más eficaz. Además, Radix sort utiliza la ordenación de recuento como una subrutina y la ordenación de recuento
46+
necesita espacio adicional para ordenar los números.
47+
48+
**Vídeo de referencia:** https://youtu.be/nu4gDuFabIM

‎es/Algoritmos de Ordenamiento/Ordenamiento Shell.md

Lines changed: 75 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,75 @@
1+
# Ordenamiento Shell
2+
3+
#### Declaración de problema
4+
5+
Dada una matriz no ordenada de `n` elementos, escriba una función para ordenar la matriz.
6+
7+
#### Enfoque
8+
9+
- Empezar con la brecha inicial, `g`
10+
- Ir a través de los primeros `(n - g)` elementos en la matriz
11+
- Comparar el elemento con el siguiente elemento que está a una distancia `g`
12+
- Intercambiar los dos elementos si el primer elemento es más grande
13+
- Disminuir la brecha y repetir hasta la brecha = 1
14+
15+
#### Complejidad horaria
16+
17+
La complejidad del tiempo depende de las secuencias de separación.
18+
Las complejidades de tiempo inferior se basan en las secuencias de separación de `n/2^k`.
19+
20+
`O(n^2)` Peor rendimiento en el caso
21+
22+
`O(n)` Mejor actuación en el caso
23+
24+
`O(n^2)` Rendimiento medio
25+
26+
#### Complejidad espacial
27+
28+
`O(1)` El peor caso
29+
30+
#### Nombre del Fundador
31+
32+
Donald Shell
33+
34+
#### Ejemplo
35+
36+
```markdown
37+
arr[] = {61, 109, 149, 111, 34, 2, 24, 119}
38+
Brecha inicial: 4
39+
40+
1. Índice = 0, Siguiente índice de elementos = 4
41+
2. 61 > 34, swap 61 y 34
42+
3. La matriz es ahora {34, 109, 149, 111, 61, 2, 24, 119}
43+
44+
4. Índice = 1, Siguiente índice de elementos = 5
45+
5. 109 > 2, swap 109 y 2
46+
6. La matriz es ahora {34, 2, 149, 111, 61, 109, 24, 119}
47+
48+
7. Índice = 2, Siguiente índice de elementos = 6
49+
8. 149 > 24, swap 149 y 24
50+
9. La matriz es ahora {34, 2, 24, 111, 61, 109, 149, 119}
51+
52+
10. Índice = 3, Siguiente índice de elementos = 7
53+
11. 111 < 119, no hagan nada y continúen
54+
55+
12. Divida la brecha por 2 y repita hasta la brecha = 1
56+
```
57+
58+
#### Enlaces de implementación de código
59+
60+
- [Java](https://github.com/TheAlgorithms/Java/blob/master/Sorts/ShellSort.java)
61+
- [C++](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/Sorting/Shell%20Sort.cpp)
62+
- [Python](https://github.com/TheAlgorithms/Python/blob/master/sorts/shell_sort.py)
63+
- [C-Sharp](https://github.com/TheAlgorithms/C-Sharp/blob/master/sorts/shell_sort.cs)
64+
- [Ir](https://github.com/TheAlgorithms/Go/blob/master/sorts/shell_sort.go)
65+
- [Ruby](https://github.com/TheAlgorithms/Ruby/blob/master/Sorting/shell_sort.rb)
66+
- [C](https://github.com/TheAlgorithms/C/blob/master/sorting/shellSort.c)
67+
- [Javascript](https://github.com/TheAlgorithms/Javascript/blob/master/Sorts/shellSort.js)
68+
69+
#### Explicación de vídeo
70+
71+
[Un vídeo explicando el algoritmo del ordenamiento de Shell](https://www.youtube.com/watch?v=H8NiFkGu2PY)
72+
73+
#### Otros
74+
75+
La ordenación del shell también se conoce como clasificación de incremento de disminución.

‎es/Algoritmos de Ordenamiento/Ordenamiento de fusión.md

Lines changed: 45 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,45 @@
1+
# Ordenamiento de fusión (dividir y conquistar algoritmo)
2+
3+
#### Declaración de problema
4+
5+
Dada una matriz de n elementos, escriba una función para ordenar la matriz
6+
7+
#### Enfoque
8+
9+
- Encontrar un punto medio y dividir la matriz en mitades basadas en el punto medio
10+
- Llamar recursivamente a la función de ordenación de fusión para las dos mitades
11+
- Combinar las dos mitades ordenadas para obtener la matriz ordenada
12+
13+
#### Complejidad horaria
14+
15+
`O(n log n)`
16+
17+
#### Complejidad espacial
18+
19+
`O(n)`
20+
21+
#### Ejemplo
22+
23+
```markdown
24+
arr = [1, 3, 9, 5, 0, 2]
25+
26+
Divida la matriz en dos mitades [1, 3, 9] y [5, 0, 2]
27+
28+
Vuelva a llamar a la función de ordenación de combinación de llamadas para estas dos mitades, lo que proporcionará mitades ordenadas
29+
=> [1, 3, 9] & [0, 2, 5]
30+
31+
Ahora combine ambas mitades para obtener la matriz ordenada [0, 1, 2, 3, 5, 9]
32+
```
33+
34+
#### Enlaces de la implementación del código
35+
36+
- [Java](https://github.com/TheAlgorithms/Java/blob/master/Sorts/MergeSort.java)
37+
- [C++](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/sorting/merge_sort.cpp)
38+
- [Python](https://github.com/TheAlgorithms/Python/blob/master/sorts/merge_sort.py)
39+
- [C-Sharp](https://github.com/TheAlgorithms/C-Sharp/blob/master/Algorithms/Sorters/Comparison/MergeSorter.cs)
40+
- [C](https://github.com/TheAlgorithms/C/blob/master/sorting/merge_sort.c)
41+
- [Ruby](https://github.com/TheAlgorithms/Ruby/blob/master/sorting/merge_sort.rb)
42+
43+
#### Explicación de vídeo
44+
45+
[Un vídeo CS50 que explica el algoritmo de ordemaniento de fusión](https://www.youtube.com/watch?v=EeQ8pwjQxTM)

‎es/Algoritmos de Ordenamiento/Ordenamiento de inserción.md

Lines changed: 62 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,62 @@
1+
# Ordenación de inserción
2+
3+
#### Declaración de problema
4+
5+
Dada una matriz de `N` elementos, escriba una función para ordenar la matriz en orden creciente.
6+
7+
#### Enfoque
8+
9+
- Definir un índice "clave", el subarray a la izquierda de los cuales se ordena.
10+
- Iniciar "clave" como 1, es decir. el segundo elemento de array(ya que solo queda un elemento del segundo elemento, que se puede considerar como matriz ordenada con un elemento).
11+
- Si el valor del elemento en la posición (clave - 1) es menor que el valor del elemento en la posición (clave); incremento "clave".
12+
- De lo contrario, mueva elementos de subarray ordenados que sean mayores que el valor del elemento en "clave" a una posición por delante de su posición actual. Coloque el valor del elemento en "clave" en el vacío recién creado.
13+
14+
#### Complejidad horaria
15+
16+
- Comparaciones `О(n^2)`, intercambia `О(n^2)` -- Peor caso
17+
- Comparaciones `O(n)`, intercambia `O(1)` -- Mejor caso
18+
19+
#### Complejidad espacial
20+
21+
`O(1)` -- (No se necesita espacio adicional, clasificación hecha en su lugar)
22+
23+
#### Ejemplo
24+
25+
```markdown
26+
27+
12, 11, 13, 5, 6
28+
29+
Vamos a bucle para i = 1 (segundo elemento de la matriz) a 4 (Tamaño de la matriz de entrada)
30+
31+
i = 1.
32+
Dado que 11 es menor que 12, mueva 12 e inserte 11 antes de 12
33+
11, 12, 13, 5, 6
34+
35+
i = 2.
36+
13 permanecerán en su posición, ya que todos los elementos en subarray ordenado son menores de 13
37+
11, 12, 13, 5, 6
38+
39+
i = 3.
40+
5 se moverá al principio,
41+
y todos los demás elementos de 11 a 13 se moverán una posición por delante de su posición actual.
42+
5, 11, 12, 13, 6
43+
44+
i = 4.
45+
6 se moverá a la posición después de 5,
46+
y los elementos del 11 al 13 se moverán una posición por delante de su posición actual.
47+
5, 6, 11, 12, 13 -- matriz ordenada
48+
```
49+
50+
#### Enlaces de implementación del código
51+
52+
- [Java](https://github.com/TheAlgorithms/Java/blob/master/Sorts/InsertionSort.java)
53+
- [C](https://github.com/TheAlgorithms/C/blob/master/sorting/insertion_sort.c)
54+
- [C++](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/sorting/insertion_sort.cpp)
55+
- [C#](https://github.com/TheAlgorithms/C-Sharp/blob/master/Algorithms/Sorters/Comparison/InsertionSorter.cs)
56+
- [Scala](https://github.com/TheAlgorithms/Scala/blob/master/src/main/scala/Sort/InsertionSort.scala)
57+
- [Python](https://github.com/TheAlgorithms/Python/blob/master/sorts/insertion_sort.py)
58+
- [Ruby](https://github.com/TheAlgorithms/Ruby/blob/master/sorting/insertion_sort.rb)
59+
60+
#### Explicación de vídeo
61+
62+
[Un vídeo CS50 que explica el algoritmo de Ordenamiento de inserción](https://www.youtube.com/watch?v=DFG-XuyPYUQ)

‎es/Algoritmos de Ordenamiento/Ordenamiento de montón (heap sort).md

Lines changed: 71 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,71 @@
1+
# Heap sort
2+
3+
### Declaración de problema
4+
5+
Dada una matriz no ordenada de `N` elementos, escriba una función para ordenar la matriz.
6+
7+
#### Enfoque
8+
9+
- Construir un montón máximo a partir de los datos de entrada.
10+
- En este punto, el elemento más grande se almacena en la raíz del montón. Reemplácelo por el último elemento del montón seguido de reducir el tamaño del montón en 1. Finalmente, amontonar la raíz del árbol.
11+
- Repita los pasos anteriores mientras que el tamaño del montón es mayor que 1.
12+
13+
#### Complejidad horaria
14+
15+
`O(n log n)` Peor rendimiento del caso
16+
17+
`O(n log n)` (claves distintas)
18+
o `O(n)` (teclas iguales) Rendimiento en el mejor de los casos
19+
20+
`O(n log n)` Rendimiento medio
21+
22+
#### Complejidad espacial
23+
24+
`O(1)` Peor caso auxiliar
25+
26+
#### Ejemplo
27+
28+
```
29+
Datos de entrada: 4, 10, 3, 5, 1
30+
4(0)
31+
/
32+
10(1) 3(2)
33+
/
34+
5(3) 1(4)
35+
36+
Los números del corchete representan los índices de la matriz
37+
representación de datos.
38+
39+
Aplicación del procedimiento de amontonación al índice 1:
40+
4(0)
41+
/
42+
10(1) 3(2)
43+
/
44+
5(3) 1(4)
45+
46+
Aplicación del procedimiento de amontonación al índice 0:
47+
10(0)
48+
/
49+
5(1) 3(2)
50+
/
51+
4(3) 1(4)
52+
El procedimiento de amontonar se llama a sí mismo recursivamente para construir el montón
53+
de la manera de arriba hacia abajo.
54+
```
55+
56+
![imagen del montón](https://upload.wikimedia.org/wikipedia/commons/1/1b/Sorting_heapsort_anim.gif "Heap sort")
57+
58+
#### Enlaces de implementación de código
59+
60+
- [Java](https://github.com/TheAlgorithms/Java/blob/master/Sorts/HeapSort.java)
61+
- [C++](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/sorting/heap_sort.cpp)
62+
- [Python](https://github.com/TheAlgorithms/Python/blob/master/sorts/heap_sort.py)
63+
- [Ir](https://github.com/TheAlgorithms/Go/blob/master/sorts/heapsort.go)
64+
- [Ruby](https://github.com/TheAlgorithms/Ruby/blob/master/sorting/heap_sort.rb)
65+
- [C-sharp](https://github.com/TheAlgorithms/C-Sharp/blob/master/Algorithms/Sorters/Comparison/HeapSorter.cs)
66+
- [C](https://github.com/TheAlgorithms/C/blob/master/sorting/heap_sort.c)
67+
- [Javascript](https://github.com/TheAlgorithms/Javascript/blob/master/Sorts/HeapSort.js)
68+
69+
#### Explicación de vídeo
70+
71+
[Un vídeo explicando el algoritmo de ordenamiento de montón (heap sort)](https://www.youtube.com/watch?v=MtQL_ll5KhQ)

‎es/Algoritmos de Ordenamiento/Ordenamiento de selección.md

Lines changed: 69 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,69 @@
1+
# Ordenamiento de selección
2+
3+
#### Declaración de problema
4+
5+
Dada una matriz no ordenada de `N` elementos, escriba una función para ordenar la matriz.
6+
7+
#### Enfoque
8+
9+
- Seleccione el elemento más pequeño de la matriz
10+
- Ponerlo al principio de la matriz
11+
- A continuación, seleccione la matriz más pequeña de la lista no ordenada restante
12+
- Anexarlo a la matriz ordenada al principio
13+
- Seguir haciendo esto para cada elemento de la matriz
14+
- Repetir el proceso anterior n veces
15+
16+
#### Complejidad horaria
17+
18+
`O(n^2)` Peor rendimiento en el caso
19+
20+
`O(n^2)` Mejor rendimiento en el caso
21+
22+
`O(n^2)` Rendimiento medio
23+
24+
#### Complejidad espacial
25+
26+
`O(1)` El peor caso
27+
28+
#### Ejemplo
29+
30+
```markdown
31+
arr[] = {80, 10, 40, 30}
32+
Índices: 0 1 2 3
33+
< 101F4 /div>
34+
1. Índice = 0
35+
Seleccione el número mínimo de la matriz (entre el índice 0-3), es decir, 10
36+
2. Intercambio 10 y 80 (arr[0])
37+
3. La matriz ahora es {10, 80, 40, 30}
38+
39+
4. Índice = 1
40+
Seleccione el número mínimo de la matriz (entre el índice 1-3), es decir, 30
41+
5. Intercambio 30 y 80 (arr[1])
42+
6. La matriz ahora es {10, 30, 40, 80}
43+
44+
7. Índice = 2
45+
Seleccione el número mínimo de la matriz (entre el índice 2-3), es decir, 40
46+
8. Intercambio 40 y 40 (arr[2])
47+
9. La matriz ahora es {10, 30, 40, 80}
48+
49+
La matriz ahora está ordenada.
50+
```
51+
52+
#### Enlaces de implementación de código
53+
54+
- [Java](https://github.com/TheAlgorithms/Java/blob/master/Sorts/SelectionSort.java)
55+
- [C++](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/Sorting/Selection%20Sort.cpp)
56+
- [Python](https://github.com/TheAlgorithms/Python/blob/master/sorts/selection_sort.py)
57+
- [Ir](https://github.com/TheAlgorithms/Go/blob/master/sorts/selection_sort.go)
58+
- [Ruby](https://github.com/TheAlgorithms/Ruby/blob/master/Sorting/selection_sort.rb)
59+
- [C](https://github.com/TheAlgorithms/C/blob/master/sorting/SelectionSort.c)
60+
- [Scala](https://github.com/TheAlgorithms/Scala/blob/master/src/main/scala/Sort/SelectionSort.scala)
61+
- [Javascript](https://github.com/TheAlgorithms/Javascript/blob/master/Sorts/selectionSort.js)
62+
63+
#### Explicación de vídeo
64+
65+
[Un vídeo explicando el algoritmo de Ordenamiento de selección](https://www.youtube.com/watch?v=f8hXR_Hvybo)
66+
67+
#### Explicación de animación
68+
69+
- [Tabla de tute](https://boardhub.github.io/tute/?wd=selectSortAlgo2)

0 commit comments

Comments
 (0)
0