Delete even nodes from linked list

Here given code implementation process.

// C Program
// Delete even nodes from linked list
#include <stdio.h>
 //For malloc function
#include <stdlib.h>

//Linked List Node
struct Node
{
	int data;
	struct Node *next;
};
//Create a node of linked list
struct Node *create_node(int data)
{
	//Create dynamic node
	struct Node *node = (struct Node *) malloc(sizeof(struct Node));
	if (node == NULL)
	{
		printf("Memory overflow\n");
	}
	else
	{
		//Set initial node value
		node->data = data;
		node->next = NULL;
	}
	return node;
}
//Add new node at end of linked list 
void add_node(struct Node **head, int data)
{
	struct Node *node = create_node(data);
	if ( *head == NULL)
	{
		*head = node;
	}
	else
	{
		struct Node *temp = *head;
		//Find last node
		while (temp->next != NULL)
		{
			temp = temp->next;
		}
		//Add node at last possition
		temp->next = node;
	}
}
//Display linked list element
void display(struct Node *head)
{
	if (head == NULL)
	{
		printf("\nEmpty linked list\n");
		return;
	}
	struct Node *temp = head;
	//iterating linked list elements
	while (temp != NULL)
	{
		if (temp != head)
		{
			printf(" →");
		}
		printf(" %d", temp->data);
		//visit to next node
		temp = temp->next;
	}
	printf(" → NULL\n");
}
//Delete all Even key nodes in linked list
struct Node *delete_even_nodes(struct Node *head)
{
	//Define some auxiliary variables
	struct Node *current = head;
	struct Node *auxiliary = NULL;
	struct Node *back = NULL;
	//iterating linked list elements
	while (current != NULL)
	{
		if (current->data % 2 == 0)
		{
			//When get even node
			auxiliary = current;
		}
		else
		{
			back = current;
		}
		//visit to next node
		current = current->next;
		if (auxiliary != NULL)
		{
			//When Deleted node exists
			if (back == NULL)
			{
				// When front node is even node
				// head visit to next node
				head = current;
			}
			else
			{
				// Deleted node are exist in intermediate or last position of linked list
				// Before delete node, there left node is connecting to next upcoming node
				back->next = current;
			}
			//unlink deleted node 
			auxiliary->next = NULL;
			//free node
			free(auxiliary);
			auxiliary = NULL;
		}
	}
	return head;
}
int main()
{
	struct Node *head = NULL;
	//Add linked list node
	add_node( &head, 8);
	add_node( &head, 1);
	add_node( &head, 4);
	add_node( &head, 3);
	add_node( &head, 9);
	add_node( &head, 7);
	add_node( &head, 5);
	add_node( &head, 6);
	//Before effect
	printf(" Before Delete Even Key Nodes\n");
	// 8 → 1 → 4 → 3 → 9 → 7 → 5 → 6 → NULL
	display(head);
	// Perform delete operation
	head = delete_even_nodes(head);
	//After effect
	printf(" After Delete Even Key Nodes\n");
	// 1 → 3 → 9 → 7 → 5 → NULL
	display(head);
	return 0;
}

Output

 Before Delete Even Key Nodes
 8 → 1 → 4 → 3 → 9 → 7 → 5 → 6 → NULL
 After Delete Even Key Nodes
 1 → 3 → 9 → 7 → 5 → NULL
// Java Program
// Delete even nodes from linked list

//Node of LinkedList
class Node
{
	public int data;
	public Node next;
	public Node(int data)
	{
		//Set node value
		this.data = data;
		this.next = null;
	}
}
class MyLinkedList
{
	public Node head;
	public Node tail;
	//Class constructor
	public MyLinkedList()
	{
		this.head = null;
		this.tail = null;
	}
	//insert node at last of linke list
	public void add_node(int data)
	{
		//Create a node
		Node node = new Node(data);
		if (this.head == null)
		{
			//When linked list empty add first node
			this.head = node;
			this.tail = node;
		}
		else
		{
			//Add new node at end of linked list
			this.tail.next = node;
			this.tail = node;
		}
	}
	//Display linked list element
	public void display()
	{
		if (this.head == null)
		{
			System.out.print("\nEmpty linked list\n");
			return;
		}
		Node temp = this.head;
		System.out.print(" Linked List : ");
		//iterating linked list elements
		while (temp != null)
		{
			if (temp != this.head)
			{
				System.out.print(" →");
			}
			System.out.print(" " + temp.data);
			//visit to next node
			temp = temp.next;
		}
		System.out.print(" → NULL\n");
	}
	//Delete all Even key nodes in linked list
	public void delete_even_nodes()
	{
		//Define some auxiliary variables
		Node current = this.head;
		Node auxiliary = null;
		Node back = null;
		//iterating linked list elements
		while (current != null)
		{
			if (current.data % 2 == 0)
			{
				//When get even node
				auxiliary = current;
			}
			else
			{
				back = current;
			}
			//visit to next node
			current = current.next;
			if (auxiliary != null)
			{
				//When Deleted node exists
				if (back == null)
				{
					// When front node is even node
					// head visit to next node
					this.head = current;
				}
				else
				{
					// Deleted node are exist in intermediate or last position of linked list
					// Before delete node, there left node is connecting to next upcoming node
					back.next = current;
				}
				//unlink deleted node 
				auxiliary.next = null;
				//free node
				auxiliary = null;
			}
		}
	}
	public static void main(String[] args)
	{
		MyLinkedList obj = new MyLinkedList();
		//Add linked list node
		obj.add_node(8);
		obj.add_node(1);
		obj.add_node(4);
		obj.add_node(3);
		obj.add_node(9);
		obj.add_node(7);
		obj.add_node(5);
		obj.add_node(6);
		//Before effect
		System.out.print(" Before Delete Even Key Nodes\n");
		// 8 → 1 → 4 → 3 → 9 → 7 → 5 → 6 → NULL
		obj.display();
		// Perform delete operation
		obj.delete_even_nodes();
		//After effect
		System.out.print(" After Delete Even Key Nodes\n");
		// 1 → 3 → 9 → 7 → 5 → NULL
		obj.display();
	}
}

Output

 Before Delete Even Key Nodes
 Linked List :  8 → 1 → 4 → 3 → 9 → 7 → 5 → 6 → NULL
 After Delete Even Key Nodes
 Linked List :  1 → 3 → 9 → 7 → 5 → NULL
//Include header file
#include <iostream>

using namespace std;
// C++ Program
// Delete even nodes from linked list

//Node of LinkedList
class Node
{
	public: int data;
	Node *next;
	Node(int data)
	{
		//Set node value
		this->data = data;
		this->next = NULL;
	}
};
class MyLinkedList
{
	public: Node *head;
	Node *tail;
	//Class constructor
	MyLinkedList()
	{
		this->head = NULL;
		this->tail = NULL;
	}
	//insert node at last of linke list
	void add_node(int data)
	{
		//Create a node
		Node *node = new Node(data);
		if (this->head == NULL)
		{
			//When linked list empty add first node
			this->head = node;
			this->tail = node;
		}
		else
		{
			//Add new node at end of linked list
			this->tail->next = node;
			this->tail = node;
		}
	}
	//Display linked list element
	void display()
	{
		if (this->head == NULL)
		{
			cout << "\nEmpty linked list\n";
			return;
		}
		Node *temp = this->head;
		cout << " Linked List : ";
		//iterating linked list elements
		while (temp != NULL)
		{
			if (temp != this->head)
			{
				cout << " →";
			}
			cout << " " << temp->data;
			//visit to next node
			temp = temp->next;
		}
		cout << " → NULL\n";
	}
	//Delete all Even key nodes in linked list
	void delete_even_nodes()
	{
		//Define some auxiliary variables
		Node *current = this->head;
		Node *auxiliary = NULL;
		Node *back = NULL;
		//iterating linked list elements
		while (current != NULL)
		{
			if (current->data % 2 == 0)
			{
				//When get even node
				auxiliary = current;
			}
			else
			{
				back = current;
			}
			//visit to next node
			current = current->next;
			if (auxiliary != NULL)
			{
				//When Deleted node exists
				if (back == NULL)
				{
					// When front node is even node
					// head visit to next node
					this->head = current;
				}
				else
				{
					// Deleted node are exist in intermediate or last position of linked list
					// Before delete node, there left node is connecting to next upcoming node
					back->next = current;
				}
				//unlink deleted node 
				auxiliary->next = NULL;
				//free node
				auxiliary = NULL;
			}
		}
	}
};
int main()
{
	MyLinkedList obj = MyLinkedList();
	//Add linked list node
	obj.add_node(8);
	obj.add_node(1);
	obj.add_node(4);
	obj.add_node(3);
	obj.add_node(9);
	obj.add_node(7);
	obj.add_node(5);
	obj.add_node(6);
	//Before effect
	cout << " Before Delete Even Key Nodes\n";
	// 8 → 1 → 4 → 3 → 9 → 7 → 5 → 6 → NULL
	obj.display();
	// Perform delete operation
	obj.delete_even_nodes();
	//After effect
	cout << " After Delete Even Key Nodes\n";
	// 1 → 3 → 9 → 7 → 5 → NULL
	obj.display();
	return 0;
}

Output

 Before Delete Even Key Nodes
 Linked List :  8 → 1 → 4 → 3 → 9 → 7 → 5 → 6 → NULL
 After Delete Even Key Nodes
 Linked List :  1 → 3 → 9 → 7 → 5 → NULL
//Include namespace system
using System;
// C# Program
// Delete even nodes from linked list
//Node of LinkedList
class Node
{
	public int data;
	public Node next;
	public Node(int data)
	{
		//Set node value
		this.data = data;
		this.next = null;
	}
}
class MyLinkedList
{
	public Node head;
	public Node tail;
	//Class constructor
	public MyLinkedList()
	{
		this.head = null;
		this.tail = null;
	}
	//insert node at last of linke list
	public void add_node(int data)
	{
		//Create a node
		Node node = new Node(data);
		if (this.head == null)
		{
			//When linked list empty add first node
			this.head = node;
			this.tail = node;
		}
		else
		{
			//Add new node at end of linked list
			this.tail.next = node;
			this.tail = node;
		}
	}
	//Display linked list element
	public void display()
	{
		if (this.head == null)
		{
			Console.Write("\nEmpty linked list\n");
			return;
		}
		Node temp = this.head;
		Console.Write(" Linked List : ");
		//iterating linked list elements
		while (temp != null)
		{
			if (temp != this.head)
			{
				Console.Write(" →");
			}
			Console.Write(" " + temp.data);
			//visit to next node
			temp = temp.next;
		}
		Console.Write(" → NULL\n");
	}
	//Delete all Even key nodes in linked list
	public void delete_even_nodes()
	{
		//Define some auxiliary variables
		Node current = this.head;
		Node auxiliary = null;
		Node back = null;
		//iterating linked list elements
		while (current != null)
		{
			if (current.data % 2 == 0)
			{
				//When get even node
				auxiliary = current;
			}
			else
			{
				back = current;
			}
			//visit to next node
			current = current.next;
			if (auxiliary != null)
			{
				//When Deleted node exists
				if (back == null)
				{
					// When front node is even node
					// head visit to next node
					this.head = current;
				}
				else
				{
					// Deleted node are exist in intermediate or last position of linked list
					// Before delete node, there left node is connecting to next upcoming node
					back.next = current;
				}
				//unlink deleted node 
				auxiliary.next = null;
				//free node
				auxiliary = null;
			}
		}
	}
	public static void Main(String[] args)
	{
		MyLinkedList obj = new MyLinkedList();
		//Add linked list node
		obj.add_node(8);
		obj.add_node(1);
		obj.add_node(4);
		obj.add_node(3);
		obj.add_node(9);
		obj.add_node(7);
		obj.add_node(5);
		obj.add_node(6);
		//Before effect
		Console.Write(" Before Delete Even Key Nodes\n");
		// 8 → 1 → 4 → 3 → 9 → 7 → 5 → 6 → NULL
		obj.display();
		// Perform delete operation
		obj.delete_even_nodes();
		//After effect
		Console.Write(" After Delete Even Key Nodes\n");
		// 1 → 3 → 9 → 7 → 5 → NULL
		obj.display();
	}
}

Output

 Before Delete Even Key Nodes
 Linked List :  8 → 1 → 4 → 3 → 9 → 7 → 5 → 6 → NULL
 After Delete Even Key Nodes
 Linked List :  1 → 3 → 9 → 7 → 5 → NULL
<?php
// Php Program
// Delete even nodes from linked list

//Node of LinkedList
class Node
{
	public $data;
	public $next;

	function __construct($data)
	{
		//Set node value
		$this->data = $data;
		$this->next = null;
	}
}
class MyLinkedList
{
	public $head;
	public $tail;
	//Class constructor
	function __construct()
	{
		$this->head = null;
		$this->tail = null;
	}
	//insert node at last of linke list
	public	function add_node($data)
	{
		//Create a node
		$node = new Node($data);
		if ($this->head == null)
		{
			//When linked list empty add first node
			$this->head = $node;
			$this->tail = $node;
		}
		else
		{
			//Add new node at end of linked list
			$this->tail->next = $node;
			$this->tail = $node;
		}
	}
	//Display linked list element
	public	function display()
	{
		if ($this->head == null)
		{
			echo "\nEmpty linked list\n";
			return;
		}
		$temp = $this->head;
		echo " Linked List : ";
		//iterating linked list elements
		while ($temp != null)
		{
			if ($temp != $this->head)
			{
				echo " →";
			}
			echo " ". $temp->data;
			//visit to next node
			$temp = $temp->next;
		}
		echo " → NULL\n";
	}
	//Delete all Even key nodes in linked list
	public	function delete_even_nodes()
	{
		//Define some auxiliary variables
		$current = $this->head;
		$auxiliary = null;
		$back = null;
		//iterating linked list elements
		while ($current != null)
		{
			if ($current->data % 2 == 0)
			{
				//When get even node
				$auxiliary = $current;
			}
			else
			{
				$back = $current;
			}
			//visit to next node
			$current = $current->next;
			if ($auxiliary != null)
			{
				//When Deleted node exists
				if ($back == null)
				{
					// When front node is even node
					// head visit to next node
					$this->head = $current;
				}
				else
				{
					// Deleted node are exist in intermediate or last position of linked list
					// Before delete node, there left node is connecting to next upcoming node
					$back->next = $current;
				}
				//unlink deleted node 
				$auxiliary->next = null;
				//free node
				$auxiliary = null;
			}
		}
	}
}

function main()
{
	$obj = new MyLinkedList();
	//Add linked list node
	$obj->add_node(8);
	$obj->add_node(1);
	$obj->add_node(4);
	$obj->add_node(3);
	$obj->add_node(9);
	$obj->add_node(7);
	$obj->add_node(5);
	$obj->add_node(6);
	//Before effect
	echo " Before Delete Even Key Nodes\n";
	// 8 → 1 → 4 → 3 → 9 → 7 → 5 → 6 → NULL
	$obj->display();
	// Perform delete operation
	$obj->delete_even_nodes();
	//After effect
	echo " After Delete Even Key Nodes\n";
	// 1 → 3 → 9 → 7 → 5 → NULL
	$obj->display();
}
main();

Output

 Before Delete Even Key Nodes
 Linked List :  8 → 1 → 4 → 3 → 9 → 7 → 5 → 6 → NULL
 After Delete Even Key Nodes
 Linked List :  1 → 3 → 9 → 7 → 5 → NULL
// Node Js Program
// Delete even nodes from linked list

//Node of LinkedList
class Node
{
	constructor(data)
	{
		//Set node value
		this.data = data;
		this.next = null;
	}
}
class MyLinkedList
{
	//Class constructor
	constructor()
	{
		this.head = null;
		this.tail = null;
	}
	//insert node at last of linke list
	add_node(data)
	{
		//Create a node
		var node = new Node(data);
		if (this.head == null)
		{
			//When linked list empty add first node
			this.head = node;
			this.tail = node;
		}
		else
		{
			//Add new node at end of linked list
			this.tail.next = node;
			this.tail = node;
		}
	}
	//Display linked list element
	display()
	{
		if (this.head == null)
		{
			process.stdout.write("\nEmpty linked list\n");
			return;
		}
		var temp = this.head;
		process.stdout.write(" Linked List : ");
		//iterating linked list elements
		while (temp != null)
		{
			if (temp != this.head)
			{
				process.stdout.write(" →");
			}
			process.stdout.write(" " + temp.data);
			//visit to next node
			temp = temp.next;
		}
		process.stdout.write(" → NULL\n");
	}
	//Delete all Even key nodes in linked list
	delete_even_nodes()
	{
		//Define some auxiliary variables
		var current = this.head;
		var auxiliary = null;
		var back = null;
		//iterating linked list elements
		while (current != null)
		{
			if (current.data % 2 == 0)
			{
				//When get even node
				auxiliary = current;
			}
			else
			{
				back = current;
			}
			//visit to next node
			current = current.next;
			if (auxiliary != null)
			{
				//When Deleted node exists
				if (back == null)
				{
					// When front node is even node
					// head visit to next node
					this.head = current;
				}
				else
				{
					// Deleted node are exist in intermediate or last position of linked list
					// Before delete node, there left node is connecting to next upcoming node
					back.next = current;
				}
				//unlink deleted node 
				auxiliary.next = null;
				//free node
				auxiliary = null;
			}
		}
	}
}

function main()
{
	var obj = new MyLinkedList();
	//Add linked list node
	obj.add_node(8);
	obj.add_node(1);
	obj.add_node(4);
	obj.add_node(3);
	obj.add_node(9);
	obj.add_node(7);
	obj.add_node(5);
	obj.add_node(6);
	//Before effect
	process.stdout.write(" Before Delete Even Key Nodes\n");
	// 8 → 1 → 4 → 3 → 9 → 7 → 5 → 6 → NULL
	obj.display();
	// Perform delete operation
	obj.delete_even_nodes();
	//After effect
	process.stdout.write(" After Delete Even Key Nodes\n");
	// 1 → 3 → 9 → 7 → 5 → NULL
	obj.display();
}
main();

Output

 Before Delete Even Key Nodes
 Linked List :  8 → 1 → 4 → 3 → 9 → 7 → 5 → 6 → NULL
 After Delete Even Key Nodes
 Linked List :  1 → 3 → 9 → 7 → 5 → NULL
#  Python 3 Program
#  Delete even nodes from linked list

# Node of LinkedList
class Node :
	
	def __init__(self, data) :
		# Set node value
		self.data = data
		self.next = None
	

class MyLinkedList :
	
	# Class constructor
	def __init__(self) :
		self.head = None
		self.tail = None
	
	# insert node at last of linke list
	def add_node(self, data) :
		# Create a node
		node = Node(data)
		if (self.head == None) :
			# When linked list empty add first node
			self.head = node
			self.tail = node
		else :
			# Add new node at end of linked list
			self.tail.next = node
			self.tail = node
		
	
	# Display linked list element
	def display(self) :
		if (self.head == None) :
			print("\nEmpty linked list\n", end = "")
			return
		
		temp = self.head
		print(" Linked List : ", end = "")
		# iterating linked list elements
		while (temp != None) :
			if (temp != self.head) :
				print(" →", end = "")
			
			print(" ", temp.data, end = "")
			# visit to next node
			temp = temp.next
		
		print(" → NULL\n", end = "")
	
	# Delete all Even key nodes in linked list
	def delete_even_nodes(self) :
		# Define some auxiliary variables
		current = self.head
		auxiliary = None
		back = None
		# iterating linked list elements
		while (current != None) :
			if (current.data % 2 == 0) :
				# When get even node
				auxiliary = current
			else :
				back = current
			
			# visit to next node
			current = current.next
			if (auxiliary != None) :
				# When Deleted node exists
				if (back == None) :
					#  When front node is even node
					#  head visit to next node
					self.head = current
				else :
					#  Deleted node are exist in intermediate or last position of linked list
					#  Before delete node, there left node is connecting to next upcoming node
					back.next = current
				
				# unlink deleted node 
				auxiliary.next = None
				# free node
				auxiliary = None
			
		
	

def main() :
	obj = MyLinkedList()
	# Add linked list node
	obj.add_node(8)
	obj.add_node(1)
	obj.add_node(4)
	obj.add_node(3)
	obj.add_node(9)
	obj.add_node(7)
	obj.add_node(5)
	obj.add_node(6)
	# Before effect
	print(" Before Delete Even Key Nodes\n", end = "")
	#  8 → 1 → 4 → 3 → 9 → 7 → 5 → 6 → NULL
	obj.display()
	#  Perform delete operation
	obj.delete_even_nodes()
	# After effect
	print(" After Delete Even Key Nodes\n", end = "")
	#  1 → 3 → 9 → 7 → 5 → NULL
	obj.display()

if __name__ == "__main__": main()

Output

 Before Delete Even Key Nodes
 Linked List :   8 →  1 →  4 →  3 →  9 →  7 →  5 →  6 → NULL
 After Delete Even Key Nodes
 Linked List :   1 →  3 →  9 →  7 →  5 → NULL
#  Ruby Program
#  Delete even nodes from linked list

# Node of LinkedList
class Node 

	# Define the accessor and reader of class Node  
	attr_reader :data, :next
	attr_accessor :data, :next
	def initialize(data)
		# Set node value
		self.data = data
		self.next = nil
	end
end
class MyLinkedList 

	# Define the accessor and reader of class MyLinkedList  
	attr_reader :head, :tail
	attr_accessor :head, :tail


	
	# Class constructor
	def initialize()
	
		self.head = nil
		self.tail = nil
	end
	# insert node at last of linke list
	def add_node(data)
	
		# Create a node
		node = Node.new(data)
		if (self.head == nil)
		
			# When linked list empty add first node
			self.head = node
			self.tail = node
		else
		
			# Add new node at end of linked list
			self.tail.next = node
			self.tail = node
		end
	end
	# Display linked list element
	def display()
	
		if (self.head == nil)
		
			print("\nEmpty linked list\n")
			return
		end
		temp = self.head
		print(" Linked List : ")
		# iterating linked list elements
		while (temp != nil)
		
			if (temp != self.head)
			
				print(" →")
			end
			print(" ", temp.data)
			# visit to next node
			temp = temp.next
		end
		print(" → NULL\n")
	end
	# Delete all Even key nodes in linked list
	def delete_even_nodes()
	
		# Define some auxiliary variables
		current = self.head
		auxiliary = nil
		back = nil
		# iterating linked list elements
		while (current != nil)
		
			if (current.data % 2 == 0)
			
				# When get even node
				auxiliary = current
			else
			
				back = current
			end
			# visit to next node
			current = current.next
			if (auxiliary != nil)
			
				# When Deleted node exists
				if (back == nil)
				
					#  When front node is even node
					#  head visit to next node
					self.head = current
				else
				
					#  Deleted node are exist in intermediate or last position of linked list
					#  Before delete node, there left node is connecting to next upcoming node
					back.next = current
				end
				# unlink deleted node 
				auxiliary.next = nil
				# free node
				auxiliary = nil
			end
		end
	end
end
def main()

	obj = MyLinkedList.new()
	# Add linked list node
	obj.add_node(8)
	obj.add_node(1)
	obj.add_node(4)
	obj.add_node(3)
	obj.add_node(9)
	obj.add_node(7)
	obj.add_node(5)
	obj.add_node(6)
	# Before effect
	print(" Before Delete Even Key Nodes\n")
	#  8 → 1 → 4 → 3 → 9 → 7 → 5 → 6 → NULL
	obj.display()
	#  Perform delete operation
	obj.delete_even_nodes()
	# After effect
	print(" After Delete Even Key Nodes\n")
	#  1 → 3 → 9 → 7 → 5 → NULL
	obj.display()
end
main()

Output

 Before Delete Even Key Nodes
 Linked List :  8 → 1 → 4 → 3 → 9 → 7 → 5 → 6 → NULL
 After Delete Even Key Nodes
 Linked List :  1 → 3 → 9 → 7 → 5 → NULL
// Scala Program
// Delete even nodes from linked list

//Node of LinkedList
class Node(var data: Int,
	var next: Node)
{
	def this(data: Int)
	{
		this(data, null);
	}
}
class MyLinkedList(var head: Node,
	var tail: Node)
{
	//Class constructor
	def this()
	{
		this(null, null);
	}
	//insert node at last of linke list
	def add_node(data: Int): Unit = {
		//Create a node
		var node: Node = new Node(data);
		if (this.head == null)
		{
			//When linked list empty add first node
			this.head = node;
			this.tail = node;
		}
		else
		{
			//Add new node at end of linked list
			this.tail.next = node;
			this.tail = node;
		}
	}
	//Display linked list element
	def display(): Unit = {
		if (this.head == null)
		{
			print("\nEmpty linked list\n");
			return;
		}
		var temp: Node = this.head;
		print(" Linked List : ");
		//iterating linked list elements
		while (temp != null)
		{
			if (temp != this.head)
			{
				print(" →");
			}
			print(" " + temp.data);
			//visit to next node
			temp = temp.next;
		}
		print(" → NULL\n");
	}
	//Delete all Even key nodes in linked list
	def delete_even_nodes(): Unit = {
		//Define some auxiliary variables
		var current: Node = this.head;
		var auxiliary: Node = null;
		var back: Node = null;
		//iterating linked list elements
		while (current != null)
		{
			if (current.data % 2 == 0)
			{
				//When get even node
				auxiliary = current;
			}
			else
			{
				back = current;
			}
			//visit to next node
			current = current.next;
			if (auxiliary != null)
			{
				//When Deleted node exists
				if (back == null)
				{
					// When front node is even node
					// head visit to next node
					this.head = current;
				}
				else
				{
					// Deleted node are exist in intermediate or last position of linked list
					// Before delete node, there left node is connecting to next upcoming node
					back.next = current;
				}
				//unlink deleted node 
				auxiliary.next = null;
				//free node
				auxiliary = null;
			}
		}
	}
}
object Main
{
	def main(args: Array[String]): Unit = {
		var obj: MyLinkedList = new MyLinkedList();
		//Add linked list node
		obj.add_node(8);
		obj.add_node(1);
		obj.add_node(4);
		obj.add_node(3);
		obj.add_node(9);
		obj.add_node(7);
		obj.add_node(5);
		obj.add_node(6);
		//Before effect
		print(" Before Delete Even Key Nodes\n");
		// 8 → 1 → 4 → 3 → 9 → 7 → 5 → 6 → NULL
		obj.display();
		// Perform delete operation
		obj.delete_even_nodes();
		//After effect
		print(" After Delete Even Key Nodes\n");
		// 1 → 3 → 9 → 7 → 5 → NULL
		obj.display();
	}
}

Output

 Before Delete Even Key Nodes
 Linked List :  8 → 1 → 4 → 3 → 9 → 7 → 5 → 6 → NULL
 After Delete Even Key Nodes
 Linked List :  1 → 3 → 9 → 7 → 5 → NULL
// Swift 4 Program
// Delete even nodes from linked list

//Node of LinkedList
class Node
{
	var data: Int;
	var next: Node? ;
	init(_ data: Int)
	{
		//Set node value
		self.data = data;
		self.next = nil;
	}
}
class MyLinkedList
{
	var head: Node? ;
	var tail: Node? ;
	//Class constructor
	init()
	{
		self.head = nil;
		self.tail = nil;
	}
	//insert node at last of linke list
	func add_node(_ data: Int)
	{
		//Create a node
		let node: Node? = Node(data);
		if (self.head == nil)
		{
			//When linked list empty add first node
			self.head = node;
			self.tail = node;
		}
		else
		{
			//Add new node at end of linked list
			self.tail!.next = node;
			self.tail = node;
		}
	}
	//Display linked list element
	func display()
	{
		if (self.head == nil)
		{
			print("\nEmpty linked list\n", terminator: "");
			return;
		}
		var temp: Node? = self.head;
		print(" Linked List : ", terminator: "");
		//iterating linked list elements
		while (temp != nil)
		{
			if (!(temp === self.head))
			{
				print(" →", terminator: "");
			}
			print(" ", temp!.data, terminator: "");
			//visit to next node
			temp = temp!.next;
		}
		print(" → NULL\n", terminator: "");
	}
	//Delete all Even key nodes in linked list
	func delete_even_nodes()
	{
		//Define some auxiliary variables
		var current: Node? = self.head;
		var auxiliary: Node? = nil;
		var back: Node? = nil;
		//iterating linked list elements
		while (current != nil)
		{
			if (current!.data % 2 == 0)
			{
				//When get even node
				auxiliary = current;
			}
			else
			{
				back = current;
			}
			//visit to next node
			current = current!.next;
			if (auxiliary != nil)
			{
				//When Deleted node exists
				if (back == nil)
				{
					// When front node is even node
					// head visit to next node
					self.head = current;
				}
				else
				{
					// Deleted node are exist in intermediate or last position of linked list
					// Before delete node, there left node is connecting to next upcoming node
					back!.next = current;
				}
				//unlink deleted node 
				auxiliary!.next = nil;
				//free node
				auxiliary = nil;
			}
		}
	}
}
func main()
{
	let obj: MyLinkedList = MyLinkedList();
	//Add linked list node
	obj.add_node(8);
	obj.add_node(1);
	obj.add_node(4);
	obj.add_node(3);
	obj.add_node(9);
	obj.add_node(7);
	obj.add_node(5);
	obj.add_node(6);
	//Before effect
	print(" Before Delete Even Key Nodes\n", terminator: "");
	// 8 → 1 → 4 → 3 → 9 → 7 → 5 → 6 → NULL
	obj.display();
	// Perform delete operation
	obj.delete_even_nodes();
	//After effect
	print(" After Delete Even Key Nodes\n", terminator: "");
	// 1 → 3 → 9 → 7 → 5 → NULL
	obj.display();
}
main();

Output

 Before Delete Even Key Nodes
 Linked List :   8 →  1 →  4 →  3 →  9 →  7 →  5 →  6 → NULL
 After Delete Even Key Nodes
 Linked List :   1 →  3 →  9 →  7 →  5 → NULL


Please share your knowledge to improve code and content standard. Also submit your doubts, and test case. We improve by your feedback. We will try to resolve your query as soon as possible.

New Comment







© 2021, kalkicode.com, All rights reserved