diff --git a/lessons/contenu_cours_applications_piles.md b/lessons/contenu_cours_applications_piles.md
new file mode 100644
index 0000000000000000000000000000000000000000..a8fe3f248c4781333e15877e905febae84c757cc
--- /dev/null
+++ b/lessons/contenu_cours_applications_piles.md
@@ -0,0 +1,74 @@
+# Algorithmes et structures de données
+
+# Deux applications des piles
+
+*****
+
+## La transformation infixe $\Leftarrow$ postfixe
+
+Exemples:
+
+| Expression infixe | | Expression postfixe |
+|-----------------------|------------------|---------------------|
+| A + B * C | transformé en | A B C * + |
+| A + (B / C – D ^ E ) | transformé en | A B C / D E ^ – + |
+
+
+A chaque opérateur, on associe une priorité, par exemple:
+
+| Opérateur | Priorité |
+|-----------|----------|
+| ^ | 3 |
+| *, / | 2 |
+| +, - | 1 |
+
+
+L'algorithme utilise une pile dans laquelle on stocke les opérateurs et les parenthèses ouvertes
+rencontrées dans l'expression.
+
+Les étapes sont les suivantes :
+
+1. Examiner le prochain caractère dans l'expression donnée.
+2. Si c'est un opérande, le mettre directement dans l'expression du résultat.
+3. Si c'est une parenthèse ouverte, la mettre dans la pile avec la priorité zéro.
+4. Si c'est un opérateur, comparer sa priorité avec celle de l'élément au sommet de la pile:
+ * Si la priorité de l'opérateur est plus grande que l'opérateur du sommet de la pile, empiler ce nouvel opérateur.
+ * Sinon prendre l'opérateur du sommet de la pile, le mettre dans l'expression du résultat et répéter la comparaison avec le nouveau sommet de la pile, jusqu'à ce qu'un opérateur de priorité inférieure à celle de l'opérateur de l'expression apparaisse au sommet de la pile ou jusqu'à ce que la pile soit vide.
+5. Si c'est une parenthèse fermée, enlever de la pile les opérateurs et les placer dans l'expression du résultat jusqu'à ce qu'une parenthèse ouverte apparaisse au sommet de la pile, se défaire de cette parenthèse.
+6. Si l'expression donnée est vide, enlever de la pile les opérateurs restants et les placer dans l'expression du résultat.
+
+La table ci-dessous montre la réalisation d'une transformation infixe - postfixe sur une expression algébrique (supposée syntaxiquement correcte):
+
+
+
+**Remarque:** On utilise aussi d'autres structures de données pour traiter ce problème. Entre autres les arbres.
+
+## L'évaluation d'une expression en notation postfixée
+
+La manière la plus simple de procéder est d'utiliser une pile contenant à chaque instant les valeurs des opérandes déjà calculés.
+
+Dans une expression donnée sous forme postfixée, chaque opérateur porte sur les opérandes qui le précédent immédiatement, ceux ci doivent toujours se trouver en tête de pile au moment de l'opération. Le résultat d'une opération est un nouvel opérande qui est remis au sommet de la pile pour la suite de l'évaluation.
+
+Les règles d'évaluation sont les suivantes:
+
+* la valeur d'un opérande est toujours empilée.
+* Un opérateur s'applique toujours aux 2 opérandes en tête de pile.
+* Le résultat de l'opération est remis en tête de pile.
+
+Exemple:
+
+Soit l'expression postfixe à évaluer: A B C + * D -
+
+| Caractères lus | Pile des opérandes (nombres) |
+|----------------|------------------------------|
+| A | A |
+| B | A, B |
+| C | A, B, C |
+| + | A, B+C |
+| * | A*(B+C) |
+| D | A*(B+C), D |
+| A | *(B+C)-D |
+
+ La pile contient finalement la valeur de l'expression.
+
+Ce traitement exige naturellement que l'expression à évaluer soit syntaxiquement correcte.
\ No newline at end of file
diff --git a/lessons/contenu_cours_struct_pile.md b/lessons/contenu_cours_struct_pile.md
new file mode 100644
index 0000000000000000000000000000000000000000..64002212eaaba036ebcb033b966fe7bbf20c3e70
--- /dev/null
+++ b/lessons/contenu_cours_struct_pile.md
@@ -0,0 +1,35 @@
+# Algorithmes et structures de données
+
+# Structure de pile
+
+*****
+
+## 1. Définition
+Une pile est une structure de données dans laquelle la dernière information entrée, est la première à ressortir (en anglais : LIFO, Last In First Out)
+
+On envisage deux types d'implémentation de piles:
+
+1. l'une à capacité limitée (piles dénommées statiques);
+2. l'autre à capacité « infinie » (piles dénommées dynamiques dont la capacité limite dépend en réalité de la mémoire disponible).
+
+## 2. Spécification de la structure
+Le type des éléments qu'on empile, n'étant pas précisé, on parle de spécification générique.
+
+Les opérations possibles sur une pile en définissent l'interface :
+
+* Opérations de manipulation
+ * Empiler un nouvel élément sur la pile
+ * Dépiler l'élément au sommet de la pile (i.e. le dernier élément introduit)
+
+* Fonctions de consultation
+ * Lire l'élément au sommet de la pile
+ * Tester si la pile est vide
+ * Tester si la pile a atteint la capacité maximale, seulement dans le cas d'une pile statique
+ * L'interface de la pile est l'ensemble des fonctionnalités offertes à l'utilisateur pour interagir avec une pile
+
+## 3. Quelques applications des piles
+* Gérer les mécanismes internes de mise en œuvre de la récursivité
+* Traiter les structures imbriquées
+* Implémenter les machines abstraites
+* Passer les paramètres aux procédures
+* Sauver l'état d'un processus
\ No newline at end of file
diff --git a/lessons/contenu_cours_struct_queue.md b/lessons/contenu_cours_struct_queue.md
new file mode 100644
index 0000000000000000000000000000000000000000..6d60b4ba5c52c2ad0ec58766c33982adaf348b1d
--- /dev/null
+++ b/lessons/contenu_cours_struct_queue.md
@@ -0,0 +1,113 @@
+# Algorithmes et structures de données
+
+# Structure de file d'attente
+
+*****
+
+## 1. Définition
+
+Une file d'attente ou queue est une structure de données dans laquelle la première information entrée est la première à ressortir (en anglais : FIFO, First In First Out)
+
+On considère ici une implémentation de queue dynamique et donc à capacité « infinie » (dépend en réalité de la mémoire disponible).
+
+## 2. Spécification de la structure
+
+Si le type des éléments qu'on insère, n'est pas précisé, on parle de spécification générique.
+
+Les opérations possibles sur une file d'attente (ou queue) en définissent l'interface :
+
+* Opérations de manipulation
+ * Créer une liste vide
+ * Détruire une liste
+ * Insérer un nouvel élément en queue de la file d'attente
+ * Extraire un élément en tête de la file d'attente (i.e. le premier élément introduit)
+ *
+* Fonctions de consultation
+ * Lire l'élément en tête de la file d'attente
+ * Lire l'élément en queue de la file d'attente
+ * Tester si la file d'attente est vide
+
+L'interface de la file d'attente est l'ensemble des fonctionnalités offertes à l'utilisateur pour interagir
+avec celle-ci.
+
+## 3. Structure de file d'attente
+
+On considère une liste chaînée d'articles avec deux pointeurs de tête et de queue. Chaque article comportera un champ pour stocker les valeurs dans cette liste et un champ contenant une variable de type accès pour assurer le chaînage. On considère à titre d'exemple le cas de valeurs entières.
+
+Schématiquement:
+
+
+
+L'accès à la file d'attente se fera par les pointeurs de tête et de queue.
+
+Une telle file d'attente basée sur une liste chaînée sera déclarée par exemple sous la forme suivante:
+
+```C
+ struct _element { // Elément de liste
+ int data;
+ struct _element* next;
+ } element;
+
+ struct _queue { // File d'attente:
+ element* tete; // tête de file d'attente
+ element* debut; // queue de file d'attente
+ }
+```
+
+## 4. Implémentation des fonctionnalité d'une file d'attente
+
+### a) Consultations
+
+On considère la fonction queue_est_vide qui teste si la file d'attente est vide et les fonctions `queue_tete` et `queue_debut` qui retournent l'élément en tête, respectivement en queue, de la file d'attente.
+
+```C
+ bool queue_est_vide(queue fa) {
+ return (NULL == fa.tete && NULL == fa.debut);
+ }
+
+ int queue_tete(queue fa) {
+ assert(!queue_est_vide(fa));
+ return fa.tete>data;
+ }
+
+ int queue_debut(queue fa) {
+ assert(!queue_est_vide(fa));
+ return fa.debut>data;
+ }
+```
+
+### b) Manipulations
+
+#### Insertion en queue de file d'attente
+
+Voici l'entête de la fonction: `void queue_inserer(queue* fa,int val);`
+
+Il faut considérer plusieurs cas:
+
+* La file d'attente est vide
+
+
+
+* L'insertion se fait en queue d'une file d'attente non vide
+
+
+
+#### Extraction en tête de file d'attente
+
+Voici l'entête de la procédure: `int queue_extraire(queue* fa);`
+
+On commence par récupérer, la valeur en tête de file d'attente via l'appel `queue_tete(*fa);`
+
+Puis on met un pointeur temporaire sur l'élément en tête, avant de déplacer le pointeur de tête sur l'élément suivant.
+Finalement, on désalloue la mémoire
+
+
+
+Si la file d'attente n'avait qu'un seul élément, alors il faudrait mettre le pointeur `fa->debut` à `NULL`.
+Dans ce cas, à la suite du point (3), le pointeur `fa->tete` se retrouve à `NULL`. On doit donc ajouter l'instruction :
+
+```C
+ if (NULL == fa>tete) {
+ fa>debut = NULL;
+ }
+```
diff --git a/lessons/contenu_cours_struct_sorted_list.md b/lessons/contenu_cours_struct_sorted_list.md
new file mode 100644
index 0000000000000000000000000000000000000000..fbe3f9d839f2083f2beb4a6bb194e287d6b74a3f
--- /dev/null
+++ b/lessons/contenu_cours_struct_sorted_list.md
@@ -0,0 +1,206 @@
+# Algorithmes et structures de données
+
+# Structure de liste triée
+
+*****
+
+## 1. Définition
+
+On considère une liste chaînée d'articles. Chaque article comportera un champ pour stocker les valeurs
+dans la liste et un champ contenant une variable de type pointeur pour assurer le chaînage.
+Schématiquement:
+
+
+
+La liste est triée pour autant que l'insertion de chaque nouvelle valeur dans la liste maintienne cette
+propriété.
+L'accès à la liste se fera uniquement par le pointeur lst qui référence le début de la liste.
+Une telle liste chaînée sera déclarée par exemple sous la forme suivante:
+
+```C
+ typedef struct _element { // Elément de liste
+ int n;
+ struct _element* suivant;
+ } element;
+
+ typedef element* liste; // Pointeur sur des éléments de liste
+```
+
+## 2. Insertion dans une liste triée
+
+Voici l'entête de la procédure : `liste inserer(liste lst,int val);`
+
+Il faut considérer plusieurs cas.
+
+### La liste est vide: `lst == NULL`
+
+
+
+### L'insertion se fait en 1ère position: `val <= lst->n`
+
+Par exemple, pour `val = 1`
+
+
+
+### Les positions autres que la 1ère position
+
+Par exemple, pour `val = 13`
+
+
+
+```C
+ (1) tmp = malloc(sizeof(element));
+ tmp->n = 13;
+```
+
+On déplace un pointeur crt jusqu'à l'élément précédent la position d'insertion de sorte que
+```C
+ crt->n < val <= crt->suivant->n
+```
+
+On utilise une boucle:
+```C
+ (2) while (NULL != crt->suivant && val > crt->suivant->n) {
+ crt = crt->suivant;
+ }
+```
+
+Puis on raccroche l'élément pointé par tmp à la liste
+```C
+ (3) tmp->suivant = crt->suivant;
+ (4) crt->suivant = tmp;
+ return lst;
+```
+
+## 3. Extraction d'un élément dans une liste triée
+
+Voici l'entête de la procédure : `liste extraire(liste lst,int val);`
+
+Si la liste est vide, on retourne la liste vide.
+
+Ensuite, on déplace deux pointeurs prec et crt à travers la liste jusqu'à ce que : `prec->n < val <= crt->n`
+
+On utilise une boucle:
+```C
+ while (NULL != crt && val > crt->n) {
+ prec = crt;
+ crt = crt->suivant;
+ }
+```
+
+Il faut à nouveau considérer plusieurs cas.
+
+### La valeur à retirer est supérieure à la dernière valeur de la liste.
+
+Ceci équivaut à: `crt == NULL` ou `prec->suivant == NULL`
+
+On retourne la liste inchangée.
+
+Par exemple, pour `val = 30`
+
+
+
+### La valeur à retirer n'est pas celle dans l'élément pointé par `crt`.
+
+Ceci équivaut à: `val < crt->n`
+
+On retourne la liste inchangée.
+
+Par exemple, pour `val = 9`
+
+
+
+ou pour val = 1
+
+
+
+### La valeur à retirer est celle dans l'élément pointé par `crt`.
+
+Ceci équivaut à: `val == crt->n`
+
+#### La valeur à retirer est en début de liste.
+
+Ceci équivaut à: `crt == prec`
+
+On doit déplacer la tête de liste : lst = crt->suivant;
+
+Par exemple, pour `val = 3`
+
+
+
+#### La valeur à retirer n'est pas en début de liste.
+
+On doit raccrocher l'élément pointé par prec à celui suivant `crt`: `prec->suivant = crt->suivant;`
+
+Par exemple, pour `val = 12`
+
+
+
+ou pour `val = 21`
+
+
+
+Finalement, on libère la mémoire de l'élément pointé par `crt`: `free(crt);`
+
+
+
+## 4. Recherche dans une liste triée
+
+La fonction recherche retourne un pointeur sur l'élément qui contient la valeur recherchée ou un pointeur `NULL` si la valeur est absente de la liste triée.
+
+Voici l'entête de la procédure : `element* recherche(liste lst,int val);`
+
+On considère d'abord la fonction utilitaire `position` qui retourne un pointeur sur l'élément avant la
+position d'insertion d'une valeur ou un pointeur `NULL` s'il s'agit de la tête de liste.
+```C
+ element* position(liste lst,int val) {
+ element* pos = lst;
+ if (est_vide(lst) || val <= lst->n) {
+ pos = NULL;
+ } else {
+ while (NULL != pos->suivant && val > pos->suivant->n) {
+ pos = pos->suivant;
+ }
+ }
+ return pos;
+ }
+```
+
+Par exemple, pour val = 1 ou 3
+
+
+
+et pour val = 29
+
+
+
+et finalement pour val = 10 ou 12
+
+
+
+Ainsi, la fonction de recherche s'écrit simplement :
+```C
+ element* recherche(liste lst,int val) {
+ element* pos = position(lst,val);
+ if (est_vide(lst)) {
+ return NULL;
+ }
+ if (NULL == pos && val == lst->n) {
+ return lst;
+ } else if (NULL != pos->suivant && val == pos->suivant->n) {
+ return pos->suivant;
+ } else {
+ return NULL;
+ }
+ }
+```
+
+## Exercice
+
+Ecrire directement la fonction `recherche` sans utiliser la fonction `position`.
+Faire les dessins illustrant les différents cas possibles.
+
+
+
+
+
diff --git a/lessons/figures/fig_1st_element_sorted_list_extract.png b/lessons/figures/fig_1st_element_sorted_list_extract.png
new file mode 100644
index 0000000000000000000000000000000000000000..02057f27d58980d2f99a9cb3b5235e2e879ae993
Binary files /dev/null and b/lessons/figures/fig_1st_element_sorted_list_extract.png differ
diff --git a/lessons/figures/fig_1st_element_sorted_list_search.png b/lessons/figures/fig_1st_element_sorted_list_search.png
new file mode 100644
index 0000000000000000000000000000000000000000..d23b4911b12a86f08dfa84429ef5ede940881637
Binary files /dev/null and b/lessons/figures/fig_1st_element_sorted_list_search.png differ
diff --git a/lessons/figures/fig_1st_position_sorted_list_insert.png b/lessons/figures/fig_1st_position_sorted_list_insert.png
new file mode 100644
index 0000000000000000000000000000000000000000..fcc97e15b6175e7a0f83b5e8eebffaead14f013c
Binary files /dev/null and b/lessons/figures/fig_1st_position_sorted_list_insert.png differ
diff --git a/lessons/figures/fig_empty_queue_insert.png b/lessons/figures/fig_empty_queue_insert.png
new file mode 100644
index 0000000000000000000000000000000000000000..0d7aad80007c8a2d0f1a3ae0a3d9561479737a23
Binary files /dev/null and b/lessons/figures/fig_empty_queue_insert.png differ
diff --git a/lessons/figures/fig_empty_sorted_list_insert.png b/lessons/figures/fig_empty_sorted_list_insert.png
new file mode 100644
index 0000000000000000000000000000000000000000..6ffe0599a2f39cf2fadbc57e16385a9f13102f13
Binary files /dev/null and b/lessons/figures/fig_empty_sorted_list_insert.png differ
diff --git a/lessons/figures/fig_free_element_sorted_list_extract.png b/lessons/figures/fig_free_element_sorted_list_extract.png
new file mode 100644
index 0000000000000000000000000000000000000000..5a868acee5c8d3b95225f1abc6cb2bfe5bf9120a
Binary files /dev/null and b/lessons/figures/fig_free_element_sorted_list_extract.png differ
diff --git a/lessons/figures/fig_greater_value_sorted_list_extract.png b/lessons/figures/fig_greater_value_sorted_list_extract.png
new file mode 100644
index 0000000000000000000000000000000000000000..4c9c23b8d88c7079f9ad8f8dfd5d4d4822eac217
Binary files /dev/null and b/lessons/figures/fig_greater_value_sorted_list_extract.png differ
diff --git a/lessons/figures/fig_last_element_sorted_list_search.png b/lessons/figures/fig_last_element_sorted_list_search.png
new file mode 100644
index 0000000000000000000000000000000000000000..65b22241c7bab9776841120c7bdb68e0034e813f
Binary files /dev/null and b/lessons/figures/fig_last_element_sorted_list_search.png differ
diff --git a/lessons/figures/fig_no_value_sorted_list_extract_1.png b/lessons/figures/fig_no_value_sorted_list_extract_1.png
new file mode 100644
index 0000000000000000000000000000000000000000..a9e531e5f06ab409da277d37cba0a0dcd5ba4ebf
Binary files /dev/null and b/lessons/figures/fig_no_value_sorted_list_extract_1.png differ
diff --git a/lessons/figures/fig_no_value_sorted_list_extract_2.png b/lessons/figures/fig_no_value_sorted_list_extract_2.png
new file mode 100644
index 0000000000000000000000000000000000000000..222afa8686d08c7039ee24be0d3bfb7382bda696
Binary files /dev/null and b/lessons/figures/fig_no_value_sorted_list_extract_2.png differ
diff --git a/lessons/figures/fig_non_empty_queue_insert.png b/lessons/figures/fig_non_empty_queue_insert.png
new file mode 100644
index 0000000000000000000000000000000000000000..8093d290f00bd6f8c320f138374dc28b6a343385
Binary files /dev/null and b/lessons/figures/fig_non_empty_queue_insert.png differ
diff --git a/lessons/figures/fig_other_element_sorted_list_extract_1.png b/lessons/figures/fig_other_element_sorted_list_extract_1.png
new file mode 100644
index 0000000000000000000000000000000000000000..5318ce34595ec1b14dd5a619bd9c50b627ca5167
Binary files /dev/null and b/lessons/figures/fig_other_element_sorted_list_extract_1.png differ
diff --git a/lessons/figures/fig_other_element_sorted_list_extract_2.png b/lessons/figures/fig_other_element_sorted_list_extract_2.png
new file mode 100644
index 0000000000000000000000000000000000000000..565a58210c3ab51a6bcbf6a320027242f0a4162e
Binary files /dev/null and b/lessons/figures/fig_other_element_sorted_list_extract_2.png differ
diff --git a/lessons/figures/fig_other_element_sorted_list_search.png b/lessons/figures/fig_other_element_sorted_list_search.png
new file mode 100644
index 0000000000000000000000000000000000000000..1b116eb37e97c15bdcdbb8a2ec53d05594f6c10a
Binary files /dev/null and b/lessons/figures/fig_other_element_sorted_list_search.png differ
diff --git a/lessons/figures/fig_other_position_sorted_list_insert.png b/lessons/figures/fig_other_position_sorted_list_insert.png
new file mode 100644
index 0000000000000000000000000000000000000000..92795feedcdc102d9067f982c1732c6559ddff67
Binary files /dev/null and b/lessons/figures/fig_other_position_sorted_list_insert.png differ
diff --git a/lessons/figures/fig_queue_extract.png b/lessons/figures/fig_queue_extract.png
new file mode 100644
index 0000000000000000000000000000000000000000..b103ee95bb0cd145678ece54c2ef5cb6b89d337e
Binary files /dev/null and b/lessons/figures/fig_queue_extract.png differ
diff --git a/lessons/figures/fig_queue_representation.png b/lessons/figures/fig_queue_representation.png
new file mode 100644
index 0000000000000000000000000000000000000000..262d9a7ee941a10e3d50a19ac87a287d6f42ce71
Binary files /dev/null and b/lessons/figures/fig_queue_representation.png differ
diff --git a/lessons/figures/fig_transf_infixe_postfixe.png b/lessons/figures/fig_transf_infixe_postfixe.png
new file mode 100644
index 0000000000000000000000000000000000000000..f306da21f0348a03652651a035e4914fcd6cfbe0
Binary files /dev/null and b/lessons/figures/fig_transf_infixe_postfixe.png differ
diff --git a/lessons/tris/figures/stack_sort_expl.eps b/lessons/tris/figures/stack_sort_expl.eps
new file mode 100644
index 0000000000000000000000000000000000000000..c3725d45cbb7fb6794306affe8771b1c57b73bdd
--- /dev/null
+++ b/lessons/tris/figures/stack_sort_expl.eps
@@ -0,0 +1,447 @@
+%!PS-Adobe-2.0 EPSF-2.0
+%%Title: exemple.fig
+%%Creator: fig2dev Version 3.2 Patchlevel 4
+%%CreationDate: Fri Jan 27 14:34:17 2006
+%%For: lazeyras@eig2 (LAZEYRAS Michel - EIG prof)
+%%BoundingBox: 0 0 470 325
+%%Magnification: 1.0000
+%%EndComments
+/$F2psDict 200 dict def
+$F2psDict begin
+$F2psDict /mtrx matrix put
+/col-1 {0 setgray} bind def
+/col0 {0.000 0.000 0.000 srgb} bind def
+/col1 {0.000 0.000 1.000 srgb} bind def
+/col2 {0.000 1.000 0.000 srgb} bind def
+/col3 {0.000 1.000 1.000 srgb} bind def
+/col4 {1.000 0.000 0.000 srgb} bind def
+/col5 {1.000 0.000 1.000 srgb} bind def
+/col6 {1.000 1.000 0.000 srgb} bind def
+/col7 {1.000 1.000 1.000 srgb} bind def
+/col8 {0.000 0.000 0.560 srgb} bind def
+/col9 {0.000 0.000 0.690 srgb} bind def
+/col10 {0.000 0.000 0.820 srgb} bind def
+/col11 {0.530 0.810 1.000 srgb} bind def
+/col12 {0.000 0.560 0.000 srgb} bind def
+/col13 {0.000 0.690 0.000 srgb} bind def
+/col14 {0.000 0.820 0.000 srgb} bind def
+/col15 {0.000 0.560 0.560 srgb} bind def
+/col16 {0.000 0.690 0.690 srgb} bind def
+/col17 {0.000 0.820 0.820 srgb} bind def
+/col18 {0.560 0.000 0.000 srgb} bind def
+/col19 {0.690 0.000 0.000 srgb} bind def
+/col20 {0.820 0.000 0.000 srgb} bind def
+/col21 {0.560 0.000 0.560 srgb} bind def
+/col22 {0.690 0.000 0.690 srgb} bind def
+/col23 {0.820 0.000 0.820 srgb} bind def
+/col24 {0.500 0.190 0.000 srgb} bind def
+/col25 {0.630 0.250 0.000 srgb} bind def
+/col26 {0.750 0.380 0.000 srgb} bind def
+/col27 {1.000 0.500 0.500 srgb} bind def
+/col28 {1.000 0.630 0.630 srgb} bind def
+/col29 {1.000 0.750 0.750 srgb} bind def
+/col30 {1.000 0.880 0.880 srgb} bind def
+/col31 {1.000 0.840 0.000 srgb} bind def
+
+end
+save
+newpath 0 325 moveto 0 0 lineto 470 0 lineto 470 325 lineto closepath clip newpath
+-35.3 342.0 translate
+1 -1 scale
+
+/cp {closepath} bind def
+/ef {eofill} bind def
+/gr {grestore} bind def
+/gs {gsave} bind def
+/sa {save} bind def
+/rs {restore} bind def
+/l {lineto} bind def
+/m {moveto} bind def
+/rm {rmoveto} bind def
+/n {newpath} bind def
+/s {stroke} bind def
+/sh {show} bind def
+/slc {setlinecap} bind def
+/slj {setlinejoin} bind def
+/slw {setlinewidth} bind def
+/srgb {setrgbcolor} bind def
+/rot {rotate} bind def
+/sc {scale} bind def
+/sd {setdash} bind def
+/ff {findfont} bind def
+/sf {setfont} bind def
+/scf {scalefont} bind def
+/sw {stringwidth} bind def
+/tr {translate} bind def
+/tnt {dup dup currentrgbcolor
+ 4 -2 roll dup 1 exch sub 3 -1 roll mul add
+ 4 -2 roll dup 1 exch sub 3 -1 roll mul add
+ 4 -2 roll dup 1 exch sub 3 -1 roll mul add srgb}
+ bind def
+/shd {dup dup currentrgbcolor 4 -2 roll mul 4 -2 roll mul
+ 4 -2 roll mul srgb} bind def
+/$F2psBegin {$F2psDict begin /$F2psEnteredState save def} def
+/$F2psEnd {$F2psEnteredState restore end} def
+
+$F2psBegin
+10 setmiterlimit
+0 slj 0 slc
+ 0.06000 0.06000 sc
+%
+% Fig objects follow
+%
+%
+% here starts figure with depth 50
+% Polyline
+7.500 slw
+n 600 2400 m 1200 2400 l 1200 2100 l 600 2100 l
+ cp gs col0 s gr
+% Polyline
+n 600 2100 m 1200 2100 l 1200 1800 l 600 1800 l
+ cp gs col0 s gr
+% Polyline
+n 600 1800 m 1200 1800 l 1200 1500 l 600 1500 l
+ cp gs col0 s gr
+% Polyline
+n 600 1500 m 1200 1500 l 1200 1200 l 600 1200 l
+ cp gs col0 s gr
+% Polyline
+n 600 1200 m 1200 1200 l 1200 900 l 600 900 l
+ cp gs col0 s gr
+% Polyline
+n 600 900 m 1200 900 l 1200 600 l 600 600 l
+ cp gs col0 s gr
+% Polyline
+n 600 600 m 1200 600 l 1200 300 l 600 300 l
+ cp gs col0 s gr
+% Polyline
+n 1800 2400 m 2400 2400 l 2400 2100 l 1800 2100 l
+ cp gs col0 s gr
+% Polyline
+n 1800 2100 m 2400 2100 l 2400 1800 l 1800 1800 l
+ cp gs col0 s gr
+% Polyline
+n 1800 1800 m 2400 1800 l 2400 1500 l 1800 1500 l
+ cp gs col0 s gr
+% Polyline
+n 1800 1500 m 2400 1500 l 2400 1200 l 1800 1200 l
+ cp gs col0 s gr
+% Polyline
+n 1800 1200 m 2400 1200 l 2400 900 l 1800 900 l
+ cp gs col0 s gr
+% Polyline
+n 1800 900 m 2400 900 l 2400 600 l 1800 600 l
+ cp gs col0 s gr
+% Polyline
+n 1800 600 m 2400 600 l 2400 300 l 1800 300 l
+ cp gs col0 s gr
+% Polyline
+n 600 2400 m
+ 2400 2400 l gs col0 s gr
+% Polyline
+n 3600 2400 m 4200 2400 l 4200 2100 l 3600 2100 l
+ cp gs col0 s gr
+% Polyline
+n 3600 2100 m 4200 2100 l 4200 1800 l 3600 1800 l
+ cp gs col0 s gr
+% Polyline
+n 3600 1800 m 4200 1800 l 4200 1500 l 3600 1500 l
+ cp gs col0 s gr
+% Polyline
+n 3600 1500 m 4200 1500 l 4200 1200 l 3600 1200 l
+ cp gs col0 s gr
+% Polyline
+n 3600 1200 m 4200 1200 l 4200 900 l 3600 900 l
+ cp gs col0 s gr
+% Polyline
+n 3600 900 m 4200 900 l 4200 600 l 3600 600 l
+ cp gs col0 s gr
+% Polyline
+n 3600 600 m 4200 600 l 4200 300 l 3600 300 l
+ cp gs col0 s gr
+% Polyline
+n 4800 2400 m 5400 2400 l 5400 2100 l 4800 2100 l
+ cp gs col0 s gr
+% Polyline
+n 4800 2100 m 5400 2100 l 5400 1800 l 4800 1800 l
+ cp gs col0 s gr
+% Polyline
+n 4800 1800 m 5400 1800 l 5400 1500 l 4800 1500 l
+ cp gs col0 s gr
+% Polyline
+n 4800 1500 m 5400 1500 l 5400 1200 l 4800 1200 l
+ cp gs col0 s gr
+% Polyline
+n 4800 1200 m 5400 1200 l 5400 900 l 4800 900 l
+ cp gs col0 s gr
+% Polyline
+n 4800 900 m 5400 900 l 5400 600 l 4800 600 l
+ cp gs col0 s gr
+% Polyline
+n 4800 600 m 5400 600 l 5400 300 l 4800 300 l
+ cp gs col0 s gr
+% Polyline
+n 3600 2400 m
+ 5400 2400 l gs col0 s gr
+% Polyline
+n 6600 2400 m 7200 2400 l 7200 2100 l 6600 2100 l
+ cp gs col0 s gr
+% Polyline
+n 6600 2100 m 7200 2100 l 7200 1800 l 6600 1800 l
+ cp gs col0 s gr
+% Polyline
+n 6600 1800 m 7200 1800 l 7200 1500 l 6600 1500 l
+ cp gs col0 s gr
+% Polyline
+n 6600 1500 m 7200 1500 l 7200 1200 l 6600 1200 l
+ cp gs col0 s gr
+% Polyline
+n 6600 1200 m 7200 1200 l 7200 900 l 6600 900 l
+ cp gs col0 s gr
+% Polyline
+n 6600 900 m 7200 900 l 7200 600 l 6600 600 l
+ cp gs col0 s gr
+% Polyline
+n 6600 600 m 7200 600 l 7200 300 l 6600 300 l
+ cp gs col0 s gr
+% Polyline
+n 7800 2400 m 8400 2400 l 8400 2100 l 7800 2100 l
+ cp gs col0 s gr
+% Polyline
+n 7800 2100 m 8400 2100 l 8400 1800 l 7800 1800 l
+ cp gs col0 s gr
+% Polyline
+n 7800 1800 m 8400 1800 l 8400 1500 l 7800 1500 l
+ cp gs col0 s gr
+% Polyline
+n 7800 1500 m 8400 1500 l 8400 1200 l 7800 1200 l
+ cp gs col0 s gr
+% Polyline
+n 7800 1200 m 8400 1200 l 8400 900 l 7800 900 l
+ cp gs col0 s gr
+% Polyline
+n 7800 900 m 8400 900 l 8400 600 l 7800 600 l
+ cp gs col0 s gr
+% Polyline
+n 7800 600 m 8400 600 l 8400 300 l 7800 300 l
+ cp gs col0 s gr
+% Polyline
+n 6600 2400 m
+ 8400 2400 l gs col0 s gr
+% Polyline
+n 600 5400 m 1200 5400 l 1200 5100 l 600 5100 l
+ cp gs col0 s gr
+% Polyline
+n 600 5100 m 1200 5100 l 1200 4800 l 600 4800 l
+ cp gs col0 s gr
+% Polyline
+n 600 4800 m 1200 4800 l 1200 4500 l 600 4500 l
+ cp gs col0 s gr
+% Polyline
+n 600 4500 m 1200 4500 l 1200 4200 l 600 4200 l
+ cp gs col0 s gr
+% Polyline
+n 600 4200 m 1200 4200 l 1200 3900 l 600 3900 l
+ cp gs col0 s gr
+% Polyline
+n 600 3900 m 1200 3900 l 1200 3600 l 600 3600 l
+ cp gs col0 s gr
+% Polyline
+n 600 3600 m 1200 3600 l 1200 3300 l 600 3300 l
+ cp gs col0 s gr
+% Polyline
+n 1800 5400 m 2400 5400 l 2400 5100 l 1800 5100 l
+ cp gs col0 s gr
+% Polyline
+n 1800 5100 m 2400 5100 l 2400 4800 l 1800 4800 l
+ cp gs col0 s gr
+% Polyline
+n 1800 4800 m 2400 4800 l 2400 4500 l 1800 4500 l
+ cp gs col0 s gr
+% Polyline
+n 1800 4500 m 2400 4500 l 2400 4200 l 1800 4200 l
+ cp gs col0 s gr
+% Polyline
+n 1800 4200 m 2400 4200 l 2400 3900 l 1800 3900 l
+ cp gs col0 s gr
+% Polyline
+n 1800 3900 m 2400 3900 l 2400 3600 l 1800 3600 l
+ cp gs col0 s gr
+% Polyline
+n 1800 3600 m 2400 3600 l 2400 3300 l 1800 3300 l
+ cp gs col0 s gr
+% Polyline
+n 600 5400 m
+ 2400 5400 l gs col0 s gr
+% Polyline
+n 3600 5400 m 4200 5400 l 4200 5100 l 3600 5100 l
+ cp gs col0 s gr
+% Polyline
+n 3600 5100 m 4200 5100 l 4200 4800 l 3600 4800 l
+ cp gs col0 s gr
+% Polyline
+n 3600 4800 m 4200 4800 l 4200 4500 l 3600 4500 l
+ cp gs col0 s gr
+% Polyline
+n 3600 4500 m 4200 4500 l 4200 4200 l 3600 4200 l
+ cp gs col0 s gr
+% Polyline
+n 3600 4200 m 4200 4200 l 4200 3900 l 3600 3900 l
+ cp gs col0 s gr
+% Polyline
+n 3600 3900 m 4200 3900 l 4200 3600 l 3600 3600 l
+ cp gs col0 s gr
+% Polyline
+n 3600 3600 m 4200 3600 l 4200 3300 l 3600 3300 l
+ cp gs col0 s gr
+% Polyline
+n 4800 5400 m 5400 5400 l 5400 5100 l 4800 5100 l
+ cp gs col0 s gr
+% Polyline
+n 4800 5100 m 5400 5100 l 5400 4800 l 4800 4800 l
+ cp gs col0 s gr
+% Polyline
+n 4800 4800 m 5400 4800 l 5400 4500 l 4800 4500 l
+ cp gs col0 s gr
+% Polyline
+n 4800 4500 m 5400 4500 l 5400 4200 l 4800 4200 l
+ cp gs col0 s gr
+% Polyline
+n 4800 4200 m 5400 4200 l 5400 3900 l 4800 3900 l
+ cp gs col0 s gr
+% Polyline
+n 4800 3900 m 5400 3900 l 5400 3600 l 4800 3600 l
+ cp gs col0 s gr
+% Polyline
+n 4800 3600 m 5400 3600 l 5400 3300 l 4800 3300 l
+ cp gs col0 s gr
+% Polyline
+n 3600 5400 m
+ 5400 5400 l gs col0 s gr
+% Polyline
+n 6600 5400 m 7200 5400 l 7200 5100 l 6600 5100 l
+ cp gs col0 s gr
+% Polyline
+n 6600 5100 m 7200 5100 l 7200 4800 l 6600 4800 l
+ cp gs col0 s gr
+% Polyline
+n 6600 4800 m 7200 4800 l 7200 4500 l 6600 4500 l
+ cp gs col0 s gr
+% Polyline
+n 6600 4500 m 7200 4500 l 7200 4200 l 6600 4200 l
+ cp gs col0 s gr
+% Polyline
+n 6600 4200 m 7200 4200 l 7200 3900 l 6600 3900 l
+ cp gs col0 s gr
+% Polyline
+n 6600 3900 m 7200 3900 l 7200 3600 l 6600 3600 l
+ cp gs col0 s gr
+% Polyline
+n 6600 3600 m 7200 3600 l 7200 3300 l 6600 3300 l
+ cp gs col0 s gr
+% Polyline
+n 7800 5400 m 8400 5400 l 8400 5100 l 7800 5100 l
+ cp gs col0 s gr
+% Polyline
+n 7800 5100 m 8400 5100 l 8400 4800 l 7800 4800 l
+ cp gs col0 s gr
+% Polyline
+n 7800 4800 m 8400 4800 l 8400 4500 l 7800 4500 l
+ cp gs col0 s gr
+% Polyline
+n 7800 4500 m 8400 4500 l 8400 4200 l 7800 4200 l
+ cp gs col0 s gr
+% Polyline
+n 7800 4200 m 8400 4200 l 8400 3900 l 7800 3900 l
+ cp gs col0 s gr
+% Polyline
+n 7800 3900 m 8400 3900 l 8400 3600 l 7800 3600 l
+ cp gs col0 s gr
+% Polyline
+n 7800 3600 m 8400 3600 l 8400 3300 l 7800 3300 l
+ cp gs col0 s gr
+% Polyline
+n 6600 5400 m
+ 8400 5400 l gs col0 s gr
+/Times-Roman ff 180.00 scf sf
+825 2325 m
+gs 1 -1 sc (17) col0 sh gr
+/Times-Roman ff 180.00 scf sf
+825 2700 m
+gs 1 -1 sc (Traitement de 17) col0 sh gr
+/Times-Roman ff 180.00 scf sf
+6825 2700 m
+gs 1 -1 sc (Traitement de 20) col0 sh gr
+/Times-Roman ff 180.00 scf sf
+825 5700 m
+gs 1 -1 sc (Traitement de 40) col0 sh gr
+/Times-Roman ff 180.00 scf sf
+3900 5700 m
+gs 1 -1 sc (Traitement de 25) col0 sh gr
+/Times-Roman ff 180.00 scf sf
+3825 2700 m
+gs 1 -1 sc (Traitement de 34) col0 sh gr
+/Times-Roman ff 180.00 scf sf
+7125 5700 m
+gs 1 -1 sc (Etat final) col0 sh gr
+/Times-Roman ff 180.00 scf sf
+3825 2325 m
+gs 1 -1 sc (34) col0 sh gr
+/Times-Roman ff 180.00 scf sf
+5025 2325 m
+gs 1 -1 sc (17) col0 sh gr
+/Times-Roman ff 180.00 scf sf
+6825 2325 m
+gs 1 -1 sc (34) col0 sh gr
+/Times-Roman ff 180.00 scf sf
+6825 2025 m
+gs 1 -1 sc (20) col0 sh gr
+/Times-Roman ff 180.00 scf sf
+8025 2325 m
+gs 1 -1 sc (17) col0 sh gr
+/Times-Roman ff 180.00 scf sf
+825 5325 m
+gs 1 -1 sc (40) col0 sh gr
+/Times-Roman ff 180.00 scf sf
+2025 5325 m
+gs 1 -1 sc (17) col0 sh gr
+/Times-Roman ff 180.00 scf sf
+2025 5025 m
+gs 1 -1 sc (20) col0 sh gr
+/Times-Roman ff 180.00 scf sf
+2025 4725 m
+gs 1 -1 sc (34) col0 sh gr
+/Times-Roman ff 180.00 scf sf
+3825 5325 m
+gs 1 -1 sc (40) col0 sh gr
+/Times-Roman ff 180.00 scf sf
+3825 5025 m
+gs 1 -1 sc (34) col0 sh gr
+/Times-Roman ff 180.00 scf sf
+3825 4725 m
+gs 1 -1 sc (25) col0 sh gr
+/Times-Roman ff 180.00 scf sf
+4950 5325 m
+gs 1 -1 sc ( 17) col0 sh gr
+/Times-Roman ff 180.00 scf sf
+4950 5025 m
+gs 1 -1 sc (20) col0 sh gr
+/Times-Roman ff 180.00 scf sf
+6825 5325 m
+gs 1 -1 sc (40) col0 sh gr
+/Times-Roman ff 180.00 scf sf
+6825 5025 m
+gs 1 -1 sc (34) col0 sh gr
+/Times-Roman ff 180.00 scf sf
+6825 4425 m
+gs 1 -1 sc (20) col0 sh gr
+/Times-Roman ff 180.00 scf sf
+6825 4125 m
+gs 1 -1 sc (17) col0 sh gr
+/Times-Roman ff 180.00 scf sf
+6750 4725 m
+gs 1 -1 sc ( 25) col0 sh gr
+% here ends figure;
+$F2psEnd
+rs
+showpage
diff --git a/lessons/tris/stack_sort.tex b/lessons/tris/stack_sort.tex
new file mode 100755
index 0000000000000000000000000000000000000000..615ba40454fcc8f0210dacd22badbab025962a82
--- /dev/null
+++ b/lessons/tris/stack_sort.tex
@@ -0,0 +1,97 @@
+\documentclass[a4paper,11pt,dvips]{article}
+\usepackage{epsfig}
+\usepackage[T1]{fontenc}
+\usepackage[latin1]{inputenc}
+\usepackage{amsmath}
+
+\pagestyle{myheadings}
+%\markright{Tri � deux piles}
+\advance\voffset by -0.5in
+\textheight=230mm
+\textwidth=165mm
+\oddsidemargin=0pt
+\evensidemargin=0pt
+\topmargin=0pt
+\headheight=0pt
+\parindent=0cm
+
+\date{}
+\title{
+ \vspace*{-2cm}
+ \begin{tabular}{|l|}
+ \hline \\
+ {\fontsize{16}{25} \bf Algorithmique et structures de donn�es} \\
+ \vspace*{-0.5cm}\\
+ \hline
+ {\bf\it \quad Tri � deux piles}\\
+ \hline
+ {\tiny ISC - HEPIA - HES-SO//Gen�ve} \\
+ \hline
+ \end{tabular}
+}
+
+\begin{document}
+
+\maketitle
+\smallskip
+\thispagestyle{empty}
+\renewcommand{\labelitemi}{$\bullet$}
+
+\vspace*{-2cm}
+\section*{Description}
+
+\medskip
+\begin{itemize}
+\item Le tableau est parcouru �l�ment par �l�ment.
+\item Une premi�re pile (celle de gauche dans l'exemple de la figure~\ref{fig1})
+contient toujours des �l�ments tri�s en ordre croissant en partant du sommet.
+\item Une seconde pile (celle de droite dans l'exemple de la figure~\ref{fig1})
+contient toujours des �l�ments en ordre d�croissant en partant du sommet.
+\item A chaque �tape, on d�pile les �l�ments d'une des piles pour les empiler
+dans l'autre, jusqu'� ce que l'�l�ment trait� soit empilable dans la pile de
+gauche en respectant l'ordre dans chacune des deux piles.
+\item En fin de tri, tous les �l�ments se trouvent dans la premi�re pile; on
+termine donc le tri en vidant cette pile dans le tableau de d�part.
+\end{itemize}
+
+\section*{Exemple}
+L'exemple d�crit ci-dessous est illustr� � la figure~\ref{fig1}.
+Soit le tableau � trier suivant:
+\begin{center}
+\begin{tabular}{|c|c|c|c|c|}
+\hline
+ 17 & 34 & 20 & 40 & 25 \\
+\hline
+\end{tabular}
+\end{center}
+Le tableau est parcouru de gauche � droite.
+
+\medskip
+\begin{itemize}
+\item 17 est plac� dans la pile de gauche.
+\item 34 est plus grand que 17: 17 est d�pil� de la pile de gauche pour �tre
+empil� dans la pile de droite; 34 est plac� dans la pile de gauche.
+\item 20 est plus petit que 34 et plus grand que 17: il est empil� dans la pile
+de gauche.
+\item 40 est compar� avec 20 et 34: ceux-ci sont d�pil�s de la pile de gauche
+pour �tre empil�s dans la pile de droite; 40 est empil� � gauche.
+\item 25 est plus petit que 34: celui-ci est d�pil� de droite pour �tre empil� �
+gauche; 25 est empil� � gauche.
+\item Il n'y a plus d'�l�ment � traiter: la pile de droite est vid�e, chacun de
+ces �l�ments �tant empil� dans la pile de gauche; cette pile contient au final
+tous les �l�ments en ordre croissant en partant du sommet.
+\item Il ne reste plus qu'� vider la premi�re pile dans le tableau.
+\end{itemize}
+
+\begin{center}
+\begin{figure}[ht]
+\begin{center}
+\epsfig{file=figures/stack_sort_expl.eps, width=12cm, height=9cm}
+\end{center}
+\caption{Utilisation des deux piles pour le tri}
+\label{fig1}
+\end{figure}
+\end{center}
+
+\end{document}
+
diff --git a/lessons/tris/stack_sort_pseudocode.txt b/lessons/tris/stack_sort_pseudocode.txt
new file mode 100644
index 0000000000000000000000000000000000000000..fde2e0c9026fd523b1c1e7e31f71970548515bfe
--- /dev/null
+++ b/lessons/tris/stack_sort_pseudocode.txt
@@ -0,0 +1,37 @@
+type Array_Int; // type tableau d'entiers à 1 dimension
+type Pile_Int; // type pile d'entiers
+
+// Retourne "a < b" si <op> = "<", "a >= b" si <op> = ">=",
+// "true" si <op> = "" et "false" sinon
+function condition(a,b : Integer; op : String) return Boolean;
+
+// Transfère les éléments de <pile_1> à <pile_2>
+// tant que condition(sommet(pile_1),val,op) est vrai
+procedure transfert(pile_1, pile_2 : Pile_Int;
+ val: Integer; op : String);
+
+// Trie à l'aide de 2 piles
+procedure trier(tab : Array_Int)
+ pile_g,pile_d : Pile_Int;
+begin
+ // parcourt le tableau <tab>
+ for i in 0..tab.length loop
+ // transfère les éléments de <pile_g> à <pile_d>
+ // tant que sommet(pile_g) < tab[i]
+ transfert(pile_g,pile_d,tab[i],"<");
+ // transfère les éléments de <pile_d> à <pile_g>
+ // tant que sommet(pile_d) >= tab[i]
+ transfert(pile_d,pile_g,tab[i],">=");
+ // empile l'élément <tab[i]> dans <pile_g>
+ empiler(pile_g,tab[i]);
+ end loop;
+
+ // transfère tous les éléments de <pile_d> à <pile_g>
+ transfert(pile_d,pile_g,0,"");
+
+ // transfère tous les éléments de <pile_g> dans <tab>
+ for i in 0..tab.length loop
+ depiler(pile_g,tab[i]);
+ end loop;
+end Trier;
+
diff --git a/slides/cours_8.md b/slides/cours_8.md
index 82262d86c28c6f8c8abe28b323cbe59f56979903..78f5e78ed5b170946633441c243f7c3c271e76a5 100644
--- a/slides/cours_8.md
+++ b/slides/cours_8.md
@@ -176,7 +176,7 @@ bool board[n][n];
```C
// Pour chaque ligne placer la reine sur toutes les colonnes
// et compter les solutions
-void nbr_solutions(board, coloumn, counter);
+void nbr_solutions(board, column, counter);
// Placer la reine à li, co et rendre inaccessible devant
void placer_devant(board_ini, board, li, co);
```
@@ -224,13 +224,13 @@ placer_devant(old_board, board, ligne, colonne)
```C
// Calcule le nombre de solutions au problème des <N> reines
-void nb_sol(int n, bool board_ini[n][n], int co, int *ptr_cpt) {
+void nb_sol(int n, bool board_in[n][n], int co, int *ptr_cpt) {
for (int li = 0; li < n; li++) {
- if (board_ini[li][co]) {
+ if (board_in[li][co]) {
if (co < n - 1) {
bool board[n][n]; // allocation
// à chaque nouvelle tentative
- prises_devant(n, board_ini, board, li, co);
+ prises_devant(n, board_in, board, li, co);
nb_sol(n, board, co + 1, ptr_cpt);
} else {
*ptr_cpt = (*ptr_cpt) + 1;
@@ -251,9 +251,9 @@ void nb_sol(int n, bool board_ini[n][n], int co, int *ptr_cpt) {
// Retourne une copie du tableau <board> complété avec les positions
// prises sur la droite droite par une reine placée en <board(li,co)>
void prises_devant(
- int n, bool board_ini[n][n], bool board[n][n], int li, int co)
+ int n, bool board_in[n][n], bool board[n][n], int li, int co)
{
- copy(n, board_ini, board);
+ copy(n, board_in, board);
board[li][co] = false; // position de la reine
for (int j = 1; j < n - co; j++) {
// horizontale et diagonales à droite de la reine
@@ -504,7 +504,8 @@ void *realloc(void *ptr, size_t size);
stack_create(); // crée une pile avec une taille par défaut
// vérifie si la pile est pleine et réalloue si besoin
stack_push();
-// vérifie si la pile est vide/trop grande et réalloue si besoin
+// vérifie si la pile est vide/trop grande
+// et réalloue si besoin
stack_pop();
```
@@ -531,11 +532,13 @@ Soit `tab` le tableau à trier:
```C
Pour tous les i = 0 à N-1
- Si tab[i] est plus petit que le sommet de G
- empiler tab[i] sur G
- sinon
- dépiler G dans D
- empiler tab[i] sur G
+
+ tant que (tab[i] > que le sommet de G ou tab[i] < sommet de D) {
+ dépiler G dans D ou de D dans G
+ }
+
+ empiler tab[i] sur G
+
tab est trié dans G
```
diff --git a/source_codes/piles/eval_post.c b/source_codes/piles/eval_post.c
new file mode 100644
index 0000000000000000000000000000000000000000..9c2993ba7992966552eeb8e2d358e5c556589436
--- /dev/null
+++ b/source_codes/piles/eval_post.c
@@ -0,0 +1,32 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include "pile_ptr_int.h"
+
+void main(int argc,char** argv) {
+ pile stack_nb = pile_creer();
+ int res,nb1,nb2;
+ for (int i=1;i<argc;i++) {
+ if ( argv[i][0] < '0' || '9' < argv[i][0]) {
+ nb1 = pile_depiler(&stack_nb);
+ nb2 = pile_depiler(&stack_nb);
+ }
+ switch(argv[i][0]) {
+ case '+':
+ res = nb2+nb1;
+ break;
+ case '-':
+ res = nb2-nb1;
+ break;
+ case 'x':
+ res = nb2*nb1;
+ break;
+ case '/':
+ res = nb2/nb1;
+ break;
+ default :
+ res = atoi(argv[i]);
+ }
+ pile_empiler(&stack_nb,res);
+ }
+ printf("%d\n",pile_depiler(&stack_nb));
+}
diff --git a/source_codes/piles/pile_array_int.c b/source_codes/piles/pile_array_int.c
new file mode 100644
index 0000000000000000000000000000000000000000..8efa1aff7d6472982a03f98828e9dd78b537d278
--- /dev/null
+++ b/source_codes/piles/pile_array_int.c
@@ -0,0 +1,68 @@
+#include <stdlib.h>
+#include <stdbool.h>
+#include <assert.h>
+#include <limits.h>
+#include"pile_array_int.h"
+
+bool pile_est_valide(pile stack) {
+ return (stack.capacite > 0 && stack.sommet >= -1 && stack.data != NULL);
+}
+
+bool pile_est_vide(pile stack) {
+ assert(pile_est_valide(stack));
+ return (-1 == stack.sommet);
+}
+
+bool pile_est_pleine(pile stack) {
+ assert(pile_est_valide(stack));
+ return (stack.capacite-1 == stack.sommet);
+}
+
+int pile_count(pile stack) {
+ assert(pile_est_valide(stack));
+ return stack.sommet+1;
+}
+
+int pile_sommet(pile stack) {
+ assert(!pile_est_vide(stack));
+ return stack.data[stack.sommet];
+}
+
+pile pile_creer(int max) {
+ assert(max > 0);
+ pile stack;
+ stack.capacite = max;
+ stack.sommet = -1;
+ stack.data = malloc(max*sizeof(int));
+ return stack;
+}
+
+void pile_resize(pile* stack,int max) {
+ assert(pile_est_valide(*stack));
+ if (max > stack->capacite) {
+ stack->capacite = max;
+ stack->data = realloc(stack->data,max*sizeof(int));
+ }
+}
+
+void pile_detruire(pile* stack) {
+ stack->capacite = -1;
+ stack->sommet = INT_MIN;
+ free(stack->data);
+ stack->data = NULL;
+}
+
+void pile_empiler(pile* stack,int val) {
+ if (pile_est_pleine(*stack)) {
+ pile_resize(stack,stack->capacite+INCR);
+ }
+ stack->sommet++;
+ stack->data[stack->sommet] = val;
+}
+
+int pile_depiler(pile* stack) {
+ int val = pile_sommet(*stack);
+ stack->sommet--;
+ return val;
+}
+
diff --git a/source_codes/piles/pile_array_int.h b/source_codes/piles/pile_array_int.h
new file mode 100644
index 0000000000000000000000000000000000000000..c9ea8e6b409c376327c678cd3418c950f2b94ca5
--- /dev/null
+++ b/source_codes/piles/pile_array_int.h
@@ -0,0 +1,35 @@
+#ifndef PILE_ARRAY_INT_H
+#define PILE_ARRAY_INT_H
+
+#include <stdbool.h>
+const int INCR = 100;
+
+typedef struct _pile {
+ int* data;
+ int sommet;
+ int capacite;
+} pile;
+
+//Créer une nouvelle pile vide
+pile pile_creer(int max);
+//Libérer le tableau, mettre la capacité à < -1
+void pile_detruire(pile* stack);
+//Empiler un élement au sommet de la pile
+void pile_empiler(pile* stack,int val);
+//Dépiler un élément du sommet de la pile
+int pile_depiler(pile* stack);
+//Tester si la pile est vide
+bool pile_est_vide(pile stack);
+//Tester si la pile est pleine
+bool pile_est_pleine(pile stack);
+//Consulter l'élément au sommet de la pile
+int pile_sommet(pile stack);
+//Compter du nombre d'éléments de la pile
+int pile_count(pile stack);
+
+#endif
+
+
+
+
+
diff --git a/source_codes/piles/pile_ptr_int.c b/source_codes/piles/pile_ptr_int.c
new file mode 100644
index 0000000000000000000000000000000000000000..c1f3b0e772d04836178e5bfbc1bcd2edc2105546
--- /dev/null
+++ b/source_codes/piles/pile_ptr_int.c
@@ -0,0 +1,96 @@
+#include <stdlib.h>
+#include <stdio.h>
+#include <stdbool.h>
+#include <assert.h>
+#include "pile_ptr_int.h"
+
+
+//Creer une nouvelle pile vide
+pile pile_creer() {
+ return NULL;
+}
+
+//Tester si la pile est vide
+bool pile_est_vide(pile stack) {
+ return (NULL == stack);
+}
+
+//Inserer un élement en début de pile
+void pile_empiler(pile* stack,int data) {
+ element* elmt = malloc(sizeof(element));
+ elmt->data = data;
+ elmt->next = *stack;
+ *stack = elmt;
+}
+
+//Consulter l'élément au sommet de la pile
+int pile_sommet(pile stack) {
+ assert(!pile_est_vide(stack));
+ return stack->data;
+}
+
+//Supprimer un élément de la pile
+int pile_depiler(pile* stack) {
+ int data = pile_sommet(*stack);
+ element* elmt = *stack;
+ *stack = (*stack)->next;
+ free(elmt);
+ return data;
+}
+
+//Désallouer complètement la pile
+void pile_detruire(pile* stack) {
+ while (!pile_est_vide(*stack)) {
+ int data = pile_depiler(stack);
+ }
+}
+
+//Compter le nombre d'éléments de la pile:
+int pile_count(pile stack) {
+ int cnt = 0;
+ while (NULL != stack) {
+ stack = stack->next;
+ cnt++;
+ }
+ return cnt;
+}
+
+/////////////////////////////////////////////////////////
+/*
+#include <stdlib.h>
+#include <stdio.h>
+#include <stdbool.h>
+#include "stack.h"
+
+void print(void* a) {
+ int* b = (int*)a;
+ printf("%d ",*b);
+}
+int cmp(void* a,void* b) {
+ int* aa = (int*)a;
+ int* bb = (int*)b;
+ if (*aa == *bb) return 0;
+ else if (*aa < *bb) return -1;
+ else return 1;
+}
+
+int main() {
+
+ Stack_Elmt* pile = stack_create();
+ int a = 3;
+ pile = stack_push(pile,&a);
+ int b = 6;
+ pile = stack_push(pile,&b);
+ int c = 7;
+ pile = stack_push(pile,&c);
+ stack_process(pile,print); printf("\n");
+ int d = 6;
+ Stack_Elmt* elmt = stack_pop(pile,&d,cmp);
+ int* tutu = (int*)(elmt->data);
+ printf("%d\n",*tutu);
+ stack_process(pile,print); printf("\n");
+ return 0;
+}*/
+
+
+
diff --git a/source_codes/piles/pile_ptr_int.h b/source_codes/piles/pile_ptr_int.h
new file mode 100644
index 0000000000000000000000000000000000000000..113525c9e0e88dca669123517d1e45d89ca76c2d
--- /dev/null
+++ b/source_codes/piles/pile_ptr_int.h
@@ -0,0 +1,32 @@
+/* pour éviter que le précompilateur inclue plusieurs fois le fichier .h */
+#ifndef PILE_PTR_INT_H
+#define PILE_PTR_INT_H
+#include <stdbool.h>
+
+/* Utilité du typedef : Element a; <=> struct Element a; */
+typedef struct _element {
+ int data;
+ struct _element* next;
+} element;
+typedef element* pile;
+
+//Créer d'une nouvelle pile vide
+pile pile_creer();
+//Désallouer complètement la pile
+void pile_detruire(pile* stack);
+//Empiler un élement en début de pile
+void pile_empiler(pile* stack,int data);
+//Dépiler un élément de la pile
+int pile_depiler(pile* stack);
+//Consulter l'élément au sommet de la pile
+int pile_sommet(pile stack);
+//Tester si la pile est vide
+bool pile_est_vide(pile stack);
+//Compter le nombre d'éléments de la pile:
+int pile_count(pile stack);
+#endif
+
+
+
+
+
diff --git a/source_codes/piles/pile_ptr_int_skel.c b/source_codes/piles/pile_ptr_int_skel.c
new file mode 100644
index 0000000000000000000000000000000000000000..9986b3aba7078701bef0a3ce29e90b3c064e11fe
--- /dev/null
+++ b/source_codes/piles/pile_ptr_int_skel.c
@@ -0,0 +1,50 @@
+#include <stdlib.h>
+#include <stdio.h>
+#include <stdbool.h>
+#include <assert.h>
+#include "pile_ptr_int.h"
+
+//Creer une nouvelle pile vide
+pile pile_creer() {
+ return NULL;
+}
+
+//Tester si la pile est vide
+bool pile_est_vide(pile stack) {
+ return (NULL == stack);
+}
+
+//Inserer un élement en début de pile
+void pile_empiler(pile* stack,int val) {
+ element* elmt = malloc(sizeof(element));
+ elmt->data = val;
+ elmt->next = *stack;
+ *stack = elmt;
+}
+
+//Consulter l'élément au sommet de la pile
+int pile_sommet(pile stack) {
+ assert(!pile_est_vide(stack));
+ return stack->data;
+}
+
+//Supprimer un élément de la pile
+int pile_depiler(pile* stack) {
+ int data = pile_sommet(*stack);
+ // à compléter
+ return data;
+}
+
+//Désallouer complètement la pile
+void pile_detruire(pile* stack) {
+ // à compléter
+}
+
+//Compter le nombre d'éléments de la pile:
+int pile_count(pile stack) {
+ int cnt = 0;
+ // à compléter
+ return cnt;
+}
+
+
diff --git a/source_codes/queues/queue_array_int.c b/source_codes/queues/queue_array_int.c
new file mode 100644
index 0000000000000000000000000000000000000000..752ef9cf4a4b573bf05d463167a092106bf5fa1e
--- /dev/null
+++ b/source_codes/queues/queue_array_int.c
@@ -0,0 +1,72 @@
+#include <stdlib.h>
+#include <stdbool.h>
+#include <assert.h>
+#include <limits.h>
+#include"queue_array_int.h"
+
+bool queue_est_valide(queue fa) {
+ return (fa.capacite > 0 && fa.debut >= -1);
+}
+
+bool queue_est_vide(queue fa) {
+ assert(queue_est_valide(fa));
+ return (-1 == fa.debut);
+}
+
+bool queue_est_pleine(queue fa) {
+ assert(queue_est_valide(fa));
+ return (fa.capacite-1 == fa.debut);
+}
+
+int queue_count(queue fa) {
+ assert(queue_est_valide(fa));
+ return fa.debut+1;
+}
+
+int queue_tete(queue fa) {
+ assert(!queue_est_vide(fa));
+ return fa.data[0];
+}
+
+int queue_debut(queue fa) {
+ assert(!queue_est_vide(fa));
+ return fa.data[fa.debut];
+}
+
+queue queue_creer() {
+ queue fa;
+ fa.capacite = INCR;
+ fa.debut = -1;
+ fa.data = malloc(INCR*sizeof(int));
+ return fa;
+}
+
+void queue_resize(queue* fa,int max) {
+ assert(queue_est_valide(*fa));
+ if (max > fa->capacite) {
+ fa->capacite = max;
+ fa->data = realloc(fa->data,max*sizeof(int));
+ }
+}
+
+void queue_detruire(queue* fa) {
+ fa->capacite = -1;
+ fa->debut = INT_MIN;
+ free(fa->data);
+}
+
+void queue_inserer(queue* fa,int val) {
+ if (queue_est_pleine(*fa)) {
+ queue_resize(fa,fa->capacite+INCR);
+ }
+ fa->debut++;
+ fa->data[fa->debut] = val;
+}
+
+int queue_extraire(queue* fa) {
+ int val = queue_tete(*fa);
+ fa->debut--;
+ fa->data = memmove(fa->data,fa->data+1,queue_count(*fa)*sizeof(int));
+ return val;
+}
+
diff --git a/source_codes/queues/queue_array_int.h b/source_codes/queues/queue_array_int.h
new file mode 100644
index 0000000000000000000000000000000000000000..9c9c53ead2839abb4191f2180ea37b95d94ae345
--- /dev/null
+++ b/source_codes/queues/queue_array_int.h
@@ -0,0 +1,35 @@
+#ifndef QUEUE_ARRAY_INT_H
+#define QUEUE_ARRAY_INT_H
+
+#include <stdbool.h>
+const int INCR = 100;
+
+typedef struct _queue {
+ int* data;
+ int debut; //tete à l'index 0
+ int capacite;
+} queue;
+
+//Créer une nouvelle queue vide
+queue queue_creer();
+//Libérer le tableau, mettre la capacité à < -1
+void queue_detruire(queue* fa);
+//Inserer un élement en début de queue
+void queue_inserer(queue* fa,int val);
+//Extraire un élément en tête de queue
+int queue_extraire(queue* fa);
+//Consulter l'élément en tête de queue
+int queue_tete(queue fa);
+//Consulter l'élément au début de queue
+int queue_debut(queue fa);
+//Tester si la queue est vide
+bool queue_est_vide(queue fa);
+//Compter du nombre d'éléments de la queue:
+int queue_count(queue fa);
+
+#endif
+
+
+
+
+
diff --git a/source_codes/queues/queue_array_int_partiel.c b/source_codes/queues/queue_array_int_partiel.c
new file mode 100644
index 0000000000000000000000000000000000000000..e964c9888d71d0f2b61e73fad405545693c120c6
--- /dev/null
+++ b/source_codes/queues/queue_array_int_partiel.c
@@ -0,0 +1,66 @@
+#include <stdlib.h>
+#include <stdbool.h>
+#include <assert.h>
+#include"queue_array_int.h"
+
+bool queue_est_valide(queue fa) {
+ return (fa.capacite > 0 && fa.debut >= -1);
+}
+
+bool queue_est_vide(queue fa) {
+ assert(queue_est_valide(fa));
+ return (-1 == fa.debut);
+}
+
+bool queue_est_pleine(queue fa) {
+ // à compléter
+}
+
+int queue_count(queue fa) {
+ // à compléter
+}
+
+int queue_tete(queue fa) {
+ assert(!queue_est_vide(fa));
+ return fa.data[0];
+}
+
+int queue_debut(queue fa) {
+ assert(!queue_est_vide(fa));
+ return fa.data[fa.debut];
+}
+
+queue queue_creer() {
+ queue fa;
+ fa.capacite = INCR;
+ fa.debut = -1;
+ fa.data = malloc(INCR*sizeof(int));
+ return fa;
+}
+
+void queue_resize(queue* fa,int max) {
+ assert(queue_est_valide(*fa));
+ if (max > fa->capacite) {
+ fa->capacite = max;
+ fa->data = realloc(fa->data,max*sizeof(int));
+ }
+}
+
+void queue_detruire(queue* fa) {
+ // à compléter
+}
+
+void queue_inserer(queue* fa,int val) {
+ if (queue_est_pleine(*fa)) {
+ queue_resize(fa,fa->capacite+INCR);
+ }
+ fa->debut++;
+ fa->data[fa->debut] = val;
+}
+
+int queue_extraire(queue* fa) {
+ int val = queue_tete(*fa);
+ // à compléter
+ return val;
+}
+
diff --git a/source_codes/queues/queue_ptr_int.c b/source_codes/queues/queue_ptr_int.c
new file mode 100644
index 0000000000000000000000000000000000000000..4da190888455e39e362c64988ef7c09d80b40f1e
--- /dev/null
+++ b/source_codes/queues/queue_ptr_int.c
@@ -0,0 +1,112 @@
+#include <stdlib.h>
+#include <stdio.h>
+#include <stdbool.h>
+#include <assert.h>
+#include "queue_ptr_int.h"
+
+
+//Creer une nouvelle queue vide
+queue queue_creer() {
+ queue fa;
+ fa.tete = fa.debut = NULL;
+ return fa;
+}
+
+//Inserer un élement en début de queue
+void queue_inserer(queue* fa,int val) {
+ element* elmt = malloc(sizeof(element));
+ elmt->data = val;
+ elmt->next = NULL;
+ if (queue_est_vide(*fa)) {
+ fa->tete = elmt;
+ } else {
+ fa->debut->next = elmt;
+ }
+ fa->debut = elmt;
+}
+
+//Extraire un élément en tête de queue
+int queue_extraire(queue* fa) {
+ int val = queue_tete(*fa);
+ element* elmt = fa->tete;
+ fa->tete = fa->tete->next;
+ free(elmt);
+ if (NULL == fa->tete) {
+ fa->debut = NULL;
+ }
+ return val;
+}
+
+//Désallouer complètement la queue
+void queue_detruire(queue* fa) {
+ while (!queue_est_vide(*fa)) {
+ int val = queue_extraire(fa);
+ }
+}
+
+//Tester si la queue est vide
+bool queue_est_vide(queue fa) {
+ return (NULL == fa.tete && NULL == fa.debut);
+}
+
+//Consulter l'élément en tête de queue
+int queue_tete(queue fa) {
+ assert(!queue_est_vide(fa));
+ return fa.tete->data;
+}
+
+//Consulter l'élément en début de queue
+int queue_debut(queue fa) {
+ assert(!queue_est_vide(fa));
+ return fa.debut->data;
+}
+
+//Compter le nombre d'éléments de la queue:
+int queue_count(queue fa) {
+ int cnt = 0;
+ while (NULL != fa.tete->next) {
+ fa.tete = fa.tete->next;
+ cnt++;
+ }
+ return cnt;
+}
+
+/////////////////////////////////////////////////////////
+/*
+#include <stdlib.h>
+#include <stdio.h>
+#include <stdbool.h>
+#include "fa.h"
+
+void print(void* a) {
+ int* b = (int*)a;
+ printf("%d ",*b);
+}
+int cmp(void* a,void* b) {
+ int* aa = (int*)a;
+ int* bb = (int*)b;
+ if (*aa == *bb) return 0;
+ else if (*aa < *bb) return -1;
+ else return 1;
+}
+
+int main() {
+
+ fa_Elmt* queue = fa_create();
+ int a = 3;
+ queue = fa_push(queue,&a);
+ int b = 6;
+ queue = fa_push(queue,&b);
+ int c = 7;
+ queue = fa_push(queue,&c);
+ fa_process(queue,print); printf("\n");
+ int d = 6;
+ fa_Elmt* elmt = fa_pop(queue,&d,cmp);
+ int* tutu = (int*)(elmt->data);
+ printf("%d\n",*tutu);
+ fa_process(queue,print); printf("\n");
+ return 0;
+}*/
+
+
+
diff --git a/source_codes/queues/queue_ptr_int.h b/source_codes/queues/queue_ptr_int.h
new file mode 100644
index 0000000000000000000000000000000000000000..4dd3a6cf62d3b1641a07edced7cf9333f1ada53f
--- /dev/null
+++ b/source_codes/queues/queue_ptr_int.h
@@ -0,0 +1,37 @@
+/* pour éviter que le précompilateur inclue plusieurs fois le fichier .h */
+#ifndef QUEUE_PTR_INT_H
+#define QUEUE_PTR_INT_H
+#include <stdbool.h>
+
+/* Utilité du typedef : Element a; <=> struct Element a; */
+typedef struct _element {
+ int data;
+ struct _element* next;
+} element;
+
+typedef struct _queue {
+ element* tete;
+ element* debut;
+} queue;
+
+//Créer d'une nouvelle queue vide
+queue queue_creer();
+//Désallouer complètement la queue
+void queue_detruire(queue* fa);
+//Insérer un élement en début de queue
+void queue_inserer(queue* fa,int val);
+//Extraire un élément de la queue
+int queue_extraire(queue* fa);
+//Consulter l'élément en tête de queue
+int queue_tete(queue fa);
+//Consulter l'élément en début de queue
+int queue_debut(queue fa);
+//Tester si la queue est vide
+bool queue_est_vide(queue fa);
+//Compter le nombre d'éléments de la queue:
+int queue_count(queue fa);
+#endif
+
+
+
+
diff --git a/source_codes/queues/queue_ptr_int_partiel.c b/source_codes/queues/queue_ptr_int_partiel.c
new file mode 100644
index 0000000000000000000000000000000000000000..41f2916747bc67b985138ea5dbfe9a85bba811e3
--- /dev/null
+++ b/source_codes/queues/queue_ptr_int_partiel.c
@@ -0,0 +1,68 @@
+#include <stdlib.h>
+#include <stdio.h>
+#include <stdbool.h>
+#include <assert.h>
+#include "queue_ptr_int.h"
+
+//Creer une nouvelle queue vide
+queue queue_creer() {
+ queue fa;
+ fa.tete = fa.debut = NULL;
+ return fa;
+}
+
+//Inserer un élement en début de queue
+void queue_inserer(queue* fa,int val) {
+ element* elmt = malloc(sizeof(element));
+ elmt->data = val;
+ elmt->next = NULL;
+ if (queue_est_vide(*fa)) {
+ fa->tete = elmt;
+ } else {
+ fa->debut->next = elmt;
+ }
+ fa->debut = elmt;
+}
+
+//Extraire un élément en tête de queue
+int queue_extraire(queue* fa) {
+ int val = queue_tete(*fa);
+ element* elmt = fa->tete;
+ fa->tete = fa->tete->next;
+ free(elmt);
+ if (NULL == fa->tete) {
+ fa->debut = NULL;
+ }
+ return val;
+}
+
+//Désallouer complètement la queue
+void queue_detruire(queue* fa) {
+ // à compléter
+}
+
+//Tester si la queue est vide
+bool queue_est_vide(queue fa) {
+ return (NULL == fa.tete && NULL == fa.debut);
+}
+
+//Consulter l'élément en tête de queue
+int queue_tete(queue fa) {
+ assert(!queue_est_vide(fa));
+ return fa.tete->data;
+}
+
+//Consulter l'élément en début de queue
+int queue_debut(queue fa) {
+ assert(!queue_est_vide(fa));
+ return fa.debut->data;
+}
+
+//Compter le nombre d'éléments de la queue:
+int queue_count(queue fa) {
+ int cnt = 0;
+ // à compléter
+ return cnt;
+}
+
+
diff --git a/source_codes/recursivity/rec_reines_no_alloc.c b/source_codes/recursivity/rec_reines_no_alloc.c
index a1fd34b96212b05544f756bdcfc921afc7088db6..a397e3cb558532cea5069fc51c0b2531e402329b 100644
--- a/source_codes/recursivity/rec_reines_no_alloc.c
+++ b/source_codes/recursivity/rec_reines_no_alloc.c
@@ -3,18 +3,18 @@
#include <stdio.h>
#include <stdlib.h>
-void board_ini(int n, bool board[n][n], bool val) {
- for (int i = 0; i < n; ++i) {
- for (int j = 0; j < n; ++j) {
+void board_init(int n, bool board[n][n], bool val) {
+ for (int i=0;i<n;i++) {
+ for (int j=0;j<n;j++) {
board[i][j] = val;
}
}
}
-// Copie les valeurs de la board_ini dans board
-void copy(int n, bool board_ini[n][n], bool board[n][n]) {
- for (int i = 0; i < n; i++) {
- for (int j = 0; j < n; j++) {
- board[i][j] = board_ini[i][j];
+// Copie les valeurs de la <board_in> dans <board>
+void copy(int n, bool board_in[n][n], bool board[n][n]) {
+ for (int i=0;i<n;i++) {
+ for (int j=0;j<n;j++) {
+ board[i][j] = board_in[i][j];
}
}
}
@@ -22,31 +22,31 @@ void copy(int n, bool board_ini[n][n], bool board[n][n]) {
// Retourne une copie du tableau <board> complété avec les positions
// prises sur la droite droite par une reine placée en <board(li,co)>
void prises_devant(
- int n, bool board_ini[n][n], bool board[n][n], int li, int co) {
- copy(n, board_ini, board);
+ int n, bool board_in[n][n], bool board[n][n], int li, int co) {
+ copy(n, board_in, board);
board[li][co] = false; // position de la reine
- for (int j = 1; j < n - co; j++) {
+ for (int j=1;j<n-co;j++) {
// horizontale et diagonales à droite de la reine
if (j <= li) {
- board[li - j][co + j] = false;
+ board[li-j][co+j] = false;
}
- board[li][co + j] = false;
- if (li + j < n) {
- board[li + j][co + j] = false;
+ board[li][co+j] = false;
+ if (li+j < n) {
+ board[li+j][co+j] = false;
}
}
}
// Calcule le nombre de solutions au problème des <N> reines
-void nb_sol(int n, bool board_ini[n][n], int co, int *ptr_cpt) {
- for (int li = 0; li < n; li++) {
- if (board_ini[li][co]) {
- if (co < n - 1) {
+void nb_sol(int n, bool board_in[n][n], int co, int *ptr_cpt) {
+ for (int li=0;li<n;li++) {
+ if (board_in[li][co]) {
+ if (co < n-1) {
bool board[n][n];
- prises_devant(n, board_ini, board, li, co);
- nb_sol(n, board, co + 1, ptr_cpt);
+ prises_devant(n, board_in, board, li, co);
+ nb_sol(n, board, co+1, ptr_cpt);
} else {
- *ptr_cpt = (*ptr_cpt) + 1;
+ *ptr_cpt = (*ptr_cpt)+1;
}
}
}
@@ -56,7 +56,7 @@ void main() {
int n = 8;
// échiquier où placer les reines
bool board[n][n];
- board_ini(n, board, true);
+ board_init(n, board, true);
// compteur du nombre de solutions au problème des <N> reines
int cpt = 0;
nb_sol(n, board, 0, &cpt);
diff --git a/source_codes/recursivity/rec_reines_no_alloc_skel.c b/source_codes/recursivity/rec_reines_no_alloc_skel.c
new file mode 100644
index 0000000000000000000000000000000000000000..b7d5fa1a90c5248c42074cc91730abfb085706ef
--- /dev/null
+++ b/source_codes/recursivity/rec_reines_no_alloc_skel.c
@@ -0,0 +1,50 @@
+// Problème des N-reines
+#include <stdbool.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+void board_init(int n, bool board[n][n], bool val) {
+ //à compléter
+}
+// Copie les valeurs de la <board_in> dans <board>
+void copy(int n, bool board_in[n][n], bool board[n][n]) {
+ //à compléter
+}
+
+// Retourne une copie du tableau <board> complété avec les positions
+// prises sur la droite droite par une reine placée en <board(li,co)>
+void prises_devant(int n, bool board_in[n][n], bool board[n][n],
+ int li, int co) {
+ copy(n, board_in, board);
+ board[li][co] = false; // position de la reine
+ for (int j=1;j<n-co;j++) {
+ // horizontale et diagonales à droite de la reine:
+ // à compléter
+ }
+}
+
+// Calcule le nombre de solutions au problème des <N> reines
+void nb_sol(int n, bool board_in[n][n], int co, int *ptr_cpt) {
+ for (int li=0;li<n;li++) {
+ if (board_in[li][co]) {
+ if (co < n-1) {
+ bool board[n][n];
+ prises_devant(n, board_ini, board, li, co);
+ nb_sol(n, board, co+1, ptr_cpt);
+ } else {
+ *ptr_cpt = (*ptr_cpt)+1;
+ }
+ }
+ }
+}
+
+void main() {
+ int n = 8;
+ // échiquier où placer les reines
+ bool board[n][n];
+ board_init(n, board, true);
+ // compteur du nombre de solutions au problème des <N> reines
+ int cpt = 0;
+ nb_sol(n, board, 0, &cpt);
+ printf("Nombre de solutions: %d\n", cpt);
+}
diff --git a/source_codes/sorted_lists/sorted_list_full.c b/source_codes/sorted_lists/sorted_list_full.c
new file mode 100644
index 0000000000000000000000000000000000000000..758000f9e1cb3f875ed4c688fdf040c463339d5f
--- /dev/null
+++ b/source_codes/sorted_lists/sorted_list_full.c
@@ -0,0 +1,110 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <assert.h>
+#include <stdbool.h>
+
+typedef struct _element {
+ int n;
+ struct _element* suivant;
+} element;
+typedef element* liste;
+
+// Crée une liste vide
+liste liste_creer() {
+ return NULL;
+}
+
+// Teste si la liste vide
+bool liste_est_vide(liste lst) {
+ return NULL == lst;
+}
+
+// Retourne un pointeur sur l'élement avant l'emplacement d'insertion;
+// ce pointeur est nul si la liste est vide ou si l'insertion est en tête de liste
+element* position(liste lst,int val) {
+ element* pos = lst;
+ if (liste_est_vide(lst) || val <= lst->n) {
+ pos = NULL;
+ } else {
+ while (NULL != pos->suivant && val > pos->suivant->n) {
+ pos = pos->suivant;
+ }
+ }
+ return pos;
+}
+
+// Insère un élément dans la liste triée et retourne la liste mise à jour
+liste liste_inserer(liste lst,int val) {
+ element* tmp = malloc(sizeof(element));
+ tmp->n = val;
+ element* crt = position(lst,val);
+ if (NULL == crt) { // insertion dans une liste vide ou en tête de liste
+ tmp->suivant = lst;
+ lst = tmp;
+ } else { // insertion au milieu ou en fin de liste
+ tmp->suivant = crt->suivant;
+ crt->suivant = tmp;
+ }
+ return lst;
+}
+
+// Extrait un élément avec la valeur <val> et retourne la liste mise à jour;
+// la liste est inchangée si elle est initialement vide
+// ou si la valeur est absente
+liste liste_extraire(liste lst,int val) {
+ element *crt = lst, *prec = lst;
+ // boucle pour placer <val>: prec->n < val <= crt->n
+ while (NULL != crt && val > crt->n) {
+ prec = crt;
+ crt = crt->suivant;
+ }
+ // liste non-vide et <val> présente de la liste
+ if (NULL != crt && val == crt->n) {
+ if (crt == prec) { // extraction en début de liste
+ lst = lst->suivant;
+ } else { // extraction en milieu ou fin de liste
+ prec->suivant = crt->suivant;
+ }
+ free(crt);
+ }
+ return lst;
+}
+
+// Retourne un pointeur sur l'élément qui contient <val> ou un pointeur nul
+// si la liste est vide ou la valeur absente
+element* liste_recherche(liste lst,int val) {
+ // à compléter
+ return NULL;
+}
+
+// Imprime le contenu de la liste
+void print(liste lst) {
+ element* crt = lst;
+ while (NULL != crt) {
+ printf("%d ",crt->n);
+ crt = crt->suivant;
+ }
+}
+
+int main(int argc, char** argv) {
+ liste lst = liste_creer();
+ char str[20];
+ do {
+ printf("Insert: ");
+ scanf("%s", str);
+ if (0 == strcmp("quit",str)) break;
+ lst = liste_inserer(lst,atoi(str));
+ print(lst);
+ printf("\n");
+ } while (true);
+ do {
+ printf("Extract: ");
+ scanf("%s", str);
+ if (0 == strcmp("quit",str)) break;
+ lst = liste_extraire(lst,atoi(str));
+ print(lst);
+ printf("\n");
+ } while (true);
+ return 0;
+}
+
diff --git a/source_codes/sorted_lists/sorted_list_partiel.c b/source_codes/sorted_lists/sorted_list_partiel.c
new file mode 100644
index 0000000000000000000000000000000000000000..773e80f39c19b6113d77280769456eb3868bf6ff
--- /dev/null
+++ b/source_codes/sorted_lists/sorted_list_partiel.c
@@ -0,0 +1,103 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <assert.h>
+#include <stdbool.h>
+
+typedef struct _element {
+ int n;
+ struct _element* suivant;
+} element;
+typedef element* liste;
+
+// Crée une liste vide
+liste liste_creer() {
+ return NULL;
+}
+
+// Teste si la liste vide
+bool liste_est_vide(liste lst) {
+ return NULL == lst;
+}
+
+// Retourne un pointeur sur l'élement avant l'emplacement d'insertion;
+// ce pointeur est nul si la liste est vide ou si l'insertion est en tête de liste
+element* position(liste lst,int val) {
+ element* pos = lst;
+ if (liste_est_vide(lst) || val <= lst->n) {
+ pos = NULL;
+ } else {
+ while (NULL != pos->suivant && val > pos->suivant->n) {
+ pos = pos->suivant;
+ }
+ }
+ return pos;
+}
+
+// Insère un élément dans la liste triée et retourne la liste mise à jour
+liste liste_inserer(liste lst,int val) {
+ element* tmp = malloc(sizeof(element));
+ tmp->n = val;
+ element* pos = position(lst,val);
+ if (NULL == pos) { // insertion dans une liste vide ou en tête de liste
+ // à compléter
+ } else { // insertion au milieu ou en fin de liste
+ // à compléter
+ }
+ return lst;
+}
+
+// Extrait un élément avec la valeur <val> et retourne la liste mise à jour;
+// la liste est inchangée si elle est initialement vide
+// ou si la valeur est absente
+liste liste_extraire(liste lst,int val) {
+ element* prec = lst;
+ element* crt = lst;
+ // boucle pour placer <val>: prec->n < val <= crt->n
+ // à compléter
+
+ // liste non-vide et <val> présente de la liste
+ if (NULL != crt && val == crt->n) {
+ if (crt == prec) { // extraction en début de liste
+ lst = lst->suivant;
+ } else { // extraction en milieu ou fin de liste
+ prec->suivant = crt->suivant;
+ }
+ free(crt);
+ }
+ return lst;
+}
+
+// Retourne un pointeur sur l'élément qui contient <val> ou un pointeur nul
+// si la liste est vide ou la valeur absente
+element* liste_recherche(liste lst,int val) {
+ // à compléter
+ return NULL;
+}
+
+// Imprime le contenu de la liste
+void print(liste lst) {
+ //à compléter
+}
+
+int main(int argc, char** argv) {
+ liste lst = liste_creer();
+ char str[20];
+ do {
+ printf("Insert: ");
+ scanf("%s", str);
+ if (0 == strcmp("quit",str)) break;
+ lst = liste_inserer(lst,atoi(str));
+ print(lst);
+ printf("\n");
+ } while (true);
+ do {
+ printf("Extract: ");
+ scanf("%s", str);
+ if (0 == strcmp("quit",str)) break;
+ lst = liste_extraire(lst,atoi(str));
+ print(lst);
+ printf("\n");
+ } while (true);
+ return 0;
+}
+
diff --git a/source_codes/sorting/Makefile b/source_codes/sorting/Makefile
index 36389c6b0a77faf226d0f2bb6d08b8329950b35c..0ff2c06b38756c6257190905e47bd88ba96cce3f 100644
--- a/source_codes/sorting/Makefile
+++ b/source_codes/sorting/Makefile
@@ -1,36 +1,9 @@
-CC:=gcc
-# SAN:=-fsanitize=address
-CFLAGS:=-Wall -Wextra -pedantic -g $(SAN)
-LDFLAGS:=-lm $(SAN)
+TOPTARGETS := all clean
-all: tris_base_part tris_base quicksort heapsort_main quicksort_part
+SUBDIRS := $(wildcard */.)
-tris_base_part: tris_base_part.c
- $(CC) $(CFLAGS) -o $@ $< $(LDFLAGS)
- @echo $@ >> .gitignore
-
-tris_base: tris_base.c
- $(CC) $(CFLAGS) -o $@ $< $(LDFLAGS)
- @echo $@ >> .gitignore
-
-quicksort: quicksort.c
- $(CC) $(CFLAGS) -o $@ $< $(LDFLAGS)
- @echo $@ >> .gitignore
-
-quicksort_part: quicksort_part.c
- $(CC) $(CFLAGS) -o $@ $< $(LDFLAGS)
- @echo $@ >> .gitignore
-
-heapsort_main: heapsort_main.c heapsort.o
- $(CC) $(CFLAGS) -o $@ $^ $(LDFLAGS)
- @echo $@ >> .gitignore
- @echo *.o >> .gitignore
-
-
-heapsort.o: heapsort.h
-
-.PHONY: clean all
-
-clean:
- rm -f *.o tris_base tris_base_part quicksort_part quicksort heapsort_main .gitignore
+$(TOPTARGETS): $(SUBDIRS)
+$(SUBDIRS):
+ $(MAKE) -C $@ $(MAKECMDGOALS)
+.PHONY: $(TOPTARGETS) $(SUBDIRS)
diff --git a/source_codes/sorting/heapsort/Makefile b/source_codes/sorting/heapsort/Makefile
new file mode 100644
index 0000000000000000000000000000000000000000..2dc0918a8e55a128537cd82f6d554379ab0bfbf4
--- /dev/null
+++ b/source_codes/sorting/heapsort/Makefile
@@ -0,0 +1,19 @@
+CC:=gcc
+# SAN:=-fsanitize=address
+CFLAGS:=-Wall -Wextra -pedantic -g $(SAN)
+LDFLAGS:=-lm $(SAN)
+
+all: heapsort_main
+
+heapsort_main: heapsort_main.c heapsort.o
+ $(CC) $(CFLAGS) -o $@ $^ $(LDFLAGS)
+ @echo $@ >> .gitignore
+ @echo *.o >> .gitignore
+
+heapsort.o: heapsort.h
+
+.PHONY: clean all
+
+clean:
+ rm -f *.o heapsort_main .gitignore
+
diff --git a/source_codes/sorting/heapsort.c b/source_codes/sorting/heapsort/heapsort.c
similarity index 87%
rename from source_codes/sorting/heapsort.c
rename to source_codes/sorting/heapsort/heapsort.c
index d65e5677ec7767901d25a6701831907f1a870a9b..6531cddef9a43cc65601312ac6ee5c38d942d3ff 100644
--- a/source_codes/sorting/heapsort.c
+++ b/source_codes/sorting/heapsort/heapsort.c
@@ -8,13 +8,6 @@ static void swap(int* a,int* b) {
*b = tmp;
}
-static void print(int* tab,int size,char* str) {
- for (int i=0;i<size;i++) {
- printf("%d ",tab[i]);
- }
- printf("%s",str);
-}
-
void heapsort(int* tab,int size) {
entassement(tab,size);
swap(tab,tab+size-1);
diff --git a/source_codes/sorting/heapsort.h b/source_codes/sorting/heapsort/heapsort.h
similarity index 100%
rename from source_codes/sorting/heapsort.h
rename to source_codes/sorting/heapsort/heapsort.h
diff --git a/source_codes/sorting/heapsort_main.c b/source_codes/sorting/heapsort/heapsort_main.c
similarity index 89%
rename from source_codes/sorting/heapsort_main.c
rename to source_codes/sorting/heapsort/heapsort_main.c
index a1b8cfcc9eb5a677e72c5533c41b3432a398a1ca..1bf83bc47887ddfa010b8b7fecf2b94d01005ed6 100644
--- a/source_codes/sorting/heapsort_main.c
+++ b/source_codes/sorting/heapsort/heapsort_main.c
@@ -11,10 +11,10 @@ int main(int argc, char** argv) {
int size = 10, inf = 0, delta = 20;
switch(argc) {
case 4: delta = atoi(argv[3]);
- case 3: inf = atoi(argv[2]);
+ case 3: inf = atoi(argv[2]);
case 2: size = atoi(argv[1]);
}
- int* tab = (int*)malloc(size*sizeof(int));
+ int* tab = malloc(size*sizeof(int));
rand_init(tab,size,inf,delta);
print(tab,size,"\n=========\n");
heapsort(tab,size);
diff --git a/source_codes/sorting/heapsort_part.c b/source_codes/sorting/heapsort/heapsort_part.c
similarity index 100%
rename from source_codes/sorting/heapsort_part.c
rename to source_codes/sorting/heapsort/heapsort_part.c
diff --git a/source_codes/sorting/quicksort.c b/source_codes/sorting/quicksort.c
deleted file mode 100644
index 95943c50c149c2b9d43aa907b3f3ba186a3d7b97..0000000000000000000000000000000000000000
--- a/source_codes/sorting/quicksort.c
+++ /dev/null
@@ -1,70 +0,0 @@
-#include <stdio.h>
-#include <stdlib.h>
-#include <stdbool.h>
-#include <assert.h>
-
-void print(int size,int tab[size]) {
- for (int i=0;i<size;i++) printf("%d ",tab[i]);
-}
-
-void random_tab(int size,int tab[size],int inf,int sup) {
- assert(sup > inf);
- for (int i=0;i<size;i++) tab[i] = inf+rand()%(sup-inf);
-}
-
-void swap(int* p_a,int* p_b) {
- int tmp = *p_a;
- *p_a = *p_b;
- *p_b = tmp;
-}
-
-int partition(int size,int array[size],int first,int last) {
- int pivot = array[last];
- int i = first-1,j = last;
- while (true) {
- do {
- i++;
- } while (array[i] < pivot && i<j);
- do {
- j--;
- } while(array[j] > pivot && i<j);
- if (i >= j) break;
- swap(&array[i],&array[j]);
- }
- swap(&array[i],&array[last]);
- return i;
-}
-
-void quicksort(int size,int array[size],int first,int last) {
- if (first < last) {
- int midpoint = partition(size,array,first,last);
- if (first < midpoint-1) quicksort(size,array,first,midpoint-1);
- if (midpoint+1 < last) quicksort(size,array,midpoint+1,last);
- }
-}
-
-void test_ordre(int size,int array[size]) {
- for (int i=0;i<size-1;i++)
- if (array[i] > array[i+1]) {
- printf("erreur");
- return;
- }
- printf("ok");
-}
-
-int main(int argc,char** argv) {
- int size = atoi(argv[1]);
- int seed = atoi(argv[2]);
- srand(seed);
- int* res = (int*)malloc(size*sizeof(int));
- for (int k=0;k<20;k++) {
- random_tab(size,res,0,100);
- print(size,res);
- printf("\n");
- quicksort(size,res,0,size-1);
- print(size,res);
- test_ordre(size,res);
- printf("\n================\n");
- }
-}
-
diff --git a/source_codes/sorting/quicksort_part.c b/source_codes/sorting/quicksort_part.c
deleted file mode 100644
index d7e0868f77a1ed059e01ad1099938e1c89693fee..0000000000000000000000000000000000000000
--- a/source_codes/sorting/quicksort_part.c
+++ /dev/null
@@ -1,99 +0,0 @@
-#include <stdio.h>
-#include <stdlib.h>
-#include <stdbool.h>
-#include <assert.h>
-
-void print(int size,int tab[size]) {
- for (int i=0;i<size;i++) {
- printf("%d ",tab[i]);
- }
-}
-
-void random_tab(int size,int tab[size],int inf,int sup) {
- assert(sup > inf);
- for (int i=0;i<size;i++) {
- tab[i] = inf+rand()%(sup-inf);
- }
-}
-
-void swap(int* p_a,int* p_b) {
- int tmp = *p_a;
- *p_a = *p_b;
- *p_b = tmp;
-}
-
-// Partition du tableau <array> autour d'une valeur pivot:
-// compléter le code
-int partition(int size,int array[size],int first,int last) {
- int pivot = array[last];
- int i = first-1,j = last;
- while (true) {
- // à compléter pour <i>: do {...} while (...);
- // à compléter pour <j>: do {...} while (...);
- if (i >= j) {
- break;
- }
- // à compléter: échanger cases <i> et <j> du tableau <array>
- }
- // à compléter: échanger cases <i> et <last> du tableau <array>
- return i;
-}
-
-// Tri rapide récursif
-void quicksort(int size,int array[size],int first,int last) {
- if (first < last) {
- int midpoint = partition(size,array,first,last);
- if (first < midpoint-1) {
- quicksort(size,array,first,midpoint-1);
- }
- if (midpoint+1 < last) {
- quicksort(size,array,midpoint+1,last);
- }
- }
-}
-
-// Test si le tableau <array> est ordonné croissant
-void test_ordre(int size,int array[size]) {
- for (int i=0;i<size-1;i++) {
- if (array[i] > array[i+1]) {
- printf("erreur");
- return;
- }
- }
- printf("ok");
-}
-
-int main(int argc,char** argv) {
- int size = atoi(argv[1]);
- int seed = atoi(argv[2]);
- srand(seed);
- int* res = (int*)malloc(size*sizeof(int));
- for (int k=0;k<20;k++) {
- random_tab(size,res,0,100);
- print(size,res);
- printf("\n");
- quicksort(size,res,0,size-1);
- print(size,res);
- test_ordre(size,res);
- printf("\n================\n");
- }
-}
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
diff --git a/source_codes/sorting/tri_2_piles/Makefile b/source_codes/sorting/tri_2_piles/Makefile
new file mode 100644
index 0000000000000000000000000000000000000000..f4e072c2dcc0212a0222da8c716facf9a05f1ae1
--- /dev/null
+++ b/source_codes/sorting/tri_2_piles/Makefile
@@ -0,0 +1,24 @@
+CC:=gcc
+# SAN:=-fsanitize=address
+CFLAGS:=-Wall -Wextra -pedantic -g $(SAN)
+LDFLAGS:=-lm $(SAN)
+
+all: tri_2_piles
+
+tri_2_piles: tri_2_piles.o pile_ptr.o
+ $(CC) -D TYPE=int $(CFLAGS) -o $@ $^ $(LDFLAGS)
+ @echo $@ >> .gitignore
+
+tri_2_piles.o: tri_2_piles.c
+ $(CC) -c -D TYPE=int $(CFLAGS) $^ $(LDFLAGS)
+ @echo *.o >> .gitignore
+
+pile_ptr.o: pile_ptr.c pile_ptr.h
+ $(CC) -c -D TYPE=int $(CFLAGS) $^ $(LDFLAGS)
+ @echo *.o >> .gitignore
+
+.PHONY: clean all
+
+clean:
+ rm -f *.o *.gch tri_2_piles .gitignore
+
diff --git a/source_codes/sorting/tri_2_piles/pile_ptr.c b/source_codes/sorting/tri_2_piles/pile_ptr.c
new file mode 100644
index 0000000000000000000000000000000000000000..d9cf8a0c05cba93984e9a4e56156e9d55a4572c7
--- /dev/null
+++ b/source_codes/sorting/tri_2_piles/pile_ptr.c
@@ -0,0 +1,60 @@
+#include <stdlib.h>
+#include <stdio.h>
+#include <stdbool.h>
+#include <assert.h>
+#include "pile_ptr.h"
+
+
+//Creer une nouvelle pile vide
+pile pile_creer() {
+ return NULL;
+}
+
+//Tester si la pile est vide
+bool pile_est_vide(pile stack) {
+ return (NULL == stack);
+}
+
+//Inserer un élement en début de pile
+void pile_empiler(pile* stack,info val) {
+ element* elmt = malloc(sizeof(element));
+ elmt->data = val;
+ elmt->next = *stack;
+ *stack = elmt;
+}
+
+//Consulter l'élément au sommet de la pile
+info pile_sommet(pile stack) {
+ assert(!pile_est_vide(stack));
+ return stack->data;
+}
+
+//Supprimer un élément de la pile
+info pile_depiler(pile* stack) {
+ info data = pile_sommet(*stack);
+ element* elmt = *stack;
+ *stack = (*stack)->next;
+ free(elmt);
+ return data;
+}
+
+//Désallouer complètement la pile
+void pile_detruire(pile* stack) {
+ while (!pile_est_vide(*stack)) {
+ pile_depiler(stack);
+ }
+}
+
+//Compter le nombre d'éléments de la pile:
+int pile_count(pile stack) {
+ int cnt = 0;
+ while (NULL != stack) {
+ stack = stack->next;
+ cnt++;
+ }
+ return cnt;
+}
+
+
+
+
diff --git a/source_codes/sorting/tri_2_piles/pile_ptr.h b/source_codes/sorting/tri_2_piles/pile_ptr.h
new file mode 100644
index 0000000000000000000000000000000000000000..507001ee84b7dee2375553f6644e3ebd67eb86ca
--- /dev/null
+++ b/source_codes/sorting/tri_2_piles/pile_ptr.h
@@ -0,0 +1,32 @@
+/* pour éviter que le précompilateur
+ inclue plusieurs fois le fichier .h */
+#ifndef PILE_PTR_H
+#define PILE_PTR_H
+#include <stdbool.h>
+/* Définir à la compilation de TYPE
+ p.ex. gcc -c -D TYPE=int pile_ptr.h pile_ptr.c */
+typedef TYPE info;
+/* Utilité du typedef :
+ Element a; <=> struct Element a; */
+typedef struct _element {
+ info data;
+ struct _element* next;
+} element;
+typedef element* pile;
+
+//Créer d'une nouvelle pile vide
+pile pile_creer();
+//Désallouer complètement la pile
+void pile_detruire(pile* stack);
+//Empiler un élement en début de pile
+void pile_empiler(pile* stack,info val);
+//Dépiler un élément de la pile
+info pile_depiler(pile* stack);
+//Consulter l'élément au sommet de la pile
+info pile_sommet(pile stack);
+//Tester si la pile est vide
+bool pile_est_vide(pile stack);
+//Compter le nombre d'éléments de la pile:
+int pile_count(pile stack);
+#endif
+
diff --git a/source_codes/sorting/tri_2_piles/tri_2_piles.c b/source_codes/sorting/tri_2_piles/tri_2_piles.c
new file mode 100644
index 0000000000000000000000000000000000000000..ca7fbb61edc54c8b36968167e98f08aa46c35d99
--- /dev/null
+++ b/source_codes/sorting/tri_2_piles/tri_2_piles.c
@@ -0,0 +1,87 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdbool.h>
+#include <string.h>
+#include "pile_ptr.h"
+
+void print(int size,int tab[size]);
+void random_tab(int size,int tab[size],int inf,int sup);
+void test_ordre(int size,int array[size]);
+
+void tri_2_pile(int size,int tab[size]);
+
+int main(int argc,char** argv) {
+ if (2 != argc) {
+ return 1;
+ }
+ int size = atoi(argv[1]);
+ int seed = atoi(argv[2]);
+ srand(seed);
+ int* res = malloc(size*sizeof(int));
+ for (int k=0;k<20;k++) {
+ random_tab(size,res,0,100);
+ print(size,res);
+ printf("\n");
+ tri_2_pile(size,res);
+ print(size,res);
+ test_ordre(size,res);
+ printf("\n================\n");
+ }
+ return 0;
+}
+
+bool condition(int a,int b,char* op) {
+ if (strcmp(op,"<") == 0) {
+ return a < b;
+ } else if (strcmp(op,">=") == 0) {
+ return a >= b;
+ } else if (strcmp(op,"") == 0) {
+ return true;
+ } else {
+ return false;
+ }
+}
+
+void transfert(pile* pile_g,pile* pile_d,int val,char* op) {
+ while (!pile_est_vide(*pile_g)
+ && condition(pile_sommet(*pile_g),val,op)) {
+ pile_empiler(pile_d,pile_depiler(pile_g));
+ }
+}
+
+void tri_2_pile(int size,int tab[size]) {
+ pile pile_g = pile_creer(), pile_d = pile_creer();
+ for (int i=0;i<size;i++) {
+ transfert(&pile_g,&pile_d,tab[i],"<");
+ transfert(&pile_d,&pile_g,tab[i],">=");
+ pile_empiler(&pile_g,tab[i]);
+ }
+ transfert(&pile_d,&pile_g,0,"");
+ for (int i=0;i<size;i++) {
+ tab[i] = pile_depiler(&pile_g);
+ }
+}
+
+void print(int size,int tab[size]) {
+ for (int i=0;i<size;i++) {
+ printf("%d ",tab[i]);
+ }
+}
+
+void random_tab(int size,int tab[size],int inf,int sup) {
+ for (int i=0;i<size;i++) {
+ tab[i] = inf+rand()%(sup-inf);
+ }
+}
+
+void test_ordre(int size,int array[size]) {
+ for (int i=0;i<size-1;i++) {
+ if (array[i] > array[i+1]) {
+ printf("erreur");
+ return;
+ }
+ }
+ printf("ok");
+}
+
+
diff --git a/source_codes/sorting/tris_basiques/Makefile b/source_codes/sorting/tris_basiques/Makefile
new file mode 100644
index 0000000000000000000000000000000000000000..9a2645067476925d5b01d7b5015ac58f078f8306
--- /dev/null
+++ b/source_codes/sorting/tris_basiques/Makefile
@@ -0,0 +1,20 @@
+CC:=gcc
+# SAN:=-fsanitize=address
+CFLAGS:=-Wall -Wextra -pedantic -g $(SAN)
+LDFLAGS:=-lm $(SAN)
+
+all: tris_base_part tris_base
+
+tris_base_part: tris_base_part.c
+ $(CC) $(CFLAGS) -o $@ $< $(LDFLAGS)
+ @echo $@ >> .gitignore
+
+tris_base: tris_base.c
+ $(CC) $(CFLAGS) -o $@ $< $(LDFLAGS)
+ @echo $@ >> .gitignore
+
+.PHONY: clean all
+
+clean:
+ rm -f *.o tris_base tris_base_part .gitignore
+
diff --git a/source_codes/sorting/tris_base.c b/source_codes/sorting/tris_basiques/tris_base.c
similarity index 97%
rename from source_codes/sorting/tris_base.c
rename to source_codes/sorting/tris_basiques/tris_base.c
index dfbd099cc12698438b800a1d5c01582b2aa90591..a47259ce1dab832935c86d8cfac8b6b1e8b2f030 100644
--- a/source_codes/sorting/tris_base.c
+++ b/source_codes/sorting/tris_basiques/tris_base.c
@@ -7,7 +7,7 @@ void tri_insertion(int size,int tab[size]);
void tri_bulle(int size,int tab[size]);
void tri_selection(int size,int tab[size]);
-void main(int argc,char** argv) {
+int main(int argc,char** argv) {
if (argc != 4) {
printf("usage: program <size> <seed> <sorting_algo_number>\n");
exit(EXIT_FAILURE);
@@ -19,7 +19,6 @@ void main(int argc,char** argv) {
int res[size];
random_tab(size,res);
print(size,res);
- printf("\n");
switch(choix) {
case 1: tri_bulle(size,res); break;
case 2: tri_selection(size,res); break;
@@ -27,13 +26,14 @@ void main(int argc,char** argv) {
default: printf("Choix non available\n");
}
print(size,res);
- printf("\n");
+ return 0;
}
void print(int size,int tab[size]) {
for (int i=0;i<size;i++) {
printf("%d ",tab[i]);
}
+ printf("\n");
}
void random_tab(int size,int tab[size]) {
diff --git a/source_codes/sorting/tris_base_part.c b/source_codes/sorting/tris_basiques/tris_base_part.c
similarity index 99%
rename from source_codes/sorting/tris_base_part.c
rename to source_codes/sorting/tris_basiques/tris_base_part.c
index f41a20e0e43fc8db5bf697160b28ee80c2f4b6b7..09ac5bdd37e63941366b30063e48294e076ce6af 100644
--- a/source_codes/sorting/tris_base_part.c
+++ b/source_codes/sorting/tris_basiques/tris_base_part.c
@@ -23,7 +23,6 @@ int main(int argc,char** argv) {
int res[size];
random_tab(size,res);
print(size,res);
- printf("\n");
switch(choix) {
case 1: tri_bulle(size,res); break;
case 2: tri_selection(size,res); break;
@@ -31,7 +30,6 @@ int main(int argc,char** argv) {
default: printf("Choix non available\n");
}
print(size,res);
- printf("\n");
return EXIT_SUCCESS;
}
@@ -102,6 +100,7 @@ void print(int size,int tab[size]) {
for (int i=0;i<size;i++) {
printf("%d ",tab[i]);
}
+ printf("\n");
}
void random_tab(int size,int tab[size]) {