Structure de données et

Programmation
avancée en C

Dr A. EL ALLAOUI
1
 Description du Module
1. Algorithmique et Mise à niveau en
langage C
- Les pointeurs 4. Structure de données élémentaires
- Les fonctions - Piles
- La gestion dynamique de la mémoire - Files
- Les structures - Listes
- Les fichiers - Tables de hachage
- Arbres
2. La récursivité et paradigme « Diviser pour
régner »

3. Les algorithmes de tri élémentaires et

avancés
- Tri par sélection 5. Algorithmes de recherche
- Tri par insertion - Recherche séquentielle
- Tri à bulle
- Recherche dichotomique
- Tri par comptage
- Tri SHELL - Recherche par interpolation
- Tri indirect
- Tri Rapide 2
Motivation

8.168.684.336 pages

Comment ça marche ?
Motivation

Structure de donnée:

- tableau a 2 dimension

Algorithmes:

- surtout I.A.
Motivation

Structure de donnée :

File

FIFO
(First In First Out)
Premier entrée, premier sortie

Aussi: File à priorité

Motivation
Structure de donnée :

Pile

LIFO
(Last In First Out)
Dernier entrée, premier sortie
Motivation

Structure de donnée :

Graphe
(pour planifier des
Trajets)
Rappel et compléments de
la programmation en
langage C

Dr A. EL ALLAOUI
8
 Objectifs
Être capable de bien programmer

Comprendre les différentes constructions de

la programmation en C

Savoir programmer de manière modulaire

9
Qualités attendues d'un
programme

Clarté
Simplicité
Efficacité
Modularité
Extensibilité

10
Introduction au Langage C,C++

Mon Premier Programme en C

Début du programme

Inclusion de la bibliothèque
#include <stdio.h>
contenant la fonction printf

void main() Point d'entré du programme

{
première
printf("Bonjour!\n");
instruction
}
Fin du programme
11
Introduction au Langage C,C++
Définition d'une variable
nom::
nom
Unique pour chaque variable
Commence toujours par une lettre : int 2a, _a, t v a ;
Différenciation minuscule-majuscule: int a, A;
type::
type
Conditionne le format de la variable en mémoire
Peut être soit un type standard ou un type utilisateur
valeur::
valeur
Peut évoluer pendant l'exécution
initialisation grâce à l'opérateur d'affectation

12
Introduction au Langage C
Types de variable
char caractères
int entiers
short [int
[int]] entiers courts
long [int
[int]] entiers longs
float nombres décimaux
double nombres décimaux de
précision
supérieure
long double nombres décimaux
encore plus
précis
unsigned int entier non signé
13
Introduction au Langage C,C++
Déclaration d'une variable
Type nom_de_la_variable [= valeur]
Exemple:
int nb;
float pi = 3.14;
char c = 'a';
long i,j,k;
double r = 6.2879821365;

14
Types de base
4 types de base, les autres types seront dérivés de ceux-ci.

Type Exemples de valeur Codage en Peut être

Signification
mémoire

'a' 'A' 'z' 'Z' '\n' 'a' 'A'

1 octet signed,
char Caractère unique 'z' 'Z' '\n'
unsigned
Varie de –128 à 127
Short, long,
0 1 -1 4589 32000
int Nombre entier 2 ou 4 octets signed,
-231 à 231 +1
unsigned
Nombre réel 0.0 1.0 3.14 5.32
float 4 octets
simple -1.23

Nombre réel 0.0 1.0E–10 1.0 -

double 8 octets long
double précision 1.34567896

15
 TYPE de la valeur de retour

"main" : Cela signifie "principale",

ses instructions sont exécutées.

int main(void)
{
void main(void): La fonction main ne prend
/* corps du programme*/
begin aucun paramètre et ne retourne pas de valeur.
déclaration des Cstes et Var ;
instruction1 ; int main(void): La fonction main retourne une
valeur entière à l'aide de l'instruction return (0
instruction2 ; si pas d’erreur).
….
int main(int argc, char *argv[]): On obtient
}
alors des programmes auxquels on peut
end adresser des arguments au moment où on lance
le programme.
Entre accolades "{" et "}" on
mettra la succession d'actions à
réaliser.(Bloc)

16
 Structure d'un programme C
#include <stdio.h>
#define DEBUT -10 Directives du préprocesseur :
#define FIN 10 accès avant la compilation
#define MSG "Programme de démonstration\n"
int fonc1(int x);
int fonc2(int x); Déclaration des fonctions

void main()
{ /* début du bloc de la fonction main*/
int i; /* définition des variables locales */
Programme
i=0; principal
fonc1(i) ;
fonc2(i) ;
} /* fin du bloc de la fonction main */
int fonc1(int x) {
return x; Définitions des
}
fonctions
int fonc2(int x) {
return (x * x);
}
17
 Indenter = lisibilté #include <Lib1.h>
#include <Lib2.h>
Prenez l'habitude de respecter (au moins au début) les #define X 0;
règles :
int fonc1(int x);
- une accolade est seule sur sa ligne, float fonc2(char a);
- { est alignée sur le caractère de gauche de la ligne
précédente, int main(void)

- } est alignée avec l'accolade ouvrante correspondante, { /*main*/

instruction;
- après { , on commence à écrire deux caractères plus à
droite. instruction;
{
Fonctionnement : instruction;
{
- Taper et sauvegarder le programme,
instruction;
- Compiler le programme,
- Exécuter le programme. }
}
instruction;
} /* fin main*/ 18
 Préprocesseur
Le préprocesseur effectue un prétraitement du programme source avant qu'il soit compilé.
Ce préprocesseur exécute des instructions particulières appelées directives.
Ces directives sont identifiées par le caractère # en tête.

Inclusion de fichiers
#include <nom-de-fichier> /* répertoire standard */
#include "nom-de-fichier" /* répertoire courant */

La gestion des fichiers (stdio.h) /* Entrees-sorties standard */

Les fonctions mathématiques (math.h)
Taille des type entiers (limits.h)
Limites des type réels (float.h)
Traitement de chaînes de caractères (string.h)
Le traitement de caractères (ctype.h)
Utilitaires généraux (stdlib.h)
Date et heure (time.h)

19
 1er Programme
#include <stdio.h>
#include <conio.h>
int main(void)
{

printf(" 1ER ANNEE GI "); 1 ER ANNEE GI

getch() ; /* Attente d'une saisie clavier */

return 0; /* En principe un code d'erreur nul signifie "pas d'erreur". */

20
La fonction printf() :
Librairie : stdio.h. #include <stdio.h>

Syntaxe : int printf( const char *format [, arg [, arg]...]);

Description : Permet l'écriture formatée (l'écran par défaut).

Exemple :
printf("Qu'il est agreable d’utiliser printf "
"en\t C,\nlorsqu'on l'utilise \"proprement\".\n");

Résultat sur la sortie :

Qu'il est agreable d’utiliser printf en C,
lorsqu'on l'utilise "proprement".

Les caractères précédés de \ sont interprétés comme suit :

\\ : caractère \
\n : retour à la ligne
\t : tabulateur.
\" : caractère "
\r : retour chariot
21
Les constantes de type caractère ont une valeur entière dans la table
ASCII(American Standard Code for Information Interchange)
char c1 = 'A',
c2 = '\x41'; /* représentation hexadécimale */

caractères nom symbole code hexa décimal

\n newline LF 10
\t tabulation HT 9
\b backspace BS 8
\r return CR 13
\f form feed FF 12
\\ backslash 5C 92
\' single quote 27 39
\" double quote 22 34

22
La fonction scanf() :
Librairie : stdio.h. #include <stdio.h>

Syntaxe : int scanf(const char *format [argument, ...]);

Description : Lit à partir de stdin (clavier en principe), les différents

arguments en appliquant le format spécifié.
Exemple : scanf(" %d", &age); /* lecture de l'âge, on donne l'adresse de age */
!
Format des paramètres passés en lecture et écriture.

"%c" : lecture d'un caractère.

"%d" ou "%i" : entier signé.
"%e" : réel avec un exposant.
"%f" : réel sans exposant.
"%g" : réel avec ou sans exposant suivant les besoins.
"%G" : identique à g sauf un E à la place de e.
"%o" : le nombre est écrit en base 8.
"%s" : chaîne de caractère.
"%u" : entier non signé.
"%x" ou "%X" : entier base 16 avec respect majuscule/minuscule.
23
 1er Programme
#include <stdio.h>
#include <conio.h>
int main(void)
{
int age; /*déclaration d’une variable*/
printf("Je te souhaite le bon"
"jour aux TP\nEt je t" L’utilisation de & est indispensable avec
scanf (valeur lue et donc modifiée), pas avec
"e souhaite bon trav"
printf (valeur écrite et donc non modifiée).
"ail\n");
!
printf("Quel est ton âge? ");
scanf(" %d", &age); /* lecture de l'âge, on donne l'adresse de age */
printf("\nAlors ton age est de %d ans!\n",age);

getch() ; /* Attente d'une saisie clavier */

return 0; /* En principe un code d'erreur nul signifie "pas d'erreur". */
}
Quel est ton âge ? 18
Alors ton age est de 18 ans!
24
 Variables : déclarations
Syntaxe : Type identificateur1, identificateur2, …,…. ;

Exemple: char c1, c2, c3;

int i, j, var_ent;

Variables : initialisations
Les variables doivent être déclarées avant leur utilisation dans un début de bloc (juste après{),
zone des déclarations:

void main(void) void main(void)

{ {
est équivalent à
char c; char c = 'A';
int i,j, k;
c = 'A'; int i=50,j, k;
i = 50; j=k=10;
j =10;
= opérateur d’affectation
k=10;

Cette règle s'applique à tous : char, int, float ... 25

 Affichages et saisies
Librairie : stdio.h
Fonction Syntaxe Description

printf printf( const char *format [, arg [, Écriture formatée

arg]...]); sortie standard

scanf scanf( const char *format [, arg [, Lecture formatée

arg]...]); entrée standard

putchar putchar(int c); Écrire le caractère c

getchar getchar(); Lecture d'un caractère

getch(); <conio.h>
getch
puts *puts(char *s); Ecriture/Lecture d'une
*gets(char *s); chaîne de caractères,
gets terminée par \n
sprintf sprintf(char *s, char *format, arg ...); Ecrit dans la chaîne
d'adresse s.

sscanf sscanf(char *s, char *format, pointer ...); Lit la chaîne d'adresse s.

26
 LES DECLARATIONS DE CONSTANTES

1ere méthode: définition d'un symbole à l'aide de la directive de compilation #define.

Le compilateur ne réserve pas

Exemple: #define PI 3.14159 de place en mémoire
void main()
{
float perimetre,rayon = 8.7;
perimetre = 2*rayon*PI;
....
}

Syntaxe : #define identificateur texte(valeur) !

Les identificateurs s'écrivent
#define TAILLE 100 traditionnellement en
majuscules, mais ce n'est pas
#define MAXI (3 * TAILLE + 5) une obligation.
Syntaxe : #define nom_macro(identif_p1 , ... ) texte
#define SOMME(X,Y) X+Y
#define MULTIP(A,B) (A)*(B)

27
 LES DECLARATIONS DE CONSTANTES

2eme méthode: déclaration d'une variable, dont la valeur sera constante pour tout le programme.

Exemple:
void main() Le compilateur réserve de la
{ place en mémoire (ici 4 octets).
const float PI = 3.14159;
const int JOURS = 5;
float perimetre,rayon = 8.7;
perimetre = 2*rayon*PI;
.... /*ERREUR !*/ On ne peut
JOURS = 3; changer la valeur d’une const.
.... !
}

28
 Les opérateurs arithmétiques
Le C propose les opérateurs suivants :

+ addition
- soustraction
* multiplication
/ division
% modulo (reste de la division entière )

% ne peut être utilisé qu'avec des entiers

7/2 3

7.0/2
7/2.0
7.0/2.0
} 3.5

29
 Utiliser des opérateurs arithmétiques

Le compilateur considère le type des opérandes

pour savoir comment effectuer les opérations
k= 5/4 = 1 void main(void)
{
int i = 5, j = 4, k;
h = 5.0/4.0 = 1.25 double f = 5.0, g = 4.0, h;

k = i / j;
h = f / g;
h = 5/4 = 1.0000 h = i / j;
}

30
Les opérateurs de comparaison
< plus petit Le type booléen
<= plus petit ou égal n'existe pas. Le
résultat d'une
> plus grand
expression logique
>= plus grand ou égal vaut 1 si elle est
! == égal vraie et 0 sinon.
!= différent
Réciproquement,
Les opérateurs logiques toute valeur non
nulle est considérée !
&& et comme vraie et la
|| ou (non exclusif) valeur nulle
comme fausse.
! non

31
 int i;
Exemple
float f;
char c;

i = 7; f = 5.5; c = 'w';

f>5 ====> vrai (1)

(i + f) <= 1 ====> faux (0) Code ascii de
c == 'w‘ ====> vrai (1) ‘w’ ==119
c != 'w' ====> faux (0)
c >= 10*(i + f) ====> faux (0)
(i >= 6) && (c == 'w') ====> vrai (1)
(i >= 6) || (c == 119) ====> vrai (1)

RQ: !expr1 est vrai si expr1 est faux et faux si expr1 est vrai ;
expr1&&expr2 est vrai si les deux expressions expr1 et expr2 sont vraies et
faux sinon. L'expression expr2 n'est évaluée que dans le cas où l'expression
expr1 est vraie ;

expr1 || expr2 = (1) si expr1=(1) ou expr2=(1) et faux sinon.

L'expression expr2 n'est évaluée que dans le cas où l'expression expr1
est fausse.
32
 Incrément et décrement

C a deux opérateurs spéciaux pour incrémenter (ajouter 1)

et décrémenter (retirer 1) des variables entières
++ increment : i++ ou ++i est équivalent à i += 1 ou i = i + 1
-- decrement
Ces opérateurs peuvent être préfixés (avant la variable) ou
postfixés (après)
int a, b=3, c, d=3;
a=++b; // équivalent à b++; puis a=b; => a=b=4 a=++b;
c=d++; // équivalent à c=d; puis d++; => c=3 et d=4

“i” vaudra 6 int i = 5, j = 4;

i++;
“j” vaudra 3
--j;
“i” vaudra 7 ++i; 33
 Préfixe et Postfixe

#include <stdio.h>

int main(void)
{
équivalent à:
int i, j = 5;
1. j++;
i = ++j;
2. i = j; !
printf("i=%d, j=%d\n", i, j);

j = 5; équivalent à:
i = j++; 1. i = j;
printf("i=%d, j=%d\n", i, j); 2. j++; !
return 0;
} i=6, j=6
i=5, j=6
34
 Les Conversions de types
Le langage C permet d'effectuer des opérations de conversion de type.
On utilise pour cela l'opérateur de "cast" ().
#include <stdio.h>
#include <conio.h>
void main()
{
int i=0x1234, j; //1234hex=4660dec Conversion float -> int: 89.67 -> 89
char d,e; Conversion int -> float: 4660 -> 4660.00
float r=89.67,s;
Conversion int -> char: 1234 -> 34
j = (int)r;
s = (float)i; Conversion float -> char: 89.67 -> 89
d = (char)i; Pour sortir frapper une touche
e = (char)r;
printf("Conversion float -> int: %5.2f -> %d\n",r,j);
printf("Conversion int -> float: %d -> %5.2f\n",i,s);
printf("Conversion int -> char: %x -> %x\n",i,d);
printf("Conversion float -> char: %5.2f -> %d\n",r,e);
printf("Pour sortir frapper une touche ");
getch(); // pas getchar
}
35
 Les structures de contrôle en C

Alternative: if-else
Choix Multiple: switch-case
Itérations: for, while, do-while
Rupture de Contrôle: break, continue, return
… goto

36
 Les structures de contrôle en C
Les décisions - if then else
if (expression booléenne vraie) if (a<b)
{ {
Pas de then en C BLOC 1 D'INSTRUCTIONS min=a;
} }
else else
Le bloc " else " { {
est optionnel. BLOC 2 D'INSTRUCTIONS min=b;
} }

* Tout ce qui est 0 ( ‘\0’ 0 0.0000 NULL ) est faux

* Tout ce qui est != de 0 ( 1 ‘0’ 0.0001 1.34 ) est vrai

if(32)
printf("ceci sera toujours affiche\n");
if(0)
printf("ceci ne sera jamais affiche\n");
37
Exemples :
if (i < 10) i++;
La variable i ne sera incrémentée que si elle a une valeur inférieure à 10.

if (i == 10) i++; == et pas =

La variable i ne sera incrémentée que si elle est égale à 10.

if (!recu) printf ("rien reçu\n");

Le message "rien reçu" est affiché si recu vaut zéro.

if ((!recu) && (i < 10)) i++;

i ne sera incrémentée que si recu vaut zéro et i<10.

Si plusieurs instructions, il faut les mettre entre accolades.

if ((!recu) && (i < 10) && (n!=0) ){

i++; if(delta != 0) = if(delta)
moy = som/n;
printf(" la valeur de i =%d et moy=%f\n", i,moy) ;
} if(delta == 0) = if(!delta)
else {
printf ("erreur \n");
i = i +2; // i +=2 ;
} !
38
 ! Attention!
Ne pas confondre = = (opérateur logique d’égalité)
et = (opérateur d’affectation)
#include <stdio.h>

int main(void)
{
int i = 0;

if(i = 0) /* ici affectation */

printf("i = zero\n");
else
printf(“Quand i != de zero\n");

return 0;
}
Quand i != de zero

39
 if emboîtés
else est associé avec le if le plus proche

int i = 100;

if(i > 0)
if(i > 1000)
printf("i > 1000\n");
else
printf("i is reasonable\n");
i is reasonable
int i = 100;

if(i > 0) {
if(i > 1000)
printf(" i > 1000 \n");
} else
printf("i is negative\n");

40
 Opérateur conditionnel ? :
<expr1> ? <expr2> : <expr3>
• Si <expr1> fournit une valeur différente de zéro (Vrai), alors la valeur de
<expr2> est fournie comme résultat
• Si <expr1> fournit la valeur zéro (faux), alors la valeur de <expr3> est
fournie comme résultat
Exemple
La suite d'instructions peut être remplacée par:
MAX = (A > B) ? A : B
if (A>B)
MAX=A;
else int a , b;
MAX=B; a = 10;
printf( "Valeur de b est %d\n",
(a == 1) ? 20: 30 );
printf( "Valeur de b est %d\n",
(a == 10) ? 20: 30 );
41
 Les itérations – for
int i,j;
for( init ; test; increment) i=0
{ for (i = 0; i <3; i++) { i=1
/* corps de for */ printf ( "i = %d\n", i); i = 2
} j=5
} j=4
for(j = 5; j > 0; j- -)
printf("j = %d\n", j); j = 3
double angle; j=2
j=1
for(angle = 0.0; angle < 3.14159; angle += 0.2)
printf("sine de %.1lf %.2lf\n",angle, sin(angle));

int i, j, k;

for( ; ; ) for(i = 0, j = 9; (i < 20) &&(j>5); i++, j--)

{
............; /* bloc d'instructions */
............;
............;
}

est une boucle infinie (répétition infinie du bloc d'instructions). 42

 LA BOUCLE TANT QUE ... FAIRE ...
Boucle pré-testée
Il s'agit de l'instruction while : tant que, pas jusqu’à ce que!
tant que (expression vraie)
faire{BLOC D'INSTRUCTIONS}
Syntaxe en C:
Organigramme:
while (expression)
{
............; /* bloc d'instructions */
............;
............;
}

Le test se fait d'abord, le bloc d'instructions

n'est pas forcément exécuté.

Rq: les {} ne sont pas nécessaires lorsque le

bloc ne comporte qu'une seule instruction.

43
 Exemple
i=1; Intérieur 1
while(i<5) Intérieur 2
{ Intérieur 3
printf(“Intérieur %d\n",i); Intérieur 4
itération i++; Extérieur 5
}
printf("Extérieur %d\n",i);

int j = 5;
start
tant que, pas jusqu’à ce que! printf("start\n"); end
while(j == 0)
printf("j = %d\n", j--);
printf("end\n");
i=1;
while(i<5);
{ "tant que l'expression est vraie
printf(“Intérieur %d\n",i); attendre".
i++;
}

44
 do while = REPETER … tant que
(guarantit l’exécution au moins une fois)
bloc d' do
{
instructions ............; /* bloc d'instructions */
............;
}

non while (expression);

condition
oui vraie

suite du programme i=1;

do
int j = 5; { i=1
do j=5 printf(“i=%d ",i);
j=4 stop
printf("j = %i\n", j--); i++;
while(j > 0); j=3 }while(i<0);
printf("stop\n"); j=2 printf("stop\n");
j=1
stop
45
 Exercice d’application
Ecrire un programme qui affiche
les nombres paires <100
Avec la boucle for
Avec la boucle while
Avec la boucle do ..while

46
switch = AU CAS OU ... FAIRE ...
switch(variable de type char ou int) /* au cas où la variable vaut: */
{
case valeur1: ......; /* cette valeur1(étiquette): exécuter ce bloc d'instructions.*/
.......;
break; /* L'instruction d'échappement break;
permet de quitter la boucle ou l'aiguillage le plus proche.
*/

case valeur2:........; /* cette valeur2: exécuter ce bloc d'instructions.*/

........;
break;
.
. /* etc ...*/
.
default: .......; /* aucune des valeurs précédentes: exécuter ce bloc
........; d'instructions, pas de "break" ici.*/
}
Le bloc "default" n'est pas obligatoire. valeur1, valeur2, …. doivent être des expressions
constantes. L’instruction switch correspond à une cascade d’instructions if ...else

47
 Cette instruction est commode pour les "menus":

char choix; int choix;

printf("SAISIE :TAPER 1\n");
printf("AFFICHAGE :TAPER 2\n"); float f;
printf("POUR SORTIR :TAPER S\n");
printf("\nVOTRE CHOIX: "); scanf(" %d ", &choix); switch(f) {
choix = getchar(); case 2:
switch(choix)
switch(choix) ....
{ {
case '1': .......; case 1: … switch(i) {
break; ! case 2 * j:
....
case '2': ......;
break;

case 'S': printf("\nFIN DU PROGRAMME ....");

break;

default; printf("\nCE CHOIX N'EST PAS PREVU "); /* pas de break ici */
}

48
 Instructions d'échappement
Pour rompre le déroulement séquentiel d'une suite d'instructions

Break; Continue;

int i, j=1; for (i = -10; i <= 10; i++)

char a; {
for (i = -10; i <= 10; i++){ if (i == 0)
continue;
while(j!=0) /* boucle infinie */ // pour éviter la division par zéro
{ printf(“ %f”, 1 / i);
a=getchar(); }
if(a= ='x')
break;
} return (expression);
} permet de sortir de la fonction qui la contient

Si x est tapée au clavier

49
 Tableaux : Introduction
Déclaration de tableaux
Un tableau (array) est une collection de variables de même type, appelées éléments
On les déclare par un type, un nom et une dimension (CONSTANTE) placée entre [ ]
Le C alloue toujours un tableau dans une zone contigüe de la mémoire
Une fois déclaré, on ne peut redimensionner un tableau

Exemples
int tab[4]; déclare un tableau de 4 valeurs entières tab[0] tab[1] tab[2] tab[3]
!
#define SIZE 10
int a[SIZE]; /* a est un vecteur de 10 entiers */

le compilateur réserve SIZE places en mémoire pour ranger les éléments du tableau.

float A[5] = { 10.1, 20.3, 30.5, 40.0, 50.4 };

50
 Accès aux éléments d’un tableau
Les éléments sont numérotés de 0 à dim-1 !
Il n’y a pas de vérification de bornes
void main(void) a void main(void)
{ 59 0
{
int a[6];
? 1
int i = 7; int i;
? 2
int A[6] = { 1, 2,3, 5, 7, 11 };
a[0] = 59; 2 3
a[5] = -10; for (i=0;i<6;i++)
a[i/2] = 2; ? 4
printf("%d ", A[i]);
-10 5
a[6] = 0; }
a[-1] = 5;
}

Les tableaux consomment beaucoup de place mémoire.

On a donc intérêt à les dimensionner au plus juste.
51
Les tableaux à plusieurs indices
Leur déclaration
Comme tous les langages, C autorise les tableaux à plusieurs indices (on dit aussi
à plusieurs dimensions). Par exemple, la déclaration :
int t[5][3]
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]

Remarque
Aucune limitation ne pèse sur le nombre d’indices que peut comporter un
tableau. Seules les limitations de taille mémoire liées à un environnement
donné risquent de se faire sentir.

52
 Arrangement en mémoire des tableaux à plusieurs
indices
Les éléments d’un tableau sont rangés suivant l’ordre obtenu en faisant varier le
dernier indice en premier.(Pascal utilise le même ordre, Fortran utilise l’ordre
opposé). Ainsi, le tableau t déclaré précédemment verrait ses éléments ordonnés
comme suit :
t[0][0]
t[0][1]
t[0][2]
t[1][0]
t[1][1]
t[1][2]
....
t[4][0]
t[4][1]
t[4][2] 53
Initialisation de tableaux à un indice
La déclaration :
int tab[5] = { 10, 20, 5, 0, 3 } ;
place les valeurs 10, 20, 5, 0 et 3dans chacun des cinq éléments du tableau tab.

Il est possible de ne mentionner dans les accolades que les premières valeurs,
comme dans ces exemples :
int tab[5] = { 10, 20 } ;
int tab[5] = { 10, 20, 5 } ;
Les valeurs manquantes seront, suivant le compilateur, initialisées à zéro
(statique) ou aléatoires (automatique).
De plus, il est possible d’omettre la dimension du tableau, celle-ci étant alors
déterminée par le compilateur par le nombre de valeurs énumérées dans
l’initialisation. Ainsi, la première déclaration de ce paragraphe est équivalente à :
int tab[] = { 10, 20, 5, 0, 3 } ;
54
 Initialisation de tableaux à plusieurs indices

Voyez ces deux exemples équivalents (nous avons volontairement choisi des valeurs
consécutives pour qu’il soit plus facile de comparer les deux formulations) :

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

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

55
void main()
{
const int N=10;
int t[N],i;
for (i=0;i<N;i++){
printf("Entrez t[%d]=",i);
scanf("%d",&t[i]);
}
}

56
Exercice
Donner un programme en langage C qui permet de trier
6 éléments tapé par clavier (utilisez les tableaux)

57