les arbres_string abrucon, idiobete

arbre_string/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 $@
+
+# 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_string/src/arbre.c

@@ -0,0 +1,398 @@
+#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(char *v, int k) //
+{
+	int	i;
+	
+	i = 0;
+	while(i < k)
+	{
+		printf("---");
+		i++;
+	}
+	printf(">%s\n", v);
+}
+
+Arbre	e(Arbre a, char *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 + 1);
+	afficherRacine(r(a), k);
+	afficherArb(ag(a), k + 1);
+}
+
+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;
+}
+
+char	*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)));
+}
+
+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(a)))
+	{
+		return a;
+	}
+	return eg(ag(a));
+}
+
+
+Arbre	ed(Arbre a) //
+{
+	if(vide(a))
+	{
+		return a;
+	}
+	if(vide(ad(a)))
+	{max
+		return a;
+	}
+	return ed(ad(a));
+}
+
+int	nn(Arbre a) //
+{
+	if(vide(a))
+		return 0;
+	return 1 + nn(ag(a)) + nn(ad(a));
+}
+
+int	max(char *a, char *b) //
+{
+	return my_strcmp(a, b);
+}
+
+bool	egarb(Arbre a, Arbre b) //
+{
+	if(vide(a) && vide(b))
+		return true;
+	if(vide (a) || vide(b))
+		return false;
+	return r(a) == r(b) && egarb(ag(a),ag(b)) && egarb(ad(a), ad(b));
+}
+
+Arbre	insf(Arbre a, char *x) //
+{
+	if(vide(a))
+	{
+		return e(arbreNouv(), x, arbreNouv());
+	}
+	if (x == r(a))
+		return a;
+	if (x < r(a))
+	{
+		a->g = insf(a->g, x);
+		return reeq(a);
+	}
+	a->d = insf(a->d, x);
+	return reeq(a);
+}
+
+Arbre	supp(Arbre a, char x) //
+{
+	Arbre	tmp;
+	
+	if(vide(a))
+		return a;
+	if(my_strcmp(x, r(a)))
+	{
+		if(vide(ag(a)))
+		{
+			tmp = a->d;
+			free(a);
+			return tmp;
+		}
+		if(vide(ad(a)))
+		{
+			tmp = a->g;
+			free(a);
+			return tmp;
+		}
+		tmp = e(oterMax(a->g), r(ed(a->g)), a->d);
+		free(a);
+		return tmp;
+	}
+	if(my_strcmp(x, r(a)) > 0)
+	{
+		tmp = e(supp(a->g, x), r(a), a->d);
+		free(a);
+		return tmp;
+	}
+	tmp = e(a->g, r(a), supp(a->d, x));
+	free(a);
+	return tmp;
+}
+
+Arbre	oterMax(Arbre a) //
+{
+	Arbre	tmp;
+
+	if(vide(a))
+		return a;
+	if(vide(ad(a)))
+	{
+		tmp = a->g;
+		free(a);
+		return tmp;
+	}
+	a->d = oterMax(a->d);
+	return a;
+}
+
+Arbre	rech(Arbre a, char *x) //
+{
+	if(vide(a) || my_strcmp(r(a), x) == 0)
+		return a;
+	if(my_strcmp(x, r(a)) < 0)
+		return rech(ag(a), x);
+	return rech(ad(a), x);
+}
+bool	trie(Arbre a) //
+{
+	bool	b1;
+	bool	b2;
+	Arbre	tmp;
+
+	b1 = false;
+	b2 = false;
+	if(vide(a))
+		return true;
+	if(vide(ag(a)))
+		b1 = true;
+	else
+	{
+		tmp = ed(ag(a));
+		b1 = r(tmp) < r(a);
+	}
+	if(vide(ad(a)))
+		b2 = true;
+	else
+	{
+		tmp = eg(ad(a));
+		b2 = r(tmp) > r(a);
+	}
+	return b1 && b2 && trie(ag(a)) && trie(ad(a));
+}
+
+Arbre	rd(Arbre a)
+{
+	Arbre	tmp;
+
+	if(vide(a))
+	{
+		printf("arbre gauche vide pour retournement droit\n");
+		exit(1);
+	}
+	tmp = e(ag(ag(a)), r(ag(a)),  e(ad(ag(a)), r(a), ad(a)));
+	free(a);
+	return tmp;
+}
+
+Arbre	rg(Arbre a)
+{
+	Arbre	tmp;
+
+	if(vide(a))
+	{
+		printf("arbre droit vide pour retournement gauche\n");
+		exit(1);
+	}
+	tmp = e(e(ag(a), r(a), ag(ad(a))), r(ad(a)), ad(ad(a)));
+	free(a);
+	return tmp;
+}
+
+Arbre	rgd(Arbre a)
+{
+	if(vide(a))
+		return a;
+	a->g = rg(a->g);
+	return rd(a);
+}
+
+Arbre	rdg(Arbre a)
+{
+	if(vide(a))
+		return a;
+	a->d = rd(a->d);
+	return rg(a);
+}
+
+Arbre	reeq(Arbre a)
+{
+	if(deseq(a) == 2 && 0 <= deseq(ag(a)))
+		a = rd(a);
+	if(deseq(a) == -2 && deseq(ad(a)) <= 0)
+		a = rg(a);
+	if(deseq(a) == 2 && -1 == deseq(ag(a)))
+		a = rgd(a);
+	if(deseq(a) == -2 && 1 == deseq(ad(a)))
+		a = rdg(a);
+	return a;
+}
+
+int	deseq(Arbre a)
+{
+	if(vide(a))
+		return 0;
+	return h(ag(a)) - h(ad(a));
+}
+
+Arbre	insr(Arbre a, int x)
+{
+	Couple	c;
+
+	c = couper(a, x);
+	return reeq(e(c.c1, x, c.c2));
+}
+Couple	couper(Arbre a, int x)
+{
+	Couple	c;
+	Couple	d;
+
+	if(vide(a))
+	{
+		c.c1 = arbreNouv();
+		c.c2 = arbreNouv();
+		return c;
+	}
+	if(my_strcmp(x, r(a)) == 0)
+	{
+		c.c1 = ag(a);
+		c.c2 = ad(a);
+		return c;
+	}
+	if(my_strcmp(x < r(a)) < 0)
+	{
+		d = couper(ag(a), x);
+		c.c1 = d.c1;
+		c.c2 = e(d.c2, r(a), ad(a));
+		return c;
+	}
+	d = couper(ad(a), x);
+	c.c1 = e(ag(a), r(a), d.c1);
+	c.c2 = d.c2;
+	return c;
+}
+Arbre	oterMin(Arbre a)
+{
+	Arbre	tmp;
+
+	if(vide(a))
+		return a;
+	if(vide(ag(a)))
+	{
+		tmp = ad(a);
+		free(a);
+		return tmp;
+	}
+	a->g = oterMin(a->g);
+	return a;
+}
+

arbre_string/src/arbre.h

@@ -0,0 +1,51 @@
+#include <stdbool.h>
+
+#define MAX(X, Y) (((X) > (Y)) ? (X) : (Y))
+
+typedef struct maillon
+{
+	struct maillon *g;
+	struct maillon *d;
+	char *v;
+} Maillon, *Arbre;
+
+typedef struct
+{
+	Arbre	c1;
+	Arbre	c2;
+}	Couple;
+
+Arbre	arbreNouv(void);//
+bool	vide(Arbre a);//
+void	afficherRacine(char *v, int k);//
+Arbre	e(Arbre a, char *x, Arbre b);//
+void	afficherArbre(Arbre a);//
+void	afficherArb(Arbre a, int k);//
+Arbre	ag(Arbre a);//
+Arbre	ad(Arbre a);//
+char	*r(Arbre a);//
+int	max(char *a, char *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);//
+int	nn(Arbre a);//
+bool	egarb(Arbre a, Arbre b);//
+Arbre	insf(Arbre a, int x);//
+Arbre	supp(Arbre a, int x);//
+Arbre	oterMax(Arbre a);//
+Arbre	rech(Arbre a, int x);//
+bool	trie(Arbre a);//
+Arbre	rd(Arbre a);//
+Arbre	rg(Arbre a);//
+Arbre	rgd(Arbre a);//
+Arbre	rdg(Arbre a);//
+Arbre	reeq(Arbre a);//
+int	deseq(Arbre a);//
+Arbre	insr(Arbre a, int x);//
+Couple	couper(Arbre a, int x);//
+Arbre	oterMin(Arbre a);//
+int	my_strcmp(char *s1, char *s2);

arbre_string/src/my_strcmp.c

@@ -0,0 +1,13 @@
+int	my_strcmp(char *s1, char *s2)
+{
+	int i;
+
+	i = 0;
+	while (s1[i])
+	{
+		if (s1[i] != s2[i])
+			return (s1[i] - s2[i]);
+		i++;
+	}
+	return (s1[i] - s2[i]);
+}

arbre_string/src/test.c

@@ -0,0 +1,46 @@
+#include "arbre.h"
+#include <stdio.h>
+
+void	testEg(bool a)
+{
+	if(a)
+		printf("EgArb ok\n");
+	else
+		printf("EgArb nope\n");
+	return;
+}
+
+void	testFeuille(bool a)
+{
+	if(a)
+		printf("c'est une feuille\n");
+	else
+		printf("c'est un baobab\n");
+	return;
+}
+
+void	testTri(bool a)
+{
+	if(a)
+		printf("arbre trié\n");
+	else
+		printf("arbre non trié\n");
+	return;
+}
+
+int	main(void)
+{
+	Arbre Arbre1 = arbreNouv();
+	Arbre1 = insf(Arbre1, 11);
+	Arbre1 = insf(Arbre1, 10);
+	Arbre1 = insf(Arbre1, 9);
+	Arbre1 = insf(Arbre1, 8);
+	Arbre1 = insf(Arbre1, 7);
+	Arbre1 = insf(Arbre1, 6);
+	Arbre1 = insf(Arbre1, 5);
+	afficherArbre(Arbre1);
+	oterMin(Arbre1);
+	afficherArbre(Arbre1);
+	viderArbre(Arbre1);
+	return 0;
+}