Discussion :

[gadalla]

Salut à tous,
je viens de faire un essai de tri à bulle mais ça n'a pas marché.
SVP aidez-moi à le corriger et dites-moi si mon idée est correcte ou non.

L'erreur est en rouge

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 trie;
uses wincrt;
type
tab = array[1..100] of integer;
var
t:tab;
n,j:integer;
procedure lecture(var t:tab;var n:integer);
var
i:integer;
begin
writeln('donnez n');
readln(n);
for i := 1 to n do
readln(t[i]);
end;

procedure tri_bull(var t:tab;var n:integer;var j : integer);
var
i,aux:integer;
begin
for i :=2 to n do
    if t[j-1]> t[j] then begin  aux :=t[j];
                                t[j-1] := t[j];
                                t[j] := aux ;
                                end;
    if n <>i then tri_bull(t,n-1, j+1 );
    end;

procedure affichage(var t:tab;n:integer);
var
i:integer;
begin
for i := 1 to n do
writeln(t[i]);
end;
begin
lecture(t,n);
affichage(t,n);
end.

[droggo]

Pei,

Le côté récursif est-il imposé par l'énoncé ?

C'est une absurdité de faire un tri à bulles récursif, c'est bien un exemple de plus où la récursivité est plus nuisible qu'utile.

[imipiya]

Vous n'avez pas fait appel à la procédure tri_bull dans le prog.principal.

[katrena99]

Pei,

Le côté récursif est-il imposé par l'énoncé ?

C'est une absurdité de faire un tri à bulles récursif, c'est bien un exemple de plus où la récursivité est plus nuisible qu'utile.

J'ai déjà eu affaire à pire! Une procédure faisant la somme de deux entiers récursivement!

gadalla, ta pocédure tri_bull est complètement fausse :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
procedure tri_bull(var t:tab;var n:integer;var j : integer);
var
i,aux:integer;
begin
for i :=2 to n do
    if t[j-1]> t[j] then begin  aux :=t[j]; //j a une valeur inconnue jusque là, probablement 0//
                                t[j-1] := t[j]; //donc ici t[-1] va se voir affecter la valeur de t[0]//
                                t[j] := aux ;//évidemment on assiste à une permutation ici//
                                end;//et voilà que les mêmes opérations sont répétées n-1 fois (boucle pour)//
    if n <>i then tri_bull(t,n-1, j+1 );
    end;

[JetliMohamed]

ta procedure tri à bulle est completement fausse vraiment car le compteur (j) il est initailement à la position (c'est automatiquement par pascal)quand vou dise if t[j-1]> t[j] then le compteur vas se pointer sur la position -1 ce qui est illogique alors ta procedure est carément fausse.
a sous titre de récurcivité votre appel récurcif est encore hors jeu pourquoi?
On sait que la récurcivité est l'opposé de l'itération alors que tu fait c'est une itération au début de la procedure et ton finish est récurcivité.
Alors là je te conseil de bien choisi votre methode de résonnement puis commence ton travail pas seulement ça il faut que tu lire bien des cours de récurcivité dans developpez http://recursivite.developpez.com/

bon courage et merci a tous.(Jetli_Mohamed)

[lo_pascal]

Le code suivant est fonctionnel:

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 Tribulles;
uses wincrt;
const N = 9;  {Limite supérieure de tableau}
type TTab = array [1..N] of integer;   { TTab : Type Tableau } 
var Tab : TTab ; 
 
procedure Tribull(var Tab:TTab;n,i:integer) ;
{Implantation Pascal de l’algorithme} 
var j, t, temp : integer;
begin 
  if i >=1 then
  begin
  for j := 2 to i do 
   if Tab[ j-1 ] > Tab[ j ] then
     begin
      temp := Tab[j-1]; 
      Tab[j-1] := Tab[j]; 
      Tab[j] := temp;
      end;
   tribull(tab,n,i-1);
  end; 
end;
procedure Remplir(var Tab:TTab) ;  
var i : integer;  { i : Indice de tableau de N colonnes }
begin 
 Randomize;
 for i := 1 to N do
  tab[i]:=random(10);
end;
procedure Affichage(Tab:TTab) ;  
{ Affichage des N nombres dans les colonnes } 
var i : integer; 
begin 
 writeln('_____________________________________________________');
  for i:= 1 to N do
   write(Tab[i] : 3, ' | ');writeln;
 writeln('_____________________________________________________');
End;
{Programme Principal}
begin 
  Remplir(Tab);
  writeln;
  writeln('TABLEAU NON TRIE'); 
  Affichage(Tab); 
  Tribull(Tab,n,n);
  writeln;
  writeln('TABLEAU TRIE');
  Affichage(Tab);
 
end.

[droggo]

Siu,

Pense à mettre les balises code (regarde quelques sujets, tu tomberas quasi forcément sur une explication).

[zizo89]

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
Program Tri_a_bulle;
uses wincrt;
type
tab=array[1..100]of integer;
var
V:tab;
p:integer;
 
Procedure Saisie(var x:integer);
begin
writeln('Donner le nombe d''elements du tableau');
readln(x);
if x<=0 then
saisie(x);
end;
 
Procedure Remplir(var T:tab; n:integer);
begin
if n>0 then
begin
Writeln('Donner l''element N°',n,'=   ');
Readln(T[n]);
Remplir(t,n-1);
end;
end;
 
 
Function Tri(t:tab; n:integer):string;
var
i:integer;
begin
Tri:='0';
repeat
i:=i+1;
until (T[i]>T[i+1]) or (i=n-1);
if i>=n-1 then
Tri:='1';
end;
 
Procedure Permuter(var x,y:integer);
var
z:integer;
begin
z:=x;
x:=y;
y:=z;
end;
 
 
Procedure Trier(var T:tab; n:integer);
var
p:boolean;
i:integer;
begin
if tri(T,n)='1' then
begin
writeln('Le Tableau est déja Trié')
end
else
begin
repeat
p:=False;
for i:=1 to n-1 do
begin
if T[i]>T[i+1] then
begin
Permuter(T[i],T[i+1]);
p:=true;
end;
end;
until (p=False);
end;
end;
 
 
Procedure Afficher(T:tab;n:integer);
var
i:integer;
begin
for i:=1 to n do
begin
write(T[i],'  ');
end;
end;
 
BEGIN
Saisie(p);
Remplir(V,p);
Trier(V,p);
Afficher(V,p);
END.