c
#include <stdio.h>
#include <stdlib.h>
● #include <stdio.h> : Inclut la bibliothèque standard d'entrée/sortie qui permet
d'utiliser des fonctions comme printf pour afficher du texte à l'écran.
● #include <stdlib.h> : Inclut la bibliothèque standard qui fournit des fonctions
comme malloc et free pour la gestion dynamique de la mémoire.
// Définition de la liste simplement chaînée (LA)
typedef struct Node {
float value;
struct Node* next;
} Node;
● typedef struct Node { ... } Node; : Définit une nouvelle structure appelée
Node qui représente un nœud dans une liste simplement chaînée.
● float value; : Champ pour stocker une valeur de type float.
● struct Node* next; : Pointeur vers le prochain nœud de la liste. S'il n'y a pas de
nœud suivant, ce champ sera NULL.
// Définition de la liste doublement chaînée (LB)
typedef struct DNode {
float value;
struct DNode* next;
struct DNode* prev;
} DNode;
● typedef struct DNode { ... } DNode; : Définit une nouvelle structure
appelée DNode pour représenter un nœud dans une liste doublement chaînée.
● float value; : Champ pour stocker une valeur de type float.
● struct DNode* next; : Pointeur vers le nœud suivant dans la liste.
● struct DNode* prev; : Pointeur vers le nœud précédent dans la liste.
// Fonction pour créer un nouveau nœud pour la liste simplement
chaînée
Node* createNode(float value) {
Node* newNode = (Node*)malloc(sizeof(Node));
newNode->value = value;
newNode->next = NULL;
return newNode;
}
● Node* createNode(float value) : Déclaration d'une fonction qui crée et
initialise un nœud pour la liste simplement chaînée.
● Node* newNode = (Node*)malloc(sizeof(Node)); : Alloue dynamiquement
la mémoire nécessaire pour un nouveau nœud de type Node.
● newNode->value = value; : Affecte la valeur passée en paramètre au champ
value du nœud.
● newNode->next = NULL; : Initialise le pointeur next à NULL (aucun nœud
suivant pour le moment).
● return newNode; : Retourne le pointeur vers le nouveau nœud créé.
// Fonction pour créer un nouveau nœud pour la liste doublement
chaînée
DNode* createDNode(float value) {
DNode* newDNode = (DNode*)malloc(sizeof(DNode));
newDNode->value = value;
newDNode->next = NULL;
newDNode->prev = NULL;
return newDNode;
}
● DNode* createDNode(float value) : Déclaration d'une fonction qui crée et
initialise un nœud pour la liste doublement chaînée.
● DNode* newDNode = (DNode*)malloc(sizeof(DNode)); : Alloue
dynamiquement la mémoire pour un nouveau nœud de type DNode.
● newDNode->value = value; : Affecte la valeur passée en paramètre au champ
value du nœud.
● newDNode->next = NULL; : Initialise le pointeur next à NULL.
● newDNode->prev = NULL; : Initialise le pointeur prev à NULL.
● return newDNode; : Retourne le pointeur vers le nouveau nœud créé.
// Fonction pour convertir une liste simplement chaînée LA en liste
doublement chaînée LB
void convertAndDelete(Node** LA, DNode** LB) {
Node* current = *LA;
DNode* prevNode = NULL;
● void convertAndDelete(Node** LA, DNode** LB) : Déclaration d'une
fonction qui convertit la liste simplement chaînée pointée par *LA en une liste
doublement chaînée, dont la tête sera stockée dans *LB. Les adresses sont passées
par référence pour pouvoir modifier les pointeurs à l'intérieur de la fonction.
● Node* current = *LA; : Initialise un pointeur current pour parcourir la liste
simplement chaînée, en partant de la tête *LA.
● DNode* prevNode = NULL; : Initialise un pointeur pour garder en mémoire le
dernier nœud créé dans la liste doublement chaînée (aucun nœud n’a encore été
créé).
// Parcours de la liste LA et création de LB
while (current != NULL) {
DNode* newDNode = createDNode(current->value);
● while (current != NULL) { : Boucle qui parcourt chaque nœud de la liste
simplement chaînée tant que current n'est pas NULL (fin de la liste).
● DNode* newDNode = createDNode(current->value); : Pour chaque nœud
de LA, crée un nouveau nœud pour LB en copiant la valeur (current->value).
if (*LB == NULL) {
*LB = newDNode; // Premier élément de LB
} else {
prevNode->next = newDNode;
newDNode->prev = prevNode;
}
● if (*LB == NULL) : Vérifie si la liste doublement chaînée LB est vide.
○ *LB = newDNode; : Si LB est vide, le nouveau nœud devient la tête de la
liste LB.
● else { ... } : Si LB n'est pas vide :
○ prevNode->next = newDNode; : Lien du nœud précédent (prevNode)
avec le nouveau nœud via le champ next.
○ newDNode->prev = prevNode; : Lien du nouveau nœud avec le nœud
précédent via le champ prev.
prevNode = newDNode;
● prevNode = newDNode; : Met à jour prevNode pour qu’il pointe sur le nouveau
nœud créé, ce qui sera utile lors de l’itération suivante pour établir le lien avec le
prochain nœud.
// Sauvegarde du prochain élément de LA avant de libérer
l'actuel
Node* temp = current;
current = current->next;
free(temp); // Suppression de l'élément de LA
}
● Node* temp = current; : Sauvegarde le pointeur vers le nœud courant afin de
pouvoir le libérer après avoir récupéré le pointeur vers le nœud suivant.
● current = current->next; : Avance le pointeur current vers le nœud suivant
de LA.
● free(temp); : Libère la mémoire du nœud sauvegardé (celui qui vient d’être
converti), supprimant ainsi l'élément de la liste LA.
c
// LA devient vide après suppression
*LA = NULL;
}
● *LA = NULL; : Une fois la boucle terminée, la liste LA a été entièrement parcourue
et tous ses nœuds ont été libérés. On définit donc la tête de LA à NULL pour indiquer
qu’elle est vide.
// Fonction pour afficher une liste simplement chaînée
void printList(Node* head) {
while (head) {
printf("%.2f -> ", head->value);
head = head->next;
}
printf("NULL\n");
}
● void printList(Node* head) : Déclare une fonction qui affiche les éléments
d'une liste simplement chaînée.
● while (head) { ... } : Parcourt la liste tant que le pointeur head n'est pas
NULL.
● printf("%.2f -> ", head->value); : Affiche la valeur du nœud actuel
formatée avec deux décimales, suivie d'une flèche indiquant la liaison au nœud
suivant.
● head = head->next; : Passe au nœud suivant dans la liste.
● printf("NULL\n"); : Affiche "NULL" à la fin pour indiquer la fin de la liste.
// Fonction pour afficher une liste doublement chaînée
void printDList(DNode* head) {
while (head) {
printf("%.2f <-> ", head->value);
head = head->next;
}
printf("NULL\n");
}
● void printDList(DNode* head) : Déclare une fonction pour afficher les
éléments d'une liste doublement chaînée.
● while (head) { ... } : Parcourt la liste jusqu’à atteindre NULL.
● printf("%.2f <-> ", head->value); : Affiche la valeur du nœud avec le
symbole <-> pour montrer que la liaison se fait dans les deux sens.
● head = head->next; : Passe au nœud suivant.
● printf("NULL\n"); : Indique la fin de la liste.
// Programme principal pour tester la fonction
int main() {
// Création de la liste simplement chaînée LA
Node* LA = createNode(1.1);
LA->next = createNode(2.2);
LA->next->next = createNode(3.3);
LA->next->next->next = createNode(4.4);
● int main() { : Déclaration de la fonction principale qui sera exécutée au
démarrage du programme.
● Node* LA = createNode(1.1); : Crée le premier nœud de la liste simplement
chaînée LA avec la valeur 1.1 et assigne son adresse à LA (la tête de la liste).
● LA->next = createNode(2.2); : Crée un second nœud avec la valeur 2.2 et le
lie au premier nœud en assignant son adresse au champ next du premier nœud.
● LA->next->next = createNode(3.3); : Crée un troisième nœud avec la
valeur 3.3 et le lie au second nœud.
● LA->next->next->next = createNode(4.4); : Crée un quatrième nœud
avec la valeur 4.4 et le lie au troisième nœud.
printf("Liste initiale LA : ");
printList(LA);
● printf("Liste initiale LA : "); : Affiche un message indiquant le début de
l'affichage de la liste LA.
● printList(LA); : Appelle la fonction printList pour afficher les éléments de la
liste simplement chaînée LA.
c
// Création d'un pointeur pour la liste doublement chaînée LB
DNode* LB = NULL;
● DNode* LB = NULL; : Déclare un pointeur pour la liste doublement chaînée LB et
l'initialise à NULL (aucun nœud dans LB au départ).
// Conversion et suppression des éléments de LA
convertAndDelete(&LA, &LB);
● convertAndDelete(&LA, &LB); : Appelle la fonction qui convertit la liste
simplement chaînée LA en une liste doublement chaînée LB.
○ &LA : Passe l'adresse du pointeur LA pour que la fonction puisse modifier la
tête de LA (en la vidant).
○ &LB : Passe l'adresse du pointeur LB pour que la fonction puisse initialiser la
nouvelle liste doublement chaînée.
printf("Liste après conversion LA (doit être vide) : ");
printList(LA);
● printf("Liste après conversion LA (doit être vide) : "); : Affiche
un message indiquant que la liste LA devrait être vide après la conversion.
● printList(LA); : Tente d'afficher LA, qui est maintenant NULL.
printf("Liste doublement chaînée LB : ");
printDList(LB);
● printf("Liste doublement chaînée LB : "); : Affiche un message
indiquant le début de l'affichage de la liste doublement chaînée LB.
● printDList(LB); : Appelle la fonction printDList pour afficher les éléments de
la liste LB.
c
return 0;
}
● return 0; : Termine le programme en renvoyant 0, ce qui indique que le
programme s'est terminé avec succès.
