Discussion :

[DBA_OCP]

Bonjour,

J'ai vu brièvement FIFO en classe et j'ai essayé de faire le programme pour tester. Je vous demande si c'est bien comme ça qu'il faut faire ??

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
 
#include<stdio.h>
#include<stdlib.h>
 
 
 
typedef struct elmt
{
	int e;
	struct elmt *next;
}file;
 
 
//PROTOTYPES
file *emfiler(file *f,int a);
file *defiler(file *f);
void afficher(file *f);
file *kiem(file *f,int k);
 
 
 
//AJOUTER UN ELEMENT EN TETE (FIFO)
file *emfiler(file *f,int a)
{
       file *tmp;
       tmp=malloc(sizeof(file));
       tmp->e=a;
       tmp->next=f;
       return tmp;
}
 
 
 
file *kiem(file *f,int k)
{
        file *tmp;
        tmp=f;
        if
        (k==1)
        return tmp;
        else
        return (kiem(tmp,k-1)->next);
}
 
 
 
 
int longueur(file *f)
{
    file *tmp;
    tmp=f;
    if(tmp==NULL)
		return 0;
    else
		return (longueur(tmp->next)+1);
}
 
 
 
 
//SUPPRIMER UN ELEMENT DE LA QUEUE (FIFO)
file *defiler(file *f)
{
	kiem(f,longueur(f)-1)->next=NULL;
    return f;
}
 
 
 
void afficher(file *f)
{
     file *tmp;
     tmp=f;
 
      printf("\n\n");
     if(tmp==NULL)
     printf("AUCUN ELEMENT DANS LA LISTE\n");
     else
     {
         while(tmp!=NULL)
         {
                          printf("\n%d",tmp->e);
                          tmp=tmp->next;
         }
     }
}
 
main()
{
	file *f=NULL;
	f=emfiler(f,10);
	f=emfiler(f,20);
	f=emfiler(f,30);
	//f=defiler(f);
	afficher(f);
	printf("\n");
	system("pause");
}

[diogene]

Vu que pour une file, tu ajoutes les éléments à une extrémité et tu les enlèves à l'autre, il est commode de définir la file par deux pointeurs : la tête et la queue. Ceci évite de rechercher la position de la queue à chaque fois.

Code actuel :
Pour ta fonction enfiler, tu dois tester la "réussite" de l'allocation dynamique

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
file *emfiler(file *f,int a)
{
       file *tmp;
       tmp=malloc(sizeof(file));
       if(tmp !=NULL)
       {
          tmp->e=a;
          tmp->next=f;
       }
       return tmp;
}

defiler devrait détruire le chaînon créé par enfiler et renvoyer simplement l'information qu'il stockait e.

Evite les appels récursifs si possible : le temps d'exécution en est affecté et tu te retrouveras limité dans la longueur de ta liste par la dimension de la pile.
Ici, en plus, une version itérative est très facile à coder, sûre et rapide.

[DBA_OCP]

diogene, tu oublis toujours que je suis un débutant et tu me dis des trucs que j'ai du mal à bien comprendre

[diogene]

Comme je t'ai dit plusieurs trucs, dis moi lesquels je dois expliciter

[DBA_OCP]

A part le test de "tmp" ben tout....

Je suis encore loin du stade pour mettre en évidence le temps d'exécution et autres..

La récursivité je l'utilise parce que c'est mon dernier cour et je dois encore savoir comment ça marche....donc je test

[diogene]

A tes fonctions enfiler et defiler, tu dois fournir la FIFO concernée. A l'heure actuelle, ta FIFO est repérée par l'adresse du premier chaînon (la tête). A chaque fois que tu ajoutes un élément tu places la tête de ta liste sur le nouveau chaînon créé par enfiler.
On est d'accord

A chaque fois que tu veux retirer un chaînon, tu dois parcourir la liste à partir de la tête jusqu'à l'avant-dernier élément pour une liste simplement chaînée (c'est ton cas) pour retirer le dernier élément (la queue) et mettre à NULL le pointeur next de l'ex-avant-dernier. Il faut prendre en compte les trois cas :
- la liste peut être vide
- la liste n'a qu'un élément
- la liste a plus d'un élément

Pour une liste simplement chaînée, Il est plus simple d'insérer en queue de la liste : tu as besoin simplement de chercher le dernier élément et d'ajouter le nouveau derrière lui et de retirer les éléments en tête de la liste ce qui fait simplement modifier la tête de la liste.
Si tu repères ta FIFO à la fois par la tête et par la queue, en mettant les deux dans un struct pour repérer la liste, tu n'as plus besoin de chercher la queue à chaque fois.

[smpinf]

Tu dois monsieurs nous préciser bien si tu veux utiliser les files ou bien les listes simplement chainées(ton cas), car cette derniere ne fonctionne ni en mode FIFO ni en mode LIFO, puisque dans une liste chainé on peut supprimer (et je dit bien supprimer et pas retirer)un element dans n'importe quelle position,alors que pour les files on ne peut que retirer(pour le supprimer) le premier élément entré puis le suivant puis....
Sinon pour les files tu peux utiliser l'exemple suivant:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
 
//exemple pour ajouter un element dans une file
#include <stdio.h>
#define max 10
int file[max],queue=0,sommet=0;
void ajouter (int valeur)
{
  if (queue-sommet<max)  //on teste si la file n'est pas complétement remplie
   {
     file[queue%max]=valeur;
       queue++;
  }
}

et c'est à toi de decouvrir la suite du code: la fonction pour retirer un element de la file, la fonction qui teste si la file est vide....
et bonne chance!!