Université Abdelmalek Essaadi Cours et modalités d’évaluation

Faculté des Sciences et Techniques de

Tanger Cours :
Cours : Séance de 1h45 / Semaine
Obligatoire :Chaque Mercredi (de 13h00 à 14h45)

Algorithmique et Programmation 2 TD : Séance de 1h45 / Semaine / Groupe

Obligatoire : voir emploi de temps

Pr. Abdelhamid ZOUHAIR

Evaluation:
Intitulé du module Algorithmique et Programmation 2
Contrôles
Etablissement dont relève le module Faculté des Sciences et Techniques de Tanger Assiduité + Absence
2ère Année du Troc Commun MIPC II
Filière
Section A

Semestre d’appartenance du module S3

Version 2.0 A. U: 2023/2024 2

1
 Plan de Cours

1. Rappel
• Les Opérateurs / Le types / Les Variables
• Les Structures de contrôles (Les Tests)
• Les Structures itératives (Les Boucles)
2. Fonctions
Chapitre 1:
3. Tableaux
Rappel d’Algorithme et
4. Pointeurs éléments de base du langage C
5. Chaînes de caractères
6. Structures, Enumérations et fichiers

3 4

2
 Etapes de l’algorithmique Traduction de l’algorithme

• Lecture de l’énoncé
• Extraire les données
Enoncé du Algorithme EQUATION
Problème
Variables
a,b,X: réel;

Langage de Programmation
DÉBUT
• Compréhension du problème
• Analyse ÉCRIRE ("Résolution de l'équation ax+b=0 " );
Résolution du
problème • Rédaction de l’algorithme ÉCRIRE ("Entrer les valeurs de a, b :");
Lire(a);
L'algorithme est ainsi conséquence directe d'une bonne analyse du problème. Traduction
Lire(b);
• Traduction de l’algorithme Si a=0 Alors

Mise en • Codification en langage choisi ( programme) ÉCRIRE (‘’Pas de solution’.’);

Œuvre sinon
X -b/a;
Finsi.
• Exécution ÉCRIRE (‘’La solution de cette équation est: ",
• Affichage des résultats X);
Exploitation
FIN.

5 6

3
 Traduction de l’algorithme Programme en C

#include<stdio.h>
#include<stdlib.h>
Algorithme EQUATION

Development Environment
Variables #include<stdio.h> float a,b,X;
Traduction en langage C #include<stdlib.h> main()
a,b,X: réel;

IDE pour Integrated

DÉBUT float a,b,X; {
ÉCRIRE ("Résolution de l'équation main()
{ printf("Résolution de l''equation ax+b=0");
ax+b=0");
printf("Résolution de l''equation ax+b=0"); printf("Entrer les valeurs de a, b :");
ÉCRIRE ("Entrer les valeurs de a, b :"); printf("Entrer les valeurs de a, b :"); scanf("%f",&a);
Lire(a); scanf("%f",&a);
scanf("%f",&b); scanf("%f",&b);
Lire(b); if(a==0) if(a==0)
Si a=0 Alors printf("Pas de solution.");
else printf("Pas de solution.");
ÉCRIRE ("Pas de solution. ");
X=-b/a; else
sinon
printf("La solution de cette équation est:%0f", X); X=-b/a;
X -b/a;
Finsi. } printf("La solution de cette equation est:%f ",
ÉCRIRE (‘’La solution de cette équation X);
est: ", X); }
FIN.

7 8

4
 Outils nécessaires pour programmer en C IDE :Integrated Development Environment

• un éditeur de texte pour écrire le code source du

programme.

Development Environment
• un compilateur pour transformer (compiler) le

IDE pour Integrated

code source en binaire.
• un débogueur pour traquer les erreurs.

9 10

5
 IDE : Integrated Development Environment IDE : Integrated Development Environment

IDE: Integrated Development Environment est un utilitaire ou

logiciel de développement qui regroupe :

Un Editeur: Permet la saisie du programme (code source).

Un Compilateur :Traduit le code source du programme en un langage

machine.

Un débuggeur: Permet de détecter les erreurs du programme.

11 12

6
 Qualités d’un programme Caractéristiques du Langage C

Universel : n'est pas orienté vers un domaine d'application particulier

(applications scientifiques, de gestion, …).
Clarté
Près de la machine : offre des opérateurs qui sont proches de ceux du
Simplicité langage machine => Efficace.
Efficacité Modulaire: peut être découpé en modules qui peuvent être compilés
séparément.
Modularité
Portable: il est possible d'utiliser le même programme sur plusieurs
Extensibilité systèmes (hardware, système d'exploitation ).

Utilisé dans la programmation système et la robotique : il est à la base

des plus grands systèmes d'exploitation (Unix, Linux, Mac OS).

13 14

7
 Structure d’un programme Structure d’un programme
#include <stdio.h>
#define DEBUT -10 Directives du préprocesseur : Directives de pré-compilation :
#define FIN 10 accès avant la compilation Elles commencent toutes par un #. Parmi ces directives, une seule est
#define MSG "Programme de démonstration\n" obligatoire pour le bon fonctionnement d’un programme en langage C:
int fonc1(int x); #include <stdio.h> : En effet, sans elle, on ne peut pas utiliser les
Déclaration des fonctions
int fonc2(int x); fonctions utiles pour l’affichage à l’écran et la lecture des données au clavier.
Int x; #include <math.h> :permet d’utiliser les fonctions mathématiques de base
Int pi=3,14; Déclaration des variables globales
(sqrt, cos).
#include <stdlib.h> : permet d’utiliser des fonctions générales.
void main()
#include<string.h> : permet de manipuler des chaînes de caractères.
{ /* début du bloc de la fonction main*/
int i; /* déclaration des variables locales */
Fonction main()
i=0;
Programme principal Elle commence par une accolade ouvrante { et se termine par une
fonc1(i) ;
fonc2(i) ; accolade fermante }. A l’intérieur, chaque instruction se termine par
} /* fin du bloc de la fonction main */ un point-virgule. Toute variable doit être déclarée.
int fonc1(int x) {
return x;
} Définitions des fonctions
int fonc2(int x) {
return (x * x);
} 15 16

8
 Les opérateurs Les opérateurs

L’Affectation: Opérateurs
Identificateur_de_variable = expression Arithmétiques Logiques De comparaison incrémentation

+ , * ,- , && , || , ! < ,> ,<=,>=, ++, --

/ !=,==
Exp:
A=5;
A=A+1; Exemple1: Opérateurs de Comparaison
B=A*2; X = (c > 3);
SOMME=A+B; X est égal à 1 si c est supérieur à 3, sinon X est égal à 0.
if ( a == b ) …
teste si a est égal à b.

17 18

9
 Les opérateurs Les opérateurs

Opérateurs Opérateurs Conditionnel

Arithmétiques Logiques De comparaison incrémentation

+ , * ,- , && , || , ! < ,> ,<=,>=, ++, -- Syntaxe : ( expression ) ? expression1 :

/ !=,==
expression2 ;
Si expression est vrai, le résultat est expression1 sinon le résultat est
expression2.
Exemple2: Opérateurs logique (booléens)
expression1 et expression2 doivent être du même type.
a >= 4 && a <= 8 ou (a >= 4) && (a <= 8)
retourne 1 si a est compris entre 4 et 8.
Exemple:
n = ( a < 0 ) ? -a : a ; n contient la valeur absolue de a.
a > 5 || b == 1
retourne 1 si a est supérieur à 5 ou si b est égal à 1.

19 20

10
 Les opérateurs Les opérateurs

Exemples: Exemples:
Le modulo : Incrémentation:
Pré-incrémentation (dans cet exemple B=5 )
a % b=r : r est le reste de division de a par b. L'instruction : A = ++B; est équivalente à :
La négation: B = B + 1;
Quelles sont les valeurs de A et B?
A = B;
!a : vaut 1 si a est nul , sinon vaut 0.
A B
Le ou et le Et:
6 6
a || b : a ou b
a && b : a et b Post-incrémentation (dans cet exemple B=5 )
Opérateur Binaire: l'instruction : A = B++; est équivalente à :
a&b : le Et bit à bit A = B;
B = B + 1; Quelles sont les valeurs de A et B?
a|b : le ou bit à bit
A B
5 6
21 22

11
 Les Types Les Types

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

Il existe un certain nombre de qualificateurs qui peuvent être
associés aux types de base :
Exemples de Codage en short : s'applique aux entiers
Type Signification Peut être
valeur mémoire (short int : entier codé sur deux octets)
long : s'applique aux entiers
'a' 'A' 'z' 'Z' '\n' 'a' (long int : entier codé sur quatre octets)
Caractère 1 octet signed,
char 'A' 'z' 'Z' '\n'
unique unsigned et aux nombres à virgule flottante double précision
Varie de –128 à 127
Short, (long double : double précision étendue)
0 1 -1 4589 32000 long,
int Nombre entier 2 ou 4 octets signed, signed : s'applique au type char (de -128 à 127) ou aux types
-231 à 231 +1
unsigned entiers (de -2n-1 à 2n-1-1, n étant le nombre de bits utilisés).
Nombre réel 0.0 1.0 3.14 5.32
unsigned : s'applique au type char (de 0 à 255) ou aux types
float 4 octets entiers (de 0 à 2n-1).
simple -1.23
Nombre réel 0.0 1.0E–10
double 8 octets long
double précision 1.0 -1.34567896

23 24

12
 Les Types Les Variables

Elles servent à stocker les valeurs des données utilisées pendant

Le Mot clé Typedef
l’exécution d’un programme.
permet de renommer un type. Elles doivent être déclarées avant d’être utilisées.
Syntaxe: Une variable est caractérisée par un :
• nom (Identificateur) : constitué de lettres, de chiffres et du
typedef type nouveau_type ; caractère
• type (entier, réel, …) : l’ensemble des valeurs qu’elle peut
Exp: prendre.
Typdef short Type1;
Noms des variables :
Typdef int Type2; Le C fait la différence entres les MAJUSCULES et les minuscules. Pour éviter
les confusions, on écrit les noms des variables en minuscule et on réserve
Type1 var1; les majuscules pour les constantes.
Les noms doivent commencer par une lettre et ne contenir aucun blanc. Le
Type2 var2; seul caractère spécial admis est le soulignement (_).
Il existe un certain nombre de noms réservés (while, if, case, ...), dont on
ne doit pas se servir pour nommer les variables. De plus, on ne doit pas
utiliser les noms des fonctions pour des variables.
25 26

13
 Les Variables Les Constantes

Déclaration des constantes:

Déclaration :
Une constante est une variable dont la valeur est inchangeable lors
La déclaration introduit les variables qui seront de l'exécution d'un programme.
utilisées, leur type et parfois aussi leur valeur de Constante : zone mémoire qui conserve sa valeur pendant toute
départ (initialisation). l’exécution d’un programme.
Syntaxe : Déclaration :
En langage C, les constantes sont définies grâce à la directive du
Type NomVar1, NomVar2,..., NomVarN ;
préprocesseur #define : #define nom_constante valeur; qui
Exemples : permet de remplacer toutes les occurrences du mot qui le suit par la
int i, j, k; int a, b ; valeur immédiatement derrière elle.
int somme; Exemple 1 :
float x, y ;
float x,y;
double z=1.5; char ch; #define Pi 3.14; (la constante ne possède pas de type)
short compteur; Il est ainsi préférable d'utiliser le mot clef const, qui permet de
char c=`A`; déclarer des constantes typées :
const type nom = expression ;
Exemple 2:
27 28
const float Pi =3.14; (la constante est typée)

14
 Les Constantes Le type caractère

Les constantes:

Code ASCII des caractères imprimables

Les constantes peuvent être de 4 types :
entier,
flottant (nombre réel),
caractère,
énumération.
Ces constantes vont être utilisées, par exemple, pour initialiser une variable.

L’opérateur adresse (&)

L’opérateur d’adresse & appliqué à une variable retourne
l’adresse-mémoire de cette variable

int a=140;
printf("L’adresse de a est %x",&a);

29 30

15
 Le type caractère Le type caractère

Caractères imprimables pour la fonction printf() Caractères non imprimables:

Opérateur de conversion de type:

L’opérateur de conversion de type, appelé cast, permet de
modifier explicitement le type d’un objet.
int main()
{ 1
int i = 3, j = 2; 1.5
printf("%f \n", i/j);
printf("%f \n",(float)i/j);
return 0;
}
31 32

16
 Les mots clefs

auto for continue

const long else
double signed return
switch static
float void extern Programmation en
int case char
short default langage C
do
struct enum if
unsigned goto union
register While
break sizeof 2ère Année du Troc Commun MIPC II
Section A
volatile typedef

LES STRUCTURES DE CONTRÔLE,

LES BOUCLES (STRUCTURES RÉPÉTITIVES)

33

17
 Les Structures de contrôle Les Structures de contrôle

L'instruction if …..else… : L'instruction if (…) instruction; :

Syntaxe: Syntaxe:

if (condition) instruction1; else instruction2; if (condition) instruction;

instruction1 est exécutée si condition est différent de 0. Si Condition vrai

instruction2 est exécutée si condition vaut 0.
Condition
?
Instruction
Si Condition vrai

Condition ? instruction 1

NB :Chaque instruction peut être un bloc d’instructions.

Sinon

instruction 2

35 36

18
 Les Structures de contrôle Les Structures de contrôle

Exemples : L'instruction switch

L'instruction permet d’affecter un choix entre plusieurs possibilités.
•if (i < 10) Il s'agit d'un opérateur de branchement.
i++; Syntaxe:
•if (delta > 0)
switch(expression)
printf("2 racines réelles\n");
{
else case const1 : instruction1;
if (delta == 0) break;
printf("racine double\n"); case const2 : instruction2;
else break;
printf("pas de racines réelles\n");
•if (a) /* équivalent à : if ( a != 0 ) */ ...
defaut : instruction_def
i++;
}
•if (an % 4 == 0 && an % 100 != 0 || an % 400 == 0)
printf("année bissextile\n");

37 38

19
 Les Structures de contrôle Les Structures de contrôle
Exemple d’une calculatrice basique switch(choix)
#include <stdio.h> {
#include <stdlib.h> case 1:
{printf("Donner a:\n"); case 4:
int main ()
scanf("%d",&a); {printf("Donner a:\n");
{
printf("Donner b:\n"); scanf("%d",&a);
int a,b; do{
scanf("%d",&b);
float resultat; printf("Donner b (non nul):\n");
resultat=a+b;
int choix=0; printf("a+b=%f\n",resultat); scanf("%d",&b);
break;} }while (b==0);
//***************Menu************* case 2: resultat=(float)a/b;
printf(" 1-Somme de a et b: \n"); {printf("Donner a:\n"); printf("a/b=%f\n",resultat);
printf(" 2-Soustraction de a et b: \n"); scanf("%d",&a); break;}
printf(" 3-Produit de a et b: \n"); printf("Donner b:\n"); case 0:
printf(" 4-Division de a par b: \n"); scanf("%d",&b); {exit(0);
printf(" 0-Quitter le programme: \n"); resultat=a-b; break;}
printf("a-b=%f\n",resultat); }
break;} getchar();getchar();
//***************Filtre *************
case 3: return 0;
while (choix >5 || choix<1)
{printf("Donner a:\n"); }
{
scanf("%d",&a);
printf(" Votre Choix SVP\n"); printf("Donner b:\n");
scanf("%d",&choix); scanf("%d",&b);
} resultat=a*b;
} printf("a*b=%f\n",resultat);
break;}

39 40

20
 Les Boucles
Les boucles permettent de répéter une série d’instructions tant qu’une
certaine condition est vérifiée.
On distingue 3 formes classiques:
while ( expression )
{
instruction1;
instruction2;
Programmation en ………..
langage C }
do {
instruction1;
instruction2;
2ère Année du Troc Commun MIPC II ………..;
Section A } while ( expression );
for ( expr 1 ; expr 2 ; expr 3)
{
LES STRUCTURES DE CONTRÔLE instruction1;
instruction2;
LES BOUCLES (STRUCTURES RÉPÉTITIVES) ………..;
} 42

21
 Les Boucles Les Boucles

Exemple: Exemple:

La boucle « While » La boucle « do … while »

while (expression) do
{ {
instruction1; instruction1;
….. …..
} } while(expression);

… …
main() main()
{ {
float note; int nbr;
printf(‘’Donner une note’’);
Scanf(‘’%f’’,&note); do
while( note<0 || note>20) {
Printf(‘’Donnez un nombre positif’’);
{ Scanf(‘’%d’’,&nbr);
printf(’’Donner une note’’); }while (nbr<0);
Scanf(‘’%f’’,&note);
} …
}
…
}
43 44

22
 Les Boucles

Exemple:

La boucle « For »
for(exp1;exp2;exp3)
{
Instruction1;
….
} Programmation en
langage C
…
main()
{
int i;
for(i=0;i<=9;i++) 2ère Année du Troc Commun MIPC II
{printf(‘’valeur %d’’,i+1); Section A

}
…
}

45

23
 Les Fonctions

Introduction

Chapitre 2: Exemple de construction d’une Maison:

Quelles sont les employés et les fonctions réalisés par ces employés?

Les fonctions en Employé

Architecte
Fonction/Tâche
Désigne de la maison

Electricien Installation électrique

Plomberie Canalisation Eau

Maçon Bâtir les murs et le toit

47

24
 Les Fonctions Les Fonctions

Introduction Introduction
En Programmation:

Nom de fonction Rôle/Tâche/Fonction Programmation modulaire

Affichage Affichage de valeur/ Les programmes longs sont difficiles à
de message écrire et à comprendre. On les découpe en
Nom de fonction Rôle/Tâche/Fonction des parties appelées sous-programmes
ou modules.
Saisie Saisie de valeur
Nom de fonction Rôle/Tâche/Fonction
Calcul Effectuer un calcul Un module est un groupe d'instructions
qui fournit une solution à des parties bien
Void Affichage () Void Saisie(int nbr) Int Calcul(int nbr) définies d'un problème plus complexe.
{ { {
Printf(" Bonjour\n" ); scanf(" %d" ,&nbr); return nbr*nbr;
} } }

50

25
 Les Fonctions Les Fonctions

Introduction Encapsule un traitement particulier formant un tout:

Programmation modulaire
La programmation modulaire à plusieurs Peut implémenter la notion de module en logique
intérêts : Notion de librairie

Fonction 1
permet de "factoriser" les programmes (mettre Augmente la lisibilité d’un programme
en commun les parties qui se répètent). Réalise un objectif précis
permet une structuration et une meilleure
lisibilité des programmes. Son utilisation se décompose en trois phases :
Fonction 2
facilite la maintenance du code (il suffit de
modifier une seule fois). Définition de la fonction
un module peut éventuellement être réutilisé dans Déclaration de la fonction
d'autres programmes.
Fonction 3

Appel de la fonction
En C, la structuration de programmes en sous-
programmes (modules) se fait à l'aide des
fonctions.

51

26
 Les Fonctions Les Fonctions

Définition Exemples
On définit une fonction en dehors de la fonction principale main ( ) par
la syntaxe suivante :
Type nom_fonction (type1 arg1,…, typeN argN)
{
instructions (corps de la fonction);
return (expression);
}
L’en-tête (prototype) de la fonction contient :
type : c’est le type du résultat retourné. Si la fonction n’a pas de
résultat à retourner, elle est de type void.
nom de la fonction.
parenthèses : on spécifie les arguments de la fonction et leurs types.
S’il n y a pas de paramètres, on peut déclarer les paramètres comme ().
Syntaxe de Fonction : Type nom_fonction (type1 arg1,…, typeN argN)
Pour fournir un résultat en quittant une fonction, on utilise la commande
{
return.
instructions (corps de la fonction);
53 return (expression); } 54

27
 Les Fonctions Les Fonctions

/*********************** programme complet***************************************/ /*********************** Exemple de calcule de Factoriel**************************/

#include <stdio.h> #include <stdio.h>
float Moyenne(float, float, float); long factoriel(int);
void main(void) int main()
{ {
float n1,n2,n3,MY; int nombre;
n1=10; printf(" Entrer un nombre\n" );
n2=16; scanf("%d" ,&nombre);
n3=19; printf(" %d!=%ld\n", nombre, factoriel(nombre));
MY=Moyenne(n1,n2, n3); return 0;
}
} long factoriel(int n)
float Moyenne(float note1, float note2, float note3) {
{ int i;
float moy; long resultat=1;
moy = 1/3*(note1+note2+note3); for(i=1;i<=n;i++)
return moy; resultat=resultat * i;
} return resultat;
}

55 56

28
 Les Fonctions Les Fonctions

Utilisation Utilisation
Appel d’une fonction : Appel d’une Fonction:
Exemple d’appel d’une fonction
L‘appel d'une fonction se fait par simple écriture de son nom avec la
cette instruction spécifie
liste des paramètres : nom_fonction (para1,…, paraN); #include <stdio.h> comment la fonction est
définie

Lors de la définition d'une fonction, les paramètres sont appelés float Moyenne(float, float, float);
paramètres formels. void main(void)
{ Le compilateur attend des
Lors de l'appel, les paramètres sont appelés paramètres effectifs. float; les conversions sont
floatn1,n2,n3,MY;
automatiques
n1=10;
L'ordre et les types des paramètres effectifs doivent correspondre à n2=16;
ceux des paramètres formels. n3=19;
MY=Moyenne(n1,n2, n3);
}
Ici, on ne tient pas compte de la valeur de retour

57 58

29
 Les Fonctions Les Fonctions

Utilisation Déclaration d’une Fonction:

Déclaration d’une fonction :
La déclaration se fait par le prototype qui indique les types des
TYPE de la valeur de retour 3 valeurs de type float
paramètres et de la fonction : type nom_fonction (type1,…, typeN);
comme paramètres
Il est interdit en C de définir des fonctions à l'intérieur d'autres
fonctions.
float Moyenne(float note1, float note2, float note3)
On doit définir les fonctions soit avant, soit après la fonction principale {
main. float moy;
Exemple : Déclaration et appel d’une fonction : Nom de la
moy = 1/3*(note1+note2+note3); fonction

return moy;
}
Valeur renvoyée

59 60

30
 Les Fonctions Les Fonctions

Variables locales et globales Variables locales et globales

On peut manipuler 2 types de variables qui se distinguent par ce
qu'on appelle leur portée (leur "espace de visibilité", leur "durée de
vie") :
variable locale :
définie à l'intérieur d’une fonction.
Elle n’est connue qu'à l'intérieur de cette fonction.
Elle est créée à l'appel de la fonction et détruite à la fin de son
exécution.
variable globale :
définie à l’extérieur des fonctions.
Elle est définie durant toute l’application;
Elle peut être utilisée et modifiée par les différentes fonctions du
programme.
Remarques :
Les variables déclarées au début de la fonction principale main
ne sont pas des variables globales, mais elles sont locales à
main.
En général, les variables globales sont déclarées immédiatement
derrière les instructions #include au début du programme.
Une variable locale cache la variable globale qui a le même
nom.
Une variable déclarée dans un bloc d'instructions {…} est :
uniquement visible à l'intérieur de ce bloc.
c’est une variable locale à ce bloc.
elle cache toutes les variables du même nom des blocs qui
l'entourent.

61 62

31
 Les Fonctions Les Fonctions

Variables locales et globales Fonction récursive

Exercice : Une fonction récursive est une fonction qui fait appel à elle-
Qu’affiche le programme suivant : même.
Toute fonction récursive doit posséder un cas limite (cas
trivial) qui arrête la récursivité.
Exemple : Une fonction qui calcule le factorielle :

int fact (int n )

{ if (n==0) /*cas trivial*/
return (1);
Else
return (n* fact(n-1) );}

63 64

32
 Les Fonctions

Fonction récursive
Exercice :
Ecrivez une fonction récursive qui calcule le terme n de la suite
de Fibonacci définie par :
U(0)=U(1)=1
U(n)=U(n-1)+U(n-2).
Programmation en
int Fib (int n) langage C
{if (n==0 || n==1)
return (1);
2ère Année du Troc Commun MIPC II
else Section B
return ( Fib(n-1)+Fib(n-2));
}

65

33
 Les Tableaux
Définition
Un tableau (array) est une collection de variables de même type, appelées
éléments.

Chapitre 3: 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.
LES TABLEAUX Une fois déclaré, on ne peut redimensionner un tableau.

•A une seule dimension Les tableaux sont une suite de variables de

•Multi-dimensions même type, situées dans un espace contigu
en mémoire.
en Un tableau a une dimension bien précise. Il peut
occuper 2, 3, 10, 150, 2 500, etc, cases.

67

34
 Les Tableaux Les Tableaux
Syntaxe de la déclaration d'un tableau (à une dimension)
Exemples
type identificateur[longueur]; int tab[4]; déclare un tableau de 4 valeurs entières tab[0] tab[1] tab[2] tab[3]

le type des éléments du tableau (un tableau est une suite de données de int tableau[4];
même type) ;
le nom du tableau (son identificateur) ; tableau[0] = 10;
la longueur du tableau (le nombre d’éléments qui le composent). Cette tableau[1] = 23;
dernière doit être une expression entière. tableau[2] = 505;
tableau[3] = 8;
Exemple
Pour définir un tableau contenant vingt int, nous devons procéder comme #define SIZE 10
suit: int tab[20]; int a[SIZE]; /* a est un vecteur de 10 entiers */

Remarque le compilateur réserve SIZE places en mémoire pour ranger les éléments du tableau.
La syntaxe de la déclaration d’un tableau est similaire à celle d’une
variable, la seule différence étant qu’il est nécessaire de préciser le
nombre d’éléments entre crochets à la suite de l’identificateur du tableau. float A[5] = { 10.1, 20.3, 30.5, 40.0, 50.4 };

35
 Les Tableaux Les Tableaux
Les tableaux
int tableau[4]; Accès aux éléments d’un tableau
printf("%d", tableau);

Le résultat sera l’adresse ou se trouve le tableau.

Si on indique l'indice de la case du tableau entre crochets, vous obtenez la void main(void)
valeur :
{
Int tableau[4]; int i;
printf("%d",tableau[0]);
int A[6] = { 1, 2,3, 5, 7, 11 };

Le résultat sera la valeur de la première case. for (i=0;i<6;i++)

On peut utiliser le symbole*pour connaître la première valeur : printf("%d ", A[i]);

int tableau[4]; }
printf("%d", *tableau);
Il est aussi possible d'obtenir la valeur de la seconde case avec*(tableau +1) Les tableaux consomment beaucoup de place mémoire. On a donc intérêt à
les dimensionner au plus juste.

36
 Les Tableaux Les Tableaux
Initialisation de tableaux à un indice Initialisation, affichage et recherche
La déclaration : void main() {
Recherche d’un élément dans un Tableu
const int N=10;
int tab[5] = { 10, 20, 5, 0, 3 } ;
int t[N],i; int rech(int t[],int r,int m){
place les valeurs 10, 20, 5, 0 et 3 dans chacun des cinq éléments du int i=0 , trouve= 0;//zéro
tableau tab. for (i=0; i<N ; i++){//Lecture while( (i < m)&&(trouve == 0)){
printf("Entrez t[%d]=",i); if (t[i] == r) trouve= 1;
Il est possible de ne mentionner dans les accolades que les premières else i++;
valeurs, comme dans ces exemples : scanf("%d", &t[i]); }
} if (i == m) return -1;
int tab[5] = { 10, 20 } ;
return i;
for (i=0; i<N ; i++){ //Affichage }
int tab[5] = { 10, 20, 5 } ;
printf("%d \t ", t[i]);
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 } ;

37
 Les Tableaux Les Tableaux

Les tableaux multidimensionnels Les tableaux à plusieurs indices

Déclaration d’un tableau multidimensionnel Arrangement en mémoire des tableaux à plusieurs indices

Comme tous les langages, C autorise les tableaux à plusieurs indices Les éléments d’un tableau sont rangés suivant l’ordre obtenu en faisant
(on dit aussi à plusieurs dimensions). varier le dernier indice en premier. Ainsi, le tableau t déclaré précédemment
verrait ses éléments ordonnés comme suit :
Par exemple, la déclaration : int t[5][3];
réserve un tableau de 15 (5 x 3) éléments. Un élément quelconque
t[0][0]
de ce tableau se trouve alors repéré par deux indices comme dans
t[0][1]
ces notations :
t[0][2]
t[3][2] t[i][j] t[i-3][i+j]
t[1][0]
t[1][1]
Remarque t[1][2]
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 t[4][0]
donné risquent de se faire sentir. t[4][1]
t[4][2]

38
 Les Tableaux Les Tableaux
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) :
Langage C :
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 } ; Les algorithmes de

void main() {
int A[5][10]; int i,j; //Lecture
for (i=0; i<5; i++) /* Pour chaque ligne ... */
Tri d’un tableau
for (j=0; j<10; j++) /* Pour chaque colonne ... */
Tri à bulles
scanf("%d", &A[i][j]);
Tri par sélection
//Affichage
Tri insertion
for (i=0; i<5; i++){ Tri fusion
for (j=0; j<10; j++)
printf("%d", A[i][j]); Tri rapide
printf("\n"); /* Retour à la ligne */ 78
}

39
 Les Tableaux Les Tableaux
Les algorithmes de Tri d’un tableau: Tri à bulles Les algorithmes de Tri d’un tableau

L'algorithme de tri par propagation consiste à inverser deux éléments Tri à bulles
successifs s'ils ne sont pas classés dans le bon ordre et à recommencer
jusqu'à ce que l'on parcoure le tableau sans effectuer une seule inversion.
Ainsi, un petit élément sera échangé plusieurs fois avec ses prédécesseurs
jusqu'à atteindre son emplacement définitif : il va se propager peu à peu, ou
«remonter» vers la bonne position lentement, comme une bulle d'air
remonte peu à peu à la surface.
L’algorithme en langage C :
tri_a_bulle_c(int t[],int n){
int j =0;int tmp =0;bool permutation = true;
while(permutation){
permutation = false;
for(j =0; j < n-1; j++){
if(t[j] > t[j+1]){
tmp = t[j+1];
t[j+1] = t[j];t[j] = tmp;
permutation = true;
}}}}

40
 Les Tableaux Les Tableaux
Les algorithmes de Tri d’un tableau: Tri par sélection Les algorithmes de Tri d’un tableau:
Pour trier un tableau par sélection. Le principe est simple : nous allons chercher le Tri par sélection
minimum du tableau et l'échanger avec le premier élément. Puis on réitère l'opération
: on recherche le minimum du tableau (privé toutefois du premier élément) et on
l'échange avec le second. On réitère la même opération et on l’échange avec le
troisième ainsi de suite. On obtient ainsi un tableau entièrement ordonné par ordre
croissant. C'est l'un des algorithmes les plus simples et intuitifs.
L’algorithme en langage C:
tri_selection(int t [], int n){
int i, min, j , tmp;
for(i =0; i < n -1; i++){
min = i;
for(j = i+1; j < n ; j++)// chercher le min
if(t[j] < t[min])
min = j;
if(min != i){
tmp = t[i];
t[i] = t[min];
t[min] = tmp;
}}}

41
 Les Tableaux Les Tableaux
Les algorithmes de Tri d’un tableau : Tri insertion Les algorithmes de Tri d’un tableau :
Le principe du tri par insertion est le principe utilisé par tout un Tri insertion
chacun pour ranger ses cartes : on les classe au fur et à mesure.
Imaginons que dans une main de 5 cartes, nous ayons déjà trié les
trois premières, nous arrivons donc à la quatrième carte. Que fait-on
? Eh bien c'est simple, on la sort du paquet de cartes pour l'insérer à
la bonne place dans la partie des cartes déjà triées.
L’algorithme en langage C:
tri_insertion(int t [] ,int n){
int i, j;
int en_cours;
for (i = 1; i < n; i++) {
en_cours = t[i];
for (j = i; j > 0 && t[j - 1] > en_cours; j--) {
t[j] = t[j - 1];
}
t[j] = en_cours;
}
}

42
 Les Tableaux Les Tableaux
Les algorithmes de Tri d’un tableau : Les algorithmes de Tri d’un tableau :
Tri fusion Tri fusion : Exemple
Prenons comme exemple du tableau suivait:
Le tri fusion est un algorithme de tri par comparaison efficace, il se base sur
le principe du diviser pour régner. 5, 1, 3, 8, 9, 6 que l’on veut trier avec le tri fusion
dans l’ordre croissant :
Principe de l’algorithme 1ère étape : diviser
5, 1, 3 | 8, 9, 6 -> on divise le tableau en deux.
L'algorithme se compose de deux parties distinctes :
5, | 1, 3 | 8 | 9, 6 -> on divise en deux les sous
• Diviser : on divise récursivement le tableau, c'est-à-dire qu'on va couper tableaux.
le tableau en deux sous tableaux et recommencer cette opération sur ces 5 | 1 | 3 | 8 | 9 | 6 -> chaque sous tableau est de
derniers jusqu'à ce que chaque sous tableau ne contienne plus qu'un seul nouveau divisé pour n'avoir plus qu'un seul élément.
élément.
• Fusionner : une fois notre tableau divisé en N sous tableaux (N étant le 2ème étape : fusionner
nombre d'éléments), on fusionne deux à deux les tableaux en réorganisant 1, 5 | 3, 8 | 6, 9 -> on prend deux sous tableaux
les éléments dans l'ordre du tri (croissant ou décroissant). adjacents que l'on fusionne en les ordonnant.
1, 3, 5, 8 | 6, 9 -> on continue la fusion des sous
tableaux.
L'intérêt de diviser pour ensuite fusionner est que créer un tableau trié à 1, 3, 5, 6, 8, 9 -> le tableau ne contient plus de sous
partir de deux sous tableaux peut s'effectuer en temps linéaire. C'est ce tableaux, il est donc trié.
point en particulier qui fait la rapidité du tri fusion. 1, 3, 5, 6, 8, 9

43
 Les Tableaux Les Tableaux
Les algorithmes de Tri d’un tableau : Les algorithmes de Tri d’un tableau : Tri fusion
Tri fusion #include <stdio.h>
#include <stdlib.h>

void fusion (int *a, int n, int m) {

int i, j, k;
int *x = malloc(n * sizeof (int));
for (i = 0, j = m, k = 0; k < n; k++) {
x[k] = j == n ? a[i++]
: i == m ? a[j++]
: a[j] < a[i] ? a[j++]
: a[i++];
}
for (i = 0; i < n; i++) {
a[i] = x[i];
}
free(x);
}

void tri_fusion (int *liste, int taille) {

if (taille < 2) return;
int milieu = taille / 2;
tri_fusion(liste, milieu);
tri_fusion(liste milieu, taille - milieu);
fusion(liste, taille, milieu);
}

44
 Les Tableaux Les Tableaux
Les algorithmes de Tri d’un tableau : Tri rapide
Les algorithmes de Tri d’un tableau : Tri rapide #include <stdio.h>
void permuter(int *a, int *b) {
Tri rapide est un algorithme qui repose sur le principe int tmp;
tmp = *a;
Diviser pour Régner. Les étapes sont les suivantes: *a = *b;
1. Choisissez un élément du tableau, cet élément est *b = tmp;
}
appelé l’élément pivot. void triRapid(int tab[], int first, int last) {
2. Divisez le tableau non trié d’éléments en deux tableaux int pivot, i, j;
if(first < last) {
dont la valeur est inférieure au pivot et qui figurent pivot = first;
dans le premier sous-tableau. Tous les éléments dont i = first;
j = last;
la valeur est supérieure au pivot figurent dans le while (i < j) {
deuxième sous-tableau (des valeurs égales peuvent while(tab[i] <= tab[pivot] && i < last)
i++;
aller dans les deux sens). Cette étape s’appelle while(tab[j] > tab[pivot])
l’opération de partition. j--;
if(i < j) {
3. Répétez de manière récursive l’étape 2 (jusqu’à ce que permuter(&tab[i], &tab[j]);
les sous-tableaux soient triés). }
}

45
 Les Tableaux Les Tableaux
Les algorithmes de Tri d’un tableau : Tri rapide Les algorithmes de Tri d’un tableau : Tri rapide (Version 2)
(suite) void echanger(int tableau[], int a, int b)
{
int temp = tableau[a];
permuter(&tab[pivot], &tab[j]); tableau[a] = tableau[b];
triRapid(tab, first, j - 1); tableau[b] = temp;
triRapid(tab, j + 1, last); }
}
} void quickSort(int tableau[], int debut, int fin)
int main() { {
int gauche = debut-1;
int tab[100], nbr, i; int droite = fin+1;
printf("\n Entrer le nombre total d'éléments : "); const int pivot = tableau[debut];
scanf("%d", &nbr); /* Si le tableau est de longueur nulle, il n'y a rien à faire. */
printf("\n Entrer les éléments du tableau : "); if(debut >= fin) return;
for(i = 0; i < nbr; i++) /* Sinon, on parcourt le tableau, une fois de droite à gauche, et une autre de gauche à droite, à la
scanf("%d", &tab[i]); recherche d'éléments mal placés, que l'on permute. Si les deux parcours se croisent, on arrête. */
triRapid(tab, 0, nbr - 1); while(1)
{
printf("\n Tableau trié : "); do droite--;
for(i = 0; i < nbr; i++) { while(tableau[droite] > pivot);
printf(" %4d", tab[i]); do gauche++;
} while(tableau[gauche] < pivot);
printf("\n"); if(gauche < droite) echanger(tableau, gauche, droite); else break;
return 0; } /* Maintenant, tous les éléments inférieurs au pivot sont avant ceux supérieurs au pivot. On a
} donc deux groupes de cases à trier. On utilise pour cela... la méthode quickSort elle-même ! */
quickSort(tableau, debut, droite); quickSort(tableau, droite+1, fin);
}

46
 Les Tableaux Les Tableaux
Les algorithmes de Tri d’un tableau : Tri rapide Les algorithmes de Tri d’un tableau : Tri rapide

47
 Les Tableaux Les Tableaux
#include<stdio.h>
#include<stdlib.h>
#define dim 10 Ecrire un programme C qui permet de :
main() 1. Lire la taille N de deux tableaux A et B du type entier;
{
float tab[dim]; 2. Remplir les tableaux par des valeurs entrées au clavier;
int i; 3. Créer et afficher un tableau S qui sera la somme des éléments des
float somme,moyenne;
/****** Remplissage du Tableau****/ deux tableaux de départ.
somme=0;
for(i=0;i<dim;i++)
{
printf("Element %d du tableau :",i+1);

scanf("%f",&tab[i]);
somme=somme+tab[i]; /*calcul de la somme */
printf("\n");
}
/****** Calcul de la moyenne****/
moyenne=somme/dim;
/****** Affichage du Tableau****/
for(i=0;i<dim;i++)
{
printf("tab[%d]:%0.0f \n",i+1,tab[i]);
}
/****** Affichage de la moyenne****/
printf("La moyenne du tableau est %.2f\n.",moyenne);
system("pause");
}

48
 Les Tableaux Les Tableaux
Solution: Exercices

#include<stdio.h> Exercice 1 :
main(){ Ecrire un programme C qui permet de saisir un nombre entier et de vérifier sa parité
int i, n, A[20], B[20], S[20]; (pair ou impaire).
printf("Entrer la taille des 2 tableaux : "); printf("\nAffichage du tableau Exercice 2:
A:\n");
scanf("%d",&n); Ecrire une fonction qui retourne la max de deux valeur A et B.
for(i = 0; i < n; i++){
printf("\nRemplissage du tableau printf("%d\t",A[i]); Exercice 3:
A:\n"); } Ecrire la fonction age(?) qui renvoie l’âge, en jours, d’une personne en saisissant sa
for(i = 0; i < n; i++){ date de naissance (jour, mois , année).
printf("\nAffichage du tableau
printf("Entrer l'element %d :", i+1); B:\n"); Exercice 4 :
scanf("%d",&A[i]); for(i = 0; i < n; i++){ Ecrire une fonction qui calcul la surface d’un rectangle de longueur A et de largeur B.
printf("%d\t",B[i]); Exercice 5 :
}
} Ecrire une fonction qui prend un tableau de 5 entiers, puis retourne la valeur Vraie ou
printf("\nLe tableau Somme
Faux selon que le tableau est trié par ordre croissant ou non.
printf("\nRemplissage du tableau est:\n");
B:\n"); for(i = 0; i < n; i++){
S[i] = A[i] + B[i];
for(i = 0; i < n; i++){ printf("%d\t",S[i]);
printf("Entrer l'element %d :", i+1); }
getchar();
scanf("%d",&B[i]);
getchar();
} }

49
 Les Tableaux
Exercice 7 :
Ecrire le programme qui permet de calculer la moyenne des éléments d’un tableau.
Exercice 8 :
Ecrire le programme qui permet de copier le contenu d’un tableau dans un autre.
Exercice 9 :
Ecrire un programme qui permet de remplir un tableau de caractères et calcul le
nombre de voyelles saisis.
Exercice 10:
Donner un programme en langage C qui permet de trier 6 éléments tapé par clavier
(utilisez les tableaux).
Exercice 11 :
Ecrire le programme qui permet de calculer la moyenne par ligne des éléments d’un
tableau de deux dimensions.
Exercice 12:
Ecrire le programme qui permet de calculer la somme des éléments diagonales d’une
matrice M(n,n);
Exercice 13 :
Ecrire le programme qui permet de calculer la transposée d’une matrice M(n,n);

50