name: inverse layout: true class: center, middle, inverse --- # INFORMATIQUE 3 - CM 3 ## Inès de Courchelle ## 2024-2025  --- layout: false # Rappel : Les piles ## LIFO (**L**ast **I**n **F**irst **O**ut) Les derniers éléments ajoutés à la Pile sont recupérés en premier. .pull-left[ - empiler - dépiler - vider - compter - inverser - afficher ] .pull-right[
] --- # Rappel : Les files ## FIFO (**F**irst **I**n **F**irst **O**ut) Les premiers éléments ajoutés à la File sont recupérés en premier. .pull-left[ - enfiler - defiler - vider - inverser - afficher - compter ] .pull-right[
] --- # Let's go ## Objectifs - Étudier des structures de données liées - Connaître les particularités des chaînes - Appréhender des notions de gestion de données
--- # Pour représenter un circuit
--- # Pour représenter un cycle
--- # Listes chaînées simple ## Définition
.pull-left[ Un maillon contient : - Une valeur - Un pointeur vers le maillon suivant
] .pull-right[
] --- # Listes Chaînées simple ## Réprésentation
--- # Listes doublements chaînées ## Définition .pull-left[ Un maillon contient : - Une valeur - Un pointeur vers le maillon suivant - Un pointeur vers le maillon précédent
] .pull-right[
] --- # Listes doublements chaînées ## Réprésentation
--- # Listes circulaires - Le dernier maillon de la liste ne pointe plus sur NULL - Toutes les listes peuvent être circulaire #### Liste circulaire simple
#### Liste circulaire double
--- # Listes circulaires ## Liste circulaire simple
--- # Listes circulaires ## Liste circulaire double
--- # Définition de notre structure ## Dans Liste.h on va définir notre structure .pull-left[ #### En algo ```c STRUCTURE maillon donnee : entier suivant : maillon FIN STRUCTURE ```
] .pull-right[ #### En C ```c typedef struct maillon{ int donnee; struct maillon* suivant; }maillon; typedef maillon* teteListe; ``` ]
## Dans le main, on va initialiser notre structure ```c int main(){ teteListe l=NULL ; /* elle ne pointe sur rien à l’état initial */ return 0; } ``` --- # Les opérations de bases ## Opérations primaires - Afficher une liste - Créer un maillon ## Insérer un maillon - au début de la liste - à la fin de la liste - où on veut ## Supprimer un maillon - au début de la liste - à la fin de la liste - où on veut
--- # Avant de commencer ## FONCTION N°1 - La fonction permettant de créer un maillon - on va s'en servir partout .pull-left[ #### En ALGO ```c FONCTION creerMaillon(donnee : entier) : maillon VARIABLES m : maillon DEBUT m.donnee <- valeur m.suivant <- NULL retourner m FIN ``` ] .pull-right[ #### EN C ```c maillon* creerMaillon(int donnee){ maillon* m; m = malloc(sizeof(maillon)*1); m->donnee=donnee m->suivant=NULL; return m; } ``` ] --- # Avant de commencer ## Procédure N°1 : Afficher ```c PROCEDURE afficher(maListe : maillon) DEBUT SI (estListeVide(maListe)) ALORS ECRIRE("---") SINON ECRIRE("maillon" + maListe.donnee) afficher(maListe.suivant) FIN SI FIN ``` .underR[Attention] : On utilise obligatoirement la récursivité ! --- # Avant de commencer ## Procédure N°1 : Afficher
--- # Avant de commencer ## Procédure N°1 : Afficher
--- # Avant de commencer ## Procédure N°1 : Afficher
--- # Avant de commencer ## Procédure N°1 : Afficher
--- # Avant de commencer ## Procédure N°1 : Afficher
--- # Avant de commencer ## Procédure N°1 : Afficher
--- # Avant de commencer ## Procédure N°1 : Afficher
--- # Avant de commencer ## Procédure N°1 : Afficher
--- # Les opérations de bases ## Opérations primaires - .underV[Afficher une liste] - .underV[Créer un maillon] ## Insérer un maillon - au début de la liste - à la fin de la liste - où on veut ## Supprimer un maillon - au début de la liste - à la fin de la liste - où on veut --- # Insertion début
--- # Insertion début
--- # Insertion début
--- # Insertion début
--- # Insertion début ## L'algo - Procédure ```c PROCEDURE ajouterTete(maListe : maillon donnee : entier) VARIABLES : m : maillon DEBU m <- creerMaillon(donnee) m.suivant<-maListe maListe <- m FIN ``` --- # Insertion début ## L'algo - Procédure - Ce n'est pas terrible, terrible ... - AjouterTete va nous permettre de faire de la récursivité - Il faut donc utiliser l'algo en mode fonction ! --- # Insertion début ## L'algo - Fonction ```c FONCTION ajouterTete(maListe : tête de liste donnee : entier) : tête de liste VARIABLES m : maillon DEBUT m <- creerMaillon(donnee) m. suivant <- maListe retourner m; FIN ``` --- # Insertion début ## Rappel .underR[attention] on utilise bien la compilation séparée ! .underV[Comment on compile plusieurs fichiers ?] .arrow[] cf cours de l'année dernière ## VAR
Cette vidéo ne peut être affichée sur votre navigateur Internet.
Une version est disponible en téléchargement sous
adresse du lien
.
--- # Insertion fin
--- # Insertion fin
--- # Insertion fin
--- # Insertion fin
--- # Insertion fin
--- # Insertion fin
--- # Insertion fin ## Algo ```c PROCEDURE ajouterFin(maListe : maillon donnee : entier) VARIABLES : m : maillon temp: maillon DEBUT m <- creerMaillon(donnee) temp <- maListe SI (temp!=NULL) ALORS TANT QUE (temp.suivant!=NULL) FAIRE temp <- temp.suivant FIN TANT QUE temp.suivant<-m SINON maListe <- m FIN SI FIN ``` --- # Insertion fin ## Algo
--- # Insertion fin ## Récursivité #### 1. La condition d'arrêt Je suis à la fin #### 2. La résolution du problème J'ajoute le maillon #### 3. L'appel récursif Je passe au maillon suivant --- # Insertion fin ## Algo ```c PROCEDURE ajouterFin(maListe : tête de liste, donnee : entier) DEBUT SI (maListe.suivant=NULL) ALORS m <- creerMaillon(donnee) maListe.suivant <- m SINON maListe <- maListe.suivant ajouterFin(maListe,donnee) FIN SI FIN ``` --- # VAR ## VIDEO #### Problème je perds le début de la liste
Cette vidéo ne peut être affichée sur votre navigateur Internet.
Une version est disponible en téléchargement sous
adresse du lien
.
--- # Insertion fin ## Solution N°1 - Il faut utiliser un pointeur de liste temp à l'appel de la fonction - Mais c'est moyen !
Cette vidéo ne peut être affichée sur votre navigateur Internet.
Une version est disponible en téléchargement sous
adresse du lien
.
--- # Insertion fin ## Solution N°2 - Utiliser la fonction ajouterDebut - La fonction et non la procédure ## Fonction ajouterTete ```c FONCTION ajouterTete(maListe : maillon donnee : entier) : maillon DEBUT m <- creerMaillon(donnee) m.suivant <- maListe retourner m; FIN ``` --- # Insertion fin ## Algo ```c FONCTION ajouterFin(maListe : maillon donnee : entier) : maillon DEBUT SI maListe = NULL ALORS retourner ajouterTete(maListe,donnee) SINON maListe.suivant <- ajouterFin(maListe.suivant,donnee) retourner maListe FIN FIN ``` --- # Insertion fin ## Illustration
--- # Insertion fin ## Illustration
--- # Insertion fin ## Illustration
--- # Insertion fin ## Illustration
--- # Insertion fin ## Illustration
--- # Insertion fin ## Illustration
--- # Insertion fin ## Illustration
--- # Insertion fin ## Illustration
--- # Insertion fin ## Illustration
--- # Insertion fin ## Illustration
--- # Insertion fin ## Illustration
--- # Insertion fin ## Illustration
--- # Insertion fin ## Illustration
--- # Insertion fin ## Illustration
--- # Insertion fin ## Illustration
--- # Insertion fin ## Illustration
--- # Insertion fin ## Illustration
--- # Insertion fin ## Illustration
--- # Insertion fin ## Illustration
--- # Insertion fin ## Illustration
--- # Insertion fin ## Illustration
--- # Insertion fin ## Illustration
--- # Insertion fin ## Illustration
--- # Insertion fin ## Illustration
--- # Insertion fin ## Illustration
--- # Insertion fin ## Illustration
--- # Insertion fin ## Illustration
--- # Insertion fin ## Illustration
--- # Insertion fin ## Illustration
--- # Video ## VAR
Cette vidéo ne peut être affichée sur votre navigateur Internet.
Une version est disponible en téléchargement sous
adresse du lien
.
--- # Insertion Position
--- # Insertion Position
--- # Insertion Position
--- # Insertion Position
--- # Insertion Position
--- # Insertion Position ## Algo ```c PROCEDURE ajouterPos(maListe : maillon valeur : entier, pos: entier) VARIABLES : m,mTemp : maillon temp: maillon i : entier DEBUT m <- creerMaillon(m) temp <- maListe TANT QUE (temp.suivant!=NULL && i!=(pos-1)) FAIRE temp <- temp.suivant i <-i+1 FIN TANT QUE mTemp <- temp.suivant m.suivant <- mTemp temp.suivant<-m FIN ``` --- # Insertion Position ## c'est pas bon
--- # Insertion Position ## Récursivité #### 1. La condition d'arrêt Je suis à la bonne position OU je suis à la fin de ma liste #### 2. La résolution du problème J'ajoute le maillon #### 3. L'appel récursif Je passe au maillon suivant --- # Insertion Position ## Récursivité ```c FONCTION ajouterPos(maListe : maillon donnee : entier, pos: entier) : maillon DEBUT SI maListe=NULL OU pos=1 ALORS retourner ajouterTete(maListe,donnee) SINON maListe.suivant = ajouterPos(maListe.suivant,donnee,pos-1) retourner maListe FIN SI FIN ``` --- # Insertion Position ## Récursivité
--- # Insertion Position ## Récursivité
--- # Insertion Position ## Récursivité
--- # Insertion Position ## Récursivité
--- # Insertion Position ## Récursivité
--- # Insertion Position ## Récursivité
--- # Insertion Position ## Récursivité
--- # Insertion Position ## Video
Cette vidéo ne peut être affichée sur votre navigateur Internet.
Une version est disponible en téléchargement sous
adresse du lien
.
--- # Les opérations de bases ## Opérations primaires - .underV[Afficher une liste] - .underV[Créer un maillon] ## Insérer un maillon - .underV[au début de la liste] - .underV[à la fin de la liste] - .underV[où on veut] ## Supprimer un maillon - au début de la liste - à la fin de la liste - où on veut --- # Suppression Début
--- # Suppression Début
--- # Suppression Début
--- # Suppression Début
--- # Suppression Début
--- # Suppression Début ## Algo ```c FONCTION supprTete(maListe : maillon) : maillon VARIABLES : temp: maillon DEBUT SI (maListe=NULL) alors retourner maListe SINON temp <- maListe.suivant retourner temp FIN SI FIN ``` --- # Suppression Fin
--- # Suppression Fin
--- # Suppression Fin
--- # Suppression Fin
--- # Suppression Fin
--- # Suppression Fin
--- # Suppression Fin
--- # Suppression Fin ## Algo ```c FONCTION supprimerFin(maListe : maillon) : entier VARIABLES : temp: maillon eltSuppr : entier DEBUT temp<-maListe SI (temp!=NULL) FAIRE TANT QUE (temp.suivant!=NULL) FAIRE temp <- temp.suivant FIN TANT QUE eltSuppr <- temp.suivant->donnee temp.suivant <- NULL SINON temp <- NULL FIN SI retourner eltSuppr FIN ``` --- # Suppression Fin ## c'est pas bon
--- # Suppression Fin ## Récursivité #### 1. La condition d'arrêt Je suis à la fin #### 2. La résolution du problème Je supprime le maillon #### 3. L'appel récursif Je passe au maillon suivant --- # Suppression Fin ## Récursivité ```c FONCTION supprFin(maListe : maillon) : maillon DEBUT SI maListe = NULL ALORS retourner maListe SINON SI (maListe.suivant= NULL) ALORS retourner supprTete(maListe) SINON maListe.suivant <- supprFin(maListe.suivant); retourner maListe FIN SI FIN SI FIN ``` --- # Suppression Fin ## Récursivité
--- # Suppression Fin ## Récursivité
--- # Suppression Fin ## Récursivité
--- # Suppression Fin ## Récursivité
--- # Suppression Fin ## Récursivité
## Question ! - Vérifier qu'on ne supprime pas la fin d'une liste vide - On aurait une erreur ici après : ```c SINON SI (maListe.suivant= NULL) ALORS ``` --- # Suppression Position ## Algo ```c FONCTION supprimerPos(maListe : maillon pos: entier) : entier VARIABLES : temp: maillon eltSuppr,i : entier DEBUT temp<-maListe TANT QUE (temp.suivant!=NULL ET (i!=(pos-1))) FAIRE temp=temp.suivant i <- i + 1 FIN TANT QUE eltSuppr <- temp.suivant.donnee temp.suivant <- temp.suivant.suivant retourner eltSuppr FIN ``` --- # Suppression Position ## c'est pas bon
--- # Suppression Position ## Récursivité #### 1. La condition d'arrêt Je suis à la fin ou à la position #### 2. La résolution du problème Je supprime et libére le maillon #### 3. L'appel récursif Je passe au maillon suivant --- # Suppression Position ## Récursivité ```c FONCTION supprPos(maListe : maillon,pos : entier) : maillon DEBUT SI maListe = NULL ALORS retourner maListe SINON SI (pos = 1) ALORS retourner supprTete(maListe) SINON maListe.suivant <- supprPos(maListe.suivant,pos-1); retourner maListe FIN SI FIN SI FIN ``` --- # Suppresion ## La vidéo
Cette vidéo ne peut être affichée sur votre navigateur Internet.
Une version est disponible en téléchargement sous
adresse du lien
.
--- # Changement de Type de données ## Maillon ```c typedef struct maillon{ int donnee; struct maillon* suivant; }maillon; typedef maillon* teteListe; ``` ## Si la donnee devient un float ```c typedef struct maillon{ float donnee; struct maillon* suivant; }maillon; typedef maillon* teteListe; ``` #### Toutes les signatures de fonctions sont fausses --- # Changement de Type de données ## Les signatures avec un entier ```c maillon* creerMaillon(int donnee); teteListe ajouterTete(teteListe maListe, int donnee); teteListe ajouterFin(teteListe maListe, int donnee); teteListe ajouterPos(teteListe maListe,int donnee,int pos); ``` ## Les signatures avec un réel ```c maillon* creerMaillon(float donnee); teteListe ajouterTete(teteListe maListe, float donnee); teteListe ajouterFin(teteListe maListe, float donnee); teteListe ajouterPos(teteListe maListe, float donnee,int pos); ``` --- # Changement de Type de données ## Mais comment faire ?
## Avec un define dans le .h ```c #define TYPE float ``` --- # Changement de Type de données ## Pour le maillon ```c typedef struct maillon{ TYPE donnee; struct maillon* suivant; }maillon; typedef maillon* teteListe; ``` ## Pour les signatures ```c maillon* creerMaillon(TYPE donnee); teteListe ajouterTete(teteListe maListe, TYPE donnee); teteListe ajouterFin(teteListe maListe, TYPE donnee); teteListe ajouterPos(teteListe maListe, TYPE donnee,int pos); ``` --- # La preuve en VIDEO ## La var
Cette vidéo ne peut être affichée sur votre navigateur Internet.
Une version est disponible en téléchargement sous
adresse du lien
.
--- # Bilan ## Liste chaînée VS Pile/File .underV[La différence est dans la gestion de la structure de données] .pull-left[ #### Liste chaînée - Accéder à l'élément que l'on souhaite - Ne pas définir de taille ] .pull-right[ #### Pile/File - Accéder au premier élément pointé - Ne pas définir de taille ] ## Utilisation de la récursivité - Utiliser des fonctions qui renvoie des pointeurs de maillons (tête de liste) - Manipuler la récursivité, ce n'est plus un secret !