les arbres binaires - Page 1

         *
       /  \
      -    2
    /   \
   /     \
  *      *
 /  \   /  \
2   3  5    4

typedef struct noeud 
{
unsigned char data;
noeud* pere_gauche;
noeud* pere_droit;
}noeud;

 
            mon noeud
           /         \  
pere_gauche           pere_droit

         *  <---- celui la
       /  \
      -    2
    /   \
   /     \
  *      *
 /  \   /  \
2   3  5    4

struct node {
  char data;
  struct node *left;
  struct node *right;
};

int calc(struct node *n)
{
  switch (n->data) {
    case '+': return calc(n->left) + calc(n->right);
    case '*': return calc(n->left) * calc(n->right);
    ...
    default: return n->data - '0';
  }
}

matthieu :
a uéééééééé putain trop balese le truc recurrent, putain excellentissime
j'y crois pas ca fait o moins 2 jours que je suis dessus et toi tu trouves ca en 5 min
ben merci infiniment

Sasume :
En C, tu peux écrire des fonctions récursives.

Sasume :
Et c'est évidemment possible de s'en passer, rien qu'en la simulant, mais parfois en écrivant autrement le code...

Moumou :
On peut toujours simuler la récursivité en utilisant des automates à quatre compteurs. Par contre, c'est plus fastidieux.

Godzil :
c'est achement plus complexe a ecrire en itératif alors que le recursif permet du code moindre et généralement plus facile a maintenir/lire

Nheryvra :
le recursif cay bo

Quesoft
:

Godzil :
c'est achement plus complexe a ecrire en itératif alors que le recursif permet du code moindre et généralement plus facile a maintenir/lire

Effectivement (à moins de ne pouvoir faire autrement, à cause de contraintes de mémoire par exemple).

Godzil :
Hum si c'est bien codé (des deux coté) j'ai un penchant sur le fait que la methode itérative bouffe plus de mémoire, apres si la pile est tres limité en espace comparté a la mémoire c'est sur que...

L'itératif est prèsque toujours moins gourmand, parce que l'appel d'une fonction bouffe quand même assez de ressource sur la pile (adresse de retour + tous les paramètres + toutes les variables locales) et est relativement plus lent. C'est pour cela que je disais ça.

typedef struct Liste_
{
   char *byte;
   Liste_ *next;
} Liste;

void FreeAll(Liste *Ptr)
{
  if (Ptr->next != NULL)
    FreeAll(Ptr->next)
  free(Ptr->byte);
}

Godzil :
essaye de faire moins lourd en mémoire/temps qu'un

typedef struct Liste_
{
   char *byte;
   Liste_ *next;
} Liste;

void FreeAll(Liste *Ptr)
{
  if (Ptr->next != NULL)
    FreeAll(Ptr->next)
  free(Ptr->byte);
}

Enfin c'est plus trop dans le sujet
[/hs]

void freeAll(void *ptr) {
  void *pPrev = ptr;

  while (pPrev != NULL) {
    ptr = pPrev->next;
    free(pPrev);
    pPrev = ptr;
  }
}

Sasume :
Quesoft> Avec ton code, les désallocations ne se font pas dans le même ordre qu'avec celui de Godzil. Mais le résultat final est le même.

#define push(i) (pile[pileTop++] = i)
#define pop() (pile[pileTop--])
#define empty() (pileTop == 0)

void freeAll(void *ptr) {
  void *pile[TAILLE_PILE];
  int pileTop = 0;

  while (ptr != NULL) {
    push(ptr);
    ptr = ptr->next;
  }

  while (!empty()) {
    free(pop());
  }
}

Quesoft
:

Moumou :
On peut toujours simuler la récursivité en utilisant des automates à quatre compteurs. Par contre, c'est plus fastidieux.

C'est à dire ? Je pige pas.

Moumou :
Ce que je voulais dire par là, c'est que ta remarque ne sert à rien, parce qu'on peut simuler la récursivité avec à peu près tous les modèles de calcul que l'on veut.