Cette page fournit une mise en application concrète des algorithmes décrits dans dans les pages précédentes.
Chaque algorithme fait l'objet d'un sous-programme, auquel il faudra ajouter quelques déclarations dans certains cas (voir le paragraphe « Déclarations des variables »).
Il pourront éventuellement servir de base à des routines dans un programme, voire être traduites dans un langage donnant des résultats plus performants (le Visual Basic n'étant certainement pas le meilleur choix pour une routine de tri !).
Mais ils pourront simplement aider à comprendre concrètement le fonctionnement de tels algorithmes.
Le dernier paragraphecomporte un petit programme « chapeau » qui utilise chaque algorithme sur plusieurs cas et indique le temps qui a été nécessaire, ce qui permet d'effectuer des comparaisons.
Sub TriSelection(Tableau As Variant, IMin_Tableau As Long, IMax_Tableau As Long)
'************************************************************
' Tri d'un tableau selon l'algorithme du tri par sélection
' Tableau Tableau à trier
' IMin_Tableau Indice de l'échelon mini à trier
' IMax_Tableau Indice de l'échelon maxi à trier
'************************************************************
Dim W_Long As Long
Dim I_Test As Long
Dim I_Min As Long
Dim I_Debut As Long
I_Debut = IMin_Tableau
While (I_Debut < IMax_Tableau)
' Recherche du plus petit élément dans le reste du tableau
I_Min = I_Debut
For I_Test = (I_Debut + 1) To IMax_Tableau
If Tableau(I_Min) > Tableau(I_Test) Then
I_Min = I_Test
End If
Next I_Test
' Echange de T(I_Min) et T(I_Debut)
W_Long = Tableau(I_Debut)
Tableau(I_Debut) = Tableau(I_Min)
Tableau(I_Min) = W_Long
I_Debut = I_Debut + 1
Wend
End Sub
Sub TriInsertion(Tableau As Variant, IMin_Tableau As Long, IMax_Tableau As Long)
'************************************************************
' Tri d'un tableau selon l'algorithme du tri par insertion
' Tableau Tableau à trier
' IMin_Tableau Indice de l'échelon mini à trier
' IMax_Tableau Indice de l'échelon maxi à trier
'************************************************************
Dim W_Long As Long
Dim I_Test As Long
' Boucle sur chacune des cases du tableau
For I_Test = (IMin_Tableau + 1) To IMax_Tableau
' Mémorisation de la valeur à classer
W_Long = Tableau(I_Test)
' Position de départ pour la recherche de la position d'insertion
I_Tableau = I_Test - 1
' Recherche de la position où insérer la valeur
' (juste après la première valeur inférieure ou égale)
' et décalage des cases lues
Do While Tableau(I_Tableau) > W_Long
Tableau(I_Tableau + 1) = Tableau(I_Tableau)
I_Tableau = I_Tableau - 1
If I_Tableau < IMin_Tableau Then
Exit Do
End If
Loop
Tableau(I_Tableau + 1) = W_Long
Next I_Test
End Sub
Sub TriBulle(Tableau As Variant, IMin_Tableau As Long, IMax_Tableau As Long)
'************************************************************
' Tri d'un tableau selon l'algorithme du tri à bulles
' Tableau Tableau à trier
' IMin_Tableau Indice de l'échelon mini à trier
' IMax_Tableau Indice de l'échelon maxi à trier
'************************************************************
Dim W_Long As Long
Dim I_Test As Long
Dim Inversion As Boolean
Inversion = True
While Inversion = True
Inversion = False
For I_Test = (IMin_Tableau + 1) To IMax_Tableau
If Tableau(I_Test - 1) > Tableau(I_Test) Then
' Echange du contenu des échelons
W_Long = Tableau(I_Test - 1)
Tableau(I_Test - 1) = Tableau(I_Test)
Tableau(I_Test) = W_Long
Inversion = True
End If
Next I_Test
Wend
End Sub
Sub TriShell(Tableau As Variant, IMin_Tableau As Long, IMax_Tableau As Long)
'************************************************************
' Tri d'un tableau selon l'algorithme du tri Shell
' Tableau Tableau à trier
' IMin_Tableau Indice de l'échelon mini à trier
' IMax_Tableau Indice de l'échelon maxi à trier
'************************************************************
Dim I_Test As Long Dim I_Tableau As Long Dim Distance As Long Dim W_Long As Long Distance = 0 Do Distance = 3 * Distance + 1 Loop Until Distance > (IMax_Tableau - IMin_Tableau + 1) ' Boucle sur la séquence des distances
Do
Distance = Distance / 3
' Boucle sur chacun des segments
For I_Test = (Distance + IMin_Tableau) To IMax_Tableau
' Tri d'un segment disjoint (tri par insertion)
W_Long = Tableau(I_Test)
I_Tableau = I_Test
Do While Tableau(I_Tableau - Distance) > W_Long
Tableau(I_Tableau) = Tableau(I_Tableau - Distance)
I_Tableau = I_Tableau - Distance
If I_Tableau < (Distance + IMin_Tableau) Then
Exit Do
End If
Loop
Tableau(I_Tableau) = W_Long
Next I_Test
Loop Until Distance = 1
End Sub
Sub TriFusion(Tableau As Variant, IMin_Tableau As Long, IMax_Tableau As Long)
'************************************************************
' Tri d'un tableau selon l'algorithme du tri fusion
' Tableau Tableau à trier
' IMin_Tableau Indice de l'échelon mini à trier
' IMax_Tableau Indice de l'échelon maxi à trier
'************************************************************
' Taille des sous-tableaux à fusionner
Dim Taille As Long
Dim IMin As Long
Dim IMed As Long
Dim IMax As Long
' Traitement pour chaque niveau de découpe, en partant de la plus fine
Taille = 1
While Taille <= (IMax_Tableau - IMin_Tableau + 1)
IMin = IMin_Tableau
IMed = IMin_Tableau + Taille - 1
IMax = IMed + Taille
' Fusion de sous-tableaux 2 à 2
While IMax <= IMax_Tableau
Call FusionTableau(Tableau, IMin, IMed, IMax)
IMin = IMax + 1
IMed = IMin + Taille - 1
IMax = IMed + Taille
Wend
' Fusion éventuelle du reliquat
If IMax_Tableau > IMed Then
' La taille du reliquat est supérieure à celle d'un sous-tableau
IMax = IMax_Tableau
Call FusionTableau(Tableau, IMin, IMed, IMax)
End If
Taille = Taille * 2
Wend
End Sub
Sub FusionTableau(Tableau As Variant, IMin As Long, IMed As Long, IMax As Long) '************************************************************
' Fusion de deux sous-tableaux contigüs triés
' Procédure utilisée par l'algorithme de tri/fusion
' Tableau Tableau où se trouvent les deux sous-tableaux
' IMin Premier échelon du premier sous-tableau
' IMed Dernier échelon du premier sous-tableau
' IMax Dernier échelon du dernier sous-tableau
'************************************************************
Dim I1 As Long
Dim I2 As Long
Dim I_T As Long
Dim T() As Long
ReDim T(IMax - IMin + 1)
I1 = IMin
I2 = IMed + 1
I_T = 0
' Fusion des 2 sous-tableaux d'origine dans un nouveau tableau
While (I1 <= IMed And I2 <= IMax)
If Tableau(I1) < Tableau(I2) Then
T(I_T) = Tableau(I1)
I1 = I1 + 1
Else
T(I_T) = Tableau(I2)
I2 = I2 + 1
End If
I_T = I_T + 1
Wend
While (I1 <= IMed)
T(I_T) = Tableau(I1)
I1 = I1 + 1
I_T = I_T + 1
Wend
While (I2 <= IMax)
T(I_T) = Tableau(I2)
I2 = I2 + 1
I_T = I_T + 1
Wend
' Recopie dans le tableau d'origine
I1 = IMin
For I_T = 0 To (IMax - IMin)
Tableau(I1) = T(I_T)
I1 = I1 + 1
Next I_T
End Sub
Sub TriRapide(Tableau As Variant, IMin_Tableau As Long, IMax_Tableau As Long)
'************************************************************
' Tri d'un tableau selon l'algorithme du tri rapide
' Tableau Tableau à trier
' IMin_Tableau Indice de l'échelon mini à trier
' IMax_Tableau Indice de l'échelon maxi à trier
'************************************************************
Dim W_Long As Long
Dim I_Haut As Long
Dim I_Pivot As Long
Dim T_Pile() As PileTri
Dim I_Pile As Long
Dim Dim_Pile As Long
Const PAS_PILE = 100
Dim_Pile = PAS_PILE
ReDim T_Pile(Dim_Pile)
I_Pile = 0
T_Pile(I_Pile).Idx_Min = IMin_Tableau
T_Pile(I_Pile).Idx_Max = IMax_Tableau
While I_Pile >= 0
Select Case T_Pile(I_Pile).Idx_Max - T_Pile(I_Pile).Idx_Min
Case Is <= 0
' Si le tableau ne comporte qu'un échelon ou moins : pas de tri
I_Pile = I_Pile - 1
Case 1
' Si le tableau ne comporte que 2 échelons : comparaison
If Tableau(T_Pile(I_Pile).Idx_Min) > Tableau(T_Pile(I_Pile).Idx_Max) Then
' Echange du contenu des échelons
W_Long = Tableau(T_Pile(I_Pile).Idx_Max)
Tableau(T_Pile(I_Pile).Idx_Max) = Tableau(T_Pile(I_Pile).Idx_Min)
Tableau(T_Pile(I_Pile).Idx_Min) = W_Long
End If
I_Pile = I_Pile - 1
Case Else
' Valeur pivot = contenu du 1er échelon
I_Haut = T_Pile(I_Pile).Idx_Max
I_Pivot = T_Pile(I_Pile).Idx_Min + 1
While (I_Pivot < I_Haut)
' A partir du haut du tableau, recherche
' d'une valeur inférieure ou égale à la valeur pivot
While (Tableau(I_Haut) > Tableau(T_Pile(I_Pile).Idx_Min)) And _
(I_Pivot < I_Haut)
I_Haut = I_Haut - 1
Wend
' A partir du bas du tableau, recherche
' d'une valeur supérieure à la valeur pivot
While (Tableau(I_Pivot) <= Tableau(T_Pile(I_Pile).Idx_Min)) And _
(I_Pivot < I_Haut)
I_Pivot = I_Pivot + 1
Wend
' Si la recherche n'est pas terminée, échange des deux échelons trouvés
If I_Pivot < I_Haut Then
W_Long = Tableau(I_Haut)
Tableau(I_Haut) = Tableau(I_Pivot)
Tableau(I_Pivot) = W_Long
End If
Wend
If Tableau(I_Pivot) > Tableau(T_Pile(I_Pile).Idx_Min) Then
I_Pivot = I_Pivot - 1
End If
' Echange du contenu des échelons
W_Long = Tableau(I_Pivot)
Tableau(I_Pivot) = Tableau(T_Pile(I_Pile).Idx_Min)
Tableau(T_Pile(I_Pile).Idx_Min) = W_Long
Call TriRapide(Tableau, IMin_Tableau, I_Pivot - 1)
Call TriRapide(Tableau, I_Pivot + 1, IMax_Tableau)
I_Pile = I_Pile + 1
If I_Pile = Dim_Pile Then
Dim_Pile = Dim_Pile + PAS_PILE
ReDim Preserve T_Pile(Dim_Pile)
End If
T_Pile(I_Pile).Idx_Max = I_Pivot - 1
T_Pile(I_Pile).Idx_Min = T_Pile(I_Pile - 1).Idx_Min
T_Pile(I_Pile - 1).Idx_Min = I_Pivot + 1
End Select
Wend
End Sub
Sub TriArbreBinaire(Tableau As Variant, IMin_Tableau As Long, IMax_Tableau As Long)
'************************************************************
' Tri d'un tableau selon l'algorithme du tri par arbre binaire ordonné
' Tableau Tableau à trier
' IMin_Tableau Indice de l'échelon mini à trier
' IMax_Tableau Indice de l'échelon maxi à trier
'************************************************************
Dim I_Tableau As Long
Dim W_Long As Long
' Initialisation de l'arbre binaire pour l'ensemble du tableau
' La construction de l'arbre binaire s'effectue de bas en haut
For I_Tableau = (IMin_Tableau + ((IMax_Tableau - IMin_Tableau) / 2)) To IMin_Tableau Step -1
Call CreeArbreOrdonne(Tableau, IMin_Tableau, I_Tableau, IMax_Tableau)
Next I_Tableau
' La plus grande valeur du tableau se trouve dans l'échelon IMin_Tableau
' Cette valeur est échangée avec le contenu de l'échelon de rang le plus élevé
' On reconstitue un nouvel arbre binaire sans le dernier échelon
' Le processus précédent est réitéré en éliminant à chaque fois le
' dernier échelon de l'arbre binaire
For I_Tableau = IMax_Tableau To (IMin_Tableau + 1) Step -1 W_Long = Tableau(I_Tableau) Tableau(I_Tableau) = Tableau(IMin_Tableau) Tableau(IMin_Tableau) = W_Long Call CreeArbreOrdonne(Tableau, IMin_Tableau, IMin_Tableau, I_Tableau - 1) Next I_Tableau End Sub Private Sub CreeArbreOrdonne(Tableau As Variant, I_Min As Long, I_Test As Long, I_Max As Long) '************************************************************
' Procédure utilisée par le tri par arbre binaire
' Crée un arbre binaire ordonné
' Tableau Tableau à traiter
' I_Min Indice du premier élément du tableau
' I_Test Indice de la racine de l'arbre à constituer
' I_Max Indice du dernier élément de l'arbre à constituer
' Les arborescences de racine 2*I_Test et (2*I_Test) + 1 doivent être des arbres ordonnés
' (ce qui revient à dire que les enfants de I_Test doivent être des arbres ordonnés)
' Il s'agit donc, si nécessaire de faire "descendre" le contenu du parent dans
' l'arborescence
'************************************************************
Dim I_Parent As Long Dim I_Enfant As Long Dim W_Long As Long Dim Fini As Boolean Fini = False W_Long = Tableau(I_Test) I_Parent = I_Test I_Enfant = (2 * I_Test) - I_Min + 1 Do While (I_Enfant <= I_Max) And (Fini = False) ' Positionnement de I_Enfant sur le plus grand des deux enfants
If I_Enfant < I_Max Then
If Tableau(I_Enfant) < Tableau(I_Enfant + 1) Then
I_Enfant = I_Enfant + 1
End If
End If
' Si le parent est plus grand que le plus grand des deux enfants
' l'arbre est constitué (puisque, par hypothèse, les enfants sont des arbres ordonnés)
If W_Long >= Tableau(I_Enfant) Then
Fini = True
Else
' Le parent est plus petit
' On fait "remonter" la valeur du plus grand enfant
Tableau(I_Parent) = Tableau(I_Enfant)
I_Parent = I_Enfant
I_Enfant = (2 * I_Parent) - I_Min + 1
End If
Loop
Tableau(I_Parent) = W_Long
End Sub
Sub TriRadix(Tableau As Variant, IMin_Tableau As Long, IMax_Tableau As Long)
'************************************************************
' Tri d'un tableau selon l'algorithme du tri Radix
' Tableau Tableau à trier (nombres entiers positifs)
' IMin_Tableau Indice de l'échelon mini à trier
' IMax_Tableau Indice de l'échelon maxi à trier
'************************************************************
Dim W_Long As Long
' Tableau des bits à 1
' 1er échelon = LSB à 1
' 2ème échelon = 2ème bit à 1, etc ...
Dim Nb_Bit As Integer
Dim T_Bit() As Long
Dim I_Bit As Long
ReDim T_Bit(1 To 32)
T_Bit(1) = 1
For I_Bit = 2 To 31
T_Bit(I_Bit) = T_Bit(I_Bit - 1) * 2
Next I_Bit
' Sous-tableaux "0" et "1"
Dim T0() As Long
Dim IMax_T0 As Long
Dim Dim_T0 As Long
Dim t1() As Long
Dim IMax_T1 As Long
Dim Dim_T1 As Long
Dim I_T0T1 As Long
Dim PAS_T0T1 As Long
' Détermination du nombre maximum de bits à traiter
W_Long = 0
For I_Tableau = IMin_Tableau To IMax_Tableau
If Tableau(I_Tableau) > W_Long Then
W_Long = Tableau(I_Tableau)
End If
Next I_Tableau
I_Bit = 32
Do While Not (W_Long And T_Bit(I_Bit))
Exit Do
I_Bit = I_Bit - 1
Loop
Nb_Bit = I_Bit
' Définition du pas pour l'allocation dynamique des sous-tableaux
PAS_T0T1 = (IMax_Tableau - IMin_Tableau) / 10
If PAS_T0T1 < 10 Then
PAS_T0T1 = 10
End If
'Création des sous-tableaux
Dim_T0 = PAS_T0T1
Dim_T1 = PAS_T0T1
ReDim T0(Dim_T0)
ReDim t1(Dim_T1)
' Itération sur chacun des bits, du LSB vers le MSB
For I_Bit = 1 To Nb_Bit
' Répartition du tabelau initial dans les 2 sous-tableaux
IMax_T0 = -1
IMax_T1 = -1
For I_Tableau = IMin_Tableau To IMax_Tableau
If Tableau(I_Tableau) And T_Bit(I_Bit) Then
' Le bit considéré est à 1
IMax_T1 = IMax_T1 + 1
If IMax_T1 > Dim_T1 Then
Dim_T1 = Dim_T1 + PAS_T0T1
ReDim Preserve t1(Dim_T1)
End If
Else
' Le bit considéré est à 0
IMax_T0 = IMax_T0 + 1
If IMax_T0 > Dim_T0 Then
Dim_T0 = Dim_T0 + PAS_T0T1
ReDim Preserve T0(Dim_T0)
End If
T0(IMax_T0) = Tableau(I_Tableau)
End If
Next I_Tableau
' Reconstitution du tableau initial à partir des 2 sous-tableaux
I_Tableau = IMin_Tableau - 1
For I_T0T1 = 0 To IMax_T0
I_Tableau = I_Tableau + 1
Tableau(I_Tableau) = T0(I_T0T1)
Next I_T0T1
For I_T0T1 = 0 To IMax_T1
I_Tableau = I_Tableau + 1
Tableau(I_Tableau) = t1(I_T0T1)
Next I_T0T1
Next I_Bit
'Supprimer les sous-tableaux
End Sub
Quelques constantes sont « en dur » :
COMPTERENDU = Chemin et nom du fichier texte où sera « imprimé » le compte-rendu du traitement'************************************************************
' Déclarations
'************************************************************
' Tableau servant de pile pour le tri rapide
Private Type PileTri
Idx_Min As Long
Idx_Max As Long
End Type
' Tableaux et variables de travail
Dim TableauRef() As Long
Dim TableauATrier() As Long
Dim Dim_TableauAtrier As Long
Dim I_TableauATrier As Long
Dim FichierCR As String
Const COMPTERENDU = "d:\cr_tri.txt"
Dim TriCorrect As Boolean
' Variable pour définition et affichage des cas à traiter
Dim MethodeTri As String
Dim CasTraite As String
Dim I_Debut As Long
Dim I_Fin As Long
Const PREMIER_INDICE = 0
Const PETITE_TAILLE = 1000
Const GRANDE_TAILLE = 10000
Il ne s'agit que d'un programme voué à effectuer des tests comparatifs ; en particulier, certaines variables sont à définir « en dur » (voir le paragraphe précédent )
Si vous voulez l'utiliser en l'état, il vous faudra créer une feuille Tris (Form), comportant un bouton B_OK (CommandButton), et une zone de message L_Message (Label).
Private Sub B_OK_Click()
'************************************************************
' Constitution de divers cas de tableau à trier, et tri selon
' plusieurs méthodes
'************************************************************
Dim Var As Long
' Initialisations
FichierCR = COMPTERENDU
Open FichierCR For Output As #99
B_OK.Enabled = False
'************************************************************
' Tri d'un tableau rempli au hasard - Petit tableau
'************************************************************
Dim_TableauAtrier = PETITE_TAILLE
CasTraite = "Tableau rempli aléatoirement - "
Call DebutCas
For I_TableauATrier = LBound(TableauRef) To UBound(TableauRef)
TableauRef(I_TableauATrier) = Int(Rnd * 1000) + 1
Next I_TableauATrier
Call ExecuteTris
'************************************************************
' Tri d'un tableau rempli au hasard - Grand tableau
'************************************************************
Dim_TableauAtrier = GRANDE_TAILLE
CasTraite = "Tableau rempli aléatoirement - "
Call DebutCas
For I_TableauATrier = LBound(TableauRef) To UBound(TableauRef)
TableauRef(I_TableauATrier) = Int(Rnd * 1000) + 1
Next I_TableauATrier
Call ExecuteTris
'************************************************************
' Tri d'un tableau initialement trié en inverse - Petit tableau
'************************************************************
Dim_TableauAtrier = PETITE_TAILLE
CasTraite = "Tableau initial trié en inverse - "
Call DebutCas
Var = UBound(TableauRef)
For I_TableauATrier = LBound(TableauRef) To UBound(TableauRef)
TableauRef(I_TableauATrier) = Var
Var = Var - 1
Next I_TableauATrier
Call ExecuteTris
'************************************************************
' Tri d'un tableau initialement trié en inverse - Grand tableau
'************************************************************
Dim_TableauAtrier = GRANDE_TAILLE
CasTraite = "Tableau initial trié en inverse - "
Call DebutCas
Var = UBound(TableauRef)
For I_TableauATrier = LBound(TableauRef) To UBound(TableauRef)
TableauRef(I_TableauATrier) = Var
Var = Var - 1
Next I_TableauATrier
Call ExecuteTris
'************************************************************
' Fin des traitements
'************************************************************
'#####################
Fin:
l_message.Caption = "Fin des tris"
Close #99
B_OK.Enabled = True
End Sub
Sub DebutTri()
'************************************************************
' Initialisation d'un tri
'************************************************************
' Réinitialisation du tableau à trier à partir du tableau de référence
DoEvents
ReDim TableauATrier(I_Debut To I_Fin)
For I_TableauATrier = LBound(TableauATrier) To UBound(TableauATrier)
TableauATrier(I_TableauATrier) = TableauRef(I_TableauATrier)
Next I_TableauATrier
' Affichage d'un message
l_message.Caption = CasTraite + Chr$(13) + MethodeTri
l_message.Refresh
' Impression de la date et heure de début de tri
Print #99, MethodeTri
Print #99, "Début : " + Str(Now)
End Sub
Sub ExecuteTris()
'************************************************************
' Appel des différents tris
'************************************************************
' Tri Fusion
MethodeTri = "Tri Fusion"
Call DebutTri
Call TriFusion(TableauATrier, LBound(TableauATrier), UBound(TableauATrier))
Call FinTri
' Tri Radix
MethodeTri = "Tri Radix"
Call DebutTri
Call TriRadix(TableauATrier, LBound(TableauATrier), UBound(TableauATrier))
Call FinTri
' Tri par arbre binaire
MethodeTri = "Tri par arbre binaire"
Call DebutTri
Call TriArbreBinaire(TableauATrier, LBound(TableauATrier), UBound(TableauATrier))
Call FinTri
' Tri Shell
MethodeTri = "Tri Shell"
Call DebutTri
Call TriShell(TableauATrier, LBound(TableauATrier), UBound(TableauATrier))
Call FinTri
' Tri par insertion
MethodeTri = "Tri par insertion"
Call DebutTri
Call TriInsertion(TableauATrier, LBound(TableauATrier), UBound(TableauATrier))
Call FinTri
' Tri rapide
MethodeTri = "Tri rapide"
Call DebutTri
Call TriRapide(TableauATrier, LBound(TableauATrier), UBound(TableauATrier))
Call FinTri
' Tri à bulles
MethodeTri = "Tri à bulles"
Call DebutTri
Call TriBulle(TableauATrier, LBound(TableauATrier), UBound(TableauATrier))
Call FinTri
' Tri par sélection
MethodeTri = "Tri par sélection"
Call DebutTri
Call TriSelection(TableauATrier, LBound(TableauATrier), UBound(TableauATrier))
Call FinTri
End Sub
Sub FinTri()
'************************************************************
' Fin d'un tri
'************************************************************
' Impression de la date et heure de fin
Print #99, "Fin : " + Str(Now)
' Contrôle de la séquence du tableau
TriCorrect = True
For I_TableauATrier = LBound(TableauATrier) + 1 To UBound(TableauATrier)
If TableauATrier(I_TableauATrier) < TableauATrier(I_TableauATrier - 1) Then
TriCorrect = False
Exit For
End If
Next I_TableauATrier
If TriCorrect = False Then
Print #99, "Tri incorrect à partir de l'échelon n° " + Str(I_TableauATrier)
Else
Print #99, "Tri correct"
End If
Print #99,
End Sub
Sub DebutCas()
'************************************************************
' Début d'un nouveau cas traité
'************************************************************
I_Debut = PREMIER_INDICE
I_Fin = Dim_TableauAtrier + PREMIER_INDICE - 1
ReDim TableauRef(I_Debut To I_Fin)
CasTraite = CasTraite + Str(Dim_TableauAtrier) + " échelons de " +
Str(I_Debut) + " à " + Str(I_Fin)
Print #99, String(80, "#")
Print #99, CasTraite
Print #99,
l_message.Caption = CasTraite
l_message.Refresh
End Sub
Retour à la table des matières des tris
Dernière mise à jour de cette page : 12/8/2007