Brazilian Portuguese translation and typos fixes (trekhleb#943)

* Update README.pt-BR.md

* TRIE README.pt-BR typo

* TREE README.pt-BR typo

* Stack README.pt-BR typo

* Priority Queue README.pt-BR typo

* hash-table README.pt-BR typo

* doubly-linked-list README.pt-BR typo

* disjoint-set README.pt-BR typo

* bloom-filter README.pt-BR typo

* merge-sort pt-BR translation

* merge-sort README added pt-BR option

* insertion sort pt-BR translation

* insertion sort README added pt-br option

* heap-sort pt-BR translation

* heap-sort READMED added pt-BR option

* bubble sort pt-BR typo

* pt-BR translation for sorting algorithms

Fixed typos and translated all the missing algorithms

* Update README.pt-BR.md

* linked list pt-BR translation

* ml pt-BR translation

* fix typo in README

Co-authored-by: Oleksii Trekhleb <[email protected]>

src/algorithms/linked-list/reverse-traversal/README.md

@@ -1,7 +1,8 @@
 # Reversed Linked List Traversal
 
 _Read this in other languages:_
-[中文](README.zh-CN.md)
+[_中文_](README.zh-CN.md),
+[_Português_](README.pt-BR.md)
 
 The task is to traverse the given linked list in reversed order.
 

src/algorithms/linked-list/reverse-traversal/README.pt-BR.md

@@ -0,0 +1,23 @@
+# Travessia de Lista Encadeada Reversa
+
+_Leia isso em outros idiomas:_
+[_中文_](README.zh-CN.md),
+[_English_](README.md)
+
+A tarefa é percorrer a lista encadeada fornecida em ordem inversa.
+
+Por exemplo, para a seguinte lista vinculada:
+
+![](https://upload.wikimedia.org/wikipedia/commons/6/6d/Singly-linked-list.svg)
+
+A ordem de travessia deve ser:
+
+```texto
+37 → 99 → 12
+```
+
+A complexidade de tempo é `O(n)` porque visitamos cada nó apenas uma vez.
+
+## Referência
+
+- [Wikipedia](https://en.wikipedia.org/wiki/Linked_list)

src/algorithms/linked-list/traversal/README.md

@@ -2,7 +2,8 @@
 
 _Read this in other languages:_
 [_Русский_](README.ru-RU.md),
-[中文](README.zh-CN.md)
+[_中文_](README.zh-CN.md),
+[_Português_](README.pt-BR.md)
 
 The task is to traverse the given linked list in straight order.
 

src/algorithms/linked-list/traversal/README.pt-BR.md

@@ -0,0 +1,24 @@
+# Travessia de Lista Encadeada
+
+_Leia isso em outros idiomas:_
+[_Русский_](README.ru-RU.md),
+[_中文_](README.zh-CN.md),
+[_English_](README.md)
+
+A tarefa é percorrer a lista encadeada fornecida em ordem direta.
+
+Por exemplo, para a seguinte lista vinculada:
+
+![Singly linked list](https://upload.wikimedia.org/wikipedia/commons/6/6d/Singly-linked-list.svg)
+
+A ordem de travessia deve ser:
+
+```texto
+12 → 99 → 37
+```
+
+A complexidade de tempo é `O(n)` porque visitamos cada nó apenas uma vez.
+
+## Referência
+
+- [Wikipedia](https://en.wikipedia.org/wiki/Linked_list)

src/algorithms/ml/k-means/README.md

@@ -1,5 +1,8 @@
 # k-Means Algorithm
 
+_Read this in other languages:_
+[_Português_](README.pt-BR.md)
+
 The **k-Means algorithm** is an unsupervised Machine Learning algorithm. It's a clustering algorithm, which groups the sample data on the basis of similarity between dimensions of vectors.
 
 In k-Means classification, the output is a set of classes assigned to each vector. Each cluster location is continuously optimized in order to get the accurate locations of each cluster such that they represent each group clearly.

src/algorithms/ml/k-means/README.pt-BR.md

@@ -0,0 +1,35 @@
+# Algoritmo k-Means
+
+_Leia isso em outros idiomas:_
+[_English_](README.md)
+
+O **algoritmo k-Means** é um algoritmo de aprendizado de máquina não supervisionado. É um algoritmo de agrupamento, que agrupa os dados da amostra com base na semelhança entre as dimensões dos vetores.
+
+Na classificação k-Means, a saída é um conjunto de classes atribuídas a cada vetor. Cada localização de cluster é continuamente otimizada para obter as localizações precisas de cada cluster de forma que representem cada grupo claramente.
+
+A ideia é calcular a similaridade entre a localização do cluster e os vetores de dados e reatribuir os clusters com base nela. [Distância Euclidiana](https://github.com/trekhleb/javascript-algorithms/tree/master/src/algorithms/math/euclidean-distance) é usado principalmente para esta tarefa.
+
+![Distância Euclidiana entre dois pontos](https://upload.wikimedia.org/wikipedia/commons/5/55/Euclidean_distance_2d.svg)
+
+_Fonte: [Wikipedia](https://en.wikipedia.org/wiki/Euclidean_distance)_
+
+O algoritmo é o seguinte:
+
+1. Verifique se há erros como dados inválidos/inconsistentes
+2. Inicialize os locais do cluster `k` com pontos `k` iniciais/aleatórios
+3. Calcule a distância de cada ponto de dados de cada cluster
+4. Atribua o rótulo do cluster de cada ponto de dados igual ao do cluster em sua distância mínima
+5. Calcule o centroide de cada cluster com base nos pontos de dados que ele contém
+6. Repita cada uma das etapas acima até que as localizações do centroide estejam variando
+
+Aqui está uma visualização do agrupamento k-Means para melhor compreensão:
+
+![KNN Visualization 1](https://upload.wikimedia.org/wikipedia/commons/e/ea/K-means_convergence.gif)
+
+_Fonte: [Wikipedia](https://en.wikipedia.org/wiki/K-means_clustering)_
+
+Os centroides estão se movendo continuamente para criar uma melhor distinção entre os diferentes conjuntos de pontos de dados. Como podemos ver, após algumas iterações, a diferença de centroides é bastante baixa entre as iterações. Por exemplo, entre as iterações `13` e `14` a diferença é bem pequena porque o otimizador está ajustando os casos limite.
+
+## Referências
+
+- [k-Means neighbors algorithm on Wikipedia](https://en.wikipedia.org/wiki/K-means_clustering)

src/algorithms/ml/knn/README.md

@@ -1,5 +1,8 @@
 # k-Nearest Neighbors Algorithm
 
+_Read this in other languages:_
+[_Português_](README.pt-BR.md)
+
 The **k-nearest neighbors algorithm (k-NN)** is a supervised Machine Learning algorithm. It's a classification algorithm, determining the class of a sample vector using a sample data.
 
 In k-NN classification, the output is a class membership. An object is classified by a plurality vote of its neighbors, with the object being assigned to the class most common among its `k` nearest neighbors (`k` is a positive integer, typically small). If `k = 1`, then the object is simply assigned to the class of that single nearest neighbor.

src/algorithms/ml/knn/README.pt-BR.md

@@ -0,0 +1,44 @@
+# Algoritmo de k-vizinhos mais próximos
+
+_Leia isso em outros idiomas:_
+[_English_](README.md)
+
+O **algoritmo de k-vizinhos mais próximos (k-NN)** é um algoritmo de aprendizado de máquina supervisionado. É um algoritmo de classificação, determinando a classe de um vetor de amostra usando dados de amostra.
+
+Na classificação k-NN, a saída é uma associação de classe. Um objeto é classificado por uma pluralidade de votos de seus vizinhos, com o objeto sendo atribuído à classe mais comum entre seus `k` vizinhos mais próximos (`k` é um inteiro positivo, tipicamente pequeno). Se `k = 1`, então o objeto é simplesmente atribuído à classe daquele único vizinho mais próximo.
+
+The idea is to calculate the similarity between two data points on the basis of a distance metric. [Distância Euclidiana](https://github.com/trekhleb/javascript-algorithms/tree/master/src/algorithms/math/euclidean-distance) é usado principalmente para esta tarefa.
+
+![Distância Euclidiana entre dois pontos](https://upload.wikimedia.org/wikipedia/commons/5/55/Euclidean_distance_2d.svg)
+
+_Fonte: [Wikipedia](https://en.wikipedia.org/wiki/Euclidean_distance)_
+
+O algoritmo é o seguinte:
+
+1. Verifique se há erros como dados/rótulos inválidos.
+2. Calcule a distância euclidiana de todos os pontos de dados nos dados de treinamento com o ponto de classificação
+3. Classifique as distâncias dos pontos junto com suas classes em ordem crescente
+4. Pegue as classes iniciais `K` e encontre o modo para obter a classe mais semelhante
+5. Informe a classe mais semelhante
+
+Aqui está uma visualização da classificação k-NN para melhor compreensão:
+
+![KNN Visualization 1](https://upload.wikimedia.org/wikipedia/commons/e/e7/KnnClassification.svg)
+
+_Fonte: [Wikipedia](https://en.wikipedia.org/wiki/K-nearest_neighbors_algorithm)_
+
+A amostra de teste (ponto verde) deve ser classificada em quadrados azuis ou em triângulos vermelhos. Se `k = 3` (círculo de linha sólida) é atribuído aos triângulos vermelhos porque existem `2` triângulos e apenas `1` quadrado dentro do círculo interno. Se `k = 5` (círculo de linha tracejada) é atribuído aos quadrados azuis (`3` quadrados vs. `2` triângulos dentro do círculo externo).
+
+Outro exemplo de classificação k-NN:
+
+![KNN Visualization 2](https://media.geeksforgeeks.org/wp-content/uploads/graph2-2.png)
+
+_Fonte: [GeeksForGeeks](https://media.geeksforgeeks.org/wp-content/uploads/graph2-2.png)_
+
+Aqui, como podemos ver, a classificação dos pontos desconhecidos será julgada pela proximidade com outros pontos.
+
+É importante notar que `K` é preferível ter valores ímpares para desempate. Normalmente `K` é tomado como `3` ou `5`.
+
+## Referências
+
+- [k-nearest neighbors algorithm on Wikipedia](https://en.wikipedia.org/wiki/K-nearest_neighbors_algorithm)

src/algorithms/sorting/bubble-sort/README.pt-BR.md

@@ -1,16 +1,19 @@
 # Bubble Sort
 
+_Leia isso em outros idiomas:_
+[_English_](README.md)
+
 O bubble sort, ou ordenação por flutuação (literalmente "por bolha"), é um algoritmo de ordenação dos mais simples. A ideia é percorrer o vetor diversas vezes, e a cada passagem fazer flutuar para o topo o maior elemento da sequência. Essa movimentação lembra a forma como as bolhas em um tanque de água procuram seu próprio nível, e disso vem o nome do algoritmo.
 
 ![Algorithm Visualization](https://upload.wikimedia.org/wikipedia/commons/c/c8/Bubble-sort-example-300px.gif)
 
-## Complexity
+## Complexidade
 
-| Name                  | Best            | Average             | Worst               | Memory    | Stable    | Comments  |
+| Nome                  | Melhor            | Média             | Pior               | Memória    | Estável    | Comentários  |
 | --------------------- | :-------------: | :-----------------: | :-----------------: | :-------: | :-------: | :-------- |
-| **Bubble sort**       | n               | n<sup>2</sup>       | n<sup>2</sup>       | 1         | Yes       |           |
+| **Bubble sort**       | n               | n<sup>2</sup>       | n<sup>2</sup>       | 1         | Sim       |           |
 
-## References
+## Referências
 
 - [Wikipedia](https://pt.wikipedia.org/wiki/Bubble_sort)
 - [YouTube](https://www.youtube.com/watch?v=6Gv8vg0kcHc&index=27&t=0s&list=PLLXdhg_r2hKA7DPDsunoDZ-Z769jWn4R8)

src/algorithms/sorting/counting-sort/README.md

@@ -1,5 +1,8 @@
 # Counting Sort
 
+_Read this in other languages:_
+[_Português_](README.pt-BR.md)
+
 In computer science, **counting sort** is an algorithm for sorting 
 a collection of objects according to keys that are small integers; 
 that is, it is an integer sorting algorithm. It operates by 

src/algorithms/sorting/counting-sort/README.pt-br.md

@@ -0,0 +1,70 @@
+# Counting Sort
+
+_Leia isso em outros idiomas:_
+[_English_](README.md)
+
+Em ciência da computação, **counting sort** é um algoritmo para ordenar
+uma coleção de objetos de acordo com chaves que são pequenos inteiros;
+ou seja, é um algoritmo de ordenação de inteiros. Ele opera por
+contando o número de objetos que têm cada valor de chave distinto,
+e usando aritmética nessas contagens para determinar as posições
+de cada valor de chave na sequência de saída. Seu tempo de execução é
+linear no número de itens e a diferença entre o
+valores de chave máximo e mínimo, portanto, é adequado apenas para
+uso em situações em que a variação de tonalidades não é significativamente
+maior que o número de itens. No entanto, muitas vezes é usado como
+sub-rotina em outro algoritmo de ordenação, radix sort, que pode
+lidar com chaves maiores de forma mais eficiente.
+
+Como a classificação por contagem usa valores-chave como índices em um vetor,
+não é uma ordenação por comparação, e o limite inferior `Ω(n log n)` para
+a ordenação por comparação não se aplica a ele. A classificação por bucket pode ser usada
+para muitas das mesmas tarefas que a ordenação por contagem, com um tempo semelhante
+análise; no entanto, em comparação com a classificação por contagem, a classificação por bucket requer
+listas vinculadas, arrays dinâmicos ou uma grande quantidade de pré-alocados
+memória para armazenar os conjuntos de itens dentro de cada bucket, enquanto
+A classificação por contagem armazena um único número (a contagem de itens)
+por balde.
+
+A classificação por contagem funciona melhor quando o intervalo de números para cada
+elemento do vetor é muito pequeno.
+
+## Algoritmo
+
+**Passo I**
+
+Na primeira etapa, calculamos a contagem de todos os elementos do
+vetor de entrada 'A'. Em seguida, armazene o resultado no vetor de contagem `C`.
+A maneira como contamos é descrita abaixo.
+
+![Counting Sort](https://3.bp.blogspot.com/-jJchly1BkTc/WLGqCFDdvCI/AAAAAAAAAHA/luljAlz2ptMndIZNH0KLTTuQMNsfzDeFQCLcB/s1600/CSortUpdatedStepI.gif)
+
+**Passo II**
+
+Na segunda etapa, calculamos quantos elementos existem na entrada
+do vetor `A` que são menores ou iguais para o índice fornecido.
+`Ci` = números de elementos menores ou iguais a `i` no vetor de entrada.
+
+![Counting Sort](https://1.bp.blogspot.com/-1vFu-VIRa9Y/WLHGuZkdF3I/AAAAAAAAAHs/8jKu2dbQee4ap9xlVcNsILrclqw0UxAVACLcB/s1600/Step-II.png)
+
+**Passo III**
+
+Nesta etapa, colocamos o elemento `A` do vetor de entrada em classificado
+posição usando a ajuda do vetor de contagem construída `C`, ou seja, o que
+construímos no passo dois. Usamos o vetor de resultados `B` para armazenar
+os elementos ordenados. Aqui nós lidamos com o índice de `B` começando de
+zero.
+
+![Counting Sort](https://1.bp.blogspot.com/-xPqylngqASY/WLGq3p9n9vI/AAAAAAAAAHM/JHdtXAkJY8wYzDMBXxqarjmhpPhM0u8MACLcB/s1600/ResultArrayCS.gif)
+
+## Complexidade
+
+| Nome                  | Melhor            | Média             | Pior               | Memória    | Estável    | Comentários  |
+| --------------------- | :-------------: | :-----------------: | :-----------------: | :-------: | :-------: | :-------- |
+| **Counting sort**     | n + r           | n + r               | n + r               | n + r     | Sim       | r - Maior número no vetor |
+
+## Referências
+
+- [Wikipedia](https://en.wikipedia.org/wiki/Counting_sort)
+- [YouTube](https://www.youtube.com/watch?v=OKd534EWcdk&index=61&t=0s&list=PLLXdhg_r2hKA7DPDsunoDZ-Z769jWn4R8)
+- [EfficientAlgorithms](https://efficientalgorithms.blogspot.com/2016/09/lenear-sorting-counting-sort.html)

src/algorithms/sorting/heap-sort/README.md

@@ -1,5 +1,8 @@
 # Heap Sort
 
+_Read this in other languages:_
+[_Português_](README.pt-BR.md)
+
 Heapsort is a comparison-based sorting algorithm.
 Heapsort can be thought of as an improved selection
 sort: like that algorithm, it divides its input into

src/algorithms/sorting/heap-sort/README.pt-BR.md

@@ -0,0 +1,20 @@
+# Heap Sort
+
+_Leia isso em outros idiomas:_
+[_English_](README.md)
+
+Heapsort é um algoritmo de ordenação baseado em comparação. O Heapsort pode ser pensado como uma seleção aprimorada sort: como esse algoritmo, ele divide sua entrada em uma região classificada e uma região não classificada, e iterativamente encolhe a região não classificada extraindo o maior elemento e movendo-o para a região classificada. A melhoria consiste no uso de uma estrutura de dados heap em vez de uma busca em tempo linear para encontrar o máximo.
+
+![Visualização do Algoritmo](https://upload.wikimedia.org/wikipedia/commons/1/1b/Sorting_heapsort_anim.gif)
+
+![Visualização do Algoritmo](https://upload.wikimedia.org/wikipedia/commons/4/4d/Heapsort-example.gif)
+
+## Complexidade
+
+| Nome                  | Melhor            | Média             | Pior               | Memória    | Estável    | Comentários  |
+| --------------------- | :-------------: | :-----------------: | :-----------------: | :-------: | :-------: | :-------- |
+| **Heap sort**         | n log(n)   | n log(n)       | n log(n)       | 1         | Não        |           |
+
+## Referências
+
+[Wikipedia](https://en.wikipedia.org/wiki/Heapsort)

src/algorithms/sorting/insertion-sort/README.md

@@ -1,5 +1,8 @@
 # Insertion Sort
 
+_Read this in other languages:_
+[_Português_](README.pt-BR.md)
+
 Insertion sort is a simple sorting algorithm that builds 
 the final sorted array (or list) one item at a time. 
 It is much less efficient on large lists than more 

src/algorithms/sorting/insertion-sort/README.pt-BR.md

@@ -0,0 +1,22 @@
+# Insertion Sort
+
+_Leia isso em outros idiomas:_
+[_English_](README.md)
+
+A ordenação por inserção é um algoritmo de ordenação simples que criaa matriz classificada final (ou lista) um item de cada vez.
+É muito menos eficiente em grandes listas do que mais algoritmos avançados, como quicksort, heapsort ou merge
+ordenar.
+
+![Visualização do Algoritmo](https://upload.wikimedia.org/wikipedia/commons/4/42/Insertion_sort.gif)
+
+![Visualização do Algoritmo](https://upload.wikimedia.org/wikipedia/commons/0/0f/Insertion-sort-example-300px.gif)
+
+## Complexidade
+
+| Nome                  | Melhor            | Média             | Pior               | Memória    | Estável    | Comentários  |
+| --------------------- | :-------------: | :-----------------: | :-----------------: | :-------: | :-------: | :-------- |
+| **Insertion sort**    | n               | n<sup>2</sup>       | n<sup>2</sup>       | 1         | Sim       |           |
+
+## Referências
+
+[Wikipedia](https://en.wikipedia.org/wiki/Insertion_sort)

src/algorithms/sorting/merge-sort/README.md

@@ -1,7 +1,8 @@
 # Merge Sort
 
 _Read this in other languages:_
-[_한국어_](README.ko-KR.md)
+[_한국어_](README.ko-KR.md),
+[_Português_](README.pt-BR.md)
 
 In computer science, merge sort (also commonly spelled
 mergesort) is an efficient, general-purpose,

src/algorithms/sorting/merge-sort/README.pt-BR.md

@@ -0,0 +1,38 @@
+# Merge Sort
+
+_Leia isso em outros idiomas:_
+[_한국어_](README.ko-KR.md),
+[_English_](README.md)
+
+Em ciência da computação, merge sort (também comumente escrito
+mergesort) é uma ferramenta eficiente, de propósito geral,
+algoritmo de ordenação baseado em comparação. A maioria das implementações
+produzir uma classificação estável, o que significa que a implementação
+preserva a ordem de entrada de elementos iguais na ordenação
+resultado. Mergesort é um algoritmo de divisão e conquista que
+foi inventado por John von Neumann em 1945.
+
+Um exemplo de classificação de mesclagem. Primeiro divida a lista em
+a menor unidade (1 elemento), então compare cada
+elemento com a lista adjacente para classificar e mesclar o
+duas listas adjacentes. Finalmente todos os elementos são ordenados
+e mesclado.
+
+![Merge Sort](https://upload.wikimedia.org/wikipedia/commons/c/cc/Merge-sort-example-300px.gif)
+
+Um algoritmo de classificação de mesclagem recursivo usado para classificar uma matriz de 7
+valores inteiros. Estes são os passos que um ser humano daria para
+emular merge sort (top-down).
+
+![Merge Sort](https://upload.wikimedia.org/wikipedia/commons/e/e6/Merge_sort_algorithm_diagram.svg)
+
+## Complexidade
+
+| Nome                  | Melhor            | Média             | Pior               | Memória    | Estável    | Comentários  |
+| --------------------- | :-------------: | :-----------------: | :-----------------: | :-------: | :-------: | :-------- |
+| **Merge sort**        | n log(n)   | n log(n)       | n log(n)       | n         | Sim       |           |
+
+## Referências
+
+- [Wikipedia](https://en.wikipedia.org/wiki/Merge_sort)
+- [YouTube](https://www.youtube.com/watch?v=KF2j-9iSf4Q&index=27&list=PLLXdhg_r2hKA7DPDsunoDZ-Z769jWn4R8)

src/algorithms/sorting/quick-sort/README.md

@@ -1,8 +1,8 @@
 # Quicksort
 
 _Read this in other languages:_
-[_Português_](README.pt-BR.md),
-[_简体中文_](README.zh-CN.md)
+[_简体中文_](README.zh-CN.md),
+[_Português_](README.pt-BR.md)
 
 Quicksort is a divide and conquer algorithm.
 Quicksort first divides a large array into two smaller