Support Algorithmique

Mathématiques et Informatique pour la géologie
Pr. G. Mangoub
Master PVRM
Partie I : Informatique : programmation avec C++

Chapitre 1 : Rappel sur les algorithmes et les différentes structures algorithmiques
Cours préparé par :

Pr. Ghita Mangoub
A. U : 2019-2020
Pr. G. Mangoub
Avant-propos
Ce cours est destiné à tout débutant désirant apprendre les bases d’écriture d’algorithme et sa
traduction en langage C++
Nous avons tenu à ce que ce cours ne présente pas de difficultés à l’apprenant et nous avons
veillé à le présenter d’une façon la plus pédagogique qui nous semble. Les différentes
structures algorithmiques seront exposées ainsi que leur traduction en C++ avec pour chaque
cas différentes applications.
Pr. G. Mangoub
Chap.1 Rappel sur les algorithmes et les différentes structures algorithmiques
I Introduction
Si l’on s’attache au domaine informatique, la réalisation d’une application informatique peut
se schématiser de la façon suivante :
Problème Algorithme Programme Solution au

posé problème
posé
Analyse, choix codage exécution

méthode
Mise en Choix Choix Choix cas

équations méthode langage test
algorith-
mique
Nous remarquons que la phase de création de l’algorithme est en tête du processus qui va
fournir la solution du problème posé. La base de la programmation est donc l’analyse
algorithmique et lorsque l’analyse est bonne, il est possible de programmer dans n’importe
quel langage.
II Qu’est ce qu’un algorithme ?
C’est un inventaire et une mise en forme d’un ensemble d’actions permettant d’accomplir une
tache que l’on s’est fixée d’avance. En effet, c’est une sorte de recette qui donne un résultat
juste lorsque nous exécutons la suite d’actions répertoriées et classées au sein de l’algorithme.
Un algorithme doit être d’une lisibilité et d’une clarté exemplaires afin qu’il puisse être lu et
repris facilement par d’autre utilisateurs, d’où l’intérêt du choix d’une méthode algorithmique
simple et facile à implémenter. C’est-à-dire qu’un algorithme doit refléter une représentation
textuelle des différentes étapes conduisant à la solution du problème avec une série de
conventions ressemblant à un langage de programmation mais sans les problèmes de syntaxe.
Pr. G. Mangoub
Structure d’un algorithme

Un algorithme doit en général comporter les étapes suivantes :
1) Partie déclaration
2) préparation du traitement et lecture des données
3) traitement
4) édition des résultats
Ces étapes peuvent être complétées par l’introduction de commentaires qui peuvent faciliter la
lecture de l’algorithme à l’étape d’édition mais aussi d’autres commentaires qui peuvent en
faciliter la lecture des résultats à l’étape d’exécution.
Dans chaque étape, un ordre fourni se traduit par un ensemble d’instructions. Ces instructions
manipulent des objets. Chaque objet est définit grâce à un ensemble de trois qualificatifs qui
sont :
- L’identificateur : c’est le nom de baptême de l’objet.
- Le type : c’est l’ensemble dans lequel l’objet prend sa valeur.
- La valeur : c’est une valeur précise dans l’ensemble définit par son type .
On note cela de la manière suivante :
objet→ ( identificateur, type, valeur)
Exemple : masse→ ( m, réel, 20 Kg)
Noter qu’un objet doit être déclaré avant d’être manipulé.
II- Les éléments de base d’un algorithme
Un algorithme doit être aussi lisible que possible, d’où l’intérêt des commentaires qui sont de
deux type :
a) Les commentaires qui n’apparaissent pas à l’étape d’exécution
Pour ces commentaires, on utilise le signe // s’il s’agit d’un commentaire sur une seule ligne.
Exemple
// Ceci est un commentaire sur une seule ligne
Pour le cas d’un commentaire qui porte sur plusieurs ligne, on le commence par le signe /*
et on le ferme par le signe */.
Pr. G. Mangoub
Exemple
/* Ceci est un autre
Commentaire
Sur plusieurs lignes
*/
b) Les commentaires qui apparaissent à l’étape d’exécution
On les met entre deux guillemets, on les verra après les ordre d’entrée sortie.
III-1 Types de bases
3 types élémentaires
Les entiers
Courts(short int), normaux(int), long(long int)
Exemple :
a : entier
a, b :entiers courts
Les réels
Courts(float)(32 bits)(6 chiffres significatifs), long(double)(64 bits)(16 chiffres),très long(long
double)(80 bits)
Exemple :
a : réel
a, b :réels longs
Les caractères
Char
Exemple : char a,b,c ;
III-2 constantes, variables

Un algorithme traite une ou des variables entrantes : les données
Il restitue une ou des variables sortantes : les résultats
Pr. G. Mangoub
Un algorithme qui ne satisfait pas à ces deux conditions n’a pas de justification et par
conséquent n’existe pas. Les données traitées par l’algorithme sont de deux types : variable ou
constante. Chaque variable et constante doit être déclarée avant d’être utilisé : nom + type.
Cette déclaration consiste en une réservation en mémoire de la place nécessaire et suffisante à
l’hébergement de la valeur.
Notion de constante : une constante porte un nom qu’on appelle identificateur et garde la
même valeur On la déclare de la façon suivante :
Const type identificateur = valeur_de_la_constante
Exemple :
Const entier N = 10 ;
C’est à dire qu’on déclare que N est une constante entière qui a pour valeur 10.
Notion de variable : Une variable est un endroit en mémoire permettant de stocker une
valeur. Une variable est caractérisée par un nom appelé un identificateur, par un type
(l’ensemble dans lequel elle prend ses valeurs) et par une valeur.
Exemple : si notre variable est la masse alors pour identificateur on peut choisir m, pour le
type c’est un réel et pour la valeur 30Kg.
La syntaxe de la déclaration est la suivante :
identificateur : type
Exemple1 : a : entier
Pour déclarer la variable dont le nom est l’identificateur a comme entier qui peut être positif
ou négatif.
Exemple2 : X,Y,Z : réels
Pour déclarer les 3 variables dont les noms respectifs sont les identificateurs X,Y et Z comme
réels qui peuvent être positifs ou négatifs.
Exemple3 : c : boelien
Pour déclarer la variable dont le nom est l’identificateur c comme boeliène. C’est à dire une
expression logique qui ne peut avoir que deux valeurs soit vrai soit faux.
Exemple4 : a,b,c : char
Pour déclarer les 3 variables dont les noms respectifs sont les identificateurs a, b et c comme
caractères.
Pr. G. Mangoub
En ce qui concerne l’identificateur, il peut être constitué de plusieurs lettres, chiffres et mots
dans ce derniers cas les différents mots sont séparés par un signe souligné c’est à dire « _
«
Exemple : X_a : entier ;
Y_b : réel;
Quelques notions utiles:
1) L’identificateur ne doit pas commencer par un chiffre. Il doit être en rapport avec ce que
contient la variable. Il ne doit pas contenir d’espaces ni contenir le caractère -. En général un
identificateur doit refléter la variable qu’il contient
Exemple : si notre variable est la masse d’un premier objet, on peut choisir comme
identificateur : masse_objet1
2) On peut copier directement une variable initialement déclarée comme entierdans une
variable initialement déclarée comme double.
Exemple a :entier ;
X :réel;
X=a ;
Alors que pour copier une variable initialement déclarée comme double dans une variable
initialement déclarée comme entier, il faut d’abord transformer la variable réelle en une
variable entière .
III-3- Opération entré – sortie

Lis (variable)
Écris ( variable )
Ecris(‘’X=’’,X) pour avoir à l’étape d’exécution X= valeur de X, ainsi, on a utilisé la notion
de commentaire affichable à l’étape d’exécution.
III-4 Expressions
Une expression peut être une instruction ou une suite d’instructions séparées par l’un des
opérateurs suivants :
Opérateurs d'assignation
Pr. G. Mangoub
Affectation d’une valeur ou d’une expression x à une variable y : (y ← x) Addition de la

valeur de gauche à la valeur de droite : + = (x ← x+2) Soustraction de la valeur de gauche à la
valeur de droite : - =
Multiplication de la valeur de gauche à la valeur de droite : * =
Division de la valeur de gauche à la valeur de droite : / =
Incrémentation : ++ : I←I+1 est équivalent à I++
Décrémentation : - - : I←I-1 est équivalent à I--
Opérateurs comparateurs de nombres

Egalité : = =
Infériorité stricte : <
Supériorité stricte : > Infériorité : < =
Supériorité :> =
Différent : ! =
Opérateur logiques
OU : ||
ET : &&
NON :!
Exercice1
Ecrire un algorithme qui lit trois variables réelles A, B et C et qui calcule :
X= A+B
Y= (A*B)-C
W=A+C
On utilisera les commentaires autant que possible
Solution de l’Exercice1
//Utilisation des opérations arithmétiques

//Déclaration
Pr. G. Mangoub
A,B,C,X,Y,Z,W :reel
//lecture des données
Ecris(« donner trois reels A,B et C »)
Lis(A,B,C)
//traitement
X← A+B
Y← (A*B)-C
W←A+C
Si (W !=0)
{
Z← (A-B)/W
Ecris(« Z= »,Z)
}
//Edition des résultats
Ecris(« X=» ,X)
Ecris(« Y= »,Y)
Ecris (« FIN »)
IV- les différentes structures algorithmiques

IV-1 La structure séquentielle
Dans cette structure les étapes conduisant à la solution du problème à résoudre apparaissent
dans un ordre bien défini dans l’algorithme.
EX: Calculer la surface d’un rectangle
// calcul de la surface d’un rectangle
// Déclaration
L,L,S : réel
// préparation du traitement
Ecris(‘’donner la largeur et la longueur du rectangle)
Lis (l,L)
//traitement
S=l*L
// Edition des résultats

Pr. G. Mangoub
Ecris (‘’surface = ‘’,S)

Ecris (‘’Fin’’)
IV-2 Les boucles en algorithmique :la structure ittérative

Si pour résoudre un certain problème, on est obligé de répéter une instruction ou bien
un ensemble d’instructions un certain nombre de fois on parle de structure en boucle
ou encore de structure alternative ou répétitive. Il existe en gros trois façon pour
exprimer cette répétition.
IV-2-1 La structure itérative « pour »
La syntaxe algorithmique de cette structure est la suivante :
Identificateur : entier
Pour identificateur de « Val initiale » à « Val finale » pas de « pas » {traitement}
Fin pour
Remarque
1) Le nombre de traitement de la boucle =
(ValeurFinale – ValeurInitiale)/ pas
2) On utilise cette structure quand on connaît le nombre de passage dans la boucle
EX: Calculer la somme des N premiers entiers
// calcul de la somme des N premiers entiers avec la boucle pour

// Déclaration
I,N,somme : entiers
Ecris(‘’donner un entier N positif’’)
Lis N
//traitement
somme = 0 //initialisation de somme

Pour I de 1 à N pas de 1
somme =somme +I

Pr. G. Mangoub
Ecris (‘’somme = ‘’,Somme)

Exemple d’exécution
donner un entier N positif

10
Somme = 55
Fin
EX: Afficher la table de multiplication d’un entier
// Afficher la table de multiplication d’un entier

// Déclaration
I,N : entiers
Ecris(‘’donner un entier pour lequel vous voulez la table’’)
Lis N
//traitement
Pour I de 0 à 9 pas de 1
Ecris(I,’’*’’,N,’’=’’,I*N)

EX: Ecrire un algorithme qui permet d’afficher N fois de suite le mot ‘phrase1’, puis une
fois le mot ‘phrase2’.
/* Ecrire un algorithme qui permet d’afficher N fois de suite le mot ‘phrase1’, puis une
fois le mot ‘phrase2’. */
// Déclaration
N : entiers
Ecris(‘’donner un entier positif N’’)
Lis N
//traitement
Pour I de 1 à N pas de 1
Pr. G. Mangoub
{
Ecris(‘’ phrase1 ‘’)
}
Ecris(‘’ phrase2 ‘’)
IV-2-2 La structure itérative « Tant que »
TantQue (condition) Faire Bloc de traitement de la boucle FinTantQue
Première méthode
// calcul de la somme des N premiers entiers avec la boucle tant que

// Déclaration
I,N,somme : entiers
Lis N
//traitement

I=0 //initialisation du compteur
Tant que ( I<N ) faire
{
I=I+1
somme =somme +I
}

Deuxième méthode
// calcul de la somme des N premiers entiers avec la boucle tant que

// Déclaration
I,N,somme : entiers
Pr. G. Mangoub

Lis N
//traitement

Tant que ( I<=N ) faire
{
somme =somme +I
I=I+1
}

EX: Afficher la table de multiplication d’un entier. On ne tiendra compte de N que s’il est
>0.
/* Afficher la table de multiplication d’un entier. On ne tiendra compte de N que s’il est >0.
*/
// Déclaration
I,N : entiers
Ecris(‘’donner un entier>0’’)
Lis N
Tant que (N<=0)
{
Ecris(‘’donner un entier>0 pour lequel vous voulez la table’’)
Lis N
}
//traitement
Tant que (I<=9) faire
Ecris(I,’’*’’,N,’’=’’,I*N)
Pr. G. Mangoub
/* d’afficher N fois de suite le mot ‘phrase1’, puis une fois le mot ‘phrase2’.
*/
// Déclaration
I,N : entiers
Ecris(‘’donner un entier>0’’)
Lis N
Tant que (N<=0)
{
Ecris(‘’donner un entier>0 pour lequel vous voulez la table’’)
Lis N
}
//traitement
// si on initialise le compteur à 1 la condition serait I<=N
Tant que (I<N) faire
{
Ecris(‘’phrase1’’)
I=I+1
}
IV-2-3 La structure itérative « répéter Tant que »
Répéter Bloc d'instruction de la boucle TantQue (condition)
Remarque : on utilise cette structure quand on ne connaît pas le nombre de passage
dans la boucle mais que l'on va y passer au moins une fois.
// calcul de la somme des N premiers entiers avec la boucle pour

// Déclaration
I,N,somme : entiers
Lis N
//traitement
Pr. G. Mangoub
I=0 // initialisation du compteur I

Répéter
{I=I+1
somme =somme +I
}
TantQue (I<N)

Exemple d’exécution
donner un entier N positif

10
Somme = 55
Fin
EX: Afficher la table de multiplication d’un entier
// Afficher la table de multiplication d’un entier

// Déclaration
I,N : entiers
Lis N
//traitement
Répéter
{
Ecris(I,’’*’’,N,’’=’’,I*N)
I=I+1
}
TantQue (I<=9)

Pr. G. Mangoub
/* Ecrire un algorithme qui permet d’afficher N fois de suite

le mot ‘phrase1’, puis une fois le mot ‘phrase2’. */
// Déclaration
I,N : entiers
Lis N
//traitement
Répéter
{
I=I+1
}
TantQue (I<N)

Remarque :
Avec la structure pour, le compteur est incrémenté automatiquement, il suffit de
préciser le pas. Par contre avec les deux autres structures, le compteur doit être
incrémenté(ou décrémenté) lors du traitement sans oublier de l’initialiser au départ.
IV-3 La sélection en algorithmique : La structure alternative

Dans cette structure, un certain nombre d’instructions est exécuté si la condition du test est
vérifiée, sinon, c’est un autre groupe d’instructions qui est exécuté. On distingue quatre
variantes de cette structure.
IV-3-1Sélection avec une seule alternative (structure alternative simple)
Lorsqu’il y’a une seule condition à vérifier, la syntaxe algorithmique se présente de la

manière suivante.
Pr. G. Mangoub
Si (condition) { traitement}
EX-1 calculer l’inverse d’un nombre
// calcul de l’inverse d’un nombre
//réalisé par G. Mangoub
//29 Septembre 2014
//déclaration
Nombre,invnombre :réel
Lis (Nombre)
// traitement
Si (Nombre !=0 )
{ invnombre= 1/ Nombre
Ecris (‘’ inverse= ‘’,invnombre)
}

Ecris (‘’FIN’’)
IV-3-2 Sélection avec deux alternatives
Lorsqu’il y’a une deux condition à vérifier, la syntaxe algorithmique peut se présenter
deux manières.
IV-3-2-1 Première variante (structure alternative simple répétée)
Si (Condition1) {traitement1 }
Si (Condition2) {traitement2}
EX calculer la valeur absolue d’un nombre

// calcul de la valeur absolue d’un nombre
//29 Septembre 2014
//déclaration
Nombre,absnombre :réel
Pr. G. Mangoub
Ecris(‘’donnez un reel’’)
Lis (Nombre)
// traitement
Si (Nombre>=0)
{ absnombre= Nombre
Ecris (‘’ val_absolue= ‘’,absnombre)
}
Si (Nombre<0)
{ absnombre= - Nombre
Ecris (‘’ val_absolue= ‘’,absnombre)
}

IV-3-2-2 Deuxième variante (structure alternative complète)
Si (Condition1) {traitement1 }
Sinon{traitement2}
EX calcul de l’inverse d’un nombre
// calcul de l’inverse d’un nombre
//29 Septembre 2014
//déclaration
Nombre,invnombre :réel
Ecris’’Donner nombre reel’’
Lis (Nombre)
// traitement
Si (Nombre !=0)
{ invnombre= 1/ Nombre
Ecris (‘’ inverse= ‘’,invnombre)
Pr. G. Mangoub
}
Sinon
Ecris (‘’ Votre nombre est nul, pas d’inverse ‘’)

EX Editer le résultat pour la résolution d’une équation du second

/* Résolution d’une équation du second degré
A.X2 + B .X +C =0 avec A non nul */
//29 Septembre 2014
//déclaration
A,B,C,D :réel
Ecris’’Donner trois reels A, B et C avec A non nul’’
Lis (A,B,C)
// traitement
D=B*B – 4*A*C
Si (D>=0)
{ Ecris (‘’ solution(s) reelle ‘’)}
Sinon
{Ecris (‘’ solutions complexe ‘’)}

IV-3-3 Imbrication de la sélection (la structure alternative complète imbriquée)
Elle est aussi utilisée lorsqu’il y’ a N conditions à vérifier, avec N>2.
Si (condition1) { traitement1}
Sinon Si (condition2) { traitement2}
Pr. G. Mangoub
Sinon Si (condition3) { traitement3}

.
.
Sinon Si (conditionN-1) { traitementN-1}
Sinon { traitementN}
EX : Editer le résultat pour la résolution d’une équation du second degré uniquement sous
forme de message en utilisant la structure alternative complète imbriquée
//29 Septembre 2014
//déclaration
A,B,C,D :réel
Lis (A,B,C)
// traitement
D=B*B – 4*A*C
Si (D>0)
{ Ecris (‘’ deux racines reelles ‘’)}
Sinon
Si (D<0)
{Ecris (‘’ deux racines complexes ‘’)}

Sinon
{Ecris (‘’ une racine double reelle ‘’)}

Pr. G. Mangoub
IV-3-4 Le choix multiple (la structure alternative de cas)

Elle est aussi utilisée lorsqu’il y’a N conditions à vérifier.
Cette structure peut se présenter de la façon suivante :
Identificateur :entier
Si (condition1) identificateur=1 ;
Si (condition2) identificateur=2 ;
Si (conditionN-1) identificateur=N-1 ;
Si (conditionN) identificateur=N ;
selon(identificateur)
{
cas 1 :{traitement1 ;break ;}
cas 2 :{traitement2 ;break ;}
.
.
case N-1 :{traitementN-1 ;break ;}
default:{traitementN ;break ;}
}
Cette structure est aussi appelée la structure du switch.

Le corps de l'instruction switch prend la forme d'un bloc { } renfermant une suite
d'instructions.
Le fonctionnement de cette instruction est le suivant : expression est évaluée ;
{ s'il existe un énoncé cas avec une constante qui égale la valeur de expression, le contrôle est
transféré à l'instruction qui suit cet énoncé ;
{ si un tel cas n'existe pas, et si l'énoncé default existe, alors le contrôle est transféré à
l'instruction qui suit l'énoncé default ;
Pr. G. Mangoub
{ si la valeur de expression ne correspond à aucun cas et s'il n'y a pas d'énoncé default, alors
aucune instruction n'est exécutée.
Attention. Lorsqu'il y a branchement réussi à un énoncé cas, toutes les instructions qui le
suivent sont exécutées, jusqu'à la fin du bloc ou jusqu'à une instruction de rupture (break).
EX Editer le résultat pour la résolution d’une équation du second avec A non nul.
//29 Septembre 2014
//déclaration
A,B,C,D :réel
I :entier
Lis (A,B,C)
// traitement
D=B*B – 4*A*C
Si (D>0) I=1
Sinon
Si (D<0) I=2
Sinon
I=3

selon(identificateur)
{
cas 1 :{ { Ecris (‘’ deux racines reelles ‘’) ;break ;}
cas 2 :{ {Ecris (‘’ deux racines complexes ‘’);break ;}
Pr. G. Mangoub
cas3:{ {Ecris (‘’ une racine double reelle ‘’) ;break ;}

}
Ecris(‘’ FIN de l algorithme’’)
Remarque :
On peut remarquer ici que la nature de la structure alternative nous a obligé dans la majorité
des cas de ne pas respecter la structure tracée au départ. C’est à dire l’affichage des résultats
dans le second bloc et non le troisième.
Combinaison de conditions
L'opérateur logique ET
si note >= 5 alors {

si note < 10 alors {
Ecrire ("vous devez passer le rattrapage du module");
}
Ces deux si imbriqués reflètent une combinaison de deux conditions qui peut se traduire
par si la valeur de note est supérieure ou égale à cinq et que la valeur de note est inférieure à
dix, alors effectuer l'instruction, ce que l'on écrira :
si note >= 5 et note <=10 alors {

Ecrire ("vous devez passer le rattrapage du module ");
}
L'opérateur logique OU
Pour exprimer l'alternative, on utilise l'opérateur ou, la condition du si sera vraie si au moins
une des sous-conditions est vraie. Il faut donc que toutes les sous-conditions soient fausses
pour que le sinon soit exécuté.
si x < 0 ou x == 0 alors {
Ecrire ("l inverse de la racine carre de votre nombre x ne peut pas être calculee");
}
sinon {
Ecrire ("l inverse de la racine carre de votre nombre x vaut :", 1/sqrt(x));
}
Il est possible de donner plusieurs conditions :
si cd1 ou cd2 ou cd3 alors {

traitement1
}
Pr. G. Mangoub
sinon {
traitement2
L'opérateur logique NON
L'opérateur non représente la négation, il peut s'appliquer à une variable ou à une condition à
évaluer. En effet, dire "X<0" est une négation de "X>=0".
si non(X<0) alors {
Ecrire (" Votre nombre X a une racine carre);
}
sinon {
Ecrire (" Votre nombre X n’a pas de racine carre);
}
EX : écrire un algorithme qui classe par ordre croissant et qui affiche trois nombres lus au
clavier.
V- Les tableaux statiques
Supposons qu’on a une grande liste d’éléments de même type à manipuler, dans ce cas il
est plus commode de les caser dans un tableau dont le nombre de case est égale au nombre
d’éléments qu’on veut manipuler.
V-1 Les tableaux statiques à un seul indice (1D)
Déclaration
Pour les tableaux statiques 1D, la taille N c’est à dire le nombre de cases est fixée une fois
pour toute au début du programme. La numérotation des éléments commence à partir de 0
et se termine à un indice égal à N-1. Le i ème élément occupe donc la case (i-1) du
tableau. L’indice est obligatoirement un entier.
Syntax algorithmique de déclaration d’un tableau 1D :

type nom_du_tableau[taille]
Exemple
entier T[10] pour déclarer un tableau de 10 entiers.

reel V[20] ; pour déclarer un tableau de 20 réels
Pr. G. Mangoub
Autre façon de déclarer T

constante N=10
entier T[N]
Manipulation des tableaux statiques 1D

a) Lecture et affichage
Exemple
Ecrire un algorithme qui lit et affiche un tableau d’entiers
// algorithme qui lit et affiche un tableau d’entiers

//déclaration
entier T[10]
I :entier
//préparation du traitement
Pour(I allant de 0 jusqu’à 9 par pas de 1)
{ecris(‘’donner l’elmt ‘’,I)
Lis T[I]
}
//traitement et affichage
Ecris(‘’voici votre tableau ‘’)
Pour(I allant de 0 jusqu’à 9 par pas de 1)
Ecris(T[I])
Ecris(‘’FIN’’)
Exemple
Ecrire un algorithme qui lit et affiche un tableau d’entiers de dimension N avec la
dimension déclarée comme constante.
// algorithme qui lit et affiche un tableau d’entiers

//déclaration
Constante N=10
entier T[N]
I :entier
//préparation du traitement
Pour(I allant de 0 jusqu’à N-1 par pas de 1)
{ecris(‘’donner l’elmt ‘’,I)
Lis T[I]
}
//traitement et affichage
Ecris(‘’voici votre tableau ‘’)
Pour(I allant de 0 jusqu’à N-1 par pas de 1)
Ecris(T[I])
Ecris(‘’FIN’’)
b) Recherche dans un tableau un seul indice
Exemple :
Pr. G. Mangoub
trouver le plus petit élément et sa position
Syntax algorithmique :
entier I,pospp,pp
Contante entier N=10
Pospp=0
Pp=T[0]
Pour I allant de 0 jusqu’à N-1 par pas de 1 fait
{si(T[I]<PP
{ pp=T[I]
Pospp=I
}
}
c) Tri des éléments d’un tableau à un seul indice
Ici nous ne présentons qu’un cas simple d’algorithme de tri dont le principe est le suivant :
Supposons que l’on veut classer par ordre croissant N variables casées dans un tableau. On
commence par supposer que la première variable est celle qui est la plus petite et on la
compare aux N-1 autres variables. Si cela est toujours vrai, la première variable dans
l’ancienne numérotation garde sa place, sinon on échange la place de cette variable avec la
première petite trouvée et ainsi de suite jusqu’à ce que la première case soit occupée
effectivement par la variable minimale, ensuite on fait pareil avec la deuxième variable, sans
toucher à la première et ainsi de suite sans toucher aux variables déjà triées . L’algorithme se
présente de la manière suivante :
Syntax algorithmique :
entier I,ECH
Contante entier N=10
Pour I allant de 0 jusqu’à N-2 par pas de 1 fait

Pour J allant de J+1 jusqu’à N-1 par pas de 1 fait
{si(T[I]> T[J]
{ ECH=T[I]
T[I]=T[J]
Pr. G. Mangoub
T[J]=ECH
}
}
for (I = 0 ;I<N-1 ; I++)
for (J = I+1; J<N ; J++)
if (B[I]> B[J])
Valint= B[I];
B[I]= B[J];
B[J] = valint ;
}
d) Suppression et tassement
On veut dans un tableau supprimer certains éléments et décaler vers la gauche d’autres
éléments du tableau à leur place. Dans les cases vides, on mettra des zéro.
Exemple
On donne
2 4 0 0 10 0 3 5 6 12
Et on veut arriver au tableau suivant :
2 4 10 3 5 6 12 0 0 0
Ecrire l’algorithme correspondant
V-2 Les tableaux statiques à deux indices (2D)
Pour Ces tableaux statiques à deux indices, le nombre de lignes NL et le nombre de

colonnes NC sont fixés une fois pour toute au début du programme. La numérotation des
éléments commence à partir de (0,0) et se termine à un indice égal à (NL-1,NC-1).
Syntax de déclaration d’un tableau à deux indices :

type nom_du_tableau[NL][NC] ;
Pr. G. Mangoub
Exemple : int A[5] [6]; pour déclarer une matrice à 5 lignes et 6 colonnes dont les
éléments sont des entiers.
Manipulation des tableaux statiques 2D

a) Lecture et affichage
Exemple
Ecrire un algorithme qui lit et affiche une matrice A(NL,NC)avec NL et NC déclarés
comme constante. NL=3 et NC=4
Exemple
b) Mise à zéro des éléments des deux diagonales
Ecrire un algorithme qui lit une matrice A(NL,NC)et qui met à zéro les éléments des deux
diagonales.
c) Produit de deux matrices

Exemple
Ecrire un algorithme en C qui lit deux matrices carrées A(N,N)et B(N,N) et calcule leur
produit, soit C=A*B.

Support Algorithmique

Transféré par

Informations du document

Titre original

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Support Algorithmique

Transféré par

Droits d'auteur :

Formats disponibles

Mathématiques et Informatique pour la géologie

Partie I : Informatique : programmation avec C++

Cours préparé par :

Chap.1 Rappel sur les algorithmes et les différentes structures algorithmiques

Problème Algorithme Programme Solution au

Analyse, choix codage exécution

Mise en Choix Choix Choix cas

Structure d’un algorithme

II- Les éléments de base d’un algorithme

III-2 constantes, variables

III-3- Opération entré – sortie

Affectation d’une valeur ou d’une expression x à une variable y : (y ← x) Addition de la

Opérateurs comparateurs de nombres

//Utilisation des opérations arithmétiques

IV- les différentes structures algorithmiques

// calcul de la surface d’un rectangle

// Edition des résultats

Ecris (‘’surface = ‘’,S)

IV-2 Les boucles en algorithmique :la structure ittérative

un ensemble d’instructions un certain nombre de fois on parle de structure en boucle

ou encore de structure alternative ou répétitive. Il existe en gros trois façon pour

exprimer cette répétition.

IV-2-1 La structure itérative « pour »

La syntaxe algorithmique de cette structure est la suivante :

Pour identificateur de « Val initiale » à « Val finale » pas de « pas » {traitement}

1) Le nombre de traitement de la boucle =

(ValeurFinale – ValeurInitiale)/ pas

2) On utilise cette structure quand on connaît le nombre de passage dans la boucle

EX: Calculer la somme des N premiers entiers

// calcul de la somme des N premiers entiers avec la boucle pour

somme = 0 //initialisation de somme

// Edition des résultats

Ecris (‘’somme = ‘’,Somme)

donner un entier N positif

EX: Afficher la table de multiplication d’un entier

// Afficher la table de multiplication d’un entier

// Edition des résultats

IV-2-2 La structure itérative « Tant que »

La syntaxe algorithmique de cette structure est la suivante :

TantQue (condition) Faire Bloc de traitement de la boucle FinTantQue

EX: Calculer la somme des N premiers entiers

// calcul de la somme des N premiers entiers avec la boucle tant que

somme = 0 //initialisation de somme

// Edition des résultats

// calcul de la somme des N premiers entiers avec la boucle tant que

Ecris(‘’donner un entier N positif’’)

somme = 0 //initialisation de somme

// Edition des résultats

IV-2-3 La structure itérative « répéter Tant que »

La syntaxe algorithmique de cette structure est la suivante :

Répéter Bloc d'instruction de la boucle TantQue (condition)

Remarque : on utilise cette structure quand on ne connaît pas le nombre de passage

dans la boucle mais que l'on va y passer au moins une fois.

EX: Calculer la somme des N premiers entiers

// calcul de la somme des N premiers entiers avec la boucle pour

I=0 // initialisation du compteur I

// Edition des résultats

donner un entier N positif

// Afficher la table de multiplication d’un entier

// Edition des résultats

/* Ecrire un algorithme qui permet d’afficher N fois de suite

// Edition des résultats

Avec la structure pour, le compteur est incrémenté automatiquement, il suffit de