Difficulté pour faire mon premier algorithme de tri

**TechnoForce** · 17/09/2015, 16h53

Bonjour, étant étudiant en L2 d'informatique, on nous a demandé d'écrire un algorithme utilisant des fonctions que nous avions créer plus en avant du cours. Malheureusement malgré diverses tentatives et plusieurs programmes écrit, je n'y arrive pas. Pourriez-vous m'aider pour me montrer où se situe mon erreur?
Merci d'avance pour vos réponses.

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
   PROCEDURE Decale_Droite(Tab : IN OUT T_Tabint; K : Natural) IS
      Mem1, Mem2: Integer;
   BEGIN
      Mem1 := Tab(k+1);
      Tab(K+1) := Tab(K);
      FOR I IN K+2..T_Tabint'last-1 LOOP
         Mem2 := Tab(I);
         Tab(I) := Mem1;
         Mem1 := Mem2;
      END LOOP;
      Tab(N) := Mem1;
   END Decale_Droite;
---------------------------------------------------------------------------
   PROCEDURE Remplace_Int (Tab : IN OUT T_Tabint ; K : Integer) IS
      Compt : Integer := T_Tabint'First;
   BEGIN
      WHILE K > Tab(Compt) LOOP
         Compt:= Compt+1;
      END LOOP;
      IF Compt = T_Tabint'First THEN
         Decale_Droite(Tab, Compt);
      ELSE
         Decale_Droite(Tab, Compt-1);
      END IF;
      Tab(Compt) := K;
   END Remplace_Int;
---------------------------------------------------------------------------
   PROCEDURE Tri_Selection(Tab : IN OUT T_Tabint) IS
      Compt : Natural := T_Tabint'First;
      Mini : Integer := Tab(T_Tabint'First);
      Indmini : Natural ;
      Memo : integer;
   BEGIN
      WHILE Compt < T_Tabint'Last LOOP
         FOR I IN Tab(Compt)..T_Tabint'Last LOOP
            IF Mini > T_Tabint'Last THEN
               Mini := Tab(I);
               Indmini := I;
            END IF;
         END LOOP;
         IF Indmini /= T_Tabint'Last THEN
            Memo := Tab(T_Tabint'Last);
         END IF;
         Afftab(Tab);
         IF Indmini /= Compt THEN
            Decale_Droite(Tab, Compt);
            Afftab(Tab);
            Tab(Compt) := Mini;
            IF Indmini < T_Tabint'Last THEN
               Tab(Indmini+1) := Memo;
               Afftab(Tab);
            END IF;    
         END IF;
         Compt := Compt+1;
         Mini := Tab(Compt);
      END LOOP;
   END Tri_Selection;

Invité · 17/09/2015, 21h21

Bonjour,

Je sais pas ou et ton erreur.
Je pige pas que tu ai écrit tout ça sans t'en sortir.

Voilà juste une image Ada du pseudo code de Wikipedia sur le tri par selection.

Code ada :

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
 
 
 
N : le dernier index du tableau passé en paramètre à la procédure.
 
procedure Sort_By_Select (Tab : in out T_Tabint; N : in Integer) is
      Min : Integer := 0;
      Buffer : Integer := 0;
   begin
 
      for I in 1 .. Tab'Last - 1 loop
 
         Min := I;
 
         for J in I + 1 .. Tab'Last loop
 
            if Tab(J) < Tab(Min) then
 
               Min := J;
 
            end if;
 
         end loop;
 
         if Min /= I then
 
         -- Premutation =>
 
            Buffer := Tab(Min);
            Tab(Min) := Tab(I);
            Tab(I) := Buffer;
 
         end if;
 
      end loop;
 
   end Sort_By_Select;

Si tu veux j'ai corrigé ta procédure décale_droite :

Code ada :

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

1
2
3
4
5
6
7
8
9
10
11
12
 
 procedure Decale_Droite(Tab : in out T_Tabint; K : Natural) is
      Mem1, Mem2: Integer := 0;
   begin
      Mem1 := Tab(K);
      for I in K+1..T_Tabint'Last loop
         Mem2 := Tab(I);
         Tab(I) := Mem1;
         Mem1 := Mem2;
      end loop;
      Tab(K) := Mem1;
   end Decale_Droite;

**Zerte** · 18/09/2015, 10h41

Essaie d'afficher ce que fait ton algorithme avec des Put, ou de passer en pas-à-pas dans un debugger.
Deux choses sautent aux yeux:
- la procédure Decale_Droite est beaucoup trop compliquée pour ce qu'elle devrait faire; ça devrait être 1 boucle avec 1 instruction dedans.
- tu fais le décalage de gauche à droite, donc il me semble qu'en fait tu copies un élément sur toute la droite du tableau.

**TechnoForce** · 18/09/2015, 13h25

Merci pour la correction de la fonction decale_droite, je l'ai modifié, je sais pas ce que j'avais fait pour avoir écrit ces trucs. Le tri ne fonctionne toujours pas, il me met tout mon tableau avec la valeur 1 (cf: mon main que j'utilise comme test de ma procédure).
La procédure afftab sert justement à afficher le tableau mais j'ai du mal à comprendre pourquoi le programme se comporte comme ça.

Mon package de fonctions dans sa totalité donne ça :

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
WITH Ada.Text_IO, Ada.float_Text_IO, ada.integer_text_io;
USE Ada.Text_IO, ada.float_Text_IO, ada.integer_text_io;
 
PACKAGE BODY Pack_Tab IS
 
---------------------------------------------------------------------------
   PROCEDURE Afftab(Tab : T_Tabint) IS
   BEGIN
      FOR I IN T_Tabint'range LOOP
         Put(Tab(I), Width => 0);
         Put(" ");
      END LOOP;
      New_line;
   END Afftab;
---------------------------------------------------------------------------
   FUNCTION Remptab RETURN T_Tabint IS
      Tab : T_Tabint;
      Remp : Integer;
   BEGIN
      Put("rentrez un entier ");
      Get(Tab(1));
      FOR I IN T_tabint'first .. t_tabint'last-1 LOOP
         Put("rentrez un entier ");
         Get(Remp);
         WHILE Remp < Tab(I) LOOP
            Put("votre suite n'est pas croissante, recommencez ");
            Get(Remp);
         END LOOP;
         Tab(I+1) := Remp;
      END LOOP;
      RETURN Tab;
   END Remptab;
---------------------------------------------------------------------------
   PROCEDURE Decale_Gauche( Tab : IN OUT T_Tabint; k : natural) IS
   BEGIN
      FOR I IN K..T_Tabint'last-1 LOOP
         Tab(I):= Tab(I+1);
      END LOOP;
   END Decale_Gauche;
---------------------------------------------------------------------------
   PROCEDURE Decale_Droite(Tab : IN OUT T_Tabint; K : Natural) IS
      Mem1, Mem2: Integer := 0;
   BEGIN
      Mem1 := Tab(K);
      FOR I IN K+1..T_Tabint'last LOOP
         Mem2 := Tab(I);
         Tab(I) := Mem1;
         Mem1 := Mem2;
      END LOOP;
      Tab(K) := Mem1;
   END Decale_Droite;
---------------------------------------------------------------------------
   PROCEDURE Remplace_Int (Tab : IN OUT T_Tabint ; K : Integer) IS
      Compt : Integer := T_Tabint'First;
   BEGIN
      WHILE K > Tab(Compt) LOOP
         Compt:= Compt+1;
      END LOOP;
      IF Compt = T_Tabint'First THEN
         Decale_Droite(Tab, Compt);
      ELSE
         Decale_Droite(Tab, Compt-1);
      END IF;
      Tab(Compt) := K;
   END Remplace_Int;
---------------------------------------------------------------------------
   PROCEDURE Tri_Selection(Tab : IN OUT T_Tabint) IS
      Compt : Natural := T_Tabint'First;
      Mini : Integer := Tab(T_Tabint'First);
      Indmini : Natural ;
      Memo : integer;
   BEGIN
      WHILE Compt < T_Tabint'Last LOOP
         FOR I IN Tab(Compt)..T_Tabint'Last LOOP
            IF Mini > T_Tabint'Last THEN
               Mini := Tab(I);
               Indmini := I;
            END IF;
         END LOOP;
         IF Indmini /= T_Tabint'Last THEN
            Memo := Tab(T_Tabint'Last);
         END IF;
         Afftab(Tab);
         IF Indmini /= Compt THEN
            Decale_Droite(Tab, Compt);
            Afftab(Tab);
            Tab(Compt) := Mini;
            IF Indmini < T_Tabint'Last THEN
               Tab(Indmini+1) := Memo;
               Afftab(Tab);
            END IF;
         END IF;
         Compt := Compt+1;
         Mini := Tab(Compt);
      END LOOP;
   END Tri_Selection;
 
END Pack_Tab;

et le main :

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
WITH Pack_Tab;
USE Pack_Tab;
 
PROCEDURE Main IS
 
   Tab : T_Tabint;
 
BEGIN
   Tab(1) := 1;
   Tab(2) := 4;
   Tab(3) := 8;
   Tab(4) := 7;
   Tab(5) := 2;
   Afftab(Tab);
   Tri_Selection(Tab);
   Afftab(Tab);
END Main;

Invité · 18/09/2015, 13h37

Bonjour,

Donc, comme tu a l'air de vouloir t'accrocher à ta boucle while et tes procédure annexes, il est indispensable que tu nous explique ta démarche.

Quels sont les comportement que tu attend de chacune de tes procédures ?

Décale droite : décale à droite.
Décale gauche décale à gauche.

Après je ne sais pas.

L'algorithme de tri selection étant relativement simple, je cherche l'objet de la démarche.

**TechnoForce** · 18/09/2015, 13h49

Le but c'est de faire un tri en utilisant decale_droitte,decale_gauche et ou remplace_internet. Je sais que je pourrais faire juste en percutant à chaque fois mais il faut utiliser au moins une de ses fonctions

Invité · 18/09/2015, 14h10

Peut-être mais c'est pas la question.

Quoi qu'il en soit.

Voici la correction de Tri selection :

Code ada :

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
 
 procedure Tri_Selection(Tab : in out T_Tabint) is
         Compt : Natural := T_Tabint'First;
         Mini : Integer := Tab(T_Tabint'First);
         Indmini : Natural ;
         Memo : Integer;
      begin
         while Compt < T_Tabint'Last loop
            for I in Compt..T_Tabint'Last loop
               if Mini > Tab(I) then
                  Mini := Tab(I);
                  Indmini := I;
               end if;
            end loop;
            if Indmini /= T_Tabint'Last then
               Memo := Tab(T_Tabint'Last);
            end if;
            Afftab(Tab);
            if Indmini /= Compt then
               Decale_Droite(Tab, Compt);
               Afftab(Tab);
               Tab(Compt) := Mini;
               if Indmini < T_Tabint'Last then
                  Tab(Indmini+1) := Memo;
                  Afftab(Tab);
               end if;
            end if;
            Compt := Compt+1;
            Mini := Tab(Compt);
         end loop;
      end Tri_Selection;

Je te conseille de comparer ce code au tien pour constater tes absence d'esprit lors de l'écriture de ce programme.
Il reste des correction à apporter dans decale gauche cependant.

Difficulté pour faire mon premier algorithme de tri

Ada

Discussions similaires

Partager

Partager