Discussion :

[madaou]

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

[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.

[madaou]

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

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
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.

[darrylsite]

il te suffit de sortir liste hors du repeat.

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
 
 
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.

[madaou]

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

[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.

[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.

[madaou]

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

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
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

[Alcatîz]

Bonjour,

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

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
  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;

[madaou]

merci Beaucoup alcotiz.

[droggo]

Hai,

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

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
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 :

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
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 ?

[madaou]

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

[droggo]

Kei,

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.

[darrylsite]

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 :

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

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

[madaou]

no je rechrech un procedure qui affiche inverser l'ordre de la liste.
inverser l'ordre de 1 er affichage.
merci

[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.

[madaou]

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 :

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
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

[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.