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 .
Eliminar de una lista vinculada: –
Puede eliminar un elemento de una lista desde:
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("\nLinked List after Deletion of 1: ");
printList(head);
return 0;
}
// This code is contributed by ac121102
C
// A complete working C program
// to demonstrate deletion in
// singly linked list
#include <stdio.h>
#include <stdlib.h>
// A linked list node
struct Node {
int data;
struct 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(struct Node** head_ref, int new_data)
{
struct Node* new_node
= (struct Node*)malloc(sizeof(struct 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(struct Node** head_ref, int key)
{
// Store head node
struct Node *temp = *head_ref, *prev;
// If head node itself holds the key to be deleted
if (temp != NULL && temp->data == key) {
*head_ref = temp->next; // Changed head
free(temp); // free old head
return;
}
// Search for the key to be deleted, keep track of the
// previous node as we need to change 'prev->next'
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(temp); // Free memory
}
// This function prints contents of linked list starting
// from the given node
void printList(struct Node* node)
{
while (node != NULL) {
printf(" %d ", node->data);
node = node->next;
}
}
// Driver code
int main()
{
/* Start with the empty list */
struct Node* head = NULL;
push(&head, 7);
push(&head, 1);
push(&head, 3);
push(&head, 2);
puts("Created Linked List: ");
printList(head);
deleteNode(&head, 1);
puts("\nLinked List after Deletion of 1: ");
printList(head);
return 0;
}
Java
// A complete working Java program
// to demonstrate deletion
// in singly linked list
class LinkedList {
Node head; // head of list
/* Linked list Node*/
class Node {
int data;
Node next;
Node(int d)
{
data = d;
next = null;
}
}
/* Given a key, deletes the first
occurrence of key in
* linked list */
void deleteNode(int key)
{
// Store head node
Node temp = head, prev = null;
// If head node itself holds the key to be deleted
if (temp != null && temp.data == key) {
head = temp.next; // Changed head
return;
}
// Search for the key to be deleted, keep track of
// the previous node as we need to change temp.next
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;
}
/* Inserts a new Node at front of the list. */
public void push(int new_data)
{
Node new_node = new Node(new_data);
new_node.next = head;
head = new_node;
}
/* This function prints contents of linked list starting
from the given node */
public void printList()
{
Node tnode = head;
while (tnode != null) {
System.out.print(tnode.data + " ");
tnode = tnode.next;
}
}
/* Driver program to test above functions. Ideally this
function should be in a separate user class. It is kept
here to keep code compact */
public static void main(String[] args)
{
LinkedList llist = new LinkedList();
llist.push(7);
llist.push(1);
llist.push(3);
llist.push(2);
System.out.println("\nCreated Linked list is:");
llist.printList();
llist.deleteNode(1); // Delete node with data 1
System.out.println(
"\nLinked List after Deletion of 1:");
llist.printList();
}
}
Python3
# A complete working Python3 program to
# demonstrate deletion in singly
# linked list with class
# Node class
class Node:
# Constructor to initialize the node object
def __init__(self, data):
self.data = data
self.next = None
class LinkedList:
# Function to initialize head
def __init__(self):
self.head = None
# Function to insert a new node at the beginning
def push(self, new_data):
new_node = Node(new_data)
new_node.next = self.head
self.head = new_node
# Given a reference to the head of a list and a key,
# delete the first occurrence of key in linked list
def deleteNode(self, key):
# Store head node
temp = self.head
# If head node itself holds the key to be deleted
if (temp is not None):
if (temp.data == key):
self.head = temp.next
temp = None
return
# Search for the key to be deleted, keep track of the
# previous node as we need to change 'prev.next'
while(temp is not None):
if temp.data == key:
break
prev = temp
temp = temp.next
# if key was not present in linked list
if(temp == None):
return
# Unlink the node from linked list
prev.next = temp.next
temp = None
# Utility function to print the linked LinkedList
def printList(self):
temp = self.head
while(temp):
print (" %d" %(temp.data)),
temp = temp.next
# Driver program
llist = LinkedList()
llist.push(7)
llist.push(1)
llist.push(3)
llist.push(2)
print ("Created Linked List: ")
llist.printList()
llist.deleteNode(1)
print ("\nLinked List after Deletion of 1:")
llist.printList()
# This code is contributed by Nikhil Kumar Singh (nickzuck_007)
C#
// A complete working C# program
// to demonstrate deletion in
// singly linked list
using System;
class GFG{
// Head of list
Node head;
// Linked list Node
public class Node
{
public int data;
public Node next;
public Node(int d)
{
data = d;
next = null;
}
}
// Given a key, deletes the first
// occurrence of key in linked list
void deleteNode(int key)
{
// Store head node
Node temp = head, prev = null;
// If head node itself holds
// the key to be deleted
if (temp != null &&
temp.data == key)
{
// Changed head
head = temp.next;
return;
}
// Search for the key to be
// deleted, keep track of the
// previous node as we need
// to change temp.next
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;
}
// Inserts a new Node at
// front of the list.
public void Push(int new_data)
{
Node new_node = new Node(new_data);
new_node.next = head;
head = new_node;
}
// This function prints contents
// of linked list starting from
// the given node
public void printList()
{
Node tnode = head;
while (tnode != null)
{
Console.Write(tnode.data + " ");
tnode = tnode.next;
}
}
// Driver code
public static void Main(String[] args)
{
GFG llist = new GFG();
llist.Push(7);
llist.Push(1);
llist.Push(3);
llist.Push(2);
Console.WriteLine("\nCreated Linked list is:");
llist.printList();
// Delete node with data 1
llist.deleteNode(1);
Console.WriteLine("\nLinked List after Deletion of 1:");
llist.printList();
}
}
// This code is contributed by Rajput-Ji
Javascript
<script>
// A complete working javascript program
// to demonstrate deletion
// in singly linked list
var head; // head of list
/* Linked list Node */
class Node {
constructor(val) {
this.data = val;
this.next = null;
}
}
/*
* Given a key, deletes the first occurrence of key in linked list
*/
function deleteNode(key) {
// Store head node
var temp = head, prev = null;
// If head node itself holds the key to be deleted
if (temp != null && temp.data == key) {
head = temp.next; // Changed head
return;
}
// Search for the key to be deleted, keep track of
// the previous node as we need to change temp.next
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;
}
/* Inserts a new Node at front of the list. */
function push(new_data) {
var new_node = new Node(new_data);
new_node.next = head;
head = new_node;
}
/*
* This function prints contents of linked list starting from the given node
*/
function printList() {
tnode = head;
while (tnode != null) {
document.write(tnode.data + " ");
tnode = tnode.next;
}
}
/*
* Driver program to test above functions. Ideally this function should be in a
* separate user class. It is kept here to keep code compact
*/
push(7);
push(1);
push(3);
push(2);
document.write("Created Linked list is:<br/>");
printList();
deleteNode(1); // Delete node with data 1
document.write("<br/>Linked List after Deletion of 1:<br/>");
printList();
// This code is contributed by todaysgaurav
</script>
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\n";
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;
}
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