Université d’Alger 1

Faculté des sciences

Département Mathématique Et Informatique
Licence
1ère année

ALGORITHMIQUE ET
STRUCTURE DE DONNÉES 1
TP EN LANGAGE C

Préparé par :
Mme Messabih.H

2021/2022
PLAN
Chapitre 1: langage C
 Instructions de base

 Structures conditionnelles

 Structures répétitives

 Tableaux

 Fonction
STRUCTURES CONDITIONNELLES
 La structure conditionnelles est une structure dont les
instructions sont exécutées selon les réponses des
conditions
STRUCTURES CONDITIONNELLES
 1-Structure conditionnelle simple(un choix)
Syntaxe:

if (Condition) if (Condition) {
Instruction;
Instruction1;
Instruction2;
…..
}
STRUCTURES CONDITIONNELLES
Écrire un programme qui demande un entier à l’utilisateur,
teste si ce nombre est positif (≥ 0) ou non, et affiche “positif”
ou “négatif”.

#include<stdio.h>
#include<stdlib.h>
main() {
int i;
printf("tapez un entier\n");
scanf("%d",&i);
if(i>=0)
printf("il est positif\n");

system("pause");

}
LES OPÉRATEURS DE COMPARAISON

Ils servent à comparer deux expressions entre elles

Symbole Signification
== Est égal à
> Est supérieur à
< Est inférieur à
>= Est supérieur ou égal à
<= Est inférieur ou égal à
!= Est différent de
LES OPÉRATEURS LOGIQUES
 Les opérateurs logiques permettent de combiner des
expressions logiques(conditions).

Symbole Signification
&& et
|| ou
! non
LES OPÉRATEURS LOGIQUES

A B A&&B A||B !A
false false false false true
false true false true true
true false false true false
true true true true false
STRUCTURES CONDITIONNELLES
 2-Structure alternative (deux choix)
Syntaxe:
if (Condition) {
if (Condition)
Instruction1;
Instruction1;
Instruction2;
else
…..
Instruction2;
}
else {

Instruction1;
Instruction2;
…..

}
STRUCTURES CONDITIONNELLES
Écrire un programme qui demande un entier à l’utilisateur,
teste si ce nombre est positif (≥ 0) ou non, et affiche “positif”
ou “négatif”.

#include<stdio.h>
#include<stdlib.h>
main() {
int i;
printf("tapez un entier\n");
scanf("%d",&i);
if(i>=0)
printf("il est positif\n");
else
printf("il est negatif\n");
system("pause");
}
STRUCTURES CONDITIONNELLES
 3-Structure imbriquée (multiple choix)
if (Condition1) {
Syntaxe:
Instructions;
}
else if (Condition2) {

Instructions;
}
else if (Condition3) {
Instructions;
}
else {
Instructions;
}
STRUCTURES CONDITIONNELLES
 4-Structure à choix multiple: switch

switch (Expression){
case valeur1 :Instruction;
break;
case valeur2 :Instruction;
break;

……………………….:………………
case valeurN :Instruction;
break;
default: AuterInstruction;
break;
}
STRUCTURES RÉPÉTITIVES
 La structure répétitive (boucle) permet d’exécuter
plusieurs fois une séquence d’instructions.
 Dans une boucle, le nombre de répétitions peut être
connu, fixé a l’avance, comme il peut dépendre d’une
condition permettant l’arret et la sortie de cette boucle.
 On distingue types de boucles courantes en C :

 1. while

 2. do. . . while

 3. for
STRUCTURES RÉPÉTITIVES (FOR)
 Cette boucle permet d’exécuter une séquence
d’instructions un nombre de fois connu fixé à l’avance.
Utilisée pour préparer notre
variable compteur.
Syntaxe:

for (initialisation; condition; incrémentation){

instruction1;
instruction2;

instructionN;
Est exécutée à la fin de chaque tour de
} boucle pour mettre à jour la variable
C'est la condition qui dit si la
boucle doit être répétée ou non. compteur.

for (initialisation; condition; incrémentation)

instruction1;
STRUCTURES RÉPÉTITIVES (FOR)
#include<stdio.h>
#include<stdlib.h>

main() {
int i;

for (i=0;i<5;i++){
printf("hello \n");
}

system("pause");

}
STRUCTURES RÉPÉTITIVES (WHILE)
 Cette boucle permet de répéter un bloc d’instructions
tant qu’une condition est vraie.
Syntaxe:
while ( Condition ) {
instruction 1 ;
Instruction 2;
Instruction 3;
Instructions à
Instruction N; répéter

La vérification de la condition s’effectue

avant l’exécution des instructions.
STRUCTURES RÉPÉTITIVES (WHILE)
#include<stdio.h>
#include<stdlib.h>

main() {
int i=0;

while (i<5){
printf("hello \n");

i++;
}

system("pause");

}
STRUCTURES RÉPÉTITIVES (DO
….WHILE)
 Cette boucle permet de répéter un bloc d’instructions
tant qu’une condition est vraie.
Syntaxe:
do{
instruction 1 ;
Instruction 2;
Instruction 3;
Instructions à
Instruction N; répéter

} while ( Condition ) ;

La vérification de la condition s’effectue

après l’exécution des instructions.
STRUCTURES RÉPÉTITIVES (DO
….WHILE)
#include<stdio.h>
#include<stdlib.h>

main() {
int i=0;

do {
printf("hello \n");

i++;
} while (i<5);

system("pause");

}
STRUCTURES RÉPÉTITIVES (EX1)
#include<stdio.h>
#include<stdlib.h>

main(){
int i,fj,fi,f,n;
printf("Donner N un nombre entier positif:");
scanf("%d",&n);
fj=0;
fi=1;
for( i=2;i<=n; i++) {
f=3*fi+2*fj;
fj=fi;
fi=f;
}
printf("F%d=%d \n",n,f);
system("pause");
}
STRUCTURES RÉPÉTITIVES (EX2)
#include<stdio.h>
#include<stdlib.h>
main(){
int i,n,signe;
float s,x,p;
printf("Calcul de ln(X+1).\nDonner N et X, deux nombres entier:");
scanf("%d%f",&n,&x);
s=0;p=x;signe=1;
for( i=1;i<=n; i++) {
s=s+signe*(p/i);
p=p*x;
signe=(-1)*signe;
}
printf("ln(1+%f)=%f \n",x,s );
system("pause");
}
#include<stdio.h>
#include<stdlib.h>

main(){

int val,s,choix,min,max,cpt;

printf("************Menu************\n");
printf("[1]->le min des valeurs lues\n");
printf("[2]->le Max des valeurs lues\n");
printf("[3]->la moyenne des valeurs lues\n");

do {
printf("Choix:[1] [2] [3]:");
scanf("%d", &choix);
}while(choix!=1 && choix!=2 && choix!=3 );
printf("Donner un nombre entier:");
scanf("%d",&val);
min=val; max=val; s=0; cpt=0;
while(val!=0) {
if (choix==1 && min>=val)
min=val;
else if(choix==2 && max<=val)
max=val;
if (choix==3) {
s+=val;cpt++;
}
printf("Donner un nombre entier:");
scanf("%d",&val);

switch (choix){
case 1:
printf("Le min :%d \n",min); break;
case 2:
printf("Le max :%d\n",max); break;
case 3:
printf("La moyenne :%f\n",(float)s/cpt); break;
}
system("pause");
}
STRUCTURES RÉPÉTITIVES (EX4)
#include<stdio.h>
#include<stdlib.h>
main(){
int a,b;
printf("Donner deux nombres entiers:");
scanf("%d%d",&a,&b);

while(a*b!=0) {

if (a>b)
a=a-b;
else
b=b-a;

}
if (a==0)
printf("le PGCD(%d,%d)=%d\n",a,b,b);
else
printf("le PGCD(%d,%d)=%d\n",a,b,a);
system("pause");
}
TABLEAUX
 Definition:Un tableau est une suite d’éléments de même
type .

Premier élément
9ème élément

0 1 2 3 4 5 6 7 8 9 Indices

14 12 9.5 11 7.5 13 16 12 10 18
Valeurs
TABLEAUX (DECLARATION)
Syntaxe

Type nom_tab [ Taille];

nom_tab 14 12 9.5 11 7.5 13 16 12 10 18

0 1 2 3 4 5 6 7 8 Taille-1

Exemple:

int T[10];
TABLEAUX (DÉCLARATION ET
INITIALISATION)
Syntaxe 1 :

Type nom_tab [ N]={val1,val2,………,valn};

Syntaxe 2:
Type nom_tab [ ]={val1,val2,………,valn};

Syntaxe 3:
Type nom_tab [ ]={ };
TABLEAUX (REMPLIR UN TABLEAU)
Syntaxe d’affectation:

nom_tab [ indice]=Valeur;

Exemple:
#include<stdio.h>
#include<stdlib.h>
main(){
int i,T[5];
for (i=0;i<5;i++){
T[i]=i+1;
printf("T[%d]=%d\n",i,T[i]);
}
system("pause");
}
TABLEAUX (REMPLIR UN TABLEAU)
Syntaxe de lecteur:
scanf(“%...", &nom_tab [ indice]);

Exemple:
#include<stdio.h>
#include<stdlib.h>
main(){
int i,T[5];
for (i=0;i<5;i++){

scanf(“%d", &T[ i]);

}
for (i=0;i<5;i++)
printf("T[%d]=%d\n",i,T[i]);
system("pause");
}
TABLEAUX (AFFICHER LES ÉLÉMENTS DU TABLEAU)
Syntaxe d’écriture:

printf(“%...", nom_tab [ indice]);

Exemple:
#include<stdio.h>
#include<stdlib.h>
main(){
int i,T[]={1,2,3,4,5};
for (i=0;i<5;i++){

printf(“%d\n", T[ i]);
}
system("pause");
}
 TABLEAUX À DEUX DIMENSIONS
 Un tableau à deux dimensions est à interpréter comme
un tableau de dimension N dont chaque élément est un
tableau de dimension M.

Tab:
N Lignes

M Colonnes
TABLEAUX À DEUX
DIMENSIONS(DÉCLARATION)

Syntaxe :

Type nom_tab [ nbr_lignes][nbr_colonnes];

Exemple:

int A[3][2];
TABLEAUX À DEUX
DIMENSIONS(INITIALISATION)

Syntaxe1 :

Type nom_tab [ N][M]={{val11,val12 ….. ,val1m},

{val21,val22 ….. ,val2m},
…………
{valn1,valn2 ,valnm}};
Syntaxe1 :
Type nom_tab [ N][M]={val11,val12 ….. ,valnm};

Exemple:
int A[3][2]={{1,2},
{10,20},
{100,200}};
TABLEAUX À DEUX
DIMENSIONS(ACCÈS )

Syntaxe d’affectation :

nom_tab [ nbr_lignes][nbr_colonnes]=Valeur;

Exemple:
int A[3][2]=2;
TABLEAUX À DEUX
DIMENSIONS(ACCÈS )

Syntaxe de lecteur:

scanf(“%...", &nom_tab [ nbr_ling] [ nbr_colon]);

Syntaxe remplir tous les éléments:

for (i=0;i<nbr_lignes ;i++){

for (j=0;j<nbr_lignes ;j++){
scanf(“%...", &nom_tab [ i] [ j]);}}
TABLEAUX À DEUX
DIMENSIONS(ACCÈS )

Syntaxe d’écriture:

printf(“%...", nom_tab [ nbr_ling] [ nbr_colon]);

Syntaxe afficher tous les éléments:

for (i=0;i<nbr_lignes ;i++){

for (j=0;j<nbr_lignes ;j++){
printf(“%...", nom_tab [ i] [ j]);}}
FONCTION
Entrées

Sous-
Programmes
Sous-
Programmes

Sous-
Programmes

Résultats
FONCTION

X F(…) y
FONCTION
Une fonction est une suite d’instructions regroupées sous un nom; elle prend en
entrée des paramètres (arguments) et retourne un résultat.

Une fonction est écrite séparément du corps de programme principal (main) et

sera appelée par celui-ci lorsque cela sera nécessaire.
FONCTION

Utilisation de la fonction en
C

Déclarer la fonction Appeler la fonction

 FONCTION

Syntaxe de déclaration de la fonction :

Argument de
fonction
Type_retour nom_fonction (type arg1,type arg2,….) {
Instruction1;
Instruction2;
Instruction3;
….;
return resultat; Traitement
}

Type de Résultat retourné

résultat
retourné
 FONCTION (TYPES)
Void nom_fonction () { Type_retour nom_fonction () {

Instructions;
Instructions;
}
}

Pas de retour et pas Avec retour et pas

d’arguments d’arguments

Pas de retour et avec Avec retour et avec

d’arguments d’arguments

Void nom_fonction (type arg1,..) {

Type_retour nom_fonction (type arg1,..) {
Instructions;
Instructions;
}
}
Procédure
FONCTION (APPEL DE LA FONCTION)
main() { main () {

X= nom_fonction ();
nom_fonction ();
Z= y/ nom_fonction ();
printf(nom_fonction ());
}
}

Pas de retour et pas Avec retour et pas

d’arguments d’arguments

Pas de retour et avec Avec retour et avec

d’arguments d’arguments

main () {
main () {
X= nom_fonction (arg1,…);
nom_fonction ( arg1,..); Z= y/ nom_fonction (arg1,..);
printf(nom_fonction (arg1,..));
}
}
 FONCTION
Exemple: calculer la somme des 5 premiers nombres et la somme des 8 premiers nombres,
puis effectuer le produit entre les deux sommes
Solution 1, sans les fonctions Solution 2, avecles fonctions
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>

main() int somme(int N)

{ { int S, i;
S=0;
int i, S1, S2,P;
for(i=0;i<=N;i++){S=S+i;}
S1=0; return S;
for(i=0;i<=5;i++){S1=S1+i;} }
main()
S2=0; {
for(i=0;i<=8;i++){S2=S2+i;} int S1, S2,P;
S1=somme(5);
P=S1*S2; S2=somme(8);
P=S1*S2;
printf("le produit =%d",P); printf("le produit =%d",P);
} }