gaspersic/freeCodeCamp
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

fix(guide): radix sort formatting/inconsistencies (#36507)

Browse Source 
* fix(guide): radix sort formatting/inconsistencies

Signed-off-by: Jonathan <theflametrooper@gmail.com>

* fix(guide): radix sort spacing should be 2 spaces

Signed-off-by: Jonathan <theflametrooper@gmail.com>
This commit is contained in:
Jonathan Graham
2019-07-29 02:58:07 +01:00
committed by Randell Dawson
parent ba6ae7154c
commit 04e98783cd
6 changed files with 268 additions and 193 deletions
Download Patch File Download Diff File Expand all files Collapse all files

103
guide/arabic/algorithms/sorting-algorithms/radix-sort/index.md
View File

@ -59,54 +59,71 @@ QuickSort و MergeSort و HeapSort هي خوارزميات الفرز على أ
تنفيذ في C: تنفيذ في C:
``` ```c
void countsort(int arr[],int n,int place){ void countsort(int arr[],int n,int place){
int i,freq[range]={0}; // range for integers is 10 as digits range from 0-9
int output[n];
int i,freq[range]={0}; //range for integers is 10 as digits range from 0-9 for(i=0;i<n;i++)
freq[(arr[i]/place)%range]++;
int output[n];
for(i=1;i<range;i++)
for(i=0;i<n;i++) freq[i]+=freq[i-1];
freq[(arr[i]/place)%range]++; for(i=n-1;i>=0;i--){
output[freq[(arr[i]/place)%range]-1]=arr[i];
for(i=1;i<range;i++) freq[(arr[i]/place)%range]--;
}
freq[i]+=freq[i-1];
for(i=0;i<n;i++)
for(i=n-1;i>=0;i--){ arr[i]=output[i];
output[freq[(arr[i]/place)%range]-1]=arr[i];
freq[(arr[i]/place)%range]--;
}
for(i=0;i<n;i++)
arr[i]=output[i];
} }
void radixsort(ll arr[],int n,int maxx){ //maxx is the maximum element in the array void radixsort(ll arr[],int n,int maxx){ // maxx is the maximum element in the array
int mul=1;
int mul=1; while(maxx){
countsort(arr,n,mul);
while(maxx){ mul*=10;
maxx/=10;
countsort(arr,n,mul); }
mul*=10;
maxx/=10;
}
} }
``` ```
### معلومات اكثر: Python:
```py
def counting_sort(arr, max_value, get_index):
counts = [0] * max_value
# Counting - O(n)
for a in arr:s
counts[get_index(a)] += 1
# Accumulating - O(k)
for i, c in enumerate(counts):
if i == 0:
continue
else:
counts[i] += counts[i-1]
# Calculating start index - O(k)
for i, c in enumerate(counts[:-1]):
if i == 0:
counts[i] = 0
counts[i+1] = c
ret = [None] * len(arr)
# Sorting - O(n)
for a in arr:
index = counts[get_index(a)]
ret[index] = a
counts[get_index(a)] += 1
return ret
```
### معلومات اكثر
* [ويكيبيديا](https://en.wikipedia.org/wiki/Radix_sort) * [ويكيبيديا](https://en.wikipedia.org/wiki/Radix_sort)
* [GeeksForGeeks](http://www.geeksforgeeks.org/radix-sort/) * [GeeksForGeeks](http://www.geeksforgeeks.org/radix-sort/)

102
guide/chinese/algorithms/sorting-algorithms/radix-sort/index.md
View File

@ -58,54 +58,72 @@ QuickSort，MergeSort，HeapSort是基于比较的排序算法。 CountSort不
该数组变为：10,11,17,21,34,44,123,654，它被排序。这就是我们的算法的工作方式。 该数组变为：10,11,17,21,34,44,123,654，它被排序。这就是我们的算法的工作方式。
C中的实现： C中的实现：
```
void countsort(int arr[],int n,int place){ ```c
void countsort(int arr[],int n,int place){
int i,freq[range]={0}; // range for integers is 10 as digits range from 0-9
int output[n];
for(i=0;i<n;i++)
freq[(arr[i]/place)%range]++;
int i,freq[range]={0}; //range for integers is 10 as digits range from 0-9 for(i=1;i<range;i++)
freq[i]+=freq[i-1];
int output[n]; for(i=n-1;i>=0;i--){
output[freq[(arr[i]/place)%range]-1]=arr[i];
freq[(arr[i]/place)%range]--;
}
for(i=0;i<n;i++) for(i=0;i<n;i++)
arr[i]=output[i];
}
freq[(arr[i]/place)%range]++; void radixsort(ll arr[],int n,int maxx){ // maxx is the maximum element in the array
int mul=1;
for(i=1;i<range;i++) while(maxx){
countsort(arr,n,mul);
freq[i]+=freq[i-1]; mul*=10;
maxx/=10;
for(i=n-1;i>=0;i--){ }
}
output[freq[(arr[i]/place)%range]-1]=arr[i];
freq[(arr[i]/place)%range]--;
}
for(i=0;i<n;i++)
arr[i]=output[i];
}
void radixsort(ll arr[],int n,int maxx){ //maxx is the maximum element in the array
int mul=1;
while(maxx){
countsort(arr,n,mul);
mul*=10;
maxx/=10;
}
}
``` ```
### 更多信息： Python:
```py
def counting_sort(arr, max_value, get_index):
counts = [0] * max_value
# Counting - O(n)
for a in arr:s
counts[get_index(a)] += 1
# Accumulating - O(k)
for i, c in enumerate(counts):
if i == 0:
continue
else:
counts[i] += counts[i-1]
# Calculating start index - O(k)
for i, c in enumerate(counts[:-1]):
if i == 0:
counts[i] = 0
counts[i+1] = c
ret = [None] * len(arr)
# Sorting - O(n)
for a in arr:
index = counts[get_index(a)]
ret[index] = a
counts[get_index(a)] += 1
return ret
```
### 更多信息
* [维基百科](https://en.wikipedia.org/wiki/Radix_sort) * [维基百科](https://en.wikipedia.org/wiki/Radix_sort)
* [GeeksForGeeks](http://www.geeksforgeeks.org/radix-sort/) * [GeeksForGeeks](http://www.geeksforgeeks.org/radix-sort/)

28
guide/english/algorithms/sorting-algorithms/radix-sort/index.md
View File

@ -66,36 +66,38 @@ Finally , we sort according to the hundred's digit (most significant digit):
The array becomes : 10, 11, 17, 21, 34, 44, 123, 654 which is sorted. This is how our algorithm works. The array becomes : 10, 11, 17, 21, 34, 44, 123, 654 which is sorted. This is how our algorithm works.
An implementation in C: An implementation in C:
```c ```c
void countsort(int arr[],int n,int place){ void countsort(int arr[],int n,int place){
int i,freq[range]={0}; //range for integers is 10 as digits range from 0-9 int i,freq[range]={0}; // range for integers is 10 as digits range from 0-9
int output[n]; int output[n];
for(i=0;i<n;i++) for(i=0;i<n;i++)
freq[(arr[i]/place)%range]++; freq[(arr[i]/place)%range]++;
for(i=1;i<range;i++) for(i=1;i<range;i++)
freq[i]+=freq[i-1]; freq[i]+=freq[i-1];
for(i=n-1;i>=0;i--){ for(i=n-1;i>=0;i--){
output[freq[(arr[i]/place)%range]-1]=arr[i]; output[freq[(arr[i]/place)%range]-1]=arr[i];
freq[(arr[i]/place)%range]--; freq[(arr[i]/place)%range]--;
} }
for(i=0;i<n;i++) for(i=0;i<n;i++)
arr[i]=output[i]; arr[i]=output[i];
} }
void radixsort(ll arr[],int n,int maxx){ //maxx is the maximum element in the array void radixsort(ll arr[],int n,int maxx){ // maxx is the maximum element in the array
int mul=1; int mul=1;
while(maxx){ while(maxx){
countsort(arr,n,mul); countsort(arr,n,mul);
mul*=10; mul*=10;
maxx/=10; maxx/=10;
} }
} }
``` ```
An implementation in python :
An implementation in Python:
```py ```py
def counting_sort(arr, max_value, get_index): def counting_sort(arr, max_value, get_index):
@ -128,7 +130,7 @@ def counting_sort(arr, max_value, get_index):
return ret return ret
``` ```
### More Information: ### More Information
- [Wikipedia](https://en.wikipedia.org/wiki/Radix_sort) - [Wikipedia](https://en.wikipedia.org/wiki/Radix_sort)

23
guide/portuguese/algorithms/sorting-algorithms/radix-sort/index.md
View File

@ -58,37 +58,38 @@ Agora, o array se torna: 10,11,17,21,123,34,44,654 Finalmente, classificamos de
A matriz torna-se: 10,11,17,21,34,44,123,654 que é classificada. É assim que nosso algoritmo funciona. A matriz torna-se: 10,11,17,21,34,44,123,654 que é classificada. É assim que nosso algoritmo funciona.
Uma implementação em C: Uma implementação em C:
```c ```c
void countsort(int arr[],int n,int place){ void countsort(int arr[],int n,int place){
int i,freq[range]={0}; // range for integers is 10 as digits range from 0-9 int i,freq[range]={0}; // range for integers is 10 as digits range from 0-9
int output[n]; int output[n];
for(i=0;i<n;i++) for(i=0;i<n;i++)
freq[(arr[i]/place)%range]++; freq[(arr[i]/place)%range]++;
for(i=1;i<range;i++) for(i=1;i<range;i++)
freq[i]+=freq[i-1]; freq[i]+=freq[i-1];
for(i=n-1;i>=0;i--){ for(i=n-1;i>=0;i--){
output[freq[(arr[i]/place)%range]-1]=arr[i]; output[freq[(arr[i]/place)%range]-1]=arr[i];
freq[(arr[i]/place)%range]--; freq[(arr[i]/place)%range]--;
} }
for(i=0;i<n;i++) for(i=0;i<n;i++)
arr[i]=output[i]; arr[i]=output[i];
} }
void radixsort(ll arr[],int n,int maxx){ // maxx is the maximum element in the array void radixsort(ll arr[],int n,int maxx){ // maxx is the maximum element in the array
int mul=1; int mul=1;
while(maxx){ while(maxx){
countsort(arr,n,mul); countsort(arr,n,mul);
mul*=10; mul*=10;
maxx/=10; maxx/=10;
} }
} }
``` ```
Uma implementação em Python : Uma implementação em Python:
```py ```py
def counting_sort(arr, max_value, get_index): def counting_sort(arr, max_value, get_index):
@ -121,7 +122,7 @@ def counting_sort(arr, max_value, get_index):
return ret return ret
``` ```
### Mais Informações: ### Mais Informações
* [Wikipedia](https://en.wikipedia.org/wiki/Radix_sort) * [Wikipedia](https://en.wikipedia.org/wiki/Radix_sort)

103
guide/russian/algorithms/sorting-algorithms/radix-sort/index.md
View File

@ -58,54 +58,73 @@ QuickSort, MergeSort, HeapSort - это алгоритмы сортировки
Массив становится: 10,11,17,21,34,44,123,654, который сортируется. Так работает наш алгоритм. Массив становится: 10,11,17,21,34,44,123,654, который сортируется. Так работает наш алгоритм.
Реализация в C: Реализация в C:
```
void countsort(int arr[],int n,int place){ ```c
void countsort(int arr[],int n,int place){
int i,freq[range]={0}; // range for integers is 10 as digits range from 0-9
int output[n];
for(i=0;i<n;i++)
freq[(arr[i]/place)%range]++;
int i,freq[range]={0}; //range for integers is 10 as digits range from 0-9 for(i=1;i<range;i++)
freq[i]+=freq[i-1];
int output[n]; for(i=n-1;i>=0;i--){
output[freq[(arr[i]/place)%range]-1]=arr[i];
freq[(arr[i]/place)%range]--;
}
for(i=0;i<n;i++) for(i=0;i<n;i++)
arr[i]=output[i];
}
freq[(arr[i]/place)%range]++; void radixsort(ll arr[],int n,int maxx){ // maxx is the maximum element in the array
int mul=1;
for(i=1;i<range;i++) while(maxx){
countsort(arr,n,mul);
freq[i]+=freq[i-1]; mul*=10;
maxx/=10;
for(i=n-1;i>=0;i--){ }
}
output[freq[(arr[i]/place)%range]-1]=arr[i];
freq[(arr[i]/place)%range]--;
}
for(i=0;i<n;i++)
arr[i]=output[i];
}
void radixsort(ll arr[],int n,int maxx){ //maxx is the maximum element in the array
int mul=1;
while(maxx){
countsort(arr,n,mul);
mul*=10;
maxx/=10;
}
}
``` ```
### Дополнительная информация: Python:
```py
def counting_sort(arr, max_value, get_index):
counts = [0] * max_value
# Counting - O(n)
for a in arr:s
counts[get_index(a)] += 1
# Accumulating - O(k)
for i, c in enumerate(counts):
if i == 0:
continue
else:
counts[i] += counts[i-1]
# Calculating start index - O(k)
for i, c in enumerate(counts[:-1]):
if i == 0:
counts[i] = 0
counts[i+1] = c
ret = [None] * len(arr)
# Sorting - O(n)
for a in arr:
index = counts[get_index(a)]
ret[index] = a
counts[get_index(a)] += 1
return ret
```
### Дополнительная информация
* [Википедия](https://en.wikipedia.org/wiki/Radix_sort) * [Википедия](https://en.wikipedia.org/wiki/Radix_sort)
* [GeeksForGeeks](http://www.geeksforgeeks.org/radix-sort/) * [GeeksForGeeks](http://www.geeksforgeeks.org/radix-sort/)

102
guide/spanish/algorithms/sorting-algorithms/radix-sort/index.md
View File

@ -58,54 +58,72 @@ Ahora, la matriz se convierte en: 10,11,17,21,123,34,44,654 Finalmente, ordenamo
La matriz se convierte en: 10,11,17,21,34,44,123,654 que está ordenada. Así es como funciona nuestro algoritmo. La matriz se convierte en: 10,11,17,21,34,44,123,654 que está ordenada. Así es como funciona nuestro algoritmo.
Una implementación en C: Una implementación en C:
```
void countsort(int arr[],int n,int place){ ```c
void countsort(int arr[],int n,int place){
int i,freq[range]={0}; // range for integers is 10 as digits range from 0-9
int output[n];
for(i=0;i<n;i++)
freq[(arr[i]/place)%range]++;
int i,freq[range]={0}; //range for integers is 10 as digits range from 0-9 for(i=1;i<range;i++)
freq[i]+=freq[i-1];
int output[n]; for(i=n-1;i>=0;i--){
output[freq[(arr[i]/place)%range]-1]=arr[i];
freq[(arr[i]/place)%range]--;
}
for(i=0;i<n;i++) for(i=0;i<n;i++)
arr[i]=output[i];
}
freq[(arr[i]/place)%range]++; void radixsort(ll arr[],int n,int maxx){ // maxx is the maximum element in the array
int mul=1;
for(i=1;i<range;i++) while(maxx){
countsort(arr,n,mul);
freq[i]+=freq[i-1]; mul*=10;
maxx/=10;
for(i=n-1;i>=0;i--){ }
}
output[freq[(arr[i]/place)%range]-1]=arr[i];
freq[(arr[i]/place)%range]--;
}
for(i=0;i<n;i++)
arr[i]=output[i];
}
void radixsort(ll arr[],int n,int maxx){ //maxx is the maximum element in the array
int mul=1;
while(maxx){
countsort(arr,n,mul);
mul*=10;
maxx/=10;
}
}
``` ```
### Más información: Python:
```py
def counting_sort(arr, max_value, get_index):
counts = [0] * max_value
# Counting - O(n)
for a in arr:s
counts[get_index(a)] += 1
# Accumulating - O(k)
for i, c in enumerate(counts):
if i == 0:
continue
else:
counts[i] += counts[i-1]
# Calculating start index - O(k)
for i, c in enumerate(counts[:-1]):
if i == 0:
counts[i] = 0
counts[i+1] = c
ret = [None] * len(arr)
# Sorting - O(n)
for a in arr:
index = counts[get_index(a)]
ret[index] = a
counts[get_index(a)] += 1
return ret
```
### Más información
* [Wikipedia](https://en.wikipedia.org/wiki/Radix_sort) * [Wikipedia](https://en.wikipedia.org/wiki/Radix_sort)
* [GeeksForGeeks](http://www.geeksforgeeks.org/radix-sort/) * [GeeksForGeeks](http://www.geeksforgeeks.org/radix-sort/)