arbre

#include <stdio.h>
#include <stdlib.h>
//recap du cours.
typedef struct arbre arbre;
struct arbre//structure arbre.
{
    int value;
    arbre *ag;//fils gauche.
    arbre *ad;//fils droite.
};
//arbre à gauche inferieur à la racine.
//arbre à droite superieur à la racine.
void construct(arbre **abr,int el)//Créer un arbre constitué d’une seule feuille.
{
    *(abr)=malloc(sizeof(arbre));
    (*abr)->ag=(*abr)->ad=NULL;
    (*abr)->value=el;
}
int supAbr(arbre *abr)//Retourne le Sup d'un arbre.
{
    if(abr){
        if(!(abr->ad))//Pas d'element superieur au élément courant.
            return abr->value;
        else
            return supAbr(abr->ad);
    }
    else{
        printf("Erreur\n");
    }
}
int infAbr(arbre *abr)//Retourne le Inf d'un arbre.
{
    if(abr){
        if(!(abr->ag))//Pas d'element inferieur au élément courant.
            return abr->value;
        else
            return infAbr(abr->ag);
    }
    else{
        printf("Erreur\n");
    }
}
void associee(arbre *abr,arbre *ag,arbre *ad)
{
    if(abr)
    {
        if ((abr->value<infAbr(ad))&&(abr->value>supAbr(ag)))
        {
            abr->ag=ag;
            abr->ad=ad;
        }
        else
            printf("Impossible régle génerale\n");
    }
    else
        printf("Void\n");
}
void ajout(arbre **abr,int el)
{
    arbre *a;
    if(!(*abr))
    {
        a=malloc(sizeof(arbre));
        a->ag=a->ad=NULL;
        a->value=el;
        *abr=a;
    }
    else
    {
        a=*abr;
        while(1){
            if (el==a->value)
            {
                printf("Impossible\n");
                break;
            }
            else if (el<a->value)
            {
                if(!(a->ag))//insere dans le premier neud possible.
                {
                    arbre *temp=malloc(sizeof(arbre));
                    temp->ag=temp->ad=NULL;
                    temp->value=el;
                    a->ag=temp;
                    break;
                }
                else{
                    a=a->ag;
                }
            }
            else if (el>a->value)
            {
                if(!(a->ad))//insere dans le premier neud possible.
                {
                    arbre *temp=malloc(sizeof(arbre));
                    temp->ag=temp->ad=NULL;
                    temp->value=el;
                    a->ad=temp;
                    break;
                }
                else{
                    a=a->ad;
                }
            }
        }
    }
}
void affiche(arbre *abr)
{
    if(abr){
        affiche(abr->ag);
        affiche(abr->ad);
        printf("%d\n",abr->value);
    }
}
int nbrElement(arbre *abr)
{
    if(!abr)
    {
        return 0;
    }
    int p1,p2;
    p1=nbrElement(abr->ag);
    p2=nbrElement(abr->ad);
    return 1 + p1 + p2;
}
int profondeur(arbre *abr)
{
    if(!abr)
    {
        return 0;
    }
    int p1,p2;
    p1=profondeur(abr->ag);
    p2=profondeur(abr->ad);
    if (p1>p2)
    {
        return 1 + p1;
    }
    else
    {
        return 1 + p2;
    }
}
int main(int argc, char const *argv[])
{
    arbre *abr;
    construct(&abr,1);
    printf("%p\n%d\n%p\n%p\n",abr,abr->value,abr->ag,abr->ag);
    ajout(&abr,7);
    ajout(&abr,6);
    ajout(&abr,8);
    ajout(&abr,-15);
    affiche(abr);
    printf("%d\n%d\n%d\n%d\n",infAbr(abr),supAbr(abr),nbrElement(abr),profondeur(abr));
    return 0;
}