debut des arbres

arbre/Makefile

@@ -0,0 +1,26 @@
+#CC : le compilateur a utiliser
+CC=gcc
+
+#CFLAGS : les options de compilation  (en C++ moderne, voir les warning,...)
+CFLAGS= -Wall -Werror -Wextra
+
+SAN= -fsanitize=leak,address
+
+# les fichiers sources : tous les fichiers présents dans src/
+SRC=$(wildcard src/*.c src/*.h)
+
+# les fichiers objets (.o)
+OBJ=$(patsubst src/%.c,obj/%.o,$(SRC))
+
+
+#edition des liens : génération de l'exécutaba partir des .o 
+bin/exe: $(OBJ)
+	$(CC) $(OBJ) -o $@ $(SAN)
+
+# génération des .a partir des .cpp et .hpporrespondants : 
+obj/%.o: src/%.c 
+	$(CC) $(CFLAGS) -c $< -o $@
+
+#nettoyage : destruction des .o et de l'exécutable
+clean:
+	rm obj/*.o bin/exe

arbre/src/arbre.c

@@ -0,0 +1,166 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include "arbre.h"
+
+Arbre	arbreNouv(void)
+{
+	return NULL;
+}
+
+void	viderArbre(Arbre a)
+{
+	if(vide(a))
+	{
+		return;
+	}
+	viderArbre(a->g);
+	viderArbre(a->d);
+	free(a);
+}
+
+bool	vide(Arbre a)
+{
+	return a == NULL;
+}
+
+void	afficherRacine(int v, int k)
+{
+	int	i;
+	
+	i = 0;
+	while(i < k)
+	{
+		printf("---");
+		i++;
+	}
+	printf("%d\n", v);
+}
+
+Arbre	e(Arbre a, int x, Arbre b)
+{
+	Maillon *m;
+
+	m = (Maillon *)malloc(sizeof(Maillon));
+	if(!m)
+	{
+		printf("erreur allocation memoire enracinement");
+		exit(1);
+	}
+	m->v = x;
+	m->g = a;
+	m->d = b;
+	return m;
+}
+
+void	afficherArbre(Arbre a)
+{
+	afficherArb(a, 0);
+}
+
+void	afficherArb(Arbre a, int k)
+{
+	if(vide(a))
+	{
+		return;
+	}
+	afficherArb(ad(a), ++k);
+	afficherRacine(r(a), k);
+	afficherArb(ag(a), ++k);
+}
+
+Arbre	ag(Arbre a)
+{
+	if(vide(a))
+	{
+		printf("operation interdite ag");
+		exit(1);
+	}
+	return a->g;
+}
+
+Arbre	ad(Arbre a)
+{
+	if(vide(a))
+	{
+		printf("operation interdite ad");
+		exit(1);
+	}
+	return a->d;
+}
+
+int	r(Arbre a)
+{
+	if(vide(a))
+	{
+		printf("operation interdite racine");
+		exit(1);
+	}
+	return a->v;
+}
+
+int	h(Arbre a)
+{
+	if(vide(a))
+	{
+		return -1;
+	}
+	return 1 + max(h(ag(a)), h(ad(a)));
+}
+
+int	max(int a, int b)
+{
+	if(a > b)
+	{
+		return a;
+	}
+	return b;
+}
+
+bool	f(Arbre a)
+{
+	if(vide(a))
+	{
+		return false;
+	}
+	return vide(ag(a)) && vide(ad(a));
+}
+
+int	nf(Arbre a)
+{
+	if(vide(a))
+	{
+		return 0;
+	}
+	if(f(a))
+	{
+		return 1;
+	}
+	return nf(ag(a)) + nf(ad(a));
+}
+
+Arbre	eg(Arbre a)
+{
+	if(vide(a))
+	{
+		return a;
+	}
+	if(vide(ag(0)))
+	{
+		return e(arbreNouv(), r(a), arbreNouv());
+	}
+	return eg(ag(a));
+}
+
+
+Arbre	ed(Arbre a)
+{
+	if(vide(a))
+	{
+		return a;
+	}
+	if(vide(ad(0)))
+	{
+		return e(arbreNouv(), r(a), arbreNouv());
+	}
+	return ed(ad(a));
+}

arbre/src/arbre.h

@@ -0,0 +1,26 @@
+#include <stdbool.h>
+
+typedef struct maillon
+{
+	struct maillon *g;
+	struct maillon *d;
+	int v;
+} Maillon, *Arbre;
+
+Arbre	arbreNouv(void);
+bool	vide(Arbre a);
+void	afficherRacine(int v, int k);
+Arbre	e(Arbre a, int x, Arbre b);
+void	afficherArbre(Arbre a);
+void	afficherArb(Arbre a, int k);
+Arbre	ag(Arbre a);
+Arbre	ad(Arbre a);
+int	r(Arbre a);
+int	max(int a, int b);
+int	nn(Arbre a);
+bool	f(Arbre a);
+int	nf(Arbre a);
+Arbre	eg(Arbre a);
+Arbre	ed(Arbre a);
+int	h(Arbre a);
+void	viderArbre(Arbre a);

arbre/src/test.c

@@ -0,0 +1,13 @@
+#include "arbre.h"
+#include <stdio.h>
+
+int	main(void)
+{
+	Arbre Arbre1 = arbreNouv();
+	Arbre Arbre2 = arbreNouv();
+	
+	Arbre Arbre3 = e(Arbre1, 5, Arbre2);
+	afficherArbre(Arbre3);
+	viderArbre(Arbre3);
+	return 0;
+}