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]>

Author: StPfeffer

README.pt-BR.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.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/reverse-traversal/README.pt-BR.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.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/linked-list/traversal/README.pt-BR.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.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/k-means/README.pt-BR.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.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/ml/knn/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)