Discussion :

[Dunk]

Bonjour

Voici mon problème : je cherche à concaténer 2 listes par l'intermédiaire d'une fonction.
Voici ce que j'ai :

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
 
Type
   liste_elts=^doublet;
   doublet=record
      element:integer;
      suivant:liste_elts;
   end;
 
Function concat(l1,l2:liste_elts):liste_elts;
Var
   l:liste_elts;
Begin
   l:=l1;
   while (l^.suivant <> nil) do
      l:=l^.suivant;
   l^.suivant:=l2;
   concat:=l1;
End;

Bon, en gros : je me place à la fin de la liste l1, et je raccord la liste l2 au bout de celle-ci. Je pense que ça, ça ne pose pas de problème.
Mon problème est dans le renvoi de concat : que dois-je renvoyer à la fonction ? l1 ? l ?
Visiblement, d'après mes tests, ça serait encore autre chose, mais je ne vois pas quoi...
Actuellement :
* lorsque je renvoie l1, il me renvoie le l1 original
* lorsque je renvoie l, il me renvoie l2...


Merci de votre aide...

[M.Dlb]

Pour moi ta fonction marche, même si je ne l'ai pas testé. l1 et l2 ne sont pas modifiés, ce qui est normal, et la valeur que tu dois retourner est bien l1. La boucle m'a l'air bonne, tu t'arretes sur le dernier élément et tu assignes le champ suivant à l2.

Es-tu sûr que l1 n'est pas modifié ? Normalement le début est le même, juste la fin change. Quant à l2 tu peux le faire pointer à null, après l'appel à ta procédure, si tout s'est bien passé tu n'auras pas de perte de données...

[Dunk]

Il y a une chose qui est bizarre...
En fait, pour tester cette fonction :
* je fais afficher l1
* je fais afficher l2
* je concatène les 2 listes
* je fais afficher l3 (la nouvelle liste)
* j'utilise une autre fonction que j'ai codé plus haut dans mon devoir pour avoir la longueur de la liste... et en l'occurence, cette fonction me renvoie comme longueur de l3 : la longueur de l1
Qui plus est, la liste l3 est strictement identique à la liste l1.

J'ai l'impression qu'en fait, quand je fais "concat:=l1", il me met dans concat la liste l1 originale... sans y avoir rajouter quoique ce soit...
Je me demande si le nil de l1 est bien supprimé...

[M.Dlb]

Attention, l1 ne soit pas être modifiée car c'est la tête de la liste. Il faut bien que le dernier pointeur suivant de l1 pointe sur l2, ce qui apparemment est bien effectué par ta fonction. A la limite ca sert à rien d'utiliser une fonction, puisque l1 n'a pas changé, juste une procédure suffit (enfin conceptuellement).

Peux-tu nous donner tout le code si il n'est pas trop long ? Sinon juste la fonction appelante et la déclaration des variables.

[Dunk]

Bon, ça avance...
Plusieurs choses :
* je trouve aussi qu'une procédure serait mieux... mais c'est un devoir que j'ai à faire, et donc je fais ce qu'on me demande... :-S
* après encore des recherches, j'ai trouvé autre chose : en fait, je ne m'en étais pas rendu compte, mais il y avait un problème avec l1...
C'est assez long à expliquer, et moi-même j'ai pas tout compris, mais en fait, en résumé :
1. quand j'affiche l1 et l2 avant d'appeler concat, tout va bien
2. ensuite, je fais : l3:=concat(l1,l2);
et là, c'est magique : l1 est modifiée... en la concaténation de l1 et l2 !!
l2 n'est pas modifiée... et l3... ça correspond à la concaténation (tenez vous bien) de la dernière cellule de l1 et de tout l2...
Un truc auquel je pense seulement maintenant : j'ai l1 et l2 en variables globales dans le programme... et l1 et l2 en arguments dans la fonction... et j'ai bien peur que dans la fonction, ça ne soit pas considéré comme des variables locales...

Je vais voir ça, je reviens

[M.Dlb]

Normalement, les arguments d'une procédure sont prioritaires sur les variables globales (enfin je crois). essaye en les renommant, on sait jamais !

[Dunk]

Bon, je comprends plus grand chose...
Je vais mettre tout le code qui importe.
Les noms des variables sont différents, j'avais simplifié en espérant que ça suffirait, mais bon...

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
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
 
Program DH2EXO2;
Uses CRT;
Type
    mot=array[0..21] of integer;
    liste_mots=^doublet;
    doublet=record
                  info:mot;
                  suiv:liste_mots
    end;
    tableau_de_liste_mots=array[0..100] of liste_mots;
Var
   u,x,y,w:mot;
   l1,l2,l3,l4,liste,sommet:liste_mots;
 
 
{*********************************************************************}
{***   Procedure d'affichage d'un mot   ***}
Procedure disp_mot(u:mot);
var
   i:integer;
begin
     for i:=1 to u[0] do
         write(u[i],' ');
     writeln;
end;
{*********************************************************************}
 
{*********************************************************************}
{***   Procedure d'affichage d'une liste de mots   ***}
procedure disp_list(l:liste_mots);
var
   i:integer;
begin
     i:=1;
     while (l <> nil) do
           begin
                write('Mot nø',i,' : ');
                disp_mot(l^.info);
                i:=i+1;
                l:=l^.suiv;
           end;
end;
{*********************************************************************}
 
 
{*********************************************************************}
{***   Fonction concat   ***}
Function concat(l1,l2:liste_mots):liste_mots;
var
   la,lb,l:liste_mots;
begin
     la:=l1;
     lb:=l2;
     l:=la;
     while (l^.suiv <> nil) do
           l:=l^.suiv;
     l^.suiv:=lb;
     concat:=l;
end;
{*********************************************************************}
 
 
begin
     clrscr;
     {***   Test est_bien_forme   ***}
     u[0]:=5;
     u[1]:=1;
     u[2]:=1;
     u[3]:=-1;
     u[4]:=-1;
     u[5]:=1;
     x[0]:=5;
     x[1]:=1;
     x[2]:=1;
     x[3]:=-1;
     x[4]:=-1;
     x[5]:=-1;
     y[0]:=5;
     y[1]:=1;
     y[2]:=-1;
     y[3]:=1;
     y[4]:=-1;
     y[5]:=-1;
     construire(x,y,w);
     {***   La procédure construire construit le mot w à partir de x et y tel que : w=(x[0]+y[0],1,x[1],...,x[x[0]],y[1],...,y[y[0]])  ***}
     {***   A noter que la composante d'indice 0 d'un mot contient sa longueur   ***}
     {***   on construit une liste avec les mots x,y et w   ***}
     new(liste);
     liste^.info:=w;
     liste^.suiv:=nil;
     sommet:=liste;
     new(liste);
     liste^.info:=y;
     liste^.suiv:=sommet;
     sommet:=liste;
     new(liste);
     liste^.info:=x;
     liste^.suiv:=sommet;
     {***   liste est construite   ***}
     disp_list(liste);
     {***   Test concat   ***}
     {***   on construit l1 et l2   ***}
     writeln;
     writeln('***************** Test concat ***');
     l1:=liste;
     write('l1 : ');
     disp_list(l1);
     new(l2);
     l2^.info:=w;
     l2^.suiv:=nil;
     sommet:=l2;
     new(l2);
     l2^.info:=y;
     l2^.suiv:=sommet;
     writeln;
     write('l2 : ');
     disp_list(l2);
     {*** l1 et l2 sont construites   ***}
     writeln;
     writeln('Après appel de concat...');
     l3:=concat(l1,l2);
     writeln;
     writeln('l1 :');
     disp_list(l1);
     writeln;
     writeln('l2 :');
     disp_list(l2);
     writeln;
     writeln('l3 :');
     disp_list(l3);
     {writeln;
     write('l3 : ');
     disp_list(l3);
     writeln('Longueur de la liste concatenee : ',longueur(l3));
     {***   Fin test concat   ***}
     readkey;
end.

Voila...