SD jusqua hachage

Vincent Benoist
1 parent 37a5f1f0
Showing 43 changed files with 1065 additions and 0 deletions Show diff stats
TpSD3_Karatsuba/.Karatsuba.c.kate-swp -> SD/TP3_Karatsuba/.Karatsuba.c.kate-swp
TpSD3_Karatsuba/Elementaire.stats -> SD/TP3_Karatsuba/Elementaire.stats
TpSD3_Karatsuba/Karatsuba.c -> SD/TP3_Karatsuba/Karatsuba.c
TpSD3_Karatsuba/Karatsuba.stats -> SD/TP3_Karatsuba/Karatsuba.stats
TpSD3_Karatsuba/a.out -> SD/TP3_Karatsuba/a.out
SD/TP5_ABR/ABR.dot
SD/TP5_ABR/ABR.pdf
SD/TP5_ABR/Makefile
SD/TP5_ABR/a.out
SD/TP5_ABR/abr.c
SD/TP5_ABR/abr.h
SD/TP5_ABR/abr.o
SD/TP5_ABR/arbres correction/abr.c
SD/TP5_ABR/arbres correction/abr.h
SD/TP5_ABR/arbres correction/abr.o
SD/TP5_ABR/arbres correction/main.c
SD/TP5_ABR/arbres correction/main.o
SD/TP5_ABR/arbres correction/prog
SD/TP5_ABR/esperanto/Makefile
SD/TP5_ABR/esperanto/abr.c
@@ -0,0 +1,8 @@
+digraph G {
+14 -> 7 [label="gauche"];
+7 -> 3 [label="gauche"];
+14 -> 88 [label="droit"];
+88 -> 51 [label="gauche"];
+51 -> 17 [label="gauche"];
+51 -> 53 [label="droit"];
+}
@@ -0,0 +1,17 @@
+.PHONY: clean,real-clean
+LD = gcc
+CC = gcc
+CFLAGS = -Wall -W 
+SRC=$(wildcard *.c)
+OBJ=$(SRC:.c=.o)
+prog : $(OBJ)
+	$(LD) -o $@ $^
+
+%.o : %.c
+	$(CC) $(CFLAGS) -c $^	
+
+clean : 
+	rm -f *.o	
+
+real-clean : clean
+	rm -f prog
@@ -0,0 +1,143 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <assert.h>
+#include "abr.h"
+
+
+/*
+    struct abr {
+        struct abr* gauche; 
+        int valeur;
+        struct abr* droit;
+};
+*/
+static struct abr* new_feuille (int x){   
+    
+    struct abr* F;
+
+    F = (struct abr*)malloc (sizeof (struct abr));
+    F->gauche = NIL;
+    F->valeur = x;
+    F->droit = NIL;
+    return F;
+}
+
+
+struct abr* ajout_abr_rec (int x, struct abr* A){
+    if (A == NIL)
+        return new_feuille (x);
+    else if (x < A->valeur)
+        A->gauche = ajout_abr_rec (x, A->gauche);
+    else
+        A->droit = ajout_abr_rec (x, A->droit);
+    return A;
+}
+
+int max( int a, int b){
+ 
+    if(a>b){
+        return a;        
+    }
+    return b;
+}
+
+int hauteur_abr( struct abr* A){
+   
+    if(A == NIL){
+        return -1;
+    }
+    return max(hauteur_abr(A->gauche),hauteur_abr(A->droit))+1;
+    
+}
+
+
+bool recherche_abr_rec (int x, struct abr* A){
+    bool b = false;
+    if (A == NIL){
+        return b;
+    } else if ( x == A->valeur ){
+        return true;
+    } else if (x < A->valeur){
+        b=recherche_abr_rec (x, A->gauche);
+    } else{
+        b=recherche_abr_rec (x, A->droit);
+    }
+    return b;
+}
+
+
+static void affiche_abr (struct abr* A){
+    if( A!= NIL){
+     affiche_abr(A->gauche);
+     printf("- %d ", A-> valeur);
+     affiche_abr(A->droit);
+    }
+
+}
+
+
+void imprime_abr (struct abr* A){
+    printf("Valeurs de l'arbre: \n");
+    affiche_abr(A);
+    printf(" -\n");
+}
+
+
+static void affiche_abrV2 (struct abr* A, int profondeur){
+    if( A!= NIL){
+        int i = 0;
+        for(i=0; i<=profondeur; i++){
+             printf("\t");
+        }
+       
+        printf("%d\n ", A-> valeur);
+        affiche_abrV2(A->droit, profondeur+1);
+        affiche_abrV2(A->gauche, profondeur+1);
+    }
+
+}
+
+void imprime_abrV2 (struct abr* A){
+    printf("Valeurs de l'arbre: \n");
+    affiche_abrV2(A, 0);
+    printf("\n");
+}
+
+void clear_abr (struct abr* A)
+{
+    if (A != NIL)
+    {   clear_abr (A->gauche);
+        clear_abr (A->droit);
+        free (A);
+    }
+}
+
+void imprimeArbreDot( struct abr* A, FILE* f){
+   if(A->gauche != NIL){
+        fprintf(f,"%d -> %d [label=\"gauche\"];\n", A->valeur, A->gauche->valeur);
+        imprimeArbreDot(A->gauche,f);
+   } 
+   if(A->droit != NIL){
+        fprintf(f,"%d -> %d [label=\"droit\"];\n", A->valeur, A->droit->valeur);
+        imprimeArbreDot(A->droit,f);
+   }
+}
+
+
+void imprimeDot( struct abr* A){
+    FILE* f;
+    f = fopen("ABR.dot", "w");
+    fprintf(f,"digraph G {\n");
+    if(A==NIL){
+        fprintf(f,"NIL\n");
+    }else if (A->gauche == NIL && A->droit == NIL){
+        fprintf(f,"%d\n", A->valeur);
+    }else {
+        imprimeArbreDot(A,f);
+    }
+    fprintf(f,"}\n");
+    fclose(f);
+    system("dot -Tpdf ABR.dot -GRANKDIR=LR -o ABR.pdf");
+    system("evince ABR.pdf &");
+}
+
@@ -0,0 +1,23 @@
+#include <stdbool.h>
+
+struct abr {
+    struct abr* gauche; 
+    int valeur;
+    struct abr* droit;
+};
+
+#define NIL (struct abr*)0
+
+
+extern struct abr* ajout_abr_rec (int, struct abr*);
+
+/* Calcule la hauteur d'un abr*/
+extern int hauteur_abr( struct abr*);
+
+extern bool recherche_abr_rec (int, struct abr*);
+
+extern void imprime_abr (struct abr*);
+
+extern void imprime_abrV2 (struct abr*);
+
+extern void clear_abr (struct abr*);
@@ -0,0 +1,96 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <assert.h>
+#include "abr.h"
+
+bool recherche_abr_iter (int x, struct abr* A0)
+{   struct abr* A; // curseur pour se déplacer dans A0
+    bool trouve;
+
+    A = A0;
+    trouve = false;
+    while (A != NIL && !trouve)
+    {
+        if (A->valeur == x)
+            trouve = true;
+        else if (A->valeur < x)
+            A = A->droit;
+        else
+            A = A->gauche;
+    }
+    return trouve;
+}
+
+bool recherche_abr_rec (int x, struct abr* A)
+{
+    if (A == NIL)
+        return false;
+    else if (A->valeur == x)
+        return true;
+    else if (A->valeur < x)
+        return recherche_abr_rec (x, A->droit);
+    else
+        return recherche_abr_rec (x, A->gauche);
+}
+
+static struct abr* new_feuille (int x)
+{   struct abr* F;
+
+    F = (struct abr*)malloc (sizeof (struct abr));
+    F->gauche = NIL;
+    F->valeur = x;
+    F->droit = NIL;
+    return F;
+}
+
+struct abr* ajout_abr_iter (int x, struct abr* A0)
+{
+    if (A0 == NIL)
+        return new_feuille (x);
+    else
+    {   struct abr* prec = NIL;
+        struct abr* cour = A0;
+        while (cour != NIL)
+        {   prec = cour;
+            if (cour->valeur < x)
+                cour = cour->droit;
+            else
+                cour = cour->gauche;
+        }
+        if (prec->valeur < x)
+            prec->droit = new_feuille (x);
+        else
+            prec->gauche = new_feuille (x);
+        return A0;
+    }
+}
+
+struct abr* ajout_abr_rec (int x, struct abr* A)
+{
+    if (A == NIL)
+        return new_feuille (x);
+    else if (x < A->valeur)
+        A->gauche = ajout_abr_rec (x, A->gauche);
+    else
+        A->droit = ajout_abr_rec (x, A->droit);
+    return A;
+}
+
+void clear_abr (struct abr* A)
+{
+    if (A != NIL)
+    {   clear_abr (A->gauche);
+        clear_abr (A->droit);
+        free (A);
+    }
+}
+
+void imprime_abr (struct abr* A)
+{
+    if (A != NIL)
+    {   imprime_abr (A->gauche);
+        printf ("%d\n", A->valeur);
+        imprime_abr (A->droit);
+    }
+}
+
@@ -0,0 +1,25 @@
+// abr.h
+
+#include <stdbool.h>
+
+struct abr {
+    struct abr* gauche; // ne contient que des entiers < valeur
+    int valeur;
+    struct abr* droit;  // ne contient que des entiers > valeur
+};
+
+#define NIL (struct abr*)0
+
+extern struct abr* ajout_abr_iter (int, struct abr*);
+
+extern struct abr* ajout_abr_rec (int, struct abr*);
+
+extern bool recherche_abr_iter (int, struct abr*);
+
+extern bool recherche_abr_rec (int, struct abr*);
+
+extern void imprime_abr (struct abr*);
+
+extern void clear_abr (struct abr*);
+
+
@@ -0,0 +1,22 @@
+#include <stdio.h>
+#include "abr.h"
+
+int main ()
+{   int T [] = { 17, 43, 109, 56, 8, 11 };
+    int i, n = sizeof(T)/sizeof(int);
+
+    struct abr* A;
+
+    A = NIL;
+    for (i = 0; i < n; i++)
+    {   A = ajout_abr_rec (T[i], A);
+    }
+    if (recherche_abr_rec (14, A))
+        printf ("14 est présent dans A\n");
+    else
+        printf ("14 est absent de A\n");
+    imprime_abr (A);
+    clear_abr (A);
+    return 0;
+}
+
@@ -0,0 +1,17 @@
+.PHONY: clean,real-clean
+LD = gcc
+CC = gcc
+CFLAGS = -Wall -W 
+SRC=$(wildcard *.c)
+OBJ=$(SRC:.c=.o)
+prog : $(OBJ)
+	$(LD) -o $@ $^
+
+%.o : %.c
+	$(CC) $(CFLAGS) -c $^	
+
+clean : 
+	rm -f *.o	
+
+real-clean : clean
+	rm -f prog
@@ -0,0 +1,143 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <assert.h>
+#include "abr.h"
+
+
+/*
+    struct abr {
+        struct abr* gauche; 
+        int valeur;
+        struct abr* droit;
+};
+*/
+static struct abr* new_feuille (wchar_t clef, wchar_t satellite){   
+    
+    struct abr* F;
+
+    F = (struct abr*)malloc (sizeof (struct abr));
+    F->gauche = NIL;
+    F->clef = x;
+    F->droit = NIL;
+    return F;
+}
+
+
+struct abr* ajout_abr_rec (wchar_t clef, wchar_t satellite, struct abr* A){
+    if (A == NIL)
+        return new_feuille (x);
+    else if (wcscmp(clef,A->clef)== -1)//
+        A->gauche = ajout_abr_rec (clef, satellite, A->gauche);
+    else
+        A->droit = ajout_abr_rec (clef, satellite, A->droit);
+    return A;
+}
+
+int max( int a, int b){
+ 
+    if(a>b){
+        return a;        
+    }
+    return b;
+}
+
+int hauteur_abr( struct abr* A){
+   
+    if(A == NIL){
+        return -1;
+    }
+    return max(hauteur_abr(A->gauche),hauteur_abr(A->droit))+1;
+    
+}
+
+
+wchar_t* recherche_abr_rec (wchar_t* x, struct abr* A){
+    wchar_t* res = (wchar_t*)0;
+    if (A == NIL){
+        return res;
+    } else if (wcscmp(x,A->clef)== 0 ){
+        return x;
+    } else if (wcscmp(x,A->clef)== -1){
+        wcscpy(res,recherche_abr_rec (x, A->gauche));
+    } else{
+        wcscpy(res,recherche_abr_rec (x, A->gauche));
+    }
+    return res;
+}
+
+
+static void affiche_abr (struct abr* A){
+    if( A!= NIL){
+     affiche_abr(A->gauche);
+     printf("- %d ", A-> valeur);
+     affiche_abr(A->droit);
+    }
+
+}
+
+
+void imprime_abr (struct abr* A){
+    printf("Valeurs de l'arbre: \n");
+    affiche_abr(A);
+    printf(" -\n");
+}
+
+
+static void affiche_abrV2 (struct abr* A, int profondeur){
+    if( A!= NIL){
+        int i = 0;
+        for(i=0; i<=profondeur; i++){
+             printf("\t");
+        }
+       
+        printf("%d\n ", A-> valeur);
+        affiche_abrV2(A->droit, profondeur+1);
+        affiche_abrV2(A->gauche, profondeur+1);
+    }
+
+}
+
+void imprime_abrV2 (struct abr* A){
+    printf("Valeurs de l'arbre: \n");
+    affiche_abrV2(A, 0);
+    printf("\n");
+}
+
+void clear_abr (struct abr* A)
+{
+    if (A != NIL)
+    {   clear_abr (A->gauche);
+        clear_abr (A->droit);
+        free (A);
+    }
+}
+/*
+void imprimeArbreDot( struct abr* A, FILE* f){
+   if(A->gauche != NIL){
+        fprintf(f,"%d -> %d [label=\"gauche\"];\n", A->valeur, A->gauche->valeur);
+        imprimeArbreDot(A->gauche,f);
+   } 
+   if(A->droit != NIL){
+        fprintf(f,"%d -> %d [label=\"droit\"];\n", A->valeur, A->droit->valeur);
+        imprimeArbreDot(A->droit,f);
+   }
+}
+
+
+void imprimeDot( struct abr* A){
+    FILE* f;
+    f = fopen("ABR.dot", "w");
+    fprintf(f,"digraph G {\n");
+    if(A==NIL){
+        fprintf(f,"NIL\n");
+    }else if (A->gauche == NIL && A->droit == NIL){
+        fprintf(f,"%d\n", A->valeur);
+    }else {
+        imprimeArbreDot(A,f);
+    }
+    fprintf(f,"}\n");
+    fclose(f);
+    system("dot -Tpdf ABR.dot -GRANKDIR=LR -o ABR.pdf");
+    system("evince ABR.pdf &");
+}
+*/
@@ -0,0 +1,27 @@
+#include <stdbool.h>
+#include <wchar.h>
+
+typedef wchar_t wstring [MAXLEN];
+
+struct abr {
+    struct abr* gauche; 
+    wchar_t clef;
+    wchar_t satellite;
+    struct abr* droit;
+};
+
+#define NIL (struct abr*)0
+
+
+extern struct abr* ajout_abr_rec (wchar_t, wchar_t , struct abr*);
+
+/* Calcule la hauteur d'un abr*/
+extern int hauteur_abr( struct abr*);
+
+extern bool recherche_abr_rec (int, struct abr*);
+
+extern void imprime_abr (struct abr*);
+
+extern void imprime_abrV2 (struct abr*);
+
+extern void clear_abr (struct abr*);
@@ -0,0 +1,22 @@
+#include <stdio.h>
+#include "abr.h"
+
+int main (){   
+    struct abr* racine;
+    int x;
+    racine = NIL;
+    scanf ("%d", &x);
+    while (x != -1) { 
+        racine = ajout_abr_rec(x, racine);
+        imprime_abrV2(racine);
+        //imprime_abr(racine);
+        scanf("%d", &x);
+    }
+    printf("%s\n", recherche_abr_rec (3, racine) ? "La valeur est bien présente" : "Val introuvée");
+    
+    printf ("la hauteur de l'ABR est %d\n", hauteur_abr(racine));
+   // imprimeDot(racine);
+    // printf ("le nombre de noeuds de l'ABR est %d\n",nombre_noeuds_abr (racine));
+    clear_abr (racine);
+    return 0;
+}
@@ -0,0 +1 @@
+14 7 88 51 17 53 3 -1
@@ -0,0 +1,22 @@
+#include <stdio.h>
+#include "abr.h"
+
+int main (){   
+    struct abr* racine;
+    int x;
+    racine = NIL;
+    scanf ("%d", &x);
+    while (x != -1) { 
+        racine = ajout_abr_rec(x, racine);
+        imprime_abrV2(racine);
+        //imprime_abr(racine);
+        scanf("%d", &x);
+    }
+    printf("%s\n", recherche_abr_rec (3, racine) ? "La valeur est bien présente" : "Val introuvée");
+    
+    printf ("la hauteur de l'ABR est %d\n", hauteur_abr(racine));
+    imprimeDot(racine);
+    // printf ("le nombre de noeuds de l'ABR est %d\n",nombre_noeuds_abr (racine));
+    clear_abr (racine);
+    return 0;
+}
@@ -0,0 +1 @@
+14 7 88 51 17 53 3 -1
@@ -0,0 +1,17 @@
+.PHONY: clean,real-clean
+LD = gcc
+CC = gcc
+CFLAGS = 
+SRC=$(wildcard *.c)
+OBJ=$(SRC:.c=.o)
+prog : $(OBJ)
+	$(LD) -o $@ $^
+
+%.o : %.c
+	$(CC) $(CFLAGS) -c $^	
+
+clean : 
+	rm -f *.o	
+
+real-clean : clean
+	rm -f prog
@@ -0,0 +1,37 @@
+#include "hachage_simple.h"
+#include "liste_double.h"
+#include <stdio.h>
+#include <stdlib.h>
+#include <assert.h>
+#include <stdbool.h>
+
+
+
+void init_table (struct table* T, fonction_hachage* H){
+    int i = 0;
+    for(i=0; i<N;i++){
+        init_liste_double (&T->tab[N].L);
+    }
+}
+
+void clear_table (struct table* T){
+    int i = 0;
+    for(i=0; i<N;i++){
+        clear_liste_double (&T->tab[N].L);
+    }
+    
+    
+}
+
+void enregistrer_table (struct table* T, double d){
+    
+}
+
+bool rechercher_table (struct table* T, double d){
+    return true;
+}
+
+void imprimer_table (struct table* T){
+    
+}
+
@@ -0,0 +1,22 @@
+/* hachage_simple.h */
+#include "liste_double.h"
+#include <stdbool.h>
+
+struct alveole {
+    struct liste_double L;
+};
+
+typedef int fonction_hachage (double);
+
+#define N 10
+struct table {
+    struct alveole tab [N];
+    fonction_hachage* hash;
+};
+
+extern void init_table (struct table*, fonction_hachage*);
+extern void clear_table (struct table*);
+extern void enregistrer_table (struct table*, double);
+extern bool rechercher_table (struct table*, double);
+extern void imprimer_table (struct table*);
+
@@ -0,0 +1,121 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <assert.h>
+#include <stdbool.h>
+#include "liste_double.h"
+
+void init_liste_double (struct liste_double* L)
+{
+    L->tete = (struct maillon_double*)0;
+    L->nbelem = 0;
+}
+
+void ajouter_en_tete_liste_double (struct liste_double* L, double d)
+{   struct maillon_double* nouveau;
+
+    nouveau = (struct maillon_double*)malloc (sizeof (struct maillon_double));
+    assert (nouveau != (struct maillon_double*)0);
+/* appeler ici un éventuel constructeur pour nouveau->value */
+    nouveau->value = d;       /* affectation de la valeur */
+    nouveau->next = L->tete;
+    L->tete = nouveau;
+    L->nbelem += 1;
+}
+
+void clear_liste_double (struct liste_double* L)
+{   struct maillon_double* courant;
+    struct maillon_double* suivant;
+    int i;
+
+    courant = L->tete;
+    for (i = 0; i < L->nbelem; i++)
+    {   suivant = courant->next;
+/* appeler ici un éventuel destructeur pour nouveau->value */
+        free (courant);
+        courant = suivant;
+    }
+}
+
+
+bool recherche_liste_double (struct liste_double* L, double d)
+{   struct maillon_double* M;
+    int i;
+
+    M = L->tete;
+    for (i = 0; i < L->nbelem; i++)
+    {   
+        if (M->value == d){
+            return true;
+        }
+        M = M->next;
+    }
+   return false;
+}
+/*
+ * Sous-fonction de set_liste_double.
+ * Si L = [m1, m2, ..., mn] avant l'appel alors
+ *    L = [mn, ..., m2, m1] après l'appel.
+ * Aucune allocation dynamique n'est effectuée. 
+ * Seuls les pointeurs sont modifiés
+ */
+
+static void retourner_liste_double (struct liste_double* L)
+{   struct maillon_double *precedent, *courant, *suivant;
+    int i;
+
+    if (L->nbelem >= 2)
+    {   courant = L->tete;
+        suivant = courant->next;
+        courant->next = (struct maillon_double*)0;
+        for (i = 1; i < L->nbelem; i++)
+        {   precedent = courant;
+            courant = suivant;
+            suivant = suivant->next;
+            courant->next = precedent;
+        }
+        L->tete = courant;
+    }
+}
+
+void set_liste_double (struct liste_double* dst, struct liste_double* src)
+{   struct maillon_double* M;
+    int i;
+
+    if (dst != src)
+    {   clear_liste_double (dst);
+        init_liste_double (dst);
+        M = src->tete;
+        for (i = 0; i < src->nbelem; i++)
+        {   ajouter_en_tete_liste_double (dst, M->value);
+            M = M->next;
+        }
+        retourner_liste_double (dst);
+    }
+}
+
+void extraire_tete_liste_double (double* d, struct liste_double* L)
+{   struct maillon_double* tete;
+
+    assert (L->nbelem != 0);
+    tete = L->tete;
+    *d = tete->value;      /* affectation */
+    L->tete = tete->next;
+    L->nbelem -= 1;
+    free (tete);
+}
+
+void imprimer_liste_double (struct liste_double* L)
+{   struct maillon_double* M;
+    int i;
+
+    printf ("[");
+    M = L->tete;
+    for (i = 0; i < L->nbelem; i++)
+    {   if (i == 0)
+            printf ("%f", M->value);
+        else
+            printf (", %f", M->value);
+        M = M->next;
+    }
+    printf ("]\n");
+}
@@ -0,0 +1,72 @@
+#if ! defined (LISTE_DOUBLE_H)
+#define LISTE_DOUBLE_H 1
+
+/**********************************************************************
+ * IMPLANTATION
+ * 
+ * Spécification de l'implantation
+ * 
+ * Implantation des listes simplement chaînées de doubles
+ * 
+ * Les maillons sont alloués dynamiquement. 
+ * Le champ next du dernier maillon vaut (struct maillon_double*)0
+ * 
+ * Le champ tete d'une liste pointe vers le premier maillon
+ * Le champ nbelem est égal au nombre de maillons de la liste
+ * La liste vide est codée par (tete, nbelem) = ((struct maillon_double*)0, 0)
+ *
+ * Des listes distinctes ont des maillons distincts (pas de maillon partagé).
+ **********************************************************************/
+
+struct maillon_double
+{   double value;
+    struct maillon_double* next;
+};
+
+struct liste_double
+{   struct maillon_double* tete;
+    int nbelem;
+};
+
+/**********************************************************************
+ * PROTOTYPES DES FONCTIONS (TYPE ABSTRAIT)
+ **********************************************************************/
+
+/* 
+ * Constructeur. Initialise son paramètre à la liste vide 
+ */
+
+extern void init_liste_double (struct liste_double*);
+
+/* 
+ * Destructeur 
+ */
+
+extern void clear_liste_double (struct liste_double*);
+
+/* 
+ * Affecte une copie de src à dst 
+ */
+
+extern void set_liste_double 
+        (struct liste_double* dst, struct liste_double* src);
+
+/* 
+ * Ajout d'un double en tête de liste 
+ */
+
+extern void ajouter_en_tete_liste_double (struct liste_double*, double);
+
+/* 
+ * Affecte à *d la valeur du premier élément de L et supprime cet élément de L. 
+ * La liste L est supposée non vide.
+ */
+
+extern void extraire_tete_liste_double (double* d, struct liste_double* L);
+
+/* 
+ * Impression. 
+ */
+
+extern void imprimer_liste_double (struct liste_double*);
+#endif
@@ -0,0 +1,12 @@
+CC=gcc
+CFLAGS=-g -Wall -Wmissing-prototypes
+LDFLAGS=-g
+objects := $(patsubst %.c,%.o,$(wildcard *.c))
+all: main
+clean:
+	-rm $(objects)
+	-rm main
+main: $(objects)
+# gcc -MM *.c pour obtenir les deux lignes ci-dessous
+liste_double.o: liste_double.c liste_double.h
+main.o: main.c liste_double.h
@@ -0,0 +1,105 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <assert.h>
+#include "liste_double.h"
+
+void init_liste_double (struct liste_double* L)
+{
+    L->tete = (struct maillon_double*)0;
+    L->nbelem = 0;
+}
+
+void ajouter_en_tete_liste_double (struct liste_double* L, double d)
+{   struct maillon_double* nouveau;
+
+    nouveau = (struct maillon_double*)malloc (sizeof (struct maillon_double));
+    assert (nouveau != (struct maillon_double*)0);
+/* appeler ici un éventuel constructeur pour nouveau->value */
+    nouveau->value = d;       /* affectation de la valeur */
+    nouveau->next = L->tete;
+    L->tete = nouveau;
+    L->nbelem += 1;
+}
+
+void clear_liste_double (struct liste_double* L)
+{   struct maillon_double* courant;
+    struct maillon_double* suivant;
+    int i;
+
+    courant = L->tete;
+    for (i = 0; i < L->nbelem; i++)
+    {   suivant = courant->next;
+/* appeler ici un éventuel destructeur pour nouveau->value */
+        free (courant);
+        courant = suivant;
+    }
+}
+
+/*
+ * Sous-fonction de set_liste_double.
+ * Si L = [m1, m2, ..., mn] avant l'appel alors
+ *    L = [mn, ..., m2, m1] après l'appel.
+ * Aucune allocation dynamique n'est effectuée. 
+ * Seuls les pointeurs sont modifiés
+ */
+
+static void retourner_liste_double (struct liste_double* L)
+{   struct maillon_double *precedent, *courant, *suivant;
+    int i;
+
+    if (L->nbelem >= 2)
+    {   courant = L->tete;
+        suivant = courant->next;
+        courant->next = (struct maillon_double*)0;
+        for (i = 1; i < L->nbelem; i++)
+        {   precedent = courant;
+            courant = suivant;
+            suivant = suivant->next;
+            courant->next = precedent;
+        }
+        L->tete = courant;
+    }
+}
+
+void set_liste_double (struct liste_double* dst, struct liste_double* src)
+{   struct maillon_double* M;
+    int i;
+
+    if (dst != src)
+    {   clear_liste_double (dst);
+        init_liste_double (dst);
+        M = src->tete;
+        for (i = 0; i < src->nbelem; i++)
+        {   ajouter_en_tete_liste_double (dst, M->value);
+            M = M->next;
+        }
+        retourner_liste_double (dst);
+    }
+}
+
+void extraire_tete_liste_double (double* d, struct liste_double* L)
+{   struct maillon_double* tete;
+
+    assert (L->nbelem != 0);
+    tete = L->tete;
+    *d = tete->value;      /* affectation */
+    L->tete = tete->next;
+    L->nbelem -= 1;
+    free (tete);
+}
+
+void imprimer_liste_double (struct liste_double* L)
+{   struct maillon_double* M;
+    int i;
+
+    printf ("[");
+    M = L->tete;
+    for (i = 0; i < L->nbelem; i++)
+    {   if (i == 0)
+            printf ("%f", M->value);
+        else
+            printf (", %f", M->value);
+        M = M->next;
+    }
+    printf ("]\n");
+}
@@ -0,0 +1,72 @@
+#if ! defined (LISTE_DOUBLE_H)
+#define LISTE_DOUBLE_H 1
+
+/**********************************************************************
+ * IMPLANTATION
+ * 
+ * Spécification de l'implantation
+ * 
+ * Implantation des listes simplement chaînées de doubles
+ * 
+ * Les maillons sont alloués dynamiquement. 
+ * Le champ next du dernier maillon vaut (struct maillon_double*)0
+ * 
+ * Le champ tete d'une liste pointe vers le premier maillon
+ * Le champ nbelem est égal au nombre de maillons de la liste
+ * La liste vide est codée par (tete, nbelem) = ((struct maillon_double*)0, 0)
+ *
+ * Des listes distinctes ont des maillons distincts (pas de maillon partagé).
+ **********************************************************************/
+
+struct maillon_double
+{   double value;
+    struct maillon_double* next;
+};
+
+struct liste_double
+{   struct maillon_double* tete;
+    int nbelem;
+};
+
+/**********************************************************************
+ * PROTOTYPES DES FONCTIONS (TYPE ABSTRAIT)
+ **********************************************************************/
+
+/* 
+ * Constructeur. Initialise son paramètre à la liste vide 
+ */
+
+extern void init_liste_double (struct liste_double*);
+
+/* 
+ * Destructeur 
+ */
+
+extern void clear_liste_double (struct liste_double*);
+
+/* 
+ * Affecte une copie de src à dst 
+ */
+
+extern void set_liste_double 
+        (struct liste_double* dst, struct liste_double* src);
+
+/* 
+ * Ajout d'un double en tête de liste 
+ */
+
+extern void ajouter_en_tete_liste_double (struct liste_double*, double);
+
+/* 
+ * Affecte à *d la valeur du premier élément de L et supprime cet élément de L. 
+ * La liste L est supposée non vide.
+ */
+
+extern void extraire_tete_liste_double (double* d, struct liste_double* L);
+
+/* 
+ * Impression. 
+ */
+
+extern void imprimer_liste_double (struct liste_double*);
+#endif
@@ -0,0 +1,16 @@
+#include "liste_double.h"
+
+int main ()
+{   struct liste_double A;
+
+    init_liste_double (&A);
+
+    ajouter_en_tete_liste_double (&A, -0.1);
+    ajouter_en_tete_liste_double (&A, 0.0);
+    ajouter_en_tete_liste_double (&A, 3.14);
+
+    imprimer_liste_double (&A);
+
+    clear_liste_double (&A);
+    return 0;
+}
@@ -0,0 +1,24 @@
+/* main.c */
+#include <stdio.h>
+#include "hachage_simple.h"
+
+int hachage_basique (double d)
+{
+    return (int)d % N;
+}
+
+int main ()
+{   
+    
+    struct table T;
+    double x;
+    init_table (&T, &hachage_basique);
+    /*scanf ("%lf", &x);
+    while (x != -1){
+        enregistrer_table (&T, x);
+    imprimer_table (&T);
+    scanf ("%lf", &x);
+    }
+    clear_table (&T);*/
+    return 0;
+}