Comment supprimer un nœud dans une liste liée C ++

Une liste liée est essentiellement une combinaison de deux choses: la partie d'information et la partie d'adresse. La partie d'adresse, également appelée le lien du pointeur ou du nœud suivant, stocke l'adresse du nœud suivant. La liste liée est essentiellement une structure de données linéaire qui stocke les données dynamiquement via des pointeurs qui peuvent être facilement accessibles par le pointeur de nœud précédent.

Le nœud de la liste liée ressemble à ceci:

Par rapport au tableau, la liste liée n'est pas une structure de données séquentielle car il s'agit d'une structure de données stockée dynamiquement. Il stocke toutes les données dans différents emplacements de mémoire et nous pouvons accéder à ces données via le pointeur du nœud qui stocke l'adresse des données.

Cette façon de stocker les données présente ces avantages:

1. Nous n'avons pas de taille de mémoire prédéfinie comme un tableau, ce qui conduit à beaucoup de déchets de mémoire.

2. Dans un tableau, si nous définissons une mémoire une fois, nous ne pouvons pas le réduire ou l'augmenter en fonction de nos exigences. Mais dans une liste liée, nous pouvons augmenter ou diminuer les nœuds en fonction de nos exigences.

La liste liée ressemble à ceci:

Chaque liste liée a un nœud d'en-tête qui est le premier nœud de la liste liée; et un nœud de queue qui est présent à la fin de la liste liée. À partir du nœud de queue, la liste liée pointant vers le nœud suivant est terminée car elle stocke l'adresse nulle, ce qui ne signifie rien. Si une liste liée n'a qu'un seul nœud, cela signifie que le nœud d'en-tête et le nœud de queue sont les mêmes.

Suppression d'une liste liée:

Comme indiqué ci-dessous, nous pouvons supprimer un nœud d'une liste liée de trois manières:

1. Supprimer le premier nœud de la liste liée

2. Supprimer le dernier nœud de la liste liée

3. Supprimer un nœud de position spécifique

Explication de tous ces concepts:

Supprimer le premier nœud de la liste liée (le nœud d'en-tête):-

Pour supprimer le premier nœud de la liste liée signifie supprimer le nœud d'en-tête (premier nœud) de la liste liée. Pour ce faire, nous devons suivre la procédure suivante:

un. Nous devons créer un pointeur (temporaire).

b. L'adresse du nœud d'en-tête est copiée sur le pointeur (temporaire).

c. Maintenant, nous avons stocké l'adresse du nœud d'en-tête. Ainsi, nous pouvons déclarer le nœud suivant de l'en-tête comme un premier nœud lié.

La suppression du premier nœud signifie que le nœud d'en-tête est simple:

CODE C ++ Pour supprimer le premier nœud de la liste liée:

void deleteLinkedListFirstNode ()

nœud * temporaryNode = nouveau nœud;
temporaryNode = headNode;
headnode = headnode-> suivant;
supprimer temporaryNode;

Suppression du dernier nœud (nœud de queue):

La suppression du nœud d'en-tête de la liste liée était simple. Mais lorsque nous voulions supprimer le dernier nœud ou nœud de queue de la liste liée, nous devons transférer le pointeur nul du nœud de queue au nœud précédent de la queue, qui a l'adresse du nœud de queue.

Pour implémenter cela, nous devons utiliser deux nœuds temporaires et exécuter la liste liée. Lorsque la liste liée à traverser est terminée, le nœud temporaire pointera vers le nœud actuel et un autre nœud temporaire pointera vers le nœud précédent. Maintenant, les deux nœuds requis abordent les détails que nous avons et nous pouvons supprimer le nœud de queue tout en déplaçant le pointeur nul vers le nœud précédent.

CODE C ++ Pour supprimer le dernier nœud de la liste liée:

void deleteLinkedListlastNode ()

nœud * currentNode = nouveau nœud;
Node * PREBERNODE = NOUVEAU NODE;
currentNode = headNode;
while (currentNode-> Suivant!= Null)

PREBERNODE = COURTHNODE;
current = currentNode-> Suivant;

Tail = PREVERNODE;
PREMERNNODE-> NEXT = NULL;
Supprimer CurrentNode;

Suppression du nœud en position spécifique:

Pour supprimer un nœud de n'importe où dans la liste liée, nous devons saisir la position particulière du nœud que nous voulons supprimer. Pour définir le nœud de position spécifique, nous utilisons deux nœuds temporaires, comme nous l'avons fait lors de la suppression du nœud de queue. Nous traversons toute la liste liée jusqu'à ce que nous n'obtenons pas le nœud de position spécifique que nous voulons supprimer, et après avoir obtenu ce nœud, l'autre nœud temporaire contiendra l'adresse du nœud précédent du nœud actuel. Maintenant, comme nous avons les deux détails de nœud, nous pouvons facilement déplacer l'adresse du nœud de suppression vers le nœud d'adresse précédent, qui pointera désormais vers le nœud suivant, tout comme dans la méthode supprimée précédente du dernier nœud.

CODE C ++ Pour supprimer le nœud du Nd de la liste liée:

void DeletentHPositionNode (int positionNumber)
nœud * currentNode = nouveau nœud;
Node * PREBERNODE = NOUVEAU NODE;
currentNode = headNode;
pour (int count = 1; iPREBERNODE = COURTHNODE;
currentNode = currentNode-> Suivant;

PREMERNNODE-> NEXT = COURTYNODE-> NEXT;

Programme C ++ pour supprimer un nœud du Nd de la liste liée

#inclure
Utilisation de Namespace Std;
classe LinkedListNode
public:
INT INFO;
Pointer LinkedListNode *;
;
int longueur LongsCalculate (nœud LinkedListNode *)
int count = 0;
while (nœud!= Null)
node = node-> pointeur;
Count ++;

Return Count;

void insert (LinkedListNode ** headnode, int info)
LinkedListNode * newNode = new LinkedListNode ();
newNode-> info = info;
newNode-> pointer = * headnode;
* headnode = newNode;

void DeletenodeMethod (int count, linkedListNode ** headnode)
LinkedListNode * temporaryNode = * headNode;
LinkedListNode * PREVERNODE;
int longueur = longueur de longueur (* headnode);
Si (compter < 1 || count > longueur)
couter << "Deletion of linked list node is not valid" << endl;
retour;

// Cette Fucntion supprimera le premier nœud de la liste liée
if (count == 1)
* headnode = (* headnode) -> pointeur;
couter << temporaryNode->Info << " deleted the linked first node" << endl;
supprimer (temporaryNode);
retour;

// tandis que la boucle s'arrêtera lorsqu'il sera atteint au
// fin de la liste liée
while (--COUNT)
PREMERNNODE = temporaryNode;
temporaryNode = temporaryNode-> pointeur;

// Cette ligne mettra à jour le pointeur précédent
// avec le pointeur de nœud lié nth lié
PREBERNODE-> pointer = temporaryNode-> pointeur;
// Ce code supprimera le nième nœud de la liste liée
couter << temporaryNode->Info << " deleted" << endl;;
supprimer (temporaryNode);

void displayLinkedList (LinkedListNode * item)
couter << "\nDisplaying LinkedList => : ";
// Cette condition s'arrêtera lorsque LinkedList a atteint à la fin
Pendant (article!= Null)
couter << item->Info << " ";
item = item-> pointeur;

couter << endl;

int main()
LinkedListNode * headnode = null;
insérer (& headnode, 29);
insérer (& headnode, 34);
insérer (& headnode, 23);
insérer (& headnode, 27);
insérer (& headnode, 31);
insérer (& headnode, 50);
DisplayLinkedList (HeadNode);
couter << "\n Deleting node number 3 = ";
DeletenodeMethod (3, & headnode);
couter << "\n After delete node number 3, linked list will be =";
DisplayLinkedList (HeadNode);
couter << "\n Deleting node number 5 = ";
DeletenodeMethod (5, & headnode);
couter << "\n After delete node number 5, linked list will be =";
DisplayLinkedList (HeadNode);
retour 0;

Sortir:

Affichage de LinkedList =>: 50 31 27 23 34 29
Suppression du nœud numéro 3 = 27 supprimé
Après la suppression du nœud numéro 3, la liste liée sera =
Affichage de LinkedList =>: 50 31 23 34 29
Suppression du nœud numéro 5 = 29 supprimé
Après supprimer le nœud numéro 5, la liste liée sera =
Affichage de LinkedList =>: 50 31 23 34

Conclusion:

Dans ce blog, nous avons étudié différentes façons de supprimer les concepts de liste liés et comment nous pouvons également coder dans un programme C ++. Enfin, nous avons étudié les principaux concepts de supprimer le nœud d'une position particulière. Les concepts de liste liés sont toujours importants car c'est la façon de jouer avec la mémoire du système d'exploitation et a beaucoup d'avantages par rapport au tableau.