Delete node from linked list with specific value C++

// A complete working C++ program to delete

// a node in a linked list at a given position

#include

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 position, deletes

// the node at the given position

void deleteNode[Node** head_ref, int position]

{

// If linked list is empty

if [*head_ref == NULL]

return;

// Store head node

Node* temp = *head_ref;

// If head needs to be removed

if [position == 0] {

// Change head

*head_ref = temp->next;

// Free old head

free[temp];

return;

}

// Find previous node of the node to be deleted

for [int i = 0; temp != NULL && i < position - 1; i++]

temp = temp->next;

// If position is more than number of nodes

if [temp == NULL || temp->next == NULL]

return;

// Node temp->next is the node to be deleted

// Store pointer to the next of node to be deleted

Node* next = temp->next->next;

// Unlink the node from linked list

free[temp->next]; // Free memory

// Unlink the deleted node from list

temp->next = next;

}

// This function prints contents of linked

// list starting from the given node

void printList[Node* node]

{

while [node != NULL] {

cout data next;

}

}

// Driver code

int main[]

{

// Start with the empty list

Node* head = NULL;

push[&head, 7];

push[&head, 1];

push[&head, 3];

push[&head, 2];

push[&head, 8];

cout next; // Advancing the head pointer

temp->next=NULL;

free[temp]; // Node is deleted

}

else

{

for[i=0;inext;

}

// Now temp pointer points to the previous node of the node to be deleted

struct node *del =temp->next; // del pointer points to the node to be deleted

temp->next=temp->next->next;

printf["\nElement deleted is : %d\n",del->data];

del->next=NULL;

free[del]; // Node is deleted

}

printf["\nUpdated Linked List is : \n"];

display_List[];

return ;

}

void insert[int value]

{

struct node *newnode; // Creating a new node

newnode = [struct node *]malloc[sizeof[struct node]]; // Allocating dynamic memory

newnode->data = value; // Assigning value to newnode

newnode->next = NULL;

if[head==NULL] // Checking if List is empty

{

head = newnode;

tail = newnode;

}

else // If not empty then...

{

tail->next=newnode;

tail=newnode; // Updating the tail node with each insertion

}

return ;

}

void display_List[]

{

struct node *temp; // Creating a temporary pointer to the structure

temp=head; // temp points to head;

while[temp!=NULL]

{

if[temp->next==NULL]

{

printf[" %d->NULL",temp->data];

}

else

{

printf[" %d->",temp->data];

}

temp=temp->next; // Traversing the List till end

}

printf["\n"];

return ;

}

// --Driver Code--

int main[]

{

insert[10];

insert[20];

insert[30];

insert[40];

insert[50];

insert[60];

printf["\n--Created Linked List--\n"];

display_List[];

printf["\nLinked List after deletion at position 0"];

delete[0]; // List indexing starts from 0

printf["\nLinked List after deletion at position 2"];

delete[2];

return 0;

}

// This code is contributed by Sanjeeban Mukhopadhyay.

// A complete working Java program to delete a node in a

// linked list at a given position

class LinkedList {

Node head; // head of list

/* Linked list Node*/

class Node {

int data;

Node next;

Node[int d]

{

data = d;

next = null;

}

}

/* Inserts a new Node at front of the list. */

public void push[int new_data]

{

/* 1 & 2: Allocate the Node &

Put in the data*/

Node new_node = new Node[new_data];

/* 3. Make next of new Node as head */

new_node.next = head;

/* 4. Move the head to point to new Node */

head = new_node;

}

/* Given a reference [pointer to pointer] to the head of

a list

and a position, deletes the node at the given

position */

void deleteNode[int position]

{

// If linked list is empty

if [head == null]

return;

// Store head node

Node temp = head;

// If head needs to be removed

if [position == 0] {

head = temp.next; // Change head

return;

}

// Find previous node of the node to be deleted

for [int i = 0; temp != null && i < position - 1;

i++]

temp = temp.next;

// If position is more than number of nodes

if [temp == null || temp.next == null]

return;

// Node temp->next is the node to be deleted

// Store pointer to the next of node to be deleted

Node next = temp.next.next;

temp.next

= next; // Unlink the deleted node from list

}

/* 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]

{

/* Start with the empty list */

LinkedList llist = new LinkedList[];

llist.push[7];

llist.push[1];

llist.push[3];

llist.push[2];

llist.push[8];

System.out.println["\nCreated Linked list is: "];

llist.printList[];

llist.deleteNode[4]; // Delete node at position 4

System.out.println[

"\nLinked List after Deletion at position 4: "];

llist.printList[];

}

}

# Python program to delete a node in a linked list

# at a given position

# Node class

class Node:

# Constructor to initialize the node object

def __init__[self, data]:

self.data = data

self.next = None

class LinkedList:

# Constructor 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 position, delete the node at a given position

#This delete function code is contributed by Arabin Islam

def deleteNode[self, position]:

if self.head is None:

return

if position == 0:

self.head = self.head.next

return self.head

index = 0

current = self.head

prev = self.head

temp = self.head

while current is not None:

if index == position:

temp = current.next

break

prev = current

current = current.next

index += 1

prev.next = temp

return prev

# Utility function to print the linked LinkedList

def printList[self]:

temp = self.head

while[temp]:

print [" %d " % [temp.data],end=" "]

temp = temp.next

# Driver program to test above function

llist = LinkedList[]

llist.push[7]

llist.push[1]

llist.push[3]

llist.push[2]

llist.push[8]

print ["Created Linked List: "]

llist.printList[]

llist.deleteNode[4]

print ["\nLinked List after Deletion at position 4: "]

llist.printList[]

# This code is contributed by Nikhil Kumar Singh[nickzuck_007]

// A complete working C# program to delete

// a node in a linked list at a given position

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;

}

}

// Inserts a new Node at front of the list.

public void Push[int new_data]

{

/* 1 & 2: Allocate the Node &

Put in the data*/

Node new_node = new Node[new_data];

/* 3. Make next of new Node as head */

new_node.next = head;

/* 4. Move the head to point to new Node */

head = new_node;

}

// Given a reference [pointer to pointer]

// to the head of a list and a position,

// deletes the node at the given position

void deleteNode[int position]

{

// If linked list is empty

if [head == null]

return;

// Store head node

Node temp = head;

// If head needs to be removed

if [position == 0] {

// Change head

head = temp.next;

return;

}

// Find previous node of the node to be deleted

for [int i = 0; temp != null && i < position - 1;

i++]

temp = temp.next;

// If position is more than number of nodes

if [temp == null || temp.next == null]

return;

// Node temp->next is the node to be deleted

// Store pointer to the next of node to be deleted

Node next = temp.next.next;

// Unlink the deleted node from list

temp.next = next;

}

// 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]

{

// Start with the empty list

GFG llist = new GFG[];

llist.Push[7];

llist.Push[1];

llist.Push[3];

llist.Push[2];

llist.Push[8];

Console.WriteLine["\nCreated Linked list is: "];

llist.printList[];

// Delete node at position 4

llist.deleteNode[4];

Console.WriteLine["\nLinked List after "

+ "Deletion at position 4: "];

llist.printList[];

}

}

// This code is contributed by Rajput-Ji

// A complete working javascript program to

// delete a node in a linked list at a

// given position

// head of list

var head;

/* Linked list Node */

class Node

{

constructor[val]

{

this.data = val;

this.next = null;

}

}

/* Inserts a new Node at front of the list. */

function push[new_data]

{

/*

* 1 & 2: Allocate the Node & Put in the data

*/

var new_node = new Node[new_data];

/* 3. Make next of new Node as head */

new_node.next = head;

/* 4. Move the head to point to new Node */

head = new_node;

}

/*

* Given a reference [pointer to pointer] to the

* head of a list and a position,

* deletes the node at the given position

*/

function deleteNode[position]

{

// If linked list is empty

if [head == null]

return;

// Store head node

var temp = head;

// If head needs to be removed

if [position == 0]

{

// Change head

head = temp.next;

return;

}

// Find previous node of the node to be deleted

for[i = 0; temp != null && i < position - 1; i++]

temp = temp.next;

// If position is more than number of nodes

if [temp == null || temp.next == null]

return;

// Node temp->next is the node to be deleted

// Store pointer to the next of node to be deleted

var next = temp.next.next;

// Unlink the deleted node from list

temp.next = next;

}

/*

* This function prints contents of linked

* list starting from the given node

*/

function printList[]

{

var 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

*/

/* Start with the empty list */

push[7];

push[1];

push[3];

push[2];

push[8];

document.write["Created Linked list is:
"];

printList[];

// Delete node at position 4

deleteNode[4];

document.write["
Linked List after " +

"Deletion at position 4:
"];

printList[];

// This code is contributed by todaysgaurav