arbre quasi sans fuite

arbre/src/arbre.c

@@ -2,12 +2,12 @@
 #include <stdlib.h>
 #include "arbre.h"
 
-Arbre	arbreNouv(void)
+Arbre	arbreNouv(void) //
 {
 	return NULL;
 }
 
-void	viderArbre(Arbre a)
+void	viderArbre(Arbre a) //
 {
 	if(vide(a))
 	{
@@ -18,12 +18,12 @@ void	viderArbre(Arbre a)
 	free(a);
 }
 
-bool	vide(Arbre a)
+bool	vide(Arbre a) //
 {
 	return a == NULL;
 }
 
-void	afficherRacine(int v, int k)
+void	afficherRacine(int v, int k) //
 {
 	int	i;
 	
@@ -33,10 +33,10 @@ void	afficherRacine(int v, int k)
 		printf("---");
 		i++;
 	}
-	printf("%d\n", v);
+	printf(">%d\n", v);
 }
 
-Arbre	e(Arbre a, int x, Arbre b)
+Arbre	e(Arbre a, int x, Arbre b) //
 {
 	Maillon *m;
 
@@ -52,23 +52,23 @@ Arbre	e(Arbre a, int x, Arbre b)
 	return m;
 }
 
-void	afficherArbre(Arbre a)
+void	afficherArbre(Arbre a) //
 {
 	afficherArb(a, 0);
 }
 
-void	afficherArb(Arbre a, int k)
+void	afficherArb(Arbre a, int k) //
 {
 	if(vide(a))
 	{
 		return;
 	}
-	afficherArb(ad(a), ++k);
+	afficherArb(ad(a), k + 1);
 	afficherRacine(r(a), k);
-	afficherArb(ag(a), ++k);
+	afficherArb(ag(a), k + 1);
 }
 
-Arbre	ag(Arbre a)
+Arbre	ag(Arbre a) //
 {
 	if(vide(a))
 	{
@@ -78,7 +78,7 @@ Arbre	ag(Arbre a)
 	return a->g;
 }
 
-Arbre	ad(Arbre a)
+Arbre	ad(Arbre a) //
 {
 	if(vide(a))
 	{
@@ -88,7 +88,7 @@ Arbre	ad(Arbre a)
 	return a->d;
 }
 
-int	r(Arbre a)
+int	r(Arbre a) //
 {
 	if(vide(a))
 	{
@@ -98,7 +98,7 @@ int	r(Arbre a)
 	return a->v;
 }
 
-int	h(Arbre a)
+int	h(Arbre a)//
 {
 	if(vide(a))
 	{
@@ -107,16 +107,7 @@ int	h(Arbre a)
 	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)
+bool	f(Arbre a)//
 {
 	if(vide(a))
 	{
@@ -125,7 +116,7 @@ bool	f(Arbre a)
 	return vide(ag(a)) && vide(ad(a));
 }
 
-int	nf(Arbre a)
+int	nf(Arbre a)//
 {
 	if(vide(a))
 	{
@@ -138,29 +129,219 @@ int	nf(Arbre a)
 	return nf(ag(a)) + nf(ad(a));
 }
 
-Arbre	eg(Arbre a)
+Arbre	eg(Arbre a) //
 {
 	if(vide(a))
 	{
 		return a;
 	}
-	if(vide(ag(0)))
+	if(vide(ag(a)))
 	{
-		return e(arbreNouv(), r(a), arbreNouv());
+		return a;
 	}
 	return eg(ag(a));
 }
 
 
-Arbre	ed(Arbre a)
+Arbre	ed(Arbre a) //
 {
 	if(vide(a))
 	{
 		return a;
 	}
-	if(vide(ad(0)))
+	if(vide(ad(a)))
 	{
-		return e(arbreNouv(), r(a), arbreNouv());
+		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(int a, int b)//
+{
+	if(a >= b)
+		return a;
+	return 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, int 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, int x) //
+{
+	Arbre	tmp;
+	
+	if(vide(a))
+		return a;
+	if(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(x < r(a))
+	{
+		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, int x)//
+{
+	if(vide(a) || r(a) == x)
+		return a;
+	if(x < r(a))
+		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/src/arbre.h

@@ -24,3 +24,16 @@ 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/src/test.c

@@ -1,13 +1,45 @@
 #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();
-	Arbre Arbre2 = arbreNouv();
-	
-	Arbre Arbre3 = e(Arbre1, 5, Arbre2);
-	afficherArbre(Arbre3);
-	viderArbre(Arbre3);
+	Arbre1 = insf(Arbre1, 5);
+	Arbre1 = insf(Arbre1, 6);
+	Arbre1 = insf(Arbre1, 7);
+	/*Arbre1 = insf(Arbre1, 8);
+	Arbre1 = insf(Arbre1, 9);
+	Arbre1 = insf(Arbre1, 10);
+	Arbre1 = insf(Arbre1, 12);*/
+	afficherArbre(Arbre1);
+	testTri(trie(Arbre1));
+	viderArbre(Arbre1);
 	return 0;
 }

graphe/src/graph.c

@@ -0,0 +1,115 @@
+#include "graph.h"
+
+Liste	listenouv(void)
+{
+	return NULL;
+}
+
+bool	videList(Liste l)
+{
+	return l == NULL;
+}
+
+
+Liste	insTList(Liste l, int x)
+{
+	Maillon*	maill;
+
+	maill = (Maillon*)malloc(sizeof(Maillon));
+	if(maill == NULL)
+	{
+		printf("Pb malloc\n");
+		exit(1);
+	}
+	maill->v = x;
+	maill->suiv = l;
+	return maill;
+}
+
+Liste	insList(Liste l, int x)
+{
+	if(videList(l))
+		return insTList(l, x);
+	if(x < l->v)
+		return insTList(l,x);
+	if(x == l->v)
+		return l;
+	l->suiv = insList(l->suiv, x);
+	return l;
+}
+
+Liste	supTList(Liste l)
+{
+	Maillon*	aux;
+	
+	if(videList(l))
+	{
+		printf("Opération interdite\n");
+		exit(1);
+	}
+	aux = l;
+	l = l->suiv;
+	free(aux);
+	return l;
+}
+
+Liste	supList(Liste l, int x)
+{
+	if(videList(l))
+		return l;
+	if(x < l->v)
+		return l;
+	if(x == l->v)
+		return supTList(l);
+	l->suiv = supList(l->suiv, x);
+	return l;
+}
+
+int	tList(Liste l)
+{
+	if(videList(l))
+	{
+		printf("Opération interdite\n");
+		exit(1);
+	}
+	return l->v;
+
+}
+
+bool	rechList(Liste l, int x)
+{
+	if(videList(l))
+		return false;
+	if(x < l->v)
+		return false;
+	if(x == l->v)
+		return true;
+	return rechList(l->suiv, x);
+}
+
+int	lgList(Liste l)
+{
+	if(videList(l))
+		return 0;
+	return 1 + lgList(l->suiv);
+}
+
+Liste	addQList(Liste l, int x)
+{
+	if(videList(l))
+		return insTList(l,x);
+	l->suiv = addQList(l->suiv, x);
+	return l;
+}
+
+void	afficherList(Liste l)
+{
+	if(videList(l))
+	{
+		printf("\n");
+		return;
+	}
+	printf("%d\n", l->v);
+	afficherList(l->suiv);
+}
+

graphe/src/graph.h

@@ -0,0 +1,32 @@
+#include <stdbool.h>
+#include <stdlib.h>
+#include <stddef.h>
+#include <stdio.h>
+
+
+typedef struct maillon
+{
+	int	v;
+	struct	maillon *suiv;
+} Maillon, *Liste;
+
+
+typedef struct maillonG
+{
+	int	v;
+	struct	maillonG *suiv;
+	Liste	l;
+} MaillonG, *Graphe;
+
+
+Liste	listenouv	(void);
+bool	videList	(Liste l);
+Liste	insTList	(Liste l, int x);
+Liste	insList		(Liste l, int x);
+Liste	supTList	(Liste l);
+Liste	supList		(Liste l, int x);
+int	tList		(Liste l);
+bool	rechList	(Liste l, int x);
+int	lgList		(Liste l);
+Liste	addQList	(Liste l, int x);
+void 	afficherList	(Liste l);