8000 Add more Sorting Algorithms in French (Merge Sort, Selection Sort and… · Surani02/Algorithms-Explanation@3706520 · GitHub
[go: up one dir, main page]
Skip to content

Commit 3706520

Browse files
aymenkhsPanquesito7
aymenkhs
and
Panquesito7
authored
Add more Sorting Algorithms in French (Merge Sort, Selection Sort and Bubble Sort) (TheAlgorithms#196)
* add : Merge Sort translation in french * add : Bubble Sort translation in french * add : Selection Sort translation in french * Apply suggestions from code review Co-authored-by: David Leal <halfpacho@gmail.com> * Apply suggestions from code review Co-authored-by: David Leal <halfpacho@gmail.com> Co-authored-by: David Leal <halfpacho@gmail.com>
1 parent 15028db commit 3706520

File tree

3 files changed

+209
-0
lines changed

3 files changed

+209
-0
lines changed

‎fr/tri/Tri_fusion.md

Lines changed: 59 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,59 @@
1+
# Tri Fusion
2+
3+
## Description
4+
5+
### Principe
6+
Le tri fusion, aussi appelé "tri dichotomique" est un Algorithme de tri Stable, qui est basé sur la technique "diviser pour régner".
7+
8+
### Complexités
9+
10+
#### Complexités spatiale
11+
12+
La complexité spatiale de l'algorithme est de `O(n)`
13+
14+
#### Complexités temporelle
15+
16+
- meilleur cas : `O(n log n)`
17+
- cas moyens : `O(n log n)`
18+
- pire cas : `O(n log n)`
19+
20+
## Étapes
21+
22+
- Trouvez le milieu du tableau et divisez le en deux moitiés en fonction du milieu.
23+
- Appeler récursivement la fonction de tri fusion pour les deux moitiés
24+
- Fusionnez les deux moitiés triées pour obtenir le tableau trié.
25+
26+
## Exemple
27+
28+
```txt
29+
tab = [1, 9, 2, 5, 7, 3, 6, 4]
30+
31+
Divisez le tableau en deux moitiés [1, 9, 2, 5] et [7, 3, 6, 4]
32+
33+
Les deux moitiés ci-dessus ne sont pas encore triées, donc nous devons les diviser à nouveau en deux moitiés.
34+
35+
Cette fois, nous obtenons quatre tableaux : [1, 9], [2, 5], [7, 3] et [6, 4].
36+
37+
les deux derniers tableaux ne sont toujours pas triés, donc nous les divisons à nouveau en deux moitiés et nous obtenons [7], [3], [6], and [4].
38+
39+
Puisqu'un tableau d'un seul élément est trié, nous avons maintenant tous les tableaux triés, il ne nous reste plus qu'à les fusionner de manière appropriée.
40+
41+
D'abord, les tableaux d'un seul élément seront fusionnés vu qu'ils ont été divisés en dernier, et sont au sommet de la pile de récursion, donc nous obtenons [3,7] et [4,6].
42+
43+
Puis la fusion va se produire conformément à la pile de récurrence, [1, 9] et [2, 5] seront fusionnés et donneront [1, 2, 5, 9].
44+
45+
De même, [3, 7] et [4, 6] seront fusionnés et donneront [3, 4, 6, 7].
46+
47+
Au niveau suivant de la pile, [1, 2, 5, 9] et [3, 4, 6, 7] seront fusionnés et nous obtiendrons le tableau trié final comme [1, 2, 3, 4, 5, 6, 7, 9].
48+
```
49+
50+
## Implémentation
51+
52+
- [Python](https://github.com/TheAlgorithms/Python/blob/master/sorts/merge_sort.py)
53+
- [Java](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/sorts/MergeSort.java)
54+
- [C](https://github.com/TheAlgorithms/C/blob/master/sorting/merge_sort.c)
55+
- [C++](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/sorting/merge_sort.cpp)
56+
- [C-Sharp](https://github.com/TheAlgorithms/C-Sharp/blob/master/Algorithms/Sorters/Comparison/MergeSorter.cs)
57+
- [Ruby](https://github.com/TheAlgorithms/Ruby/blob/master/sorting/merge_sort.rb)
58+
- [Go](https://github.com/TheAlgorithms/Go/blob/master/sort/mergesort.go)
59+
- [JavaScript](https://github.com/TheAlgorithms/JavaScript/blob/master/Sorts/MergeSort.js)

‎fr/tri/Tri_par_selection.md

Lines changed: 63 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,63 @@
1+
# Tri par Selection
2+
3+
## Description
4+
5+
### Principe
6+
7+
Le tri par sélection est un algorithme de tri par comparaison, qui malgres sa simplicité est en generale considerer comme ineficasse de fait de sa complexité.
8+
9+
### Complexités
10+
11+
#### Complexités spatiale
12+
13+
- `O(1)`
14+
15+
#### Complexité temporelle
16+
17+
- Pire, moyens et meilleur cas : `O(n^2)`
18+
19+
## Étapes
20+
21+
- Sélectionner le plus petit élément du tableau
22+
- Le permuter avec le premier élément du tableau
23+
- Puis sélectionner le plus petit élément du tableau dans la liste non triée restante
24+
- Le permuter avec le premier élément du tableau dans la liste non triée restante
25+
- Continuez à faire cela pour chaque élément du tableau
26+
27+
## Exemple
28+
29+
```txt
30+
31+
tab[] = {80, 10, 40, 30}
32+
Indexes : 0 1 2 3
33+
34+
1. Index = 0
35+
Sélectionnez le nombre minimum dans le tableau et son index (index entre 0-3), (la plus petite valeur est 10, et l'index est 1)
36+
2. Permuter les indexe 1 et 0 (valeurs 10 et 80)
37+
3. La nouvelle valeur du tableau est : {10, 80, 40, 30}
38+
39+
4. Index = 1
40+
Sélectionnez le nombre minimum dans le tableau et son index (index entre 1-3), (la plus petite valeur est 30, et l'index est 3)
41+
5. Permuter les indexe 3 et 1 (valeurs 30 et 80)
42+
6. La nouvelle valeur du tableau est : {10, 30, 40, 80}
43+
44+
7. Index = 2
45+
Sélectionnez le nombre minimum dans le tableau et son index (index entre 2-3), (la plus petite valeur est 40, et l'index est 2)
46+
8. Permuter les indexe 2 et 2 (valeurs 40 et 40)
47+
9. La nouvelle valeur du tableau est : {10, 30, 40, 80}
48+
49+
Le Tableau est maintenant trié.
50+
```
51+
52+
## Implémentation
53+
54+
- [Java](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/sorts/SelectionSort.java)
55+
- [C++ Iterative](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/sorting/selection_sort_iterative.cpp)
56+
- [C++ Recursive](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/sorting/selection_sort_recursive.cpp)
57+
- [Python](https://github.com/TheAlgorithms/Python/blob/master/sorts/selection_sort.py)
58+
- [Go](https://github.com/TheAlgorithms/Go/blob/master/sort/selectionsort.go)
59+
- [Ruby](https://github.com/TheAlgorithms/Ruby/blob/master/Sorting/selection_sort.rb)
60+
- [C iterative](https://github.com/TheAlgorithms/C/blob/master/sorting/selection_sort.c)
61+
- [C recursive](https://github.com/TheAlgorithms/C/blob/master/sorting/selection_sort_recursive.c)
62+
- [Scala](https://github.com/TheAlgorithms/Scala/blob/master/src/main/scala/Sort/SelectionSort.scala)
63+
- [TypeScript](https://github.com/TheAlgorithms/Javascript/blob/master/Sorts/selectionSort.js)

‎fr/tri/Tri_à_bulles.md

Lines changed: 87 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,87 @@
1+
# Tri à bulles
2+
3+
## Description
4+
5+
### Principe
6+
7+
Le principe du tri à bulles est de comparer répétitivement les éléments consécutifs d'un tableau deux à deux, et de les permuter lorsque ces derniers sont mal trié.
8+
9+
### Complexités
10+
11+
#### Complexités temporelle
12+
13+
- Dans le pire des cas, lorsque le plus petit élément est à la fin du tableau, la complexité est de `O(n^2)`
14+
- Dans le meilleur cas, lorsque le tableau est déjà trié, la complexité est de `O(n)` (on n'effectue qu’une seule itération de l'algorithme)
15+
- En moyenne, la complexité est de `O(n^2)`
16+
17+
18+
## Étapes
19+
20+
- Sélectionner le premier élément du tableau
21+
- Le comparer avec l'élément suivant
22+
- Si la valeur du premier élément est plus grande que celle du deuxième, permuter ces derniers.
23+
- Sinon, ne rien faire
24+
- Continuez à faire cela pour chaque index du tableau.
25+
- Répétez les étapes précédentes n fois.
26+
27+
## Exemple
28+
29+
```txt
30+
tab[] = {10, 80, 40, 30}
31+
Indexes: 0 1 2 3
32+
33+
1. Index = 0, Valeur = 10
34+
2. 10 < 80, ne rien faire et continuer
35+
36+
3. Index = 1, Valeur = 80
37+
4. 80 > 40, permuter 80 et 40
38+
5. Les nouvelles valeurs du tableau sont : {10, 40, 80, 30}
39+
40+
6. Index = 2, Valeur = 80
41+
7. 80 > 30, permuter 80 et 30
42+
8. Les nouvelles valeurs du tableau sont : {10, 40, 30, 80}
43+
44+
Répétez les étapes précédentes
45+
46+
tab[] = {10, 40, 30, 80}
47+
Indexes: 0 1 2 3
48+
49+
1. Index = 0, Valeur = 10
50+
2. 10 < 40, ne rien faire et continuer
51+
52+
3. Index = 1, Valeur = 40
53+
4. 40 > 30, permuter 40 et 30
54+
5. Les nouvelles valeurs du tableau sont : {10, 30, 40, 80}
55+
56+
6. Index = 2, Valeur = 40
57+
7. 40 < 80, ne rien faire
58+
8. Les nouvelles valeurs du tableau sont : {10, 30, 40, 80}
59+
60+
Répétez les étapes précédentes
61+
62+
tab[] = {10, 30, 40, 80}
63+
Indexes: 0 1 2 3
64+
65+
1. Index = 0, Valeur = 10
66+
2. 10 < 30, ne rien faire et continuer
67+
68+
3. Index = 1, Valeur = 30
69+
4. 30 < 40, ne rien faire et continuer
70+
71+
5. Index = 2, Valeur = 40
72+
6. 40 < 80, ne rien faire
73+
74+
Puisqu'il n'y a pas de permutations dans les étapes précédentes, cela signifie que le tableau est trié et que nous pouvons nous arrêter ici.
75+
```
76+
77+
## Implémentations
78+
79+
- [Python](https://github.com/TheAlgorithms/Python/blob/master/sorts/bubble_sort.py)
80+
- [C](https://github.com/TheAlgorithms/C/blob/master/sorting/bubble_sort.c)
81+
- [C++](https://github.com/TheAlgorithms/C-Plus-Plus/blob/master/sorting/bubble_sort.cpp)
82+
- [C-Sharp](https://github.com/TheAlgorithms/C-Sharp/blob/master/Algorithms/Sorters/Comparison/BubbleSorter.cs)
83+
- [Java](https://github.com/TheAlgorithms/Java/blob/master/src/main/java/com/thealgorithms/sorts/BubbleSort.java)
84+
- [Go](https://github.com/TheAlgorithms/Go/blob/master/sorts/bubblesort.go)
85+
- [Ruby](https://github.com/TheAlgorithms/Ruby/blob/master/sorting/bubble_sort.rb)
86+
- [Scala](https://github.com/TheAlgorithms/Scala/blob/master/src/main/scala/Sort/BubbleSort.scala)
87+
- [JavaScript](https://github.com/TheAlgorithms/Javascript/blob/master/Sorts/BubbleSort.js)

0 commit comments

Comments
 (0)
0