Liste liée à la circulaire en C ++

Nous pouvons mettre des éléments dans la liste liée à la circulaire de n'importe où dans la liste; Cependant, nous ne pouvons pas insérer des éléments dans le tableau de n'importe où dans la liste car il est en mémoire contiguë. Le dernier élément d'une liste liée circulaire maintient l'adresse de l'élément suivant, tandis que le dernier élément maintient l'adresse du premier élément. Une chaîne circulaire est formée par les éléments se référant les uns aux autres dans un motif circulaire.

Comme la liste liée à la circulaire a une taille dynamique, la mémoire ne peut être allouée que lorsqu'elle est nécessaire. L'article démontrera la liste liée à la circulaire avec les illustrations du programme C ++ en C++.

Application de la liste liée à la circulaire

Une liste liée à la circulaire est celle dans laquelle tous les nœuds sont connectés en cercle. Il n'y a pas d'élément nul dans la liste liée à la circulaire. Un point de départ peut être n'importe quel nœud. À partir de n'importe quel endroit de la liste, nous pouvons traverser toute la liste. Tout ce que nous avons à faire maintenant est d'attendre que le premier nœud soit atteint à nouveau. Là, nous avons quelques applications d'une liste liée circulaire comme suit:

1. Nos ordinateurs personnels, qui exécutent plusieurs applications, sont un exemple de la façon dont la liste liée circulaire est utilisée dans la vie réelle. Toutes les applications en cours d'exécution sont stockées dans une liste liée à la circulaire, et le système d'exploitation attribue à chacun un certain créneau horaire à exécuter. Le système d'exploitation continue de se dérouler sur la liste liée jusqu'à ce que tous les programmes soient exécutés.
2. Les jeux multijoueurs sont un autre excellent exemple. Tous les joueurs sont stockés dans une liste liée circulaire, le pointeur avançant lorsque l'opportunité de chaque joueur expire.
3. La file d'attente circulaire peut également être créée à l'aide d'une liste liée circulaire. Nous devons conserver les deux pointeurs, avant et arrière, en mémoire à tout moment dans une file d'attente, mais un seul pointeur est nécessaire dans une liste liée circulaire.

Exemple 1: Création de la traversée de liste liée circulaire en C++

La seule différence est que dans une liste liée circulaire, le nœud de la dernière position aura son prochain lien vers la tête de la liste, tandis que dans une liste liée, le dernier nœud aurait son prochain point au bas du bas Liste. L'implémentation du code de traversée de liste liée à la circulaire en C ++ est illustrée ci-dessous.

Dans la première étape, nous avons défini une classe comme un «nœud», dans lequel nous avons déclaré une variable int en «mydata». La variable «MyData» est les données du nœud. Le pointeur est également déclaré dans cette classe comme «suivant» pour le pointeur vers le nœud suivant dans la liste liée à la circulaire.

Après la classe «nœud», nous avons une fonction appelée «push», qui insère le nœud au début de la liste liée circulaire. Nous avons défini le constructeur, qui passe la référence du pointeur Head_Node de la classe «nœud» et la variable «mydata» comme paramètre. Le nouveau pointeur est créé comme «myptr», qui a appelé et attribué le «nœud».

Ensuite, le pointeur temp. Il y a des pointeurs tels que «ptr1» et «ptr2» qui sont appelés «mydata» et pointeur «Suivant» et prenez leurs adresses. Après cela, nous avons une déclaration IF dans laquelle il n'y a que Head_node, et il est maintenu nul. Si la liste liée à la circulaire est nul, ajoutez le suivi au dernier nœud à l'aide d'une boucle de temps. Sinon, l'instruction ELSE sera exécutée dans laquelle la tête pointe vers le premier nœud de la liste.

Ensuite, nous avons créé une autre fonction en tant que «liste d'affichage», et dans le constructeur de cette fonction, nous venons de passer la tête de nœud de la liste liée à la circulaire. La fonction affichera les nœuds dans une liste liée circulaire via une boucle de bricolage après l'instruction IF, qui a la condition que la tête du nœud ne doit pas être égale à Null.

Enfin, il existe la méthode principale, qui testera la mise en œuvre décrite précédemment. La tête du pointeur de la classe «nœud» a été définie sur «null» dans la méthode principale. Ensuite, ajoutez les données à la liste liée à l'aide de la méthode push (). La «tête» est transmise à la fonction «DisplayList», qui affichera la liste liée à la circulaire.

#inclure
Utilisation de Namespace Std;
nœud de classe

public:
int mydata;
Nœud * suivant;
;
void push (nœud ** head_node, int mydata)

Node * myptr1 = new node ();
Node * temp = * head_node;
Myptr1-> mydata = mydata;
Myptr1-> next = * head_node;
if (* head_node != Null)

tandis que (temp-> suivant != * head_node)
temp = temp-> suivant;
temp-> next = myptr1;

autre
Myptr1-> next = myptr1;
* head_node = myptr1;

void DisplayList (Node * Head)

Node * temp = tête;
Si (tête != Null)

faire

couter
tandis que (temp != tête);


int main()

Nœud * head = null;
Push (& Head, 2001);
Push (& Head, 2015);
Push (& Head, 2006);
push (& head, 2022);
couter<< "Circular Linked List:\n ";
DisplayList (Head);
couter<< "\n ";
retour 0;

La liste liée à la circulaire implémentée dans la sortie de code ci-dessus s'affiche dans l'image suivante.

Exemple2: Divisez la liste liée à la circulaire en deux moitiés en C++

Le programme suivant rend la division d'une liste liée circulaire en deux parties possibles. Examinons la mise en œuvre de la façon dont nous avons divisé la liste liée à la circulaire en C++.

Tout d'abord, nous avons un «nœud» de classe où nous avons défini une variable «éléments» et le pointeur «Suivant» du nœud. Les membres de la classe «nœud» sont publics dans ce programme. Ensuite, nous avons construit une fonction intitulée «Halvelist» dans laquelle nous avons divisé la liste depuis le début avec la tête en deux listes. Les hier1_node et head2_node sont des références aux deux nœuds de tête des listes liées liées résultant.

Dans la fonction, nous avons déclaré deux pointeurs, «S_PTR» et le «F_PTR», qui a la tête de la liste liée. Si l'instruction IF est utilisée pour le nœud de tête contenant une valeur nulle, nous avons une boucle while qui indique que f_ptr-> Ensuite devient la tête si la liste circulaire a des nœuds impairs, et f_ptr-> Next-> Suivant devient la tête si le La liste contient même les nœuds.

Après la boucle while, nous avons à nouveau utilisé l'instruction IF dans laquelle la condition est «Si la liste contient un nombre uniforme d'éléments, F_PTR doit être déplacé et définir le pointeur Head1_Node de la première moitié». Dans l'instruction suivante, nous avons réglé la tête2_node sur la seconde moitié de la liste liée.

Nous avons attribué le s_ptr-> à côté du f_ptr-> à côté de la deuxième moitié circulaire de la liste, puis S_PTR-> est maintenu égal à la tête de la liste et fait le premier demi-cercle.

La deuxième fonction est créée comme «push», qui est utilisée pour insérer un nœud au début d'une liste liée circulaire à cette fonction. Dans la fonction, la condition implique que la tête_node de la liste liée circulaire n'est pas nul, puis réglé à côté du dernier nœud. La troisième fonction, «DisplayList», est générée pour que la liste liée circulaire soit affichée.

Ensuite, nous avons la fonction principale, où nous avons initialisé la tête, head1_node et head2_node vide. La méthode push est utilisée pour insérer les valeurs dans la liste liée, et via la commande cout, la liste liée circulaire et la liste liée circulaire divisée seront affichées.

#inclure
Utilisation de Namespace Std;
classe MyNode

public:
articles int;
Mynode * suivant;
;
void halvelist (MyNode * Head, mynode ** head1_node, mynode ** head2_node)

Mynode * s_ptr = tête;
Mynode * f_ptr = tête;
si (tête == null)
retour;
tandis que (f_ptr-> suivant != tête &&
f_ptr-> Suivant-> Suivant != tête)

f_ptr = f_ptr-> suivant-> suivant;
s_ptr = s_ptr-> suivant;

if (f_ptr-> next-> next == tête)
f_ptr = f_ptr-> suivant;
* head1_node = head;
if (head-> Suivant != tête)
* head2_node = s_ptr-> suivant;
f_ptr-> next = s_ptr-> suivant;
s_ptr-> next = tête;

void push (mynode ** head_node, int items)

MyNode * newptr = new MyNode ();
Mynode * temp = * head_node;
Newptr-> items = items;
Newptr-> next = * head_node;
if (* head_node != Null)

tandis que (temp-> suivant != * head_node)
temp = temp-> suivant;
temp-> next = newptr;

autre
Newptr-> next = newptr; / * Pour le premier mynode * /
* head_node = newptr;

void DisplayList (MyNode * Head)

MyNode * temp = tête;
Si (tête != Null)

couter<faire
couter tandis que (temp != tête);


int main()

int mylistsize, i;
Mynode * head = null;
Mynode * head1 = null;
Mynode * head2 = null;
push (& head, 10);
push (& head, 90);
push (& head, 40);
push (& head, 70);
couter<< "Circular Linked List";
DisplayList (Head);
Halvelist (Head, & Head1, & Head2);
couter<< "\nFirst Halve Circular Linked List";
DisplayList (head1);
couter<< "\nSecond Halve Circular Linked List";
DisplayList (head2);
retour 0;

Ici, nous avons la sortie de la liste liée circulaire d'origine, la sortie de la première liste liée à moitié circulaire et la seconde moitié de la liste liée circulaire.

Exemple 3: Tri de la liste liée à la circulaire en C++

Dans la première étape, nous avons une classe «nodelist», qui contient des variables et des pointeurs membres dans la classe. Ensuite, nous avons créé une fonction «SortInsertion», qui insère un nouveau nœud dans une liste triée. Cette fonction nécessite un pointeur vers le nœud de tête car il peut modifier la tête de la liste liée à l'entrée.

Après cela, nous avons une déclaration IF pour Nodelist, qui ne contient que du nœud. Le hier_node pointe vers le nouveau nœud. Dans la déclaration ELSE, IF, nous avons attribué les données du nodeliste au courant.

Ici, un nouveau nœud est ajouté avant le nœud de tête. Le bloc IF-Else a une boucle de temps qui a une condition; Si la valeur est inférieure à la valeur de la tête, le nœud suivant ou dernier doit être modifié. La boucle while n'identifiera que le nœud avant le point d'insertion.

Après cela, nous avons fait un New_Nodelist, le nœud suivant qui localise le nœud suivant du pointeur. Ensuite, actuel-> Suivant, nous devons changer l'emplacement du pointeur vers le suivant. Pour imprimer les nœuds de la liste liée, nous avons appelé une fonction «Showlist».

En fin de compte, nous avons la fonction principale où nous avons initialisé un tableau et itéré sur le tableau spécifié, qui sera un tableau trié.

#inclure
Utilisation de Namespace Std;
classe nodelist

public:
valeurs int;
NodeList * Suivant;
;
void sortInsertion (nodelist ** head_node, nodelist * new_nodelist)

NodeList * current = * head_node;
si (courant == null)

new_nodeList-> next = new_nodeList;
* head_node = new_nodeList;

else if (current-> valeurs> = new_nodelist-> valeurs)

tandis que (actuel-> suivant != * head_node)
Current = Current-> Suivant;
current-> next = new_nodeList;
new_nodeList-> next = * head_node;
* head_node = new_nodeList;

autre

tandis que (actuel-> suivant!= * head_node &&
Current-> Next-> valeurs valeurs)
Current = Current-> Suivant;
new_nodeList-> next = current-> suivant;
current-> next = new_nodeList;


void showlist (nodelist * begin)

Nodelist * temp;
Si (commencez != Null)

temp = commencer;
faire
couter tandis que (temp != commencer);


int main()

int myarr [] = 31, 5, 23, 99, 30;
int list_size, i;
Nodelist * begin = null;
Nodelist * temp;
pour (i = 0; ivalues ​​= Myarr [i];
SorInsertion (& begin, temp);

couter<<"Sorted Circular Linked List:\n";
showlist (begin);
couter<<"\n";
retour 0;

La liste liée circulaire triée s'affiche sur l'écran suivant d'Ubuntu.

Conclusion

Cela met fin à notre discussion sur la façon d'insérer, de diviser et de trier les nœuds dans une liste liée circulaire en C++. Une liste liée circulaire est utilisée dans de nombreuses applications qui exigent beaucoup de flexibilité. J'espère que cela vous aidera à supprimer l'ambiguïté liée à la liste liée à la circulaire en C++.