Université Ibn Zohr - Faculté des Sciences

SMI3

Programmation I
Les tableaux

1
Supposons que nous souhaitions déterminer, à partir de vingt notes
d’élèves (fournies en données), combien d’entre elles sont supérieures
à la moyenne de la classe.

S’il ne s’agissait que de calculer simplement la moyenne de ces notes, il

nous suffirait d’en calculer la somme, en les cumulant dans une
variable, au fur et à mesure de leur lecture (simple boucle).

Mais, ici, il nous faut à nouveau pouvoir consulter les notes pour
déterminer combien d’entre elles sont supérieures à la moyenne ainsi
obtenue.

Il est donc nécessaire de pouvoir mémoriser ces vingt notes.

Tableau
2
La déclaration :
Type Non_Tableau[taille] ;

Exemple : int t[20];

réserve l’emplacement pour 20 éléments de type int.
Remarques:
• Chaque élément est repéré par sa position dans le tableau, nommée
indice, en langage C, la première position porte le numéro 0.
• Dans l’exemple, les indices vont de 0 à 19.
• Le premier élément du tableau sera désigné par t[0],
• le troisième par t[2],
• le dernier par t[19].
• La notation &t[i] désigne l’adresse de cet élément t[i]

3
Les éléments de tableau:
Un élément de tableau est une lvalue. Il peut donc apparaître comme:
• affectation t[2] = 5
• opérande d’un opérateur d’incrémentation t[3]++ --t[i]
• si t1 et t2 sont des tableaux d’entiers, t1 = t2 ; n’est pas possible

Les indices : de type int

t[n-3] avec n, p, k et j de type int
t[3*p-2*k+j%2]
La dimension d’un tableau:
Ne peut être qu’une constante ou une expression constante
#define N 50
.....
int t[N] ;
float h[2*N-1] ;
Débordement d’indice:
Aucun contrôle de débordement d’indice n’est mis en place 4
Il est possible, comme on le fait pour une variable scalaire, d’initialiser
(partiellement ou totalement) un tableau lors de sa déclaration

a) int tab[5] = { 10, 20, 5, 0, 3 } ;

place les valeurs 10, 20, 5, 0 et 3 dans chacun des cinq éléments du
tableau tab.

b) int tab[5] = { 10, 20 } ;

int tab[5] = { 10, 20, 5 } ;
Les valeurs manquantes seront, suivant la classe d’allocation du
tableau, initialisées à zéro (statique) ou aléatoires (automatique).

c) int tab[] = { 10, 20, 5, 0, 3 } ;

Il est possible d’omettre la dimension du tableau, celle-ci étant alors
déterminée par le nombre de valeurs énumérées dans l’initialisation

5
#include <stdio.h>
main()
{ int i, nbm ;
float t[20], som, moy ;

for (i=0 ; i<20 ; i++)

{ printf ("donnez la note numéro %d : ", i+1) ;
scanf ("%f", &t[i]) ;
}
for (i=0, som=0 ; i<20 ; i++) som += t[i] ;

moy = som / 20 ;
printf ("\n\n moyenne de la classe : %f\n", moy) ;

for (i=0, nbm=0 ; i<20 ; i++ )

if (t[i] > moy) nbm++ ;

printf ("%d élèves ont plus de cette moyenne", nbm) ;

} Réaliser un contrôle de saisie des notes 6
 C autorise les tableaux à deux dimensions, tableau a deux indices,
nommé souvent matrice . Par exemple, la déclaration :
int t[5][3]; Type nom_tab[nbr_lignes][nbr_colonnes];

réserve un tableau de 15 (5 x 3) éléments. Un élément quelconque de ce

tableau se trouve alors repéré par deux indices comme dans ces
notations :
t[3][2] t[i][j] t[i-3][i+j]

Schéma: matrice Mat(NxM) ; N lignes; M colonnes

Mat[0][0] Mat[0][1] Mat[0][2] … … Mat[0][M]
Mat[1][0] Mat[1][1] Mat[1][2] … … Mat[1][M]
… … … …
Mat[N][0] Mat[N][1] Mat[N][2] … … Mat[N][M]

Mat[0][0] Mat[0][1] … Mat[0][M] Mat[0][M] … Mat[N][M]

RAM
Ligne 0 Ligne 1 …. Ligne N 7
Il est possible d’initialiser (partiellement ou totalement) un tableau 2D
lors de sa déclaration

a) int tab [3] [4] = { { 1, 2, 3, 4 } ,

{ 5, 6, 7, 8 },
{ 9,10,11,12 } };
considère notre tableau comme formé de trois tableaux de quatre
éléments chacun.

b) int tab [3] [4] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12 } ;

se contente d’énumérer les valeurs du tableau suivant cet ordre.

chacun des deux niveaux, les dernières valeurs peuvent être omises.
Les déclarations suivantes sont correctes (mais non équivalentes) :

int tab [3] [4] = { { 1, 2 } , { 3, 4, 5 } } ;

int tab [3] [4] = { 1, 2 , 3, 4, 5 } ;
8
Exercice:

Ecrire un programme qui lit les dimensions L et C

d'un tableau T à deux dimensions du type int
(dimensions maximales: 10 lignes et 10 colonnes).
- Remplir le tableau par des valeurs entrées au
clavier et afficher le tableau
- Remplir le tableau automatiquement (rand())
- Par des valeurs 0<T[i]<20

9
10
Tri : éléments dans un ordre (croissant - décroissant)

Algorithmes de Tri classique (TP)

• Tri par sélection
• Tri par insertion
• Tri par bulle

11
Tri par sélection:
• À partir du 1er élément du tableau
• Rechercher le plus petit élément dans le sous
tableau à droite de T[i]
• Si i != pos_min permuter (T[i] , T[pos_min])

12
Tri par sélection:
Initial 5 9 2 6 8

Itération 1 2 9 5 6 8

Itération 2 2 5 9 6 8

Itération 3 2 5 6 9 8

Itération 4 2 5 6 8 9

13
Tri par insertion:
À partir du 2ème élément du tableau (s’il existe ! )
Pour chaque élément T[i] :
• s = T[i];
• Supposer le sous tableau à gauche de i déjà trié
• Chercher la position j où T[j-1] <= s et T[j] > s
• Faire un décalage à droite des éléments du sous
tableau à droite de j
• Insérer l’élément T[i] à la position j

14
Tri par insertion:
Initial 5 9 2 6 8

Itération 1 5 9 2 6 8

Itération 2 2 5 9 6 8

Itération 3 2 5 6 9 8

Itération 4 2 5 6 8 9

15
Tri par bulles (propagation):
Pour chaque itération :
• parcourir le tableau et comparer les couples
d'éléments successifs.
• Lorsque deux éléments successifs ne sont
pas dans l'ordre croissant, ils sont permutés.
• Lorsqu'aucun échange n'a lieu pendant un
parcours, arrêter (le tableau est trié).

16
Tri par bulles: itération 1
5 9 2 7 6

5 2 9 7 6

5 2 7 9 6

5 2 7 6 9

17
Tri par bulles: itération 2

5 2 7 6 9

2 5 7 6 9

2 5 6 7 9

18
Tri par bulles: itération 3

2 5 6 7 9

2 5 6 7 9

2 5 6 7 9

19