Discussion :

[Gildas777]

Bonjour tout le monde,

Voilà, j'ai un nouveau soucis : D!

J'ai un programme qui compile, je l'ai annoté, mais au sein de mon programme, je ne sais pas si le tri a bulle fonctionne correctement : il compile mais j'obtiens le même résultat 10 fois de suite dans mon dernier tri. Je ne comprends pas.

Pouvez vous jeter un coup d'oeil s'il vous plaît et m'aider à résoudre ce soucis?

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
 
 
PROGRAM exercice1 ;
 
type
tableau = array[1..150000] of integer;  (* tableau utilisé pour le premier et le deuxième tri*)
 
 
var
F: text ;                                 (*nom du fichier utilisé*)
k, m, pair : integer;                      (* nom d'entiers définsi commes entiers principaux de l'exercice*)
tab : tableau;                             (*valeur d'uitlisation du tableau principale*)
 
procedure tri(var t : tableau ; n:integer );  (* premier tri*)
var 
temp,i,j : integer ;                         (*valeurs locales*)
Begin
     pair:=0;
     for i:=1 to n do
     begin
         if odd (t[i])=false then
         begin
            temp:=t[i];
            t[i]:=t[pair+1];
            t[pair+1]:= temp;
            pair:= pair+1;
         end;
     end;
  for i:=2 to pair do
  begin
            temp := t[i];
            j := i-1;
            while (t[j]>temp) and (j>0) do
            begin
                 t[j+1]:=t[j] ;
                 j:=j-1;
            end;
            t[j+1]:=temp ;
       end;
 
End;
 
Procedure Tri_Fusion(Var t : tableau; g, d : integer);   (* deuxième tri*)
Var
   m, i, j, k : integer;                                 (*définition des valeurs locales*)
   s : tableau;
Begin                                                     (*procédure de tri*)
     If d > g Then
     Begin         
          m := (g + d) Div 2;
          Tri_Fusion (t, g, m);
          Tri_Fusion (t, m + 1, d);
 
	    For i := m DownTo g Do
              s[i] := t[i];
 
	    For j := m + 1 To d Do
              s[d + m + 1 - j] := t[j];
 
	    i := g; j := d;
          For k := g To d Do
          Begin
               If s[i] < s[j] Then
               Begin
                    t[k] := s[i];
                    i := i + 1;
               End
               Else
                   Begin
                         t[k] := s[j];
                         j := j - 1;
                   End;
          End;
     End;
End;
 
procedure tribulle(var t: tableau; n : integer);
var e: boolean; 
i,z: integer; 
begin 
      repeat
      e:= false;
      for i := 1 to n-1 do
      if t[i]>t[i+1] then
      begin
           z:=t[i];
           t[i]:=t[i+1];
           t[i+1]:=t[i];
           e:= true;
      end;
      until e = false;
end;
 
 
begin
     Assign(F,'D:\Documents\Dossier pascal\Travaux validés\serve_bulletin.txt');
     Reset(F);
     k := 1 ;
     while not eof(F) do
     begin
          ReadLn(F,tab[k]);
          writeln(tab[k]);
          k:=k+1;
     end;
     close(F);
     tri(tab,k-1);
     tri_fusion(tab,pair+1,k-1);
     tri (tab, k-1);
     tribulle (tab, k-1);
 
     writeln;
     for m := 1 to k-1 do
     writeln(tab[m]);
      readln;
end.

[krachik]

Bonjour

ej ne sais pas si le tri a bulle fonctionne correctement :

Pourquoi tu ne teste pas seul ce tri dans ton programme pour voir si ça fonctionne?

il compile mais j'obtiens le même résultat 10 fois de suite dans mon dernier tri. Je ne comprends pas

c'est à dire ?

[l_autodidacte]

il compile mais j'obtiens le même résultat 10 fois de suite dans mon dernier tri. Je ne comprends pas.

Ton problème se situe au niveau des boucles For.......Do que tu utilises sans délimiter leurs actions par
Begin
.............
.............
End;
si bien que ces boucles s'imbriquent et le résultat sera multiplié par le nombre de ces boucles.