rappel sur les variables statiques ce qui a été vu? variables de type simple (entier, réels,...

Rappel sur les variables statiquesRappel sur les variables statiques

Ce qui a été vu?Ce qui a été vu?• variables de type simple (entier, réels, caractère, etc.)variables de type simple (entier, réels, caractère, etc.)• variables de type tableau(array), enregistrement (record) variables de type tableau(array), enregistrement (record)

Exemple :Exemple :var c :var c : char;char;var tab :var tab : array[1..20] of integer;array[1..20] of integer;var étudiant :var étudiant : recordrecord

nom, prénom :nom, prénom : string[20];string[20];dateNaiss :dateNaiss : recordrecord

jour, mois, année :jour, mois, année : integer;integer;

end;end;end;end;

Rappel sur les variables statiquesRappel sur les variables statiques

Que se passe t’il lorsqu’on déclare ?Que se passe t’il lorsqu’on déclare ?var N: var N: integerinteger

• un certain espace, désigné par son adresse dans la mémoire est un certain espace, désigné par son adresse dans la mémoire est associé à la variable associé à la variable NN

• association faite par le compilateur (avant l’exécution du association faite par le compilateur (avant l’exécution du programme)programme)

• les occurrences de les occurrences de NN dans le programme sont remplacées par dans le programme sont remplacées par l’adresse de la variablel’adresse de la variable

• à l’exécution toutes ces adresses sont fixéesà l’exécution toutes ces adresses sont fixées

allocation statiqueallocation statique

Variables dynamiquesVariables dynamiques

C’est quoi?C’est quoi?

« « C’est une variable pouvant être allouée pendant C’est une variable pouvant être allouée pendant

l’exécution, au moment où il y en a besoin! sous le l’exécution, au moment où il y en a besoin! sous le

contrôle du programme au moyen d’instructions contrôle du programme au moyen d’instructions

spéciales.spéciales. » »

On parle alors d’On parle alors d’allocation dynamiqueallocation dynamique (contrôlée), (contrôlée),

… … pointeurspointeurs

Les pointeursLes pointeurs

IntroductionIntroduction

Lille

Lens

Paris

Marseille

Toulouse

Nice

30 km220 km

210 km

650 km

200 km

800 km

200 km

La notion de pointeur permet la construction de structures de données :

Caen

200 km

700 km

chaînées (les objets sont chaînées entre eux)

dynamique (dont la forme et la taille peuvent évoluer en cours d’exécution)

Variables de type pointeurVariables de type pointeur

DéfinitionDéfinition : une variable de type pointeur est une : une variable de type pointeur est une variable dont la valeur est l’adresse d’une autre variable dont la valeur est l’adresse d’une autre variable.variable.

a

p p^ 2000010000

Adresse Case mémoire

a200000

p

p^Variable pointeur(variable statique)

Variable pointée par p(variable dynamique)

Variables de type pointeursVariables de type pointeurs

La mise en place d’une variable dynamique La mise en place d’une variable dynamique se déroule en trois étapes :se déroule en trois étapes :

1. 1. Déclaration de la variable pointeurDéclaration de la variable pointeur

2. 2. Initialisation de la variable pointeur et/ou Initialisation de la variable pointeur et/ou allocation de la variable dynamique (pointée)allocation de la variable dynamique (pointée)

3. 3. Utilisation de la variable dynamiqueUtilisation de la variable dynamique


1. Déclaration : 1. Déclaration : PseudoPseudo (Pascal): (Pascal): var p :var p : ^̂ typeObjet; typeObjet;

pp est une variable statique de type pointeur vers un est une variable statique de type pointeur vers un objet de type objet de type typeObjettypeObjet

pp^̂ désigne la variable désigne la variable dynamique de type dynamique de type

« « typeObjettypeObjet » dont l’adresse est rangée dans » dont l’adresse est rangée dans pp

PseudoPseudo PascalPascal SchémaSchéma

var pi : var pi : ^̂entierentier var pi: var pi: ^̂integer;integer;

« « pipi est une variable de type pointeur vers un entier est une variable de type pointeur vers un entier » »

?pi


2.2. Initialisation et/ou allocation :Initialisation et/ou allocation :a)a) initialisation de la variable pointeur et allocation de la variable initialisation de la variable pointeur et allocation de la variable dynamique (pointée) :dynamique (pointée) :

- Pseudo :- Pseudo : allouer (p) allouer (p)

- Pascal :- Pascal : new(p); new(p);

«réservation d’une zone mémoire correspondant à une «réservation d’une zone mémoire correspondant à une variable de type ‘typeObjet’ et enregistre dans p l’adresse variable de type ‘typeObjet’ et enregistre dans p l’adresse de cette zone.»de cette zone.»

PseudoPseudo PascalPascal SchémaSchémavar pi : var pi : ^̂entierentier var pi : var pi : ^̂integer;integer;allouer (pi)allouer (pi) new(pi);new(pi);

pi pi^


b) initialisation de la variable pointeur par l ’adresse b) initialisation de la variable pointeur par l ’adresse d’une autre variable :d’une autre variable :

- - PseudoPseudo : : p := adresse (variable) p := adresse (variable)- - PascalPascal : : p := @variable; p := @variable;

Pseudo Pseudo PascalPascal SchémaSchémavar pi : var pi : ^̂entierentier var pi : var pi : ^̂integerinteger;;

e : entiere : entier e : integer; e : integer;

pi := adresse(e)pi := adresse(e) pi := pi := @@ e; e;

pi pi^

e


3.3. Utilisation de la variable dynamiqueUtilisation de la variable dynamique

Exemple:Exemple:Pseudo Pseudo PascalPascal SchémaSchéma

var pi : var pi : ^̂entierentier var pi: var pi: ^̂integer;integer;

pi = allouer(entier)pi = allouer(entier) new(pi);new(pi);

pipi^̂ := 8 := 8 pi pi ^̂ := 8; := 8;

?pi pi^

?pi

8pi pi^


Libérer la variable dynamique (pointée)Libérer la variable dynamique (pointée)« rendre disponible l’espace mémoire occupé « rendre disponible l’espace mémoire occupé

par la variable dynamique créé par new »par la variable dynamique créé par new »Exemple:Exemple:Pseudo Pseudo PascalPascal SchémaSchémavar pi : var pi : ^̂entierentier var pi: var pi: ^̂integer;integer;

allouer(pi)allouer(pi) new(pi);new(pi);

libérer(pi)libérer(pi) dispose(pi);dispose(pi);

?pi pi^

?pi

pi pi^


Opérations courantes sur les pointeursOpérations courantes sur les pointeurs- affectation, comparaison- affectation, comparaison

addition et soustraction (dépend du langage)!!addition et soustraction (dépend du langage)!!

Constante Constante Le type pointeur admet une seule constante prédéfinie Le type pointeur admet une seule constante prédéfinie nilnil en Pascal et en Pascal et NULLNULL en C et C++ en C et C++

« p:=nil; signifie que« p:=nil; signifie que p pointe vers rien »p pointe vers rien »

PseudoPseudo PascalPascal SchémaSchémavar p: êntiervar p: êntier var p: înteger;var p: înteger;p:=nilp:=nil p := nil;p := nil; p

RésuméRésumé

type pchaine = ^ string var p, q : pchaineInstructions Effets

new( p)

p^ := ‘Luc’

new( q)q^:= ‘Marc’

p̂ := q̂

p:= q

dispose(p)

?p p^

Lucp p^

?q q^

Marcq q^

Marcp p^

Marcq q^

Marcp p^

Marcq q^

Marcp p^

Marcq q^

inaccessible

Listes chaînéesListes chaînées

une une cellulecellule est composée : est composée :• d’un d’un élémentélément de la suite de la suite• d’un d’un lienlien vers la cellule suivante (pointeur) vers la cellule suivante (pointeur)

une une liste chaînéeliste chaînée est composé d’un ensemble est composé d’un ensemble de cellulede cellule

listeliste contient l’adresse de la première cellule; qui à contient l’adresse de la première cellule; qui à

son tour contient l’adresse de la cellule suivante, ...son tour contient l’adresse de la cellule suivante, ...

Liste chaînée

cellule

a b c d

liste

Listes chaînées : représentationListes chaînées : représentation

Définition récursive d’une listeDéfinition récursive d’une liste

PascalPascal

où où typeElementtypeElement est un type simple (entier, caractère, ...), est un type simple (entier, caractère, ...),

ou composé (tableau, structure, …)ou composé (tableau, structure, …)

Type Liste = ^cellule;cellule = record

info : typeElement;suivant : Liste;

end;

var a : Liste

Listes chaînées : manipulationListes chaînées : manipulation

Accès aux champs d’une celluleAccès aux champs d’une cellule

PascalPascal SchémaSchéma

var a : Liste…new(a);

a^.infoa^.suivant

?a

a


Création d’une listeCréation d’une liste

ExempleExemple: création d’une liste : création d’une liste aa représentant représentant ((x,yx,y))var a, p: Liste;var a, p: Liste;1.1. Création d’une liste videCréation d’une liste vide

a :=nil;a :=nil; 2.2. Création de la liste a contenantCréation de la liste a contenant ((yy))

new(p);new(p);

p^.info := ‘ y’;p^.info := ‘ y’;

p^.suivant := a;p^.suivant := a;

a := p;a := p;

a

p

yp

yp

yp

a

?p?a


3.3. Création de la liste Création de la liste aa contenant contenant ((x, y x, y )) : :new(p);new(p);

p^.info := x;p^.info := x;

p^.suivant := a;p^.suivant := a;

a := p;a := p;

on obtient :on obtient :

p

xp

ya

xp

ya

xp

xa y

Listes chaînées : opérations courantesListes chaînées : opérations courantes

1.1. Initialiser une liste à videInitialiser une liste à videprocedure initListe( var a:Liste)procedure initListe( var a:Liste)

begin begin

a:=nil;a:=nil;

end;end;

2.2. Tester si une liste est videTester si une liste est videfonction listeVide( a:Liste ):booleanfonction listeVide( a:Liste ):boolean

beginbegin

listeVide:= (a=nil);listeVide:= (a=nil);

end;end;

Listes chaînées : opérations courantesListes chaînées : opérations courantes

33.. Insertion en tête de la listeInsertion en tête de la listeprocedure insertête(elem :typeElement, var a:Liste)procedure insertête(elem :typeElement, var a:Liste)var p:Liste;var p:Liste;beginbegin new(p);new(p);

p^.info := elem;p^.info := elem;p^.suivant := a;p^.suivant := a;a :=p;a :=p;

end;end;4.4. Suppression en tête de la listeSuppression en tête de la listeprocedure supptête( var a:Liste)procedure supptête( var a:Liste)var p:Liste;var p:Liste;

if (a<>nil) if (a<>nil) then beginthen begin p := a; a := a^.suivant; dispose(p);p := a; a := a^.suivant; dispose(p);end;end;

end;end;

insertêteinsertête et et supptêtesupptête• sont très important sont très important (utilisées souvents)!!!(utilisées souvents)!!!• cas particuliers cas particuliers (modification de la(modification de la tête de la liste)tête de la liste)

Listes chaînées : manipulation Listes chaînées : manipulation

ApplicationApplication : : passage d ’une représentation vecteur à passage d ’une représentation vecteur à une représentation liste chaînéeune représentation liste chaînée..

Const Max = 100;Const Max = 100;Type vecteur = array[1..Max] of typeElement; Type vecteur = array[1..Max] of typeElement;

procedure vecteurListe( v:vecteur, nb:integer, var a:Liste)procedure vecteurListe( v:vecteur, nb:integer, var a:Liste)beginbegin

a:=nil;a:=nil;for i:=1 to nb do for i:=1 to nb do

insertete(v[i], a);insertete(v[i], a);end;end;


Parcours d’une liste chaînéeParcours d’une liste chaînéeDéfinition récursive d’une listeDéfinition récursive d’une liste

Une Une liste chaînéeliste chaînée est : est : Soit une liste Soit une liste videvide

Soit composé d’Soit composé d’une celluleune cellule (la première) (la première)

chaînée à chaînée à une listeune liste

Remarque :Remarque :Définition très importante, à la base de Définition très importante, à la base de tous les algorithmes récursifs sur les listestous les algorithmes récursifs sur les listes

a

a

cellule liste chaînée


Premier parcoursPremier parcours

1.1. On traite la cellule courante (première)On traite la cellule courante (première)

2.2. On effectue le parcours de la sous-listeOn effectue le parcours de la sous-listeprocedure parcours1(a:Liste)procedure parcours1(a:Liste)begin begin

if (a<>nil) if (a<>nil) then beginthen begin

traiter(a^.info);traiter(a^.info);parcours1(a^.suivant);parcours1(a^.suivant);

end;end;end;end;

ExempleExemple

Soit la liste Soit la liste a = (1, 2, 3, 4),a = (1, 2, 3, 4), en remplaçant traiter par afficher, en remplaçant traiter par afficher,parcours1 parcours1 affiche les éléments de affiche les éléments de aa dans l’ordre dans l’ordre


Second parcoursSecond parcours1.1. On effectue le parcours de la sous-listeOn effectue le parcours de la sous-liste 2.2. On traite la cellule courante (première)On traite la cellule courante (première)

procedure parcours2(a:Liste)procedure parcours2(a:Liste)begin begin

if (a<>nil)if (a<>nil)then beginthen begin

parcours2(a^.suivant);parcours2(a^.suivant);traiter(a^.info);traiter(a^.info);

end;end;end;end;

ExempleExemple Soit la liste Soit la liste a = (1, 2, 3, 4),a = (1, 2, 3, 4), en remplaçant traiter par afficher, en remplaçant traiter par afficher,parcours2 parcours2 affiche les éléments de affiche les éléments de aa dans l’ordre inverse dans l’ordre inverse


Version itérativeVersion itérativeprocedure parcours(a:Liste)procedure parcours(a:Liste) var p:Liste;var p:Liste;beginbegin

p:= a;p:= a;while(p<>nil) while(p<>nil) do begindo begintraiter(p^.info);traiter(p^.info);p:= p^.suivant;p:= p^.suivant; end;end;

end;end;

Le paramètre a est passé par valeurLe paramètre a est passé par valeur

procedure parcours(a:Liste)procedure parcours(a:Liste)beginbeginwhile(a<>nil) do beginwhile(a<>nil) do begintraiter(a^.info);traiter(a^.info);a:= a^.suivant;a:= a^.suivant;end;end;end;end;


ExerciceExerciceSoit a = (1, 2, 3), qu’affiche la procédure suivante?Soit a = (1, 2, 3), qu’affiche la procédure suivante?

procedure P(a:Liste)procedure P(a:Liste)begin begin

if (a<>nil)if (a<>nil)then beginthen begin

write(a^.info);write(a^.info);P(a^.suivant);P(a^.suivant);write(a^.info); write(a^.info);

end;end;end;end;

Résultats : 1 2 3 3 2 1


ExerciceExercice Soit a = (1, 2, 3), qu’affiche la procédure Soit a = (1, 2, 3), qu’affiche la procéduresuivante?suivante?

procedure P(a: Liste)procedure P(a: Liste)begin begin

if (a<>nil) then beginif (a<>nil) then beginP(a^.suivant);P(a^.suivant);write(a^.info); write(a^.info); P(a^.suivant);P(a^.suivant);

end;end;end;end;

Résultats : 3 2 3 1 3 2 3

Listes chaînées particulièresListes chaînées particulières

Les pilesLes piles

Exemple Exemple : pile d’assiettes, pile d’exécution, … : pile d’assiettes, pile d’exécution, …

UtilisationUtilisation : sauvegarder temporairement des : sauvegarder temporairement des informations en respectant leur ordre d’arrivée,informations en respectant leur ordre d’arrivée,et les réutiliser en ordre inverseet les réutiliser en ordre inverse

Principe de fonctionnementPrincipe de fonctionnement : :

- Dernier arrivé, premier servi - Dernier arrivé, premier servi (en Anglais « (en Anglais « LLast ast IIn n FFirst irst OOut »ut »

- ajout et retrait au sommet de la pile- ajout et retrait au sommet de la pile


Les pilesLes pilesSchéma : Schéma :

sommet

Pile (tableaux)

éléments

éléments

sommet

Pile (liste)

sommet

sommet

empiler

sommet

sommet

sommetsommet

dépiler

sommet

sommet

empiler

empilerempiler


Les filesLes files

Exemple Exemple : file d’attente, file d’impression, … : file d’attente, file d’impression, …

UtilisationUtilisation : sauvegarder temporairement des : sauvegarder temporairement des informations en respectant leur ordre d’arrivée, informations en respectant leur ordre d’arrivée, et les réutiliser en ordre d’arrivéeet les réutiliser en ordre d’arrivée

Principe de fonctionnementPrincipe de fonctionnement : :

- Premier arrivé, premier servi - Premier arrivé, premier servi

(en Anglais « (en Anglais « FFirst irst IIn n FFirst irst OOut »)ut »)

- ajout en queue et retrait en tête de la file- ajout en queue et retrait en tête de la file


Les filesLes files Schéma Schéma

tête

File (tableaux)

éléments

queue

éléments

File (liste)

tête queue

Piles et files TD

enfiler

queuequeue

enfilerdéfiler

têtetête

Listes chaînées : quelques algorithmes Listes chaînées : quelques algorithmes

Calcul du nombre d’occurrences d’un élément dans une listeCalcul du nombre d’occurrences d’un élément dans une liste

Version itérativeVersion itérative

function nbOcc(val :typeElement, a:Liste):integerfunction nbOcc(val :typeElement, a:Liste):integer var nb :integer;var nb :integer;beginbegin

nb:=0;nb:=0;while (a<>nil) do beginwhile (a<>nil) do begin

if (a^.info =val) then nb:=nb+1;if (a^.info =val) then nb:=nb+1;a := a^.suivant;a := a^.suivant;

end;end;nbOcc:=nb;nbOcc:=nb;

end;end;


Calcul du nombre d’occurrences d’un élément dans une listeCalcul du nombre d’occurrences d’un élément dans une liste

Version récursive Version récursive

function nbOcc(val typeElement, a:Liste):integerfunction nbOcc(val typeElement, a:Liste):integerbegin begin

if (a=nil) if (a=nil) then nbOcc:= 0then nbOcc:= 0else if (a^.info =val)else if (a^.info =val)

then nbOcc:=1 + nbOcc(val, a^.suivant);then nbOcc:=1 + nbOcc(val, a^.suivant); else nbOcc:=nbOcc(val, a^.suivant);else nbOcc:=nbOcc(val, a^.suivant);

end;end;


Algorithmes d’accèsAlgorithmes d’accès

a) accès par positiona) accès par position algorithme d’accès au kème élément : algorithme d’accès au kème élément :

donnéesdonnées : : kk : entier : entieraa : Liste : Listerésultatsrésultats : :pointkpointk : Liste : Liste

SpécificationsSpécifications : retourne l’adresse de la kème cellule : retourne l’adresse de la kème cellulesi elle existe; nil sinon.si elle existe; nil sinon.

a pointkk=3

Listes chaînées : Listes chaînées : Accès par positionAccès par position

Version itérativeVersion itérativefunction accesK(k:integer, a:Liste ):Listefunction accesK(k:integer, a:Liste ):Listevar i:integer:var i:integer:begin begin

i := 1; i := 1; while(i<k and a<> nil) beginwhile(i<k and a<> nil) begin

a := a^.suivant;a := a^.suivant;i:=i+1;i:=i+1;

end;end;acceK:=a;acceK:=a;

end;end; Version récursiveVersion récursive

function accesK(k:integer, a:Liste ): Listefunction accesK(k:integer, a:Liste ): Listebegin begin

if (a=nil) then accesK:= nilif (a=nil) then accesK:= nilelse if (k=1) then accesL:= aelse if (k=1) then accesL:= a

else accesK:= accesK(k-1, a^.suivant);else accesK:= accesK(k-1, a^.suivant);end;end;


Algorithmes d’accèsAlgorithmes d’accèsb) accès par valeurb) accès par valeur algorithme d’accès à la première occurrence d’unealgorithme d’accès à la première occurrence d’unevaleur donnée : valeur donnée :

donnéesdonnées : : valval : typeElement : typeElementaa : Liste : Listerésultatsrésultats : :pointkpointk : Liste : ListeSpécificationsSpécifications : retourne l’adresse de la cellule : retourne l’adresse de la cellule contenant la première occurrence de val; nil si valcontenant la première occurrence de val; nil si val a a

8 3 5 9

a pointkval=5

Listes chaînées : Listes chaînées : Accès par valeurAccès par valeur

Version itérativeVersion itérativefunction accesV(val:typeElement, a: Liste):Listefunction accesV(val:typeElement, a: Liste):Listevar var trouve :boolean;trouve :boolean;beginbegin

trouve := false;trouve := false;while(not trouve and a<>nil) beginwhile(not trouve and a<>nil) begin

trouve := (val =a^.info);trouve := (val =a^.info);if (not trouve) then a := a^.suivant;if (not trouve) then a := a^.suivant;

end;end;accesV:=a;accesV:=a;

end;end; Version récursiveVersion récursive

function accesV(val:typeElement, a:Liste):Listefunction accesV(val:typeElement, a:Liste):Listebegin begin

if (a=nil) then acceV:= nil;if (a=nil) then acceV:= nil;else if (val=a^.info) then acceV:=aelse if (val=a^.info) then acceV:=a

else accesV:= accesV(val, a^.suivant);else accesV:= accesV(val, a^.suivant);end;end;


Algorithmes d’insertionAlgorithmes d’insertiona) insertion en fin de listea) insertion en fin de liste algorithme d’insertion d’une valeur donnée en finalgorithme d’insertion d’une valeur donnée en finde listede liste

donnéesdonnées : : valval : typeElement : typeElementaa : Liste : Listerésultatsrésultats : :aa : Liste : ListeSpécificationsSpécifications : insertion d’une valeur donnée : insertion d’une valeur donnée valval en fin de liste en fin de liste aa

8 3 5 9

a dernierval=7 p

7

Listes chaînées : Listes chaînées : insertion en fin de listeinsertion en fin de liste

Version itérativeVersion itérativefunction dernier(a:Liste):Liste;function dernier(a:Liste):Liste;beginbegin if(a<>nil) then if(a<>nil) then

while(a^.suivant<>nil) dowhile(a^.suivant<>nil) doa := a^.suivant;a := a^.suivant;

dernier:=a;dernier:=a;end;end;

Version récursiveVersion récursivefunction dernier(a:Liste):Liste;function dernier(a:Liste):Liste;begin begin

if (a=nil) then dernier:=nilif (a=nil) then dernier:=nilelse if (a^.suivant=nil) then dernier:=aelse if (a^.suivant=nil) then dernier:=a

else dernier:= dernier(a^.suivant);else dernier:= dernier(a^.suivant);end;end;

Calcul de l ’adresse du dernier

Listes chaînées : Listes chaînées : insertion en fin de listeinsertion en fin de liste

Ajout en fin de listeAjout en fin de liste

procedure inserFin(val :typeElement , var a:Liste);procedure inserFin(val :typeElement , var a:Liste);var der:Liste;var der:Liste;beginbegin

der := dernier(a);der := dernier(a);if(der=nil) then insertete(val, a)if(der=nil) then insertete(val, a)else insertete(val, der^.suivant);else insertete(val, der^.suivant);

end;end;

Version récursive (sans utilisation de dernier)Version récursive (sans utilisation de dernier)procedure inserFin(val:typeElement, var a:Liste)procedure inserFin(val:typeElement, var a:Liste)begin begin

if (a=nil) then insertete(val, a) if (a=nil) then insertete(val, a) else inserFin(val, a^.suivant);else inserFin(val, a^.suivant);

end;end;


Algorithmes d’insertionAlgorithmes d’insertionb) insertion à la kème placeb) insertion à la kème place algorithme d’insertion d’une valeur à la kème placealgorithme d’insertion d’une valeur à la kème place

donnéesdonnées : : valval : typeElement : typeElementkk : entier : entieraa : Liste : Listerésultatsrésultats : :aa : Liste : ListeSpécificationsSpécifications : insertion d’une valeur donnée : insertion d’une valeur donnée valval à la à la kkème place de la liste ème place de la liste a a (si possible)(si possible)

5 98 3

a (k-1)val=7

p

7

(k)

3

preck=3

Listes chaînées : Listes chaînées : insertion à la kème placeinsertion à la kème place

Version itérativeVersion itérativeprocedure inserK(val:typeElement , k:integer, var a:Liste);procedure inserK(val:typeElement , k:integer, var a:Liste);var var prec:Liste;prec:Liste;

if (k=1) then insertete(val, a)if (k=1) then insertete(val, a)else else begin begin

prec := accesK(k-1,a);prec := accesK(k-1,a); if(prec<>nil) then if(prec<>nil) then

insertete(val, prec^.suivant)insertete(val, prec^.suivant)else writeln(‘ insertion impossible ’);else writeln(‘ insertion impossible ’);

end;end;end;end;

Version récursiveVersion récursiveprocedure inserK(val:typeElement, k:integer, var a:Liste);procedure inserK(val:typeElement, k:integer, var a:Liste);beginbegin

if (k=1) then insertete(val, a)if (k=1) then insertete(val, a)else if (a=nil) then writeln(‘ insertion impossible ’)else if (a=nil) then writeln(‘ insertion impossible ’)else inserK(val, k-1, a^.suivant);else inserK(val, k-1, a^.suivant);

end;end;


Algorithmes de suppressionAlgorithmes de suppressionb) Suppression du kème élémentb) Suppression du kème élément algorithme de suppression du kème élémentsalgorithme de suppression du kème éléments

donnéesdonnées : : kk : entier : entieraa : Liste : Listerésultatsrésultats : :aa : Liste : ListeSpécificationsSpécifications : suppression du kème élément de la : suppression du kème élément de la liste; si possible.liste; si possible.

8 3 5

a (k)k= 4

3

p

9 2

prec

p

9

Listes chaînées : Listes chaînées : suppression du kème élémentsuppression du kème élément

Version itérativeVersion itérativeprocedure suppK(k:integer, var a:Liste)procedure suppK(k:integer, var a:Liste)var var prec:Liste;prec:Liste;

if (k=1) then supptete(a);if (k=1) then supptete(a);else else beginbegin

prec := accesK(k-1,a);prec := accesK(k-1,a); if(prec<>nil) thenif(prec<>nil) then

supptete(prec^.suivant)supptete(prec^.suivant)else writeln(‘ suppression impossible ’);else writeln(‘ suppression impossible ’);

end;end;end;end;

Version récursiveVersion récursiveprocedure suppK(k:integer, var a:Liste)procedure suppK(k:integer, var a:Liste)begin begin if (k=1) then supptete(a)if (k=1) then supptete(a)

else if (a=nil) then writeln(‘ suppression impossible ’)else if (a=nil) then writeln(‘ suppression impossible ’)else suppK(k-1, a^.suivant);else suppK(k-1, a^.suivant);

end;end;


Algorithmes de suppressionAlgorithmes de suppressionb) Suppression de la première occurrence d ’uneb) Suppression de la première occurrence d ’une

valeur donnéevaleur donnée

donnéesdonnées : : valval : entier : entieraa : Liste : Listerésultatsrésultats : :aa : Liste : ListeSpécificationsSpécifications : suppression de la première occurrence : suppression de la première occurrenced’une valeur donnée.d’une valeur donnée.

8 3 5

aval= 9

9

p

9 2

prec

p

9

Listes chaînées : Listes chaînées : suppression 1ère occurrencesuppression 1ère occurrence

Version itérativeVersion itérativeprocedure suppV(val : typeElement, var a:Liste);procedure suppV(val : typeElement, var a:Liste);var prec,p : Liste;var prec,p : Liste;

trouve: boolean; trouve: boolean; beginbegin

trouve := false; p:= a; prec:=nil;trouve := false; p:= a; prec:=nil;while (not trouve and p<>nil) dowhile (not trouve and p<>nil) dobeginbegin trouve := (val=p^.info);trouve := (val=p^.info);

if (not trouve) then beginif (not trouve) then beginprec := p; p:=p^.suivant;prec := p; p:=p^.suivant;

end;end;endendif (trouve) thenif (trouve) then

if (prec=nil) then supptete(a)if (prec=nil) then supptete(a)else supptete(prec^.suivant)else supptete(prec^.suivant)

else writeln(‘ suppression impossible ’);else writeln(‘ suppression impossible ’);end;end;

Listes chaînées : Listes chaînées : suppression 1ère occurrencesuppression 1ère occurrence

Version récursiveVersion récursiveprocedure suppV(val:typeElement, var a:Liste);procedure suppV(val:typeElement, var a:Liste);beginbegin

if (a=nil) thenif (a=nil) thenwriteln(‘ suppression impossible ’)writeln(‘ suppression impossible ’)

else if (val=a^.info) then supptete(val, a)else if (val=a^.info) then supptete(val, a)else suppV(val, a^.suivant);else suppV(val, a^.suivant);

end;end;

Listes chaînées particulières Listes chaînées particulières

Listes chaînées bidirectionnellesListes chaînées bidirectionnellesSchémaSchéma

ReprésentationReprésentationtype ListeBi = ^cellule type ListeBi = ^cellule

cellule = recordcellule = record infoinfo : typeElement; : typeElement; precedent, suivant :precedent, suivant : ListeBi ListeBi

end;end;

8

a

259 7

Listes chaînées particulières Listes chaînées particulières

Listes chaînées bidirectionnellesListes chaînées bidirectionnellesUtilisationUtilisationLes listes chaînées bidirectionnelles sont utiliséesLes listes chaînées bidirectionnelles sont utiliséesuniquement dans le cas où on a besoin d ’effectueruniquement dans le cas où on a besoin d ’effectuersouvent des retour arrière.souvent des retour arrière.

ExercicesExercicesEn considérant une liste chaînée bidirectionnelle, En considérant une liste chaînée bidirectionnelle, réécrire les différents algorithmes vu en Cours réécrire les différents algorithmes vu en Cours

Listes chaînées bidirectionnelles Listes chaînées bidirectionnelles

Insertion en tête d’une liste bidirectionnelleInsertion en tête d’une liste bidirectionnelle

a

839 5

p

a2elem

2

a

new(p);p^.info := elem;p^.precedant := nil;

p^.suivant := a;if (a<>nil) then a^.precedant := p;a:=p;

end;

procedure insertête(elem :typeElement, var a: ListeBi)var p:ListeBi;begin

Listes chaînées bidirectionnelles Listes chaînées bidirectionnelles

Suppression en tête d’une liste bidirectionnelleSuppression en tête d’une liste bidirectionnelle

procedure supptête( var a:ListeBi)var p:Liste;begin if (a<>nil) then begin

83 59

pa a

9

ap

a

p := a; a := a^.suivant;

dispose(p); if (a<>nil) then a^.precedant := nil;end;

end;

Listes chaînées circulairesListes chaînées circulaires

SchémaSchéma

Représentation Représentation

même type que pour les listes chaînéesmême type que pour les listes chaînées

ExerciceExercice : écrire un procédure affichant les: écrire un procédure affichant les

élément d’une liste chaînée circulaireélément d’une liste chaînée circulaire

a b c d

liste

Listes chaînées circulairesListes chaînées circulaires

Version récursiveVersion récursive

procedure afficher(a:Liste )procedure afficher(a:Liste )begin begin

if ( ) thenif ( ) then

beginbegin write( a^.info ) ;write( a^.info ) ;

afficher(a^.suivant );afficher(a^.suivant );end;end;

end;end;

a b c d

a

A<>nil

, p: Liste // à l ’appel p = a

, pif (a^.suivant<>p) then

Listes chaînées / tableauxListes chaînées / tableaux

Liste chaînéeListe chaînée : :• avantagesavantages : :

– la taille peut évoluer (limite : espace mémoire)la taille peut évoluer (limite : espace mémoire)– mise à jour plus efficace : ne nécessite aucune mise à jour plus efficace : ne nécessite aucune

recopierecopie• inconvénientsinconvénients : :

– plus encombranteplus encombrante– accès à un élément : plus longaccès à un élément : plus long

TableauTableau : :• avantagesavantages : :

– accès plus rapideaccès plus rapide– moins encombrantesmoins encombrantes

• inconvénientsinconvénients : :– plus rigide (limité par la taille spécifiée au départ) plus rigide (limité par la taille spécifiée au départ) – mise à jour plus coûteusemise à jour plus coûteuse

Listes chaînée / tableauxListes chaînée / tableaux

1)1) représentation chaînée (listes)représentation chaînée (listes)::

mises à jour > consultationsmises à jour > consultations

2)2) représentation contiguë (tableaux)représentation contiguë (tableaux) : :

consultations > mises à jourconsultations > mises à jour

En pratiqueEn pratique : :

On utilise très souvent des structures mixtesOn utilise très souvent des structures mixtescomposées de listes chaînées et de tableauxcomposées de listes chaînées et de tableaux

Polynôme?Polynôme?

Type Type monomemonome = record = record

exp:integer;exp:integer;

coeff:real;coeff:real;

end;end;

ListeMonoListeMono = ^cellule = ^cellule

cellulecellule = record= record

m: monome;m: monome;

monoSuivant:ListeMono;monoSuivant:ListeMono;

end;end;

polynomepolynome = record = record

nbMono:integer;nbMono:integer;

poly : ListeMono;poly : ListeMono;

end;end;

polypolyProcedure Procedure lireMonolireMono(var m:monome);(var m:monome);beginbegin repeatrepeat

write(‘ exp? ’);readln(m.exp);write(‘ exp? ’);readln(m.exp);write(‘ coeff? ’); readln(m.coeff);write(‘ coeff? ’); readln(m.coeff);

until m.coeff<>0;until m.coeff<>0;end;end;

Procedure Procedure lirePolylirePoly(var p:polynome);(var p:polynome);var m:monome;var m:monome;

i :integer;i :integer;beginbegin

write(‘ nb Mnome? ’); readln(p.nbMono);write(‘ nb Mnome? ’); readln(p.nbMono);p.poly:=nil;p.poly:=nil;writeln(‘ entrez les monomes <ordre croissant>? ’);writeln(‘ entrez les monomes <ordre croissant>? ’);for i:=1 to p.nbMono do beginfor i:=1 to p.nbMono do begin

lireMono(m);lireMono(m);inserTete(p.poly, m);inserTete(p.poly, m);

end;end;end;end;

Procedure Procedure inserTeteinserTete(var l:listeMono;(var l:listeMono;

m;monome);m;monome);

var p:listeMono;var p:listeMono;

beginbegin

new(p);new(p);

p^.m:=m;p^.m:=m;

p^.monoSuivant:=l;p^.monoSuivant:=l;

l:=p;l:=p;

end;end;

polypolyProcedure Procedure ecrireMonoecrireMono(var m:monome);(var m:monome);beginbegin

if(m.coeff>0) thenif(m.coeff>0) thenwrite(‘ + ’, m.coeff, ‘ ^ ’, m.exp )write(‘ + ’, m.coeff, ‘ ^ ’, m.exp )

else write(‘ - ’, abs(m.coeff), ‘ ^ ’, m.exp )else write(‘ - ’, abs(m.coeff), ‘ ^ ’, m.exp )end;end;

Procedure Procedure afficherMonomesafficherMonomes(monos:ListeMono);(monos:ListeMono);beginbegin if (monos<>nil) then beginif (monos<>nil) then begin

ecrireMonome (monos^.m);ecrireMonome (monos^.m);afficherMonomes(monos^.monoSuivant);afficherMonomes(monos^.monoSuivant);

end;end; writeln;writeln;end;end;

Procedure Procedure afficherPolynomeafficherPolynome(p:polynome);(p:polynome);beginbegin

afficherMonomes(p.poly);afficherMonomes(p.poly);end;end;

polypolyProcedure Procedure addPolynomesaddPolynomes(p1:polynome; p2:polynome; var p3:polynome);(p1:polynome; p2:polynome; var p3:polynome);var m:monome;var m:monome;beginbegin

p3.poly:=nil;p3.poly:=nil;while(p1.poly<>nil and p2.poly<>nil) do beginwhile(p1.poly<>nil and p2.poly<>nil) do begin if(p1.poly^.m.exp=p2.poly^.m.exp) then beginif(p1.poly^.m.exp=p2.poly^.m.exp) then begin

m.coeff:= p1.poly^.m.coeff + p2.poly^.m.coeff;m.coeff:= p1.poly^.m.coeff + p2.poly^.m.coeff;if(m.coeff<>0) then beginif(m.coeff<>0) then begin

m.exp:=p1.poly^.m.exp;m.exp:=p1.poly^.m.exp; inserTete(p3.poly, m);inserTete(p3.poly, m);end;end;

end else beginend else beginif (p1.poly^.m.exp<p2.poly^.m.exp) beginif (p1.poly^.m.exp<p2.poly^.m.exp) begin m.coeff:=p1.poly^.m.coeff; m.exp:=p1.poly^.m.exp;m.coeff:=p1.poly^.m.coeff; m.exp:=p1.poly^.m.exp; inserTete(p.poly, m)inserTete(p.poly, m)end else beginend else begin

m.coeff:=p2.poly^.m.coeff; m.exp:=p2.poly^.m.exp;m.coeff:=p2.poly^.m.coeff; m.exp:=p2.poly^.m.exp;inserTete(p.poly, m)inserTete(p.poly, m)end;end;

end;end;end;end;

polypoly

while(p1.poly<>nil) do beginwhile(p1.poly<>nil) do begin

m.coeff:=p1.poly^.m.coeff; m.exp:=p1.poly^.m.exp; m.coeff:=p1.poly^.m.coeff; m.exp:=p1.poly^.m.exp;

inserTete(p3.poly, m);inserTete(p3.poly, m);

end;end;

while(p2.poly<>nil) do beginwhile(p2.poly<>nil) do begin

m.coeff:=p2.poly^.m.coeff; m.exp:=p2.poly^.m.exp; m.coeff:=p2.poly^.m.coeff; m.exp:=p2.poly^.m.exp;

inserTete(p3.poly, m);inserTete(p3.poly, m);

end;end;

end;end;

ArbresArbres

Arbre ?Arbre ?

Arbre ordinaire : A = (N,P)

- N ensemble des nœuds

- P relation binaire « parent de »

- r N la racine

x N un seul chemin de r vers x

r = yo P y1 P y2 . . . P yn = x

r n’a pas de parent x N - { r } x a exactement un parent

1

2 3 4

5 6 7 8

9 10

ArbresArbres

ExemplesExemplestables des matièrestables des matières

1. Introduction 1. Introduction

2. Pointeurs2. Pointeurs

3. Listes3. Listes3.1. Pile3.1. Pile

3.2. Files3.2. Files

4. Arbres4. Arbres4.1. Arbres binaires4.1. Arbres binaires

4.2 Arbres n-aires4.2 Arbres n-aires

4.3. Forêts 4.3. Forêts

5. Tables5. Tables

Arbres (Exemples suite)Arbres (Exemples suite)

organisation des fichiersorganisation des fichiers dans des systèmes dans des systèmes d’exploitation tels que Unixd’exploitation tels que Unix

expression arithmétiqueexpression arithmétique

a b . .

c + a b

a b

+ +

( a + b) / ( c . (a + b ) + (a . b) )


Arbre généalogiqueArbre généalogique

HerveHerve Georgette Georgette AndreAndre NicoleNicole

BernardBernard CatherineCatherine

PatrickPatrick


Phrases d’une langue naturellePhrases d’une langue naturelle

DictionnaireDictionnaire

beau

hiera

Il fait

* *

couart

* i

cle ste

* r vent

* *

TerminologieTerminologie

1

3 4

10

2

9

5 6 7 8

racineracine

nœud internenœud interne

niveau 2niveau 2

nœud externe(feuille)nœud externe(feuille)branchebranche

hauteurhauteur

3

2, 3, 4 enfants de 12, 3, 4 enfants de 13, 4 frères de 23, 4 frères de 222 fils de 1 fils de 11 père de 2, 3 et 41 père de 2, 3 et 41, 3 ancêtres de 71, 3 ancêtres de 7

9, 10 descendants de 79, 10 descendants de 7

67

Arbre A = Arbre A = arbre vide ouarbre vide ou (r, {A (r, {A11, ..., A, ..., Akk} )} )

A ou

r

A 1

Définitions récursivesDéfinitions récursives

A k A 2

. . .

r élément, r élément, AA11, ..., , ..., AAk k arbres arbres

Nœuds (Nœuds (AA) = {) = { rr } } ( ( Nœuds ( Nœuds (AAi i ) )) )

Taille (A) = | Nœuds(A)|Taille (A) = | Nœuds(A)|

Condition analogue

Quelques définitions

Une autre définition récursiveUne autre définition récursiveun arbre est :un arbre est :

• soit videsoit vide• soit constitué d’un nœud soit constitué d’un nœud auquel sont chaînées un ou plusieurs sous arbresauquel sont chaînées un ou plusieurs sous arbres

A arbre x nœud de A A arbre x nœud de A

niveauniveauAA(x) = distance de x à la racine(x) = distance de x à la racine

niveauniveauAA(x) = (x) = 0 si x = racine(A)0 si x = racine(A)

1 + niveau (parent (x) ) sinon1 + niveau (parent (x) ) sinon

Niveaux

1

3 4

10

2

9

5 6 7 8

0

1

2

3



hhAA(x) = distance de x à son plus lointain descendant(x) = distance de x à son plus lointain descendant

qui est un nœud externequi est un nœud externe

hhAA(x) =(x) = 0 0 si A est vide si A est vide

1 + max { h1 + max { hAA(e) | e enfant de x } sinon(e) | e enfant de x } sinon

h(A) = hh(A) = hAA(racine(A))(racine(A))

Hauteurs

1

3 4

10

2

9

5 6 7 8

hA (8) = 1 hA (7) = 2 hA (3) = 3

h(A) = hA (1) = 4



ArbreArbreAA(x) = sous-arbre de A qui a racine x(x) = sous-arbre de A qui a racine x

Sous-arbres

1

3 4

10

2

9

5 6 7 8ArbreA (2)ArbreA (7)ArbreA (8)


Quelques définitions Quelques définitions

• lorsqu ’un arbre admet, pour chaque nœud, lorsqu ’un arbre admet, pour chaque nœud, au plus n au plus n filsfils, l’arbre est dit , l’arbre est dit n-airen-aire

• si si n est égale 2n est égale 2, l’arbre est dit , l’arbre est dit binairebinaire

RemarqueRemarque : un arbre n-aire peut être : un arbre n-aire peut être représenté par un arbre binaire équivalentreprésenté par un arbre binaire équivalent

Arbre binaire et arbre n-aireArbre binaire et arbre n-aire

72

Arbre binaireArbre binaire A = A = arbre vide arbre vide ou ou

(r, (r, G, D ))

A ou

r

G

Arbre binaire : définitions récursivesArbre binaire : définitions récursives

D. . .

r élément, r élément,

G, D sous-arbres gauche et droite sous-arbres gauche et droite

Condition analogue


Une autre définition récursiveUne autre définition récursiveun un arbre binairearbre binaire est : est :

• soit videsoit vide• soit constitué d’un nœud auquel sont chaînéessoit constitué d’un nœud auquel sont chaînées un sous arbre gauche et un sous arbre droitun sous arbre gauche et un sous arbre droit

Arbre binaireArbre binaire

Représentation interneReprésentation interne

type Arbre = ^nœud;type Arbre = ^nœud;

nœud = record nœud = record

infoinfo : typeElement; : typeElement;

fgfg, , fdfd : Arbre; : Arbre;

end;end;

Gauche Droit

info

fdfg nœud

Arbre binaire (exemple)Arbre binaire (exemple)

A

+

5

24

-

3

*3 * ( (4 - 2) + 5)

Parcours d’un arbre binaireParcours d’un arbre binaire

Pré-ordre (préfixé, Pré-ordre (préfixé, RRGD)GD)• racineracine • sous-arbre gauchesous-arbre gauche• sous-arbre droitsous-arbre droit

Sur l’exemple :Sur l’exemple :

A

+

5

24

-

3

*

G

GG

G

GG

G

R

R

R

R

R

R

R

D

D

D

D

DD

D* 3 + - 4 2 5


In-ordre (infixé, GIn-ordre (infixé, GRRD)D)• sous-arbre gauchesous-arbre gauche• racineracine• sous-arbre droitsous-arbre droit


A

+

5

24

-

3

*

G

GG

G

GG

G

R

R

R

R

R

R

R

D

D

D

D

DD

D3 * 4 - 2 + 5


Post-ordre (postfixé, GDPost-ordre (postfixé, GDRR))• sous-arbre gauchesous-arbre gauche• sous-arbre droitsous-arbre droit• racineracine


A

+

5

24

-

3

*

G

GG

G

GG

G

R

R

R

R

R

R

R

D

D

D

D

D D

D3 *4 -2 +5

Algorithmes Algorithmes

procedure préfixe(a: Arbre );procedure préfixe(a: Arbre );beginbegin

if (a<>nil) then beginif (a<>nil) then begintraiter(a)traiter(a) ; ;préfixé(a^.fg);préfixé(a^.fg);préfixé(a^.fd);préfixé(a^.fd);

end;end;end;end;

procedure infixe(a: Arbre );procedure infixe(a: Arbre );beginbegin

if (a<>nil) then beginif (a<>nil) then begininfixé(a^.fg);infixé(a^.fg);traiter(a)traiter(a) ; ;infixé(a^.fd);infixé(a^.fd);

end;end;end;end;

procedure postfixe(a: Arbre );procedure postfixe(a: Arbre );beginbegin

if (a<>nil) then beginif (a<>nil) then beginpostfixé(a^.fg);postfixé(a^.fg);postfixé(a^.fd);postfixé(a^.fd); traiter(a)traiter(a) ; ;

end;end;end;end;

AlgorithmesAlgorithmes

Calculer la taille d’un arbre binaireCalculer la taille d’un arbre binaire

Taille (A) = 0 Taille (A) = 0 si A = si A = arbre vide arbre vide 1 + Taille(G)+ Taille(D)1 + Taille(G)+ Taille(D) si A=(si A=(rr,G, D),G, D)

function taille(a: Arbre):integer;begin

if (a=nil) then taille:= 0else taille:= 1+ taille(a^.fg) + taille(a^.fd);

end;


Calculer le nombre de feuilles d’arbre binaireCalculer le nombre de feuilles d’arbre binaire

nbFeuilles (A) = 0 nbFeuilles (A) = 0 si A = si A = arbre vide arbre vide 1 1 si A est une feuillesi A est une feuille

nbFeuille(G)+ nbFeuille(D)nbFeuille(G)+ nbFeuille(D) si A=(si A=(rr,G, D),G, D)

function nbFeuilles(a: Arbre): integer;

begin

if (a=nil) then nbFeuilles := 0

else if (a^.fg= nil and a^.fd=nil) then nbFeuilles:= 1

else nbFeuilles:= nbFeuilles(a^.fg) + nbFeuilles(a^.fd);

end;


Appartient (A, x) = vrai ssi x est étiquette d’un noeud de A

Appartient (A, x) =

faux si A vide vrai si x = yAppartient (G(A), x) ou Appartient (D(A), x); sinon

y

G D

Appartient ?Rechercher un élémentRechercher un élément


function appartient(a:Arbre, val: typeElement)

begin

if (a=nil)

then appartient:=faux

else if (a^.info =val)

then appartient:= true

else appartient:= appartient(a->fg, val) or

appartient(a->fd, val);

end;

Quelques définitionsQuelques définitions

• chaque nœud autre qu’une feuille admet deux descendants chaque nœud autre qu’une feuille admet deux descendants

• toutes les feuilles se trouve au même niveautoutes les feuilles se trouve au même niveau

Arbre binaire completArbre binaire complet


le facteur d’équilibre de chaque sous arbre est associé à sa le facteur d’équilibre de chaque sous arbre est associé à sa racine racine

le facteur d’équilibre d ’un nœud le facteur d’équilibre d ’un nœud

est égal à la hauteur du sous-arbre gauche est égal à la hauteur du sous-arbre gauche

moins la hauteur du sous-arbre droitmoins la hauteur du sous-arbre droit

Facteur d’équilibre d ’un arbre binaireFacteur d’équilibre d ’un arbre binaire

1

1

0

1

0

2

0

1

0

1

0

5

-2

4

2

2

1

3

-11

0

La hauteurLa hauteur

Facteur d’équilibreFacteur d’équilibre


pour tout nœud de l’arbre la valeur absolue du pour tout nœud de l’arbre la valeur absolue du

facteur d ’équilibre est inférieur ou égale à 1facteur d ’équilibre est inférieur ou égale à 1

arbre binaire équilibréarbre binaire équilibré

1

2

0

1

0

1

01

0

4

-1

3

1

1

0

2

01

0

La hauteurLa hauteur

Facteur d’équilibreFacteur d’équilibre

Arbre binaire équilibréArbre binaire équilibré


un arbre binaire est dit dégénéré, si tous les nœuds un arbre binaire est dit dégénéré, si tous les nœuds

de cet arbre ont au plus 1 fils. de cet arbre ont au plus 1 fils.

Arbre binaire dégénéréArbre binaire dégénéré


Soit A un arbre binairenœuds étiquetés par des élémentsA est un arbre binaire ordonnée (de recherche) :

ssi en tout noeud p de A Elt(G(p)) Elt(p) < Elt(D(p))

ssi A Arbre_vide ou

A = (r, G, D) avec

. G, D arbres binaires de recherche et

. Elt(G) Elt (r) < Elt(D)

Arbre binaire de ordonnée (de recherche)Arbre binaire de ordonnée (de recherche)

Arbre binaire de rechercheArbre binaire de recherche

ExempleExemple

1

2

3

4

5

6

1 2 3 4 5 6


Appartient (A, x) = vrai ssi x est étiquette d’un noeud de A

Appartient (A, x) = faux si A vide

vrai si x = yAppartient (G(A), x) si x < y

Appartient (D(A), x) si x > y

y

G D

Appartient ?



function appartient(a:Arbre, val:typeElement);function appartient(a:Arbre, val:typeElement);beginbegin

if (a=nil) if (a=nil) then appartient:= fauxthen appartient:= fauxelse if (a^.info = val) else if (a^.info = val)

then appartient:= truethen appartient:= trueelse if (val < a^.info)else if (val < a^.info) then appartient:= appartient(a^.fg, val)then appartient:= appartient(a^.fg, val) else appartient:= appartient(a^.fd, val);else appartient:= appartient(a^.fd, val);

end;end;



function appartient(a:Arbre, val:typeElement);function appartient(a:Arbre, val:typeElement);var trouve:boolean;var trouve:boolean;

beginbegintrouve:= false;trouve:= false;while (a<>nil and not(trouve)) dowhile (a<>nil and not(trouve)) dobeginbegin

trouve := (a^.info = val); trouve := (a^.info = val); if (val < a^.info)if (val < a^.info)

then a := a^.fg then a := a^.fg else a := a^.fd;else a := a^.fd;

end;end;appartient:= trouve;appartient:= trouve;

end;end;


Ajout d’une valeur donnéeAjout d’une valeur donnée

A

26

3518

3

8

2312

Val = 10

p

10


Version itérativeVersion itérativeprocedure ajout (var a:ARbre, val:integer);procedure ajout (var a:ARbre, val:integer);var p , pere:Arbre;var p , pere:Arbre;beginbegin

p:=a; pere:=nil;p:=a; pere:=nil;while (p<>nil) do beginwhile (p<>nil) do beginpere := p;pere := p;if (val <= p^.info)if (val <= p^.info)then p := p^.fgthen p := p^.fgelse p := p^.fd;else p := p^.fd;end;end;new(p); p^.info:= val; p^.fg :=nil; p^.fd :=nil;new(p); p^.info:= val; p^.fg :=nil; p^.fd :=nil;if (pere =nil) then a := pif (pere =nil) then a := pelse if (val <=pere^.info)then pere^.fg := pelse if (val <=pere^.info)then pere^.fg := pelse pere^.fd := p;else pere^.fd := p;

end;end;



procedure ajout (var a:Arbre, val:integer);procedure ajout (var a:Arbre, val:integer);if (a =nil) then beginif (a =nil) then begin

new(a);new(a);a^.info := val;a^.info := val;a^.fg := nil;a^.fd := nil;a^.fg := nil;a^.fd := nil;

endend else if (val <= a^.info) thenelse if (val <= a^.info) then

ajout (a^.fg, val)ajout (a^.fg, val)else ajout (a^.fd, val);else ajout (a^.fd, val);

end;end;


suppression d’une valeur donnéesuppression d’une valeur donnée

Val = 5 10

8

6 9

3

1 4

p

pere

p^.fgp^.fd

3

1 4

3

1 4

55



procedure suppression (var a:Arbre, val:integer);procedure suppression (var a:Arbre, val:integer);beginbeginif (a <>nil) if (a <>nil)

if( a^.info=val) thenif( a^.info=val) then suppNoeud (a)suppNoeud (a)else if (val < a^.info) thenelse if (val < a^.info) then suppression (a^.fg, val)suppression (a^.fg, val) else suppression(a^.fd, val);else suppression(a^.fd, val);

end;end;

Arbre binaire de rechercheArbre binaire de rechercheprocedure suppNoeud (var a:Arbre)procedure suppNoeud (var a:Arbre)var p,q:Arbre;var p,q:Arbre;beginbegin

p := a;p := a;if (a^.fd <>nil) if (a^.fd <>nil) thenthenbeginbegin

q := p^.fd;q := p^.fd;while(q^.fg<nil) then q := q^.fg;while(q^.fg<nil) then q := q^.fg;

q^.fg := p^.fg;q^.fg := p^.fg;a := a^.fd;a := a^.fd;

end end else a := a^.fg;else a := a^.fg;dispose(p);dispose(p);

end;end;


Dupliquer un arbreDupliquer un arbre

8

7

53

2

9 10

1 15

12

8

7

53

2

9 10

1 15

12


Dupliquer un arbre Dupliquer un arbre

procedure dupliquer (a1:Arbre, var a2:Arbre);procedure dupliquer (a1:Arbre, var a2:Arbre);

beginbegin

if (a1 <>nil)if (a1 <>nil)

then beginthen begin

new(a2);new(a2);

a2^.info := a1^.info;a2^.info := a1^.info;

dupliquer(a1^.fg, a2^.fg);dupliquer(a1^.fg, a2^.fg);

dupliquer(a1^.fd, a2^.fd) );dupliquer(a1^.fd, a2^.fd) );

endend

else a2 := nil;else a2 := nil;

end;end;


Une autre versionUne autre version

function dupliquer (a1:Arbre ): Arbrefunction dupliquer (a1:Arbre ): Arbre

var a2: Arbre;var a2: Arbre;

beginbegin

if (a1 <>nil)if (a1 <>nil)


new(a2);new(a2);

a2^.info := val;a2^.info := val;

a2^.fg := dupliquer(a1^.fg);a2^.fg := dupliquer(a1^.fg);

a2^.fd := dupliquer(a1^.fd);a2^.fd := dupliquer(a1^.fd);

dupliquer:=a2;dupliquer:=a2;

endend

else dupliquer:=nil;else dupliquer:=nil;

end;end;


Tester la similarité de deux arbres binairesTester la similarité de deux arbres binaires

8

7

53

2

9 10

1 15

12

9

1

54

3

6 8

7 30

253

similaire

ne sont pas similaire


Arbres similaireArbres similaire

function similaire (a1, a2 : Arbre ):boolean;function similaire (a1, a2 : Arbre ):boolean;

beginbegin

if (a1 <>nil and a2 <>nil)if (a1 <>nil and a2 <>nil)

then similaire:= similaire (a1^.fg, a2^.fg) and similaire (a1^.fd, a2^.fd)then similaire:= similaire (a1^.fg, a2^.fg) and similaire (a1^.fd, a2^.fd)

else if ( (a1=nil and a2<>nil) or (a1<>nil and a2=nil) )else if ( (a1=nil and a2<>nil) or (a1<>nil and a2=nil) )

then similaire:= falsethen similaire:= false

else similaire:= true;else similaire:= true;

end;end;

ExercicesExercices

Calculer la hauteur d ’un arbre binaireCalculer la hauteur d ’un arbre binaire

Tester si un arbre binaire est dégénéréTester si un arbre binaire est dégénéré

Calculer le nombre d ’occurrences d ’une valeur Calculer le nombre d ’occurrences d ’une valeur donnéedonnée

......

Arbre n-aireArbre n-aire

lorsqu ’un arbre admet, pour chaque nœud, lorsqu ’un arbre admet, pour chaque nœud, au plus n au plus n filsfils, l’arbre est dit , l’arbre est dit n-airen-aire

A

C DB

E F G

Arbre 3-aire (arbre ternaire)


ReprésentationReprésentation

• première solutionpremière solution : :

on définit un nœud comme une structures à plusieurs champs : on définit un nœud comme une structures à plusieurs champs :

info, fils1, fils2, …, filsn info, fils1, fils2, …, filsn

irréaliste (cas où il y a de nombreux fils absentsirréaliste (cas où il y a de nombreux fils absents

• Deuxième solutionDeuxième solution : :

Se ramener aux arbres binaires avec trois informations : info, Se ramener aux arbres binaires avec trois informations : info,

successeur (ou fils ainé) et alternant (frère)successeur (ou fils ainé) et alternant (frère)

Solution préférée en généralSolution préférée en général


De l’exemple suivant :De l’exemple suivant :

On obtient : On obtient :

A

C DB

E F G

A

C DB

E F G

suc

suc suc

alt alt

alt


Représentation interneReprésentation interne

type Arbre = ^ nœud;type Arbre = ^ nœud;

nœud = record nœud = record

infoinfo : typeElement; : typeElement;

sucsuc, , alt : alt : Arbre;Arbre;

end; end;

OU

nœud = record

info : typeElement;fils, frere : Arbre;

end;

Forêt Forêt

Définition :Définition : on appelle une on appelle une forêtforêt un ensemble d’arbres n- un ensemble d’arbres n-airesaires

Exemple :Exemple :

A

C DB

E F G

H

J K LI

M N O

Forêt Forêt

Représentation Représentation

on se ramène aux arbres n-aires en créant une racine on se ramène aux arbres n-aires en créant une racine

virtuelle permettant « d’ enraciner » tous les arbresvirtuelle permettant « d’ enraciner » tous les arbres

n-aires de la forêt.n-aires de la forêt.

Pour l’exemple précédent, on obtient :Pour l’exemple précédent, on obtient :

A

C DB

E F G

H

J K LI

M N O

Forêt Forêt

Algorithmes traitant des forêts Algorithmes traitant des forêts Comme pour les arbres binaires, on peut définir des Comme pour les arbres binaires, on peut définir des parcours infixés, préfixés ou postfixés sur la parcours infixés, préfixés ou postfixés sur la représentation équivalentes de la forêt, etc.représentation équivalentes de la forêt, etc.

Application :Application :Gestion d’un dictionnaire arborescentGestion d’un dictionnaire arborescentTrès utilisée pour manipuler de gros dico en minimisant Très utilisée pour manipuler de gros dico en minimisant la place occupée.la place occupée.Exemple : Exemple : ARTART BAL BAL COUCOUARTICLEARTICLE BARBAR COURCOURARTISTEARTISTE BARBEBARBE COULEURCOULEUR

Forêt Forêt

* * *

A B C

R A O

T L R U

* I * * B R * R L

C S E E * E

L T * * U

E E R

alt

suc

InformationsInformations

Cours : dernière séance - mardi 6 janvierCours : dernière séance - mardi 6 janvier

TD : TD : • G 2G 2 : Vendredi 9 , 15h - 16h15 (Salle E06), Rattrapage : Vendredi 9 , 15h - 16h15 (Salle E06), Rattrapage• pas TD la semaine du 12 janvier pas TD la semaine du 12 janvier

TP : semaine du 12 janvier :TP : semaine du 12 janvier :• 30 mn pour rendre votre TP30 mn pour rendre votre TP• 1H30 Contrôle TP1H30 Contrôle TP

Consignes pour la remise du projet LabyConsignes pour la remise du projet Laby

Listing du programme:

Pour chaque procédure ou fonction, on veut trouver au moins les informations suivantes sous l’entête :

Entrées : quelles sont-elles, quelles sont leurs propriétés ...

Sorties : quelles sont-elles, quelles sont leurs propriétés ...

Spécification : Une description (en utilisant par exemple le langage naturel) de ce que la fonction est sensé réaliser.

etc.

Consignes pour la remise du projet LabyConsignes pour la remise du projet Laby

Il faut éviter la programmation par effet de bord.

Pour l’écriture du code source, il faut également tenir compte des conseils suivants :

– Commentaires (pertinents) dans le listing

– dans les déclarations (à quoi sert une variable)

– dans le code : présentation d’un sous-traitement ...

– Sur l’écriture du code (quelques règles)

– garder une même unité de présentation

– noms évocateurs pour les identificateurs

– une procédure ou une fonction ne doit pas excéder une page

– ne pas oublier l’indentation

Exemple de barème : TP1Exemple de barème : TP1

Programme source :Programme source :• commentairescommentaires• types et variables (structures de données)types et variables (structures de données)• indentationindentation• procédure et fonctions procédure et fonctions • algorithmiquealgorithmique

ExécutionExécution• InterfaceInterface• correctes? correctes?

Le TP 1 est annuléLe TP 1 est annulé

Correction du contrôleCorrection du contrôle

Exercice 1: Exercice 1:

Soit le type liste simplement chaînée codant une suite d’entiers .Soit le type liste simplement chaînée codant une suite d’entiers .

Qu’affiche la procédure suivante pour une liste codant la suite (1,2,3)?Qu’affiche la procédure suivante pour une liste codant la suite (1,2,3)?

procedure afficher ( a: Liste )procedure afficher ( a: Liste )

beginbegin

if (a <>nil)if (a <>nil)


afficher (a^.suivant) ;afficher (a^.suivant) ;

write(a^.info);write(a^.info);

afficher (a^.suivant) ;afficher (a^.suivant) ;

endend

else writeln;else writeln;

end;end;


afficher ( afficher ( (1, 2, 3)(1, 2, 3) ) ) ? ?

• afficher( (3) )

• cout << 2 << “ ”“ ”

• afficher( (3) )

• cout << 1 << “ ”“ ”

• afficher( (2, 3) )

• afficher( (2, 3) )

• afficher( () )

• write( 3 )

• afficher( () )

•writeln

• cout << “\n”“\n”

• afficher( () )

• cout << 3 << “ ”“ ”

• afficher( () )

• cout << “\n”“\n”

• cout << “\n”“\n”

• afficher( (3) )

• cout << 2 << “ ”“ ”

• afficher( (3) )

...

...


Affichage : Affichage :

33

22

33

11

33

22

33


Exercice 2 :Exercice 2 :• Définir une liste chaînée codant une suite d’entiersDéfinir une liste chaînée codant une suite d’entiers

Type Liste = ^cellulecellule = record

info:integer;suivant: Liste;

end;


Ecrire les procédures ou fonctions suivantes :Ecrire les procédures ou fonctions suivantes :

• Vérification qu’une liste est triée par ordre croissant.Vérification qu’une liste est triée par ordre croissant.

function estTrié(a:Liste):boolean;begin if (a=nil) then estTrié:= true else if (a^.suivant =nil)

then estTrié:= true else if(a^.info <= a^.suivant^.info)

then estTrié:= estTrié(a^.suivant) else estTrié:= false;end;

if (a=nil or a^.suivant =nil) then estTrié:= true;

Version récursive



function estTrié(a:Liste):boolean;var trié:boolean; begin if (a=nil or a^.suivant =nil ) then estTrié:= true else begin trié := true;

while (a^.suivant<>nil and trié) dobegin trié := (a^.info<=a^.suivant^.info); a := a^.suivant;end;estTrié:= trié;

end;end;



procédure insererListeTriee(x: integer; var a:Liste);var p:Liste; trouve : boolean; begin p:=a; prec:=nil; while (a<>nil and x>p^.info) do begin prec:=p; p := p^.suivant; end; if (prec=nil) then insertete(x, a) else insertete(x,prec^.suivant);end;


Compter le nombre d’entiers compris dans un intervalle donné [binf, bsup] Compter le nombre d’entiers compris dans un intervalle donné [binf, bsup] (version récursive et itérative)(version récursive et itérative)

function compter(a:Liste, binf, bsup:integer):integer;begin if (a=nil) then compter:= 0 else if (a^.info >= binf and a^.info <= bsup) then compter:= 1 + compter (a^.suivant, binf,bsup) else compter:= compter (a^.suivant, binf,bsup) ;end;

Version récursive


Compter le nombre d’entiers compris dans un intervalle donné [binf, bsup] Compter le nombre d’entiers compris dans un intervalle donné [binf, bsup] (version récursive et itérative)(version récursive et itérative)

function compter(a :Liste, binf, bsup:integer):integer;var nb:integer; nb =0; while(a<>nil) do begin

if (a^.info >= binf and a^.info <= bsup)then nb:=nb+1;

a := a^.suivant; end; compter:= nb;end;

Version itérative


Suppression de la dernière occurrence d’une valeur donnée Suppression de la dernière occurrence d’une valeur donnée dans une liste.dans une liste.

Version itérativeVersion itérativeprocedure suppDerOcc(var a: Liste, val:integer)var p, prec, precDer: Liste begin p :=a, prec :=nil, precDer :=nil;

while(p<>nil) do begin

if (p^.info =val) then precDer := prec; prec := p; p := p^.suivant; end;

if (precDer<>nil) then supptete(precDer^.suivant) else if (a<>nil and a^.info =val) then supptete(a);end;


Suppression de la dernière occurrence d’une valeur donnée Suppression de la dernière occurrence d’une valeur donnée dans une liste.dans une liste.


procedure suppDerOcc(var a:Liste, val:integer, var fait:boolean)begin if (a<>nil) then begin

suppDerOcc(a^.suivant, val, fait); if (not(fait) and a^.info =val) then begin

supptete(a);fait := true;

end; end;end; Appel : fait = false


Ajouter un élément avant la première occurrence d’une valeur Ajouter un élément avant la première occurrence d’une valeur donnéedonnée

version récursiveversion récursive

procedure ajoutAvOcc(var a:Liste, val, occ:integer)begin if (a<>nil) then if (a^.info =occ)

then insertete(a, val)else ajoutAvOcc(a^.suivant, val,occ);

end;


Ajouter un élément avant la première occurrence d’une valeur Ajouter un élément avant la première occurrence d’une valeur donnéedonnée

version itérativeversion itérativeprocedure ajoutAvOcc(var a:Liste, val, occ:integer)var p,prec: Liste; trouve:boolean;begin p := a; prec := nil; trouve := false; while(p<>nil and not trouve)do begin

trouve := (p^.info =occ);if (not trouve) then begin prec := p; p:=p^.suivant;end;

end; if (trouve) then if (prec =nil) then insertete(a, val) else insertete(prec^.suivant, val);end;

TP de synthèseTP de synthèse

ObjectifsObjectifs

Synthèse des différentes parties du cours de Synthèse des différentes parties du cours de structures de données : chaînes de caractères, structures de données : chaînes de caractères, fichiers, listes et arbres.fichiers, listes et arbres.

Réalisation et présentation d’un dossier d’analyse.Réalisation et présentation d’un dossier d’analyse.

Présentation d’un dossier de programmationPrésentation d’un dossier de programmation


Sujet du TPSujet du TPIl s’agit d’écrire un programme qui étant donnée un fichier texte (par Il s’agit d’écrire un programme qui étant donnée un fichier texte (par

exemple un programme C++) l’affiche en numérotant les lignes. Puis exemple un programme C++) l’affiche en numérotant les lignes. Puis

affiche la liste de ses identificateurs, classée par ordre alphabétique, affiche la liste de ses identificateurs, classée par ordre alphabétique,

chaque identificateur étant suivi de la liste des numéros de lignes où il chaque identificateur étant suivi de la liste des numéros de lignes où il

apparaît.apparaît.

La syntaxe d’un identificateur est la suivante :La syntaxe d’un identificateur est la suivante :

<identificateur> := <lettre>{<lettre> | <chiffre> | ‘_’ }<identificateur> := <lettre>{<lettre> | <chiffre> | ‘_’ }

<lettre>:= ‘a’ | ‘b’ | ... <lettre>:= ‘a’ | ‘b’ | ... | ‘z’ | ‘A’ | ‘B’ | ... | ‘z’ | ‘A’ | ‘B’ | ... | ‘Z’| ‘Z’

<chiffre>:= ‘0’ | ‘1’ | ... | ‘9’<chiffre>:= ‘0’ | ‘1’ | ... | ‘9’


Sujet du TPSujet du TPLes identificateurs seront rangés dès leur rencontre dans un arbre binaire. Les identificateurs seront rangés dès leur rencontre dans un arbre binaire. Cet arbre devra être construit de telle sorte que, pour tout nœud portant un Cet arbre devra être construit de telle sorte que, pour tout nœud portant un identificateur <id>, tous les nœuds se trouvant dans le sous-arbre gauche identificateur <id>, tous les nœuds se trouvant dans le sous-arbre gauche portent des identificateurs situés avant <id> dans l’ordre alphabétique; de portent des identificateurs situés avant <id> dans l’ordre alphabétique; de même tous les nœuds se trouvant dans le sous-arbre droit portent des même tous les nœuds se trouvant dans le sous-arbre droit portent des identificateurs situés après <id>. A chacun des identificateurs sera associé identificateurs situés après <id>. A chacun des identificateurs sera associé la liste des numéros de lignes où ils sont apparus.la liste des numéros de lignes où ils sont apparus.

La liste des numéros de lignes où chaque identificateur apparaît sera donc La liste des numéros de lignes où chaque identificateur apparaît sera donc traité aussi au moyen de pointeurs. Pour gagner du temps, chaque nouvelle traité aussi au moyen de pointeurs. Pour gagner du temps, chaque nouvelle apparition pourra être insérée en tête de liste; il ne faudra pas oublier alors apparition pourra être insérée en tête de liste; il ne faudra pas oublier alors à l’impression que les références se trouvent en ordre inverse.à l’impression que les références se trouvent en ordre inverse.

Le langage de programmation à utiliser est le C++ (sous Linux). Le fichier Le langage de programmation à utiliser est le C++ (sous Linux). Le fichier source est à mettre dans le répertoire source est à mettre dans le répertoire PROJETSDPROJETSD avant le vendredi 25 avant le vendredi 25 mai 2001.mai 2001.

ExempleExemple

Soit un fichier texte contenant les lignes suivantes :Soit un fichier texte contenant les lignes suivantes :

Definition recursive d'une liste:Definition recursive d'une liste:

une liste est:une liste est:

- soit une liste videsoit une liste vide

- soit compose d'un element, suivi d'une liste- soit compose d'un element, suivi d'une liste

Definition recursive d'un arbre binaire:Definition recursive d'un arbre binaire:

un arbre binaire est :un arbre binaire est :

- soit vide - soit vide

- soit compose d'un noeud, du sous_arbre gauche et du - soit compose d'un noeud, du sous_arbre gauche et du sous_arbre droitsous_arbre droit

ExempleExemple

Première partie : Numerotation du fichierPremière partie : Numerotation du fichier

1 : Definition recursive d'une liste:1 : Definition recursive d'une liste:

2 : 2 :

3 : une liste est:3 : une liste est:

4 : - soit une liste vide4 : - soit une liste vide

5 : - soit compose d'un element, suivi d'une liste5 : - soit compose d'un element, suivi d'une liste

6 : 6 :

7 : Definition recursive d'un arbre binaire:7 : Definition recursive d'un arbre binaire:

8 : 8 :

9 : un arbre binaire est :9 : un arbre binaire est :

10 : - soit vide 10 : - soit vide

11 : - soit compose d'un noeud, du sous_arbre gauche 11 : - soit compose d'un noeud, du sous_arbre gauche

et du sous_arbre droitet du sous_arbre droit

12 : 12 :

ExempleExemple

Seconde partie : Traitement des identificateursSeconde partie : Traitement des identificateurs

DefinitionDefinition : 1 7 : 1 7 arbrearbre : 7 9 : 7 9

binairebinaire : 7 9 : 7 9 composecompose : 5 11 : 5 11

dd : 1 5 5 7 11 : 1 5 5 7 11 droitdroit : 11 : 11

dudu : 11 11 : 11 11 elementelement : 5 : 5

estest : 3 9 : 3 9 etet : 11 : 11

gauchegauche : 11 : 11 listeliste : 1 3 4 5 : 1 3 4 5

noeudnoeud : 11 : 11 recursiverecursive : 1 7 : 1 7

soitsoit : 4 5 10 11 : 4 5 10 11 sous_arbresous_arbre : 11 11 : 11 11

suivisuivi : 5 : 5 unun : 5 7 9 11 : 5 7 9 11

uneune : 1 3 4 5 : 1 3 4 5 videvide : 4 10 : 4 10

ReprésentationReprésentation

“ “ une liste est :une liste est :

- soit une liste vide,- soit une liste vide,

- soit composé d’un élément, suivi d’une liste ”- soit composé d’un élément, suivi d’une liste ”

une 2 31

vide 2 liste 2 31

est 1 soit 2 3

un 3

suivi 3

compose 3

d 3

element 3 3

racine

TablesTables

1. Introduction

2. Hachage ouvert

3. Hachage fermé

4. Implémentation des fonctions

Méthodes de hachage


3 4 8 9 10 20 40 50 70 75 80 83 85 90 table

Recherche dichotomique

bool ELEMENT (int x, Table T, int d, int f ) { int m; if (d > f) { return false; } else { m = (d+f ) / 2 ; if (x==T[m]) return true; else if (x > T [i]) return ELEMENT (x, T, m+1, f ); else return ELEMENT (x, T, d, m) ; }}

4 ?


Idée Idée : :

Établir une relation entre un élément et la caseÉtablir une relation entre un élément et la case

à laquelle il est rangé dans le tableauà laquelle il est rangé dans le tableau

x

0

12

B-1

i xh(x)

élément clé

HachageHachage

Type abstrait « dictionnaire »Type abstrait « dictionnaire »

Ensembles avec les opérations principalesEnsembles avec les opérations principales

ELEMENT (ELEMENT (x, Ax, A))

AJOUTER (AJOUTER (x, Ax, A))

ENLEVER (ENLEVER (x, Ax, A))

Table de hachageTable de hachage

table dont les indices sont dans [0 .. G-1] table dont les indices sont dans [0 .. G-1]

Fonction de hachageFonction de hachage

hh : éléments : éléments [0 .. B-1] [0 .. B-1] non injective en généralnon injective en général

Résolution des collisionsRésolution des collisions

Hachage ouvert : avec listes, triées ou non.Hachage ouvert : avec listes, triées ou non.

Hachage fermé : linéaire, quadratique, aléatoire, uniforme, double, ...Hachage fermé : linéaire, quadratique, aléatoire, uniforme, double, ...

TablesTables

Hachage ouvert

table01

B-1

int h (string x){ int somme = 0 ; for (int i=0; i<x.length(); i++)

somme = somme + x.charAt(i) ; return (somme % B) ;fin

h(x)x

Hachage ouvert : implémentationHachage ouvert : implémentation

const int B = ... ;typedef struct cel { string mot ;

struct cel * suivant;} cellule; typedef cellule * Liste;typedef Liste DICO[B];

void init (Table T) { for (int i=0; i<B-1;i++) T[i] = NULL; }

bool appartient (string x, DICO A){ Liste p = A [ h(x) ] ; while ( p != NULL) if (p->elt == x) return true; else p = p->suivant ; return false ;}

Hachage ouvert : implémentationHachage ouvert : implémentation

void ajouter ( string x, DICO A){ ajouterListe ( x, A[h(x)] ) ;}

x

A[h(x)]void ajouterListe (string x, Liste & L){

if (!appartient(x, L)) {p = L ;

L = new cellule ;L->mot = x ;

L->suivant = p ;}

}


De l’analyse du problème à l’exécution du programmeDe l’analyse du problème à l’exécution du programme 1.1. Bien lire l ’énoncé du problème, être certain de bien le comprendre.Bien lire l ’énoncé du problème, être certain de bien le comprendre.

2.2. Réfléchir au problème, déterminer les points principaux à traiter.Réfléchir au problème, déterminer les points principaux à traiter.

3. Trouver un bon algorithme de résolution, l’écrire sur papier en 3. Trouver un bon algorithme de résolution, l’écrire sur papier en français.français.

4. Coder l’algorithme en un programme écrit sur papier4. Coder l’algorithme en un programme écrit sur papier

5. Introduire le programme dans l’ordinateur au moyen d’un éditeur.5. Introduire le programme dans l’ordinateur au moyen d’un éditeur.

6. Vérifier la syntaxe du programme au moyen d ’un vérificateur de 6. Vérifier la syntaxe du programme au moyen d ’un vérificateur de syntaxe.syntaxe.

7. Compiler le programme7. Compiler le programme

8. Exécuter le programme, vérifier son bon fonctionnement par des 8. Exécuter le programme, vérifier son bon fonctionnement par des tests.tests.

Revision (TD)Revision (TD)

Problème : • On désire créer un programme permettant la manipulation On désire créer un programme permettant la manipulation

d’ensemble d’entiers.d’ensemble d’entiers.

a) Après avoir préalablement défini a) Après avoir préalablement défini le type ensemble le type ensemble

d’entiers(utilisation de tableau)d’entiers(utilisation de tableau). Écrire les procédures ou . Écrire les procédures ou

fonctions de manipulations (opérateurs) d’ensembles décrites fonctions de manipulations (opérateurs) d’ensembles décrites

ci-dessous:ci-dessous:

TD (Révision)TD (Révision)• |E| ? retourne la cardinalité (le nombre d’éléments) d’un ensemble E.

• E = Ø? retourne un booléen qui indique si E est l’ensemble vide ou non.

• x E? retourne un booléen indiquant si un élément x appartient à un ensemble E.

• E1 E2 retourne l’intersection des ensembles E1 et E2. E3 = { x x E1 x E2}.

• E1 E2 retourne l’union des ensembles E1 et E2, E3 = { x x E1 x E2}.

• E1 \ E2 retourne les éléments de E1 qui ne sont pas dans E2, appelé la différence de E1 et E2. Si E3 = E1 \ E2 alors E3 = { x x E1 x E2}.

• E2 E1 + x E2 = E1 {x}

• E2 E1 - x E2 = E1 \ {x}

• E1 = E2? retourne un booléen qui indique si les 2 ensembles contiennent exactement les mêmes éléments

• E1 E2? indique si les éléments de E1 sont inclus dans E2, sans que E1 = E2. E1 E2 si x E1 x E2 et E1 E2.

TD (Révision)TD (Révision)Const Max = 100;

type ensemble = record

nbElement : integer;

element: array[1..Max] of integer;

end;

|E| ? retourne la cardinalité (le nombre d’éléments) d’un ensemble E. Function cardinal(e:ensemble) : integer;

begin

cardinal := e.nbElement;

end;

E = Ø? retourne un booléen qui indique si E est l’ensemble vide ou non.

Function estVide(e:ensemble) : boolean;

begin

estVide := (e.nbElement = 0);

end;

TD (Révision)TD (Révision)x E? retourne un booléen indiquant si un élément x appartient à un ensemble E.

Function appartient(x:integer; e:ensemble) : boolean;

var trouve:boolean;

i:integer;begin

trouve:=false; i:=1;

while (i<=cardinal(e) and (not trouve) )

do begin

trouve:=(e.element[i]=x);

i:=i+1;

end;

appartient:=trouve;end;

TD (Révision)TD (Révision)E1 E2 retourne l’intersection des ensembles E1 et E2.E3 = { x x E1 x E2}. procedure intersection(e1:ensemble; e2:ensemble;

var e3:ensemble);var i:integer;begin

e3.nbElement:=0;for i:=1 to cardinal(e1)

do if(appartient(e1.element[i], e2) )

then ajout(e1.element[i], e3);end;E1 E2 retourne l’union des ensembles E1 et E2, E3 = { x x E1 x E2}.procedure union(e1:ensemble; e2:ensemble;


copier(e1,e3);for i:=1 to cardinal(e2)

do if(not appartient(e2.element[i], e1) )

then ajout(e2.element[i], e3);end;

TD (Révision)TD (Révision)E1 \ E2 retourne les éléments de E1 qui ne sont pas dans E2, appelé la différence de E1 et E2. Si E3 = E1 \ E2 alors E3 = { x x E1 x E2}. procedure différence(e1:ensemble; e2:ensemble;



do if(not appartient(e1.element[i], e2) )

then ajout(e1.element[i], e3);end;

E1 E2 retourne la différence symétrique de E1 et E2.

E3 = {E1 \ E2} {E2 \ E1}.procedure différenceSym(e1:ensemble; e2:ensemble;

var e3:ensemble);var e4,e5:ensemble;begin

difference(e1,e2,e4); difference(e2,e1,e5);union(e4,e5,e3);

end;

TD (Révision)TD (Révision)E2 E1 + x E2 = E1 {x}

procedure ajout(x:integer; var e:ensemble);

var i:integer;

begin

if(cardinal(e)<max)

then begin

e.nbElement:=e.nbElement+1;

e.element[e.nbElement]:=x;

end;

end;

TD (Révision)TD (Révision)E2 E1 - x E2 = E1 \ {x}

procedure supprimer(x:integer; var e:ensemble);

var i:integer;

begin

i:=1;

while(i<=cardinal(e)and x<>e.element[i])

do i:=i+1;

if(i<=cardinal(e))

then begin

e.element[i]:=e.element[cardinal(e)];

e.nbElement:=e.nbelement-1;

end;

end;

TD (Révision)TD (Révision)E1 E2? indique si les éléments de E1 sont inclus dans E2, sans que E1 = E2. E1 E2 si x E1 x E2 et E1 E2. function inclus(e1,e2:ensemble):boolean;var i:integer; dans:boolean;begin

dans:=true; i:=1;while(i<=cardinal(e1)and dans ) do begin

dans := appartient(e1.element[i],e2);i:=i+1;

end;inclus:=dans;

end;function inclus(e1,e2:ensemble):boolean;var e:ensemble;begin

difference(e1,e2,e);inclus:=vide(e);

end;

TD (Révision)TD (Révision)E1 = E2? retourne un booléen qui indique si les 2 ensembles contiennent exactement les mêmes éléments function egal(e1,e2:ensemble):boolean;begin

egal := inclus(e1,e2) and inclus(e2,e1);

end;function egal(e1,e2:ensemble):boolean;var e:ensemble;

begin

differenceSym(e1,e2,e);

egal := vide(e);

end;E2 := E1 ; copier E1 dans E2.procedure copier(e1:ensemble; var e2:ensemble);var i:integer;begin


do ajout(e1.element[i], e2);end;

TD (Révision)TD (Révision)b) En supposant un ordre (croissant) sur les éléments de l’ensemble, apportez les

modifications nécessaires aux opérations précédentes.

x E? retourne un booléen indiquant si un élément x appartient à un ensemble E.


var trouve:boolean;

i:integer;begin

trouve:=false;i:=1;

while (i<=cardinal(e) and x>e.element[i] )

do i:=i+1;

if i<=cardinal(e)

then trouve:=(x=e.element[i]);




E2 E1 + x E2 = E1 {x}


var i:integer;

begin

if(cardinal(e)<max)

then begin

pos:=positionInsertion(x,e);

decalerDroite(pos,e);

e.element[pos]:=x;


end;

end;



function positionInsertion(x:integer; e:ensemble):integer;

var i:integer;

begin

i:=1;

while (i<=cardinal(e) and x >e.element[i])

do i:=i+1;

positionInsertion:=i;

end;

procedure decalerDroite(pos:integer; var e:ensemble);

var i:integer;

begin

for i:=cardinal(e) downto pos

do e.element[i+1]:=e.element[i];

end;



E2 E1 - x E2 = E1 \ {x} procedure supprimer(x:integer; var e:ensemble);var i:integer;begin

while(i<=cardinal(e)and x>e.element[i])do i:=i+1;if(i<=cardinal(e) and e.element[i]=x)then begin

decalerGauche(i,e);e.nbElement:=e.nbElement-1;

end;end;

procedure decalerGauche(pos:integer; var e:ensemble);var i:integer;

beginfor i:= pos to cardinal(e)-1do e.element[i]:=e.element[i+1];

end;

TD (Révision)TD (Révision)c) donnez les versions récursives pour les fonctions ou procédures 3, 4, 5, 9 et 10


Function appartient(x:integer; e:ensemble;

i:integer):boolean;

begin

if(i>cardinal(e)

then appartient:=false

else appartient:=(x=e.element[i])

or appartient(x,e,i+1);

end;

Appel : appartient(x,e,1);

TD (Révision)TD (Révision)

type Liste = ^cellule

cellule = record

val: integer;

suivant : Liste;

end;

ensemble = record

nbElement : integer;

element: Liste;

end;

TD (révision)TD (révision)

|E| ? retourne la cardinalité (le nombre d’éléments) d’un ensemble E. Function cardinal(e:ensemble) : integer;

begin

cardinal := e.nbElement;

end;

E = Ø? retourne un booléen qui indique si E est l’ensemble vide ou non.

Function estVide(e:ensemble) : boolean;

begin

estVide := (e.nbElement = 0);

end;

TD (Révision)TD (Révision)x E? retourne un booléen indiquant si un élément x appartient à un ensemble E.


var trouve:boolean;

p:Liste;begin

trouve:=false; p:=e.element;

while (p<>nil and (not trouve) )

do begin

trouve:=(p^.val=x);

p:=p^.suivant;

end;


TD (Révision)TD (Révision)E1 E2 retourne l’intersection des ensembles E1 et E2.E3 = { x x E1 x E2}. procedure intersection(e1:ensemble; e2:ensemble;

var e3:ensemble);var p:Liste;begin

e3.nbElement:=0; e3.element:=nil;p:=e1.element;while( p<>nil)

do if(appartient(p.val, e2) )

then ajout(p.val e3);end;

====================================================E1 E2 retourne l’union des ensembles E1 et E2, E3 = { x x E1 x E2}.procedure union(e1:ensemble; e2:ensemble;


copier(e1,e3); p:=e2.element;while(p<>nil)

do if(not appartient(p^.val, e1) )

then ajout(p^.val, e3);end;

TD (Révision)TD (Révision)E1 \ E2 retourne les éléments de E1 qui ne sont pas dans E2, appelé la différence de E1 et E2. Si E3 = E1 \ E2 alors E3 = { x x E1 x E2}. procedure différence(e1:ensemble; e2:ensemble;


e3.nbElement:=0;e3.element:=nil;p:=e1.element;while(p<>nil)

do if(not appartient(p^.val e2) )

then ajout(p^.val e3);end;

E1 E2 retourne la différence symétrique de E1 et E2.

E3 = {E1 \ E2} {E2 \ E1}.procedure différenceSym(e1:ensemble; e2:ensemble;

var e3:ensemble);var e4,e5:ensemble;begin

difference(e1,e2,e4); difference(e2,e1,e5);union(e4,e5,e3);

end;

TD (Révision)TD (Révision)E2 E1 + x E2 = E1 {x}


var p:Liste;

begin

if(not appartient(x,e))

then begin


insertete(x, e.element);

end;

end;

TD (Révision)TD (Révision)E2 E1 - x E2 = E1 \ {x}

procedure supprimer(x:integer; var e:ensemble);

var p, prec:Liste

begin

p:=e.element; prec:=nil;

while(p<>nil and x<>p.val)

do begin pres:=p; p:=p^.suivant; end;

if(p<>nil)

then begin

e.nbElement:=e.nbElement-1;

if ( prec=nil)

then supptete(e.element)

else supptete(prec^.suivant);

end;

end;

TD (Révision)TD (Révision)E1 E2? indique si les éléments de E1 sont inclus dans E2, sans que E1 = E2. E1 E2 si x E1 x E2 et E1 E2. procedure inclus(e1,e2:ensemble):boolean;var p:Liste; dans:boolean;begin

dans:=true; p:=e1.element;while(p<>niland dans ) do begin

dans := appartient(p^.val,e2);p:=p^.suivant;

end;inclus:=dans;

end;procedure inclus(e1,e2:ensemble):boolean;var e:ensemble;begin

difference(e1,e2,e);inclus:=vide(e);

end;

TD (Révision)TD (Révision)E1 = E2? retourne un booléen qui indique si les 2 ensembles contiennent exactement les mêmes éléments procedure egal(e1,e2:ensemble):boolean;begin

egal := inclus(e1,e2) and inclus(e2,e1);

end;procedure egal(e1,e2:ensemble):boolean;var e:ensemble;

begin

differenceSym(e1,e2,e);

egal := vide(e);

end;E2 := E1 ; copier E1 dans E2.procedure copier(e1:ensemble; var e2:ensemble);var p:Liste;begin

e2.nbElement:=0; e2.element:=nil;p:=e1.element;while (p<>nil)

do begin insertete(p^.val, e2);p:=p^.suivant; end;end;





var trouve:boolean;

p:Liste;begin

trouve:=false;p:=e.element;

while (p<>nil and x>p^.val )

do p:=p^.suivant;

if p<>nil

then trouve:=(x=p^.val)




E2 E1 + x E2 = E1 {x}


var p,pos:Liste;

begin

if(not appartient(x,e))

then begin

pos:=positionInsertion(x,e);

if (pos=nil)

then insertete(x,e.element)

else insertete(x,pos^.suivant);


end;

end;



function positionInsertion(x:integer; e:ensemble):integer;

var p, prec:Liste;

begin

p:=e.element;prec:=nil;

while (p<>nil and x >p^.val

do begin

prec:=p; p:=p^.suivant;

end;

positionInsertion:=prec;

end;



E2 E1 - x E2 = E1 \ {x} procedure supprimer(x:integer; var e:ensemble);var p,prec:Liste;begin

p:=e.element;prec:=nil;while(p<>nil and x>p^.val)do begin

prec:=p;p:=p^.suivant;

end;if(p<>nil and p^.val=x)then if (prec=nil)

then supptete(e.element) else supptete(prec^.suivant);

end;

TD (Révision)TD (Révision)c) donnez les versions récursives pour les fonctions ou procédures 3, 4, 5, 9 et 10


Function appartient(x:integer; e:ensemble):boolean;

begin

if(e.element=nil)

then appartient:=false

else if(x=e.element^.val)

then appartient:=true

else begin

e.element:=e.element^.suivant;

appartient:=appartient(x,e);

end;

end;

Projet de TPProjet de TP

Jeu du Labyrinthe

On se propose de programmer un jeu (interactif) qui doit permettre

tout d’abord de créer un labyrinthe graphiquement, puis à un

utilisateur (le joueur) de se déplacer dans ce labyrinthe avec comme

objectif d’en trouver la sortie.

Le programme se décompose en deux parties distinctes que nous

détaillons :

• Création du labyrinthe

• Jeu avec le labyrinthe


Remarques Importantes :

• Evitez de passer du temps dans les aspects graphiques, limitez vous aux stricte nécessaire. Nous vous rappelons que ce qui sera primordial pour la notation, c’est bon fonctionnement du jeu, et non sa beauté de la grille etc.

• Il est vivement conseillé, d’adopter la démarche de résolution de problèmes (voir cours et TD). Dans une première étape, on analyse et on ne programme pas !

• Ce projet est à réaliser en binôme, le programme doit être rendu la semaine du 05/01/2003. La séance de cette dernière semaine sera décomposée en deux parties, la finalisation et la remise du projet ainsi que le contrôle de TP.

Projet de TP (Jeu Puissance 4)Projet de TP (Jeu Puissance 4)

On se propose de programmer un jeu interactif; voici les règles que nous On se propose de programmer un jeu interactif; voici les règles que nous utiliserons :utiliserons :

Règles du jeu :Règles du jeu :

Ce jeu se déroule sur une grille LxC avec des pions blancs et des pions Ce jeu se déroule sur une grille LxC avec des pions blancs et des pions rouge. Ce jeu oppose 2 joueurs, l’un posant sur la grille les pions blancs, rouge. Ce jeu oppose 2 joueurs, l’un posant sur la grille les pions blancs, l’autre les pions rouge. Chacun des joueurs posera à son tour un pion sur la l’autre les pions rouge. Chacun des joueurs posera à son tour un pion sur la grille. Le premier pion déposé est blanc, et il est placé en bas de la grille. grille. Le premier pion déposé est blanc, et il est placé en bas de la grille. Tout nouveau pion déposé sur la grille doit l’être : Tout nouveau pion déposé sur la grille doit l’être :

En bas de la grille(ligne 1) ou juste au-dessus d’un pion (blanc ou En bas de la grille(ligne 1) ou juste au-dessus d’un pion (blanc ou rouge) déjà déposé (s’il reste de la place) ; a priori il y a autant de rouge) déjà déposé (s’il reste de la place) ; a priori il y a autant de possibilités qu’il y a de colonnes.possibilités qu’il y a de colonnes.

Sur une case vide (ceci restreint les possibilités précédentes)Sur une case vide (ceci restreint les possibilités précédentes)

Le jeu s’arrête dès qu’un joueur a placé 3 pions à la file et en ligne Le jeu s’arrête dès qu’un joueur a placé 3 pions à la file et en ligne horizontale, verticale ou diagonale. Ce joueur est déclaré vainqueur. Si la horizontale, verticale ou diagonale. Ce joueur est déclaré vainqueur. Si la grille est remplie et qu’aucun joueur n’a gagné, la partie sera déclaré nulle grille est remplie et qu’aucun joueur n’a gagné, la partie sera déclaré nulle (match nul).(match nul).


But du projet :But du projet :Dans le programme à concevoir, il faut permettre à deux joueurs de jouer de Dans le programme à concevoir, il faut permettre à deux joueurs de jouer de

manière interactive. Pour placer un pion, le joueur désignera sa case (x,y) en manière interactive. Pour placer un pion, le joueur désignera sa case (x,y) en

utilisant les flèches du clavier, en considérant “utilisant les flèches du clavier, en considérant “ ” pour le déplacement vers ” pour le déplacement vers

la gauche, “la gauche, “” pour le déplacement vers le haut, etc. Un contrôle sera opéré ” pour le déplacement vers le haut, etc. Un contrôle sera opéré

sur la validité des coups du joueur.sur la validité des coups du joueur.

Ci-dessous les codes ASCII : Ci-dessous les codes ASCII :

““ ” ” : aller à gauche (code = 75): aller à gauche (code = 75)

“ “ ” ” : aller à droite (code = 77): aller à droite (code = 77)

“ “ ” ” : monter (code = 72): monter (code = 72)

“ “ ” ” : descendre (code= 80): descendre (code= 80)

“ “ ” ” : valider (code=13): valider (code=13)


On utilisera la représentation de la grille (e.g. 7x6) et des pions proposée ci-On utilisera la représentation de la grille (e.g. 7x6) et des pions proposée ci-dessous :dessous :

66

55

44

33 BB

22 BB BB NN

11 NN BB NN NN

11 22 33 44 55 66 77

La taille de la grille sera définie en fonction des limites de l’écran de l’ordinateur La taille de la grille sera définie en fonction des limites de l’écran de l’ordinateur que vous utiliserez . que vous utiliserez .

Les primitives graphiques nécessaires et autorisées, vous serons explicité en Les primitives graphiques nécessaires et autorisées, vous serons explicité en cours ou en TP.cours ou en TP.

Projet de TPProjet de TPUn algorithme général :Un algorithme général :Nous proposons un schéma d’algorithme qui permet de programmer ce problème. Nous proposons un schéma d’algorithme qui permet de programmer ce problème. Vous n’êtes pas obligés de le respecter ; il vous est donnée pour vous montrer la Vous n’êtes pas obligés de le respecter ; il vous est donnée pour vous montrer la démarche générale à adopter, et vous exprimer la faisabilité du projet.démarche générale à adopter, et vous exprimer la faisabilité du projet.DébutDébut

– {initialisation}{initialisation}– <initialisation des variables ><initialisation des variables >– <initialisation de l’écran><initialisation de l’écran>– {jeu – les blancs commencent}{jeu – les blancs commencent}– répéter répéter

– si (joueur=blanc) si (joueur=blanc) – alors débutalors début

» <lire action><lire action>» <exécuter action><exécuter action>» si(non <fin de partie> ) alors joueur := noirsi(non <fin de partie> ) alors joueur := noir» finfin

– sinon débutsinon début» <lire action><lire action>» <exécuter action><exécuter action>» si(non <fin de partie> ) alors joueur := blancsi(non <fin de partie> ) alors joueur := blanc» finfin

– jusqu’à (<fin de partie>)jusqu’à (<fin de partie>)– <afficher le résultat><afficher le résultat>

Fin.Fin.


Le programme doit permettre deux possibilités de jeuxLe programme doit permettre deux possibilités de jeux entre deux joueurs humainsentre deux joueurs humains

entre un joueur humain et la machine. Dans ce dernier cas, entre un joueur humain et la machine. Dans ce dernier cas,

l’ordinateur utilisera la stratégie à courts termes que nous l’ordinateur utilisera la stratégie à courts termes que nous

décrivons ci-dessous (Blanc désigne l’utilisateur et Rouge décrivons ci-dessous (Blanc désigne l’utilisateur et Rouge

l’ordinateur) :l’ordinateur) :

Si Rouge peut réaliser une file (horizontale, verticale ou en diagonale) de 3 Si Rouge peut réaliser une file (horizontale, verticale ou en diagonale) de 3

pions ; il la réalisepions ; il la réalise

Sinon si Blanc peut réaliser au coup suivant une file de 3 pions ; Rouge s’y Sinon si Blanc peut réaliser au coup suivant une file de 3 pions ; Rouge s’y

oppose (en plaçant un pion à un bout). Ceci est parfois insuffisant pour oppose (en plaçant un pion à un bout). Ceci est parfois insuffisant pour

éviter la défaite.éviter la défaite.

Sinon si Rouge peut réaliser peut réaliser une file de 2 pions , il la réalise.Sinon si Rouge peut réaliser peut réaliser une file de 2 pions , il la réalise.

Sinon mettre un pion rouge au dessus d’un pion noir ou en bas de la grille.Sinon mettre un pion rouge au dessus d’un pion noir ou en bas de la grille.


Remarques importantes Remarques importantes ::

Il est vivement conseille, d’adopter la démarche de Il est vivement conseille, d’adopter la démarche de

résolution de problèmes (vu en cours : voir résolution de problèmes (vu en cours : voir

exemple de tri).exemple de tri).

Dans une première étape, on analyse et on ne Dans une première étape, on analyse et on ne

programme pas !programme pas !

rappel sur les variables statiques ce qui a été vu? variables de type simple (entier, réels,...

Documents