sorted list added <> OK

include/util.h

@@ -49,28 +49,38 @@ char *util_read_file (char *filename);
 // de même que sont interdits: cracks, warez, sérials (sauf évaluation), etc.
 // Est bien sûr autorisé tout ce qui concerne les logiciels gratuits, freewares et évaluation.
 
-typedef struct pile {int valeur; struct pile *prec;} pile; // structure d'un élément
+typedef struct pile {int value; struct pile *prev;} pile; // structure d'un élément
-int  util_pile_push   (pile **, int);   //  empile une valeur sur la pile
+void util_pile_clear  (pile **);        //  vide toute la pile
-int  util_pile_pop    (pile **);  //  retire la dernière valeur empilée
+void util_pile_view   (pile *);         //  affiche la pile en commençant par le sommet
-void util_pile_clear  (pile **);  //  vide la pile
+int  util_pile_push   (pile **, int);   //  ajoute une valeur sur la pile
-int  util_pile_length (pile *p);  //  retourne le nombre d'éléments de la pile
+int  util_pile_pop    (pile **);        //  retire la dernière valeur empilée
-void util_pile_view   (pile *);   //  affiche la pile en commençant par le sommet
+int  util_pile_length (pile *p);        //  renvoie le nombre d'éléments de la pile
 
 //------------------------------------------------------------------------------
 
 typedef struct elem {int value; struct elem *prev; struct elem *next;} elem;
 typedef struct {elem *first; elem *last;} dblist;   //  structure d'accès à la liste
-void util_list_2x2_init (dblist *l);                //  initialisation
+void util_list_2x2_init       (dblist *l);          //  initialisation
-int util_list_2x2_push_back  (dblist *l, int val);  //  ajoute une valeur en fin de liste
+void util_list_2x2_clear      (dblist *l);          //  vide toute la liste
-int util_list_2x2_push_front (dblist *l, int val);  //  ajoute une valeur en début de liste
+void util_list_2x2_view       (dblist l);           //  affiche les valeurs de toute la liste
-int  util_list_2x2_pop_back  (dblist *l);   //  retire une valeur en fin de liste
+int  util_list_2x2_push_back  (dblist *l, int val); //  ajoute une valeur en fin de liste
-int  util_list_2x2_pop_front (dblist *l);   //  retire une valeur en début de liste
+int  util_list_2x2_push_front (dblist *l, int val); //  ajoute une valeur en début de liste
-int  util_list_2x2_length (dblist l);       //  retourne le nombre d'éléments de la liste
+int  util_list_2x2_pop_back   (dblist *l);          //  retire une valeur en fin de liste
-void util_list_2x2_view   (dblist l);       //  affiche les valeurs de toute la liste
+int  util_list_2x2_pop_front  (dblist *l);          //  retire une valeur en début de liste
-void util_list_2x2_clear  (dblist *l);      //  vide toute la liste
+int  util_list_2x2_length     (dblist l);           //  renvoie le nombre d'éléments de la liste
+
+//------------------------------------------------------------------------------
+
+typedef struct slist {int value; struct slist *suiv;} slist ;
+void util_sorted_list_clear  (slist **sl);          //  vide toute la liste
+void util_sorted_list_view   (slist *sl);           //  affiche toute la liste
+int  util_sorted_list_insert (slist **sl, int val); //  insertion d'un élément selon son rang
+int  util_sorted_list_pop    (slist **sl);          //  retire la dernière valeur de la liste
+int  util_sorted_list_length (slist *sl);           //  renvoie le nombre d'éléments de la liste
 
 //------------------------------------------------------------------------------
 
 void util_pile_test();
 void util_double_list_test();
+void util_sorted_list_test();
 

src/fsm/measure.c

@@ -103,6 +103,7 @@ void fsm_add_measure (char *measure_name) {fsm_debug_msg (2, 0, measure_name, 2)
 void fsm_measures_list_init ()
 {
     fsm_debug_msg (0,0, "fsm_measures_list_init()", 2);  //  sub_automaton 2
-    if (1) util_pile_test();
+    if (0) util_pile_test();
     if (0) util_double_list_test();
+    util_sorted_list_test();
 }

src/util/list_2x2.c

@@ -117,7 +117,7 @@ int util_list_2x2_length (dblist l)
 
 void util_list_2x2_view (dblist l)
 {
-    printf ("view liste  (n = %d)\n", util_list_2x2_length (l));
+    printf ("--------   view liste  (n = %d)\n", util_list_2x2_length (l));
     elem *pelem = l.first;
     while (pelem)
     {

src/util/pile.c

@@ -35,8 +35,8 @@ int util_pile_push (pile **p, int Val)
 {
     pile *element = malloc (sizeof(pile));
     if (!element) exit (EXIT_FAILURE);     // Si l'allocation a échoué.
-    element->valeur = Val;
+    element->value = Val;
-    element->prec = *p;
+    element->prev = *p;
     *p = element;       // Le pointeur pointe sur le dernier élément.
     return Val;
 }
@@ -46,11 +46,11 @@ int util_pile_pop (pile **p)
     int Val;
     pile *tmp;
     if (!*p) return -1;     // Retourne -1 si la pile est vide.
-    tmp = (*p)->prec;
+    tmp = (*p)->prev;
-    Val = (*p)->valeur;
+    Val = (*p)->value;
     free (*p);
     *p = tmp;       // Le pointeur pointe sur le dernier élément.
-    return Val;     // Retourne la valeur soutirée de la pile.
+    return Val;     // Retourne la value soutirée de la pile.
 }
 
 
@@ -59,7 +59,7 @@ void util_pile_clear (pile **p)
     pile *tmp;
     while (*p)
     {
-        tmp = (*p)->prec;
+        tmp = (*p)->prev;
         free (*p);
         *p = tmp;
     }
@@ -71,18 +71,18 @@ int util_pile_length (pile *p)
     while (p)
     {
         n++;
-        p = p->prec;
+        p = p->prev;
     }
     return n;
 }
 
 void util_pile_view (pile *p)
 {
-    printf ("view pile  (n = %d)\n", util_pile_length (p));
+    printf ("------  view pile  (n = %d)\n", util_pile_length (p));
     while (p)
     {
-        printf ("%d\n", p->valeur);
+        printf ("%d\n", p->value);
-        p = p->prec;
+        p = p->prev;
     }
     puts ("------");
 }

src/util/sorted_list.c

@@ -0,0 +1,97 @@
+/*  *  *  *  *  *  *  *  *  *  *  *  *  *  *  *  *  *  *  *  *  *  *  *  *  *  *
+*                                                                              *
+*                             Gem-graph client                                 *
+*                                                                              *
+*                      Finite State Machine (fsm) header                       *
+*                                                                              *
+*         Copyright © 2021 Libre en Communs <contact@a-lec.org>                *
+*         Copyright © 2021 Adrien Bourmault <neox@a-lec.org>                   *
+*         Copyright © 2021 Jean Sirmai <jean@a-lec.org>                        *
+*                                                                              *
+*                        This file is part of Gem-graph.                       *
+*                                                                              *
+*   This program is free software: you can redistribute it and/or modify it    *
+*         under the terms of the GNU Affero General Public License             *
+*                as published by the Free Software Foundation,                 *
+*                       either version 3 of the License,                       *
+*                    or (at your option) any later version.                    *
+*                                                                              *
+*       This program is distributed in the hope that it will be useful,        *
+*                         but WITHOUT ANY WARRANTY;                            *
+*            without even the implied warranty of MERCHANTABILITY              *
+*                    or FITNESS FOR A PARTICULAR PURPOSE.                      *
+*         See the GNU Affero General Public License for more details.          *
+*                                                                              *
+*   You should have received a copy of the GNU Affero General Public License   *
+*     along with this program.  If not, see <http://www.gnu.org/licenses/>.    *
+*                                                                              *
+*  *  *  *  *  *  *  *  *  *  *  *  *  *  *  *  *  *  *  *  *  *  *  *  *  *  */
+
+
+#include "../../include/util.h"
+
+
+void util_sorted_list_clear  (slist **sl)
+{
+    slist *tmp;
+    while (*sl)
+    {
+        tmp = (*sl)->suiv;
+        free (*sl);
+        *sl = tmp;
+    }
+}
+
+void util_sorted_list_view   (slist *sl)
+{
+    printf ("--------   view liste  (n = %d)\n", util_sorted_list_length (sl));
+    while(sl)
+    {
+        printf("%d\n",sl->value);
+        sl = sl->suiv;
+    }
+    puts ("--------------");
+}
+
+int  util_sorted_list_insert (slist **sl, int value)
+{
+    slist *tmp = NULL;
+    slist *csl = *sl;
+    slist *elem = malloc (sizeof (slist));
+    if (!elem) exit (EXIT_FAILURE);
+    elem->value = value;
+    while (csl && csl->value < value)
+    {
+        tmp = csl;
+        csl = csl->suiv;
+    }
+    elem->suiv = csl;
+    if(tmp) tmp->suiv = elem;
+    else *sl = elem;
+    return 0;
+}
+
+int  util_sorted_list_pop    (slist **sl)
+{
+    int value;
+    slist *tmp;
+    if (! *sl) return -1;
+    tmp = (*sl)->suiv;
+    value = (*sl)->value;
+    printf("value = %d  <>  pb with free(sl)  in pop()\n", (*sl)->value);
+    free (*sl);
+    *sl = tmp;
+    return value;
+}
+
+int  util_sorted_list_length (slist *sl)
+{
+    int n = 0;
+    while (sl)
+    {
+        n++;
+        sl = sl->suiv;
+    }
+    return n;
+}
+

src/util/tests.c

@@ -46,11 +46,11 @@ void util_pile_test()
     printf ("pop   > %d\n", util_pile_pop (&exemple));
     printf ("pop   > %d\n", util_pile_pop (&exemple));
 
-    util_pile_view(exemple);
+    util_pile_view (exemple);
 
     printf ("clear pile\n");  util_pile_clear (&exemple);
 
-    util_pile_view(exemple);
+    util_pile_view (exemple);
 }
 
 void util_double_list_test()
@@ -78,7 +78,44 @@ void util_double_list_test()
 
     util_list_2x2_view (exemple);
 
-    printf ("clear all\n");      util_list_2x2_clear (&exemple);
+    printf ("clear list\n");     util_list_2x2_clear (&exemple);
 
     util_list_2x2_view (exemple);
 }
+
+void util_sorted_list_test()
+{
+        slist *Mysl = NULL;
+
+        puts("création d'une liste de 9 elements :");
+        util_sorted_list_insert (&Mysl,9);
+        util_sorted_list_insert (&Mysl,8);
+        util_sorted_list_insert (&Mysl,3);
+        util_sorted_list_insert (&Mysl,5);
+        util_sorted_list_insert (&Mysl,1);
+        util_sorted_list_insert (&Mysl,5);
+        util_sorted_list_insert (&Mysl,2);
+        util_sorted_list_insert (&Mysl,0);
+        util_sorted_list_insert (&Mysl,7);
+        util_sorted_list_view (Mysl);
+
+        puts("retrait des 3 premiers elements :");
+        printf("%d\n",util_sorted_list_pop (&Mysl));
+        printf("%d\n",util_sorted_list_pop (&Mysl));
+        printf("%d\n",util_sorted_list_pop (&Mysl));
+        printf("Nb d'elements : %d\n", util_sorted_list_length (Mysl));
+        util_sorted_list_view (Mysl);
+
+        puts("on vide de la liste puis on ajoute 4 elements :");
+        util_sorted_list_clear (&Mysl);
+        util_sorted_list_insert (&Mysl,3);
+        util_sorted_list_insert (&Mysl,1);
+        util_sorted_list_insert (&Mysl,9);
+        util_sorted_list_insert (&Mysl,5);
+        printf("nb d'elements : %d\n", util_sorted_list_length (Mysl));
+        util_sorted_list_view (Mysl);
+
+        util_sorted_list_clear (&Mysl);
+}
+
+