Spanish spelling/grammar improvements (#130)

* using temporal and espacial instead of others expression less used in computational complexity in spanish

* fixing the busqueda binaria translation

* Update es/Algoritmos de búsqueda/Búsqueda binaria.md

Co-authored-by: David Leal <halfpacho@gmail.com>

Author: david-xander

es/Algoritmos de Ordenamiento/Ordenamiento Burbuja.md

@@ -13,15 +13,15 @@ Dado un arreglo desordenado de n elementos, escribir una función que ordene el
 - Realizar las operaciones anteriores para cada elemento del arreglo.
 - Repetir el procedimiento descrito n veces.
 
-#### Complejidad en Orden de Tiempo
+#### Complejidad temporal
 
 `O(n^2)` Rendimiento en el peor de los casos
 
 `O(n)` Rendimiento en el mejor de los casos
 
 `O(n^2)` Rendimiento promedio
 
-#### Complejidad en Orden de Espacio
+#### Complejidad espacial
 
 `O(1)` Peor caso
 

es/Algoritmos de Ordenamiento/Ordenamiento Radix.md

@@ -36,8 +36,8 @@ La clasificación por el dígito más significativo (lugar de los años 100) da:
 ## ¿Cuál es el tiempo de ejecución de Radix Sort?
 
 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.
-¿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
-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
+¿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 temporal es `O((n+b) * logb(k))`. Lo que parece más que el
+complejidad temporal  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
 `O(n logb(n))`. Pero todavía no supera los algoritmos de clasificación basados en comparación.
 
 ## ¿Radix Sort es preferible a algoritmos de ordenación basados en comparación como Quick-Sort?

es/Algoritmos de Ordenamiento/Ordenamiento Shell.md

@@ -12,9 +12,9 @@ Dada una matriz no ordenada de `n` elementos, escriba una función para ordenar
 - Intercambiar los dos elementos si el primer elemento es más grande
 - Disminuir la brecha y repetir hasta la brecha = 1
 
-#### Complejidad horaria
+#### Complejidad temporal 
 
-La complejidad del tiempo depende de las secuencias de separación.
+La complejidad temporal depende de las secuencias de separación.
 Las complejidades de tiempo inferior se basan en las secuencias de separación de `n/2^k`.
 
 `O(n^2)` Peor rendimiento en el caso

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

@@ -10,7 +10,7 @@ Dada una matriz de n elementos, escriba una función para ordenar la matriz
 - Llamar recursivamente a la función de ordenación de fusión para las dos mitades
 - Combinar las dos mitades ordenadas para obtener la matriz ordenada
 
-#### Complejidad horaria
+#### Complejidad temporal 
 
 `O(n log n)`
 

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

@@ -11,7 +11,7 @@ Dada una matriz de `N` elementos, escriba una función para ordenar la matriz en
 - 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".
 - 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.
 
-#### Complejidad horaria
+#### Complejidad temporal 
 
 - Comparaciones `О(n^2)`, intercambia `О(n^2)` -- Peor caso
 - Comparaciones `O(n)`, intercambia `O(1)` -- Mejor caso

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

@@ -10,7 +10,7 @@ Dada una matriz no ordenada de `N` elementos, escriba una función para ordenar
 - 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.
 - Repita los pasos anteriores mientras que el tamaño del montón es mayor que 1.
 
-#### Complejidad horaria
+#### Complejidad temporal 
 
 `O(n log n)` Peor rendimiento del caso
 

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

@@ -13,7 +13,7 @@ Dada una matriz no ordenada de `N` elementos, escriba una función para ordenar
 - Seguir haciendo esto para cada elemento de la matriz
 - Repetir el proceso anterior n veces
 
-#### Complejidad horaria
+#### Complejidad temporal 
 
 `O(n^2)` Peor rendimiento en el caso
 

es/Algoritmos de Ordenamiento/Ordenamiento rápido.md

@@ -11,7 +11,7 @@ Dada una matriz no ordenada de n elementos, escriba una función para ordenar la
 - quicksort partición izquierda recursivamente
 - quicksort partición derecha recursivamente
 
-#### Complejidad horaria
+#### Complejidad temporal 
 
 - `O(n^2)` Peor rendimiento en el caso
 - `O(n log n)` Mejor rendimiento en el caso

es/Algoritmos de búsqueda/Búsqueda binaria.md

@@ -1,41 +1,41 @@
-# Búsqueda binaria (un algoritmo de dividir y conquistar)
+# Búsqueda binaria (un algoritmo de divide y vencerás)
 
 #### Declaración de problema
 
 Dada una matriz ordenada de `n` elementos, escriba una función para buscar el índice de un elemento determinado (destino).
 
 #### Enfoque
 
-- Busque la matriz dividiendo la matriz por la mitad repetidamente.
-- Inicialmente, considere la matriz real y elija el elemento en el índice medio.
-- Mantener un índice más bajo, es decir, 0 y mayor índice, es decir, la longitud de la matriz.
-- Si es igual al elemento de destino, devuelva el índice.
-- De lo contrario, si es mayor que el elemento de destino, tenga en cuenta sólo la mitad izquierda de la matriz (índice inferior = 0, superior = medio - 1).
-- De lo contrario, si es menor que el elemento de destino, tenga en cuenta sólo la mitad derecha de la matriz (índice inferior = medio + 1, más alto = longitud de la matriz).
-- Devolver -1 si el elemento de destino no se encuentra en la matriz (caso base: si el índice inferior es mayor o igual que el índice superior).
+- Se busca la matriz dividiendo la matriz por la mitad repetidamente.
+- Inicialmente, se considera la matriz real y se selecciona el elemento en el índice medio.
+- Se mantiene el índice más bajo, el número 0, y el más alto, la longitud de la matriz.
+- Si es igual al elemento de destino, se devuelve el índice.
+- De lo contrario, si es mayor que el elemento de destino, se condiera únicamente la mitad izquierda de la matriz (índice inferior = 0, superior = medio - 1).
+- De lo contrario, si es menor que el elemento de destino, se considera únicamente la mitad derecha de la matriz (índice inferior = medio + 1, más alto = longitud de la matriz).
+- Se devuelve -1 si el elemento de destino no se encuentra en la matriz (caso base: si el índice inferior es mayor o igual que el índice superior).
 
-#### Complejidad horaria
+#### Complejidad temporal
 
-`O(log n)`- Peor caso
-`O(1)`- Mejor caso (Si el elemento central de la matriz inicial es el elemento de destino)
+`O(log n)`- En el peor de los casos
+`O(1)`- En el mejor de los casos (Si el elemento central de la matriz inicial es el elemento de destino)
 
 #### Complejidad espacial
 
-`O(1)`- Para enfoque iterativo
-`O(log n)`- Para el enfoque recursivo debido a la pila de llamadas de recursividad
+`O(1)`- Para un enfoque iterativo
+`O(log n)`- Para un enfoque recursivo debido a la pila de llamadas de recursividad
 
 #### Ejemplo
 
 ```
 arr = [1,2,3,4,5,6,7]  
 
 target = 2
-Inicialmente, el elemento en el índice medio es 4 que es mayor que 2. Por lo tanto, buscamos la mitad izquierda de la
-matriz, es decir, [1,2,3].
-Aquí encontramos el elemento central igual al elemento objetivo por lo que devolvemos su índice, es decir, 1
+Inicialmente, el elemento en el índice medio es 4, que es mayor que 2. Por lo tanto, buscamos la mitad izquierda de la
+matriz, es decir: [1,2,3].
+Aquí encontramos el elemento central igual al elemento objetivo, por lo que devolvemos su índice: 1
 
-target = 9          
-Búsqueda binaria debe devolver -1 como 9 no está presente en la matriz
+target = 9
+Búsqueda binaria debe devolver -1 dado que 9 no está presente en la matriz
 ```
 
 #### Enlaces de implementación de código
@@ -56,7 +56,7 @@ Búsqueda binaria debe devolver -1 como 9 no está presente en la matriz
 - [Scala](https://github.com/TheAlgorithms/Scala/blob/master/src/main/scala/Search/BinarySearch.scala)
 - [MATLAB-Octave](https://github.com/TheAlgorithms/MATLAB-Octave/blob/master/algorithms/Searching/binary_search.m)
 
-#### Explicación en video de YouTube
+#### Explicación en vídeo de YouTube
 
 [Un vídeo CS50 explicando el algoritmo de búsqueda binaria](https://www.youtube.com/watch?v=5xlIPT1FRcA)
 

es/Algoritmos de búsqueda/Búsqueda exponencial.md

@@ -30,7 +30,7 @@ Ahora podemos aplicar la búsqueda binaria en el subarray de 512 y 1_000.
 
 **Nota**: aplicamos la búsqueda binaria de 512 a 1_000 porque en `i = 2^10 = 1_024` la matriz está finisced y el número de destino es menor que el índice más reciente de la matriz ( 1_000 ).
 
-#### Complejidad horaria
+#### Complejidad temporal 
 
 **Peor caso:** `O(log *i*)` donde `*i* = índice` (posición) del objetivo