Intro Algo

SYSTEMES RESEAUX INFORMATIQUES
Introduction à l'Algorithmique et à la Programmation | 1
&
TELECOMMUNICATIONS
Introduction à l’algorithmique
et à la programmation
2013-2014
Semestre 1
Raogo KABORE
Contenu de la matière :
 Introduction à l’algorithmique
 Environnement algorithmique
 Type de données, constante, variables
 Structures conditionnelles
 Structures itératives
 Les types structurés
 Tableaux unidimensionnel (vecteur)
 Tableaux bidimensionnels (matrice)
 Les enregistrements
 Algorithmes de tri : par sélection, par insertion, à bulle, quick sort, etc
 Algorithmes de recherche (par dichotomie)
Mode d’évaluation :
Références (Livre, Polycopié, Site internet, etc) :
____________________________________________________________________________________________________ 1
I. Introduction et définition de l'algorithmique _________________________________________________________ 4
1. Le développement d'applications ________________________________________________________________ 4
L'analyse _______________________________________________________________________________________ 4
L'algorithmique _________________________________________________________________________________ 4
Définition de l'algorithmique _______________________________________________________________________ 4
La démarche algorithmique ________________________________________________________________________ 4
Algorithmique et informatique _____________________________________________________________________ 5
La programmation _______________________________________________________________________________ 5
2. Structure générale d'un algorithme _______________________________________________________________ 7
Saisie des données et affichage _________________________________________________ Erreur ! Signet non défini.
II. Les données ____________________________________________________________________________________ 9
3. Les variables _________________________________________________________________________________ 9
Définition et caractéristiques ______________________________________________________________________ 9
Le nom des variables _____________________________________________________________________________ 9
Le type de données des variables ___________________________________________________________________ 9
Les valeurs des variables _________________________________________________________________________ 10
Affectation ____________________________________________________________________________________ 10
Déclaration des variables _________________________________________________________________________ 10
4. Les Types de données _________________________________________________________________________ 11
Les types de base _______________________________________________________________________________ 11
Les types structurés _____________________________________________________________________________ 11
Les tableaux unidimensionnels (vecteurs) ___________________________________________________________ 13
Les tableaux bidimensionnels (matrices) ____________________________________________________________ 14
5. Les constantes ______________________________________________________________________________ 15
Définition et caractéristiques _____________________________________________________________________ 15
Déclaration des constantes _______________________________________________________________________ 15
III. Les structures de contrôle ________________________________________________________________________ 16
Exécution sélective _____________________________________________________________________________ 16
Exécution alternative (deux choix) _________________________________________________________________ 16
Structure alternative imbriquée ___________________________________________________________________ 17
Structure à choix multiple ________________________________________________________________________ 18
Exécution répétitive _____________________________________________________________________________ 20
IV. Les fonctions __________________________________________________________________________________ 22
6. Interface ___________________________________________________________________________________ 22
7. passage des paramètres _______________________________________________________________________ 22
Passage par valeur ______________________________________________________________________________ 22
Passage par adresse _____________________________________________________________________________ 22
8. Fonction recursive ___________________________________________________________________________ 23
9. visibilite des variables _________________________________________________________________________ 23
Variables locales ________________________________________________________________________________ 23
Variables globales ______________________________________________________________________________ 23
V. algorithmes de tri ______________________________________________________________________________ 24
10. Tri Par Insertion _____________________________________________________________________________ 24
11. Tri rapide (Quick Sort) ou tri par segmentation _____________________________________________________ 26
12. Tri fusion (MERGE SORT) ______________________________________________________________________ 31
13. Tri à bulles (BUBBLE SORT) _____________________________________________________________________ 34
14. Tri par sélection (selEction sort) _________________________________________________________________ 35
VI. Algorithmes de recherche _____________________________________________________________________ 36
15. Algorithme de recherche séquentielle____________________________________________________________ 36
16. Algorithme de recherche dichotomique : _________________________________________________________ 36
I. INTRODUCTION ET DEFINITION DE L'ALGORITHMIQUE
1. LE DEVELOPPEMENT D'APPLICATIONS
De manière générale, on peut représenter l'activité de développement sous la forme suivante :
L'analyse
L'analyse est la lecture que le développeur porte sur un problème énoncé dans une formulation propre
à l'auteur et au métier sans tenir compte des considérations informatiques.
Il est donc nécessaire à l'informaticien d'exprimer, dans un premier temps, le problème au moyen d'un
vocabulaire, d'outils, de concepts spécifiquement informatique (Modélisation, déclaration de variables,
de constantes, opérations à effectuer,…).
L'algorithmique
Une fois cette analyse complétée, nombre de données et de traitements sont mis à jour. Ceux-ci se-
ront au cœur du second temps de la réflexion, celle de la formalisation d'algorithmes.
Définition de l'algorithmique
Le mot Algorithme est la traduction latine du nom du mathématicien et philosophe perse d'Asie Cen-
trale (dans l'actuel Ouzbékistan) AL KHAWARIZNI (783-850). On lui doit aussi le mot Algèbre (al-jabr)
L'algorithmique est une méthode de réflexion qui permet de décomposer un problème complexe en
une suite ordonnée et finie d'action à accomplir (l'algorithme), pour parvenir à un résultat déterminé.
La démarche algorithmique
L'algorithmique est une méthode permettant de trouver l'algorithme qui résout un problème donné.
L'algorithme lui-même n'est donc que le résultat d'une démarche qui consiste à :
 Comprendre le problème à résoudre
Si ce n'est pas le cas, il pourrait être utile de se le représenter à travers des cas ou exemples con-
crets. Par ailleurs, le questionnement et la recherche d'une reformulation seront aussi précieux pour
éclairer le sujet.
 Rechercher une solution
Il peut en exister plusieurs, certaines étant meilleures que d'autres. Un moyen efficace sera de " Divi-
ser chaque problème en autant de parties qu'il est nécessaire pour mieux les résoudre"
Algorithmique et informatique
En informatique, un algorithme représente l'enchaînement des actions (instructions) nécessaires pour
faire exécuter une tâche à un ordinateur (résoudre un problème).
L'algorithme peur être présenté sous forme de graphe ou bien verbeuse. Nous utiliserons cette der-
nière forme au moyen d'un pseudo-langage.
Tout comme un programme, un algorithme transforme des données (entrées) en résultats (sorties) par
un traitement.
La programmation
Un algorithme est un programme que l'on peut qualifier d'universel. Il représente l'ensemble des ac-
tions que l'on va demander à l'ordinateur d'effectuer. Cet ensemble est rédigé dans un pseudo-
langage indépendant :
 Du langage de programmation réel
 Du système d'exploitation utilisé
 De l'architecture de l'ordinateur
La programmation consiste à réaliser les programmes qui vont permettre la mise en œuvre des algo-
rithmes.
Le programme est obtenu par le codage de l'algorithme dans le langage de programmation retenu.
Les programmes ont pour but de traiter des données afin de produire des résultats. Ces résultats
peuvent eux-mêmes constituer des données pour d'autres programmes ou pour le programme lui-
même.
Vu de l'extérieur, le programme est une boîte noire dans laquelle ont introduit des données (les en-
trées) pour produire des résultats (les sorties).
Le rôle du programmeur est de définir le contenu de la boîte noire selon les besoin de l'utilisateur qui
souhaite des réponses correctes dans un temps raisonnable.
Les données sont manipulées des calculs dans un programme pour produire un résultat.
Les données sont :
 variables
 structures
 tableaux
 pointeurs
 modèles dynamiques
 …
Les calculs sont :

 instructions
 conditions
 boucles
 fonctions
 Procedures
 Récursion
 …
2. STRUCTURE GENERALE D'UN ALGORITHME
La structure générale d'un algorithme est la suivante :
Les mots ALGO, DEBUT et FIN ainsi que le nom de l'algorithme sont obligatoires.
L'indentation (lignes en retrait) est indispensable dans un algorithme (ou un code source) pour le
rendre plus lisible.
Il est fortement conseillé d'ajouter des commentaires dans les algorithmes et programmes. Ces com-
mentaires vont permettre de décrire des portions de code complexes, définir l'utilité d'une variable,
etc. Ces commentaires vont permettre une meilleure relecture. Ces commentaires vont permettre une
meilleure relecture du traitement et sont donc très utiles en maintenance corrective ou évolutive.
Il est possible d'insérer des commentaires:
 Sur une ligne : dans ce cas on le fait précéder de //
 Sur plusieurs lignes : dans ce cas, la première ligne commence par /* et la dernière ligne se
termine par */
Le dialogue avec l'utilisateur

Pour permettre au programme de dialoguer avec l'utilisateur, c'est à dire d'afficher un résultat à l'écran
et de lire une entrée au clavier, il faut au moins deux instructions une pour lire, l'autre pour afficher
L’affichage : ECRIRE
Cette action permet de communiquer un résultat ou un message sur écran ou sur imprimante pour
l'utilisateur.
Syntaxe
ECRIRE (paramètre1 [[,paramètre2]…])
Paramètre = variable | expression | constante
Constante = nombre | message
Exemples
ECRIRE(" La valeur de 3*2 est égale à ", 3*2)
ECRIRE(" La moyenne est = ", MOY)
La saisie des données : LIRE

L'ordre LIRE permet à l'ordinateur d’acquérir des données à partir de l’utilisateur, dans des cases
mémoire bien définies (qui sont les variables déclarées).
Rappel
Les variables sont des cases mémoire, supposées contenir un type de données, nommées par le nom
de variable.
LIRE(variable1 [[, variable2] …])
Remarques :
1. La saisie se fait uniquement dans des variables. Ce sont les cases (cellules) qui pourront accueillir
les données correspondantes.
2. La donnée à introduire doit être de même type que la variable réceptrice.
II. LES DONNEES

Un algorithme ou un programme manipule des informations : les données.
On distingue deux types de données : les variables et les constantes.
Les variables sont des données qui pourront varier (dont la valeur pourra changer) durant l'exécution
du programme.
A l'inverse, les constantes ont une valeur constante tout au long de l'exécution du programme.
3. LES VARIABLES
Définition et caractéristiques
Une variable est le nom d'une espace mémoire destiné à contenir une donnée (une valeur).
Le nom des variables

Il s'agit d'un identificateur unique, par lequel on peut accéder à son contenu.
Convention de nommage
 Le nom d'une variable est constitué d'un ou plusieurs mots, la première lettre de chaque mot
étant en majuscule, sauf le premier en général.
Exemple : montantTTC, valeurDeTravail
 Un nom peut être composé de lettre et de chiffre,mais il ne peut pas commencer par un
chiffre et ne peut pas comporter d'espace
 Le nom des variables doit être suffisamment significatif afin de reconnaître le rôle de cette
variable
Le type de données des variables

Le type d'une variable correspond à la nature de l'information qu'elle va recevoir.: nombre entier,
nombre réel, texte, booléen,…
Le type de données est une information importante, car il détermine la nature des opérations qui pour-
ront être ensuite réalisées sur la variable (opération arithmétique sur des nombres, concaténation de
chaine de caractères, etc.)
Les valeurs des variables

La valeur d'une variable correspond au contenu de cette variable (emplacement mémoire).
Affectation
Pour affecter une valeur à une variable, on utilise la notation suivante :
x<- 25 (on stocke le nombre 25 dans case mémoire nommée x )
Les opérations arithmétiques
Les opérations arithmétiques courantes, addition, soustraction, multiplication et division s'écrivent

ainsi :
c <- a + b
c <- a - b
c <- a * b
c <- a / b
Déclaration des variables

Pour qu'un programme puisse utiliser une variable, il faut au préalable que cette variable ait été décla-
rée, c’est-à-dire que le programme lui ait réservé une place une mémoire.
Les variables sont déclarées dans le bloc de déclaration de variables.
Exemple
4. LES TYPES DE DONNEES
Les types de base
Le type des variables permet de déterminer :
 La taille mémoire nécessaire pour stocker la valeur

 Les opérations applicables sur la variable
En algorithmique, on distingue six principaux types de base:

Caractère : permet de stocker des caractères : 'a', 'B', '1', '&'
Chaîne : permet de stocker une chaîne de caractère : "Bonjour"
Entier : Nombre sans virgule
Réel : Stocke les nombres à virgule ou sans virgule. Le séparateur décimal est le point
Booléen : Permet de stocker les valeurs logiques VRAI ou FAUX
Date : Permet le stockage des dates.
Les types structurés

Les types structurés sont des types construits par le programmeur, regroupant plusieurs variables qui
peuvent être de types différents.
Type Date = Structure

jour : entier
mois : entier
annee : entier
Fin Struct
Type structuré = création d’un nouveau type de variable =nom d’un espace en mémoire
Pour une variable t de type date, on la représentation mémoire suivante :
La construction de types peut être faite en combinant tous les types de base et les types déjà définis.
L’utilisation se fait en utilisant le point “.”
…
VAR t1,t2 : Date
DEBUT
t1.jour = 10
t1.mois = 5
t1.annee = 2008
...
t2 <- t1 (copie de toute la structure = 3 variables)
FIN
Les tableaux unidimensionnels (vecteurs)
Un tableau représente une collection de variables. Il est de taille fixe et ses données son contiguës en
mémoire.
Tableaux : structure permettant d’accéder de façon indépendante à un ensemble de variables de
même type.
t[1..12]: entier // tableau t contenant 12 entiers

x : entier
x = t[6] //copie du 6_eme élément de t dans la variable x
t[7] = 42 //modification du 7_eme élément
Attention : le premier élément d’un tableau est souvent d'indice 0 en informatique.

Les tableaux bidimensionnels (matrices)
Un tableau bidimensionnel est une matrice, c’est-à-dire, un tableau dont les éléments sont des ta-
bleaux.
Définition de tableau bidimensionnel :
Définition de type
constante N = 3, M = 4
type Matrice = tableau[1 .. N][1 .. M] de Entier
Définition de variables
m1 : Matrice
m2 : tableau[1 .. N][1 .. M] de Entier
Accès aux composants

c [i][j] c [i][j] + a [i][k] × b [k][j]
Algorithme de base
pour ligne = 1 : NaturelNonNul à N // première dimension
pour colonne = 1 : NaturelNonNul à M // deuxième dimension
traiterElément ( t [ligne][colonne] )
fpour colonne
fpour ligne
Remarques
Il est possible de définir des tableaux de dimension supérieure à deux.
Il n’est bien sûr pas possible de définir un tableau de dimension infini.
5. LES CONSTANTES
Définition et caractéristiques
Une constante est une donnée qui ne possède pas d'emplacement en mémoire. En fait, une cons-
tante est en quelque sorte un "alias" de la valeur. Au lieu d'indiquer dans le code la valeur elle-même,
on précise le nom de la constante. Le compilateur remplace directement la valeur dans le code du
programme chaque fois qu'il rencontre une constante.
L'intérêt des constantes est double : mise à jour plus rapide te lisibilité du code.
Comme la constante ne possède pas d'emplacement mémoire, sa valeur ne peut pas être modifiée.
Tout comme les variables, les constantes sont caractérisées par un nom, une valeur, et un type de
données.
Le type de donnée de la constante est implicite (on ne le précise pas) puisqu'il est déterminé par la
valeur de la constante.
Déclaration des constantes

Les constantes sont déclarées dans le bloc de déclaration des constantes.
Le bloc des constantes est TOUJOURS placé avant le bloc des variables
III. LES STRUCTURES DE CONTROLE
Exécution sélective
La structure sélective est une structure dont les instructions sont exécutées selon les réponses des
conditions.
si [test est vrai] alors

instructions
fin si
Si la condition vaut Vrai alors le bloc d’instructions sera exécuté, sinon il sera ignoré.
Exemple
si a < b alors
a=b
finsi
Exécution alternative (deux choix)
La structure s est une structure dont les instructions sont exécutées selon les réponses des condi-
tions.
si [test est vrai] alors

instruction1
sinon
instruction2
fin si
Si la condition vaut Vrai alors le bloc d’instructions1 sera exécuté, et le bloc d’instructions2 sera igno-
ré, sinon le bloc d’instructions2 sera exécuté et le bloc d’instructions1 sera ignoré.
Exemple
si a < b alors
a=b
sinon
b=a
finsi
Exemple
Un algorithme qui demande un nombre entier à l’utilisateur, et l’informe ensuite si ce nombre
est positif ou négatif
Algo Nature_nombre ;
Var n : Entier ;
Début
Ecrire ('Entrez un nombre : ') ;
Lire( n) ;
Si n > 0 Alors
Ecrire ('Ce nombre est positif' ) ;
Sinon
Ecrire ('Ce nombre est négatif' ) ;
Fin si
Fin.
Structure alternative imbriquée

Syntaxe :
Si condition1 Alors
Instructions1 ;
Sinon
Si condition 2 Alors
Instructions2 ;
Sinon
Instructions3 ;
Fin si
Fin si
Exemple : structure alternative imbriquée
Un algorithme qui demande un nombre à l’utilisateur, et l’informe ensuite si ce nombre est

positif ou nul ou négatif.
Algo Nature_nombre ;
Var n : Entier ;
Début
Ecrire ('Entrez un nombre : ') ;
Lire (n) ;
Si n > 0 Alors
Ecrire ('Ce nombre est positif ') ;
Sinon
Si n = 0 Alors
Ecrire ('Ce nombre est nul') ;
Sinon
Ecrire ('Ce nombre est négatif ') ;
Fin si
Fin si
Fin.
Structure à choix multiple

Lorsque l’imbrication des alternatives devient importante, l’utilisation de la structure à choix
multiple devient nécessaire.
Syntaxe :
Cas Variable ou Expression Vaut

Val 1 : Instructions 1 ;
Val 2 : Instructions 2 ;
……………
Val n : Instructions n ;
Sinon
Autres Instructions ;
Fin Cas
Si Variable vaut une valeur (val 1, val 2,……. val n) alors c’est le bloc Instructions
correspond à cette valeur qui sera exécuté et tous les autres blocs seront ignorés.
Si Variable n’a aucun valeur parmi val 1, val 2,……. val n, alors c’est le bloc autre
instructions qui sera exécuté et les instructions associées à les valeurs val 1, val 2,……. val n,
Seront ignorés.
Exemple : Structure alternative imbriquée
Algo Nom_chiffre
Var n : entier ;
Début
Ecrire ('donnez votre chiffre entre 0 et 4 : ') ;
Lire (n) ;
Si n=0 Alors
Ecrire ('Zéro') ;
Sinon
Si n=1 Alors
Ecrire ('Un') ;
Sinon
Si n=2 Alors
Ecrire ('Deux') ;
Sinon
Si n=3 Alors
Ecrire ('Trois') ;
Sinon
Si n=4 Alors
Ecrire ('Quatre') ;
Sinon
Ecrire ('erreur de la saisie ') ;
Fin si
Fin si
Fin si
Fin si
Fin si
Fin.
Exemple : Structure à choix multiple
Algo Nom_chiffre ;
Var n : entier ;
Début
Ecrire ('donnez votre chiffre entre 0 et 4 : ') ;
Lire (n) ;
Cas n vaut
0 : Ecrire (' Zéro') ;
1 : Ecrire ('Un') ;
2 : Ecrire ('Deux') ;
3 : Ecrire ('Trois') ;
4 : Ecrire ('Quatre') ;
Sinon
Ecrire ('erreur de la saisie) ;
Fin cas
Fin.
Exécution répétitive
 Boucle de répétition Fixe
pour [ensemble de valeurs] faire

instructions
fin pour
Exemple
pour i :=0 jusqu’à i<12 faire

afficher t[i]
fin pour
 Boucle de répétition Tant que … Faire
Tant que [test vrai] faire

instructions
fin tant que
Exemple
I <- 0
Tant que i < 12 faire
afficher t[i]
i: = i + 1
fin tant que
 Boucle de répétition Faire ..; Tant que
Faire
Instructions
Tant que [test Vrai]
Exemple
i <- 0
Faire
afficher t[i]
i := i + 1
Tant que i < 12
IV. LES FONCTIONS
Les fonctions permettent le découpage d’un programme en blocs ou fonctions.

Permet de regrouper et nommer un ensemble d’instructions.
Permet d’utiliser des paramètres.
Permet de réutiliser une même portion de programme depuis plusieurs endroits.
6. INTERFACE
L'interface ou signature de la fonction représente les paramètres et valeur renvoyée.
La valeur renvoyée peut être ignorée si on ne l’utilise pas.
7. PASSAGE DES PARAMETRES

Les paramètres dans une fonction se passent soit par valeur ou par variable
Passage par valeur

Seule la valeur de la variable est importante, elle n'est pas modifiée dans la fonction
Passage par adresse

La variable peut être modifiée par la fonction
ALGO Fonction TrouveMaximum (a : entier, b: entier) : entier

VAR m : entier ( variable locale m )
DEBUT
si a < b alors
m <- b
sinon
m <- a
fin si
renvoyer m
FIN
Appel de la fonction
i <- TrouveMaximum(1,100)
j <- TrouveMaximum(i,120)
8. FONCTION RECURSIVE
Une fonction itérative s'exécute de manière répétitive sur des ensembles de données
A contrario, une fonction récursive s’appelle elle-même avec un ensemble de données à traiter plus
petit
Exemple : Factorielle(n) = n*(n-1)*(n-2)….*1
ALGO Fonction Factorielle (n:entier) : entier

VAR
r : entier
DEBUT
si n = 0 alors
r <- 1
sinon
r <- n * Factorielle(n-1)
fin si
renvoyer r
FIN
9. VISIBILITE DES VARIABLES
Variables locales
Les variables locales sont des variables internes à un bloc
Variables globales
Les variables globales sont des variables visibles dans tout le programme
Exemple
V. ALGORITHMES DE TRI
10. TRI PAR INSERTION

Cet algorithme de tri est un des plus simples qui existent. Son implémentation est facile à réaliser. Il
n'est toutefois pas performant dès que le nombre de clés à trier devient conséquent.
L'algorithme du tri par insertion est souvent assimilé au joueur qui trie ses cartes. Au début, le joueur a
ses cartes placées en tas devant lui. Il les prend une par une de sa main droite pour les placer dans
sa main gauche au bon endroit (c’est-à-dire en insérant systématiquement la dernière carte saisie à
sa place).
La procédure suivante prend en paramètre un tableau A[1..n] contenant une suite de n clés à trier.
Les clés étant triées sur place, ce même tableau A contient les clées triées à la sortie de la procédure.
TRI-INSERTION (A)
Pour j<- 2 à n faire
Clé <- A[j]
I<- j-1
Tant que i > 0 et A[i] > clé
A[i+1] <- A[i]
I<- i-1
Fin Tant que
A[i+1] <- clé
Finpour
Exemple sur la suite d'entiers <15, 10, 4, 34, 1,19>
Sur le schéma, on représente en noir la case qui est analysée (indice j de la boucle pour, ligne 1). Les
cases grises correspondent aux valeurs comparées à A[j] (condition de la boucle tant que, ligne 4).
Les flèches grises représentent les clés déplacées (ligne 5) et les flèches noires l'insertion de A[j] à sa
place (ligne 8)
----------------------------- 2eme ---------------------

Insertion : méthode utilisée pour trier une main de jeu de carte. On prend les cartes une par une de la
gauche vers la droite. Pour chaque carte on la place au bon ordre parmi les précédentes.
ALGO TriInsertion(t Tableau d'entier, taille : entier)

VAR
i,j,tmp : entier
DEBUT
Pour i=0 jusqu’à i<taille Faire
tmp := t[i]
j := i
Tant que j>0 et t[j-1] > tmp Faire
t[j] := t[j-1]
j := j-1
Fin Tant que
t[j] = tmp
Fin Pour
FIN
11. TRI RAPIDE (QUICK SORT) OU TRI PAR SEGMENTATION
Le tri rapide fait partie des algorithmes du type "diviser pour régner". C'est un des algorithmes les plus
utilisés et également celui qui présente certainement le plus grand nombre de variantes.
Le tri rapide choisit un élément particulier de la liste de clés, appelé pivot. Il construit ensuite deux
sous-listes gauche et droite contenant respectivement les clés inférieures et supérieures du pivot.
Ainsi pour trier un sous-tableau A[p..r] du tableau initial A[1..n], on retrouve les trois phases sui-
vantes :
 Diviser : choisir le pivot d'indice q dans le tableau A[p..r]. Partitionner en 3 ce sous tableau :
 A[p..q-1] contient les clés inférieures à A[q]
 A[q] le pivot
 A[q+1..r] contient les clés supérieures à A[q].
Les deux sous-tableaux gauche et droite peuvent éventuellement être vides.
 Régner : les sous-tableaux A[p..q-1] et A[q+1..r] sont traités en appelant récursivement le tri
rapide
 Combiner : Cette phase est instantanée. Puisque les sous tableau sont triés sur place, aucun
travail n'est nécessaire pour les combiner.
Version standard
PARTITION (A, p, r)
X<- A[r]
I<- p-1
Pour j<- p à r-1 faire
Si A[j] < = x alors
I<- i+1
PERMUTER (A,i,j)
Fin si
Fin pour
PERMUTER(A, i+1,r)
Retourner i+1
TRI-RAPIDE(A,p,r)
Si p < r alors
Q<- PARTITION(A,p,r)
TRI-RAPIDE(A,p,q-1)
TRI-RAPIDE(A,q+1,r)
Fin si
PERMUTER (A, i,j)

Tmp <- A[i]
A[i] <- A[j]
A[j <-tmp]
On démarre l'algorithme par un appel à TRI-RAPIDE(A,1,n)
Cette version de l'algorithme prend la dernière clé du sous-ensemble comme pivot.
Exemple d'application sur les suite d'entiers <15,10,4,34,1,19>
Sur ce schéma, on représente les appels récursifs aux deux procédures PARTITION et TRI-RAPIDE.
Sur le tableau issu de la partition, on représente en blanc le pivot, en gris le sous-tableau gauche et
en noir le sous-tableau droit. L'étape (j) est le tableau trié obtenu à la fin du déroulement de l'algo-
rithme.
Version aléatoire
Cette version rend le cas défavorable très improbable. En effet, au lieu de prendre la dernière clé du
sous-tableau comme pivot, elle prend une clé au hasard. La probabilité d'être dans le cas défavorable,
(c’est-à-dire de choisir aléatoirement une clé qui à chaque étape produirait un partitionnement complè-
tement déséquilibré) est très faible.
PARTITION-RANDOMISEE(A,p,r)
i<- RANDOM(p,r)
PERMUTER (A, r,i)
Retourner PARTITION (A,p,r)
TRI-RAPIDE-RANDOMISE(A,p,r)
Si p < r alors
q <- PARTITION-RANDOMISE(A,p,r)
TRI-RAPIDE-RANDOMISE(A,p,q-1)
TRI-RAPIDE-RANDOMISE(A,q+1,r)
Fin si
------------------------------ 2eme ------------------------

partition(tableau T, entier premier, entier dernier)
debut
entier compteur, pivot, i
compteur<-premier
pivot<-T(premier)
pour i=deb+1 à dernier faire

si T(i)<pivot alors //si l'élément est inférieur au pivot
compteur<-compteur+1 //on incrémente le compteur (modification de la place finale du pi-
vot)
echanger(T,compteur,i) //on place l'élément à la position finale du pivot
fin si
fin pour
echanger(T,compteur,premier) //on place le pivot à sa place

retourner(compteur) //on renvoie la position finale du pivot
fin
tri_rapide_bis(tableau T, entier premier, entier dernier)

debut
entier pivot
si premier<dernier alors //condition d'arret de la récursivité

pivot<-partition(T,premier,dernier) //partition du tableau en 2
tri_rapide_bis(T,premier,pivot-1) //tri de la premiére partition
tri_rapide_bis(T,pivot+1,dernier) //tri de la seconde partition
fin si
fin
tri_rapide(tableau T)
debut
tri_rapide_bis(T,0,taille(T)-1)) //tri du tableau entier
fin
-------------------------------------------
Global :Tab[min..max] tableau d'entier
fonction Partition( G , D : entier ) résultat : entier

Local : i , j , piv , temp : entier
début
piv <- Tab[D];
i <- G-1;
j <- D;
repeter
repeter i <- i+1 jusquà Tab[i] >= piv;
repeter j <- j-1 jusquà Tab[j] <= piv;
temp <- Tab[i];
Tab[i] <- Tab[j];
Tab[j] <- temp
jusquà j <= i;
Tab[j] <- Tab[i];
Tab[i] <- Tab[d];
Tab[d] <- temp;
résultat <- i
FinPartition
Algorithme TriRapide( G , D : entier );
Local : i : entier
début
si D > G alors
i <- Partition( G , D );
TriRapide( G , i-1 );
TriRapide( i+1 , D );
Fsi
FinTRiRapide
Remarque
Nous supposons avoir mis une sentinelle dans le tableau, dans la première cellule la plus à gauche,
avec une valeur plus petite que n'importe qu'elle autre valeur du tableau.
Cette sentinelle est utile lorsque le pivot choisi aléatoirement se trouve être le plus petit élément de la
table /pivot = min (a1, a2, ... , an)/ :
Comme nous avons:

j, Tab[j] > piv ,
alors la boucle :
"repeter j <- j-1 jusquà Tab[j] <= piv ;"
pourrait ne pas s'arrêter ou bien s'arrêter sur un message d'erreur.
La sentinelle étant plus petite que tous les éléments y compris le pivot arrêtera la boucle et encore
une fois évite de programmer le cas particulier du pivot = min (a1, a2, ... , an).
12. TRI FUSION (MERGE SORT)

Le tri fusion fait également partie des algorithmes de tri de type "diviser pour régner". Cet algorithme
partage le tableau en deux sous-tableaux de taille n/2 qu'il trie. Il fusionne ensuite les résultats des
deux sous-tableaux. On retrouve alors les 3 phase suivantes :
 Diviser : Partager le tableau en deux sous-tableaux de taille n/2. Cette phse es instantanée,
puisqu'il suffit de calculer l'indice n/2
 Régner : les sous-tableaux sont traités recursivement en appelant récursivement le tri fusion.
 Combiner : C'est cette phase qui contient toute la logique de l'algorithme. La fusion de deux
sous-tableau déjà triés se fait en les parcourant en parallèle en en plaçant systématiquement
la plus petite clé dans le tableau résultat. Pour cela, la procédure FUSION crée deux tableau
temporaires pour stocker les deux sous-tableaux à fusionner. On utilise une sentinelle à la fin
de chacun de ces 2 tableaux temporaires pour éviter d'ajouter des tests suppelmentaires
pour détecter la fin de l'un d'entre eux dans la procédure de fusion.
FUSION(A,p,q,r)
N1<- q-p+1
N2 <- r-q
Créer tableaux L[1..n1+1] er R[1..n2+1]
Pour i<- 1 à n1 faire
L[i] <-A[p+i-1]
Fin pour
Pour j <- 1 à n2 faire
R[j] <- A[q+j]
Fin pour
L[n1+1] <-∞
R[n2+1] <- ∞
I<-1
J<-1
Pour k <-p à r faire
Si L[i] <= R[j] alors
A[k] <- L[i]
I <- i+1
Sinon
A[k] <- R[j]
J <- j+1
Fin Si
Fin pour
TRI-FUSION (A,p,r)
Si p < r alors
q<- (p+r)/2
TRI-FUSION(A,p,q)
TRI-FUSION(A,q+1;r)
FUSION(A,p,q,r)
Fin si
Exemple d'application sur la suite d'entiers <15, 10, 4, 34, 1, 19 >
Sur ce schéma, on représente le déroulement du tri par fusion. Les étapes b, c et d correspondent aux
appels récursifs à la procédure TRI-FUSION. Ensuite les étapes e, f et g correspondent à la terminai-
son de la récursion par l'appel de la procédure fusion.
13. TRI A BULLES (BUBBLE SORT)

Le principe de cet algorithme est d'échanger les clés contiguës qui ne sont pas correctement triées.
Son nomvient du fait que les clés se déplacent comme des bulles dans une flûte de champagne. Elles
remontent si lentement que cela explique la complexité quadratique.
TRI-BULLES(A)
Pour i<- 1 à n faire
Pour j<- n à i+1 faire
Si A[j] < A[j-1] alors
PERMUTER (A,j,j-1)
Fin si
Fin pour
Fin Pour
--------------------- 2eme ---------------------
Bulle : les éléments les plus petits se «déplacent» vers le

début du tableau. Les éléments contiguës sont échangés 2
à 2.
ALGO TriBulle(t : Tableau d'entiers, taille : entier)

VAR
i,j,tmp : entier
DEBUT
Pour i de taille jusqu’à i>1 avec i = i-1 Faire
Pour j <- 1 jusqu’à j<i faire
si t[j-1] > t[j] alors
tmp <- t[j-1]
t[j-1] <- t[j]
t[j] <- tmp
Fin Si
Fin Pour
Fin Pour
FIN
14. TRI PAR SELECTION (SELECTION SORT)

Le principe de cet algorithme est de choisir l'élément minimum et de le placer en première position,
puis le second en seconde position, …
TRI-SELECTION(A)
Pour i<- 1 à n faire
min <- i
Pour j <- i+1 à n faire
si A[min] > A[j] alors
min< - j
Fin si
Si min > i alors PERMUTER (A, i, min)
Fin si
Fin pour
Fin pour
--------------------- 2eme -------------------------------------------
on cherche l’élément de plus petite valeur dans le tableau

 le placer en tête du tableau
 Recommencer avec le tableau moins la première case
ALGO TriSelection(t : tableau d'entier , taille: entier)
VAR
i,j,min,tmp : entier
DEBUT
Pour i<-0 jusqu’à j < taille-2 Faire
min <- i
Pour j <- i+1 jusqu’à j < taille Faire
Si t[j] < t[min] Alors
min <- j
Fin Si
Fin Pour
tmp <- t[min]
t[min] <- t[i]
t[i] <- tmp
Fin Pour
FIN
VI. ALGORITHMES DE RECHERCHE
15. ALGORITHME DE RECHERCHE SEQUENTIELLE
Principe :
Parcourir le tableau A du début jusqu’à ce qu’on trouve un élément x = e.
Lorsqu’on visite un élément x d’indice i, on le compare avec e. Si x = e, on s’arrête
et on retourne i, sinon on continue le parcours du tableau (on incrémente la valeur
de i).
Algorithme :
Fonction RechSéq(A : Tableau d’Entier, n, e : Entier) : Entier

VAR i : Entier;
DEBUT
i := 1;
Tant Que (i ≤ n)
Si (A[i] = e) Alors
Retourner(i);
Sinon
i := i + 1;
FinSi
FinTQ
Retourner(0);
FIN
16. ALGORITHME DE RECHERCHE DICHOTOMIQUE :
Principe :
Lorsque le tableau initial est déjà trié, on peut améliorer la recherche en procédant, par une stratégie
de type diviser pour régner, comme suit :
On compare l’élément recherché e avec l’élément m qui se trouve au milieu du tableau initial A (dont
l’indice est j).
Si m = e, on retourne l’indice du milieu du tableau (c-à-d. j).
Si e < m, on refait le même processus dans le tableau A[1…j - 1].
Si e > m, on refait le même processus dans le tableau A[j + 1…n].
Algorithme :
Fonction RechDicho(A : Tableau d’Entier, deb, fin : Entier) : Entier

VAR m : Entier; // indice du minimum
DEBUT
Si (deb > fin) Alors
Retourner(0);
Sinon m <- (deb+fin)/2
Si (A[m] = e) Alors
Retourner(m);
Sinon
Si (A[m] > e) Alors
Retourner(RechDicho(A, deb, m - 1));
Sinon
Retourner(RechDicho(A, m + 1, fin));
FinSi
FinSi
FinSi
FIN

Intro Algo

Transféré par

Informations du document

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

Intro Algo

Transféré par

Droits d'auteur :

Formats disponibles

SYSTEMES RESEAUX INFORMATIQUES

Introduction à l'Algorithmique et à la Programmation | 1

 Type de données, constante, variables

 Les types structurés

 Tableaux unidimensionnel (vecteur)

 Tableaux bidimensionnels (matrice)

 Algorithmes de recherche (par dichotomie)

I. INTRODUCTION ET DEFINITION DE L'ALGORITHMIQUE

Les calculs sont :

2. STRUCTURE GENERALE D'UN ALGORITHME

La structure générale d'un algorithme est la suivante :

Le dialogue avec l'utilisateur

ECRIRE(" La moyenne est = ", MOY)

La saisie des données : LIRE

LIRE(variable1 [[, variable2] …])

II. LES DONNEES

Le nom des variables

Le type de données des variables

Les valeurs des variables

Les opérations arithmétiques

Les opérations arithmétiques courantes, addition, soustraction, multiplication et division s'écrivent

Déclaration des variables

4. LES TYPES DE DONNEES

Les types de base

Le type des variables permet de déterminer :

 La taille mémoire nécessaire pour stocker la valeur

En algorithmique, on distingue six principaux types de base:

Les types structurés

Type Date = Structure

Pour une variable t de type date, on la représentation mémoire suivante :

Les tableaux unidimensionnels (vecteurs)

t[1..12]: entier // tableau t contenant 12 entiers

Attention : le premier élément d’un tableau est souvent d'indice 0 en informatique.

Les tableaux bidimensionnels (matrices)

Accès aux composants

Déclaration des constantes

III. LES STRUCTURES DE CONTROLE

si [test est vrai] alors

Exécution alternative (deux choix)

si [test est vrai] alors

Structure alternative imbriquée

Exemple : structure alternative imbriquée

Un algorithme qui demande un nombre à l’utilisateur, et l’informe ensuite si ce nombre est

Structure à choix multiple

Cas Variable ou Expression Vaut

Exemple : Structure alternative imbriquée

Exemple : Structure à choix multiple

 Boucle de répétition Fixe

pour [ensemble de valeurs] faire

pour i :=0 jusqu’`a i<12 faire

 Boucle de répétition Tant que … Faire

Tant que [test vrai] faire

 Boucle de répétition Faire ..; Tant que

IV. LES FONCTIONS

Les fonctions permettent le découpage d’un programme en blocs ou fonctions.

La valeur renvoyée peut être ignorée si on ne l’utilise pas.

7. PASSAGE DES PARAMETRES

Passage par valeur

Passage par adresse

ALGO Fonction TrouveMaximum (a : entier, b: entier) : entier

Exemple : Factorielle(n) = n*(n-1)*(n-2)….*1

ALGO Fonction Factorielle (n:entier) : entier

9. VISIBILITE DES VARIABLES

10. TRI PAR INSERTION

Exemple : Factorielle(n) = n(n-1)(n-2)….*1