tp processus

Vincent Benoist
1 parent cb716d77
Showing 58 changed files with 1102 additions and 19 deletions Show diff stats
ProcessusMultiThread/Tp1/Makefile
ProcessusMultiThread/Tp1/oldversion/tp1_fork.c
ProcessusMultiThread/Tp1/oldversion/tp1_fork.o
ProcessusMultiThread/Tp1/prog
ProcessusMultiThread/Tp1/tp1_fork_ex3.c
ProcessusMultiThread/Tp1/tp1_fork_ex3.o
ProcessusMultiThread/Tp2/Makefile
ProcessusMultiThread/Tp2/cmd_suivi
ProcessusMultiThread/Tp2/cmd_suivi.c
ProcessusMultiThread/Tp2/dir.txt
ProcessusMultiThread/Tp2/dir2.txt
ProcessusMultiThread/Tp2/pd_sm
ProcessusMultiThread/Tp2/pipe
ProcessusMultiThread/Tp2/pipe_lec.c
ProcessusMultiThread/Tp2/produit
ProcessusMultiThread/Tp2/produit.c
ProcessusMultiThread/Tp2/produit_somme.c
ProcessusMultiThread/Tp2/prog
ProcessusMultiThread/Tp2/redirect
ProcessusMultiThread/Tp2/redirect.c
@@ -0,0 +1,17 @@
+.PHONY: clean,real-clean
+LD = gcc
+CC = gcc
+CFLAGS = -Wall -W -Werror
+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
 \ No newline at end of file
@@ -0,0 +1,31 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <sys/wait.h>
+#include <unistd.h>
+
+int main(){
+    int cr, cpt=0;
+    if((cr=fork())<0){
+        perror("erreur exec du fork");
+        exit(1);
+    }
+    for(;;){
+        if(cr ==0){
+            printf("fils");
+            sleep(1);
+        } else {
+            int r, pid;
+            printf("pere");
+            sleep(2);
+            cpt++;
+            if (cpt==5) {
+                exit(0);
+            }
+            if((pid= wait(&r)) <0){
+                perror("erreur exec du wait");
+                exit(1);
+            }
+        }
+    }
+    return 0;
+}
@@ -0,0 +1,111 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <sys/wait.h>
+#include <unistd.h>
+/*
+int main(){
+    int cr, ent=0;
+    if((cr=fork())<0){
+        perror("erreur exec du fork");
+        exit(1);
+    }
+    if(cr == 0){
+        printf("dans le fils, val de ent : %d\n", ent);
+        ent ++;
+        printf("dans le fils, val de ent après incrémentation: %d\n", ent);
+    } else {
+        int r, pid;
+        printf("dans le père, val de ent : %d\n", ent);
+        ent++;
+        printf("dans le père, val de ent après incrémentation: %d\n", ent);
+        if((pid= wait(&r)) <0){
+            perror("erreur exec du wait");
+            exit(1);
+        }
+    }
+    return 0;
+}
+
+int main(){
+    int fork1, fork2;
+    if((fork1=fork())<0){
+        perror("erreur exec du fork");
+        exit(1);
+    }
+    if(fork1 == 0){
+        printf("dans le fils1, pid: %d\n", getpid());
+        sleep(2);
+    }
+   
+    else {
+        if((fork2=fork())<0){
+            perror("erreur exec du fork");
+            exit(1);
+        }
+        if(fork2 == 0){
+            printf("dans le fils2, pid: %d\n", getpid());
+            sleep(4);
+        } 
+        else{
+            int r, pid;
+            printf("dans le père, val de ent : %d\n", getpid());
+            if((pid= wait(&r)) <0){
+                perror("erreur exec du wait");
+                exit(1);
+            }
+            if((pid= wait(&r)) <0){
+                perror("erreur exec du wait");
+                exit(1);
+            }
+        }
+    }
+    return 0;
+}
+*/
+int main(){
+    int fils, petitfils;
+    if((fils=fork())<0){
+        perror("erreur exec du fork");
+        exit(1);
+    }
+    if(fils == 0){
+        sleep(2);
+        if((petitfils=fork())<0){
+            perror("erreur exec du fork");
+            exit(1);
+        }
+        if(petitfils == 0){
+            sleep(4);
+            printf("dans le petitfils, pid: %d\n", getpid());
+            for(;;){}
+            exit(8);
+        } 
+        else{
+            int r, pid;
+            printf("dans le fils, val de ent : %d\n", getpid());
+            if((pid= wait(&r)) <0){
+                perror("erreur exec du wait");
+                exit(1);
+            }
+            if(WIFEXITED(r)){
+                printf("Mort normale du fils: %d\n", WEXITSTATUS(r));
+            }else if( WIFSIGNALED(r)){
+                printf("Fils mort avec le code: %d\n", WTERMSIG(r));
+            }
+            exit(2);
+        }
+    } else {       
+        int r, pid;
+        printf("dans le père, val de ent : %d\n", getpid());
+        if((pid= wait(&r)) <0){
+            perror("erreur exec du wait");
+            exit(1);
+        }
+        if(WIFEXITED(r)){
+            printf("Mort normale du fils: %d\n", WEXITSTATUS(r));
+        }else if( WIFSIGNALED(r)){
+            printf("Fils mort avec le code: %d\n", WTERMSIG(r));
+        }
+    }
+    return 0;
+}
@@ -0,0 +1,17 @@
+.PHONY: clean,real-clean
+LD = gcc
+CC = gcc
+CFLAGS = -Wall -W -Werror
+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
 \ No newline at end of file
@@ -0,0 +1,55 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <sys/wait.h>
+#include <unistd.h>
+
+int main(){
+    int fork1, fork2, fork3;
+    if((fork1=fork())<0){
+        perror("erreur exec du fork");
+        exit(1);
+    }
+    if(fork1 == 0){
+        if(execlp("who","who",NULL)==-1){
+            perror("echec execlp");
+            exit(1);
+        }  
+    }else{
+        int pid, r; 
+        if((pid= wait(&r)) <0){
+                perror("erreur exec du wait");
+                exit(1);
+        }
+        if((fork2=fork())<0){
+            perror("erreur exec du fork");
+            exit(1);
+        }
+        if(fork2 == 0){
+            if(execlp("ps","ps","-x",NULL)==-1){
+                perror("echec execlp");
+                exit(1);
+            }  
+        }else{
+            if((pid= wait(&r)) <0){
+                    perror("erreur exec du wait");
+                    exit(1);
+            }
+            if((fork3=fork())<0){
+                perror("erreur exec du fork");
+                exit(1);
+            }
+            if(fork3 == 0){
+                if(execlp("ls","ls","-la",NULL)==-1){
+                    perror("echec execlp");
+                    exit(1);
+                }  
+            }else{
+                if((pid= wait(&r)) <0){
+                    perror("erreur exec du wait");
+                    exit(1);
+                }
+            }
+        }
+    }
+    return 0;
+}
@@ -0,0 +1,9 @@
+-la
+-la
+-la
+-la
+-la
+-la
+-la
+-la
+-la
@@ -0,0 +1 @@
+-la
@@ -0,0 +1,69 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <sys/wait.h>
+#include <unistd.h>
+
+
+int main(int argc, char * argv[]){
+    if(argc != 2){
+        return 1;
+    }
+    int fils1, fils2;
+    int entierCourant;
+    int tube[2];
+    if(pipe(tube)<0){
+        
+        perror("erreur pipe");
+        exit(1);
+    }
+    
+    if((fils1=fork())<0){
+        perror("erreur exec du fork");
+        exit(1);
+    }
+    if(fils1 == 0){
+        close(tube[0]); //fils 1 ne lit pas 
+        printf("entiers:\n");
+        scanf("%d",&entierCourant);
+        while(entierCourant != 0){
+            if(entierCourant%2==0){
+                write(tube[1], &entierCourant, sizeof(int));
+            }
+            scanf("%d",&entierCourant);
+        }
+        close(tube[1]);
+    }
+   
+    else {
+        if((fils2=fork())<0){
+            perror("erreur exec du fork");
+            exit(1);
+        }
+        if(fils2 == 0){
+            close(tube[1]); //fils 2 n'écrit pas
+            while(read(tube[0],&entierCourant,sizeof(int))==sizeof(int)){
+                if(entierCourant > atoi(argv[1])){
+                    printf("%d \n",entierCourant);
+                }
+            }
+            close(tube[0]);
+        } 
+        else{
+            int r, pid;
+            
+            close(tube[1]);
+            close(tube[0]);
+           
+            if((pid= wait(&r)) <0){
+                perror("erreur exec du wait");
+                exit(1);
+            }
+            if((pid= wait(&r)) <0){
+                perror("erreur exec du wait");
+                exit(1);
+            }
+            printf("\nDans le père, traitement fini\n");
+        }
+    }
+    return 0;
+}
@@ -0,0 +1,11 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+
+int main(int argc, char * argv[]){
+    int n1,n2;
+    n1=atoi(argv[1]);
+    n2=atoi(argv[2]);
+    printf("PID : %d, PPID : %d, %d * %d = %d\n", getpid(), getppid(), n1, n2, n1*n2);
+    return 0;
+}
@@ -0,0 +1,56 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <sys/wait.h>
+#include <unistd.h>
+
+int main(int argc, char * argv[]){
+    if(argc != 3){
+        return 1;
+    }
+    int fork1, fork2;
+    if((fork1=fork())<0){
+        perror("erreur exec du fork");
+        exit(1);
+    }
+    if(fork1 == 0){
+        if(execlp("./somme","somme",argv[1],argv[2],NULL)==-1){
+            perror("echec execlp");
+            exit(1);
+        }  
+    }
+   
+    else {
+        if((fork2=fork())<0){
+            perror("erreur exec du fork");
+            exit(1);
+        }
+        if(fork2 == 0){
+            sleep(2);
+            if(execlp("./produit","produit",argv[1],argv[2],NULL)==-1){
+                perror("echec execlp");
+                exit(1);
+            }  
+        } 
+        else{
+            int r, pid;
+            if((pid= wait(&r)) <0){
+                perror("erreur exec du wait");
+                exit(1);
+            }else if(pid==fork1){
+                printf("Somme effectuée\n");
+            }else if(pid==fork2){
+                printf("Produit effectuée\n");
+            }
+            
+            if((pid= wait(&r)) <0){
+                perror("erreur exec du wait");
+                exit(1);
+            }else if(pid==fork1){
+                printf("Somme effectuée\n");
+            }else if(pid==fork2){
+                printf("Produit effectuée\n");
+            }
+         }
+    }
+    return 0;
+}
@@ -0,0 +1,41 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <sys/wait.h>
+#include <unistd.h>
+#include <sys/types.h>
+
+int main(){
+   
+    int desc;
+    if((desc=open("dir2.txt",0666))<0){
+        if((desc=creat("dir2.txt",0666))==-1){
+            perror("creation fichier impossible");
+            exit(1);
+        }
+    }else {   
+        if(lseek(desc,0,SEEK_END)==-1){
+            perror("creation fichier impossible");
+            exit(1);
+        }
+    }
+    close(1);
+    dup(desc);
+    int fork1;
+    if((fork1=fork())<0){
+        perror("erreur exec du fork");
+        exit(1);
+    }
+    if(fork1 == 0){
+        if(execlp("echo","echo","-la",NULL)==-1){
+            perror("echec execlp");
+            exit(1);
+        }  
+    }else{
+        int pid, r; 
+        if((pid= wait(&r)) <0){
+                perror("erreur exec du wait");
+                exit(1);
+        }
+    }
+    return 0;
+}
@@ -0,0 +1,11 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+
+int main(int argc, char * argv[]){
+    int n1,n2;
+    n1=atoi(argv[1]);
+    n2=atoi(argv[2]);
+    printf("PID : %d, PPID : %d, %d + %d = %d\n", getpid(), getppid(), n1, n2, n1+n2);
+    return 0;
+}
@@ -0,0 +1,57 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <sys/wait.h>
+#include <unistd.h>
+
+
+int main(int argc, char * argv[]){
+    int fils1, fils2;
+    int tube[2];
+    if(pipe(tube)<0){
+        perror("erreur pipe");
+        exit(1);
+    }
+    
+    if((fils1=fork())<0){
+        perror("erreur exec du fork");
+        exit(1);
+    }
+    if(fils1 == 0){
+        close(tube[0]); //fils 1 ne lit pas 
+        dup2(tube[1],1);
+        if(execlp("cat","cat","/etc/passwd",NULL)==-1){
+            perror("echec execlp");
+            exit(1);
+        }
+    } else {
+        if((fils2=fork())<0){
+            perror("erreur exec du fork");
+            exit(1);
+        }
+        if(fils2 == 0){
+            close(tube[1]); //fils 2 n'écrit pas
+            dup2(tube[0],0);
+            if(execlp("wc","ws",NULL)==-1){
+                perror("echec execlp");
+                exit(1);
+            }
+            
+        } else{
+            int r, pid;
+                
+            close(tube[1]);
+            close(tube[0]);
+           
+            if((pid= wait(&r)) <0){
+                perror("erreur exec du wait");
+                exit(1);
+            }
+            if((pid= wait(&r)) <0){
+                perror("erreur exec du wait");
+                exit(1);
+            }
+            printf("\nDans le père, traitement fini\n");
+        }
+    }
+    return 0;
+}
@@ -0,0 +1,37 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <sys/wait.h>
+#include <unistd.h>
+
+/*int main(){
+    printf("lancement de la commande ls\n");
+    if(execlp("ls","ls","-l",NULL)==-1){
+     perror("echec execlp");
+     exit(1);
+    }
+    return 0;
+}*/
+
+int main(){
+    int fils;
+    char fich[256];
+    printf("nom  du fichier ?\n");
+    scanf("%s",fich);
+    if((fils=fork())<0){
+        perror("erreur exec du fork");
+        exit(1);
+    }
+    if(fils == 0){
+        if(execlp("wc","ws","-l",fich,NULL)==-1){
+            perror("echec execlp");
+            exit(1);
+        }  
+    } else {
+        int r, pid;
+        if((pid= wait(&r)) <0){
+            perror("erreur exec du wait");
+            exit(1);
+        }
+    }
+    return 0;
+}
@@ -0,0 +1,99 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <sys/wait.h>
+#include <unistd.h>
+#include <pthread.h>
+#include <signal.h>
+
+
+#define ATTENTE 3
+int vitesse_train =0;
+int conducteur_actif =1;
+pthread_mutex_t mutex;
+
+void hand(int sig){
+        printf("Veuiller bouger\n");
+}
+
+void * conducteur_action(void* arg){
+    while(1){
+        sleep(ATTENTE);
+        pthread_mutex_lock(&mutex);
+        if(conducteur_actif==0){
+            kill(getppid(),SIGINT);
+            sleep(3);
+            if(conducteur_actif==0){
+                kill(getppid(),SIGKILL);
+            }
+        }    
+        conducteur_actif=0;
+        pthread_mutex_unlock(&mutex);   
+    }
+}
+
+int main(int argc, char * argv[]){
+    int fils1;
+    int action_courante=0;
+    int tube[2];
+    pthread_mutex_init(&mutex,NULL);
+    if(pipe(tube)<0){
+        perror("erreur pipe");
+        exit(1);
+    }
+    
+    if((fils1=fork())<0){
+        perror("erreur exec du fork");
+        exit(1);
+    }
+    if(fils1 == 0){
+        close(tube[1]); //fils n'écrit pas
+        int variation_v;
+        
+        pthread_t tid1;
+        pthread_attr_t attr;
+        pthread_attr_init(&attr);
+        pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
+        pthread_create(&tid1, &attr, conducteur_action, NULL);
+        while(read(tube[0],&variation_v,sizeof(int))==sizeof(int)){
+            
+            pthread_mutex_lock(&mutex);
+            conducteur_actif = 1;
+            pthread_mutex_unlock(&mutex);  
+            
+            vitesse_train = vitesse_train + variation_v;
+            printf("Vitesse actuelle: %d\n",vitesse_train);
+        }
+        close(tube[0]);
+    } else {
+        
+        struct sigaction action;
+        sigset_t ens;
+        sigemptyset(&ens);
+        action.sa_handler = hand;
+        action.sa_mask =ens;
+        action.sa_flags = SA_RESTART;
+        sigaction(SIGINT,&action,NULL);
+        
+        close(tube[0]); //pere 1 ne lit pas 
+        printf("Action:\n");
+      
+        scanf("%d",&action_courante);
+        while(action_courante != -2){
+                if((action_courante<2) && (action_courante>-2)){
+                    write(tube[1], &action_courante, sizeof(int));
+                }
+                scanf("%d",&action_courante);
+        }
+        vitesse_train=0;
+        close(tube[1]);
+        
+        int r, pid;
+        if((pid= wait(&r)) <0){
+            perror("erreur exec du wait");
+            exit(1);
+        }
+        printf("\nDans le père, train arrêté, vitesse: %d\n",vitesse_train);
+        
+    }
+    return 0;
+}
@@ -0,0 +1,3 @@
+1000 0 30 40 50 60 70 80 90 100
+90
+10
@@ -0,0 +1,84 @@
+#include <stdio.h>
+#include <pthread.h>
+#include <stdlib.h>
+#define MAX 		10
+
+int tab[MAX];
+int nb=0;
+pthread_mutex_t mutex;
+
+void lire() {
+	int i;
+	printf("saisir %d entiers\n", MAX);
+	for (i=0; i<MAX ; i++) scanf("%d", &tab[i]);
+}
+void affiche(){
+	int i;
+	printf("entiers saisis :");
+	for (i=0; i<MAX ; i++) printf("%d ",tab [i]);
+	printf("\n");
+}
+void * moyenne(void* arg){
+	int i, moy=tab[0];
+	for (i=1; i<MAX; i++) moy = moy + tab[i];
+	printf("moyenne des entiers = %f\n", (float)moy/MAX);
+}
+void * supSeuil(void* arg){
+	int i;
+    int seuil =*(int*)arg;
+    pthread_mutex_lock(&mutex);
+	for (i=0; i<MAX; i++) if (tab[i]>seuil) nb++;
+	printf("fin de fonction supSeuil : nb = %d\n", nb);
+    pthread_mutex_unlock(&mutex);
+}
+void * infSeuil(void* arg){
+	int i;
+    int seuil =*(int*)arg;
+    pthread_mutex_lock(&mutex);
+	for (i=0; i<MAX; i++) if (tab[i]<seuil) nb++;
+	printf("fin de fonction infSeuil : nb = %d\n", nb);
+    pthread_mutex_unlock(&mutex);
+}
+
+void minMax(int *min, int *max) {
+	int i;
+	*min=tab[0];
+	*max=tab[0];
+	for (i=1; i<MAX; i++) {
+	    if (tab[i]<*min) *min=tab[i];
+	    else if (tab[i]>*max) *max=tab[i];
+	}
+}
+
+int main(){
+	int seuilInf, seuilSup, min, max;
+    pthread_t tid1, tid2, tid3;
+    pthread_attr_t attr;
+    pthread_attr_init(&attr);
+    pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
+    
+ 
+    pthread_mutex_init(&mutex,NULL);
+   
+   
+	lire();
+	affiche();
+    
+    pthread_create(&tid1, &attr, moyenne, NULL);
+	
+    
+    
+	printf("saisir les seuils sup et inf : ");
+	scanf("%d%d", &seuilSup, &seuilInf);
+	 int * p_seuilInf = (int *) malloc(sizeof(int));
+    *p_seuilInf = seuilInf;
+    int * p_seuilSupp = (int *) malloc(sizeof(int));
+    *p_seuilSupp = seuilSup;
+    pthread_create(&tid2, &attr, supSeuil,(void *) p_seuilSupp);
+    pthread_create(&tid3, &attr, infSeuil,(void *) p_seuilInf);
+    
+	minMax(&min, &max);
+	printf("min = %d, max = %d\n", min, max);
+    pthread_exit(NULL);
+	return(0);
+}
@@ -0,0 +1,96 @@
+#include <stdio.h>
+#include <pthread.h>
+#include <stdlib.h>
+#define MAX 		10
+
+int tab[MAX];
+int nb=0;
+pthread_mutex_t mutex;
+struct minMax {
+    int *min;
+    int *max;
+    };
+
+void lire() {
+	int i;
+	printf("saisir %d entiers\n", MAX);
+	for (i=0; i<MAX ; i++) scanf("%d", &tab[i]);
+}
+void affiche(){
+	int i;
+	printf("entiers saisis :");
+	for (i=0; i<MAX ; i++) printf("%d ",tab [i]);
+	printf("\n");
+}
+void * moyenne(void* arg){
+	int i, moy=tab[0];
+	for (i=1; i<MAX; i++) moy = moy + tab[i];
+	printf("moyenne des entiers = %f\n", (float)moy/MAX);
+}
+void * supSeuil(void* arg){
+	int i;
+    int seuil =*(int*)arg;
+    for (i=0; i<MAX; i++){
+        if (tab[i]>seuil){
+            pthread_mutex_lock(&mutex);
+            nb++;
+            pthread_mutex_unlock(&mutex);   
+        }
+    }
+     
+}
+void * infSeuil(void* arg){
+    int i;
+    int seuil =*(int*)arg;
+    
+    for (i=0; i<MAX; i++){
+        if (tab[i]<seuil){
+            pthread_mutex_lock(&mutex);
+            nb++;
+            pthread_mutex_unlock(&mutex);   
+        }
+    }
+}
+
+void * minMax(void * arg) {
+	int i;
+    struct minMax str_minMax = *(struct minMax *)arg;
+	*str_minMax.min=tab[0];
+	*str_minMax.max=tab[0];
+	for (i=1; i<MAX; i++) {
+	    if (tab[i]<*str_minMax.min) *str_minMax.min=tab[i];
+	    else if (tab[i]>*str_minMax.max) *str_minMax.max=tab[i];
+	}
+}
+
+int main(){
+	int seuilInf, seuilSup, min, max;
+    pthread_t tid1, tid2, tid3, tid4;
+ 
+    pthread_mutex_init(&mutex,NULL);
+   
+	lire();
+	affiche();
+    
+    pthread_create(&tid1, NULL, moyenne, NULL); 
+    
+	printf("saisir les seuils sup et inf : ");
+	scanf("%d%d", &seuilSup, &seuilInf);
+ 
+    pthread_join(tid1,NULL);
+    pthread_create(&tid2, NULL, supSeuil,(void *) &seuilSup);
+    pthread_create(&tid3, NULL, infSeuil,(void *) &seuilInf);
+    pthread_join(tid2,NULL);
+    pthread_join(tid3,NULL);
+    
+    struct minMax str_minMax;
+
+    str_minMax.min = &min;
+    str_minMax.max = &max;
+    pthread_create(&tid4, NULL, minMax,(void *) &str_minMax);
+	    
+    pthread_join(tid4,NULL);
+	printf("min = %d, max = %d\nnb=%d", *str_minMax.min, *str_minMax.max, nb);
+    pthread_exit(NULL);
+	return(0);
+}
@@ -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,41 @@
+#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[i].L);
+    }
+    T->hash = H;*/
+}
+
+void clear_table (struct table* T){
+    /*int i = 0; 
+    for(i=0; i<N;i++){
+        clear_liste_double (&T->tab[i].L);
+    }*/
+}
+
+void enregistrer_table (struct table* T, double d){
+   /* int i;
+    i=T->hash(d);
+    ajouter_en_tete_liste_double(&T->tab[i].L,d);*/
+}
+
+bool rechercher_table (struct table* T, double d){
+   /*int i;
+   i= T->hash(d);
+   recherche_liste_double(&T->tab[i].L,d);*/
+}
+
+void imprimer_table (struct table* T){
+   /*int i = 0; 
+    for(i=0; i<N;i++){
+        imprimer_liste_double (&T->tab[i].L);
+    } */
+}
+
@@ -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*);
+
 #if ! defined (LISTE_DOUBLE_H)
 #define LISTE_DOUBLE_H 1
  
+#include <stdbool.h>
+
 /**********************************************************************
  * IMPLANTATION
  * 
@@ -38,6 +40,8 @@ struct liste_double
  
 extern void init_liste_double (struct liste_double*);
  
+
+extern bool recherche_liste_double (struct liste_double* , double );
 /* 
  * Destructeur 
  */
@@ -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;
+}
@@ -0,0 +1,136 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <assert.h>
+#include "abr.h"
+
+
+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,29 @@
+#if ! defined (ABR_H)
+#define ABR_H 1
+
+
+#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*);
+
+#endif
-#include "hachage_simple.h"
-#include "liste_double.h"
 #include <stdio.h>
 #include <stdlib.h>
 #include <assert.h>
 #include <stdbool.h>
-
+#include "hachage_simple.h"
+#include "abr.h"
  
  
 void init_table (struct table* T, fonction_hachage* H){
-    int i = 0;
+   int i = 0;
     for(i=0; i<N;i++){
-        init_liste_double (&T->tab[N].L);
+       (T->tab[i].L) = NIL;
     }
+    T->hash = H;
 }
  
 void clear_table (struct table* T){
-    int i = 0;
+   int i = 0; 
     for(i=0; i<N;i++){
-        clear_liste_double (&T->tab[N].L);
+       clear_abr(T->tab[i].L);
     }
-    
-    
 }
  
 void enregistrer_table (struct table* T, double d){
-    
+    int i;
+    i=T->hash(d);
+    T->tab[i].L = ajout_abr_rec(i, T->tab[i].L);
 }
  
 bool rechercher_table (struct table* T, double d){
-    return true;
+   int i;
+   i= T->hash(d);
+   recherche_abr_rec(i,T->tab[i].L);
 }
  
 void imprimer_table (struct table* T){
-    
+   int i = 0; 
+    for(i=0; i<N;i++){
+       imprime_abr(T->tab[i].L);
+    } 
 }
  
 /* hachage_simple.h */
-#include "liste_double.h"
+#include "abr.h"
 #include <stdbool.h>
  
 struct alveole {
-    struct liste_double L;
+    struct abr* L;
 };
  
 typedef int fonction_hachage (double);
@@ -9,16 +9,16 @@ int hachage_basique (double d)
  
 int main ()
 {   
-    
     struct table T;
     double x;
     init_table (&T, &hachage_basique);
-    /*scanf ("%lf", &x);
+
+    scanf ("%lf", &x);
     while (x != -1){
         enregistrer_table (&T, x);
-    imprimer_table (&T);
-    scanf ("%lf", &x);
+        imprimer_table (&T);
+        scanf ("%lf", &x);
     }
-    clear_table (&T);*/
+    clear_table (&T);
     return 0;
 }