fix(guide): simplify directory structure

guide/portuguese/algorithms/search-algorithms/binary-search/index.md

@@ -0,0 +1,268 @@
+---
+title: Binary Search
+localeTitle: Pesquisa binária
+---
+## Pesquisa binária
+
+Uma pesquisa binária localiza um item em uma matriz ordenada dividindo repetidamente o intervalo de pesquisa pela metade.
+
+Como você pesquisa um nome em uma lista telefônica?
+
+Uma maneira seria começar a partir da primeira página e ver cada nome na lista telefônica até encontrarmos o que estamos procurando. Mas isso seria uma maneira extremamente laboriosa e ineficiente de pesquisar.
+
+Como sabemos que os nomes da lista telefônica são classificados em ordem alfabética, provavelmente poderíamos trabalhar nos seguintes passos:
+
+1.  Abra a página do meio da agenda
+2.  Se tiver o nome que estamos procurando, estamos prontos!
+3.  Caso contrário, jogue fora a metade da agenda que não contém o nome
+4.  Repita até encontrar o nome ou não há mais páginas na lista telefônica
+
+Complexidade de tempo: Como descartamos uma parte do caso de pesquisa durante cada etapa da pesquisa binária e executamos a operação de pesquisa na outra metade, isso resulta em uma complexidade de tempo de pior caso de _O_ ( _log 2 N_ ).
+
+Complexidade de espaço: A pesquisa binária leva constante ou _O_ ( _1_ ) espaço, o que significa que não definimos qualquer variável relacionada ao tamanho de entrada.
+
+para pequenos conjuntos, a pesquisa linear é melhor, mas em grandes, é muito mais eficiente usar a pesquisa binária.
+
+Em detalhes, quantas vezes você pode dividir N por 2 até ter 1? Essencialmente, isso significa fazer uma pesquisa binária (metade dos elementos) até encontrá-la. Em uma fórmula, isso seria:
+```
+1 = N / 2x 
+```
+
+Multiplique por 2x:
+```
+2x = N 
+```
+
+Agora faça o log2:
+```
+log2(2x)    = log2 N 
+ x * log2(2) = log2 N 
+ x * 1       = log2 N 
+```
+
+Isso significa que você pode dividir o log N vezes até que você tenha tudo dividido. O que significa que você tem que dividir o log N ("faça a etapa de busca binária") até encontrar seu elemento.
+
+_O_ ( _log 2 N_ ) é assim porque em cada etapa a metade dos elementos no conjunto de dados desapareceu, o que é justificado pela base da função logarítmica.
+
+Este é o algoritmo de busca binária. É elegante e eficiente, mas para funcionar corretamente, a matriz deve ser **classificada** .
+
+* * *
+
+Encontre 5 na matriz de números fornecida usando a pesquisa binária.
+
+![Pesquisa Binária 1](https://i.imgur.com/QAuugOL.jpg)
+
+Marque as posições baixa, alta e média na matriz.
+
+![Pesquisa Binária 2](https://i.imgur.com/1710fEx.jpg)
+
+Compare o item que você está procurando com o elemento do meio.
+
+![Pesquisa Binária 3](https://i.imgur.com/jr4icze.jpg)
+
+Jogue fora a metade esquerda e olhe na metade direita.
+
+![Pesquisa Binária 4](https://i.imgur.com/W57lGsk.jpg)
+
+Mais uma vez compare com o elemento do meio.
+
+![Pesquisa Binária 5](https://i.imgur.com/5Twm8NE.jpg)
+
+Agora, vá para a metade esquerda.
+
+![Pesquisa Binária 6](https://i.imgur.com/01xetay.jpg)
+
+O elemento do meio é o item que estávamos procurando!
+
+O algoritmo de busca binária adota uma abordagem de divisão e conquista em que a matriz é continuamente dividida até que o item seja encontrado ou até que não haja mais elementos para a verificação. Portanto, esse algoritmo pode ser definido recursivamente para gerar uma solução elegante.
+
+Os dois casos básicos para recursão seriam:
+
+*   Não há mais elementos restantes na matriz
+*   Item é encontrado
+
+O poder da pesquisa binária em sistemas de dados (árvores B +): As árvores de pesquisa binária são muito poderosas por causa de seus tempos de pesquisa O (log n), depois da estrutura de dados hashmap que usa uma chave de hashing para pesquisar dados em O (1). É importante entender como o tempo de execução do log n vem da altura de uma árvore de pesquisa binária. Se cada nó se dividir em dois nós (binário), a profundidade da árvore será log n (base 2). Para melhorar essa velocidade no Data System, usamos árvores B + porque elas têm um fator de ramificação maior e portanto, mais altura. Espero que este pequeno artigo ajude a expandir sua mente sobre como a pesquisa binária é usada em sistemas práticos.
+
+O código para pesquisa binária recursiva é mostrado abaixo:
+
+### Implementação Javascript
+
+```javascript
+function binarySearch(arr, item, low, high) { 
+    if (low > high) { // No more elements in the array. 
+        return null; 
+    } 
+ 
+    // Find the middle of the array. 
+    var mid = Math.ceil((low + high) / 2); 
+ 
+    if (arr[mid] === item) { // Found the item! 
+        return mid; 
+    } 
+ 
+    if (item < arr[mid]) { // Item is in the half from low to mid-1. 
+        return binarySearch(arr, item, low, mid-1); 
+    } 
+ 
+    else { // Item is in the half from mid+1 to high. 
+        return binarySearch(arr, item, mid+1, high); 
+    } 
+ } 
+ 
+ var numbers = [1,2,3,4,5,6,7]; 
+ print(binarySearch(numbers, 5, 0, numbers.length-1)); 
+```
+
+Aqui está outra implementação em Javascript:
+
+```Javascript
+function binary_search(a, v) { 
+    function search(low, high) { 
+        if (low === high) { 
+            return a[low] === v; 
+        } else { 
+            var mid = math_floor((low + high) / 2); 
+            return (v === a[mid]) 
+                   || 
+                   (v < a[mid]) 
+                   ? search(low, mid - 1) 
+                   : search(mid + 1, high); 
+        } 
+    } 
+    return search(0, array_length(a) - 1); 
+ } 
+```
+
+### Implementação Ruby
+
+```ruby
+def binary_search(target, array) 
+  sorted_array = array.sort 
+  low = 0 
+  high = (sorted_array.length) - 1 
+ 
+  while high >= low 
+    middle = (low + high) / 2 
+ 
+    if target > sorted_array[middle] 
+      low = middle + 1 
+    elsif target < sorted_array[middle] 
+      high = middle - 1 
+    else 
+      return middle 
+    end 
+  end 
+  return nil 
+ end 
+```
+
+### Exemplo em C
+
+```C
+int binarySearch(int a[], int l, int r, int x) { 
+   if (r >= l){ 
+        int mid = l + (r - l)/2; 
+        if (a[mid] == x) 
+            return mid; 
+        if (arr[mid] > x) 
+            return binarySearch(arr, l, mid-1, x); 
+        return binarySearch(arr, mid+1, r, x); 
+   } 
+   return -1; 
+ } 
+```
+
+### Implementação C / C ++
+
+```C++
+int binary_search(int arr[], int l, int r, int target) 
+ { 
+   if (r >= l) 
+   { 
+        int mid = l + (r - l)/2; 
+        if (arr[mid] == target) 
+            return mid; 
+        if (arr[mid] > target) 
+            return binary_search(arr, l, mid-1, target); 
+        return binary_search(arr, mid+1, r, target); 
+   } 
+   return -1; 
+ } 
+```
+
+### Implementação em Python
+
+```Python
+def binary_search(arr, l, r, target): 
+    if r >= l: 
+        mid = l + (r - l)/2 
+        if arr[mid] == target: 
+            return mid 
+        elif arr[mid] > target: 
+            return binary_search(arr, l, mid-1, target) 
+        else: 
+            return binary_search(arr, mid+1, r, target) 
+    else: 
+        return -1 
+```
+
+### Exemplo em C ++
+
+```c++
+// Binary Search using iteration 
+ int binary_search(int arr[], int beg, int end, int num) 
+ { 
+    while(beg <= end){ 
+        int mid = (beg + end) / 2; 
+        if(arr[mid] == num) 
+            return mid; 
+        else if(arr[mid] < num) 
+            beg = mid + 1; 
+        else 
+            end = mid - 1; 
+    } 
+    return -1; 
+ } 
+```
+
+```c++
+// Binary Search using recursion 
+ int binary_search(int arr[], int beg, int end, int num) 
+ { 
+    if(beg <= end){ 
+        int mid = (beg + end) / 2; 
+        if(arr[mid] == num) 
+            return mid; 
+        else if(arr[mid] < num) 
+            return binary_search(arr, mid + 1, end, num); 
+        else 
+            return binary_search(arr, beg, mid - 1, num); 
+    } 
+    return -1; 
+ } 
+```
+
+### Exemplo em C ++
+
+Abordagem recursiva!
+
+\`\` \`C ++ - abordagem recursiva int binarySearch (int arr \[\], int início, int fim, int x) { if (end> = start) { int mid = start + (end - start) / 2; if (arr \[meio\] == x)  
+retorno no meio;
+```
+    if (arr[mid] > x) 
+        return binarySearch(arr, start, mid-1, x); 
+ 
+    return binarySearch(arr, mid+1, end, x); 
+```
+
+} return -1; }
+```
+Iterative approach! 
+```
+
+C ++ - abordagem iterativa int binarySearch (int arr \[\], int início, int fim, int x) { while (início <= fim) { int mid = start + (end - start) / 2; if (arr \[meio\] == x) retorno no meio; if (arr \[mid\] <x) start = mid + 1; outro end = mid - 1; } return -1; } \`\` \`
+
+### Mais Informações
+
+*   [Pesquisa binária (vídeo do YouTube)](https://youtu.be/P3YID7liBug)
+*   [Pesquisa binária - CS50](https://www.youtube.com/watch?v=5xlIPT1FRcA)

guide/portuguese/algorithms/search-algorithms/exponential-search/index.md

@@ -0,0 +1,95 @@
+---
+title: Exponential Search
+localeTitle: Pesquisa Exponencial
+---
+## Pesquisa Exponencial
+
+Pesquisa Exponencial também conhecida como busca por dedo, busca por um elemento em um array ordenado, saltando `2^i` elementos a cada iteração onde eu represente o valor da variável de controle de loop e, em seguida, verificar se o elemento de pesquisa está presente entre o último salto e o salto atual
+
+# Caso Pior da Complexidade
+
+O (log (N)) Muitas vezes confuso por causa do nome, o algoritmo é chamado assim não por causa da complexidade do tempo. O nome surge como resultado do algoritmo saltando elementos com passos iguais a expoentes de 2
+
+# Trabalho
+
+1.  Pule a matriz `2^i` elementos de uma vez pesquisando a condição `Array[2^(i-1)] < valueWanted < Array[2^i]` . Se `2^i` for maior que o comprimento da matriz, defina o limite superior para o comprimento da matriz.
+2.  Faça uma busca binária entre `Array[2^(i-1)]` e `Array[2^i]`
+
+# Código
+```
+// C++ program to find an element x in a 
+ // sorted array using Exponential search. 
+ #include <bits/stdc++.h> 
+ using namespace std; 
+ 
+ int binarySearch(int arr[], int, int, int); 
+ 
+ // Returns position of first ocurrence of 
+ // x in array 
+ int exponentialSearch(int arr[], int n, int x) 
+ { 
+    // If x is present at firt location itself 
+    if (arr[0] == x) 
+        return 0; 
+ 
+    // Find range for binary search by 
+    // repeated doubling 
+    int i = 1; 
+    while (i < n && arr[i] <= x) 
+        i = i*2; 
+ 
+    //  Call binary search for the found range. 
+    return binarySearch(arr, i/2, min(i, n), x); 
+ } 
+ 
+ // A recursive binary search function. It returns 
+ // location of x in  given array arr[l..r] is 
+ // present, otherwise -1 
+ int binarySearch(int arr[], int l, int r, int x) 
+ { 
+    if (r >= l) 
+    { 
+        int mid = l + (r - l)/2; 
+ 
+        // If the element is present at the middle 
+        // itself 
+        if (arr[mid] == x) 
+            return mid; 
+ 
+        // If element is smaller than mid, then it 
+        // can only be present n left subarray 
+        if (arr[mid] > x) 
+            return binarySearch(arr, l, mid-1, x); 
+ 
+        // Else the element can only be present 
+        // in right subarray 
+        return binarySearch(arr, mid+1, r, x); 
+    } 
+ 
+    // We reach here when element is not present 
+    // in array 
+    return -1; 
+ } 
+ 
+ int main(void) 
+ { 
+   int arr[] = {2, 3, 4, 10, 40}; 
+   int n = sizeof(arr)/ sizeof(arr[0]); 
+   int x = 10; 
+   int result = exponentialSearch(arr, n, x); 
+   (result == -1)? printf("Element is not present in array") 
+                 : printf("Element is present at index %d", result); 
+   return 0; 
+ } 
+```
+
+# Mais Informações
+
+*   [Wikipedia](https://en.wikipedia.org/wiki/Exponential_search)
+    
+*   [GeeksForGeeks](https://www.geeksforgeeks.org/exponential-search/)
+    
+
+# Créditos
+
+[Implementação de C ++](https://www.wikitechy.com/technology/exponential-search/)

guide/portuguese/algorithms/search-algorithms/index.md

@@ -0,0 +1,21 @@
+---
+title: Search Algorithms
+localeTitle: Algoritmos de Pesquisa
+---
+## Algoritmos de Pesquisa
+
+Em ciência da computação, um algoritmo de busca é qualquer algoritmo que solucione o problema de Busca, ou seja, recuperar informações armazenadas em alguma estrutura de dados ou calculadas no espaço de busca de um domínio de problema. Exemplos de tais estruturas incluem listas vinculadas, estruturas de dados de matriz, árvores de pesquisa e muito mais. O algoritmo de pesquisa apropriado geralmente depende da estrutura de dados que está sendo pesquisada, mas também do conhecimento prévio sobre os dados. [Mais na wikipedia](https://en.wikipedia.org/wiki/Search_algorithm) .
+
+Esse tipo de algoritmo analisa o problema de reorganizar uma matriz de itens em ordem crescente. Os dois exemplos mais clássicos disso são a busca binária e o algoritmo de ordenação por fusão.
+
+Nos links a seguir, você também pode encontrar mais informações sobre:
+
+*   Pesquisa binária
+*   Pesquisa Linear
+*   Pesquisando listas vinculadas vs arrays
+
+#### Mais Informações:
+
+*   MIT OCW Introdução aos algoritmos de [busca](https://ocw.mit.edu/courses/electrical-engineering-and-computer-science/6-01sc-introduction-to-electrical-engineering-and-computer-science-i-spring-2011/unit-4-probability-and-planning/search-algorithms/) .
+*   Universidade de Princeton: [classificação e pesquisa.](https://introcs.cs.princeton.edu/java/42sort/)
+*   A anatomia de um mecanismo de busca [(Google).](http://infolab.stanford.edu/~backrub/google.html)

guide/portuguese/algorithms/search-algorithms/jump-search/index.md

@@ -0,0 +1,29 @@
+---
+title: Jump Search
+localeTitle: Pesquisa de salto
+---
+## Pesquisa de salto
+
+Uma pesquisa de salto localiza um item em uma matriz ordenada pulando k itens e, em seguida, verifica se o item desejado está entre o salto anterior e o salto atual.
+
+# Caso Pior da Complexidade
+
+O (√N)
+
+# Trabalho
+
+1.  Defina o valor de k, o número do salto: O tamanho ideal do salto é √N, onde o N é o comprimento do array
+2.  Salta o array k-by-k pesquisando pela condição `Array[i] < valueWanted < Array[i+k]`
+3.  Faça uma pesquisa linear entre `Array[i]` e `Array[i + k]`
+
+![Pesquisa de Salto 1](https://i1.wp.com/theoryofprogramming.com/wp-content/uploads/2016/11/jump-search-1.jpg?resize=676%2C290)
+
+# Código
+
+Para ver exemplos de implementação de código deste método, acesse este link abaixo:
+
+[Pesquisa de salto - OpenGenus / cosmos](https://github.com/OpenGenus/cosmos/tree/master/code/search/jump_search)
+
+# Créditos
+
+[A imagem da matriz da lógica](http://theoryofprogramming.com/2016/11/10/jump-search-algorithm/)

guide/portuguese/algorithms/search-algorithms/linear-search/index.md

@@ -0,0 +1,140 @@
+---
+title: Linear Search
+localeTitle: Pesquisa Linear
+---
+## Pesquisa Linear
+
+Suponha que você receba uma lista ou uma matriz de itens. Você está procurando por um item em particular. Como você faz isso?
+
+Encontre o número 13 na lista dada.
+
+![Pesquisa Linear 1](https://i.imgur.com/ThkzYEV.jpg)
+
+Você apenas olha para a lista e aí está!
+
+![Pesquisa Linear 2](https://i.imgur.com/K7HfCly.jpg)
+
+Agora, como você diz a um computador para encontrá-lo?
+
+Um computador não pode olhar mais do que o valor em um determinado instante de tempo. Então, é preciso um item da matriz e verifica se é o mesmo que você está procurando.
+
+![Pesquisa Linear 3](https://i.imgur.com/ZOSxeZD.jpg)
+
+O primeiro item não coincidiu. Então, mude para o próximo.
+
+![Pesquisa Linear 4](https://i.imgur.com/SwKsPxD.jpg)
+
+E assim por diante…
+
+Isso é feito até que uma correspondência seja encontrada ou até que todos os itens tenham sido verificados.
+
+![Pesquisa Linear 5](https://i.imgur.com/3AaViff.jpg)
+
+Neste algoritmo, você pode parar quando o item é encontrado e, em seguida, não há necessidade de procurar mais.
+
+Então, quanto tempo levaria para fazer a operação de busca linear? Na melhor das hipóteses, você poderia ter sorte e o item que você está olhando talvez na primeira posição na matriz! Mas, na pior das hipóteses, você teria que olhar para cada item antes de encontrar o item no último lugar ou antes de perceber que o item não está na matriz.
+
+A complexidade, portanto, da pesquisa linear é: O (n).
+
+Se o elemento a ser pesquisado preside o primeiro bloco de memória, a complexidade seria: O (1).
+
+O código para uma função de pesquisa linear em JavaScript é mostrado abaixo. Esta função retorna a posição do item que estamos procurando no array. Se o item não estiver presente na matriz, a função retornará null.
+
+### Exemplo em Javascript
+
+```javascript
+function linearSearch(arr, item) { 
+  // Go through all the elements of arr to look for item. 
+  for (var i = 0; i < arr.length; i++) { 
+    if (arr[i] === item) { // Found it! 
+      return i; 
+    } 
+  } 
+ 
+  // Item not found in the array. 
+  return null; 
+ } 
+```
+
+### Exemplo em Ruby
+
+```ruby
+def linear_search(target, array) 
+  counter = 0 
+ 
+  while counter < array.length 
+    if array[counter] == target 
+      return counter 
+    else 
+      counter += 1 
+    end 
+  end 
+  return nil 
+ end 
+```
+
+### Exemplo em C ++
+
+```c++
+int linear_search(int arr[],int n,int num) 
+ { 
+    for(int i=0;i<n;i++){ 
+        if(arr[i]==num) 
+            return i; 
+   } 
+   // Item not found in the array 
+   return -1; 
+ } 
+```
+
+### Exemplo em Python
+
+```python
+def linear_search(array, num): 
+    for i in range(len(array)): 
+        if (array[i]==num): 
+            return i 
+    return -1 
+```
+
+## Pesquisa Linear Global
+
+E se você estiver pesquisando as várias ocorrências de um elemento? Por exemplo, você quer ver quantos 5 estão em uma matriz.
+
+Alvo = 5
+
+Matriz = \[1, 2, 3, 4, 5, 6, 5, 7, 8, 9, 5\]
+
+Este array tem 3 ocorrências de 5s e queremos retornar os índices (onde estão no array) de todos eles. Isso é chamado de pesquisa linear global e você precisará ajustar seu código para retornar uma matriz dos pontos de índice nos quais ele encontra o elemento de destino. Quando você encontrar um elemento de índice que corresponda ao seu destino, o ponto de índice (contador) será adicionado na matriz de resultados. Se não corresponder, o código continuará a avançar para o próximo elemento da matriz, adicionando 1 ao contador.
+
+```ruby
+def global_linear_search(target, array) 
+  counter = 0 
+  results = [] 
+ 
+  while counter < array.length 
+    if array[counter] == target 
+      results << counter 
+      counter += 1 
+    else 
+      counter += 1 
+    end 
+  end 
+ 
+  if results.empty? 
+    return nil 
+  else 
+    return results 
+  end 
+ end 
+```
+
+## Por que a pesquisa linear não é eficiente
+
+Não há dúvida de que a busca linear é simples, mas porque compara cada elemento um a um, consome tempo e, portanto, não é muito eficiente. Se tivermos que encontrar um número, digamos, o número e número de 1000000 estiver no último local, a técnica de busca linear se tornará bastante entediante. Então, aprenda também sobre bubble sort, quick sort etc.
+
+#### Vídeo relevante:
+
+#### Outros recursos
+
+[Pesquisa Linear - CS50](https://www.youtube.com/watch?v=vZWfKBdSgXI)

guide/portuguese/algorithms/search-algorithms/searching-linked-lists-versus-arrays/index.md

@@ -0,0 +1,23 @@
+---
+title: Searching Linked Lists Versus Arrays
+localeTitle: Pesquisando Listas Vinculadas Versus Arrays
+---
+## Pesquisando Listas Vinculadas Versus Arrays
+
+Suponha que você precise procurar um elemento em uma lista e array vinculados _não classificados_ . Nesse caso, você precisa fazer uma pesquisa linear (lembre-se, não classificada). Fazer uma pesquisa linear por um elemento em qualquer estrutura de dados será uma operação O (n).
+
+Agora, se você tiver uma lista e uma matriz vinculadas _ordenadas_ , ainda poderá pesquisar em ambas as estruturas de dados no tempo O (log n) usando a Pesquisa binária. Embora, seja um pouco entediante codificar enquanto estiver usando listas vinculadas.
+
+Listas vinculadas geralmente são preferidas em arrays, onde a inserção é uma operação freqüente. É mais fácil inserir em listas vinculadas, pois apenas um ponteiro é alterado. Mas, para inserir em uma matriz (o meio ou o começo), você precisa mover todos os elementos após o que você insere. Outro lugar onde você deve usar listas vinculadas é onde o tamanho é incerto (você não sabe o tamanho quando está começando), porque as matrizes têm tamanho fixo.
+
+Os arrays fornecem algumas vantagens sobre as listas vinculadas:
+
+1.  Acesso aleatório
+2.  Menos memória em comparação com listas vinculadas
+3.  Matrizes têm melhor localidade de cache, proporcionando melhor desempenho
+
+Depende completamente do caso de uso para saber se matrizes ou listas vinculadas são melhores.
+
+### Mais Informações:
+
+*   A abordagem de um programador de olhar para a lista interligada versus matriz: [Geeks para Geeks](http://www.geeksforgeeks.org/programmers-approach-looking-array-vs-linked-list/)