Arrumando os comentarios de Busca Binaria, Busca sequencia e recursiva

Author: MarceloLuisDantas

src/rust/busca_binaria.rs

@@ -1,5 +1,5 @@
 /* 
-    Crontibuidores
+    Contribuidores
         - Dromedario de Chapéu
    
         O que é busca Binaria -
@@ -23,7 +23,7 @@ where
     // Centro indica o centro a lista ou sublista
     let mut centro = lista.len() / 2;   
 
-    // Limite_r representa o maior indice possivel, referente ao extremo direito
+    // Limite_r representa o maior indice possível, referente ao extremo direito
     // da lista atual, serve para dividir a lista original sem precisar ficar 
     // clonando ou literalmente dividindo. Seria o [-1] da sublista
     let mut limite_r = lista.len() - 1; 
@@ -49,19 +49,19 @@ where
         }
 
         // O segundo bloco se responsabiliza em verificar a distancia entre o valor recebido
-        // e o atual valor_p, caso sejá valor_p sejá maior, significa que o valor procurado
-        // esta mais para tras, e o centro é movido para o centro da sub lista anterior.
-        // Porem caso valor sejá maior qe o valor_p, significa que precisamos mover o centro
-        // para o centro da sub lista superiors
+        // e o atual valor_p, caso seja valor_p seja maior, significa que o valor procurado
+        // esta mais para trás, e o centro é movido para o centro da sub lista anterior.
+        // Porem caso valor seja maior que o valor_p, significa que precisamos mover o centro
+        // para o centro da sub lista superiors 
         if *valor_p > valor {
             limite_r = centro; 
             centro = centro / 2;
         } else if *valor_p < valor {
             limite_l = centro;
             // O If esta verificando se o espaço entre limite_r e limite_l é igual a 1
-            // pois a operação de padrão usada daria o resultado de 0 nesse caso, pos 
-            // Rust aredonda os valores para baixo, logo 0.5 é jogado para 0
-            // Poderia ser feito em uma linha utilizado conversõ de tipos e arredondamento 
+            // pois a operação de padrão usada daria o resultado de 0 nesse caso, pois 
+            // Rust arredonda os valores para baixo, logo 0.5 é jogado para 0
+            // Poderia ser feito em uma linha utilizado conversão de tipos e arredondamento  
             // porem eu pessoalmente acredito que a performance ganha não vale compensa
 
             centro = if (limite_r - limite_l) == 1 { centro + 1 } 

src/rust/busca_sequencial.rs

@@ -1,17 +1,17 @@
 /* 
-    Crontibuidores
+    Contribuidores
         - Dromedario de Chapéu
     
-    Busca Sequencial é o mais simples algoritmo de busca possivel, alem de 
-    ser um dos menos eficientes. Ele simplesmente intera por todos os itens 
+    Busca Sequencial é o mais simples algoritmo de busca possessive, alem de 
+    ser um dos menos eficientes. Ele simplesmente itera por todos os itens 
     de uma lista ate encontrar o valor desejado ou atingir o final da lista
     retornando que o elemento não esta presente na lista.
 
-    Esse algotimo pode ser util para listas pequenas de algumas poucas centenas
+    Esse algorítimo pode ser útil para listas pequenas de algumas poucas centenas
     de valores de tipo simples, porem mais que isso ele sera um grande gargalo 
     durante a execução do programa.
 
-    Uma possivel vantagem deste algoritmo, é que ele independe da lista esta
+    Uma possível vantagem deste algoritmo, é que ele independe da lista esta
     ordenada para funcionar. Pois ele não se importa com a ordem dos elementos.
 */
 fn busca_sequencial(lista: &[i32], valor: i32) -> (bool, usize) {

src/rust/busca_sequencial_recursiva.rs

@@ -1,33 +1,33 @@
 /* 
-    Crontibuidores
-        - Dromedario de Chapéu
+    Contribuidores
+        - Dromedário de Chapéu
    
-    A Busca Sequencial Recusivar consiste do mesmo conceito da Busca Sequencial.
-    A diferente é que invês de interar na lista utilizando um for por exemplo,
-    é utlizado recursãom que é resumidamente uma função que se chama N vezes com
-    mudanças no seus parametros te atingir ou o resultado desejado, ou um estado
+    A Busca Sequencial Recursiva consiste do mesmo conceito da Busca Sequencial.
+    A diferente é que invés de iterar na lista utilizando um for por exemplo,
+    é utilizado recursão que é resumidamente uma função que se chama N vezes com
+    mudanças no seus parâmetros te atingir ou o resultado desejado, ou um estado
     onde não ha mais o que fazer.
 
     Essa implementação é ainda mais lenta e custosa que a forma utilizando for,
-    pois recursão utliza muito mais memoria e processamente para ser utlizada, para
-    poucos itens na pratica ele vai ser tão rapido quanto qualquer outro algorimo. 
+    pois recursão utiliza muito mais memoria e processamento para ser utilizada, para
+    poucos itens na pratica ele vai ser tão rápido quanto qualquer outro algoritmo. 
     Porem caso seja uma lista de milhares de itens este algoritmo sera um problema.
 */
 
-// A mudança da declaração da sequencial normal para esta é a adição do parametro
-// indice, que indica em qual indice da lista nos estamos.
+// A mudança da declaração da sequencial normal para esta é a adição do parâmetro
+// índice, que indica em qual índice da lista nos estamos.
 fn busca_sequencial_recursiva(lista: &[i32], valor: i32, indice: usize) -> (bool, usize) {
     // O primeiro If indica a condição onde a recursão ocorreu vezes o suficiente
-    // para que o indice chega a ofinal da lista + 1, logo todos os itens da lista
+    // para que o índice chega ao final da lista + 1, logo todos os itens da lista
     // foram percorridos
     if indice == lista.len() {
         return (false, 0)
     } else if lista[indice] == valor {
         return (true, indice)
     }    
 
-    // Caso o item atual não seja o item desejado, nos chamamos a função com o indice
-    // acrescentado, para que na proxima execução da função seja verificado o proximo
+    // Caso o item atual não seja o item desejado, nos chamamos a função com o índice
+    // acrescentado, para que na próxima execução da função seja verificado o próximo
     // item da lista
     return busca_sequencial_recursiva(lista, valor, indice + 1);
 }