Crowdly

Soient les fonctions suivantes :

void fonction1(t_cell *ptr_c)
{
       printf("%d ", ptr_c->value);
       fonction1(ptr_c->next);
}

void fonction2(t_list mylist)
{
    fonction1(mylist.head);
}

Quelle est l'affichage obtenu si on appelle la fonction2 sur la liste suivante ?

42 63 19

19 63 42, en boucle

19 63 42 segmentation fault

42 42 42

Soient les fonctions suivantes :

void fonction1(t_cell *ptr_c)
{
       printf("%d ", ptr_c->value);
       fonction1(ptr_c->next);
}

void fonction2(t_list mylist)
{
    fonction1(mylist.head);
}

Quelle est l'affichage obtenu si on appelle la fonction2 sur la liste suivante ?

42 63 19

19 63 42, en boucle

19 63 42 segmentation fault

42 42 42

Let be the following functions :

void fonction1(t_cell *ptr_c)
{
       printf("%d ", ptr_c->value);
       fonction1(ptr_c->next);
}

void fonction2(t_list mylist)
{
    fonction1(mylist.head);
}

What is the display obtained if we call the function2 on the following list ?

42 63 19

19 63 42, en boucle

19 63 42 segmentation fault

42 42 42

we want to call this function from the main program, for a non-empty list named list_1.

Consider the following function, which recursively searches for the maximum in a list :

int maxRecList(t_cell *cell, int cur_max)
{
    if (cell == NULL) {
        return cur_max;
    }
    if (cell->value > cur_max) {
        cur_max = cell->value;
    }
    return maxRecList(cell->next, cur_max);
}

Which main program is used to make this call to obtain the correct result ?

(we assume that all the right #includes have been made)

int main()
{
  t_list list_1;
  int max;
  max = maxRecList(list_1, 0);
}

int main()
{
  t_list list_1;
  int max = maxRecList(list_1.head, list_1.head->value);
}

int main()
{
  t_list list_1;
  int max;
  max = maxRecList(&list_1.head, max);
}

int main()
{
  t_list list_1;
  int max;
 
  max = maxRecList(list_1, max);
}

Let be the following functions :

void fonction1(t_cell *ptr_c)
{
       printf("%d ", ptr_c->value);
       fonction1(ptr_c->next);
}

void fonction2(t_list mylist)
{
    fonction1(mylist.head);
}

What is the display obtained if we call the function2 on the following list ?

42 63 19

19 63 42, en boucle

19 63 42 segmentation fault

42 42 42

On souhaite 'détruire' une liste, c'est à dire libérer (free()) toutes les cellules qui la constituent

on vous propose la fonction suivante :

void destroyList(t_list *ptr_list)
{
   t_cell *cur;
   t_cell *prev;
   while (ptr_list->head !=NULL)
   {
      cur = ptr_list->head;
      prev = cur;
      while (cur->next != NULL)
      {
           prev = cur;
           cur = cur->next;
      }
      prev->next = NULL;

      free(cur);
    }

Que pouvez-vous dire de cette fonction ? (plusieurs réponses)

Cette fonction effectue beaucoup de parcours de liste, on peut la rendre plus efficace

cette fonction est itérative

Cette fonction libère effectivement bien la liste

Cette fonction est récursive

Cette fonction ne libère pas la première cellule - le programme plante !

We want to 'destroy' a list, i.e. free() all the cells in it.

we propose the following function :

void destroyList(t_list *ptr_list)
{
   t_cell *cur;
   t_cell *prev;
   while (ptr_list->head !=NULL)
   {
      cur = ptr_list->head;
      prev = cur;
      while (cur->next != NULL)
      {
           prev = cur;
           cur = cur->next;
      }
      prev->next = NULL;

      free(cur);
    }

What can you say about this function? (several answers)

This function does a lot of list browsing, so we can make it more efficient

this function is iterative

This function does not release the first cell - the program crashes!

This function effectively frees the list

This function is recursive

the following function performs a chain at the head of the list (adds a new cell to the head) :

(we assume that the function t_cell *createCell(int); creates a new individual cell)

void addHead(t_list *p_list, int val)
{
    t_cell *new = createCell(val);
    p_list->head = new;
    new->next = p_list->head;

la fonction suivante effectue bien un chaînage en tête de liste (ajoute une nouvelle cellule en tête) :

(on suppose que la fonction t_cell *createCell(int); crée bien une nouvelle cellule individuelle)

void addHead(t_list *p_list, int val)
{
    t_cell *new = createCell(val);
    p_list->head = new;
    new->next = p_list->head;

True

False