Skip to content

Commit da6ae08

Browse files
StPfeffertrekhleb
StPfeffer
and
trekhleb
authoredOct 10, 2022
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]>
1 parent 9ef6650 commit da6ae08

File tree

34 files changed

+567
-145
lines changed

34 files changed

+567
-145
lines changed
 

‎README.pt-BR.md

+112-105
Large diffs are not rendered by default.

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

+2-1
Original file line numberDiff line numberDiff line change
@@ -1,7 +1,8 @@
11
# Reversed Linked List Traversal
22

33
_Read this in other languages:_
4-
[中文](README.zh-CN.md)
4+
[_中文_](README.zh-CN.md),
5+
[_Português_](README.pt-BR.md)
56

67
The task is to traverse the given linked list in reversed order.
78

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

+23
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,23 @@
1+
# Travessia de Lista Encadeada Reversa
2+
3+
_Leia isso em outros idiomas:_
4+
[_中文_](README.zh-CN.md),
5+
[_English_](README.md)
6+
7+
A tarefa é percorrer a lista encadeada fornecida em ordem inversa.
8+
9+
Por exemplo, para a seguinte lista vinculada:
10+
11+
![](https://upload.wikimedia.org/wikipedia/commons/6/6d/Singly-linked-list.svg)
12+
13+
A ordem de travessia deve ser:
14+
15+
```texto
16+
37 → 99 → 12
17+
```
18+
19+
A complexidade de tempo é `O(n)` porque visitamos cada nó apenas uma vez.
20+
21+
## Referência
22+
23+
- [Wikipedia](https://en.wikipedia.org/wiki/Linked_list)

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

+2-1
Original file line numberDiff line numberDiff line change
@@ -2,7 +2,8 @@
22

33
_Read this in other languages:_
44
[_Русский_](README.ru-RU.md),
5-
[中文](README.zh-CN.md)
5+
[_中文_](README.zh-CN.md),
6+
[_Português_](README.pt-BR.md)
67

78
The task is to traverse the given linked list in straight order.
89

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

+24
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,24 @@
1+
# Travessia de Lista Encadeada
2+
3+
_Leia isso em outros idiomas:_
4+
[_Русский_](README.ru-RU.md),
5+
[_中文_](README.zh-CN.md),
6+
[_English_](README.md)
7+
8+
A tarefa é percorrer a lista encadeada fornecida em ordem direta.
9+
10+
Por exemplo, para a seguinte lista vinculada:
11+
12+
![Singly linked list](https://upload.wikimedia.org/wikipedia/commons/6/6d/Singly-linked-list.svg)
13+
14+
A ordem de travessia deve ser:
15+
16+
```texto
17+
12 → 99 → 37
18+
```
19+
20+
A complexidade de tempo é `O(n)` porque visitamos cada nó apenas uma vez.
21+
22+
## Referência
23+
24+
- [Wikipedia](https://en.wikipedia.org/wiki/Linked_list)

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

+3
Original file line numberDiff line numberDiff line change
@@ -1,5 +1,8 @@
11
# k-Means Algorithm
22

3+
_Read this in other languages:_
4+
[_Português_](README.pt-BR.md)
5+
36
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.
47

58
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

+35
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,35 @@
1+
# Algoritmo k-Means
2+
3+
_Leia isso em outros idiomas:_
4+
[_English_](README.md)
5+
6+
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.
7+
8+
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.
9+
10+
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.
11+
12+
![Distância Euclidiana entre dois pontos](https://upload.wikimedia.org/wikipedia/commons/5/55/Euclidean_distance_2d.svg)
13+
14+
_Fonte: [Wikipedia](https://en.wikipedia.org/wiki/Euclidean_distance)_
15+
16+
O algoritmo é o seguinte:
17+
18+
1. Verifique se há erros como dados inválidos/inconsistentes
19+
2. Inicialize os locais do cluster `k` com pontos `k` iniciais/aleatórios
20+
3. Calcule a distância de cada ponto de dados de cada cluster
21+
4. Atribua o rótulo do cluster de cada ponto de dados igual ao do cluster em sua distância mínima
22+
5. Calcule o centroide de cada cluster com base nos pontos de dados que ele contém
23+
6. Repita cada uma das etapas acima até que as localizações do centroide estejam variando
24+
25+
Aqui está uma visualização do agrupamento k-Means para melhor compreensão:
26+
27+
![KNN Visualization 1](https://upload.wikimedia.org/wikipedia/commons/e/ea/K-means_convergence.gif)
28+
29+
_Fonte: [Wikipedia](https://en.wikipedia.org/wiki/K-means_clustering)_
30+
31+
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.
32+
33+
## Referências
34+
35+
- [k-Means neighbors algorithm on Wikipedia](https://en.wikipedia.org/wiki/K-means_clustering)

‎src/algorithms/ml/knn/README.md

+3
Original file line numberDiff line numberDiff line change
@@ -1,5 +1,8 @@
11
# k-Nearest Neighbors Algorithm
22

3+
_Read this in other languages:_
4+
[_Português_](README.pt-BR.md)
5+
36
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.
47

58
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

+44
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,44 @@
1+
# Algoritmo de k-vizinhos mais próximos
2+
3+
_Leia isso em outros idiomas:_
4+
[_English_](README.md)
5+
6+
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.
7+
8+
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.
9+
10+
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.
11+
12+
![Distância Euclidiana entre dois pontos](https://upload.wikimedia.org/wikipedia/commons/5/55/Euclidean_distance_2d.svg)
13+
14+
_Fonte: [Wikipedia](https://en.wikipedia.org/wiki/Euclidean_distance)_
15+
16+
O algoritmo é o seguinte:
17+
18+
1. Verifique se há erros como dados/rótulos inválidos.
19+
2. Calcule a distância euclidiana de todos os pontos de dados nos dados de treinamento com o ponto de classificação
20+
3. Classifique as distâncias dos pontos junto com suas classes em ordem crescente
21+
4. Pegue as classes iniciais `K` e encontre o modo para obter a classe mais semelhante
22+
5. Informe a classe mais semelhante
23+
24+
Aqui está uma visualização da classificação k-NN para melhor compreensão:
25+
26+
![KNN Visualization 1](https://upload.wikimedia.org/wikipedia/commons/e/e7/KnnClassification.svg)
27+
28+
_Fonte: [Wikipedia](https://en.wikipedia.org/wiki/K-nearest_neighbors_algorithm)_
29+
30+
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).
31+
32+
Outro exemplo de classificação k-NN:
33+
34+
![KNN Visualization 2](https://media.geeksforgeeks.org/wp-content/uploads/graph2-2.png)
35+
36+
_Fonte: [GeeksForGeeks](https://media.geeksforgeeks.org/wp-content/uploads/graph2-2.png)_
37+
38+
Aqui, como podemos ver, a classificação dos pontos desconhecidos será julgada pela proximidade com outros pontos.
39+
40+
É importante notar que `K` é preferível ter valores ímpares para desempate. Normalmente `K` é tomado como `3` ou `5`.
41+
42+
## Referências
43+
44+
- [k-nearest neighbors algorithm on Wikipedia](https://en.wikipedia.org/wiki/K-nearest_neighbors_algorithm)

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

+7-4
Original file line numberDiff line numberDiff line change
@@ -1,16 +1,19 @@
11
# Bubble Sort
22

3+
_Leia isso em outros idiomas:_
4+
[_English_](README.md)
5+
36
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.
47

58
![Algorithm Visualization](https://upload.wikimedia.org/wikipedia/commons/c/c8/Bubble-sort-example-300px.gif)
69

7-
## Complexity
10+
## Complexidade
811

9-
| Name | Best | Average | Worst | Memory | Stable | Comments |
12+
| Nome | Melhor | Média | Pior | Memória | Estável | Comentários |
1013
| --------------------- | :-------------: | :-----------------: | :-----------------: | :-------: | :-------: | :-------- |
11-
| **Bubble sort** | n | n<sup>2</sup> | n<sup>2</sup> | 1 | Yes | |
14+
| **Bubble sort** | n | n<sup>2</sup> | n<sup>2</sup> | 1 | Sim | |
1215

13-
## References
16+
## Referências
1417

1518
- [Wikipedia](https://pt.wikipedia.org/wiki/Bubble_sort)
1619
- [YouTube](https://www.youtube.com/watch?v=6Gv8vg0kcHc&index=27&t=0s&list=PLLXdhg_r2hKA7DPDsunoDZ-Z769jWn4R8)

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

+3
Original file line numberDiff line numberDiff line change
@@ -1,5 +1,8 @@
11
# Counting Sort
22

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

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

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

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

+3
Original file line numberDiff line numberDiff line change
@@ -1,5 +1,8 @@
11
# Heap Sort
22

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

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

+20
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,20 @@
1+
# Heap Sort
2+
3+
_Leia isso em outros idiomas:_
4+
[_English_](README.md)
5+
6+
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.
7+
8+
![Visualização do Algoritmo](https://upload.wikimedia.org/wikipedia/commons/1/1b/Sorting_heapsort_anim.gif)
9+
10+
![Visualização do Algoritmo](https://upload.wikimedia.org/wikipedia/commons/4/4d/Heapsort-example.gif)
11+
12+
## Complexidade
13+
14+
| Nome | Melhor | Média | Pior | Memória | Estável | Comentários |
15+
| --------------------- | :-------------: | :-----------------: | :-----------------: | :-------: | :-------: | :-------- |
16+
| **Heap sort** | n&nbsp;log(n) | n&nbsp;log(n) | n&nbsp;log(n) | 1 | Não | |
17+
18+
## Referências
19+
20+
[Wikipedia](https://en.wikipedia.org/wiki/Heapsort)

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

+3
Original file line numberDiff line numberDiff line change
@@ -1,5 +1,8 @@
11
# Insertion Sort
22

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

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

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

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

+2-1
Original file line numberDiff line numberDiff line change
@@ -1,7 +1,8 @@
11
# Merge Sort
22

33
_Read this in other languages:_
4-
[_한국어_](README.ko-KR.md)
4+
[_한국어_](README.ko-KR.md),
5+
[_Português_](README.pt-BR.md)
56

67
In computer science, merge sort (also commonly spelled
78
mergesort) is an efficient, general-purpose,

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

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

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

+2-2
Original file line numberDiff line numberDiff line change
@@ -1,8 +1,8 @@
11
# Quicksort
22

33
_Read this in other languages:_
4-
[_Português_](README.pt-BR.md),
5-
[_简体中文_](README.zh-CN.md)
4+
[_简体中文_](README.zh-CN.md),
5+
[_Português_](README.pt-BR.md)
66

77
Quicksort is a divide and conquer algorithm.
88
Quicksort first divides a large array into two smaller

‎src/algorithms/sorting/quick-sort/README.pt-BR.md

+8-4
Original file line numberDiff line numberDiff line change
@@ -1,15 +1,19 @@
11
# Quicksort
22

3-
Quicksort é um algoritmo de dividir para conquistar é um algoritmo de divisão e conquista.
3+
_Leia isso em outros idiomas:_
4+
[_简体中文_](README.zh-CN.md),
5+
[_English_](README.md)
6+
7+
Quicksort é um algoritmo de dividir para conquistar.
48
Quicksort primeiro divide uma grande matriz em duas menores
59
submatrizes: os elementos baixos e os elementos altos.
6-
O Quicksort pode então classificar recursivamente as submatrizes
10+
O Quicksort pode então classificar recursivamente as submatrizes.
711

812
As etapas são:
913

1014
1. Escolha um elemento, denominado pivô, na matriz.
1115
2. Particionamento: reordene a matriz para que todos os elementos com
12-
valores menores que o pivô vêm antes do pivô, enquanto todos
16+
valores menores que o pivô estejam antes do pivô, enquanto todos
1317
elementos com valores maiores do que o pivô vêm depois dele
1418
(valores iguais podem ser usados em qualquer direção). Após este particionamento,
1519
o pivô está em sua posição final. Isso é chamado de
@@ -27,7 +31,7 @@ As linhas horizontais são valores dinâmicos.
2731

2832
| Nome | Melhor | Média | Pior | Memória | Estável | Comentários |
2933
| --------------------- | :-------------: | :-----------------: | :-----------------: | :-------: | :-------: | :-------- |
30-
| **Quick sort** | n&nbsp;log(n) | n&nbsp;log(n) | n<sup>2</sup> | log(n) | No | Quicksort geralmente é feito no local com espaço de pilha O(log(n)) |
34+
| **Quick sort** | n&nbsp;log(n) | n&nbsp;log(n) | n<sup>2</sup> | log(n) | Não | Quicksort geralmente é feito no local com espaço de pilha O(log(n)) |
3135

3236
## Referências
3337

‎src/algorithms/sorting/radix-sort/README.md

+3
Original file line numberDiff line numberDiff line change
@@ -1,5 +1,8 @@
11
# Radix Sort
22

3+
_Read this in other languages:_
4+
[_Português_](README.pt-BR.md),
5+
36
In computer science, **radix sort** is a non-comparative integer sorting
47
algorithm that sorts data with integer keys by grouping keys by the individual
58
digits which share the same significant position and value. A positional notation

‎src/algorithms/sorting/radix-sort/README.pt-BR.md

+48
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,48 @@
1+
# Radix Sort
2+
3+
_Leia isso em outros idiomas:_
4+
[_English_](README.md)
5+
6+
Em ciência da computação, **radix sort** é uma classificação inteira não comparativa
7+
algoritmo que classifica os dados com chaves inteiras agrupando as chaves pelo indivíduo
8+
dígitos que compartilham a mesma posição e valor significativos. Uma notação posicional
9+
é necessário, mas porque os números inteiros podem representar cadeias de caracteres
10+
(por exemplo, nomes ou datas) e números de ponto flutuante especialmente formatados, base
11+
sort não está limitado a inteiros.
12+
13+
*De onde vem o nome?*
14+
15+
Em sistemas numéricos matemáticos, a *radix* ou base é o número de dígitos únicos,
16+
incluindo o dígito zero, usado para representar números em um sistema de numeração posicional.
17+
Por exemplo, um sistema binário (usando números 0 e 1) tem uma raiz de 2 e um decimal
18+
sistema (usando números de 0 a 9) tem uma raiz de 10.
19+
20+
## Eficiência
21+
22+
O tópico da eficiência do radix sort comparado a outros algoritmos de ordenação é
23+
um pouco complicado e sujeito a muitos mal-entendidos. Se raiz
24+
sort é igualmente eficiente, menos eficiente ou mais eficiente do que o melhor
25+
algoritmos baseados em comparação depende dos detalhes das suposições feitas.
26+
A complexidade de classificação de raiz é `O(wn)` para chaves `n` que são inteiros de tamanho de palavra `w`.
27+
Às vezes, `w` é apresentado como uma constante, o que tornaria a classificação radix melhor
28+
(para `n` suficientemente grande) do que os melhores algoritmos de ordenação baseados em comparação,
29+
que todos realizam comparações `O(n log n)` para classificar chaves `n`. No entanto, em
30+
geral `w` não pode ser considerado uma constante: se todas as chaves `n` forem distintas,
31+
então `w` tem que ser pelo menos `log n` para que uma máquina de acesso aleatório seja capaz de
32+
armazená-los na memória, o que dá na melhor das hipóteses uma complexidade de tempo `O(n log n)`. Este
33+
parece tornar a ordenação radix no máximo tão eficiente quanto a melhor
34+
ordenações baseadas em comparação (e pior se as chaves forem muito mais longas que `log n`).
35+
36+
![Radix Sort](https://www.researchgate.net/publication/291086231/figure/fig1/AS:614214452404240@1523451545568/Simplistic-illustration-of-the-steps-performed-in-a-radix-sort-In-this-example-the.png)
37+
38+
## Complexidade
39+
40+
| Nome | Melhor | Média | Pior | Memória | Estável | Comentários |
41+
| --------------------- | :-------------: | :-----------------: | :-----------------: | :-------: | :-------: | :-------- |
42+
| **Radix sort** | n * k | n * k | n * k | n + k | Sim | k - comprimento da chave mais longa |
43+
44+
## Referências
45+
46+
- [Wikipedia](https://en.wikipedia.org/wiki/Radix_sort)
47+
- [YouTube](https://www.youtube.com/watch?v=XiuSW_mEn7g&index=62&t=0s&list=PLLXdhg_r2hKA7DPDsunoDZ-Z769jWn4R8)
48+
- [ResearchGate](https://www.researchgate.net/figure/Simplistic-illustration-of-the-steps-performed-in-a-radix-sort-In-this-example-the_fig1_291086231)

‎src/algorithms/sorting/selection-sort/README.md

+1-1
Original file line numberDiff line numberDiff line change
@@ -1,7 +1,7 @@
11
# Selection Sort
22

33
_Read this in other languages:_
4-
[Português brasileiro](README.pt-BR.md).
4+
[_Português_](README.pt-BR.md).
55

66
Selection sort is a sorting algorithm, specifically an
77
in-place comparison sort. It has O(n2) time complexity,

‎src/algorithms/sorting/selection-sort/README.pt-BR.md

+2-2
Original file line numberDiff line numberDiff line change
@@ -1,7 +1,7 @@
11
# Selection Sort
22

3-
_Leia isso em outras línguas:_
4-
[english](README.md).
3+
_Leia isso em outros idiomas:_
4+
[_English_](README.md).
55

66
Selection Sort é um algoritmo de ordenação, mais especificamente um algoritmo de ordenação por comparação in-place (requer uma quantidade constante de espaço de memória adicional). Tem complexidade O(n²), tornando-o ineficiente em listas grandes e, geralmente, tem desempenho inferior ao similar Insertion Sort. O Selection Sort é conhecido por sua simplicidade e tem vantagens de desempenho sobre algoritmos mais complexos em certas situações, particularmente quando a memória auxiliar é limitada.
77

‎src/algorithms/sorting/shell-sort/README.md

+3
Original file line numberDiff line numberDiff line change
@@ -1,5 +1,8 @@
11
# Shellsort
22

3+
_Read this in other languages:_
4+
[_Português_](README.pt-BR.md).
5+
36
Shellsort, also known as Shell sort or Shell's method,
47
is an in-place comparison sort. It can be seen as either a
58
generalization of sorting by exchange (bubble sort) or sorting

‎src/algorithms/sorting/shell-sort/README.pt-BR.md

+60
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,60 @@
1+
# Shellsort
2+
3+
_Leia isso em outros idiomas:_
4+
[_English_](README.md).
5+
6+
Shellsort, também conhecido como Shell sort ou método de Shell,
7+
é uma classificação de comparação in-loco. Pode ser visto tanto como um
8+
generalização da ordenação por troca (bubble sort) ou ordenação
9+
por inserção (ordenação por inserção). O método começa classificando
10+
pares de elementos distantes um do outro, então progressivamente
11+
reduzindo a distância entre os elementos a serem comparados. Iniciando
12+
com elementos distantes, pode mover alguns fora do lugar
13+
elementos em posição mais rápido do que um simples vizinho mais próximo
14+
intercâmbio
15+
16+
![Shellsort](https://upload.wikimedia.org/wikipedia/commons/d/d8/Sorting_shellsort_anim.gif)
17+
18+
## Como o Shellsort funciona?
19+
20+
Para nosso exemplo e facilidade de compreensão, tomamos o intervalo
21+
de `4`. Faça uma sub-lista virtual de todos os valores localizados no
22+
intervalo de 4 posições. Aqui esses valores são
23+
`{35, 14}`, `{33, 19}`, `{42, 27}` e `{10, 44}`
24+
25+
![Shellsort](https://www.tutorialspoint.com/data_structures_algorithms/images/shell_sort_gap_4.jpg)
26+
27+
Comparamos valores em cada sublista e os trocamos (se necessário)
28+
na matriz original. Após esta etapa, o novo array deve
29+
parece com isso
30+
31+
![Shellsort](https://www.tutorialspoint.com/data_structures_algorithms/images/shell_sort_step_1.jpg)
32+
33+
Então, pegamos o intervalo de 2 e essa lacuna gera duas sub-listas
34+
- `{14, 27, 35, 42}`, `{19, 10, 33, 44}`
35+
36+
![Shellsort](https://www.tutorialspoint.com/data_structures_algorithms/images/shell_sort_gap_2.jpg)
37+
38+
Comparamos e trocamos os valores, se necessário, no array original.
39+
Após esta etapa, a matriz deve ficar assim
40+
41+
![Shellsort](https://www.tutorialspoint.com/data_structures_algorithms/images/shell_sort_step_2.jpg)
42+
43+
> OBS: Na imagem abaixo há um erro de digitação e a matriz de resultados deve ser `[14, 10, 27, 19, 35, 33, 42, 44]`.
44+
45+
Finalmente, ordenamos o resto do array usando o intervalo de valor 1.
46+
A classificação de shell usa a classificação por inserção para classificar a matriz.
47+
48+
![Shellsort](https://www.tutorialspoint.com/data_structures_algorithms/images/shell_sort.jpg)
49+
50+
## Complexidade
51+
52+
| Nome | Melhor | Média | Pior | Memória | Estável | Comentários |
53+
| --------------------- | :-------------: | :-----------------: | :-----------------: | :-------: | :-------: | :-------- |
54+
| **Shell sort** | n&nbsp;log(n) | depends on gap sequence | n&nbsp;(log(n))<sup>2</sup> | 1 | Não | |
55+
56+
## Referências
57+
58+
- [Tutorials Point](https://www.tutorialspoint.com/data_structures_algorithms/shell_sort_algorithm.htm)
59+
- [Wikipedia](https://en.wikipedia.org/wiki/Shellsort)
60+
- [YouTube by Rob Edwards](https://www.youtube.com/watch?v=ddeLSDsYVp8&index=79&list=PLLXdhg_r2hKA7DPDsunoDZ-Z769jWn4R8)

‎src/data-structures/bloom-filter/README.pt-BR.md

+2-2
Original file line numberDiff line numberDiff line change
@@ -3,7 +3,7 @@
33
O **bloom filter** é uma estrutura de dados probabilística
44
espaço-eficiente designada para testar se um elemento está
55
ou não presente em um conjunto de dados. Foi projetado para ser
6-
incrivelmente rápido e utilizar o mínimo de memória ao
6+
incrivelmente rápida e utilizar o mínimo de memória ao
77
potencial custo de um falso-positivo. Correspondências
88
_falsas positivas_ são possíveis, contudo _falsos negativos_
99
não são - em outras palavras, a consulta retorna
@@ -12,7 +12,7 @@ não são - em outras palavras, a consulta retorna
1212
Bloom propôs a técnica para aplicações onde a quantidade
1313
de entrada de dados exigiria uma alocação de memória
1414
impraticavelmente grande se as "convencionais" técnicas
15-
error-free hashing fossem aplicado.
15+
error-free hashing fossem aplicadas.
1616

1717
## Descrição do algoritmo
1818

‎src/data-structures/disjoint-set/README.pt-BR.md

+5-5
Original file line numberDiff line numberDiff line change
@@ -1,18 +1,18 @@
1-
# Conjunto Disjuntor (Disjoint Set)
1+
# Conjunto Disjunto (Disjoint Set)
22

3-
**Conjunto Disjuntor**
3+
**Conjunto Disjunto**
44

5-
**Conjunto Disjuntor** é uma estrutura de dados (também chamado de
5+
**Conjunto Disjunto** é uma estrutura de dados (também chamado de
66
estrutura de dados de union–find ou merge–find) é uma estrutura de dados
77
que rastreia um conjunto de elementos particionados em um número de
88
subconjuntos separados (sem sobreposição).
99
Ele fornece operações de tempo quase constante (limitadas pela função
1010
inversa de Ackermann) para *adicionar novos conjuntos*, para
1111
*mesclar/fundir conjuntos existentes* e para *determinar se os elementos
1212
estão no mesmo conjunto*.
13-
Além de muitos outros usos (veja a seção Applications), conjunto disjuntor
13+
Além de muitos outros usos (veja a seção Applications), conjuntos disjuntos
1414
desempenham um papel fundamental no algoritmo de Kruskal para encontrar a
15-
árvore geradora mínima de um gráfico (graph).
15+
árvore geradora mínima de um grafo (graph).
1616

1717
![disjoint set](https://upload.wikimedia.org/wikipedia/commons/6/67/Dsu_disjoint_sets_init.svg)
1818

‎src/data-structures/doubly-linked-list/README.pt-BR.md

+3-3
Original file line numberDiff line numberDiff line change
@@ -4,7 +4,7 @@ Na ciência da computação, uma **lista duplamente conectada** é uma estrutura
44
de dados vinculada que se consistem em um conjunto de registros
55
sequencialmente vinculados chamados de nós (nodes). Em cada nó contém dois
66
campos, chamados de ligações, que são referenciados ao nó anterior e posterior
7-
de uma sequência de nós. O começo e o fim dos nós anteriormente e posteiormente
7+
de uma sequência de nós. O começo e o fim dos nós anteriormente e posteriormente
88
ligados, respectiviamente, apontam para algum tipo de terminação, normalmente
99
um nó sentinela ou nulo, para facilitar a travessia da lista. Se existe
1010
somente um nó sentinela, então a lista é ligada circularmente através do nó
@@ -20,7 +20,7 @@ Enquanto adicionar ou remover um nó de uma lista duplamente vinculada requer
2020
alterar mais ligações (conexões) do que em uma lista encadeada individualmente
2121
(singly linked list), as operações são mais simples e potencialmente mais
2222
eficientes (para nós que não sejam nós iniciais) porque não há necessidade
23-
de se manter rastreamento do nó anterior durante a travessia ou não há
23+
de manter um rastreamento do nó anterior durante a travessia ou não há
2424
necessidade de percorrer a lista para encontrar o nó anterior, para que
2525
então sua ligação/conexão possa ser modificada.
2626

@@ -44,7 +44,7 @@ Add(value)
4444
end Add
4545
```
4646

47-
### Deletar
47+
### Remoção
4848

4949
```text
5050
Remove(head, value)

‎src/data-structures/hash-table/README.pt-BR.md

+2-2
Original file line numberDiff line numberDiff line change
@@ -1,6 +1,6 @@
11
# Tabela de Hash (Hash Table)
22

3-
Na ciência da computação, uma **tabela de hash** (hash map) é uma
3+
Na ciência da computação, uma **tabela de hash** (hash table) é uma
44
estrutura de dados pela qual implementa um tipo de dado abstrado de
55
*array associativo*, uma estrutura que pode *mapear chaves para valores*.
66
Uma tabela de hash utiliza uma *função de hash* para calcular um índice
@@ -10,7 +10,7 @@ pode ser encontrado.
1010
Idealmente, a função de hash irá atribuir a cada chave a um bucket único,
1111
mas a maioria dos designs de tabela de hash emprega uma função de hash
1212
imperfeita, pela qual poderá causar colisões de hashes onde a função de hash
13-
gera o mesmo índice para mais de uma chave.Tais colisões devem ser
13+
gera o mesmo índice para mais de uma chave. Tais colisões devem ser
1414
acomodados de alguma forma.
1515

1616
![Hash Table](./images/hash-table.jpeg)

‎src/data-structures/priority-queue/README.pt-BR.md

+4-4
Original file line numberDiff line numberDiff line change
@@ -1,7 +1,7 @@
11
# Fila de Prioridade (Priority Queue)
22

3-
Na ciência da computação, uma **fila de prioridade** é um tipo de dados
4-
abastrato que é como uma fila regular (regular queue) ou estrutura de
3+
Na ciência da computação, uma **fila de prioridade** é um tipo de estrutura de
4+
dados abastrata que é como uma fila regular (regular queue) ou estrutura de
55
dados de pilha (stack), mas adicionalmente cada elemento possui uma
66
"prioridade" associada.
77

@@ -10,11 +10,11 @@ antes de um elemento com baixa prioridade. Caso dois elementos posusam a
1010
mesma prioridade, eles serão servidos de acordo com sua ordem na fila.
1111

1212
Enquanto as filas de prioridade são frequentemente implementadas com
13-
pilhas (heaps), elas são conceitualmente distintas das pilhas (heaps).
13+
pilhas (stacks), elas são conceitualmente distintas das pilhas (stacks).
1414
A fila de prioridade é um conceito abstrato como uma "lista" (list) ou
1515
um "mapa" (map); assim como uma lista pode ser implementada com uma
1616
lista encadeada (liked list) ou um array, a fila de prioridade pode ser
17-
implementada com uma pilha (heap) ou com uima variedade de outros métodos,
17+
implementada com uma pilha (stack) ou com uma variedade de outros métodos,
1818
como um array não ordenado (unordered array).
1919

2020
## Referências

‎src/data-structures/stack/README.pt-BR.md

+4-4
Original file line numberDiff line numberDiff line change
@@ -1,14 +1,14 @@
1-
# Stack
1+
# Pilha (Stack)
22

3-
Na ciência da computação, um **stack** é uma estrutura de dados abstrata
3+
Na ciência da computação, uma **pilha** é uma estrutura de dados abstrata
44
que serve como uma coleção de elementos com duas operações principais:
55

66
* **push**, pela qual adiciona um elemento à coleção, e
77
* **pop**, pela qual remove o último elemento adicionado.
88

99
A ordem em que os elementos saem de um _stack_ dá origem ao seu
10-
nome alternativo, LIFO (last in, first out). Adicionalmente, uma
11-
espiar a operação pode dar acesso ao topo sem modificar o _stack_.
10+
nome alternativo, LIFO (last in, first out). Adicionalmente, uma operação
11+
de espiada (peek) pode dar acesso ao topo sem modificar o _stack_.
1212
O nome "stack" para este tipo de estrutura vem da analogia de
1313
um conjunto de itens físicos empilhados uns sobre os outros,
1414
o que facilita retirar um item do topo da pilha, enquanto para chegar a

‎src/data-structures/tree/README.pt-BR.md

+1-1
Original file line numberDiff line numberDiff line change
@@ -8,7 +8,7 @@
88

99
Na ciência da computação, uma **árvore** é uma estrutura de dados
1010
abstrada (ADT) amplamente utilizada - ou uma estrutura de dados
11-
implementando este ADT que simula uma estrutura hierarquica de árvore,
11+
implementando este ADT que simula uma estrutura hierárquica de árvore,
1212
com valor raíz e sub-árvores de filhos com um nó pai, representado
1313
como um conjunto de nós conectados.
1414

‎src/data-structures/trie/README.pt-BR.md

+3-3
Original file line numberDiff line numberDiff line change
@@ -1,9 +1,9 @@
1-
# Trie
1+
# Árvore de Prefixos (Trie)
22

33
Na ciência da computação, uma **trie**, também chamada de árvore digital (digital tree)
44
e algumas vezes de _radix tree_ ou _prefix tree_ (tendo em vista que eles
5-
podem ser pesquisados por prefixos), é um tipo de árvore de pesquisa, uma
6-
uma estrutura de dados de árvore ordenada que é usado para armazenar um
5+
podem ser pesquisados por prefixos), é um tipo de árvore de pesquisa, uma
6+
estrutura de dados de árvore ordenada que é usado para armazenar um
77
conjunto dinâmico ou matriz associativa onde as chaves são geralmente _strings_.
88
Ao contrário de uma árvore de pesquisa binária (binary search tree),
99
nenhum nó na árvore armazena a chave associada a esse nó; em vez disso,

0 commit comments

Comments
 (0)
Please sign in to comment.