Null en c

Bonjour,

Je vous rappelle que je rampe encore en c.

Mon prob est d'écrire un algo me permettant de retrouver la représentation fonctionnelle d'un arbre abstrait à partir de sa représentation préfixée d'une part et de sa représentation postfixée d'autre part.

Corriger mes erreur dans le prog ci-dessous pour que je puisse résoudre mon pro.

/* Les composantes de l'arbre seront donc soit des opérateurs (noeuds),*/
/* soit des opérandes (feuilles). Nous allons choisir les déclarations suivantes :*/

#include <stdio.h>


typedef float type_feuille;
typedef struct s_noeud_2
{char op_c;
struct s_comp*fils1;
struct s_comp*fils2;
}type_noeud_2;

typedef struct s_noeud_1
{char op_c;
struct s_comp*fils;
}type_noeud_1;

typedef struct s_comp
{int arite;
union
{type_noeud_2 n2;
type_noeud_1 n1;
type_feuille f;
}val;
}composante;

typedef composante *lien;



main
{
lien saisie_prefixe(char **deb);
affiche_prefixe(lien x);
lien saisie_postfixe(char **deb);
affiche_postfixe(lien x;
affiche_fonctionnelle(lien x);
}


/* Fonction créant l'arbre à partir d'une chaîne de caractères préalablement saisie,*/
/* contenant l'expression en notation préfixée on donne une chaîne de caractère contenant*/
/*l'expression en notation préfixée. les opérateurs possibles sont +,-,*,/(deuxaires), */
/* C,S(cos,sin,unaires).*/
/* Les nombres sont séparés par des blancs (optionnels pour les opérateurs) */
/* Les nombres commencent par un chiffre (exemple 0.7 au lieu de .7). */
/* deb pointe sur le début de chaîne, il pointera ensuite sur le reste de la chaîne */
/* (pas encore traitée) donc passage par adresse d'un pointeur */


lien saisie_prefixe(char **deb)

{
lien x;
printf("entrez op‚randes (nombres) et op‚rateurs (+,-,*,/,C (cos),S)\n");
printf("s‚par‚s par des blancs\n");
printf(" \n");
/* char c; */
while(**deb==' '||**deb==',') (*deb)++;
if(**deb==0) /* on est arrivé en fin de chaîne */
{puts("erreur : il doit manquer des opérandes");
return(NULL);}
x=(composante*)malloc(sizeof(composante));
if(isdigit(**deb))
{
x->arite=0;
sscanf(*deb,"%f",&(x->val.f));
while(isdigit(**deb)||**deb=='.') (*deb)++;
}
else
{
c=toupper(*((*deb)++));
if(c=='*'||c=='/'||c=='+'||c=='-')
{
x->arite=2;
x->val.n2.op_c=c;
x->val.n2.fils1=saisie_prefixe(deb);
x->val.n2.fils2=saisie_prefixe(deb);
}
else if(c=='C'||c=='S')
{
x->arite=1;
x->val.n1.op_c=c;
x->val.n1.fils=saisie_prefixe(deb);
}
else printf("erreur, '%c'n'est pas un opérateur prévu\n",c);
}
return(x);
}



/* Fonction créant l'arbre à partir d'une chaîne de caractères préalablement saisie, contenant l'expression en notation postfixée */


lien saisie_postfixe(char **deb)

{
lien x;
printf("entrez op‚randes (nombres) et op‚rateurs (+,-,*,/,C (cos),S)\n");
printf("s‚par‚s par des blancs\n");
char c;
while(**deb==' '||**deb==',') (*deb)++;
if(**deb==0) /* on est arrivé en fin de chaîne */
{puts("erreur : il doit manquer des opérandes");
return(NULL);}
x=(composante*)malloc(sizeof(composante));
if(isdigit(**deb))
{
x->arite=0;
sscanf(*deb,"%f",&(x->val.f));
while(isdigit(**deb)||**deb=='.') (*deb)++;
}
else
{
c=toupper(*((*deb)++));
if(c=='*'||c=='/'||c=='+'||c=='-')
{
x->arite=2;
x->val.n2.fils1=saisie_prefixe(deb);
x->val.n2.fils2=saisie_prefixe(deb);
x->val.n2.op_c=c;
}
else if(c=='C'||c=='S')
{
x->arite=1;
x->val.n1.fils=saisie_prefixe(deb);
x->val.n1.op_c=c;
}
else printf("erreur, '%c'n'est pas un opérateur prévu\n",c);
}
return(x);
}




/* Utilisation de l'arbre pour afficher sa représentation fonctionnelle. */
/* On afficher la valeur du noeud puis le fils gauche et le fils droit séparés*/
/* par une virgule et tous deux entre parenthèse. */


void affiche_prefixe(lien x)
{

switch(x->arite)
{
case 0:printf("%6.1f ",x->val.f);break;

case 1:printf(" %C ",x->val.n1.op_c);
affiche_prefixe(x->val.n1.fils);
break;

case 2:printf(" %c ",x->val.n2.op_c);
affiche_prefixe(x->val.n2.fils1);
affiche_prefixe(x->val.n2.fils2);
}
}

void affiche_postfixe(lien x)
{

switch(x->arite)
{
case 0:printf("%6.1f ",x->val.f);break;

case 1:affiche_postfixe(x->val.n1.fils);
printf(" %C ",x->val.n1.op_c);
break;

case 2:affiche_postfixe(x->val.n2.fils1);
affiche_postfixe(x->val.n2.fils2);
printf(" %c ",x->val.n2.op_c);
}
}

void affiche_fonctionnelle(lien x)
{
switch(x->arite)
{
case 0:printf("%6.1f ",x->val.f);break;

case 1:printf(x->val.n1.op_c," %C( ");
affiche_fonctionnelle(x->val.n1.fils);
putch(')');
break;

case 2:printf(" %c ",x->val.n2.op_c);

if(x->val.n2.fils1->arite!=0)putch('(');
affiche_fonctionnelle(x->val.n2.fils1);
if(x->val.n2.fils1->arite!=0)putch(')');

putch(',')


if(x->val.n2.fils2->arite!=0)putch('(');
affiche_fonctionnelle(x->val.n2.fils2);
if(x->val.n2.fils2->arite!=0)putch(')');
putch(',')
}
}

Quand je compile, les erreurs ne me laissent pas respirer en commençant par le char de lien saisie_postfixe(char **deb) qu'il ignore carrément.

Je veut voir quelque chose qui marche avant de dormir.

Merci d'avance pour lami qui m'a permis de décoller.

A plus mes profs