*** 1ère Année LMD ***

Cours d’Algorithmique et
structures de données
*** (Semestre 01) ***
chapitre 1 : introduction générale
1-Définition d'informatique :
Le mot informatique a été créé en 1962 par Philippe Dreyfus. Il s’agit d’un néologisme de la
langue française fait de la contraction des deux mots « automatique » et « information ».

comme son nom l'indique, permet d'automatiser l'information que nous manipulons. Cette
informatisation permettra de réaliser un gain considérable en temps et en effort.

On peut voir l’informatique selon deux aspects : matériel (hardware) et logiciel (software).

Le schéma suivant résume les composants matériels et logiciels d’un ordinateur :

2- Définition d'ordinateur :
Un ordinateur se définit comme une machine de traitement de l’information. Il est
normalement capable d’acquérir et de conserver des informations, d’effectuer des
traitements et restituer les informations stockées.
2- Histoire de l'informatique :
Si l'informatique en tant que telle n'existe que depuis quelques dizaines d'années, ses
origines sont issues de nombreux domaines et remontent pour certaines à très longtemps.

Pour relater chronologiquement les avancées de l'informatique, on se basera ici

principalement sur les progrès concernant les aspects matériels.

Les ancêtres des ordinateurs reviennent aux machines et instruments purement mécanique
qui aident à faire des calcule tel que :

Pascaline (1642) : crée par Blaise Pascal capable de faire l'addition et la soustraction
amélioré en 1673 par Leibniz afin de faire la multiplication et la soustraction.

Vers 1936, les premiers calculateurs binaires ont apparut : le Bell Labs Relays
Computer de Stibitz (1937), machine qui utilisait des relais électromécaniques, puis le Z1
(1938) de Zuse (en Allemagne), Mark I(1943) d'IBM (pèse 5 tonnes et mesure 17 m de long
et 2,5 m en hauteur).

l'ENIAC réalisé en 1946 par J.P.Eckert et J.W.Mauchly est le premier véritable

ordinateur électronique. Cette machine qui pesait 30 tonnes occupait un volume de 85 m.

Ici commence en fait l'histoire de l'informatique. En effet, les problèmes techniques de la

réalisation des ordinateurs ne furent vraiment résolus que par l'arrivée de l'électronique.

L’apparition du transistor et circuit intégrés révolutionne l’informatique, permettant d'aller

des grands ordinateurs vers des micros ordinateurs plus petites et plus performants.

La fin des années 70, puis les années 80 ont vu un essor particulièrement
remarquable de

l'informatique "personnelle": (PC (1981):

en 1977: Lancement du Apple II, premier ordinateur personnel carrossé en plastique et

présentant une interface graphique en couleur.

en 1981: Sortie du PC d'IBM

Les avancées technologiques s’accélèrent considérablement dans les années 1990.

Aujourd’hui, la micro-informatique se développe à un rythme très rapide. Avec la
miniaturisation des composants matériels, on parle de nano-technologie.
chapitre 2 : Algorithmique Séquentiel simple
1- notion d'algorithme
1-1- l'origine du mot algorithmique :

Le mot algorithme vient du nom du mathématicien arabe du 9ème siècle Al Khou Warismi.
Son nom, déformé par la latinisation, a fourni le terme « algorithme ».

Son apport en mathématiques fut tel qu’il est également surnommé « le père de l’algèbre »,
En effet, il fut le premier à répertorier de façon systématique des méthodes de résolution
d’équations en classant celles-ci.

1-2- définition d'algorithme:

Un algorithme est une suite finie et non-ambiguë d'actions (opérations) logiquement

ordonnées permettant de résoudre un problème donné.

L’algorithmique reste la base dure de l’Informatique. Généralement un algorithme consiste à

traité un ensemble de données pour avoir des résultats, il est considéré comme un outils de
transformation d’un ensemble de données en entrée, en un nouvel ensemble de données en
sortie (résultats).

Exemples d’algorithmes :

- Une recette de cuisine (ingrédients → plat préparé)

- La recherche dans un dictionnaire (mot → définition)

- La division entière (deux entiers → leur quotient)

- calcule de la surface d'un rectangle (largeur et longueur → surface)

- Le tri d’une séquence (séquence → séquence ordonnée)

1-3 Propriétés d'un algorithme :

Un bon algorithme doit être :

- Claire est non ambigüe.

- Universel (Général) : Il doit tenir compte de tous les cas possibles. Il traite le cas général

et les cas particuliers.

- Finis : Il doit toujours s’arrêter au bout d’un temps fini.

- Structuré :un algorithme doit être composé de différentes parties facilement identifiables.

- Il est indépendant des langages de programmation et des matériels informatiques.

• Déterministe : Dans des conditions d’exécution similaires (avec des données identiques), il

fournit toujours le même résultat.

2- Notions de programme, langage et compilation

Langage de programation : est un ensemble de règles syntaxiques (comment écrire

correctement un programme) et sémantiques (le sens affecté à chaque instruction ou structure
du programme).

Le langage Algorithmique : comme les langages de programmation, le langage

algorithmique utilise un vocabulaire et respecte des règles d’écriture universelles.
Contrairement au langage de programmation, l’algorithmique est très proche des langages
humains. Un algorithme est la formalisation de la solution d’un problème par l’être humain
et il n’est destiné pour être interpréter par la machine. Alors l’algorithmique n’impose pas le
respect stricte de sa syntaxe.

programme : un ensemble d’instructions destinées à être exécutées par un ordinateur.

C’est la traduction d’un algorithme en utilisant (en respectant) un langage de programmation.

Programme exécutable (code binaire) : programme écrit en langage machine (en binaire)
directement exécuté par la machine sans l'intervention d'un autre programme. il suffit de le
lancer.

Instruction : action que l’ordinateur connait et peut réaliser.

Jeu d’instructions : ensemble des instructions autorisées dans un langage de

programmation.

Bloc d'instructions : sous séquence d'instructions cohérent. elles sert généralement à

déterminer l'ensemble d'instructions d'une fonction ou une structure de contrôle. Il est aussi
possible de définir un bloc à l’intérieur d’un autre bloc (blocs imbriqués )

Code source : code d'un programme écrit en utilisant un langage de programmation.

Compilation : action permet de transformer un code source en code binaire, de manière à

obtenir un fichier exécutable à partir d’un fichier source.

Le compilateur peut indiquer une erreur, qui empêche de finaliser la compilation. Dans
ce cas-là, il n’est pas possible de créer le fichier exécutable correspondant à ce programme. Il
est donc inutile de tenter d’exécuter le programme si la compilation a échoué.

Mots clés : sont des mots prédéfinis et réservés utilisés en programmation qui ont une
signification particulière pour le compilateur. Les mots-clés font partie de la syntaxe et ils ne
peuvent pas être utilisés comme identifiant.
Un identificateur : Un identificateur est un nom utilisé pour nommer (identifier) un élément
ou une entité d' un programme (ou d'un algorithme) que se soit : une variable, une fonction,
un programme, un algorithme. IL ne doit pas être un des mots clés.

Ce nom peut être composé de lettres et chiffres et doit obligatoirement commencer par une
lettre (pas un chiffre), et ne doit pas contenir de lettres de ponctuation, l’espace

en particulier.

Les commentaires :Un commentaire est un texte libre qui peut être étendu sur

plusieurs lignes et encadré par les séquences de caractères ”/*” et ”*/”.

les commentaire à mettre quelque explications ou remarque concernant le code source.

un commentaire n’est pas pris en compte à la compilation. Autrement dit, il n’a aucune
influence sur l’exécution de l’algorithme.

4- structure d'un algorithme :

L’algorithme se compose de façon générale de trois blocs :

a- L’entête : permet de donner un nom (un identificateur) à l’algorithme en utilisant le mot clé
"Algo"

b-La partie déclaration : pour définir (déclarer) tous les éléments nécessaires dont la
machine aura besoin (variables, constantes, modules ...) pour résoudre le problème.

c) Le corps de l’algorithme : contient les actions (les instructions) à exécuter pour résoudre
le problème. il est délimité par les mots clés ‘Debut’ et ‘Fin’
5- les données :
On distingue deux types de données manipulées par un algorithme:

- des objets qui peuvent varier durant le déroulement d'un algorithme : Variables.

- des objets qui ne peuvent pas varier par le déroulement qui

5-1 Les variables :

une variable est un objet qui associe un nom à une donnée manipulé par l'algorithme.

chaque variable se caractérise par :

- un nom unique (l'identificateur): pour le distinguer et le référer.

- un type : exprime la nature de cette dernière

- une valeur qui peuvent être modifiée au cours de déroulement de l’algorithme.

Elle associe également ce nom à l'emplacement mémoire bien précis la où on stocke la valeur
de donnée manipulée.

Déclaration :

Toute variable utilisée dans un algorithme doit être déclarée avant le traitement. Ceci
consiste à indiquer son nom et son type pour que l'ordinateur lui réserve une case mémoire.

La déclaration se fait dans la partie déclaration de l'algorithme en utilisant le mot clé Variable
ou VAR.

La syntaxe de déclaration des variables est comme suit :

var nom_de_la_variable : type_de_la_variable

Remarque : Il n’est pas nécessaire de répéter les mots clés ‘VAR’ pour chaque déclaration.

Exemple1 :

Var compteur : entier

x : réel

lettre : caractère

trouve : booléen

Lorsque plusieurs objets sont de même type, nous pouvons les regrouper dans une même et
seule déclaration comme suit :

nom_de_la_variable1, nom_de_la_variable2, nom_de_la_variable1,... : type_des_variables

Exemple2:

Var i, j : entier

n , x, y : réel

5-2 Les constantes :

les constantes sont utilisées pour simplifier la programmation. Une constante reçoit sa valeur
au moment de sa déclaration et elle n’est pas modifiable. Après compilation d’un programme,
les constantes sont remplacées par leurs valeurs.

Déclaration :

la déclaration se fait dans la partie déclaration de l'algorithme en utilisant le mot clé Constant
ou CONST comme suit :

CONST nom_de_la_constante = valeur

Exemple

CONST Pi = 3.14

CONST max = 100

CONST trouve = Vrai

Remarque : il n’est pas nécessaire de répéter les mots clés ‘CONST’ pour chaque
déclaration.

6- type de données:
Un type est un domaine de définition qui détermine l’ensemble des valeurs qu’un objet peut
prendre, sa représentation en mémoire d’un ordinateur ainsi qu’un ensemble d'opérations
pour le manipulé.

On distingue deux sortes de types :

a- Type simple : type de données décrivant une information atomique.

b- Type complexe : type de données décrivant une information composite, constituée de

plusieurs valeurs, elles-mêmes de types simples ou complexes.

types de base :

Type entier :

Le type entier est l’ensemble des entiers relatifs, cependant il faudra signaler que si en
mathématiques cet ensemble est infini, sur un ordinateur les valeurs sont limitées par la
longueur des mots mémoires.

si le mot mémoire est sur 32 bits --> les nombre entiers sont dans l'intervalle[-2(16-1) , 2(16-1)]
Type réel : Le type réel est l’ensemble des nombres ayant une partie fractionnelle.

type caractère :

Les caractères sont un ensemble de symboles pouvant apparaitre dans un texte qui peuvent
être :

Des lettres alphabétiques (majuscule + minuscule) : ‘A’ ‘B’ ...

- Des chiffres : ‘0’ .. ‘9’

- Les caractères spéciaux : ‘,’ ‘?’ ‘#’ ‘$’...

- Le caractère espace (blanc) : ‘ ’

la machine ne manipule que des 0 et des 1; Dans les cas des caractères, on doit établir une
correspondance entre les élément de type caractère et une représentation binaire.

Dans ce cadre plusieurs standard de codage ont été proposés ( ASCII, IBM-PC, ISO-xxx, . .. ).

La norme ASCII à cet effet. Dans sa version de base, elle associe un code numérique à
128=27 caractères différents. Il s’agit principalement de lettres majuscules et minuscules,
de chiffres, de signes de ponctuation, et de caractères non-imprimables.

0 1 2 3 4 5 6 7 8 9 A B C D E F
000 NUL SOH STX ETX EOT ENQ ACK BEL BS HT LF VT FF CR SO SI

001 DLE DC1 DC2 DC3 DC4 NAK SYN ETB CAN EM SUB ESC FS GS RS US

002 SP ! " # $ % & ' ( ) * + , - . /

003 0 1 2 3 4 5 6 7 8 9 : ; < = > ?

004 @ A B C D E F G H I J K L M N O

005 P Q R S T U V W X Y Z [ \ ] ^ _

006 ` a b c d e f g h i j k l m n o

007 p q r s t u v w x y z { | } ~ DEL

Type booléen (logique)

Le type booléen constitue l’ensemble des valeurs {vrai, faux}.

Type chaine de caractère

Le type chaîne de caractères sera utilisé pour stocker des séquences finies de
caractères. Le nombre de caractères composant une chaîne de caractères est la
longueur de cette chaîne.
7- Les opérations de base
Un opérateur : est un signe utilisé pour effectuer une opération arithmétique ou logique (+,
- , *...).

Un opérande : est une donnée ou valeur entrant dans une opération (arithmétique ou
logique).

On distingue de type d'opération selon le nombre d'opérandes :

a- Opération unaire : est une opération qui ne nécessite qu'un seul opérande.

b- Opération binaire : est une opération qui nécessite deux opérandes.

Les expressions :Une expression est une suite d’opérandes (variables, constantes,
fonctions) combinées par un ensemble d'opérateurs avec éventuellement un jeux de
Parenthèses ouvrantes et fermantes.

En algorithmique les traitements arithmétique et logique sont effectués en utilisant des

opérateurs. On distingue plusieurs types d’opérateurs :

7-1 des opérations arithmétiques :

Les opérateurs arithmétiques : sont applicables sur des nombres (entier, réel).

mod modulo, il fournit le reste de la division, ex : 20 mod 3 = 2 ;

7-2 Les opérateurs logique :

sont applicables sur des données de type boolienne :

7-3 Les opérateurs relationnels :

ils sont utilisés pour comparer les valeurs de deux variables. Ils produisent un résultat
booléenne (vrai/faux).

Remarque :

Les entiers et les réels sont comparés selon l'ordre numérique usuel. Les caractères sont
comparés selon l'ordre déni par le code ASCI I : chaque caractère est codé par un entier
compris entre 0 et 255, appelé code ASCI I, et pour comparer deux caractères, on compare
leur code ASCI I. Dans ce code, les chiffres sont inférieurs aux caractères majuscules qui sont
eux-mêmes inférieurs au caractères minuscules.

7-4 Evaluation des expressions : une expression arithmétique ou logique est évaluée
en respectant l’ordre de priorité des opérateurs. La machine effectue un seul calcul à la fois,
de ce fait lorsqu’une expression contient plusieurs opérateurs de même priorité, l’opérateur le
plus à gauche est évalué en premier.

donc :

- Un opérande placé entre 2 opérateurs de priorités différentes sera lié à l’opérateur de priorité
la plus élevée.

Exemple1 : X * a + b : L’opérande a sera lié à l’opérateur *.

- Un opérande placé entre 2 opérateurs de même priorité sera lié à l’opérateur se trouvant à
gauche.

Exemple2 : X + b - c : L’opérande b sera lié à l’opérateur +

Exemple 3 :

Utilisation des parenthèses :

Les parenthèses sont utiliser pour éliminer l’ambiguïté concernant l’ordre de réalisation des
opérations (peut même changer l'ordre d'évaluation).

Les expressions entre parenthèses sont évaluées en premier en commençant par les
parenthèses les plus intérieures.

Les expressions contenues entre parenthèses sont évaluées séparément, puis leur résultat
est traité comme un seul opérande.

Exemple :

(a + b) * c : On évalue l’addition a+b, puis la multiplication (*) de c par le résultat de a+b.

8- Les instructions de base :

8-1 L'Affectation :

L’affectation consiste à attribuer (affecter) une valeur à une variable.

L’affectation est notée par le signe ←. selon la syntaxe suivante

variable ← valeur

La valeur attribuée peut être :

 Une constante (valeur direct ) :

Exemples :

n←5 x←3.5 c ← 'b' s ← 'bonjour'

 Une autre variable :

Exemples :

X←Y Nombre ← Resultat i←k

 La valeur d'une expression

Exemples :

X ← Y+1

Nombre ← Resultat * 2

moy ← (a*c1 + b*c2) / (c1+c2).

8-2 Opération d'entée sortie :

la lecture (instruction d'entrée ) :

permet d’introduire des données, venant de l’extérieur (via le clavier), dans des variables.

elle a la syntaxe suivante :

Lire (variable) ;

on peut lire une ou plusieurs variables à la fois.

Lire (variable1, variable2,…, variablen) ;

Exemple : lire(a) ; permet d'introduire la valeur de a via le clavier.

A l’exécution de l’instruction lire(a), le programme se met en attente jusqu’à ce que

l’utilisateur saisie une valeur au clavier et valide par la touche entré. La valeur saisie est

sauvegardée ensuite dans la case mémoire réservée pour la variable a.

cette instruction permet de généraliser l’algorithme (traiter le cas générale des données ) et
ces à l'utilisateur finale du programme de spécifier( d'introduire ) à chaque exécution la les
valeurs des données voulus.

l'écriture (instruction de sortie) :

permet d'afficher des résultat ou des simple message à l'utilisateur sur un périphérique de
sortie (l'écrans )

Syntaxe :

Ecrire(d)

Tel que: d peut être une constante , une variables, une expression ou une chaine de
caractère.
l’instruction Ecrire peut afficher plusieurs éléments en même temps (séparées par des
virgules) :

Ecrire (d1, d2 ….)

Exemple :

Ecrire(a) ; affiche la valeur de la variable a.

Ecrire(pi) ; affiche la valeur de la constante pi.

Ecrire(x,y,z) ; affiche les valeurs des variables x, y, et z.

Ecrire('Bonjour') ; affiche le message Bonjour

Ecrire (a+b) affiche la somme de a et b

Ecrire ('la moyenne est ', moy) affiche le message la moyenne est suivie par la valeur de la
variable moy.

9- Exemple d'un algorithme :

l'algorithme suivant permet de calculer la moyenne des deux nombre

Algo Moyenne

Var x,y,moy : entier

Début

Ecrire ('SVP entrer le premier nombre ')

lire (x)

Ecrire ('SVP entrer le deuxième nombre ')

lire (y)

moy ← (x+y) / 2

Ecrire (la moyenne des deux nombre est ', moy )

Fin
9- Représentation d'un algorithme avec un organigramme :
un organigramme (ou algorigramme) permet de représenter graphiquement un algorithme, il
montre l'enchaînement des opérations et des décisions effectuées par un algorithme.

10 - Langage C
C est un langage de programmation impératif, de bas niveau. Inventé au début des années
1970 pour réécrire UNIX, C est devenu un des langages les plus utilisés. il est universel,
rapide et extensible.

10-1 Structure d'un programme en C:

Un programme C d'un ensemble de parties optionnelles et d'un programme principale :

[ directives au préprocesseur]

[ déclarations de variables externes]

[ fonctions secondaires]

main()

déclarations de variables internes

instructions

* Le préprocesseur est un programme exécuté lors de la première phase de la compilation. Il

effectue des modifications textuelles sur le fichier source à partir de directives. Les différentes
directives au préprocesseur, introduites par le caractère #, ont pour but :
 - L'incorporation dans le fichier source le texte figurant dans un autre fichier. Ce dernier
peut être un fichier en-tête de la librairie standard (stdio.h, math.h,...) ou n'importe quel
autre fichier en utilisant la directive #include

- La définition de constantes symboliques et de macros (#define),

- la compilation conditionnelle (#if, #ifdef,...).

* Les fonctions secondaires peuvent être placées indifféremment avant ou après la

fonction principale.

* La fonction main() constitue le programme principal. C’est la partie obligatoire dans un

programme C.

10-2 Instructions et commentaire :

Les instructions : En C les instructions peuvent être (affectation, déclaration, appelle d'une
fonction ou une expression).

- Chaque instruction se termine par un point virgule;

- On peut écrire plusieurs instructions dans la même ligne

Bloc d'instructions : En C les blocs d'instructions sont délimitées par des accolades

Les commentaires : les commentaires en C peuvent apparaître n’importe où dans le

programme pour donner des explications ou des remarques. Ces derniers peuvent être écrit :

- Sur un seul ligne en utilisant le signe // tous ce qui suit ce signe jusqu'à la fin de la ligne est
considérer comme commentaire

- Sur plusieurs lignes en utilisant /* pour exprimer son début et */ pour exprimer son fin

10-3 Les types prédéfinis

Les types entiers :

Le type entier est l’ensemble des entiers relatifs,

. En C en distingue 4 sous types d'entier: int, long, short, long et long long

ces tailles ne sont pas standardisées, elle dépendent de la machine, du système d’exploitation
et du compilateur. Ces tailles peuvent être trouvées en utilisant l’instruction sizeof(<type>). un
bit est réservé pour coder le signe, les autres bits codent la valeur absolue du nombre.

Le type PC Intel (Linux) Description

short 16 bits entier court
int 32 bits Entier standard
long 32 bits entier long
long long 64 bits entier long (non ANSI)
Ces types admettent le qualificatif unsigned. Dans ce cas, il n’y a plus de bit pour représenter
le signe, et seuls les nombres positifs sont codés.

Les types réels : représente des nombres en virgule flottante

En C, nous avons le choix entre trois types de réels: float, double et long double

Le type PC Intel Description

float 32 bits flottant
double 64 bits flottant double précision
long double 128 bits flottant quadruple précision

Le type caractère :

Le mot-clef char désigne un objet de type caractère. Un char peut contenir n'importe quel
élément du jeu de caractères de la machine utilisée. La plupart du temps, un objet de type
char est codé sur un octet ; Le jeu de caractères utilisé correspond généralement au codage
ASCII (sur 7 bits).

En langage C, le type char est un cas particulier du type entier.

on distingue deux type de caractère :

a- Caractère imprimable : code représentant un caractère apparaissant à l’écran ou lors

d’une

pression papier.

Exemples : lettres, chiffres, signes de ponctuations, mais aussi le caractère espace.

b- Caractère non-imprimable : (ou caractère de contrôle) : code ne représentant par un

caractère, mais une commande utilisée notamment pour la mise en forme.

Exemple : retour à la ligne, tabulation

Remarque : En C il n'existe pas de type spécial pour les variables booléennes. Si l'utilisation
d'une variable booléenne est indispensable, on utilisera une variable de type int. Les
opérations logiques en C retournent toujours des résultats du type int : 0 pour faux et 1 pour
vrai.

10-4 Les opérateurs en C :

Opérateurs arithmétique :

Opérateurs Opération
+ Addition
- Soustraction
* Multiplication
/ Division (entière ou rationnel)
% Modulo (reste d'une div entire )
Opérateurs logiques:

Opérateurs Opération
! Négation logique
|| Ou logique
&& Et logique

En C : le type booléen est exprimé par les deux valeur entière 1 et 0 (1 exprime le vrai et 0
pour exprimer le faux).

Les opérateurs de comparaisons

Opérateurs Signification
== Egale à
!= Différent de
> Supérieur
< inferieur
>= Supérieur ou égale
< Inferieur ou égale

La valeur rendue est de type int (il n'y a pas de type booléen en C); elle vaut 1 si la condition
est vraie, et 0 sinon.

10-5 L'affectation :
l'affectation s'exprime par le signe =

elle a la syntaxe suivante :

variable = expression ;

exemples i = 5 ; x = a / b;

10-6 Les variables et les constants :

a- La déclaration des variables :

elle a la syntaxe suivante :

Type NomVar1, NomVar2,..., NomVarN;

Exemples :

int compteur, i, j; float hauteur, largeur; double m; char c;

- il n’existe pas une partie dédiée à la déclaration des variables. Toutefois, toute variable doit
faire l’objet d’une déclaration avant d’être utilisée.
une valeur initiale peut être affectée à une variable lors de sa déclaration.

comme suit :

type nomVariable = valeur;

Exemple : int i = 1;

pour les expressions de la forme: var1 = var1 op (expr2) Il existe une formulation ()
équivalente: expr1 op= expr2

exemple : L’affectation i = i + 2 peut s’écrire i + = 2

b- Déclaration des constantes :

Une constante peut être déclarée sous la forme :

const Type Identificateur = Valeur ;

Elle peut aussi être définie en utilisant la directive #define:

#define Identificateur Valeur

La directive #define demande au préprocesseur de substituer toute occurrence de

Identificateur par Valeur dans la suite du fichier source.

Exemple :

# define pi 3.14

main ( )

const float max = 100 ;

...

10-7 Les opérateurs d'affectation composés :

Pour les expressions de la forme: variable = (variable) op (expr2) Il existe une formulation
équivalente: variable op= expr2

Opérateurs Signification exemple équivalant

+= Ajouter à X+= y X= X+Y
-= Diminuer de X-= Y X-= Y
*= Multiplier par X*= Y X*= Y
/= Diviser par X/= Y X/= Y
10-8 Les opérations d'incrémentation et de décrémentation :
L'incrémentation et la décrémentation s'exprime en utilisant les deux opérateurs unaires ++ et
-- qui s'appliquent sur un variable ils le permettent de l'ajouter (ou de le diminuer) un 1.

l' opérateurs ++ (ou --) peut être utilisés sous forme de préfixe (pré-incrémentation ) ou de
suffixe (poste-incrémentation) d'un opérande

a- Pré-incrémentation : utilisation d'opérateur ++ comme préfixe

Syntaxe : ++operand

l'opérande est incrémenté d'abord de 1 et la valeur résultante de l'opérande est utilisée dans
l'évaluation de l'expression.

Exemple:

i = 3;

j = ++i ; // j = 4

b- Poste-incrémentation : utilisation d'opérateur ++ comme suffixe

Syntaxe : operand++

la valeur actuelle de l'opérande (l'ancienne valeur) est utilisée dans l'expression, puis la valeur
de l'opérande est incrémentée de 1 .

Exemple :

i = 3;

j = ++i ; // j =4

10-9 Opération d'entrée sortie :

La lecture :

En C pour lire une variable (introduire sa valeur de l'extérieur en utilisant le clavier) en utilise la
fonction scanf

Syntaxe : scanf (format, p1,p2,......);

La fonction scanf lit les caractères à partir de l’entrée standard, les interprète selon les
spécificateurs de conversion dans la chaine de caractère format et sauvegarde les données
d’entrée converties dans les paramètres Pi qui expriment les variables concernées, dont les
noms(les identificateurs des variables) doivent être précédés par le signe &

Type Lettre Signification

Int %d ou %i Entier relatif
Long %ld Entier long
float / double %f / %lf Nombre rationnel en notation décimale
Float/ double %e / le Nombre rationnel en notation scientifique
Float / double %g / %lg Nombre rationnel en notation décimale ou scientifique
Char %c caractère
string (char*) %s Chaine de caractère
entier hexadécimal %x ou %b Entier exprimé en hexadécimale

Exemple :

include <stdio.h>

main () {

int i ; float x;

scanf ("%f", &x);

scanf ("%d %d", &i, &j);

L'écriture :

Le langage C utilise la fonction printf() pour afficher des informations à l’écran

Syntaxe : printf (format , expr1, expr2, ...);

format est une chaîne de caractère qui peut contenir :

- du texte

- des séquences d'échappement ( saut de la ligne: \n , tabulation: \t ...)

- des spécificateurs de format ( un spécificateur pour chaque expression) tel que : %d, %f

la fonction prinf() remplace chaque spécificateur de format par la valeur de l'expression (ou
variable) correspondante passée en paramètre en respectant le format précis (exactement à
l'emplacement d'occurrence de la spécificateur de format).

Exemple : soit le programme suivant :

l'affichage correspondant est comme suit :

Remarque :

- Il est indispensable d'inclure la bibliothèque stdio.h afin d'utiliser les deux fonctions scanf et
printf.

- il existe d'autres fonctions qui permet de faire la lecture ou l'écriture des caractères ou des
chaines de caractères tel que : getc, putc, get et put.
Chapitre 3

Les structures conditionnelles

Les instructions d’un algorithme s’exécutent les unes après les autres, dans l’ordre où elles
ont été écrites. On exécute normalement les instructions de la première à la dernière, sauf
lorsqu’on rencontre une structure conditionnelle qui permet de suivre différents chemins
suivant les circonstances. L’instruction ne sera exécutée que sous certaines conditions.
I. Structure conditionnelle simple (à un choix)
Une structure conditionnelle simple contient un seul bloc d’instructions. Selon une
condition (expression logique ou booléenne), on décide est-ce-que le bloc d’instructions
est exécuté ou non. Si la condition est vraie, on exécute le bloc, sinon on ne l’exécute pas.
La syntaxe d’une structure conditionnelle simple est comme suit :
En algorithmique En langage C
si (condition) alors if (condition)
{
instruction(s) ; instruction(s);
finsi ; }
Organigramme correspondant :

Exemple :
Écrire un algorithme qui demande un entier (A) à l’utilisateur, teste si ce nombre est positif
(A≥ 0) et affiche "positif".
Solution :
algorithme positif ;
debut
var A : entier ;
ecrire ("entrer la valeur de A ") ;
lire (A) ;
si (A ≥ 0) alors
ecrire (" positif ") ;
finsi ;
fin.

1
Les structures conditionnelles

II. Structure conditionnelle alternative (à deux choix)

Une structure conditionnelle alternative contient deux blocs d'instructions : on est amené à
décider entre le premier bloc ou le second. Cette décision est réalisée selon une condition
(expression logique ou booléenne) qui peut être vraie ou fausse. Si la condition est vraie
on exécute le premier bloc, sinon on exécute le second. La syntaxe d'une structure
conditionnelle alternative est comme suit :

En algorithmique En langage c
si condition alors if (condition)
{
instructions 1 instructions 1;
}
sinon else
{
instructions 2
instructions 2;
finsi ; }

Organigramme correspondant

Exemple :
Écrire un algorithme qui demande un entier (A) à l’utilisateur, teste si ce nombre est positif
(A ≥ 0) ou non, et affiche "positif" ou "négatif".
Solution :
algorithme positif ;
debut
var A : entier ;
ecrire ("entrer la valeur de A ") ;
lire (A) ;
si (A ≥ 0) alors
ecrire ("positif ") ;
sinon
ecrire ("négatif ") ;
finsi ;
fin.

2
Les structures conditionnelles

III. Structures conditionnelles imbriquées

Les structures conditionnelles imbriquées fait appel à plus de deux blocs d’instructions.
L’exécution d’un bloc entraîne automatiquement la non-exécution des autres blocs. La
syntaxe d'une structure conditionnelle imbriquée est comme suit :

En algorithmique En langage c
si (condition) alors if (condition)
{
instructions 1 ;
instructions 1 ;
sinon }
si (condition 2) alors else
instructions 2 ; if (condition2)
sinon {
instructions 2 ;
}

si (condition (n-1)) alors

if (condition(n-1))
instructions (n-1) ; {
sinon instructions(n-1) ;
instructions n ; }
finsi ; else
{
finsi ;
Instructions n ;
finsi ; }

Organigramme correspondant

Exemple :
Écrire un algorithme qui demande un entier à l’utilisateur, teste si ce nombre est strictement
positif, nul ou strictement négatif, et affiche ce résultat.

3
Les structures conditionnelles

Solution :
algorithme positif ;
var A : entier ;
ecrire ("entrer la valeur de A") ;
Lire (A) ;
si (A ≥ 0) alors
ecrire ("positif") ;
sinon
si (A = 0) alors
ecrire ("nul" ) ;
sinon
ecrire ("négatif" ) ;
finsi ;
finsi ;
fin.

VI. Structure conditionnelle de choix multiple

Le choix d’un traitement se fait suivant la valeur d’un sélecteur. Cette structure permet d’éviter
le recours à une structure conditionnelle imbriquée et offre une meilleure lisibilité de la solution.
En algorithmique En langage c :
selonque selecteur faire switch (selecteur) {
case Valeur1 :
Valeur1 : instructions 1 ;
instructions 1;
Valeur2 : instructions 2 ; break;
case Valeur2 :
instructions 2;
break;
Valeu n : instructions n ;
sinon
instructions n+1 ; case Valeurn :
instructions n;
finselonque ; break;
default:
instructions n+1;
}

Remarques :
- Le sélecteur doit être de type entier ou caractère et doit avoir une valeur avant d’être impliqué
dans le Selonque.
- Selecteur et valeur1, valeur2, …, valeurN doivent être du même type.
- Les instructions relatives aux valeurs peuvent comporter également d’autres structures
conditionnelles.
- Valeuri peut être un ensemble des valeurs qui seront séparées par des virgules ou intervalle
des valeurs (borne_inf .. borne_sup).
- Si expression n'est égale à aucune des valeurs allant de valeur1 à valeurN, c'est le bloc Sinon
qui est exécuté. Ce bloc est optionnel.

4
Les structures conditionnelles

Exécution du selonque
On suppose que la valeur du sélecteur est connue avant de commencer le Selonque (soit par
une lecture, soit par une affectation). À partir de cette valeur, on va s’aiguiller directement au
traitement (instructions) correspondant à cette valeur puis l’exécuter. À la fin de l’exécution,
on continuera la suite de l’exécution du programme à partir de la 1ère instruction qui vient après
finselonque. Dans le cas où la valeur du sélecteur n’existe pas parmi les choix possibles, on
exécutera le traitement Sinon du Selonque.

Organigramme correspondant

V. Structure de contrôle de branchements / sauts (l'instruction "aller à ")

Un algorithme utilise l’instruction "aller à" ainsi que des étiquettes pour faire des
branchements. L’étiquette donne une position dans l’algorithme, l’instruction "aller à"
demande à l’algorithme d’aller directement à l’endroit de l’étiquette désigné pour continuer
l’exécution.
La syntaxe d'un branchement est comme suit :

En algorithmique En langage c :
aller à <etiq> goto <etiq>;

<etiq> : <etiq> :
. .
. .

5
Les structures conditionnelles

Exemple :
algorithme branchement ;
var a, b: entier ;
debut
lire (a) ;
1 : b a ;
si b mod 2 = 0 alors
aller à 2 ; // branchement conditionnel (branchement appartenant au bloc si)
finsi ;
a  a+1 ;
aller à 1 ; // branchement inconditionnel (branchement n’appartenant pas au bloc si)
2 : ecrire ("c’est pair") ;
Fin.

Dans l'exemple ci-dessus, il y a deux étiquettes : l’étiquette 1 (ba) et l’étiquette 2

(ecrire ('c’est pair')). Voici un exemple de déroulement de l’algorithme pour a = 5.
Variables A B Affichage
Instructions
Lire (a) 5
b a 5 5
b mod 2 = 0 faux on 6 5
n’entre pas au bloc du si
a a+1 ;
aller à 1 6 6
ba;
b mod 2 = 0 vrai on entre 6 6 C’est pair
au bloc si
aller à 2 ecrire(‘c’est pair’)

Remarque :
Un branchement en lui-même n’est pas très intéressant. La pratique des informations a montré
que l’utilisation des goto donne souvent des programmes non maintenables (impossible à
corriger ou modifier). Les problèmes qu’ils posent ont amené les programmeurs expérimentés
à ne s’en servir qu’exceptionnellement.

6
chapitre 4: Structures itératives (les boucles )
1- Introduction :
Pour résoudre un problème, Il est souvent nécessaire de répéter plusieurs fois le même
traitement. Par exemple en délibération le calcule de la moyenne se répète pour chaque
étudiant.

En Algorithmique la structure utilisée est la structure itérative appelée, aussi boucle.

Une boucle permet d’exécuter plusieurs fois consécutives un ou plusieurs instructions (bloc
d'instruction).

Il y a principalement trois types de boucles : la boucle Tantque , la boucle pour , la boucle

Répéter.

On désigne par le mot Itération : la réalisation d'un cycle complet de la boucle; en d'autre
terme elle indique qu’on exécute une fois le bloc d'instructions de la boucle(le traitement à
répéter).

2- La boucle Tantque :
La boucle Tantque permet de répéter l’exécution d’un bloc d’instructions tant qu’une
condition est vraie. La condition est exprimée par une expression logique ou booléenne.

Syntaxe en Algorithmique :

Tantque (condition) alors

instructions

finTantque

Syntaxe en C :

while (condition)

instructions

}
Principe de fonctionnement (Déroulement) :

la boucle Tantque fonctionne de la façon suivante :

1- évaluation de la condition;

2- si la condition est vraie (vaut vrai), on exécute le bloc d'instructions de la boucle et on

recommence en 1 (refaire le test).

3 - si la condition est fausse, on sort de la boucle et on exécute sa suite (le reste de

l'algorithme).

La boucle Tantque est très utile lorsque le nombre d’itération n’est pas connu à l’avance.

Remarque : Il faut s’assurer que les instructions de la boucle permettent de modifier la

valeur de sa condition, si ce n’est pas le cas, dans le cas où la condition et satisfaite; la
boucle ne s’arrête jamais et on obtient ce que appelle boucle infini.

Exemple : Soit l’exemple d’algorithme suivant, qui demande un nombre entier. Si ça valeur
est inférieur de 100 alors on double ça valeur. à la fin en affiche ça valeur finale.

En algorithmique En C
Algo Double #include <stdio.h>
Var n: entier Main()
Début {
lire(n) int n;
Tantque (n < 100 ) Faire scanf ("%d", &n);
n ←i * 2 while(n < 100)
FinTantque {
Ecrire (n) n = n * 2;
Fin }
Printf ("%d", n );
}
Supposant que l'utilisateur à introduire la valeur 40 dans ce cas l'algorithme exécute deux
itérations. On peut pas faire la troisième itération car la condition est non satisfaite(160 >100)

Etape Valeurs de n avant itération Valeurs de n après itération

1ère itération 40 40*2 = 80
2ème itération 80 80*2 = 160
3- La boucle Répéter :
La boucle Répéter quant à elle, fait la même chose que la boucle TantQue, sauf qu’elle teste
une condition à la fin de l’exécution de chaque itération.

Le bloc d'instructions est exécuté au moins une fois contrairement à la boucle Tanque dont
on peut ne pas exécuter sa bloc d'instruction (si la condition dès le début est non satisfaite).

Syntaxe En Algorithmique :

Répéter

instructions

jusqua (condition)

Principe de fonctionnement :

Le principe de fonctionnement de la boucle Répéter (en Algorithmique, en Pascal) est

comme suit :

1- exécution du bloc d’instructions;

2- évaluation de la condition (d’arrêt) ;

3 - Si la condition est fausse, on recommence à 1 ;

4 - Si la condition est vraie, on sort de la boucle et on exécute sa suite(le reste du

programme).

la condition testée à la fin c'est une condition pour sortir de la boucle (on répète le traitement
jusqu' ce que la condition est satisfaite) (même principe en Pascal et en Basic).
Syntaxe En C :

en C elle à la syntaxe suivante :

do

instructions

} while (conditions);

Principe de fonctionnement en C :

le même principe est appliqué sauf que la condition testée à la fin c'est une condition de
continuité de la boucle en d'autre terme si la condition est satisfaite on ré-exécute le bloc
d'instructions. c'est le même principe appliqué en plusieurs langage de programmation telque
Java, PHP, ...

Exemple :

Soit l'algorithme suivant permettant de calculer la somme d’une suite de nombre saisis au
clavier(en doit introduire au moins un nombre), la saisie s’arrête lorsque l’utilisateur saisie la
valeur 0.

En algorithmique En C
Algo SommeSuite #include <stdio.h>
Var n,som : réel Main()
Début {
som ←0; float n, som ;
Repeter som = 0;
Lire (n) do {
som ← som + n; scanf ("%f", &n);
Jusqua (n = 0) som = som + n ;
Ecrire ('la somme est ,som ) } while (n != 0)
Fin Printf ("la somme est %f", som );
}

4- La boucle Pour :
Elle permet de répéter l’exécution d’un bloc d’instructions un certain nombre de fois connu à
l’avance.

Une variable Dite compteur de type entier est utilisée pour contrôler le nombre d’itérations de
la boucle (généralement en utilise les identificateur i, j, k, l.... comme nom des conteurs ).
Syntaxe en Algorithmique :

elle a la syntaxe suivante :

Pour cpt allant de Vi à Vf Pas = Vp faire

instructions;

finpour;

cpt : est le conteur de la boucle.

vi : valeur initiale du compteur.

vf : valeur finale du compteur.

pas : le pas d'incrémentation de la boucle.

Par défaut, le pas d'incrémentation est 1. Donc dans ce cas la on peut ne pas le mettre.

principe de fonctionnement :

Le déroulement de la boucle pour peut être décrit comme suit :

1.initialiser le compteur (cpt) (variable de contrôle) avec la valeur initiale (vi);

2- tester si la valeur du compteur cpt inferieur à la valeur finale vf :

3- Si le test est vrai alors

• exécuter le bloc d’instructions de la boucle pour;

• incrémenter le compteur par son pas (par défaut on l'incrémente par 1);

• recommencer à l'étape 2 ;

4.Si le test est faux alors sortir de la boucle et exécuter l’action qui suit la fin du bloc pour (le
reste de l'algorithme).
Il ne faut surtout pas modifier la valeur du compteur de la boucle dans sa bloc d'instructions .
En effet, sa modification est intégrée à l’instruction Pour elle même.

La boucle pour en langage C :

La boucle pour en C est exprimée par le mot clé for

syntaxe (en C):

for(initialisations; condition; modifications)

instructions ;

En effet, le mot-clé for, qui précède le bloc, est suivi de trois expressions séparées par des
points-virgules :

- La première permet d’effectuer l’initialisation : elle est exécutée une seule fois, au

début de la boucle ;

- La deuxième est la condition : elle est évaluée au début de chaque itération ;

- La troisième est la modification : elle est exécuté à la fin de chaque itération (généralement
elle est utilisée pour incrémenter la variable du compteur de la boucle).

À noter qu’il est possible d’initialiser/modifier plusieurs variables de boucle en même temps
en utilisant des virgules dans les expressions ex: for(x=1,y=10; x=y; x++,y--) {//....}

principe de fonctionnement (En C) :

Le déroulement de la boucle for est comme suit :

1- exécuter les expressions d'initialisation de la boucle.

2- évaluer la condition;

3- Si la condition est satisfaite alors :

- exécuter le bloc d'instructions de la boucle for;

- évaluer les expressions de modifications de la boucle;

4- si la condition n'est pas satisfaite alors on sortir de la boucle et exécuter l’action qui suit la
fin du bloc d'instructions pour (le reste de l'algorithme).
Exemple :

Soit l'algorithme suivant qui permet d'afficher les nombre de 1 à 30

En Algorithmique En C
Algo Afichage #include <stdio.h>
Var i : entier Main()
Pour (i de 1 à 30 ) Faire {
Ecrire (i) int i ;
FinPour for(i =1; i<=30; i++)
Fin {
Printf ("%d", i );
}

en peut le faire en utilisant la boucle Tanque comme suit :

En algorithmique En C
Algo Afichage #include <stdio.h>
Var i : entier Main()
i ←1; {
Tantque (i < 30 ) Faire Int i = 1;
Ecrire (i) while(i < 30)
i ←i+1; {
FinTantque Printf ("%d", i );
Fin i= i+1; // ou bien i++;
}
}

Remarques :

- On peut implémenter la boucle Pour en utilisant une décrémentation de l'indice de la

boucle (en gardant le même principe de fonctionnement) (utilisation de down to en Pascal /
i--; en C).

- La boucle Tantque suffit pour exprimer tous les traitements itératifs (en peut exprimer les
deux autre forme de boucle en utilisant la boucle Tantque ).

- Une boucle peut contenir une autre structure de contrôle (conditionnelle ou itérative).

- En C c'est le bloc d'instruction d'une structure conditionnelle ou itératif ne contient qu'une

seule instruction; dans ce cas les accolades de ce bloc sont facultatives.
chapitre 5 : les tableaux et les chaines de caractères
1- introduction :
Si on veut manipuler une suite de données de types simples (réels, entiers, caractère).il est
indispensable de déclarer pour chaque donnée une variable correspondante chose qui est
difficile à faire et rend l'algorithme moins lisible.

si en prend l'exemple des notes des étudiants il est indispensables de déclarer pour chaque
étudiant une variables sinon on perd la trace de ces données.

L'un des solutions proposées est d'utiliser la structure de donnée tableau qui permet de les
regrouper et de faciliter sa manipulation en utilisant une seule variable(identificateur).

Un tableau donné peut contenir des éléments de n’importe quel type, mais d’un seul type à la
fois. On peut accéder à chaque élément en utilisant un ou plusieurs indices.

on distingue deux type de tableau : les tableau d'une dimension et les tableaux multi
dimensionnel.

2- Tableau à une dimension ( vecteur) :

Un tableau à une dimension, appelé aussi vecteur est une structure de données désignée par
un identificateur unique permettant de stocker un nombre fini d'éléments de même type.
chaque élément est accessible en utilisant un seul indice (avec l'identificateur du tableau).

Taille d’un tableau : nombre d’éléments maximal que le tableau peut contenir.

Indice d'un tableau : est une variable entière qui permet d’accéder aux éléments d’un
tableau. elle indique le rang (la position) (numéro de la case) d'un élément.

Un indice peut avoir les valeur :

- De 1 jusqu'à la taille du tableau (cas du langage pascal,...).

- De 0 jusqu'à (la taille du tableau - 1) (cas du langage C,Java).

Exemple : l'exemple suivant montre le tableau T (T est l'identificateur) qui contient 5

éléments (taille = 5 ) de type réel. la valeur de l'indice de la case qui contient la valeur 133.1
est 3

T 3.14 2.8 -7.9 133.1 - 88.3

0 1 2 3 4
Déclaration d'un tableau à une dimension:

Syntaxe de déclaration en Algorithmique :

Pour déclarer une variable de type tableau en utilise la syntaxe suivante :

Va r identificateur_du_tableau : tableau [ Borne_inf .. Borne_sup ] de Type_éléments .

borne_inf : représente la valeur minimale de l'indice (0 en C, 1 en pascal)

borne_sup : représente la valeur maximale de l'indice.

type_éléments : représente le type des éléments du tableau.

On peut déduire la taille du tableau en calculant la déférence entre les deux bornes de l'indice.

Une fois qu’un tableau a été déclaré, on ne peut plus changer sa taille.

Exemple :

Var T : tableau [0..4] de réel

Remarque : on peut déclarer un tableau d'une autre manière en définissant tout d'abord un
nouveau type ensuite on déclare une variable de ce type comme suit :

Type identificateur_type = tableau [born_inf..borne_sup] de type_éléments ;

Var identificateur_tableau : id_type ;

Exemple :

Type Notes = tableau [0..4] de réel

Var T: Notes

Syntaxe de déclaration en C :

Pour déclarer une variable de type tableau en utilise la syntaxe suivante :

type_éléments identificateur_du_tableau [taille] ;

- type_éléments : représente le type des élément du tableau (int, float, char,...).

Exemple :

float T[5];
Utilisation des tableaux :

accès au éléments d'un tableau unidimensionnelle :

on accède à un élément du tableau comme suit :

identificateur_du_tableau [indice_de_élément]

pour affecter à une case (un élément du tableau) une valeur en écrit comme suit :

identificateur_du_tableau [indice_de_élément] ← valeur

Exemple : soit le tableau suivant

T 3.14 2.8 -7.9 133.1 - 88.3

0 1 2 3 4

On peut par exemple récupérer dans une variable n la valeur du case à la position 3 comme
suit : n ← T[3]

On peut aussi affecter à cette dernière la valeur 50.6 comme suit : T[3] ← 50.6

Remarque :

Une erreur est engendrer si on tente d'accéder à des éléments situés hors du tableau (indice
> borne_sup ou indice < borne_inf), on appelle ça Débordement de tableau.

Lecture et écriture d'un tableau :

pour lire ou écrire les élément d'un tableau il faut le faire élément par élément

par exemple : lire (T(0)), lire (T(1)), lire (T(2))..... lire (T(n))

Pour éviter la répétition, nous utilisons une des structures itératives(Pour, Tanque ou Répéter).

Exemple : la lecture d'un tableau de 5 éléments réel est comme suit :

En Algorithmique En C
Algo lecture #include <stdio.h>
Var T : tableau [0..4] de réel Main ()
I : entier {
Début float T [5]
Pour (i allant de 0 à 4 ) alors int i ;
Lire (T[i]) for (i=0; i<= 4 ; i++ )
FinPour scanf("%f", &T[i]);
}
Fin
Remarque : Un tableau peut-être totalement ou partiellement lu. Ce n’est pas obligatoire
d'utiliser toutes les composantes du tableau, pour cela on déclare une variable entière N qui
représente la taille du tableau à utiliser. La valeur de cette variable sera introduite au cours de
l'exécution (par lecture). elle doit être supérieur du borne_inf et inferieur ou égale à born_sup.

Algo Lecture

Var T : Tableau [0..99] de entier

N, pos : entier

Début

/* lecture de n en assurant que n appartient à [0..99] (réintroduire n le cas échéant ) */

Repeter

Lire (N) ;

Jusqua ((N>=0) et (N<100))

/* lecture des éléments du tableau */

Pour i allant de 1 jusqua N faire

Lire (T[i]) ;

FinPour

Fin

Recherche d’un élément dans un vecteur

Ci-dessous un exemple d'un l'algorithme permettant de rechercher une valeur dans un

tableau en récupérant sa position (sa première occurrence ).

algorithme recherche_valeur

Var T : Tableau [0..99] de entier

N, Val,i, pos : entier

Trouve : booleen

Debut

Pour i allant de 0 jusqua 99 faire

Lire (T[i])
FinPour

Lire (Val)

i ← 0;

Trouve ← Faux ;

Tantque ((i <= 99) et (Trouve=Faux)) faire

Si (T[i] = Val) alors

Trouve ← Vrai

pos ← i

FinSi

i←i+1;

FinTantque ;

Si (Trouve = Vrai) alors

Ecrire ('La valeur ', Val, 'existe')

Ecrire ('Sa position est', pos)

Sinon

Ecrire ('La valeur’, Val, 'n''existe pas')

FinSi

Fin.

3-Tableaux à deux dimensions (matrices) :

Définition :

On appelle matrice A d’ordre m et n, notée A(m, n), un ensemble de m * n éléments rangés

dans des cases disposées en m lignes et n colonnes.

Notons que l’élément d’une matrice, noté A[i, j], est repéré par deux indices; le premier indique
la ième ligne et le second indique la jème colonne.

Exemple : soit la matrice suivant A(3*4)

12.3 8 -9 2
30 55 7.66 100
-88 62 46 87
Déclaration d'une matrice :

en garde les mêmes principes mais cette fois ci on utilise deux indice.

En Algorithmique :

voici la syntaxe de déclaration :

Var id_mat: tableau [premier_indice_ligne..dernier_indice_ligne, premier_indice_colonne

.. dernier_indice_colonne] de type_des_éléments

Exemple : on peut déclarer la matrice précédente comme suit :

Var A : tableau [0..2, 0..3] de réel

En langage C :

en la déclare comme suit :

Type_elements id_mat [nombre_lignes][nombre_colonnes] ;

Exemple : la matrice précédente est déclarer comme suit :

float A [3][4]

Manipulations des éléments d'une matrice :

Chaque élément de la matrice est repéré par deux indices; le premier indique la ième ligne et
le second indique la jème colonne. en utilisant la syntaxe suivante :

id_matrice [indice_ligne, indice colonne]

Exemple : Dans l'exemple précédent A[1,3] signifie l'élément de ligne numéro 1 et la colonne
numéro 3.

pour lire ou écrire une matrice en applique le même principe du vecteur mais cette fois ci en
utilisant deux boucle imbriquées; l'une pour parcourir les ligne et l'autre pour parcourir les
colonnes en d'autre terme on fait le parcours des ligne; pour chaque ligne parcourue on fait le
parcours de ses colonnes.

Exemple :

Si on veut lire la matrice A précédente on doit faire :

Algo lire_matrice;

Var A : [0..2, 0..3] de réel

i, j : entier
 Debut

Pour i allant de 0 jusqua 2 faire

Pour j allant de 0 jusqua 3 faire

Lire (A[i,j])

FinPour

FinPour

Fin.

4- Les chaines de caractères :

Définition

Les chaînes de caractères sont des séquences finies de caractères. Le nombre de

caractères composant une chaîne de caractères est la longueur de cette chaîne.

Une chaîne de longueur nulle ne comprend aucun caractère : c’est la chaîne vide.

En algorithmique, une chaîne de caractères est encadrée par des guillemets simples '
(apostrophe )

En C, une chaîne de caractères est encadrée par par des doubles guillemets "

Exemple :

- La chaine 'bonjour' constituée des caractères 'b','o','n','j','o','u','r'

- La chaine ' ' constituée d'un espace.

- La chaine '' est la chaine vide.

Déclaration en Algorithmique :

on peut la déclarer en précisant ou non sa longueur comme suit

Var nom_variable : chaine [longueur] ;

ou bien

Var nom_variable : chaine ;

Exemple : Var s1: chaine [7]

s2: chaine
Déclaration en C :

Il n'existe pas de type spécial pour les chaînes de caractères en langage C. Une
chaîne de caractères est déclarée comme un tableau à une dimension de char (vecteur de
caractères) dont la fin est indiquée par le caractère '\0'. La taille de la chaîne est égale à la
longueur maximale de la chaine plus un pour qu’on puisse stocker le caractère '\0' dénotant la
fin.

elle est déclarée comme suit :

char nom_variable [longueur] ;

Exemple : char s[8];

Initialisation d’une chaîne de caractères

Pour initialiser une chaîne de caractères, nous déclarons la variable chaîne et affectons sa
valeur initiale.

En Algorithmique :

Var s : chaine [10] ;

s ← 'Bonjour' ;

En langage C :

En C on peut initialiser directement une variable de type chaine de caractères que dans sa
déclaration de deux façons :

- la première consiste à introduire lors de sa déclaration l'ensemble des caractère voulus.

Exemple : char s[] = { 'b','o','n','j','o','u','r', '\0'};

- la deuxième consiste à attribué directement la valeur de la chaine voulue.

char s[] = 'bonjour' ; /* l'ordinateur réserve automatiquement le nombre d'octets nécessaires

pour la chaîne, c.-à-d.: le nombre de caractères + 1 (ici: 8 octets). */

char s[8] = 'bonjour' ; /* indication explicite du nombre d'octets à réserver, le nombre

d’octets doit être supérieur ou égale à la longueur de la chaîne. */

Accès aux éléments d’une chaîne de caractères

L'accès à un élément d'une chaîne de caractères peut se faire de la même façon que l'accès à
un élément d'un tableau. en utilisant s[2]

Exemple : Pour la chaîne s précédente, nous avons :

s[0] égale à 'b' , s[3] = 'j' s[7] = '\0' ;

Lecture et affichage

En algorithmique, une chaîne de caractères est lue (affichée) globalement (d'un seul coup) et

non pas caractère par caractère.

En algorithmique :

On peut lire ou écrire la totalité d'une chaine caractères en utilisant lire et Ecrire.

Exemple :

Lire (s) Ecrire (s)

En langage C : On peut lire (afficher) une chaîne de caractères de deux façons :

Première façon : scanf ("%s", s) ; printf ("%s", s) ;

Deuxième façon : gets (s); puts (s);

La différence entre scanf et gets est que scanf amène uniquement le texte introduit
avant le premier blanc (espace) dans la variable à lire. gets amène tout le texte introduit
jusqu'au retour chariot (retour à la ligne) dans la variable à lire.

Comparaison de chaînes de caractères

Comme pour les caractères, la comparaison des chaînes de caractères se base sur l’ordre
des codes internes des caractères. Pour comparer deux chaînes de caractères, on compare

tous d'abord les deux premiers caractère S'ils sont égaux on passe aux deux caractère du
rang suivant et ainsi de suite. jusqu'au on trouve deux caractères du même rang qui sont
différent.

Le résultat de comparaison des deux chaines est celle de la dernières comparaison faite.

Exemples :

• 'bonjour' < 'salut' car le code ASCII de b vaut 98 est inférieur au code 's' vaut 115.

• "bonjour" < "bonsoir" : les trois premiers caractères sont les mêmes donc en compare le j et
le s (j < s car le code ASCII de 'j' (106) est inferieur au code ASCII de 's'(110)).

Fonctions et procédures sur les chaînes de caractères

plusieurs fonctions et procédure sont définies pour manipuler les chaine de caractères
(recherche, concaténation, insertion....)

Exemple :

Pour calculer la longueur d'une chaine : en algorithmique on utilise la fonction long. En C on

utilise la fonction Strlen de la bibliothèque string.h
chapitre 6 : Les types personnalisés
1- introduction :
Outre que les données de type simple(entiers, réels, caractère, booléen), un programme traite
souvent d'autres types de données plus complexes et plus évolués. La construction de ces
types se base essentiellement sur la personnalisation et la compositions des types simples.

Dans ce cadre plusieurs types sont proposés (les tableaux, les énumération, les
enregistrements, les ensembles, les intervalles...).

2- Enumération :
Définition :

une énumération appelé aussi type énuméré permettant la définition d’une liste homogène fini
et ordonnée de constantes (aux maximum 256). Dont les variables associées à ce type ne
peut prendre qu'un des valeur énuméré dans cette dernière. L’ordre par défaut est celui dans
lequel les identificateurs ont été énumérés en commençant par 0.

Exemples :

On peut définir les énumérations suivantes:

- les jours de la semaine : (samedi, dimanche, lundi, mardi, mercredi, jeudi, vendredi).

- les états d'un étudiant : (nouveau, répétitif, endette).

- les couleurs de base : (rouge, vert, bleu).

Déclaration En algorithmique :

avant de déclarer une variable d'une énumération il faut d'abord définir le type d'énumération.

La déclaration d’un type énuméré suit la syntaxe suivante :

Type nom_du_type = (const_0, const_1, const_2,.... const_n-1)

ensuite en déclare la variable associée comme suit

Var nom_Variable : nom_Type_Enuméré

Exemple :

Type Jours = (Vendredi, Samedi, Dimanche, Lundi, Mardi, Mercredi, Jeudi)

Etat_Etuds = (NOUVEAU, REPETITIF, ENDETTE)

Couleurs = (ROUGE, VERT, BLEU)

Var j : Jours

e: Etat_Etuds

couleur : Couleurs

la variable déclarée peut être utilisé par la suite en l'affectant par exemple une valeur parmi les
valeur citées (énumérées ) dans sa définition : j ← JEUDI

Déclaration En C :

avant de déclarer une variable d'une énumération il faut d'abord définir le type d'énumération
en utilisant le mot clé enum.

La déclaration d’un type énuméré suit la syntaxe suivante :

enum Nom_du_type {const_0, const_1, const_2, .... const_n-1};

Exemple :

enum Jours {Vendredi, Samedi, Dimanche, Lundi, Mardi, Mercredi, Jeudi};

enum Etat_Etuds {NOUVEAU, REPETITIF, ENDETTE};

enum Couleurs {ROUGE, VERT, BLEU};

Jours j;

Etat_Etuds e;

Couleurs couleur;

j = Vert;

Remarques :

- En C les objets de type énumération sont considérés (représentés par) comme des int. Donc
la valeur de premiers constant vaut 0 et ainsi de suite.

- En C une énumération peut être déclaré en spécifiant la valeur entière correspondante à un

de ses constantes(par défaut c'est le rang de cette dernière) comme suit : enum naturel {SIX
= 6, SEPT, HUIT};
3- Les Enregistrements :
Définition : Un enregistrement (appelé aussi une structure) (contrairement à un tableau) sert
à rassembler au sein d’une seule entité un ensemble fini d’éléments (ou champs) de type
éventuellement différents.

chaque champs représente une informations élémentaire de l'information globale représentée

par cet enregistrement.

les champs de l'enregistrement peuvent être de n'importe quel types (simple ou composé).

Exemples :

ci-dessous quelques exemples de données composées (d'enregistrements ) :

- un Point est composé de :

 x
 y
- un nombre complexe est constitué de :
 partie réel
 partie imaginaire
- un compte bancaire constitué de :
 numéro de compte
 solde
- un étudiant est définit par un ensemble de renseignements :
 son numéro séquentiel
 son nom
 son prénom
 sa date naissance
 sa moyenne...
Déclaration d'un enregistrement :

Avant de déclarer une variable de type enregistrement, on doit tous d'abord déclarer le type
enregistrement en définissant ses champs comme suit :

En Algorithmique En C

Type nom_du_type = Enregistrement struct Nom_Enregistrement

Nom_champ_1 : type_1 {
Nom_champ_2 : type_2 Type_1champs_1
: Type_2 champs_2
: :
: :
Nom_champ_n : type_n :.
FinEnregistrement Type_n champs_n

}
en peut par la suite déclarer une variable de ce type comme suit :

En Algorithmique En C
Nom_type_enregistrement nom_Variable
Var nom_Variable : Nom_type_enregistrement

Exemple :

En Algorithmique En C
struct Point {
Type Point = Enregistrement flaot x;
X : réel float y;
Y : réel }
FinEnregistrement Point a;
Var a : Point

Type Etudiant = Enregistrement struct Etudiant {

num : entier int num;
nom : chaine de caractères char nom [];
prenom : chaine de caractères char prenom [];
FinEnregistrement
Var e : Etudiant }
Etudiant e;

Accès aux champs de l'enregistrement :

pour accéder (utiliser) un champs d'une variable de type enregistrement en utilise le nom de la
variable suivi par un point '.' suivi par le nom du champ: (nom_Variable.nom_champ).
Exemple :
pour affecter 3 au champs x de la variable a (exemple précédent )
En Algorithmique En C
a.x ← 3 a.x = 3

Lecture et écriture d'une variable de type enregistrement :

on peut pas lire ou écrire une variable de type enregistrement d'un seul coup; car elle
composée. on peut le lire (ou l'écrire) partiellement en utilisant ses champs.

Exemple : pour introduire la valeur du point a (3,2) on doit introduire la valeur de x ensuite la
valeur y comme suit :

En Algorithmique En C

Lire (a.X) scanf ("%f",& a.x);

Lire (a.Y) scanf("%f",& a.y) ;
4- Autres possibilités de définition des types :
l'utilisation de notion de enregistrement, énumérations, tableaux personnalisés permet de
concevoir autant de type qu'on veut en précisant par exemple, pour chaque enregistrement
crée le nombre et la nature des champs qui le constituent même chose pour les tableau; on
défini des nouveaux types de données en utilisant des tableau avec des contenus et des
capacités différents

En peut aussi les crées en utilisant les notions d'ensemble, union, intervalle...

On peut crées des nouveaux types en combinant les techniques de création de type : en peut
par exemple crée un tableau d'enregistrement qui contient un champs de type énumération...

En algorithme toute définition d'un nouveau type doit être dans la section de déclaration des
types en utilisant le mot clé Type.

En langage C: L'instruction appelée typedef permet de créer de nouveaux noms de

types (sert à créer un alias de type ) :

exmple : typedef int entier ; permet de crées le type entier (donner un autre nom au type int ).

Les nouveaux paradigmes de programmation offre d'autres possibilités de création de type en

utilisant les notion de classe et d'agent...