Ministre de lEnseignement Suprieur et de la Recherche Scientifique
Direction Gnrale des tudes Technologiques
AU 2009-2010 (Semestre 2) SUPPORT DE COURS Algorithmique et structures des donnes 2 Enseignants : Ahlem Tayachi Fatma Laribi Maali Ben Khadija Nesrine Ben Hadj Hammouda Sameh Mansouri
Prsentation du cours
Fiche matire Domaine de formation : Sciences et technologies Mention : Technologie de linformatique (TI) Parcours : Tronc Commun Semestre : S2 Unit denseignement : Programmation et structures dynamiques Volume horaire : 45 heures (22,5 cours 22,5 TD) Coefficient : 2 Rsum du cours Le cours dalgorithmique et structure de donnes est destin aux tudiants de premire anne du tronc commun de loption Technologies de lInformatique. Ce cours dfinit les enregistrements et la faon de les utiliser afin de pouvoir matriser par la suite les structures de donnes dynamiques. Il introduit ensuite les types de donnes abstraits pour pouvoir les implmenter dans la reprsentation des donnes et les diffrentes oprations associes. Aprs avoir spcifier le type de donne abstrait, ce cours prsente les structures linaires simples, telles que les listes, les piles et les files pour terminer par des structures pour des structures plus complexes telles que les graphes et les arbres. Enfin, ce cours introduit la notion de complexit algorithmique en donnant un aperu sur la complexit de quelques algorithmes. Mentionnons que ce cours ncessite comme pr-requis lalgorithmique et structures de donnes 1. Objectifs gnraux Ce cours vise approfondir les comptences acquises par lapprenant en algorithmique. Savoir crire des algorithmes se rapportant des structures dynamiques : listes, piles, files, arbres, etc. Etre capable de transformer un schma itratif simple en un schma rcursif.
Pr-requis Algorihtmique1 Programmation1 Evaluation Interrogation Orale Un devoir surveill dune heure Examen Final crit de 2 heures sur tout le programme Moyens Pdagogiques Expos informel Tableau Support du cours Travaux dirigs
Mthodologie
Le cours sarticule autour de 2 types dactivits, les cours intgrs et les sances de travaux dirigs. Les sries dexercices sont distribus aux tudiants et corriges en classe.
SOMMAIRE Chapitre1 : Les enregistrements 1.1 Les types ......................................................................................................................... 1 1.1.1 Les types de base ........................................................................................................ 1 1.1.2 Les types simples .......................................................................................................... 1 1.1.3 Les types complexes ................................................................................................ 1 1.2 Dfinition dun enregistrement .................................................................................... 2 1.2.1 Utilit ....................................................................................................................... 2 1.2.2 Dfinition ................................................................................................................. 2 1.2.3 Syntaxe ..................................................................................................................... 2 1.2.4 Reprsentation .......................................................................................................... 3 1.3 Utilisation dun enregistrement ................................................................................... 3 1.3.1 Dclaration ............................................................................................................... 3 1.3.2 Accs ........................................................................................................................ 3 1.3.3 Exemple ................................................................................................................... 4 1.4 Les types abstraits ......................................................................................................... 4 1.4.1 Dfinition ................................................................................................................. 5 1.4.2 Exemple : ................................................................................................................. 5 1.4.3 Signature dun type abstrait ..................................................................................... 5 1.5 Exercices dapplication .................................................................................................... 6 1.6 Solutions des exercices ...................................................................................................... 7 Chapitre 2: Les pointeurs 2.1 Rappel ........................................................................................................................... 10 2.1.1 Mmoire centrale (MC) ......................................................................................... 10 2.1.2 Structure de la mmoire centrale ........................................................................... 10 2.1.3 La notion dadresse ................................................................................................ 10 2.2 Les pointeurs ................................................................................................................ 10 2.2.1 Dfinition ............................................................................................................... 10 2.2.2 Dclaration dun pointeur ...................................................................................... 11 2.2.3 Cration dun pointeur ........................................................................................... 11 2.2.4 Utilisation dun pointeur ........................................................................................ 12
2.2.5 Suppression dune variable point ......................................................................... 13 2.2.6 Arithmtiques sur les pointeurs.............................................................................. 13 2.2.7 Les tableaux et les pointeurs .................................................................................. 16 2.2.8 Les chaines des caractres et les pointeurs ............................................................ 18 2.3 Exercices dapplication ............................................................................................... 18 2.4 Solution des exercices .................................................................................................. 20 Chapitre3: Les listes 3.1 Introduction ................................................................................................................. 27 3.2 Dfinition ...................................................................................................................... 27 3.3 Oprations sur les listes .............................................................................................. 27 3.4 Reprsentation ............................................................................................................. 28 3.4.1 Reprsentation graphique ....................................................................................... 28 3.4.2 Reprsentation des donnes ................................................................................... 28 3.5 Algorithmes de quelques oprations sur les listes ..................................................... 29 Chapitre4: Les piles et les files 4.1 Les piles ........................................................................................................................ 33 4.1.1 Prsentation ............................................................................................................ 33 4.1.2 Manipulation dune pile ......................................................................................... 34 4.2 Les Files ........................................................................................................................ 35 4.2.1 Prsentation ............................................................................................................ 35 4.2.2 Manipulation dune file .......................................................................................... 36 Chapitre5: La rcursivit 5.1 Rappel ........................................................................................................................... 39 5.1.1 Les procdures ....................................................................................................... 39 5.1.1.1 Dfinition ............................................................................................................. 39 5.1.1.2 Les variables et les paramtres ....................................................................... 40 5.1.1.3 Passage des paramtres ................................................................................... 41 5.1.2 Les fonctions .......................................................................................................... 42 5.1.2.1 Dfinition ........................................................................................................ 42 5.2 Algorithmes rcursifs .................................................................................................. 43 5.2.1 Dfinitions rcursives ............................................................................................ 43
5.2.2 Fonctions rcursives ............................................................................................... 44 5.2.2.1 Dfinition ........................................................................................................ 44 5.2.2.2 Excution dune fonction rcursive ................................................................ 44 5.2.2.3 Variables locales et paramtres des fonctions rcursives ............................... 45 5.3 Exercices dapplication ............................................................................................... 46 5.4 Solution des exercices .................................................................................................. 47 Chapitre6: Les arbres et les graphes 6.1 Les Arbres .................................................................................................................... 52 6.1.1 Dfinition ............................................................................................................... 52 6.1.2 Implmentation ...................................................................................................... 53 6.1.3 Les fonctions daccs ............................................................................................. 53 6.1.4 Niveau et hauteur dun arbre :................................................................................ 56 6.1.5 Parcours dun arbre ................................................................................................ 57 6.2 Les graphes .................................................................................................................. 59 6.2.1 Dfinition ............................................................................................................... 59 6.2.2 Implmentation : ......................................................................................................... 60 Chapitre7: Les algorithmes de recherche rcursifs 7.1 Dfinition ...................................................................................................................... 65 7.2 Recherche dans une liste chaine ............................................................................... 65 7.2.1 Recherche squentielle ........................................................................................... 65 7.2.2 Recherche par valeur .............................................................................................. 65 7.2.3 Recherche par position ........................................................................................... 66 7.2.4 Recherche dichotomique ........................................................................................ 66 7.2.5 Recherche dans une liste ordonne ........................................................................ 66 7.3 Recherche dans un arbre binaire ............................................................................... 69 7.3.1 Parcours en profondeur .......................................................................................... 69 7.3.1.1 Parcours prfix .............................................................................................. 69 7.3.1.2 Parcours infix ................................................................................................ 70 7.3.1.3 Parcours postfix ............................................................................................ 71 7.3.2 Application ............................................................................................................. 71 7.3.3 Arbre binaire de recherche ..................................................................................... 72
Chapitre8: Complexit des algorithmes 8.1 Introduction ................................................................................................................. 74 8.2 Dfinition ...................................................................................................................... 74 8.3 Calcul de la complexit ............................................................................................... 74 8.4 Type de complexit ...................................................................................................... 75 8.5 Complexit de quelques algorithmes ......................................................................... 76 8.5.1 Recherche du plus petit lment ............................................................................ 76 8.5.2 Produit de matrice .................................................................................................. 76 DS et examen
Chapitre 1 : Les enregistrements
Vue densemble Cette leon prsente la dfinition et lutilisation des enregistrements.
Objectifs Ce chapitre a pour objectifs de permettre aux tudiants dacqurir les connaissances de base se rapportant aux objectifs spcifiques suivants: Etre capable dutiliser et crer des nouveaux types de donnes selon le besoins du programme (les enregistrements). Savoir crire un enregistrement
Pr-requis Algorithmique 1
Dure 3 H
Elments de contenu 1. Les types 2. Dfinition dun enregistrement 3. Utilisation dun enregistrement 4. Les types abstraits 5. Exercices dapplication 6. Solutions des exercices Chapitre1 : Les enregistrements
@quipe pdagogique Algorithmique2 1
1.1 Les types 1.1.1 Les types de base - Toute variable utilise dans un algorithme doit avoir un type qui caractrise lensemble de valeur quelle peut prendre dans cet algorithme, ce type peut tre un type de base (prdfinit) ou un type compos qui est dfinit par lutilisateur. - Les types de base se divisent en 2 catgories : les types simples et les types complexe. 1.1.2 Les types simples Les types de simple qui peuvent tre utilis pour reprsenter les variables dun algorithme sont : - Entier : la variable peut prendre des valeurs entires positives ou ngatives, pour utiliser ce type on utilise le mot cl entier
- Reel : la variable peut prendre des valeurs relles, pour utiliser ce type on utilise le mot cl reel
- Caractere : la variable peut prendre tout caractre quon peut saisir avec un clavier standard, pour utiliser ce type on utilise le mot cl reel
- Booleen : la variable a 2 valeurs VRAI ou FAUX, pour utiliser ce type on utilise le mot cl booleen 1.1.3 Les types complexes Les types simples servent pour dfinir les types complexes qui permettent de reprsenter des structures de donnes plus compliqus, ces types sont : - Tableau : o la variable est forme par lunion de plusieurs cases mmoire qui contiennent chacune le mme type. o la dclaration dun tableau se fait comme suit : nom : Tableau [i_deb .. i_fin] de type . o i_deb et i_fin reprsentent lindice de dbut et lindice de fin du tableau. - Chane de caractre : Chapitre1 : Les enregistrements
@quipe pdagogique Algorithmique2 2
o Cest la concatnation de plusieurs caractres qui finissent par le marqueur de fin de chane. Cest ainsi un tableau de caractres qui contient comme dernier caractre un caractre spcial pour reprsenter le marqueur de fin de chane. o La dclaration se fait comme suit : nom : chaine [ Max ] o Max est le nombre maximum de caractre. 1.2 Dfinition dun enregistrement 1.2.1 Utilit Contrairement aux types de base les types composs sont dfinit par lutilisateur. Les types de bases servent pour dfinir de nouveaux types composs. Ces nouveaux types servent pour reprsenter des structures de donnes plus complexes quon ne peut pas reprsenter par les types de bases. Exemple : Si on veut reprsenter les donnes relatives une personne telle que le nom et lge dans une seule variable ou une seule structure de donne, on ne peut pas faire a avec les types de bases et particulirement avec les tableaux. On peut utiliser un nouveau type appel enregistrement qui contient 2 champs, un pour reprsenter le nom de type chane de caractre et le 2 me pour reprsenter lage de type entier. On remarque quon ne peut pas reprsenter la personne par un tableau car elle est forme de 2 types diffrents. Ainsi on dfinit le type personne par un enregistrement comme suit : Personne = Enreg nom : chane [30] age : entier FinEnreg 1.2.2 Dfinition Lenregistrement est une structure de donnes (ou un type) compose, qui est form par plusieurs autres structures de donnes de nature diffrentes. Il permet ainsi de les regrouper dans une seule structure de donnes. 1.2.3 Syntaxe Nom = Enreg Champ1 : type Chapitre1 : Les enregistrements
@quipe pdagogique Algorithmique2 3
Champs N : type FinEnreg On dsigne par : - Nom : reprsente le nom de lenregistrement. - Champs 1N : les noms des champs qui constituent lenregistrement. - Type : est le type de chaque champ. 1.2.4 Reprsentation Les enregistrements sont reprsents en mmoire sous forme de suite de zones contigus qui servent chacune reprsenter les diffrents champs, ces zones sont de taille diffrentes puisque chaque champ a un type diffrent. Par exemple lenregistrement personne sera reprsenter en mmoire comme suit : Octet 1 Octet 2 Octet 30 Octet nom age
1.3 Utilisation dun enregistrement 1.3.1 Dclaration La dclaration dun enregistrement se fait comme tant un nouveau type dfinit par lutilisateur dans lalgorithme, il doit tre dclar dans la partie Type avant dtre utilis comme type de variable dans la partie Var. 1.3.2 Accs Lenregistrement qui est une structure de donnes compos de plusieurs champs nest pas accessible dans sa totalit, donc pour faire un accs un enregistrement on accde tous les champs un par un. Et pour utiliser un champ on crit le nom de la variable de type enregistrement suivi de point suivi du champ auquel on veut accder : Nom_enregistrement.champ_desire Chapitre1 : Les enregistrements
@quipe pdagogique Algorithmique2 4
1.3.3 Exemple On veut crire un algorithme qui lit le nom, le prnom et la moyenne gnrale dun tudiant puis il affiche si cet tudiant a russi ou non selon que sa moyenne est >= 10 ou non. Utiliser un enregistrement pour reprsenter ltudiant. Algorithme Resultat Type Etudiant = Enreg nom : chane [30] prenom : chane [30] MG : reel R : caractere FinEnreg Var E : Etudiant Debut Lire (E.nom) Lire (E.prenom) Lire (E.MG) Si (E.MG >= 10) Alors E.R 'A' Ecrire (''Admis '') Sinon E.R 'R' Ecrire (''Refus '') FinSi Fin 1.4 Les types abstraits Les enregistrements permettent de reprsenter des structures de donnes complexes et formes par des types non homognes. Mais ils ne prsentent pas une abstraction au niveau des structures de donnes de lalgorithme. Pour rsoudre ce problme on fait recours une gnralisation du type enregistrement par les types abstraits. Ce qui donne une indpendance vis--vis dune implmentation particulire et les donnes sont considres dune manire abstraite. Chapitre1 : Les enregistrements
@quipe pdagogique Algorithmique2 5
1.4.1 Dfinition Un type abstrait permet de reprsenter les donnes, les oprations faites sur ces donnes et les proprits de ces oprations, dans une mme structure de donnes. 1.4.2 Exemple : Si on veut reprsenter un Compte Bancaire par un type abstrait il sera compos des donnes et des oprations concernant les Comptes Bancaires : - Les donnes seront : Une variable pour reprsenter le numro du compte Une variable pour reprsenter le solde Une variable pour reprsenter le nom du propritaire - Les oprations sur les comptes bancaires: Une fonction pour crer un nouveau compte Une fonction pour consulter un compte Une procdure pour dbiter un compte Une procdure pour crditer un compte - Les proprits des oprations : Pour dbiter il faut que le solde soit positif Seuls les salaris peuvent crer des comptes. 1.4.3 Signature dun type abstrait La signature dun type abstrait de donnes est dfinie par : Les noms des types utiliss pour reprsenter les donnes (rels, entiers, ). Les noms des oprations et leurs profils. La signature dcrit la syntaxe du type abstrait mais elle ne le dfinie pas rellement. Ainsi pour lexemple prcdent la signature est : - Les types des donnes : entier reel chaine[20] - les oprations et leurs profils : Chapitre1 : Les enregistrements
@quipe pdagogique Algorithmique2 6
Creer_compte : chaine[20] entier Consulter _compte : entier reel Debiter : entier * reel Crediter : entier * reel 1.5 Exercices dapplication Exercice 1 : Saisie dune fiche Une fiche contient les coordonnes suivantes: -Nom (chane de caractres de longueur 10) -Prnom (chane de caractres de longueur 10) -Age (entier) -Note (rel) Ecrire un algorithme puis un programme C qui permet de crer la structure ci-dessus, saisir une fiche et l'afficher. Exercice 2 : Somme et produit de deux nombres complexes Ecrire un algorithme puis un programme C qui lit deux nombres complexes C1 et C2 et qui affiche ensuite leur somme et leur produit. On utilisera les formules de calcul suivantes : (a + bi)+(c + di) = (a + c) + (b + d)i (a + bi)(c + di) = (ac - bd) + (ad + bc)i Exercice 3 : Coordonnes dun point Crer une structure Point qui contient les champs suivants : num : entier x et y : reel Ecrire un programme C qui permet de saisir 4 points, les ranger dans un tableau puis les afficher. Exercice 4 : Tableau des employs Ecrire un programme C qui permet de crer un tableau TabEmp qui contiendra les informations sur les 10 employs dune entreprise (Matricule, Nom, Salaire, Etat_Civil), le remplir puis afficher le nombre demploys dont le salaire est compris entre 500 et 700 D.
Chapitre1 : Les enregistrements
@quipe pdagogique Algorithmique2 7
1.6 Solutions des exercices Exercice 1 : Algorithme Saisie_Fiche Type fiche=enreg nom : chaine[10] prenom : chaine[10] age : entier note : reel FinEnreg Var f : fiche Dbut Lire (f.nom) Lire (f.prenom) Lire (f.age) Lire (f.note) Ecrire (f.nom, f.prenom,f.age,f.note) Fin Exercice 2 : Algorithme CalculComplexe Type Complexe=enreg Re : Rel Im : Rel FinEnreg Var C1, C2, S, P : Complexe Dbut Ecrire ( Partie relle du premier nombre :) Chapitre1 : Les enregistrements
@quipe pdagogique Algorithmique2 8
Lire (C1.Re) Ecrire ( Partie imaginaire du premier nombre :) Lire (C1.Im) Ecrire ( Partie relle du deuxime nombre :) Lire (C2.Re) Ecrire ( Partie imaginaire du deuxime nombre :) Lire (C2.Im)
P.Re = (C1.Re * C2.Re) (C1. Im * C2.Im) P.Im = (C1.Re * C2.Im) + (C1. Im * C2.Re) Ecrire (Produit=, P.Re, +, P.Im, i) Fin Exercice 4 :
Algorithme Personnel Constantes n = 50 Types Employ=Struct Matricule : Entier Nom : Chane Sal : Rel Etat_Civil : Caractre Fin Struct Tab = Tableau [1..n] de Employ Variables TabEmp : Tab I, nb : Entier Chapitre1 : Les enregistrements
@quipe pdagogique Algorithmique2 9
Procdure Remplir (Var T :Tab) Dbut Pour i de1 n faire Ecrire ( Matricule de lemploy :) Lire (T[i].Matricule) Ecrire ( Nom de lemploy :) Lire (T[i].Nom) Ecrire ( Salaire de lemploy :) Lire (T[i].Sal) Ecrire ( Etat civil de lemploy :) Lire (T[i].Etat_Civil) Fin pour Fin Fonction Compter (T : Tab) : Entier Dbut Compter 0 Pour i de 1 n faire Si (T[i].Sal >=500) ET (T[i].Sal <=700) alors Compter Compter + 1 Fin si Fin pour Fin Dbut Remplir (TabEmp) Nb Compter (TabEmp) Ecrire ( nb, employs touchent entre 500 et 700 Dt) Fin
Chapitre 2 : Les pointeurs
Vue densemble Cette leon prsente la dfinition et lutilisation des pointeurs.
Objectifs Ce chapitre a pour objectifs de permettre aux tudiants dacqurir les connaissances de base se rapportant aux objectifs spcifiques suivants: Etre capable dutiliser les pointeurs. grer un ensemble fini dlments dont le nombre varie au cours de lexcution du programme. Savoir crire un algorithme en utilisant des variables dynamiques laide du pointeur.
Pr-requis Algorithmique 1 Les enregistrements
Dure 3 H
Elments de contenu 1. Rappel 2. Les variables dynamiques 3. Les pointeurs 4. Exercices dapplications 5. Solutions des exercices Chapitre2 : Les Pointeurs
@quipe pdagogique Algorithmique2 10
2.1 Rappel 2.1.1 Mmoire centrale (MC) La mmoire centrale mmorise les donnes en cours de traitement par lunit de traitement (UT). Elle contient les instructions et les donnes du programme en cours. LUT lit une instruction, les oprandes de cette instruction, calcule le rsultat puis lcrit dans la mmoire centrale. En entre, lUT lit une donne depuis une unit dEntr\sortie et lcrit dans la MC et inversement pour une sortie. 2.1.2 Structure de la mmoire centrale La mmoire centrale est compose de cellules mmoire. Une cellule est un ensemble de 8 circuits lectroniques. Chaque circuit est capable de soutenir dans un de deux tats :
Haut reprsente le bit 1 Bas reprsente le bit 0 Une cellule est donc un ensemble de 8 bits dit un octet (8 bits = 1 octet). Les cellules de la mmoire sont numrotes de 0 n-1, avec n est le nombre de cellules quelle contient. Pour mmoriser plus dinformations, on utilise deux cellules adjacentes (un mot) ou 4 cellules adjacentes (un double mot). Une variable est en faite une petite zone mmoire issue de n octets que lon salloue et dans laquelle les informations sont ranges. 2.1.3 La notion dadresse Lors de la compilation dun programme, lordinateur rserve dans sa mmoire une zone mmoire pour chaque variable dclare. Cest cet endroit que la valeur de la variable est stocke. Il associe alors au nom de la variable ladresse de stockage. Ainsi, pendant le droulement du programme, quand il rencontre un nom de variable, il va chercher ladresse correspondante la valeur en mmoire. En langage C, il est possible de mettre une valeur dans une variable laide de loprateur = ou de la fonction scanf( ). Ladresse mmoire est accessible en faisant prcder la variable de loprateur &. Exemple : char car = c; printf ("adresse de car %lx", &car);
2.2 Les pointeurs 2.2.1 Dfinition Un pointeur est une variable qui a pour valeur ladresse mmoire dune autre variable sur laquelle il pointe. Le pointeur est dtermin par le type sur lequel il pointe (variable, premier lment dun tableau, .).
Chapitre2 : Les Pointeurs
@quipe pdagogique Algorithmique2 11
2.2.2 Dclaration dun pointeur
En algorithmique, on dclare un pointeur en prcdant son type de base par le caractre ^ . Syntaxe :
Nom_pointeur : ^ type
Exemple 1 :
P : ^caractre dclarer un pointeur appel P sur une variable de type caractre.
P P^
- La variable pointeur P a pour valeur ladresse 43 . Elle pointe sur lespace mmoire P^ ladresse 43 dont le contenu est le caractre T .
- La dclaration dune variable de type pointeur a pour effet la rservation dune case mmoire qui va contenir ladresse de la variable point.
Exemple 2 :
Si on dclare 2 pointeurs Pe et Pf - Pe pointe vers une variable de type entier ; -Pf pointe vers une variable de type rel, Ceci implique la cration de deux variables qui contiennent respectivement ladresse dun entier et ladresse dun rel comme suit :
Pe : ^entier Pf : ^reel
2.2.3 Cration dun pointeur Pour utiliser la variable point il faut dabord la crer, ce qui a pour effet de rserver un bloc en mmoire capable de stocker la valeur de cette variable. Pour crer une variable point, on utilise linstruction Allouer.
43 T Mmoire Pe @? Pf @? Chapitre2 : Les Pointeurs
@quipe pdagogique Algorithmique2 12
Syntaxe :
Allouer (nom_pointeur) Exemple :
Pour crer la variable point par Pe on crit : Allouer (Pe), et pour crer la variable point par Pf on crit : Allouer (Pf).
- Linstruction Allouer (P) : Rserve un bloc mmoire de la taille adquate pour contenir la valeur de la variable pointe par P. Rcupre ladresse de ce bloc et la met dans la variable P.
2.2.4 Utilisation dun pointeur Pour accder la variable point par un pointeur appel P on utilise loprateur ^. Syntaxe :
P^ : dsigne la variable pointe par P. Exemple : Lalgorithme suivant stocke la valeur 10 dans une variable de type pointeur.
Algorithme Pointeur_element Var P : ^entier Debut Allouer (P) P^ 10 Fin
Mmoire Pe @1 Pf @2 entier rel Mmoire P @ 10 Chapitre2 : Les Pointeurs
@quipe pdagogique Algorithmique2 13
2.2.5 Suppression dune variable point Lorsquune variable pointe na plus dutilit, il est possible de la supprimer et de rendre disponible lespace mmoire quelle occupe. Linstruction qui ralise cette tche est Liberer .
Syntaxe : Liberer (nom_pointeur) Exemple : Lexemple suivant montre leffet de linstruction Liberer sur la mmoire.
Algorithme exemple Var P : ^entier Debut Allouer (P) P^ 10 Liberer (P) P^ 4 {erreur} Fin
- Liberer (P) supprime la variable point par P et libre lespace mmoire occup par cette variable. Par contre la variable pointeur P nest pas supprime mais son contenu nest plus ladresse de la variable point mais une adresse non significative.
Remarque : - Lutilisation de la variable point aprs linstruction Liberer provoque une erreur. 2.2.6 Arithmtiques sur les pointeurs 2.2.6.1 Initialisation dun pointeur
Pour initialiser un pointeur on lui affecte une valeur constante appel Nil . Cette constante signifie que le pointeur ne pointe sur rien. Syntaxe : P Nil
Mmoire
P Mmoire P ? Chapitre2 : Les Pointeurs
@quipe pdagogique Algorithmique2 14
Exemple : On peut aussi initialiser un pointeur partir dun autre pointeur comme le montre lexemple suivant : - Supposons quon soit dans la situation initiale illustre par la figure a :
Si linstruction : PQ est excut, nous passerons la nouvelle situation illustre par la figure b. Dans ce cas, on a : P^ = Q^ = Sousse - Si on modifie la valeur de Q^, P^ sera galement modifi et restera gal Q^.
- Par contre, si linstruction : P^Q^ est excut. On passe la nouvelle situation illustre par la figure c.
Sousse
Sousse Q Q^ P^ P P^ P
Tunis
Sousse Q Q^ P
Tunis
Sousse Q Q^ P^ Chapitre2 : Les Pointeurs
@quipe pdagogique Algorithmique2 15
Dans ce cas, on a galement P^ = Q^ = Sousse ; Mais si lon modifie la valeur de Q^, P^ ne sera pas modifi. 2.2.6.2 Affectation dun pointeur un autre Le contenu dune variable pointeur peut tre recopi dans une autre variable pointeur grce linstruction daffectation, condition que les 2 pointeurs soit de mme type. Exemple : Les pointeurs P1 et P2 pointent sur un entier. Linstruction P1 P2 permet de copier ladresse contenu dans P2 dans le pointeur P1. Donc P1 et P2 vont pointer vers la mme variable.
2.2.6.3 Loprateur dadresse Loprateur dadresse permet de rcuprer ladresse en mmoire dune variable il se note &. Comme le pointeur contient ladresse dune variable pointeur on peut utiliser loprateur dadresse pour affecter un pointeur ladresse dune autre variable et ainsi il va pointer vers cette nouvelle variable. La syntaxe est la suivante : pointeur & variable 2.2.6.4 Comparaison de pointeurs - On peut comparer 2 pointeurs entre eux avec loprateur = ou <> condition quils ont le mme sous type. Et on peut comparer la valeur Nil nimporte quel pointeur quelque soit son sous-type. - On peut aussi comparer les valeurs des variables pointes par 2 pointeurs.
2.2.6.5 Exemple Algorithme Adresse Var P : ^entier A : entier Debut Mmoire P1 @1 10 P2 @1 Chapitre2 : Les Pointeurs
@quipe pdagogique Algorithmique2 16
Allouer (P) A 10 P & A Ecrire (A) {10} Ecrire (P^) {10} Liberer (P) Fin
2.2.6.6 Tableau rcapitulatif
Algorithmique Langage C Syntaxe Exemple Syntaxe Exemple Dclaration pointeur nomPointeur :^type P :^entier type* nomPointeur int * P ; Cration pointeur Allouer (^type) Allouer(p) (type*)malloc(sizeof(type)) P=(int*)malloc(sizeof(int)) ; Suppression pointeur Librer (^type) Librer(p) delete (type *) delete(p) ;
2.2.7 Les tableaux et les pointeurs En dclarant un tableau, on dfinit automatiquement un pointeur (on dfinit en fait l'adresse du premier lment du tableau).
Les tableaux une dimension: Les critures suivantes sont quivalentes:
- En algorithmique :
tableau: ^entier int tableau[10]; dclaration
Allouer (tableau)
tableau^ tableau[0] le 1er lment
(tableau+i)^ tableau[i] un autre lment
Chapitre2 : Les Pointeurs
@quipe pdagogique Algorithmique2 17
tableau & tableau[0] adresse du 1er lment
( tableau + i) & (tableau[i]) adresse d'un autre lment
Les tableaux plusieurs dimensions:
Un tableau plusieurs dimensions est un pointeur de pointeur.
Exemple: int t[3][4]; t est un pointeur de 3 tableaux de 4 lments ou bien de 3 lignes 4 lments.
Les critures suivantes sont quivalentes:
t[0] &t[0][0] t :adresse du 1er lment
t[1] &t[1][0] adresse du 1er lment de la 2e ligne
t[i] &t[i][0] adresse du 1er lment de la ime ligne
t[i]+1 &(t[i][0])+1 adresse du 1er lment de la ime +1 ligne Chapitre2 : Les Pointeurs
@quipe pdagogique Algorithmique2 18
REPARTITION DES ELEMENTS EN MEMOIRE Le t ableau a t dclar ainsi: int t[3][4]; t[0] t[0][0] t[0][2] t[1] t[2] t[2][3]
2.2.8 Les chaines des caractres et les pointeurs Les chanes de caractres sont des tableaux de caractres. Leur manipulation est donc analogue celle d'un tableau une dimension:
2.3 Exercices dapplication Exercice 1 Complter le tableau en indiquant les valeurs des diffrentes variables au terme de chaque instruction du programme suivant (on peut aussi indiquer sur quoi pointent les pointeurs) : Programme A B C P1 P1^ P2 P2^ A, B, C : entier P1, P2 :^entier ;
- - - - - - - A 1, B 2, C 3
P1 &A, P2 &C
P1^ (P2^) ++
P1 P2
P2 &B
P1^ - P2^
Chapitre2 : Les Pointeurs
@quipe pdagogique Algorithmique2 19
P2^= (P2^ )++
P1^ * P2^
A = ++ P2^ * P1^ ;
P1 = &A ;
P2^ = P1^ /= ^P2 ;
Exercice 2 Soit P un pointeur qui pointe sur un tableau A dont ses valeurs sont {12 , 23, 34 ,45,56,67, 78, 89, 90} P : ^entier P=A ; Quelle valeur fournissent ces expressions : a) P^+2 b) (p+2)^ c) P+1 d) & A [4] +1 e) A+3 f) P + (P^ - 10) g) (P + (P+9)^ -A [8])^ Exercice 3 On dclare un tableau de 10 entiers A. Ecrire un algorithme et un programme permettant de remplir et dafficher ce tableau. Dclarer un pointeur pointant vers l'lment 7 de A. Incrmenter le pointeur c'est--dire le faire pointer vers la case suivante. Incrmenter la valeur pointe. Vrifier par laffichage des rsultats. Afficher le tableau aprs modifications.
Chapitre2 : Les Pointeurs
@quipe pdagogique Algorithmique2 20
Exercice 4 Ecrire, de deux faons diffrentes, un algorithme et un programme en C qui lit 10 nombres entiers dans un tableau avant den rechercher le plus grand et le plus petit : 1. en utilisant uniquement le formalisme tableau, 2. en utilisant le formalisme pointeur chaque fois que cela est possible. 2.4 Solutions des exercices Exercice 1 Programme A B C P1 P1^ P2 P2^ A, B, C : entier P1, P2 :^entier ;
- - - - - - - A 1, B 2, C 3
1 2 3 - - - - P1 &A, P2 &C
1 2 3 &A 1 &C 3 P1^ (P2^) ++
3 2 4 &A 3 &C 4 P1 P2
3 2 4 &C 4 &C 2 P2 &B
3 2 4 &C 4 &B 2 P1^ - P2^
3 2 2 &C 2 &B 2 P2^= (P2^ )++
3 3 2 &C 2 &B 3 P1^ * P2^
3 3 6 &C 6 &B 3 A = ++ P2^ * P1^ ;
24 4 6 &C 6 &B 4 P1 = &A ;
24 4 6 &A 24 &B 4 P2^ = P1^ /= ^P2 ;
6 6 6 &A 6 &B 6 Exercice 2 a) P^+2 : 14 b) (p+2)^ : 23 c) P+1 : &A [2] d) & A [4] +1 : &A [5] e) A+3 : &A [4] Chapitre2 : Les Pointeurs
@quipe pdagogique Algorithmique2 21
f) P + (P^ - 10) : &A [3] g) (P + (P+9)^ -A [8])^ : 23 Exercice 3 Algorithme Pointeur_tableau Variables A : tableau [1..10] de entier i : entier c :^entier Dbut Allouer(c) Pour i de 1 10 faire Ecrire ( donner les lments du tableau ) Lire (A[i]) Fin pour Pour i de 1 10 faire Ecrire (A[i]) Fin pour c&A[7] cA[7+1] c^ c^ +1 ecrire ( ladesse et le contenu de c sont respectivemnt2 , c, c^). Pour i de 1 10 faire Ecrire (A[i]) Fin pour Liberer(c) Fin
Chapitre2 : Les Pointeurs
@quipe pdagogique Algorithmique2 22
Exercice4 : a/ Algorithme min_max Const NVAL =10 Var i,min,max,min_p,max_p :entier t : tableau [1..NVAL] de entier t :^entier Dbut Pour i de 1 NVAL faire Lire(t[i]) Fin pour ecrire( formalisme tableau ) max=min=t[0] pour i de1 NVAL faire si (t[i]>max) alors maxt[i] si (t[i]<min) alors mint[i] finsi ecrire( val max ,max) ecrire( val min ,min) ecrire ( formalisme pointeur ) Allouer(t) max_p=min_p=t pour i de 1 NVAL faire si ((t+i)^ > max_p) alors max_p=(t+i)^ si ((t+i)^ < min_p) alors min_p=(t+i)^ Chapitre2 : Les Pointeurs
@quipe pdagogique Algorithmique2 23
finsi ecrire( val_max , max_p) ecrire( val_min , min_p) liberer(t) Fin b/ Algorithme min_max Const NVAL =10 Var i,min,max,min_p,max_p :entier t : tableau [1..NVAL] de entier t :^entier Dbut Pour i de 1 NVAL faire Lire(t[i]) Fin pour ecrire( formalisme tableau ) max=min=t[0] pour i de1 NVAL faire si (t[i]>max) alors maxt[i] si (t[i]<min) alors mint[i] finsi ecrire( val max ,max) ecrire( val min ,min) ecrire ( formalisme pointeur ) Allouer(t) max_p=min_p=t pour i de 1 NVAL faire si ((t+i)^ > max_p) alors Chapitre2 : Les Pointeurs
@quipe pdagogique Algorithmique2 24
max_p=(t+i)^ si ((t+i)^ < min_p) alors min_p=(t+i)^ finsi ecrire( val_max , max_p) ecrire( val_min , min_p) liberer(t) Fin
Chapitre 3 : Les listes
Vue densemble Ce Chapitre prsente la dfinition et lutilisation des listes
Objectifs Ce chapitre a pour objectifs de permettre aux tudiants dacqurir les connaissances de base se rapportant aux objectifs spcifiques suivants: Etre capable dutiliser les listes. Connatre une nouvelle structure de donnes, sa cration et surtout les oprations de base sur une liste chane Savoir crire un algorithme en utilisant la structure de donnes listes.
Pr-requis Algorithmique 1 Les enregistrements Les pointeurs
Dure 3 H
Elments de contenu 1. Introduction 2. Dfinition 3. Oprations sur les listes 4. Reprsentations 5. Algorithmes de quelques oprations sur les listes Chapitre3 : Les Listes
@quipe pdagogique Algorithmique2 27
3.1 Introduction Le principal problme des donnes stockes sous forme de tableaux est que celles-ci doivent tre ordonnes : le "suivant" doit toujours tre stock physiquement derrire. Imaginons grer une association. Un tableau correspond une gestion dans un cahier : un adhrent par page. Supposons dsirer stocker les adhrents par ordre alphabtique. Si un nouvel adhrent se prsente, il va falloir trouver o l'insrer, gommer toutes les pages suivantes pour les rcrire une page plus loin, puis insrer le nouvel adhrent. Une solution un peu plus simple serait de numroter les pages, entrer les adhrents dans n'importe quel ordre et disposer d'un index : une feuille o sont indiqus les noms, dans l'ordre, associs leur "adresse" : le numro de page. Toute insertion ne ncessitera de dcalages que dans l'index. Cette mthode permet l'utilisation de plusieurs index (par exemple un second par date de naissance). La troisime solution est la liste chane : les pages sont numrotes, sur chaque page est indique la page de l'adhrent suivant, sur le revers de couverture on indique l'adresse du premier. Ainsi, l'insertion d'un nouvel adhrent se fera avec le minimum d'oprations. Nous intressons dans ce chapitre de cette nouvelle structure de donnes, sa cration et surtout les oprations de base sur une liste chane. 3.2 Dfinition Les listes font parties des structures de donnes abstraites trs couramment utilises dans les programmes. Une structure de donne abstraite est un type de donne dfini par lutilisateur sous forme de deux composantes une pour reprsenter les donnes (les notations) et une pour reprsenter les oprations daccs aux donnes et ses caractristiques. Une liste stocke un ensemble de donnes et permet de parcourir cet ensemble du dbut la fin dans l'ordre. Cest une suite finie (ventuellement vide) d'lments, Lorsque elle nest pas vide, son premier lment est appel tte et la suite constitue des autres lments est appele queue. Remarque : Les listes servent pour reprsenter des structures de donnes dont la taille change souvent ou pour stocker des donnes dans l'ordre en ayant la possibilit de les mettre jour quand il y a des changements. 3.3 Oprations sur les listes Il existe un certain nombre d'oprations classiques sur les listes. Le test si la liste est vide. ajouter un lment: o au dbut de la liste o la fin de la liste o un rang donn Chapitre3 : Les Listes
@quipe pdagogique Algorithmique2 28
rechercher un lment: o rsultat boolen o rsultat = rang de la premire occurrence o rsultat = nombre d'occurrences enlever un lment: o caractris par sa valeur o caractris par son rang calculer la longueur d'une liste (nombre d'lments) 3.4 Reprsentation 3.4.1 Reprsentation graphique
3.4.2 Reprsentation des donnes La structure de donne qui permet de reprsenter une liste chane dans le cas gnral est dclare comme suit : Type Cellule = enreg valeur : type suivant : ^Cellule FinEnreg Liste : ^Cellule Ainsi le type Liste est un pointeur vers le type Cellule qui est un enregistrement form de deux champs : un qui contient la valeur de llment donc le type peut tre un type quelconque et le 2 me champ contient un pointeur vers la cellule suivante. C'est--dire il contient ladresse de la cellule suivante. La dernire cellule ne pointe vers rien donc elle doit contenir la valeur Nil. L Chapitre3 : Les Listes
@quipe pdagogique Algorithmique2 29
Le type Liste contient un pointeur vers le type Cellule qui contient ladresse du 1 er lment de la liste. 3.5 Algorithmes de quelques oprations sur les listes Pour simplifier on va travailler sur une liste dont les valeurs sont de type entier. Alors la dfinition du type liste sera comme suit : Type Cellule = enreg valeur : entier suivant : ^Cellule FinEnreg Liste : ^Cellule ListeVide : La 1 re fonction de base quon doit crire pour pouvoir manipuler des donnes de type liste est la fonction ListeVide () qui prend en entre une liste et retourne vrai si elle est vide et faux sinon. Fonction ListeVide (liste1 : Liste) : Booleen Debut Si (liste1 = Nil) Alors Retourner (Vrai) Sinon Retourner (Faux) FinSi Fin
PosFin : La fonction PosFin () prend en entre une liste et retourne un pointeur vers le dernire lment de la liste.
Chapitre3 : Les Listes
@quipe pdagogique Algorithmique2 30
Fonction PosFin (liste1 : Liste) : Liste Var listeAux : Liste Debut listeAux liste1 Si (listeAux <> Nil) Alors Tantque (listeAux^.suivant <> Nil) Faire listeAux listeAux^.suivant Fintanque FinSi Retourner (listeAux) Fin
AjouterTete : La fonction AjouterTete () prend en entre une valeur ajouter en tte dune liste donne et retourne un pointeur vers le dbut de la nouvelle liste. Cette fonction doit crer une nouvelle variable dynamique pour contenir la nouvelle cellule, puis remplir le champ valeur et le champ suivant de cette cellule ensuite mettre ladresse de cette cellule dans le pointeur vers la tte de liste et retourner cette valeur.
Fonction AjouterTete (v : entier, L : Liste) : Liste Var C : ^Cellule Debut Allouer (C) C^.valeur v C^.suivant L L C Retourner (L) Fin
Ajouter un lment la fin de la liste La fonction Ajouter_fin() prend en entre une valeur ajouter la fin dune liste donne et retourne un pointeur vers le dbut de la nouvelle liste. v L Chapitre3 : Les Listes
@quipe pdagogique Algorithmique2 31
procedure ajouter_fin(liste1 : Liste, e : entier) liste2 : Liste; debut oSi (liste1= Nil) Alors liste1 new couple(e, null) sinon /* parcours de la liste vers la fin */ Liste2 PosFin(liste1) /*ajout de llment e la fin de la liste */ liste2.suivant new couple(e, null) fisi /* nous pouvons ajouter le retour en tte de la liste */ fin ajouter_fin;
langueur dune Liste Cette fonction calcule le nombre des lments de la liste. Elle prend comme argument lentre une liste et retourne comme sortie un entier prsentant la langueur de la liste. function longueur(liste1 : Liste) : entier x : entier listeAux : Liste dbut x 0 listeAux liste1 Tantque (listeAux^.suivant <> Nil) Faire x x + 1 listeAux listeAux^.suivant Fintanque retourner x; fin longueur
chercher un lment dans la liste Chapitre3 : Les Listes
@quipe pdagogique Algorithmique2 32
Cette fonction permet de rechercher la position dun lment dans une liste en supposant quil existe, sinon, la fonction retourne faux. Ses paramtres dentre sont alors la liste et llment recherch, et son paramtre de sortie tant un boolen.
function appartient(x : entier; liste1 : Liste) : boolen liste2 : Liste dbut liste2 liste1 tantque (liste2 != null && liste2^.valeur <>x) liste2 liste2^.suivant fin tantque si (liste2^.valeur <>x) alors retourner (vrai) sinon retourner (faux) fin si fin appartient;
Chapitre 4 : Les Piles et les Files
Vue densemble Ce Chapitre prsente la dfinition et lutilisation des Piles et des files
Objectifs Ce chapitre a pour objectifs de permettre aux tudiants dacqurir les connaissances de base se rapportant aux objectifs spcifiques suivants: Etre capable dutiliser les piles et les files. Connatre une nouvelle structure de donnes, sa cration et surtout les oprations de base sur une pile et une file Savoir crire un algorithme en utilisant les structure de donnes piles et files.
Pr-requis Algorithmique 1 Les enregistrements Les pointeurs
Dure 6 H
Elments de contenu 1. Introduction 2. Les piles 3. Les files
Chapitre4 : Les Piles et les Files
@quipe pdagogique Algorithmique2 33
4.1 Les piles 4.1.1 Prsentation Une pile est une suite de cellules alloues dynamiquement (liste chane) o linsertion et la suppression dun lment se font toujours en tte de liste. Limage intuitive dune pile peut tre donne par une pile dassiettes, ou une pile de dossiers condition de supposer quon prend un seul lment la fois (celui du sommet). On peut rsumer les contraintes daccs par le principe dernier arriv, premier sorti qui se traduit en anglais par : Last In First Out (figure 1).
La structuration dun objet en pile simpose lorsquon mmorise des informations qui devront tre traites dans lordre inverse de leur arrive. Cest le cas, par exemple, de la gestion des adresses de retour dans lexcution dun programme rcursif. En supposant que les lments de la pile sont des entiers, celle-ci se dclare de la faon suivante : Types Pile = ^Cellule Cellule = Enreg Elem : Entier Suiv : Pile FinEnreg Var P : Pile E1 E2 E3 Nil Sommet Chapitre4 : Les Piles et les Files
@quipe pdagogique Algorithmique2 34
4.1.2 Manipulation dune pile Dun point de vue manipulation, les contraintes daccs sont matrialises par les procdures et les fonctions suivantes : Procdure Initialiser (Var P : Pile) : cre une pile vide P. Procdure Initialiser (Var P : Pile) Dbut P Nil Fin Fonction Pile_Vide (P : Pile) : Boolen : renvoie la valeur vrai si la pile est vide. Fonction Pile_Vide (P : Pile) : Boolen Dbut Pile_Vide (P = Nil) Fin Procdure Empiler (x : Entier ; Var P : Pile) : ajoute llment x au sommet de la pile. Procdure Empiler (x : Entier ; Var P : Pile) Variables Q : Pile Dbut Allouer (Q) Q^.Elem x Q^.Suiv P P Q Fin
x P Chapitre4 : Les Piles et les Files
@quipe pdagogique Algorithmique2 35
Procdure Dpiler (Var x : Entier ; Var P : Pile) : dpile le sommet de la pile et le met dans la variable x. Procdure Dpiler (Var x : Entier ; Var P : Pile) Dbut Si NON (Pile_Vide(P)) Alors x P^ .Elem Q P P P^ .Suiv Librer (Q) Sinon Ecrire (Impossible, la pile est vide) FinSi Fin
4.2 Les Files 4.2.1 Prsentation Une file est une suite de cellules alloues dynamiquement (liste chane) dont les contraintes daccs sont dfinies comme suit : - On ne peut ajouter un lment quen dernier rang de la suite. - On ne peut supprimer que le premier lment. Limage intuitive dune file peut tre donne par la queue devant un guichet lorsquil ny a pas de resquilleurs. On peut rsumer les contraintes daccs par le principe premier arriv, premier sorti qui se traduit en anglais par : First In First Out.
La structuration dun objet en file simpose en particulier lorsquune ressource doit tre partage par plusieurs utilisateurs : il y a formation dune file dattente. Queue E1 E2 E3 Nil Sommet
P Chapitre4 : Les Piles et les Files
@quipe pdagogique Algorithmique2 36
Un exemple est donn par le spooler dimpression qui est un programme qui reoit, traite, planifie et distribue les documents imprimer dans un systme multiprogramm. En supposant que les lments de la file sont des entiers, celle-ci se dclare de la faon suivante : Types Liste = ^Cellule Cellule = Enreg Elem :Entier Suiv : Liste FinEnreg File = Enreg Tte : Liste Queue : Liste FinEnreg Var F : File 4.2.2 Manipulation dune file Dun point de vue manipulation, les contraintes daccs sont matrialises par les procdures et les fonctions suivantes : Procdure Initialiser (Var F : File) : cre une file vide F. Procdure Initialiser (Var F : File) Dbut F.Tte Nil F .Queue Nil Fin Procdure Ajouter (x : Entier ; Var F : File) : ajoute llment x la fin de la file. Procdure Ajouter (x : Entier ; Var F : File) Var P : Liste Dbut Chapitre4 : Les Piles et les Files
@quipe pdagogique Algorithmique2 37
Allouer (P) P^ .Elem x P^ .Suiv Nil Si (F .Queue <> Nil) Alors F .Queue^. Suiv P Sinon F.Tte P FinSi F .Queue P Fin Dans le cas o la file est vide, comme la queue, la tte de la file doit galement pointer vers le nouvel lment. Procdure Extraire (Var x : entier ; Var F : File) : extrait le sommet de la file et le met dans la variable x. Procdure Extraire (Var x : entier ; Var F : File) Var P : Liste Dbut Si (F.Tte = Nil) Alors Ecrire ( impossible, la file est vide ) Sinon P F.Tte x F.Tte^.Elem F.Tte F.Tte^. Suiv Librer (P) FinSi Fin Remarque Dans les langages qui noffrent pas le type pointeur, les structures de pile ou file peuvent tre implantes sous forme de tableaux. Ainsi, une pile dentiers peut tre dclare de la faon suivante : Chapitre4 : Les Piles et les Files
@quipe pdagogique Algorithmique2 38
Constantes n = 100 Types Indice : 1..n Cellule = Enreg Elem : entier Suiv : Indice FinEnreg Pile = Tableau [Indice] de cellule Variables L : Pile
Chapitre 5 : La Rcursivit
Vue densemble Cette leon prsente la dfinition et lutilit de la rcursivit.
Objectifs Ce chapitre a pour objectifs de permettre aux tudiants dacqurir les connaissances de base se rapportant aux objectifs spcifiques suivants: Etre capable de transformer un schma itratif simple en un schma rcursif. Savoir crire un algorithme rcursif.
Pr-requis Algorithmique 1
Dure 6 H
Elments de contenu 1. Rappel 2. Algorithmes rcursives Chapitre5 : La rcursivit
@quipe pdagogique Algorithmique2 39
5.1 Rappel 5.1.1 Les procdures 5.1.1.1 Dfinition Une procdure est un sous algorithme ralisant un traitement sur une partie des donnes dun algorithme principal. Elle permet de dcomposer un algorithme en sous algorithme ou module plus simple et donc de simplifier la lecture et le suivi dun algorithme. Une procdure est dfinie avant le code de lalgorithme principal puis elle est appele par son nom suivi de ses paramtres sils existent. Syntaxe
Procedure nom (P1: type, , Pn : type) Var {Variable} Debut <Traitement> Fin
Algorithme Principal Var {Variable} Debut
nom (P1, , Pn)
Fin
Remarque : - nom est le nom de la procdure. - type est un type de donne simple ou compos. - P1 Pn sont les paramtres de la procdure. - Une procdure peut tre appele partir de lalgorithme principal ou dune autre procdure.
Schma dexcution Lappel de la procdure se fait en utilisant son nom suivi de ses paramtres spars par des virgules et entours par des parenthses. Quand on appelle une procdure le contrle se trouve automatiquement transfr au dbut de la procdure. Quand toutes les instructions de la procdure ont t excutes le contrle retourne linstruction qui suit immdiatement linstruction dappel de la procdure.
Chapitre5 : La rcursivit
@quipe pdagogique Algorithmique2 40
Algorithme Principal Var V1: entier Debut
proc (V1)
Fin Procedure proc (P1: entier) Var X1 : reel Debut
Fin 5.1.1.2 Les variables et les paramtres Variable locale Une variable est dite locale si elle est dfinie dans la partie de dclaration des variables propre la procdure. Elle nest accessible que dans la procdure o elle a t dfinie. Dans lexemple prcdent X1 est une variable locale la procdure proc. Variable globale Une variable est dite globale si elle est dfinie au niveau de lalgorithme principal qui appelle la procdure cest dire une variable utilise par la procdure et qui nest pas dclar dans cette procdure. Une variable globale peut tre utilis nimporte o, lintrieur ou lextrieur dune procdure on parle donc de visibilit et on dit quelle est visible par lalgorithme principal et par toutes les autres procdures utilises. Dans lexemple prcdent V1 est une variable globale. Lchange dinformation entre la procdure et lalgorithme peut se faire travers les variables globales. Cette mthode peut changer le contenu de la variable lintrieur de la procdure ce qui peut affecter lexcution de lalgorithme principal. Pour rsoudre ce problme on fait recours lemploie des paramtres qui offrent une meilleur approche pour lchange dinformation entre la procdure et le lalgorithme principal. Le transfert dune donne se fait entre un paramtre effectif et un paramtre formel. Paramtre formel Un paramtre formel est un paramtre dfini dans la dclaration de la procdure c'est-- dire dans lentte de procdure. Dans lexemple prcdent P1 est un paramtre formel la procdure proc. Chapitre5 : La rcursivit
@quipe pdagogique Algorithmique2 41
Paramtre effectif Un paramtre effectif est un paramtre utilis pendant lappel de la procdure. Dans lexemple prcdent V1 est un paramtre effectif pour la procdure proc. Lors de lappel de la procdure et avant de commencer son excution les paramtres formels sont initialiss par les valeurs des paramtres effectifs. Ainsi dans lexemple prcdent P1 est initialis avec la valeur de V1. Exemple
Procedure max (x : entier, y : entier) Var m : entier Debut Si x>y Alors m x Sinon m y FinSi Ecrire ("le max est :", m) Fin Algorithme Maximum Var A, B : entier Debut Lire (A, B) max (A, B) Fin
On dsigne par - A, B: 2 paramtres effectifs - x, y: 2 paramtre formels - A, B : variables globales - m: variable locale 5.1.1.3 Passage des paramtres Passage des paramtres par valeur Le mode de transfert de paramtre entre lalgorithme appelant et la procdure appel dfinit un moyen dchange de donne entre eux. Dans le passage des paramtres par valeur qui reprsente le 1 er mode, les paramtres formels de la procdure reoivent les valeurs des paramtres effectifs, ainsi avant lexcution de la procdure, ses paramtres formels sont initialiss avec les valeurs des paramtres effectifs. Tous changement des paramtres formels dans la procdure ne change pas les valeurs des paramtres effectifs associs. Dans lexemple prcdent le mode de passage des paramtres pour la procdure max est par valeur, les paramtres formels sont x et y, ils sont initialiss par les valeurs de A et B. Passage des paramtres par variable Contrairement au mode de passage des paramtres par valeur, dans le mode de passage des paramtres par variable toutes modification dans la valeur du paramtre formel pass par variable, implique une modification de la valeur du paramtre effectif correspondant. Ainsi ce Chapitre5 : La rcursivit
@quipe pdagogique Algorithmique2 42
2 me mode est plus gnral que le 1 er il prend les caractristiques du 1 er et ajoute la possibilit de modifier les variables de lalgorithme appelant partir de la procdure. Pour dfinir un passage de paramtre par variable on ajoute le mot cl var dans la dfinition des paramtres de la procdure avant les paramtres pour lesquels on veut dfinir ce mode. Un paramtre pass par variable ne peut tre quune variable il ne peut pas tre une constante ou une expression. Exemple Procedure max (x : entier, var y : entier) Var m : entier Debut Si x>y Alors m x Sinon m y FinSi Ecrire ("le max est :", m) x 0 y 0 Fin Algorithme Maximum Var A, B : entier Debut Lire (A, B) {2,4} {ceci est un commentaire} max (A, B) Ecrire (A, B) Ecrire (x, y) Fin
5.1.2 Les fonctions 5.1.2.1 Dfinition La fonction possde la mme dfinition que la procdure mais avec seulement 2 diffrences. Dabord une fonction possde une valeur de retour. Ensuite la fonction est utilise dans lalgorithme principal comme une variable contrairement la procdure qui est utilis comme une instruction. Syntaxe
Fonction nom_fonction (P1: type, , Pn : type) : type Var {Variable} Debut <Traitement> Retourner (val_retour) Fin
Algorithme Principal Var vf : type
Debut
vf nom_fonction (P1, , Pn)
Fin Chapitre5 : La rcursivit
@quipe pdagogique Algorithmique2 43
Remarque : Le type de la fonction doit tre le mme que le type de la variable vf utilis dans lalgorithme principal pour recevoir la valeur de retour de la fonction. Exemple Fonction max (x : entier, y : entier) : entier Var
Debut Si x>y Alors Retourner (x) Sinon Retourner (y) FinSi Fin Algorithme Maximum Var A, B, M : entier Debut Lire (A, B) {2,4} M max (A, B) Ecrire ("le max est :", M) Fin
5.2 Algorithmes rcursifs 5.2.1 Dfinitions rcursives Une dfinition rcursive est dfinie en fonction d'un objet ou d'une action de mme nature mais de complexit moindre. Exemple On peut dfinir le factoriel d'un nombre n positif de deux manires: - dfinition non rcursive (ou itrative): n ! = n * n-1 * ... 2 * 1 - dfinition rcursive:
n ! = n * (n-1) ! et 0 ! = 1
Une dfinition rcursive est compose de deux partie: une partie strictement rcursive et une partie non rcursive (base) servant de point de dpart l'utilisation de la dfinition rcursive. Chapitre5 : La rcursivit
@quipe pdagogique Algorithmique2 44
5.2.2 Fonctions rcursives 5.2.2.1 Dfinition Comme pour les dfinitions rcursives, les fonctions rcursives sont des fonctions qui sont appeles depuis leur propre corps de fonction, soit directement soit indirectement, travers une ou plusieurs fonctions relais. Si la fonction P appelle directement P, on dit que la rcursivit est directe. Si P appelle une fonction P1, qui appelle une fonction P2 et qui enfin appelle P, on dit qu'il s'agit d'une rcursivit indirecte. Si la fonction P appelle dans son propre corps la fonction P, il est logique de penser que lexcution ne s'arrtera jamais. Il est donc primordial qu'une des branches de la fonction P permette de stopper la rcursivit. Exemple On veut calculer la somme des n premiers entiers positifs. Une dfinition rcursive de cette somme serait: Somme (n) = n + somme (n-1) Et somme(1) = 1
Ce qui se traduit par la fonction rcursive suivante:
Fonction somme (n : entier) : entier Var m : entier Debut Si (n = 1) alors somme 1 Sinon m somme (n-1) somme n + m FinSi Fin
Il est clair que sans le test Si (n = 1) cette fonction ne s'arrterait jamais. 5.2.2.2 Excution dune fonction rcursive Supposant qu'on appelle la fonction somme (4). Puisque 4 1, cette fonction va s'appeler elle-mme avec la valeur 3 (somme (3)). Ce nouvel appel se termine en renvoyant une valeur Chapitre5 : La rcursivit
@quipe pdagogique Algorithmique2 45
(dans cet exemple la valeur retourne est 6 = 3 + 2 + 1). Cette valeur sera ajoute la valeur 4 et l'appel de somme (4) retournera la valeur 10 (4 + 6). L'appel somme (3) suivra le mme processus et appellera somme (2) qui lui-mme appellera somme (1) qui retourne 1. somme(4) somme(3) somme(2) somme(1) retourne 1 retourne 2 + 1 retourne 3 + 3 retourne 4 + 6 5.2.2.3 Variables locales et paramtres des fonctions rcursives Lorsqu'une fonction rcursive dfinit des variables locales, un exemplaire de chacune d'entre elles est cr chaque appel rcursif de la fonction. Dans notre exemple somme (4), la variable locale m est cre 4 fois. Ces variables sont dtruites au fur et mesure que l'on quitte la fonction comme toute variable locale d'une fonction. Il en est de mme des paramtres des fonctions. somme(4) cration du 1 er m somme(3) cration du 2 me m somme(2) cration du 3 me m somme(1) cration du 4 me m destruction de m retourne 1 destruction de m retourne 2 + 1 destruction de m retourne 3 + 3 destruction de m retourne 4 + 6 Chapitre5 : La rcursivit
@quipe pdagogique Algorithmique2 46
5.3 Exercices dapplication
Exercice 1 : Ecrire une fonction rcursive qui permet de calculer le produit de deux entiers k et x selon la formule suivante : K*x=x+ (k-1)*x On prendra soin de trouver les cas particuliers (pour que la rcursivit sarrte) Exercice2: Pour calculer le PGCD de deux entiers positifs a et b, nous allons utiliser lalgorithme dEuclide. Celui-ci est rsum comme suit : Si lun des entiers est nul, alors le PGCD est gal lautre. Sinon le PGCD de a et b est gale au PGCD de a et de b-a (sous lhypothse que b>=a) Ecrire la fonction rcursive correspondante. Exercice 3 : 1. Nous cherchons raliser une fonction qui partir de deux entiers positifs a et b, renvoie le quotient de la division de a par b .On cherche raliser cela sans utiliser les oprateurs DIV ou MOD, Ecrire le programme de cette division sous forme rcursive. 2. Mme question, mais pour le reste de la division de a par b Exercice 4 : Ecrire une fonction rcursive qui prend en entre un entier positif N et retourne la valeur de N factoriel (N !), en utilisant la dfinition rcursive suivante : N ! = N * (N-1) ! 0 ! = 1 Exercice 5 : Ecrire une fonction rcursive qui permet de calculer les n termes de la suite de Fibonacci sachant que : F (0) = 1 F (1) = 1 Pour tout N 2 : F (N) = F (N-1) + F (N-2)
Chapitre5 : La rcursivit
@quipe pdagogique Algorithmique2 47
Exercice 6 : On dsire raliser les tches suivantes : 1- Saisir un entier N (0 <N <20). 2- remplir un tableau T par N entiers positifs. 3- Inverser le tableau T. 4- Afficher le nouveau tableau T. Exemple : Si on donne N=7 et T 1 10 9 6 11 3 8 Aprs inversion on obtient 8 3 11 6 9 10 1 Ecrire le programme principal et les sous programmes ncessaires pour raliser ces tches. Les algorithmes de la tche 1,2 et 4 doivent tre itratifs et celui de la tache 3 rcursif.
5.4 Solutions des exercices
Exercice1 : Fonction produit(k :entier,x :entier) :entier var p :entier debut Si (k=1) alors Px sinon si(k=0) alors p0 sinon px+produit(k-1,x) FinSi FinSi returner(p) Fin
Chapitre5 : La rcursivit
@quipe pdagogique Algorithmique2 48
Exercice 2 Foncion pgcd(a :entier,b :entier) :entier var r :entier debut Si ((a=0) ou (b=0))alors Ra+b; sinon
Si (b>=a) alors Rpgcd(a,b-a); sinon rpgcd(b,a-b); FinSi
FinSi returner(r) Fin
Exercice 3 Fonction quotient(a :entier,b :entier) :entier var q :entier debut si (a<b) alors q0; sinon q1+quotient(a-b,b); finSi returner(q) Fin Fonction reste(a :entier,b :entier) :entier var r :entier Chapitre5 : La rcursivit
@quipe pdagogique Algorithmique2 49
debut si (a<b)alors ra; sinon rreste(a-b,b) finSi returner(r) Fin
Exercice 4
Fonction Factoriel(n :entier):entier
var F: entier Debut Si(n=0) Alors Retourner(1) Sinon F Factoriel(n-1) Retourner(n*F) FinSi Fin
Exercice 5 Fonction Fibonacci(n :entier):entier var F1,F2: entier Debut Si(n=0 ou n=1) Alors Retourner(1) Sinon F1 Fibonacci(n-1) Chapitre5 : La rcursivit
@quipe pdagogique Algorithmique2 50
F2 Fibonacci(n-2) Retourner(F1+F2) FinSi Fin
Exercice 6 Procedure saisir(var n:entier)
debut ecrire("taper un entier entre 1..20") lire(n)
Si (n>20) ou (n<0) alors saisir(n) fin
procedure remplir(var a: tableau[1..20] de entier;n:entier) var i:entier
debut
lire(a[n])
Si a[n]<0 Alors remplir(a,n) sinon si n>1 alors remplir(a,n-1) finSi fin
procedure affiche(a: tableau[1..20] de entier;n:entier) var i:entier
debut
ecrire(a[n])
Si n>1 Alors affiche(a,n-1) Chapitre5 : La rcursivit
@quipe pdagogique Algorithmique2 51
finSi fin
procedure inverser(var t: tableau[1..20] de entier;d,f:entier) var aux:entier
debut Si d <f alors auxt[d] t[d]t[f] t[f]aux inverser(t,d+1,f-1) FinSi Fin
//Algorithme principlal Algorithme inversttrecursif var t: tableau[1..20] de entier n:entier debut
saisir(n) remplir(t,n) affiche(t,n) inverser(t,1,n) affiche(t,n) Fin
Chapitre 6 : Les arbres et les graphes
Vue densemble Ce Chapitre prsente la dfinition et lutilisation des arbres et des graphes
Objectifs Ce chapitre a pour objectifs de permettre aux tudiants dacqurir les connaissances de base se rapportant aux objectifs spcifiques suivants: Etre capable dutiliser les arbres et les graphes. Connatre une nouvelle structure de donnes, sa cration et surtout les oprations de base sur un arbre et un graphe Savoir crire un algorithme en utilisant se rapportant des structures dynamiques de donnes arbres et graphes.
Pr-requis Algorithmique 1 Les enregistrements Les pointeurs La rcursivit
Dure 6 H
Elments de contenu 1. Les arbres 2. Les graphes Chapitre6 : Les arbres et les graphes
@quipe pdagogique Algorithmique2 52
6.1 Les Arbres 6.1.1 Dfinition Un arbre est un ensemble de nuds avec une relation de hirarchie entre Pre et Fils
Sous arbre
Remarque : - Un arbre est : - soit un arbre vide - soit un nud racine et un ensemble de (sous)-arbres T1 ,, Tn de sorte ce que la racine de Ti est connect par un lien direct la racine. - la racine est un nud sans pre - la feuille est un nud sans fils - le nud interne est un nud admettant au moins un fils Exemple
feuille Fils Pre et Fils feuille
racine Nud interne A B C C D F H G E
Pre et Fils Fils Pre Chapitre6 : Les arbres et les graphes
@quipe pdagogique Algorithmique2 53
Oprations sur les arbres Il existe un certain nombre d'oprations classiques sur les arbres : - Tester si larbre est vide ou non - Crer un arbre ou une feuille - Supprimer un nud ou la totalit de larbre - Accder une valeur qui se trouve dans la racine. 6.1.2 Implmentation Un arbre peut tre reprsent par un ensemble de nuds, chaque nud contient une valeur et un tableau de N case qui contient des pointeurs pour les N fils du nud. N reprsente le nombre maximal de fils que peut avoir un nud dans larbre. Ainsi il se dfinit comme suit : Type Nud = Enreg valeur : type fils : Tableau [1..N] de ^Nud FinEnreg Arbre = ^Nud Var A : Arbre La figure ci-dessous reprsente un arbre avec N= 3, donc chaque nud doit avoir au maximum 3 fils.
6.1.3 Les fonctions daccs Nous allons tudier un cas particulier des arbres : les arbres binaires. Un arbre binaire est un arbre o tout nud a zro ou deux fils. La reprsentation de la structure de donnes arbre binaire est constitue de 2 parties une pour reprsenter un nud qui contient une valeur, un pointeur vers le nud gauche appel aussi A Chapitre6 : Les arbres et les graphes
@quipe pdagogique Algorithmique2 54
fils gauche et un pointeur vers le nud droit ou le fils droit ; et une autre partie qui constitue la reprsentation de larbre sous forme dun pointeur vers un nud qui est la racine. On travaille sur les valeurs de type entier. Type Nud = enreg valeur : entier fils_gauche : ^Nud fils_droit : ^Nud FinEnreg Arbre_binaire = ^Nud
ArbreBinVide Teste si un arbre binaire est vide ou non. Fonction ArbreBinVide (A : Arbre_binaire) : Booleen Debut Si (A = Nil) Alors Retourner (Vrai) Sinon Retourner (Faux) FinSi Fin CreerFeuille Cette fonction cre un nud contenant une valeur et retourne son adresse en mmoire.
A Chapitre6 : Les arbres et les graphes
@quipe pdagogique Algorithmique2 55
Fonction CreerFeuille (v : entier) : Arbre_binaire Var F : Arbre_binaire Debut Allouer (F) F^.valeur v F^.fils_gauche Nil F^.fils_droit Nil Retourner (F) Fin CreerArbreBin Cette fonction cre un arbre binaire partir dun sous arbre droit et un sous arbre gauche existants et dune valeur mettre dans la racine enfin elle retourne ladresse de la racine. Fonction CreerArbreBin (v : entier, fg : Arbre_binaire, fd : Arbre_binaire) : Arbre_binaire Var R : Arbre_binaire Debut Allouer (R) R^.valeur v R^.fils_gauche fg R^.fils_droit fd Retourner (R) Fin
v F v R Chapitre6 : Les arbres et les graphes
@quipe pdagogique Algorithmique2 56
SupprimeArbreBin Cette procdure permet de supprimer tous les nuds dun arbre binaire dont ladresse de sa racine est fournie en paramtre. Procedure SupprimeArbreBin (A : Arbre_binaire) Debut Si ( ArbreBinVide(A) = Faux ) Alors SupprimeArbreBin (A^.fils_gauche) SupprimeArbreBin (A^.fils_droit) Liberer(A) FinSi Fin Accs la racine Cette fonction rcupre la valeur contenue dans le nud racine Fonction Racine (A :Arbre_Binaire) : entier Debut Si (A<>Nil) Retourner (A^.valeur) Sinon Ecrire( Erreur ) Fin Si Fin 6.1.4 Niveau et hauteur dun arbre : - Le niveau dun nud v est le nombre de ses anctres - si v est la racine alors son niveau est 0 - sinon le niveau de v est : 1+ niveau du pre de v - La hauteur dun nud v est dfinie par la dfinition suivante : Chapitre6 : Les arbres et les graphes
@quipe pdagogique Algorithmique2 57
- si v est un nud feuille alors sa hauteur est 0 - sinon la hauteur de v est : 1+ maximum des hauteurs de ses fils - La hauteur dun arbre est la hauteur de sa racine
- Nud b : - niveau=1 - hauteur=2 - hauteur de larbre=3 6.1.5 Parcours dun arbre 6.1.5.1 Types de parcours - Parcourir un arbre revient visiter ses nuds - Visiter un nud revient effectuer un certain traitement sur ce nud qui dpend de lapplication (affichage du contenu, modification dun attribut, calcul dune valeur, ) - Il existe 2 types de parcours : o Le parcours en profondeur qui explore larbre branche par branche et peut tre prfix, infix ou post fix : Parcours prfix : on parcourt la racine puis le sous arbre gauche enfin le sous arbre droit. Parcours infix: on parcourt le sous arbre gauche puis la racine enfin le sous arbre droit. a b c d f e g k h l Niveau 0 Niveau 1 Niveau 2 Niveau 3 Chapitre6 : Les arbres et les graphes
@quipe pdagogique Algorithmique2 58
Parcours postfix: on parcourt le sous arbre gauche puis le sous arbre droit enfin la racine. o Le parcours en largeur qui explore larbre niveau par niveau en commence par la racine. Parcours I nfix Soit un arbre binaire dont les valeurs sont des entiers on veut crire une procdure rcursive qui fait un parcours infix de cet arbre pour afficher les valeurs qui se trouvent dans tous les nuds. Procedure Infixe (A : Arbre_binaire) Var Debut Si ( ArbreBinVide(A) = Faux ) Alors Infixe (A^.fils_gauche) Ecrire (A^.valeur) Infixe (A^.fils_droit) FinSi Fin Exemple Si on prend larbre suivant :
Niveau 0 1
Niveau 1 2 3 4
Niveau 2 5 6 7 Chapitre6 : Les arbres et les graphes
@quipe pdagogique Algorithmique2 59
- Le parcours prfix donne : (1,2,5,6,3,4,7) - Le parcours postfix donne : (5,6,2,1,3,7,4,1) - Le parcours infix donne : (5,2,6,1,3,7,4) - Le parcours en largeur donne : (1,2,3,4,5,6,7) 6.2 Les graphes 6.2.1 Dfinition - Les graphes sont des structures de donnes qui permettent de reprsenter un grand nombre de donnes : des rseaux, des plans, des trajets, etc. - Un graphe orient est un couple G=(S, A) o : - S reprsente un ensemble de sommets, - A reprsente un ensemble darcs. Soit a A, a= (u, v) - u est appel origine de a, - v est appel extrmit de a, - u=prdcesseur (v) - v=successeur (u) - larc a est not uv Exemple S= {1, 2, 3, 4,5} A= {(1,2), (1,3), (2,4), (2,5), (3,1), (3,3), (4,5), (5,1)} 1 3 5 4 2
Chapitre6 : Les arbres et les graphes
@quipe pdagogique Algorithmique2 60
6.2.2 Implmentation : Pour implmenter un graphe, nous allons utiliser le mode de reprsentation par matrice dadjacence. Dans un graphe, il faux pouvoir bnficier des fonctionnalits suivantes : - crer un graphe - initialiser un graphe - ajouter un arc dans un graphe - supprimer un arc dans un graphe - ajouter un sommet dans le graphe - trouver le successeur dun sommet du graphe Structure de donnes Pour implmenter la structure de donnes graphe selon la reprsentation matricielle, nous avons besoin de : - un tableau deux dimensions pour dfinir le graphe - un type de donnes sommet, dans ce cas un sommet est un entier (indice de ligne ou de colonne de la matrice) - un arc dfini par deux sommets : une origine et une extrmit. Type Sommet=entier Arc = Enreg Origine : Sommet Extrmit : Sommet FinEnreg Graphe =Enreg T : Tableau [1..Max][1..Max] de Sommet NS : entier FinEnreg Avec NS=Nombre de sommets dans les graphes. Max : nombre maximal pour le nombre de sommets du graphe Cration du graphe Pour crer un graphe, revient initialiser le nombre de sommet. Chapitre6 : Les arbres et les graphes
@quipe pdagogique Algorithmique2 61
Fonction CreerGraphe(n :entier) :Graphe Var G :Graphe Debut G.NS n Allouer (G.T, n*n) Retourner (G) Fin Initialisation du graphe Cette fonction permet dinitialiser les cases de la matrice 0, le graphe une fois cre est initialis, ensuite les arcs sont ajouts au fur et mesure des besoins de lapplication. Fonction InitialiserGraphe(G :Graphe) :Graphe Var i, j : entier Debut Pour i de 1 G.NS faire Pour j de 1 G.NS faire G.T[i,j]0 Fin Pour Fin Pour Retourner (G) Fin Ajout dun arc Permet dattacher un arc pralablement cre au graphe Fonction AjouterArc (G :Graphe, a :Arc) :Graphe Debut Si (a.origine >G.NS ou a.extrmit>G.NS ou a.origine <1 ou a.extrmit<1) alors Ecrire ( Arc non dfini ) Sinon G.T [a.origine , a.extrmit] 1 Fin Si Retourner (G) Fin Chapitre6 : Les arbres et les graphes
@quipe pdagogique Algorithmique2 62
Suppression dun arc Permet de supprimer un arc existant du graphe Fonction SupprimerArc (G :Graphe, a :Arc) :Graphe Debut Si (a.origine >G.NS ou a.extrmit>G.NS ou a.origine <1 ou a.extrmit<1) alors Ecrire ( Arc non dfini ) Sinon G.T [a.origine, a.extrmit] 0 Fin Si Retourner (G) Fin Ajout dun sommet Cette fonction permet dajouter un sommet au graphe dans la limite de la taille prvue, et initialise les arcs du nouveau sommet 0 Fonction AjouterSommet (G : Graphe, s : Sommet) :Graphe Debut Si (s>Max) alors Ecrire ( Arc non dfini ) Sinon G.NS=G.NS+1 Pour i de 1 G.NS faire G.T [s, i] 0 G.T [i, s] 0 Fin pour Fin Si Retourner (G) Fin Successeur dun sommet Recherche le premier successeur dun sommet du graphe. Cette fonction retourne le premier successeur du sommet dans le graphe, et la valeur -1 sil nexiste pas de successeur Fonction Successeur (G : Graphe, s : Sommet) : Sommet Var Trouve : boolen succ: Sommet Chapitre6 : Les arbres et les graphes
@quipe pdagogique Algorithmique2 63
dbut si (s<1) ou (S>G.NS) alors Ecrire ( Sommet inexistant ) Sinon Trouve faux Succ 1 Tant que (succ<G.NS) et (trouve<>vrai) faire Si (G.T[s,succ]=1) alors Trouvevrai Sinon Succsucc+1 Fin Si Fin Tant que Si (trouve=vrai) alors Retourner (succ) Sinon Retourner (-1) Fin Si Fin Exemple Nous allons crer le graphe suivant : 1 3 2
Algorithme Principal Type Sommet=entier Arc = Enreg Origine : Sommet Extrmit : Sommet FinEnreg Graphe =Enreg Chapitre6 : Les arbres et les graphes
@quipe pdagogique Algorithmique2 64
T : Tableau [1..Max][1..Max] de Sommet NS : entier FinEnreg Var G1 : Graphe A : Arc Dbut G1CreerGraphe(3) G1InitialisationGraphe(G1) //1re arc A.origine 1 A.extrmit 1 G1 AjouterArc(G1,A) ;
//4me arc A.origine 3 A.extrmit 2 G1 AjouterArc(G1,A) ; Fin
Chapitre 7 : Les algorithmes rcursifs de recherche
Vue densemble Ce Chapitre prsente les algorithmes de recherche rcursifs.
Objectifs Ce chapitre a pour objectifs de permettre aux tudiants dacqurir les connaissances de base se rapportant aux objectifs spcifiques suivants: Etre capable dutiliser les algorithmes de recherches rcursifs sur des structures des donnes dynamique (liste, pile, file, arbre, graphe). Savoir crire un algorithme de recherche sur une structure de donnes dune faon rcursive
Pr-requis Algorithmique 1 Les enregistrements Les pointeurs La rcursivit Les listes Les arbres et les graphes
Dure 6 H
Elments de contenu 1. Dfinition 2. Recherche dans une liste chane 3. Recherche dans un arbre binaire Chapitre7 : Les algorithmes rcursifs de recherches
quipe pdagogique Algorithmique2 65
7.1 Dfinition
Un algorithme de recherche est un type d'algorithme qui cherche, parmi une liste de donnes, les lments satisfaisant certains critres. En gnral, le critre de recherche porte sur la valeur d'une cl (ex : chercher un numro de tel dans un ensemble de personnes (une personne=nom + adresse + tel...), rechercher un mot dans un dictionnaire (dictionnaire=mots+dfinitions+photo+...), ...). Cette cl peut aussi tre simplement la valeur de l'objet (recherche d'un entier dans une liste d'entier, ...). Les algorithmes de recherche que nous allons prsenter retournent un lment quelconque ayant une cl de la valeur cherche. Il est parfois plus utile de retourner la place de cet lment dans l'ensemble des donnes (pour par exemple effectuer ensuite une suppression, ...). 7.2 Recherche dans une liste chaine 7.2.1 Recherche squentielle La recherche squentielle est une mthode de recherche qui consiste chercher un lment dans une liste d'lments de mme type. On commence du premier lment de la liste jusqu' ce qu'on trouve l'lment. Si on ne le trouve pas, alors on aura parcouru toute la liste. Si on teste souvent une liste et si ces lments sont rpartis de manire alatoire, le nombre moyen d'lments comparer pour savoir si un lment est dans la liste ou non est de : N/2 o N est le nombre d'lments de la liste. 7.2.2 Recherche par valeur La fonction recherche par valeur retourne un pointeur vers le premier lment trouv dont la valeur est passe en paramtre, ou le pointeur nil si aucun lment n'a t trouv Fonction recherche_valeur (L: Liste, val:entier): Liste Dbut si (L=nil ) alors Retourner (nil) sinon si (L^.valeur = val) alors Retourner(L) sinon Retourner recherche_valeur (L^.suivant,val) finsi finsi Chapitre7 : Les algorithmes rcursifs de recherches
quipe pdagogique Algorithmique2 66 fin 7.2.3 Recherche par position La fonction recherche par position retourne un pointeur vers l'lment ayant la position passe en paramtre. Si la liste contient moins dlments que le paramtre position, le pointeur nil est retourn. Fonction recherche_postion (L: Liste, pos:entier): Liste Dbut si (L=nil ou pos=1) alors Retourner(L) sinon Retourner recherche_position (L^.suivant , pos-1) finsi fin 7.2.4 Recherche dichotomique La dichotomie consiste diviser une liste de donnes en deux sous-listes. La recherche dichotomique consiste dcomposer une liste en deux sous-listes A et B puis dterminer si l'lment recherch se trouve en A ou B. Puis on redcoupe en deux sous-listes C et D, la sous-liste o se trouve l'lment puis on dtermine si l'lment recherch se trouve en C ou D. On rpte l'opration tant qu'on n'a pas trouv l'lment ou que les sous-listes restantes ne soient composes plus que d'un seul lment, puisqu'on n'a pas dcompos une liste d'un seul lment. Dans ce cas, on considre que l'lment n'est pas dans la liste recherche. La mthode par dichotomie est une des mthodes de recherche la plus rapide, le problme essentiel de la recherche dichotomique est la ncessit que les lments de la liste soient tris (croissant ou dcroissant). 7.2.5 Recherche dans une liste ordonne Principe : On regarde l'lment au milieu de la liste : - Sil est gal la valeur cherche, c'est fini - Sil est infrieur la valeur cherche, il ne reste traiter que la moiti droite de la liste - Sil est suprieur la valeur cherche, il ne reste traiter que la moiti gauche de la liste Chapitre7 : Les algorithmes rcursifs de recherches
quipe pdagogique Algorithmique2 67 On continue ainsi la recherche en diminuant chaque fois de moiti le nombre d'lments de la liste restant traiter. Pour raliser la recherche dichotomique dans une liste trie, la fonction Recherche_dicho est implmente, elle prend 4 paramtres : llment x cherche, L : la tte de la liste chane, le dbut et la fin de la sous liste dans la quelle x est cherche. Dans lalgorithme principal, lappel sera comme suit : Recherche_dicho(x, L, 1, longueur (L)) Avec longueur (L) est une fonction qui renvoi la longueur de la liste chane. Fonction Recherche_dicho(x : entier, L : Liste, debut : entier, fin:entier) : Boolen Var Rang, milieu, e : entier Dbut si debut<=fin alors milieu (fin+debut) div 2 e ieme(milieu,L) si (x=e) alors // on a trouve l'element retourner VRAI sinon si (x<e) alors // il est peut tre dans la moiti gauche retourner Recherche_dicho(x, L, debut, milieu-1) sinon // il est peut tre dans la moiti droite retourner Recherche_dicho(x, L, milieu+1, fin) finsi finsi sinon // la liste traiter est vide retourner FAUX finsi fin
Chapitre7 : Les algorithmes rcursifs de recherches
quipe pdagogique Algorithmique2 68 La fonction ieme(milieu, L) est une fonction qui retourne la valeur de la cellule ayant la position milieu de la liste L. Fonction ieme(pos : entier, L : Liste) : entier Var P : Liste i : entier Dbut P L i 1 Tantque (i < pos) faire P P^.suivant i i + 1 fin tantque retourner P^.valeur Fin La fonction longueur (L) est une fonction qui calcule la longueur dune liste chane L. Fonction longueur (L : Liste) : entier Var P : Liste nb : entier //nb est le nombre dlment de la liste Dbut P L nb 0 Tantque (P<>Nil) faire nb nb + 1 P P^.suivant fin tantque Retourner (nb) Fin
Chapitre7 : Les algorithmes rcursifs de recherches
quipe pdagogique Algorithmique2 69
7.3 Recherche dans un arbre binaire
La recherche dans un arbre binaire d'un nud ayant une valeur particulire est un procd rcursif. On commence par examiner la racine. Si sa valeur est la valeur recherche, l'algorithme se termine et renvoie la racine. Si elle est strictement infrieure, alors elle est dans le sous-arbre droit, sur lequel on effectue alors rcursivement la recherche. De mme si la valeur de la racine est strictement suprieure la valeur recherche la recherche continue sur le sous-arbre gauche. Si on atteint une feuille dont la valeur n'est pas celle recherche, on sait alors que la valeur recherche n'appartient aucun nud. On peut la comparer avec la recherche par dichotomie qui procde peu prs de la mme manire. 7.3.1 Parcours en profondeur Le parcours en profondeur est un parcours rcursif sur un arbre. Il existe trois ordres pour cette mthode de parcours. 7.3.1.1 Parcours prfix Dans ce mode de parcours, on traite la racine, puis le sous-arbre gauche, puis le sous-arbre droit.
Ainsi, un parcours prfix pour cet arbre va nous donner comme rsultat : 11- 8 -5 -10 -14 -13 -15 La procdure rcursive de la recherche prfixe est : Procdure prfix ( A : Arbre ) Dbut si (A < > nil) alors Chapitre7 : Les algorithmes rcursifs de recherches
quipe pdagogique Algorithmique2 70 traiter(A) prfix(A^.FilsG) prfix(A^.FilsD) finsi Fin Remarque : - Traiter(A) : est le traitement exercer sur larbre de racine A, ajout, suppression, recherche, affichage, 7.3.1.2 Parcours infix Dans ce mode de parcours, on traite le sous-arbre gauche, puis la racine, puis le sous-arbre droit.
Ainsi un parcours infix pour cet arbre va nous donner comme rsultat : 5 8 10 11 13 14 15 La procdure rcursive de la recherche infixe est : Procdure infix ( A : Arbre ) Dbut si (A < > nil) alors infix(A^.FilsG) traiter(A) infix(A^.FilsD) finsi Fin Chapitre7 : Les algorithmes rcursifs de recherches
quipe pdagogique Algorithmique2 71 7.3.1.3 Parcours postfix Dans ce mode de parcours, on traite le sous-arbre gauche, le sous-arbre droit, puis la racine.
La procdure rcursive de la recherche postfixe est : Procdure postfix (A : Arbre ) Dbut si (A < > nil) alors postfix(A^.FilsG) postfix(A^.FilsD) traiter(A) finsi Fin
7.3.2 Application Recherche rcursive du pre dune valeur dans un sous arbre de racine A : Algorithme pere(x : entier, A : Arbre): Arbre
Var tmp, P : Arbre Dbut si (A=Nil) alors Retourner (Nil) sinon P A Chapitre7 : Les algorithmes rcursifs de recherches
quipe pdagogique Algorithmique2 72 si (P^.valeur=x) alors Retourner (Nil) // cas particulier pere de la racine sinon si (P.FilsG^.valeur=x) ou ( P.FilsD^.valeur=x) alors Retourner (P) sinon tmp pere(x, P^.FilsG) // recherche rcursive dans le SAG si (tmp=Nil) alors // s'il n'est pas gauche, c'est qu'il est droite tmp pere(x, P^.FilsD) finsi Retourner (tmp) finsi finsi finsi Fin 7.3.3 Arbre binaire de recherche Un arbre binaire de recherche (ABR) est un arbre binaire tel que la valeur stocke dans chaque sommet est suprieure celles stockes dans son sous-arbre gauche et infrieur celles de son sous-arbre droit. Exemple :
Algorithme de recherche dans un arbre binaire de recherche: Chapitre7 : Les algorithmes rcursifs de recherches
quipe pdagogique Algorithmique2 73 Algorithme Recherche(e : entier, B : arbre) : boolen // vrifier si e appartient au sous-arbre B (qui peut tre vide) Dbut Si (B=Nil) Alors // l'lment n'est pas dans l'arbre Retourner FAUX Sinon Si (e=B^.valeur) Alors // on l'a trouv Retourner VRAI Sinon Si (e<B^.valeur) Alors // s'il existe, c'est dans le sous-arbre gauche Retourner Recherche(e, B^.FilsG) Sinon // s'il existe, c'est dans le sous-arbre droit Retourner Recherche(e, B^.FilsD) Finsi Finsi Finsi fin
Chapitre 8: Complexit des algorithmes
Vue densemble Ce Chapitre prsente la complexit des algorithmes.
Objectifs Ce chapitre a pour objectifs de permettre aux tudiants dacqurir les connaissances de base se rapportant aux objectifs spcifiques suivants: Etre capable dvaluer un algorithme en calculant sa complexit Savoir calculer la complexit dun algorithme.
Pr-requis Algorithmique 1 Algorithmique 2
Dure 3 H
Elments de contenu 1. Introduction 2. Dfinition 3. Calcule de la complexit 4. Type de la complexit 5. Complexit de quelque algorithme Chapitre8 : Complexit des algorithmes
quipe pdagogique Algorithmique2 74
8.1 Introduction
Un algorithme est une procdure finie et un enchanement des tapes de rsolution dun problme. Un algorithme doit tre appliqu sur toutes les donnes possibles du problme et doit fournir une solution correcte dans chaque cas. En informatique, il est possible de rsoudre un problme donn par implantation dun algorithme conu spcification pour la rsolution. Cependant, pour un problme donn, il peur tre rsolu souvent avec plusieurs algorithmes. Le problme qui se pose alors : Comment choisir entre les algorithmes? Comment dterminer lefficacit dun algorithme par rapport un autre ? De ces questions est ne la complexit des algorithmes. 8.2 Dfinition La mesure de la complexit dun algorithme est une estimation de son temps dexcution ainsi que de lespace mmoire utilis. Ces 2 mesures sont appeles complexit spatiale et temporelle de lalgorithme. - La complexit spatiale exprime la taille occupe par les donnes de lalgorithme dans la mmoire de lordinateur. - La complexit temporelle exprime le temps que prendra lexcution de l'algorithme. La mesure de la complexit permet de dcider si un algorithme est efficace ou non indpendamment de la machine qui va lexcuter et du langage dimplmentation, elle ne dpend que de lalgorithme lui-mme. 8.3 Calcul de la complexit Le temps dexcution dun algorithme est fonction du nombre doprations lmentaires dans cet algorithme. Par exemple, pour le parcourt dun tableau et la recherche dun lment donne, la comparaison entre llment courant du tableau et llment recherch sera prise en compte. La complexit dun algorithme dpend de plusieurs facteurs, tel que la taille des donnes traiter et le type doprations effectuer, par exemple une addition est plus rapide quune multiplication. Il nexiste pas de mthode formelle pour calculer la complexit dun algorithme mais il y a des rgles qui peuvent tre appliques. On note T (Op) : le temps dexcution dune oprations Op, voici les rgles qui peuvent tre appliqu lors du calcul du temps dexcution dun algorithme :
Chapitre8 : Complexit des algorithmes
quipe pdagogique Algorithmique2 75 - Si Op est une instruction lmentaire alors T (Op) est considr comme constant et il est not O(1). - Si Op est une instruction conditionnelle (si condition alors op1 sinon op2) alors T (Op) est estim T (condition) + Max (T (op1) + T (op2)). - Si Op est une boucle (Pour i de 1 N faire Operation) alors T (Op) est estim Somme (T (Operation) ) qui reprsente la somme des temps des oprations de chaque itration. 8.4 Type de complexit Les algorithmes usuels peuvent tre classs en un certain nombre de grandes classes de complexit. Les algorithmes sous-linaires, dont la complexit est en gnral en O(log n). C'est le cas de la recherche d'un lment dans un ensemble ordonn fini de n lments (recherche dun lment dans un tableau de taille n). Les algorithmes linaires en complexit O(n) sont considrs comme rapides, comme l'valuation de la valeur d'une expression compose de n symboles ou les algorithmes de tri de tableaux de n lments. Plus lents sont les algorithmes de complexit situe entre O(n 2 ) et O(n 3 ), c'est le cas de la multiplication des matrices de taille n. Puisque on calcule la complexit temporelle en faisant une approximation, on utilise donc les notations suivantes: O(1) :complexit constante O(log(n)) :complexit logarithmique O(n) : complexit linaire O(n 2 ) : complexit quadratique O(n 3 ) : complexit cubique O(n p ) : complexit polynomiale O(2 n ) : complexit exponentielle
Chapitre8 : Complexit des algorithmes
quipe pdagogique Algorithmique2 76 8.5 Complexit de quelques algorithmes 8.5.1 Recherche du plus petit lment Soit l'exemple suivant: fonction plusPetit (x: Tableau[1..n] de entier) var k,i: entier Debut k0 pour i de 1 n faire
si(x[i] < x[k]) alors k i finsi finpour Retourner (k) Fin Dans cette fonction, on excute n-1 tests de comparaison. La complexit temporelle est donc n-1 elle est not O(n). 8.5.2 Produit de matrice Soit l'exemple suivant: Algorithme Produit_Matrice var u,v, w : Tableau[1..n] de entier i : entier Debut pour i de 1 n faire pour j de 1 n faire w[i,j] u[i,j] * v[i,j] finpour fin pour fin
Chapitre8 : Complexit des algorithmes
quipe pdagogique Algorithmique2 77 La complexit temporelle de cet algorithme est la somme des temps ncessaire pour faire les multiplications sur une ligne de la matrice w savoir n * le temps dune multiplication qui est considr comme constante donc O(n). Ce calcul est rpt pour chaque ligne donc la complexit prcdente doit tre multiplie par n. Finalement on peut en dduire que lalgorithme est de complexit gale O(n 2 ). 8.6 Exercices dapplication
Exercice 1 : Donnez la complexit des programmes suivants (a) pour i = 1 n faire pour j = 1 n faire x + 3
(b) pour i = 1 n faire pour j = 1 i faire x + 3
(c) pour i = 5 n-5 faire pour j = i-5 i+5 faire x + 3
(d) pour i = 1 n faire pour j = 1 n faire pour k = 1 n faire 4 x x+a
(f) pour i = 1 n faire pour j = 1 i faire pour k = 1 j faire x x+a
Exercice 2 : Soit lalgorithme suivant: Fonction Partition (var T : tableau [1..N] de entier, deb, fin : entier) : entier Var i, j, v, p: entier Debut i deb-1 j fin p T[fin] Repeter Repeter i i+1 Jusqu' ( T[i] p ) Chapitre8 : Complexit des algorithmes
quipe pdagogique Algorithmique2 78 Repeter j j-1 Jusqu' ( T[j] p ) Si ( i< j) Alors v T[i] T[i] T[j] T[j] v FinSi Jusqu' ( i j ) T[fin] T[i] T[i] p Retourner (i) Fin Procedure Tri_Rapide (var T : tableau[1..N] de entier, deb, fin :entier) Var Pos : entier Debut Si (deb < fin) Alors Pos Partition (T,deb,fin) Tri_Rapide (T,deb,pos-1) Tri_Rapide (T,pos+1,fin) FinSi Fin
Dterminer la complexit de la procdure Tri_Rapide 8.7 Solutions des exercices Exercice 1 : a- O(N) b- O (N 2 ) c- O (N 2 ) d- O (N 3 ) f- O (N 3 ) Exercice 2 : O (log(n))
DS et examen
Bibliographie
Livres [1]: Amina Bouraoui baccar, Algorithmique avance et structures de donnes cours et applications. [2]: Warin Bruno, Lalgorithmique votre passeport informatique pour la programmation, Ellipses, 2002 [3]: ROHAUT, Algorithmique et Techniques fondamentale de programmation, Edition Eni 2007 [3]: LIGNELET P., Algorithmique. Mthodes et modles, Paris : Masson, 1985 Sites Web