Bonjour, j'essaie de créer un programme qui prend une liste chaînée d'entiers et additionne les carrés de l'entier, en utilisant la récursivité. J'ai essayé cela jusqu'à présent, mais je n'arrive pas à faire fonctionner la fonction de somme des carrés. Je ne sais pas si utiliser le pow() est le meilleur moyen ?

#include <stdio.h>
#include <stdlib.h> 
#include <assert.h> 
#include<math.h>

typedef struct node
{
  int value;
  struct node* next;
} node;

/* terminal node at the end of the list */
node SENTINEL = {0, 0};

/* utility functions to create and free lists */
node * make_node(int v, node * q)
{
  node* p = (node*) malloc(sizeof(node));
  p->value = v;
  p->next = q;
  return p;
}

int sum_squares(node* list)
{
    if(list == 0)
        return 0;
    else
    {
        return(pow(&list, 2) + sum_squares(list));
    }
    
    
}
void free_node(node* p)
{
  if(p == &SENTINEL)
    return;
  else
  {
    free_node(p->next);
    free(p);
  }
}

int main(void)
{
    int sum;
    node* list =    
        make_node(1,
            make_node(2,
                make_node(3,
                    make_node(4,
                        make_node(5, &SENTINEL)
                    )
                )
            )
        );
    sum = sum_squares(list);

    printf("The sum of squares is: %d\n",sum);
  free_node(list);

  return 0;
} 

Il devrait être égal à 55 avec les nombres actuels

0
Gustav 15 nov. 2020 à 22:46

1 réponse

Meilleure réponse

Il y a quelques choses que vous devriez éditer!

  • Dans votre fonction sum_squares, votre cas de base vérifie si le nœud actuel list est égal à 0, mais vous devez vérifier s'il s'agit du nœud sentinelle.
  • Dans le cas récursif, vous devez utiliser pow(&list, 2). &list, cependant, renvoie l'adresse de l'argument list. Ce que vous recherchez est la valeur entière contenue dans la structure de nœud, que vous obtenez en utilisant l'opérateur ->. &list devient list->value.
  • Enfin, lorsque vous appelez récursivement votre prochaine fonction, vous lui passez le même nœud. Cela l'amènera à s'appeler infiniment sur le même nœud et à ne jamais parcourir la liste. Au lieu de simplement passer list à nouveau, vous devriez passer list->next !

Les modifications sont appliquées ci-dessous :

int sum_squares(node* list)
{
    if (list == &SENTINEL)
        return 0;

    return (pow(list->value, 2) + sum_squares(list->next));
}
0
Chrysophylaxs 15 nov. 2020 à 20:16