Imprimer la liste des liens en C++
- Utiliser une fonction personnalisée pour imprimer les éléments d’une LinkedList
- Utiliser la fonction définie par l’utilisateur pour imprimer tous les éléments de la LinkedList
Cet article explique plusieurs méthodes pour imprimer les éléments d’une LinkedList en C++.
Utiliser une fonction personnalisée pour imprimer les éléments d’une LinkedList
Dans les exemples suivants, nous construisons manuellement une structure de données de LinkedList, nous l’initialisons avec des valeurs arbitraires, puis nous imprimons les éléments sur la console. La structure implémentée est une liste à liens simples avec trois membres de données appelés city, country et key.
La fonction addNewNode est utilisée pour construire un nouvel élément dans une LinkedList. Elle prend l’argument Node* comme adresse où construire un nouveau noeud et 3 valeurs correspondantes qui doivent être assignées à ses membres de données.
Comme nous construisons la structure des données manuellement, nous devons utiliser l’allocation dynamique de mémoire. Ainsi, une autre fonction, freeNodes, est nécessaire pour désallouer la LinkedList avant que le programme ne se termine.
Une fois que l’initialisation de la LinkedList est faite, nous pouvons appeler la fonction printNodeData dans la boucle pour imprimer le même nombre d’éléments qui ont été poussés vers la liste à partir du vector de paires. La fonction prend le seul argument de type Node* et appelle count pour sortir chaque élément de données vers la console. L’inconvénient de cette fonction est que l’utilisateur doit se soucier de l’itération correcte dans la LinkedList chaque fois qu’il a besoin d’imprimer les éléments.
#include <iostream>
#include <string>
#include <vector>
using std::cin;
using std::cout;
using std::endl;
using std::pair;
using std::string;
using std::vector;
struct Node {
struct Node *next{};
string city;
string country;
int key{};
};
struct Node *addNewNode(struct Node *node, int key, string &city,
string &country) {
node->next = new Node;
node->next->key = key;
node->next->city = city;
node->next->country = country;
return node;
}
void freeNodes(struct Node *node) {
struct Node *tmp = nullptr;
while (node) {
tmp = node;
node = node->next;
delete tmp;
}
}
void printNodeData(struct Node *node) {
cout << "key: " << node->key << endl
<< "city: " << node->city << endl
<< "county: " << node->country << endl
<< endl;
}
int main() {
struct Node *tmp, *root;
struct Node *end = nullptr;
vector<pair<string, string>> list = {{"Tokyo", "Japan"},
{"New York", "United States"},
{"Mexico City", "Mexico"},
{"Tangshan", "China"},
{"Tainan", "Taiwan"}};
root = new Node;
tmp = root;
for (int i = 0; i < list.size(); ++i) {
tmp = addNewNode(tmp, i + 1, list[i].first, list[i].second);
tmp = tmp->next;
}
tmp = root->next;
for (const auto &item : list) {
printNodeData(tmp);
tmp = tmp->next;
}
freeNodes(root->next);
delete root;
return EXIT_SUCCESS;
}
Production :
key: 1
city: Tokyo
county: Japan
...
Utiliser la fonction définie par l’utilisateur pour imprimer tous les éléments de la LinkedList
Une meilleure mise en œuvre de la fonction print serait celle qui n’est appelée qu’une fois. La fonction printNodes est définie comme le type void qui ne renvoie rien à l’appelant. Elle prend exactement un argument de type Node* similaire à la fonction précédente, et elle fait l’itération à travers la LinkedList toute seule. Notez que l’appel de la fonction freeNodes ne suffit pas à nettoyer toute la mémoire dynamique utilisée par la structure de données. Le pointeur root alloué par la fonction main doit être libéré également ; sinon, une fuite de mémoire sera inévitable.
#include <iostream>
#include <string>
#include <vector>
using std::cin;
using std::cout;
using std::endl;
using std::pair;
using std::string;
using std::vector;
struct Node {
struct Node *next{};
string city;
string country;
int key{};
};
struct Node *addNewNode(struct Node *node, int key, string &city,
string &country) {
node->next = new Node;
node->next->key = key;
node->next->city = city;
node->next->country = country;
return node;
}
void freeNodes(struct Node *node) {
struct Node *tmp = nullptr;
while (node) {
tmp = node;
node = node->next;
delete tmp;
}
}
void printNodes(struct Node *node) {
while (node) {
cout << "key: " << node->key << endl
<< "city: " << node->city << endl
<< "county: " << node->country << endl
<< endl;
node = node->next;
}
}
int main() {
struct Node *tmp, *root;
struct Node *end = nullptr;
vector<pair<string, string>> list = {{"Tokyo", "Japan"},
{"New York", "United States"},
{"Mexico City", "Mexico"},
{"Tangshan", "China"},
{"Tainan", "Taiwan"}};
root = new Node;
tmp = root;
for (int i = 0; i < list.size(); ++i) {
tmp = addNewNode(tmp, i + 1, list[i].first, list[i].second);
tmp = tmp->next;
}
printNodes(root->next);
freeNodes(root->next);
delete root;
return EXIT_SUCCESS;
}
Production :
key: 1
city: Tokyo
county: Japan
...
Founder of DelftStack.com. Jinku has worked in the robotics and automotive industries for over 8 years. He sharpened his coding skills when he needed to do the automatic testing, data collection from remote servers and report creation from the endurance test. He is from an electrical/electronics engineering background but has expanded his interest to embedded electronics, embedded programming and front-/back-end programming.
LinkedIn Facebook