Implémenter un algorithme (méthode de gestion de stockage) de FIFO et LIFO

Version imprimable

10/12/2008, 15h34
madaou

Implémenter un algorithme (méthode de gestion de stockage) de FIFO et LIFO

salut à tout le monde
Je voudrais savoir comment inserer une liste chainée par la méthode 'First in, First out', méthode de gestion de stockage (FIFO)
et merci
10/12/2008, 16h59
darrylsite

Prend au moins le soin d'ecrire dans un français correct. pas de sms.
Montre nous le code que tu as dejà produit, ensuite on va essayer de t'aider.

pardon je saiss pas bien parler français
voila mon code

Code:

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
program ff;
uses wincrt;
type
  PCellule = ^Cellule;
  Cellule = record
    valeur: string;
    suivant: PCellule;
  end;
 
var debut,liste,courant,p: PCellule;
   valeur: string;
   rep:char;
begin
  new(debut);
  courant:=debut;
repeat
writeln ('entez le nom');
readln(valeur);
  courant^.valeur := valeur;
  courant^.suivant := liste;
  liste := courant;
writeln ('autre element:o/n ?');
readln (rep);
if rep='o' then
begin
new (courant^.suivant);
courant:=courant^.suivant;end
else courant^.suivant:=nil;
until rep='n';
 
 
 p := liste;
  while p <> nil do
  begin
    writeln(p^.valeur);
    p := p^.suivant;
  end;
 
 
end.

il te suffit de sortir liste hors du repeat.

Code:

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
 
 
program Project1;
 
{$mode objfpc}{$H+}
 
uses
  Classes, SysUtils
  { you can add units after this };
 
type
  PCellule = ^Cellule;
  Cellule = record
    valeur: string;
    suivant: PCellule;
  end;
 
var debut,liste,courant,p: PCellule;
   valeur: string;
   rep:char;
begin
  new(debut);
  courant:=debut;
{-----------------ici--------------------}
  liste:=debut;
{----------------------------------------}
repeat
writeln ('entez le nom');
readln(valeur);
  courant^.valeur := valeur;
  courant^.suivant := nil;
writeln ('autre element:o/n ?');
readln (rep);
if rep='o' then
begin
new (courant^.suivant);
courant:=courant^.suivant;end
else courant^.suivant:=nil;
until rep='n';
 
 
 p := liste;
  while p <> nil do
  begin
    writeln(p^.valeur);
    p := p^.suivant;
  end;
 
readln;
end.

11/12/2008, 10h53
madaou

merci darrylsite
mais le probléme reste
commet pouvons-nous transformer cett algorithme a la methode last in - first out (lifo);
merci
11/12/2008, 12h59
darrylsite

non aux MP. Pour des question, pose les sur le forum.
Pour la methode LIFO, il te suffit d'ajouter l'élement en tete de liste et retirer un element en tete de liste.
Je te conseil de faire des procedure separé pour chaque cas (FIFO, LIFO).
Propose nous un code et on essaiera de t'aider.
11/12/2008, 18h23
droggo

Hoe,

Pour tous les algorithmes, et encore plus pour ceux qui concernent les listes chaînées et autres piles, FIFO, LIFO, etc. le mieux est d'en revenir aux bons vieux principes, à savoir : papier + crayon.

Tu dessines quelques cases contenant des valeurs (les données), avec des flèches les reliant (qui représentent donc les pointeurs), et tu regardes ce qui se passe quand tu enlèves/ajoutes un élément, du bon côté selon le type de ta pile, sans oublier les cas limites (ajout d'un premier élément dans une pile vide, enlever le dernier élément d'une pile).
Une fois que tu a bien compris et noté comment ça se passe, écrire le code est un jeu d'enfant.

:oops:
ok voila mon essaye dans la method (lifo) last in first out

Code:

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
program lust;
uses wincrt;
                         type
                              pointeur=^per;
                              per=record           
                              s:string;
                              suivant:pointeur;
                               end;
var debut,courant,p:pointeur;
    i:integer ;
    rep:char;
 
 
 
  begin
  new (debut);
  courant:=debut;
 
  repeat
  writeln ('donne le nom');
  readln(courant^.s);
  new(courant^.suivant);
  courant^.suivant:=nil;
  readln (rep);
  writeln ('outre element o/n ? ');
  if rep='o' then
  begin
  new(p);
  writeln ('donne le nom');
  readln(courant^.s);
  p^.suivant:=debut;
  debut:=p;
  end;
  until rep='n';
 
  while courant <>nil do
  begin
 writeln (courant^.s);
 courant:=courant^.suivant;
 end;
  end.

merci a tout

Bonjour,

Tu peux t'en sortir avec simplement les deux pointeurs Debut et Courant. ;)
La boucle donnerait quelque chose comme ceci :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
  courant := Nil;
  repeat
    New(debut);
    debut^.suivant := courant;
    Write('Donne le nom : ');
    ReadLn(debut^.s);
    Write('Autre élément ? o/n : ');
    ReadLn(rep);
    if rep in ['o','O']
       then
         courant := debut;
  until rep in ['n','N'];
 
  WriteLn('Affichage de la liste :');
  while debut <>nil do
    begin
      writeln (debut^.s);
      debut:=debut^.suivant;
    end;

;)

12/12/2008, 21h09
madaou

merci Beaucoup alcotiz.

Hai,

Citation:

Envoyé par madaou

:oops:
ok voila mon essaye dans la method (lifo) last in first out

Code:

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
program lust;
uses wincrt;
                         type
                              pointeur=^per;
                              per=record           
                              s:string;
                              suivant:pointeur;
                               end;
var debut,courant,p:pointeur;
    i:integer ;
    rep:char;
 
 
 
  begin
  new (debut);
  courant:=debut;
 
  repeat
  writeln ('donne le nom');
  readln(courant^.s);
  new(courant^.suivant);
  courant^.suivant:=nil;
  readln (rep);
  writeln ('outre element o/n ? ');
  if rep='o' then
  begin
  new(p);
  writeln ('donne le nom');
  readln(courant^.s);
  p^.suivant:=debut;
  debut:=p;
  end;
  until rep='n';
 
  while courant <>nil do
  begin
 writeln (courant^.s);
 courant:=courant^.suivant;
 end;
  end.

merci a tout

Je n'ai pas corrigé ton code, mais un conseil tout de même : prends l'habitude de présenter ton code correctement : indentation régilière et cohérente, lignes vides pour aérer en séparant les blocs logique, commentaires.

Voici ton code remis en forme (par exemple, d'autres options sont possibles, en particulier le décalage pour chaque niveau d'indentation).
Je n'ai pas pris la peine d'ajouter des commentaires, à toi de le faire.

Code:

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
program lust;
 
uses wincrt;
 
type
  pointeur = ^per;
  per = record           
    s: string;
    suivant : pointeur;
  end;
 
var 
  debut, courant, p : pointeur;
  i : integer;
  rep : char;
 
begin
  New(debut);
  courant := debut;
 
  repeat
    Writeln('donne le nom');
    Readln(courant^.s);
    New(courant^.suivant);
    courant^.suivant := nil;
    Readln(rep);
 
    Writeln('outre element o/n ? ');
    if rep = 'o' then
    begin
      New(p);
      Writeln('donne le nom');
      Readln(courant^.s);
      p^.suivant := debut;
      debut := p;
    end;
  until rep = 'n';
 
  while courant <> nil do
  begin
    Writeln(courant^.s);
    courant := courant^.suivant;
  end;
end.

Tout de suite plus lisible, non ? :)

12/12/2008, 22h20
madaou

merci droqqo .
mais commet cree procédure permettant d'inverser l'ordre de la liste.
merci a tout
12/12/2008, 23h18
droggo

Kei,

Citation:

Envoyé par madaou

merci droqqo .
mais commet cree procédure permettant d'inverser l'ordre de la liste.
merci a tout

Ben, comme d'habitude, c'est à dire papier + crayon. :)

Citation:

Envoyé par madaou

merci droqqo .
mais commet cree procédure permettant d'inverser l'ordre de la liste.
merci a tout

tu veux dire un truc du genre 1-2-3-4 en 4-3-2-1?
c'est pas une question de langage mais plutot d'algorithme.
Voici un pseudo-code
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 //courant est la chaine à inverser //nouveau permet d'allouer de la memoire liste=nil; tant que (courant<>nil) nouveau(second); second.s=courant.s; second.suivant=liste; liste=second; courant=courant.suivant fin tant que //liste est la nouvelle chaine tirée de courant

13/12/2008, 23h04
madaou

no je rechrech un procedure qui affiche inverser l'ordre de la liste.
inverser l'ordre de 1 er affichage.
merci
14/12/2008, 01h03
droggo

Koe,

Pour inverser l'affichage, il faut inverser la pile, du moins avec des traitements basiques comme tu le fais, sinon il faut implémenter des fonctions qui permettent de le faire autrement, mais on sort de l'utilisation d'une pile FIFO simplement chaînée comme la tienne.
Une solution simple serait de faire une liste doublement chaînée (chaque cellule pointe vers l'avant et l'arrière), mais c'est du luxe. :)

implémenter un algorithme

slt tout
mi mnt :
j'ai outre probleme tri de la list
commet cree un programme qui permettant de trier par ordre alphabétique la liste chainée,
voila mon code

Code:

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
program lust;
uses wincrt;
    type
       pointeur=^per;
       per=record
       s:string;
       svt:pointeur;
       end;
var debut,courant,t:pointeur;
    i:integer ;
    rep:char;
    s,p:string;
                            procedure aff (s:string);
                            begin
                            courant:=debut;
                            while courant <>nil do
                            begin
                            writeln (courant^.s);
                            courant:=courant^.svt;
                            end;
                            end;
  begin
  new (debut);
  courant:=debut;
  repeat
 
  write ('donne le mot:   ');
  readln(courant^.s);
 
  write (' outre siesie:o\n ?   ');
  readln (rep);
  if rep='o' then
  begin
   new(courant^.svt);
  courant:=(courant^.svt);
  end
  else 
  courant^.svt:=nil ;
  until rep='n';
  aff (s);
  courant:=debut;
  while courant<>nil do
  begin
  if courant^.s<courant^.svt^.s then
  begin
  p:=courant^.s;
  courant^.s:=courant^.svt^.s;
  courant^.svt^.s:=p;
  end
  else
  courant:=courant^.svt;
  end;
  aff (s);
 
 
  end.

merci a tout

18/12/2008, 13h20
droggo

Koe,

Au risque de me répéter (:)) : soigner la présentation du code. Ça te sera utile, et c'est également utile pour les lecteurs.
Le moyen est de le faire à mesure de l'écriture du code, ce qui n'est pas difficile, la plupart des IDE permettant de le faire de manière très simple, et quasi automatique.

Pour en revenir à ta question, ce sujet parle depuis le début de piles. Une pile, LIFO ou FIFO ne se trie pas, ta question à propos du tri n'a donc aucun sens dans ce cadre.

Si tu y tiens, ouvre un nouveau sujet, parlant de liste.