CHAPITRE 4 : Les structures de données statiques

Les variables entières, réelles, caractères et booléennes ne comportaient qu’un seul élément.
En revanche, les variables structurées sont composées de plusieurs éléments.
La caractéristique la plus importante d’une variable structurée est la façon d’accéder à chacun
de ses composants.

I Les tableaux à une dimension (ou Vecteurs) :

I.1 Définition : C’est une structure de données composée d’un nombre fixe d’éléments (ou de
composantes) de même type. Ces éléments sont identifiés par un seul nom.

Une variable de type tableau est de type structuré, car elle comprend plusieurs éléments
assemblés suivant certaines règles :

- Les éléments du tableau sont du même type simple ;

- L’accès à un élément du tableau est déterminé par l’utilisation d’un indice.
- L’indice d’une composante est la position (le rang) de la composante relativement au
début du tableau qui permet d’accéder directement à chaque élément ;
- Le nombre d’éléments du tableau est fixé dans la déclaration et ne peut pas changer
(statique)

Une variable de type tableau se définit donc par :

a) Le type de l’élément du tableau ;
b) La taille du tableau (intervalle d’entier).

I.2 Déclaration :

VAR
< identificateur> : Array [intervalle] of <type_élément> ;

où identificateur : Désigne le nom de la variable tableau ;

intervalle : Est un intervalle de type entier ex :[ 1..50], [1…20].
type_élément : C’est le type des éléments du tableau et peut être de type entier, caractère,
booléen ou réel.

Exemple :
Var
T : Array[1..15] of Integer ;

I.3 Les opérations sur les tableaux :

a) L’accès à un élément du tableau est désigné par :

<Identificateur> [indice de l’élément]

(nom du tableau et le rang de l’élément dans le tableau)

Cours sur les vecteurs section 7

 Exemple : T[3] ainsi on accède à l’élément 3 du tableau T.

Remarque : l’indice peut aussi être une expression. T[2*3-2] ou T[i+1]

b) Lire ou écrire une ou plusieurs valeurs du tableau :

Read(T[3]) ; Read(T[i]) ; /* lire la 3ème valeur ou la ième valeur du tableau T*/

Write(T[3]) ; Write(T[i]) ; /* afficher la 3ème valeur ou la ième valeur du tableau T*/

Si on veut lire N valeurs en les sauvegardant dans un tableau :

For i 1 to N Do
Read (T[i]) ;
Done ;
N=9
T
10 6 -4 7 .. ..

1 2 3 4 5 6 7 8 9
T[1] T[2] T[3]
T[1]=10, T[2]=6..

Si on veut afficher le contenu d’un tableau :

For i 1 To N Do
Write(T[i]) ;
Done;

c) Affecter une valeur dans la position i du tableau : T[i]  Val ; T[i]7 ; T[i]T[j] ;

d) Faire des opérations de calcul : T[i]  T[i]*2 ;

(Utiliser un élément du tableau dans une expression)

e) Faire des comparaisons : If T[i]>0 Then … , If T[i]<T[j] Then….

Remarque : La taille du tableau est fixe et ne peut être modifié. Généralement on fixe une
taille maximale (par rapport aux besoins des données d’un problème donné) que nous
n’utiliserons pas parfois entièrement.

Exemple :
VAR
T : Array[1..8] of Integer ;
N, i : Integer ;
Begin
Repeat
Read(N) ;
Until N>0 And N<=8 ;
For i 1 To N Do

Cours sur les vecteurs section 7

 Read(T[i]) ;
Done ;
For i  1 To N Do
Write(T[i]) ;
Done ;
End.

T N=5
10 12 4 5 8

10 12 4 5 8

Exemple : Ecrire un algorithme qui permet de déclarer un tableau de 100 réels et d’afficher
la somme des 20 premiers éléments.
Solution :
Algorithm somme ;
Var
T :Array[1..100]of Real ;
I,N :Integer ;
S :Real ;
Begin
Repeat
Write(‘donner la taille du tableau >=20 et <=100’) ;
Read(N);
Until N>=20 et N<=100 ;
For i1 To N Do
Read (T[i]) ;
Done ;
S0 ;
For i1 To 20 Do
SS+T[i] ;
Done ;
Write (‘la somme =’,S) ;
End.

I.4 Quelques algorithmes de bases sur les vecteurs :

I.4.1 Les algorithmes de recherche :

a) La recherche séquentielle d’une valeur VAL dans un tableau de N nombres entiers non
trié :

Algorithm recherche1 ;
VAR
T : Array[1..50] of Integer ;
N, i, VAL :Integer ;
Begin
Repeat
Write(‘donner la taille du tableau <50’) ;

Cours sur les vecteurs section 7

 Read(N) ;
Until N>0 et N<=50 ;
Write(‘donner la valeur recherchée’) ;
Read(VAL) ;
For i 1 To N Do
Read(T[i]) ;
Done ;
i 1 ;
While (i<=N) And (T[i]<>VAL) Do
ii+1 ;
Done;
If (i>N) Then Write(VAL,’n’’existe pas’)
Else Write(VAL,’Existe’) ;
Eif ;
End.

/* 2ème solution avec un booleen */

Algorithm recherche2 ;
VAR
T : Array[1..50] of Integer ;
N, i, VAL :Integer ;
B :Boolean ;
Begin
Repeat
Read(N) ;
Until N>0 And N<=50 ;
Read(VAL) ;
/* remplir le tableau*/
For i 1 To N Do
Read(T[i]) ;
Done;
/* faire la recherche*/
i 1 ;Bfalse ;
While (i<=N) And(B=false) Do
If (T[i]=VAL) Then B True
Else i i+1 ;
Eif ;
Done ;
If (B=True) Then Write(VAL,’existe’)
Else Write(VAL,’n’’existe pas’) ;
Eif ;
End.

b) La recherche d’une valeur VAL dans un tableau Trié (on suppose le tri croissant):

❖ Recherche séquentielle :

Algorithm recherche3 ;
VAR

Cours sur les vecteurs section 7

T : Array[1..100] of Integer ;
N, i, VAL : Intger ;
Begin
Repeat
Read(N) ;
Until N>0 And N<=100 ;
Read(VAL) ;
For i 1 To N Do
Read(T[i]) ;
Done ; /* on suppose que les éléments sont introduits triés dans l’ordre croissant */
If (VAL<T[1]) Or (VAL>T[N]) Then Write(VAL ,’n’’existe pas’)
Else i1 ;
While VAL>T[i] Do
i i+1 ;
Done;
If (VAL=T[i]) Then Write(VAL,’Existe’)
Else Write(VAL,’n’’existe pas’) ;
Eif;
Eif ;
End.

Déroulement

T (trié)
2 5 8 12
1 2 3 4

VAL i N Affichage
1 4 1 n’existe
pas
8 1
2
3 8 existe
4 1
2 4 n’existe
pas

❖ Recherche dichotomique : (dichotomie : division en deux parts égales)

Algorithm recherche4 ;
VAR
T : Array[1..100] of Integer ;
N , i , milieu , VAL ,D , F: Integer ;
B :Boolean ;
Begin
Repeat
Read(N) ;
Until N>0 And N<=100;
Read( VAL) ;
Cours sur les vecteurs section 7
 For i 1 To N Do
Read(T[i])
Done; /* croissant */
If (VAL<T[1]) Or (VAL>T[N]) Then Write(VAL ,’n’’existe pas’)
Else
D 1 ; F N ; BFalse ;
While (D<=F) And (B=False) Do
milieu (D+F) Div 2 ;
If (T[milieu]=VAL) Then B True
Else If VAL<T[milieu] Then F milieu-1
Else D milieu+1 ;
Eif ;
Eif;
Done; VAL D F milieu B
If (B=True) Then Write(VAL,’Existe’) 6 1 9 5 false
Else Write(VAL,’n’’existe pas’) ; 3 4 2
Eif ; 3 true
Eif ;
End.

Déroulement :
N=9 val= 6 T
1 4 6 9 14 18 28 38 40
1 2 3 4 5 6 7 8 9

Faites des déroulements sur des valeurs :

- inferieures à l’élément du milieu et non existante, Val=5
- superieure à l’élément du milieu et inexistantes, Val=29
- supérieures à l’élément du milieu et existantes Val=38

I.4.2 Les algorithmes de tri :

Trier un tableau revient à ordonner ses éléments selon l’ordre croissant (ou décroissant)

a)Tri par sélection (extraction) :

Principe : le principe du tri par sélection est le suivant ;
Rechercher le plus petit élément du tableau, et l'échanger avec l'élément d'indice 1 ;
Rechercher le second plus petit élément du tableau, et l'échanger avec l'élément d'indice 2 ;
Continuer de cette façon jusqu'à ce que le tableau soit entièrement trié.

Algorithm tri_sélection ; /* on va trier selon l’ordre croissant : */

Var
T : Array [1..50] d’Integer ;
i, N, j, X, Pmin : Integer ;
Begin
Repeat
Read(N) ;
until N>0 And N<=50 ;
For i1 To N Do

Cours sur les vecteurs section 7

 Read(T[i]) ;
Done ; /* non trié*/
For i  1 To N-1 Do
Pmin i ; /* pour chaque itération on cherche le min des éléments restants*/
For j  i+1 To N Do
If (T[j]< T[Pmin]) Then Pmin  j ;
Eif ;
Done ;
If (i<>Pmin) Then
X  T[i] ; T[i]  T[Pmin] ; T[Pmin]  X ;
Eif ;
Done ;
/ * affichage du tableau trié */
For i  1 To N Do Write(T[i] ) ; Done;/* tableau trié*/
End.

Déroulement :
T
13 0 2 18

1 2 3 4
0 13 2 18

0 2 13 18

N=4
i j Pmin X
1 2 1
3 2
4 13
5
2 3 2
4 3 13
5
3 4 3
5
4

b) Tri par permutation (tri Bulle) :

Principe :
On parcourt le tableau et on compare les éléments consécutifs. Lorsque deux éléments
consécutifs ne sont pas dans l'ordre, ils sont échangés.

Cours sur les vecteurs section 7

 Après le premier parcours, le plus grand élément est à sa position définitive. Il faut parcourir
le tableau à nouveau, en s'arrêtant à l'avant-dernier élément, pour le reste du tableau qui est
encore en désordre.
Après ce deuxième parcours, les deux plus grands éléments sont à leur position définitive. Il
faut donc répéter les parcours du tableau, jusqu'à ce que le plus petit élément soit placé à sa
position définitive.

Algorithm tri_permutation ; /* on va trier selon l’ordre croissant : */

Var
T : Array [1..50] d’Integer ;
i, N, j, X : Integer ;

Begin
Repeat Read (N) ; Until N>0 And N<=50 ;
For i 1 To N Do Read (T[i]) ; Done ; /*non trié */
For i 1 To N-1 Do /* parcours*/
For j1 To N-i Do
If (T[j]> T[j+1]) Then
X T[j] ; T[j] T[j+1] ; T[j+1] X ;
Eif;
Done;
Done ;
/* affichage du tableau trié */
For i 1 To N Do Write (T[i] ) ; Done ;
End.

Déroulement : i j x N
Parcours 1 1 1 14 4
14 2 3 1 2 14
1 2 3 4 3 14
4
2 14 3 1 2 1
2 3
2 3 1 14 3
Parcour2 3 1 2
2 1 3 14 2
Parcours 3 4
1 2 3 14

c) Tri par Insertion :

Principe : Le principe du tri par insertion est d’insérer à la n ième itération le n ième
élément à la bonne place.
Dans l'algorithme, on parcourt le tableau à trier du début à la fin. Au moment où on
considère le i-ème élément, les éléments qui le précèdent sont déjà triés.

Cours sur les vecteurs section 7

 L'objectif d'une étape est d'insérer le i-ème élément à sa place parmi ceux qui précèdent. Il
faut pour cela trouver où l'élément doit être inséré en le comparant aux autres, puis décaler
les éléments afin de pouvoir effectuer l'insertion.

Algorithm Tri_Insertion ;
Var
T : Array[1..50] d’Integer ;
N, i, j, X, Pos : Integer;
Begin
Repeat Read (N) ; Until N>0 And N<=50 ;
For i1 To N Do Read(T[i]) ; Done;
For i2 To N faire /* les elements à placer */
Pos1 ;
While (T[Pos]< T[i]) Do PosPos + 1 ; /* trouver où l’élément doit être inséré*/
Done ;
If ( Pos<>i ) Then /* si l’élément n’est pas déjà à sa place*/
X T[i] ; j i ;
While (j>= pos+1) Do /* décaler les éléments pour pouvoir faire l’insertion*/
T[j]  T[j-1] ;
j j-1 ;
Done; i j Pos X
T[Pos] X; 2 2 1 5
Eif; 1
Done; 3 3 1 3
For i 1 To N Do WriteT[i]) ;
2
End.
1
4 1
Déroulement : N=4
2
8 5 3 24
3
1 2 3 4
4
.
. 5
.

3 5 8 24
1 2 3 4

I.4.3 Mise à jour d’un vecteur Trié :

a) Insertion d’une valeur dans le tableau trié :

Algorithm InsertValeur ;
Var T: Array [1..100] of Integer;
N, i, j, val : Integer ;

Cours sur les vecteurs section 7

 Begin
Repeat Read(N); Until N>0 And N<100 ;
For i  1 To N Do Read(T[i]) ; Done ; /* trié*/
Read (val) ; i  1;
While (i<=N) And (val>T[i]) Do i  i+1 ; Done; /* recherche de la position de
val*/
j N+1;
While (j>i) Do /* decalage*/
T[j]  T[j-1] ;
j j-1;
Done ;
T[i] val ; N  N+1 ;
For i 1 To N Do Write(T[i]) ;Done ;
End.

Faites le déroulement tout seul.

b) Suppression d’une valeur :

Algorithm suppression ;
Var T: Array [1..100] of Integer;
N, i, j, val : Integer ;
trouv :Boolean ;
Begin
Repeat Read(N); Until N>=1 And N<=100 ;
For i  1 To N Do Read(T[i]) ; Done;
Read(val) ;
/* vérification de l’existence de la valeur à supprimer et détermination
de sa position */
i1 ; trouvFalse ;
While i<=N And trouv=False Do
If T[i]=val Then trouvTrue
Else ii+1 ;
Eif ;
Done ;
If trouv=True Then
i  i+ 1 ; /* pour le décalage avec T[i]  T[i+1] le i n’est pas incrémenté */
While (i<=N) Do
T[i-1]  T[i] ; /* ou T[i]  T[i+1] avec i<N dans la condition de la boucle*/
i  i+1;
Done ;
NN-1;
For i  1 To N Do Write(T[i]) ; Done
Else Write(‘the value don’t exist ‘) ;
Eif;
End.

1 4 5 8 20 30 41 50 60 60

1 2 3 4 5 6 7 8 9 10

Cours sur les vecteurs section 7

Val=15

i=5 6 7 8 9 10 11 N=10 9

2eme solution
Suppression d’une valeur :
Algorithm Suppression ;
Var T: Array [1..100] of Integer;
N, i, j, val : Integer ;
trouv :Boolean ;
Begin
Repeat Read(N); Until N>=1 And N<=100 ;
For i  1 to N Do Read (T[i]) ; Done;
Read(val) ;
/* vérification de l’existence de la valeur à supprimer et détermination
de sa position */
i1 ; trouvfaux ;
While i<=N And trouv=False Do
If T[i]=val Then trouvTrue
Else ii+1 ; Eif ;
Done ;
If trouv=vrai Then
While (i<N) Do
T[i]  T[i+1] ;
i  i+1;
Done ;
NN-1;
For i  1 To N Do Write(T[i]) ;Done;
Else Write (‘la valeur n’’existe pas’) ;
Eif ;
End.

Cours sur les vecteurs section 7