Skip to content

Commit f5d267b

Browse files
IonfinisherIonfinisher
authored
French Translation (#778)
* continue french tranlsation * continue french translation
1 parent 1fb0c97 commit f5d267b

File tree

5 files changed

+1398
-75
lines changed

5 files changed

+1398
-75
lines changed

‎Data Structures/readme_fr.md‎

Lines changed: 254 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,254 @@
1+
# Structures de Données
2+
En informatique, une structure de données est un format d'organisation, de gestion et de stockage des données qui permet un accès et une modification efficaces. Plus précisément, une structure de données est une collection de valeurs de données, les relations entre elles et les fonctions ou opérations qui peuvent être appliquées aux données.
3+
4+
## Types de Structures de Données
5+
- [Tableau](#tableau)
6+
- [Liste Chaînée](#liste-chaînée)
7+
- [Pile](#pile)
8+
- [File](#file)
9+
- [Table de Hachage](#table-de-hachage)
10+
- [Tas](#tas)
11+
- [Arbre](#arbre)
12+
- [Graphe](#graphe)
13+
- [Trie](Trie.md)
14+
- [Pointeurs](Pointers.md)
15+
16+
## Tableau
17+
Un tableau est une structure de données qui stocke une collection de valeurs de données dans des emplacements de mémoire contigus.
18+
19+
### Exemple
20+
```
21+
let array = [4,3,8,1,0,14,6];
22+
```
23+
24+
| Emplacement Mémoire | Valeur |
25+
|---------------------|--------|
26+
| 1000 | 4 |
27+
| 1001 | 3 |
28+
| 1002 | 8 |
29+
| 1003 | 1 |
30+
| 1004 | 0 |
31+
| 1005 | 14 |
32+
| 1006 | 6 |
33+
34+
L'accès à un élément dans un tableau se fait par indexation.
35+
```
36+
array[0] // 4 (l'index 0 est le premier élément) (1000)
37+
array[1] // 3 (l'index 1 est le deuxième élément) (1001)
38+
array[2] // 8 (l'index 2 est le troisième élément) (1002)
39+
array[3] // 1 (l'index 3 est le quatrième élément) (1003)
40+
array[4] // 0 (l'index 4 est le cinquième élément) (1004)
41+
array[5] // 14 (l'index 5 est le sixième élément) (1005)
42+
array[6] // 6 (l'index 6 est le septième élément) (1006)
43+
```
44+
45+
#### Complexités temporelles de certaines opérations de base sur les tableaux
46+
47+
| Opération | Complexité Temporelle |
48+
|-------------------------|-----------------------|
49+
| Accès à un élément | O(1) |
50+
| Recherche d'un élément | O(N) |
51+
| Insertion d'un élément | O(N) |
52+
| Suppression d'un élément| O(N) |
53+
54+
[Plus sur les Tableaux](Array.md)
55+
56+
57+
## Liste Chaînée
58+
Une liste chaînée est une structure de données qui consiste en un groupe de nœuds où chaque nœud contient une valeur de données et une référence (ou lien) vers le nœud suivant dans la liste.
59+
60+
### Exemple
61+
```
62+
let list = [4,3,1,0,14,6];
63+
```
64+
65+
| Emplacement Mémoire | Valeur |
66+
|---------------------|--------|
67+
| 1000 | 4 |
68+
| 1001 | 1008 |
69+
| 1002 | 1 |
70+
| 1003 | 1004 |
71+
| 1004 | 0 |
72+
| 1005 | 1006 |
73+
| 1006 | 14 |
74+
| 1007 | 1010 |
75+
| 1008 | 3 |
76+
| 1009 | 1002 |
77+
| 1010 | 6 |
78+
| 1011 | 1000 |
79+
80+
L'accès à un élément dans une liste chaînée se fait en parcourant la liste et en trouvant l'élément à l'index correct.
81+
```
82+
index 0 valeur est 4 avec emplacement mémoire 1000 et un pointeur vers le nœud suivant 1008
83+
index 1 valeur est 3 avec emplacement mémoire 1008 et un pointeur vers le nœud suivant 1002
84+
index 2 valeur est 1 avec emplacement mémoire 1002 et un pointeur vers le nœud suivant 1004
85+
index 3 valeur est 0 avec emplacement mémoire 1004 et un pointeur vers le nœud suivant 1006
86+
index 4 valeur est 14 avec emplacement mémoire 1006 et un pointeur vers le nœud suivant 1010
87+
index 5 valeur est 6 avec emplacement mémoire 1010 et un pointeur vers le premier nœud 1000
88+
```
89+
90+
#### Complexités temporelles de certaines opérations de base sur les listes chaînées
91+
92+
| Opération | Complexité Temporelle |
93+
|-------------------------|-----------------------|
94+
| Accès à un élément | O(N) |
95+
| Recherche d'un élément | O(N) |
96+
| Insertion d'un élément | O(1) |
97+
| Suppression d'un élément| O(1) |
98+
99+
100+
#### Il peut y avoir différents types de listes chaînées :
101+
102+
### Liste Chaînée Simple
103+
Une liste chaînée simple est un type de liste chaînée qui est unidirectionnelle, c'est-à-dire qu'elle peut être parcourue dans une seule direction, de la tête au dernier nœud (queue).
104+
105+
### Liste Chaînée Circulaire
106+
Ici, le dernier nœud de la liste contient un pointeur vers le premier nœud de la liste. Nous parcourons la liste chaînée circulaire jusqu'à ce que nous atteignions le même nœud où nous avons commencé. Elle n'a ni début ni fin. Tous les nœuds ne peuvent pas être nuls.
107+
108+
### Liste Chaînée Double
109+
Dans une liste chaînée double, un nœud se compose de trois parties : les données du nœud, un pointeur vers le nœud suivant dans la séquence (pointeur suivant) et un pointeur vers le nœud précédent (pointeur précédent). Nous pouvons parcourir dans n'importe quelle direction.
110+
111+
[Plus sur les Listes Chaînées](LinkedList.md)
112+
113+
114+
## Pile
115+
Une pile est une structure de données qui stocke une collection de valeurs de données dans un ordre LIFO (dernier entré, premier sorti).\
116+
Les opérations sur la pile ne peuvent se faire que par l'une de ses extrémités, appelée le _sommet_ de la pile.\
117+
L'implémentation peut être de type tableau (statique et contigu) ou de type liste chaînée (dynamique et discontiguë).
118+
119+
[Plus sur les Piles](Stack.md)
120+
121+
## File
122+
Une file stocke une collection de valeurs de données dans un ordre FIFO (premier entré, premier sorti). Le premier élément ajouté à la file sera le premier à être traité (retiré).\
123+
Une file ne peut être accédée que par ses extrémités, appelées _tête_ pour son arrière et _queue_ pour son avant.\
124+
L'implémentation peut être de type tableau (statique et contigu) ou de type liste chaînée (dynamique et discontiguë).
125+
126+
[Plus sur les Files](Queue.md)
127+
128+
129+
## Graphe
130+
131+
Le graphe est une structure de données qui consiste en des sommets (pour stocker les données) et des arêtes (pour connecter les sommets) afin de créer une structure de type réseau. Dans le graphe, chaque relation est une arête d'un sommet à un autre.
132+
133+
#### Types de Graphe
134+
135+
**1. Graphe Dirigé** : Les graphes dans lesquels la direction de l'arête d'un sommet à un autre est donnée sont appelés graphes dirigés.\
136+
**2. Graphe Non Dirigé** : Les graphes dans lesquels la direction de l'arête d'un sommet à un autre n'est pas donnée sont appelés graphes non dirigés. Ils ont une relation bidirectionnelle.\
137+
**3. Graphe Cyclique** : Un graphe dans lequel le cycle est présent (capable de revenir au même sommet) est appelé graphe cyclique.\
138+
**4. Graphe Acyclique** : Les graphes dans lesquels le cycle n'est pas présent (incapable de revenir au même sommet) sont appelés graphes acycliques.\
139+
**5. Graphe Pondéré** : Si un poids est présent sur l'arête du graphe, alors nous appelons ce graphe un graphe pondéré.\
140+
141+
### Terminologies de Base Concernant le Graphe
142+
143+
**Degré** : Dans un graphe non dirigé, le nombre d'arêtes connectées à un sommet est appelé le degré du sommet.\
144+
**Degré d'Entrée** : Dans un graphe dirigé, le nombre d'arêtes entrant dans le sommet est appelé le degré d'entrée du sommet.\
145+
**Degré de Sortie** : Dans un graphe dirigé, le nombre d'arêtes sortant du sommet est appelé le degré de sortie du sommet.\
146+
147+
### Représentation du Graphe
148+
149+
Nous pouvons représenter le graphe de deux manières :
150+
151+
**1. Matrice d'Adjacence** : Dans cette représentation, s'il y a une arête entre les sommets i et j, alors nous assignons la valeur INT_MAX à cet endroit et sinon Zéro.
152+
153+
| | 0 | 1 | 2 | 3 |
154+
|--|---|---------|---|---------|
155+
| **0** | 0 | INT_MAX | 0 | INT_MAX |
156+
| **1** | INT_MAX | 0 | 0 | INT_MAX |
157+
| **2** | 0 | INT_MAX | 0 | INT_MAX |
158+
| **3** | 0 | INT_MAX | 0 | 0 |
159+
160+
**2. Liste d'Adjacence** : Dans cette représentation, nous créons une liste de voisins avec le sommet.
161+
162+
| sommet | voisins |
163+
|--------|---------|
164+
0 -> | 1 , 3 |
165+
1 -> | 0 , 3 |
166+
2 -> | 1 , 3 |
167+
3 -> | 1 |
168+
169+
[Plus sur les Graphes](graph.md)
170+
171+
172+
## Tas
173+
174+
Un tas est une structure de données qui est un arbre binaire complet dans lequel le nœud parent est soit supérieur à ses deux nœuds enfants, soit inférieur à ses nœuds enfants.
175+
176+
### Implémentation du Tas
177+
```
178+
priority_queue<int, vector<int>,greater<int>> (heap_name); // tas min
179+
priority_queue<int, vector<int>> (heap_name); // tas max
180+
181+
```
182+
183+
### Types de Tas
184+
185+
**1. Tas Max** : Dans un tas max, le nœud racine contient la plus grande valeur parmi toutes les valeurs de ses nœuds enfants.
186+
**2. Tas Min** : Dans un tas min, le nœud racine contient la plus petite valeur parmi toutes les valeurs de ses nœuds enfants.
187+
188+
### Avantages du Tas
189+
190+
**1.** En utilisant un tas, nous pouvons accéder aux données les plus grandes ou les plus petites en temps constant.\
191+
**2.** Le temps de parcours d'un tas en utilisant l'algorithme de graphe (BFS, DFS) est réduit à un ordre polynomial.\
192+
**3.** Comme le tas est un arbre binaire complet, pour N nœuds, la hauteur maximale d'un tas est log(N), donc la complexité temporelle pour accéder au nombre maximum et minimum est réduite à un temps constant et pour le Kème élément, elle est réduite à une complexité linéaire.\
193+
194+
[Plus sur les Tas](Heap.md)
195+
196+
197+
#### Table de Hachage
198+
199+
La table de hachage est une structure de données qui stocke les données de manière associative. Dans une table de hachage, les données sont stockées sous forme de tableau, où chaque valeur de données a sa propre valeur d'index unique. L'accès aux données devient très rapide si nous connaissons l'index des données souhaitées.
200+
201+
### Exemple
202+
203+
```
204+
La fonction de hachage H(x) = [11,12,13,14,15]
205+
// elle sera stockée aux positions {1,2,3,4,5}
206+
// dans le tableau ou la table de hachage respectivement.
207+
```
208+
[Plus sur les Tables de Hachage](HashTable.md)
209+
210+
## Tas
211+
212+
Un tas est une structure de données spécialisée basée sur les arbres qui est un arbre presque complet qui satisfait la propriété du tas. La propriété du tas signifie que l'élément avec la clé la plus grande est toujours dans le nœud racine, un tel tas est parfois appelé un tas max.
213+
214+
### Exemple
215+
216+
```
217+
Laissez le tableau de nombres être [100, 7, 2, 17, 3, 25, 1, 36, 19]
218+
// Il sera sous forme d'arbre où le plus grand nombre pointera vers un nombre plus petit et le plus petit nombre pointera vers un nombre encore plus petit, et ainsi de suite
219+
220+
Une représentation en tas du tableau ressemblerait à ceci :
221+
100
222+
/ \
223+
19 36
224+
/ \ / \
225+
17 3 25 1
226+
/ \
227+
2 7
228+
```
229+
[Plus sur les Tas](Heap.md)
230+
231+
## Arbre
232+
233+
Un arbre est une structure de données non linéaire et hiérarchique composée d'une collection de nœuds de telle sorte que chaque nœud de l'arbre stocke une valeur et une liste de références vers d'autres nœuds (les "enfants").
234+
235+
### Exemple
236+
237+
```
238+
Laissez le tableau de nombres être [100, 7, 2, 17, 3, 25, 1, 36, 19]
239+
// L'arbre est une méthode spécialisée pour organiser et stocker les données dans l'ordinateur pour être utilisé plus efficacement
240+
Une représentation en arbre du tableau ressemblerait à ceci :
241+
100
242+
/ \
243+
19 36
244+
/ \ / \
245+
17 3 25 1
246+
/ \
247+
2 7
248+
```
249+
[Plus sur les Arbres](Tree.md)
250+
251+
## Graphe
252+
Un graphe est une structure de données non linéaire composée de sommets et d'arêtes. Les sommets sont parfois également appelés nœuds et les arêtes sont des lignes ou des arcs qui connectent deux nœuds quelconques dans le graphe. Plus formellement, un graphe est composé d'un ensemble de sommets (V) et d'un ensemble d'arêtes (E). Le graphe est noté G(E, V).
253+
254+
[Plus sur les Graphes](Graph.md)

0 commit comments

Comments
 (0)