corrected a lot of typos

slides/cours_24.md

@@ -32,7 +32,7 @@ initialiser(graphe) // tous sommets sont non-visités
 file = visiter(sommet, vide) // sommet est un sommet 
                              // du graphe
 tant que !est_vide(file)
-    v = défiler(file)
+    v = defiler(file)
     file = visiter(v, file)
 
 file visiter(sommet, file)
@@ -463,7 +463,7 @@ tab dijkstra(graph, s, t)
 . . .
 
 * Pour chaque nouveau noeud à visiter, il suffit d'enregistrer d'où on est venu!
-* On a besoin d'un tableau `précédent`.
+* On a besoin d'un tableau `precedent`.
 
 ## Modifier le pseudo-code ci-dessus pour ce faire (3min matrix)
 
@@ -475,7 +475,7 @@ tab dijkstra(graph, s, t)
 tab, tab dijkstra(graph, s, t)
     pour chaque v dans graphe
         distance[v] = infini
-        précédent[v] = indéfini
+        precedent[v] = indéfini
         q = ajouter(q, v)
     distance[s] = 0
     tant que non_vide(q)
@@ -489,8 +489,8 @@ tab, tab dijkstra(graph, s, t)
             n_distance = distance[u] + w(u, v)
             si n_distance < distance[v]
                 distance[v] = n_distance
-                précédent[v] = u
-    retourne distance, précédent
+                precedent[v] = u
+    retourne distance, precedent
 ```
 
 # Algorithme de Dijkstra
@@ -500,14 +500,14 @@ tab, tab dijkstra(graph, s, t)
 . . .
 
 ```C
-pile parcours(précédent, s, t)
+pile parcours(precedent, s, t)
     sommets = vide
     u = t
     // on a atteint t ou on ne connait pas de chemin
-    si u != s && précédent[u] != indéfini 
+    si u != s && precedent[u] != indéfini 
         tant que vrai 
             sommets = empiler(sommets, u)
-            u = précédent[u]
+            u = precedent[u]
             si u == s // la source est atteinte
                 retourne sommets
     retourne sommets
@@ -538,11 +538,11 @@ pile parcours(précédent, s, t)
 ## Trois fonction principales
 
 ```C
-booléen est_vide(élément) // triviale
-élément enfiler(élément, data, priorité)
-data défiler(élément)
-rien modifier_priorité(élément, data, priotié)
-nombre priorité(data) // utilitaire
+booléen est_vide(element) // triviale
+element enfiler(element, data, priorite)
+data defiler(element)
+rien changer_priorite(element, data, priorite)
+nombre priorite(element) // utilitaire
 ```
 
 ## Pseudo-implémentation: structure (1min)
@@ -550,10 +550,10 @@ nombre priorité(data) // utilitaire
 . . .
 
 ```C
-struct élément
+struct element
     data
-    priorité
-    élément suivant
+    priorite
+    element suivant
 ```
 
 # Les files de priorité
@@ -563,61 +563,61 @@ struct élément
 . . .
 
 ```C
-élément enfiler(élément, data, priorité)
-    n_élément = créer_élément(data, priorité)
-    si est_vide(élément)
-        retourne n_élément
-    si priorité(d) > priorité(e.d)
-        n_élément.suivant = élément
-        retourne n_élément
+element enfiler(element, data, priorite)
+    n_element = creer_element(data, priorite)
+    si est_vide(element)
+        retourne n_element
+    si priorite(n_element) > priorite(element)
+        n_element.suivant = element
+        retourne n_element
     sinon
-        tmp = élément
-        préc = élément
-        tant que !est_vide(tmp) && priorité < tmp.priorité
-            préc = tmp
+        tmp = element
+        prec = element
+        tant que !est_vide(tmp) && priorite < priorite(tmp)
+            prec = tmp
             tmp = tmp.suivant
-        prev.suivant = n_élément
-        n_élément.suivant = tmp
-        retourne élément           
+        prev.suivant = n_element
+        n_element.suivant = tmp
+        retourne element           
 ```
 
 # Les files de priorité
 
-## Pseudo-implémentation: défiler (2min)
+## Pseudo-implémentation: defiler (2min)
 
 . . .
 
 ```C
-data, élément défiler(élément)
-    si est_vide(élément)
+data, element defiler(element)
+    si est_vide(element)
         retourne AARGL!
     sinon
-        tmp = élément.data
-        n_élément = élément.suivant
-        libérer(élément)
-        retourne tmp, n_élément
+        tmp = element.data
+        n_element = element.suivant
+        liberer(element)
+        retourne tmp, n_element
 ```
 
 # Algorithme de Dijkstra avec file de priorité min
 
 ```C
-distance, précédent dijkstra(graphe, s, t):
+distance, precedent dijkstra(graphe, s, t):
     distance[source] = 0
     fp = file_p_vide()
     pour v dans sommets(graphe)
         si v != s
             distance[v] = infini
-            précédent[v] = indéfini
+            precedent[v] = indéfini
         fp = enfiler(fp, v, distance[v])
     tant que !est_vide(fp)
-        u, fp = défiler(fp)
+        u, fp = defiler(fp)
         pour v dans voisinage de u
             n_distance = distance[u] + w(u, v)
             si n_distance < distance[v]
                 distance[v] = n_distance
-                précédent[v] = u
-                fp = changer_priorité(fp, v, n_distance)
-    retourne distance, précédent
+                precedent[v] = u
+                fp = changer_priorite(fp, v, n_distance)
+    retourne distance, precedent
 ```
 
 # Algorithme de Dijkstra avec file
@@ -633,13 +633,13 @@ O(V)    si v != s
 O(V)        fp = enfiler(fp, v, distance[v]) // notre impl est nulle
 ------------------O(V * V)-------------------------------
     tant que !est_vide(fp)
-O(1)    u, fp = défiler(fp)
+O(1)    u, fp = defiler(fp)
 ---------------------------------------------------------
 O(E)    pour v dans voisinage de u
             n_distance = distance[u] + w(u, v)
             si n_distance < distance[v]
                 distance[v] = n_distance
-O(V)            fp = changer_priorité(fp, v, n_distance)
+O(V)            fp = changer_priorite(fp, v, n_distance)
 ---------------------------------------------------------
     retourne distance
 ```
@@ -667,7 +667,7 @@ O(V)            fp = changer_priorité(fp, v, n_distance)
 ## A chaque étape donner:
 
 * Le tableau des distances à `a`;
-* Le tableau des prédécessueurs;
+* Le tableau des prédécesseurs;
 * L'état de la file de priorité.
 
 # Algorithme de Dijkstra (corrigé)