Hemos discutido la introducción de listas vinculadas y la inserción de listas vinculadas en publicaciones anteriores sobre una lista vinculada individualmente.
Formulemos el enunciado del problema para comprender el proceso de eliminación. Dada una ‘clave’, elimine la primera aparición de esta clave en la lista vinculada .
Método iterativo:
para eliminar un Node de la lista vinculada, debemos realizar los siguientes pasos.
1) Busque el Node anterior del Node a eliminar.
2) Cambiar el siguiente del Node anterior.
3) Memoria libre para el Node a borrar.
Dado que cada Node de la lista vinculada se asigna dinámicamente mediante malloc() en C, debemos llamar a free() para liberar la memoria asignada para que se elimine el Node.
C++
// A complete working C++ program to
// demonstrate deletion in singly
// linked list with class
#include <bits/stdc++.h>
using namespace std;
// A linked list node
class Node{
public:
int data;
Node* next;
};
// Given a reference (pointer to pointer)
// to the head of a list and an int,
// inserts a new node on the front of the
// list.
void push(Node** head_ref, int new_data)
{
Node* new_node = new Node();
new_node->data = new_data;
new_node->next = (*head_ref);
(*head_ref) = new_node;
}
// Given a reference (pointer to pointer)
// to the head of a list and a key, deletes
// the first occurrence of key in linked list
void deleteNode(Node** head_ref, int key)
{
// Store head node
Node* temp = *head_ref;
Node* prev = NULL;
// If head node itself holds
// the key to be deleted
if (temp != NULL && temp->data == key)
{
*head_ref = temp->next; // Changed head
delete temp; // free old head
return;
}
// Else Search for the key to be deleted,
// keep track of the previous node as we
// need to change 'prev->next' */
else
{
while (temp != NULL && temp->data != key)
{
prev = temp;
temp = temp->next;
}
// If key was not present in linked list
if (temp == NULL)
return;
// Unlink the node from linked list
prev->next = temp->next;
// Free memory
delete temp;
}
}
// This function prints contents of
// linked list starting from the
// given node
void printList(Node* node)
{
while (node != NULL)
{
cout << node->data << " ";
node = node->next;
}
}
// Driver code
int main()
{
// Start with the empty list
Node* head = NULL;
// Add elements in linked list
push(&head, 7);
push(&head, 1);
push(&head, 3);
push(&head, 2);
puts("Created Linked List: ");
printList(head);
deleteNode(&head, 1);
puts("
Linked List after Deletion of 1: ");
printList(head);
return 0;
}
// This code is contributed by ac121102
Producción:
Created Linked List: 2 3 1 7 Linked List after Deletion of 1: 2 3 7
Complejidad de tiempo: O(n), donde n representa la longitud de la lista enlazada dada.
Espacio auxiliar: O(1), no se requiere espacio adicional, por lo que es una constante.
Método recursivo:
Para eliminar un Node de una lista enlazada de forma recursiva, debemos realizar los siguientes pasos.
1.Pasamos node* (puntero de Node) como referencia a la función (como en node* &head)
2.Ahora, dado que el puntero del Node actual se deriva del siguiente Node anterior (que se pasa por referencia), ahora, si se cambia el valor del puntero del Node actual, el valor del siguiente Node anterior también se cambia, que es la operación requerida al eliminar un Node (es decir, apunta el Node anterior junto al Node actual (clave que contiene) siguiente).
3.Encuentre el Node que contiene el valor dado.
4. Almacene este Node para desasignarlo más tarde usando la función free().
5. Cambie el puntero de este Node para que apunte al siguiente y, al ejecutar el siguiente Node anterior, también se vincule correctamente.
A continuación se muestra la implementación del enfoque anterior.
C++
// C++ program to delete a node in
// singly linked list recursively
#include <bits/stdc++.h>
using namespace std;
struct node {
int info;
node* link = NULL;
node() {}
node(int a)
: info(a)
{
}
};
/*
Deletes the node containing 'info' part as val and
alter the head of the linked list (recursive method)
*/
void deleteNode(node*& head, int val)
{
// Check if list is empty or we
// reach at the end of the
// list.
if (head == NULL) {
cout << "Element not present in the list
";
return;
}
// If current node is the node to be deleted
if (head->info == val) {
node* t = head;
head = head->link; // If it's start of the node head
// node points to second node
delete (t); // Else changes previous node's link to
// current node's link
return;
}
deleteNode(head->link, val);
}
// Utility function to add a
// node in the linked list
// Here we are passing head by
// reference thus no need to
// return it to the main function
void push(node*& head, int data)
{
node* newNode = new node(data);
newNode->link = head;
head = newNode;
}
// Utility function to print
// the linked list (recursive
// method)
void print(node* head)
{
// cout<<endl gets implicitly
// typecasted to bool value
// 'true'
if (head == NULL and cout << endl)
return;
cout << head->info << ' ';
print(head->link);
}
int main()
{
// Starting with an empty linked list
node* head = NULL;
// Adds new element at the
// beginning of the list
push(head, 10);
push(head, 12);
push(head, 14);
push(head, 15);
// original list
print(head);
deleteNode(head, 20); // Call to delete function
print(head); // 20 is not present thus no change in the
// list
deleteNode(head, 10);
print(head);
deleteNode(head, 14);
print(head);
return 0;
}
Producción:
Element not present in the list 15 14 12 10 15 14 12 15 12
Complejidad de tiempo: O(n), donde n representa la longitud de la lista enlazada dada.
Espacio auxiliar: O(n), debido a la pila de llamadas recursivas donde n representa la longitud de la lista enlazada dada.
Consulte el artículo completo en Lista vinculada | ¡ Establezca 3 (Eliminación de un Node) para obtener más detalles!
Publicación traducida automáticamente
Artículo escrito por GeeksforGeeks-1 y traducido por Barcelona Geeks. The original can be accessed here. Licence: CCBY-SA