Find product of the alternate nodes of linked list

Here given code implementation process.

// C Program
// Find product of the alternate nodes of 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 insert(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;
	printf("\n Linked List : ");
	while (temp != NULL)
	{
		printf("  %d", temp->data);
		//visit to next node
		temp = temp->next;
	}
	printf("\n");
}
// Find the product of all alternate nodes in linked list
void alternate_nodes_product(struct Node *head)
{
	if (head == NULL)
	{
		return;
	}
	//Define resultant variables
	int result = 1;
	int counter = 0;
	//Start to first node of linked list
	struct Node *temp = head;
	//iterating linked list elements
	while (temp != NULL)
	{
		if (counter % 2 == 0)
		{
			//When get alternate node
			result = result *temp->data;
		}
		//linked list node counter
		counter++;
		//visit to next node
		temp = temp->next;
	}
	printf(" Alternate nodes product : %d\n", result);
}
int main()
{
	struct Node *head = NULL;
	//Create linked list
	insert( &head, 4);
	insert( &head, 7);
	insert( &head, 2);
	insert( &head, 9);
	insert( &head, 1);
	insert( &head, 3);
	insert( &head, 4);
	insert( &head, 3);
	insert( &head, 5);
	//Display of linked list nodes
	display(head);
	alternate_nodes_product(head);
	return 0;
}

Output

 Linked List :   4  7  2  9  1  3  4  3  5
 Alternate nodes product : 160
// Java Program
// Sum of all odd frequency nodes of the 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;
	}
}
public class MyLinkedList
{
	public Node head;
	public Node tail;
	//Class constructors
	public MyLinkedList()
	{
		this.head = null;
		this.tail = null;
	}
	//insert node at last of linke list
	public void insert(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("\n Linked List : ");
		while (temp != null)
		{
			System.out.print("  " + temp.data);
			temp = temp.next;
		}
      	System.out.print("\n");
	}
	// Find the product of all alternate nodes in linked list
	public void alternate_nodes_product()
	{
		if (this.head == null)
		{
			return;
		}
		//Define resultant variables
		int result = 1;
		int counter = 0;
		//Start to first node of linked list
		Node temp = this.head;
		//iterating linked list elements
		while (temp != null)
		{
			if (counter % 2 == 0)
			{
				//When get alternate node
				result = result * temp.data;
			}
			//linked list node counter
			counter++;
			//visit to next node
			temp = temp.next;
		}
		System.out.print(" Alternate nodes product : " + result + "\n");
	}
	public static void main(String[] args)
	{
		MyLinkedList obj = new MyLinkedList();
		//Create linked list
		obj.insert(4);
		obj.insert(7);
		obj.insert(2);
		obj.insert(9);
		obj.insert(1);
		obj.insert(3);
		obj.insert(4);
		obj.insert(3);
		obj.insert(5);
		//Display of linked list nodes
		obj.display();
		obj.alternate_nodes_product();
	}
}

Output

 Linked List :   4  7  2  9  1  3  4  3  5
 Alternate nodes product : 160
//Include header file
#include <iostream>

using namespace std;
// C++ Program
// Sum of all odd frequency nodes of the 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 constructors
	MyLinkedList()
	{
		this->head = NULL;
		this->tail = NULL;
	}
	//insert node at last of linke list
	void insert(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 << "\n Linked List : ";
		while (temp != NULL)
		{
			cout << "  " << temp->data;
			temp = temp->next;
		}
		cout << "\n";
	}
	// Find the product of all alternate nodes in linked list
	void alternate_nodes_product()
	{
		if (this->head == NULL)
		{
			return;
		}
		//Define resultant variables
		int result = 1;
		int counter = 0;
		//Start to first node of linked list
		Node * temp = this->head;
		//iterating linked list elements
		while (temp != NULL)
		{
			if (counter % 2 == 0)
			{
				//When get alternate node
				result = result * temp->data;
			}
			//linked list node counter
			counter++;
			//visit to next node
			temp = temp->next;
		}
		cout << " Alternate nodes product : " << result << "\n";
	}
};
int main()
{
	MyLinkedList obj = MyLinkedList();
	//Create linked list
	obj.insert(4);
	obj.insert(7);
	obj.insert(2);
	obj.insert(9);
	obj.insert(1);
	obj.insert(3);
	obj.insert(4);
	obj.insert(3);
	obj.insert(5);
	//Display of linked list nodes
	obj.display();
	obj.alternate_nodes_product();
	return 0;
}

Output

 Linked List :   4  7  2  9  1  3  4  3  5
 Alternate nodes product : 160
//Include namespace system
using System;

// C# Program
// Sum of all odd frequency nodes of the linked list

//Node of LinkedList
public class Node
{
	public int data;
	public Node next;
	public Node(int data)
	{
		//Set node value
		this.data = data;
		this.next = null;
	}
}
public class MyLinkedList
{
	public Node head;
	public Node tail;
	//Class constructors
	public MyLinkedList()
	{
		this.head = null;
		this.tail = null;
	}
	//insert node at last of linke list
	public void insert(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("\n Linked List : ");
		while (temp != null)
		{
			Console.Write("  " + temp.data);
			temp = temp.next;
		}
		Console.Write("\n");
	}
	// Find the product of all alternate nodes in linked list
	public void alternate_nodes_product()
	{
		if (this.head == null)
		{
			return;
		}
		//Define resultant variables
		int result = 1;
		int counter = 0;
		//Start to first node of linked list
		Node temp = this.head;
		//iterating linked list elements
		while (temp != null)
		{
			if (counter % 2 == 0)
			{
				//When get alternate node
				result = result * temp.data;
			}
			//linked list node counter
			counter++;
			//visit to next node
			temp = temp.next;
		}
		Console.Write(" Alternate nodes product : " + result + "\n");
	}
	public static void Main(String[] args)
	{
		MyLinkedList obj = new MyLinkedList();
		//Create linked list
		obj.insert(4);
		obj.insert(7);
		obj.insert(2);
		obj.insert(9);
		obj.insert(1);
		obj.insert(3);
		obj.insert(4);
		obj.insert(3);
		obj.insert(5);
		//Display of linked list nodes
		obj.display();
		obj.alternate_nodes_product();
	}
}

Output

 Linked List :   4  7  2  9  1  3  4  3  5
 Alternate nodes product : 160
<?php
// Php Program
// Sum of all odd frequency nodes of the 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 constructors
	function __construct()
	{
		$this->head = null;
		$this->tail = null;
	}
	//insert node at last of linke list
	public	function insert($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 "\n Linked List : ";
		while ($temp != null)
		{
			echo "  ". $temp->data;
			$temp = $temp->next;
		}
		echo "\n";
	}
	// Find the product of all alternate nodes in linked list
	public	function alternate_nodes_product()
	{
		if ($this->head == null)
		{
			return;
		}
		//Define resultant variables
		$result = 1;
		$counter = 0;
		//Start to first node of linked list
		$temp = $this->head;
		//iterating linked list elements
		while ($temp != null)
		{
			if ($counter % 2 == 0)
			{
				//When get alternate node
				$result = $result * $temp->data;
			}
			//linked list node counter
			$counter++;
			//visit to next node
			$temp = $temp->next;
		}
		echo " Alternate nodes product : ". $result ."\n";
	}
}

function main()
{
	$obj = new MyLinkedList();
	//Create linked list
	$obj->insert(4);
	$obj->insert(7);
	$obj->insert(2);
	$obj->insert(9);
	$obj->insert(1);
	$obj->insert(3);
	$obj->insert(4);
	$obj->insert(3);
	$obj->insert(5);
	//Display of linked list nodes
	$obj->display();
	$obj->alternate_nodes_product();
}
main();

Output

 Linked List :   4  7  2  9  1  3  4  3  5
 Alternate nodes product : 160
// Node Js Program
// Sum of all odd frequency nodes of the linked list

//Node of LinkedList
class Node
{
	constructor(data)
	{
		//Set node value
		this.data = data;
		this.next = null;
	}
}
class MyLinkedList
{
	//Class constructors
	constructor()
	{
		this.head = null;
		this.tail = null;
	}
	//insert node at last of linke list
	insert(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("\n Linked List : ");
		while (temp != null)
		{
			process.stdout.write("  " + temp.data);
			temp = temp.next;
		}
		process.stdout.write("\n");
	}
	// Find the product of all alternate nodes in linked list
	alternate_nodes_product()
	{
		if (this.head == null)
		{
			return;
		}
		//Define resultant variables
		var result = 1;
		var counter = 0;
		//Start to first node of linked list
		var temp = this.head;
		//iterating linked list elements
		while (temp != null)
		{
			if (counter % 2 == 0)
			{
				//When get alternate node
				result = result * temp.data;
			}
			//linked list node counter
			counter++;
			//visit to next node
			temp = temp.next;
		}
		process.stdout.write(" Alternate nodes product : " + result + "\n");
	}
}

function main()
{
	var obj = new MyLinkedList();
	//Create linked list
	obj.insert(4);
	obj.insert(7);
	obj.insert(2);
	obj.insert(9);
	obj.insert(1);
	obj.insert(3);
	obj.insert(4);
	obj.insert(3);
	obj.insert(5);
	//Display of linked list nodes
	obj.display();
	obj.alternate_nodes_product();
}
main();

Output

 Linked List :   4  7  2  9  1  3  4  3  5
 Alternate nodes product : 160
#  Python 3 Program
#  Sum of all odd frequency nodes of the linked list

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

class MyLinkedList :
	
	# Class constructors
	def __init__(self) :
		self.head = None
		self.tail = None
	
	# insert node at last of linke list
	def insert(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("\n Linked List : ", end = "")
		while (temp != None) :
			print("  ", temp.data, end = "")
			temp = temp.next
		
		print("\n", end = "")
	
	#  Find the product of all alternate nodes in linked list
	def alternate_nodes_product(self) :
		if (self.head == None) :
			return
		
		# Define resultant variables
		result = 1
		counter = 0
		# Start to first node of linked list
		temp = self.head
		# iterating linked list elements
		while (temp != None) :
			if (counter % 2 == 0) :
				# When get alternate node
				result = result * temp.data
			
			# linked list node counter
			counter += 1
			# visit to next node
			temp = temp.next
		
		print(" Alternate nodes product : ", result ,"\n", end = "")
	

def main() :
	obj = MyLinkedList()
	# Create linked list
	obj.insert(4)
	obj.insert(7)
	obj.insert(2)
	obj.insert(9)
	obj.insert(1)
	obj.insert(3)
	obj.insert(4)
	obj.insert(3)
	obj.insert(5)
	# Display of linked list nodes
	obj.display()
	obj.alternate_nodes_product()

if __name__ == "__main__": main()

Output

 Linked List :    4   7   2   9   1   3   4   3   5
 Alternate nodes product :  160
#  Ruby Program
#  Sum of all odd frequency nodes of the 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 constructors
	def initialize()
	
		self.head = nil
		self.tail = nil
	end
	# insert node at last of linke list
	def insert(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("\n Linked List : ")
		while (temp != nil)
		
			print("  ", temp.data)
			temp = temp.next
		end
		print("\n")
	end
	#  Find the product of all alternate nodes in linked list
	def alternate_nodes_product()
	
		if (self.head == nil)
		
			return
		end
		# Define resultant variables
		result = 1
		counter = 0
		# Start to first node of linked list
		temp = self.head
		# iterating linked list elements
		while (temp != nil)
		
			if (counter % 2 == 0)
			
				# When get alternate node
				result = result * temp.data
			end
			# linked list node counter
			counter += 1
			# visit to next node
			temp = temp.next
		end
		print(" Alternate nodes product : ", result ,"\n")
	end
end
def main()

	obj = MyLinkedList.new()
	# Create linked list
	obj.insert(4)
	obj.insert(7)
	obj.insert(2)
	obj.insert(9)
	obj.insert(1)
	obj.insert(3)
	obj.insert(4)
	obj.insert(3)
	obj.insert(5)
	# Display of linked list nodes
	obj.display()
	obj.alternate_nodes_product()
end
main()

Output

 Linked List :   4  7  2  9  1  3  4  3  5
 Alternate nodes product : 160
// Scala Program
// Sum of all odd frequency nodes of the 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 constructors
	def this()
	{
		this(null, null);
	}
	//insert node at last of linke list
	def insert(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("\n Linked List : ");
		while (temp != null)
		{
			print("  " + temp.data);
			temp = temp.next;
		}
		print("\n");
	}
	// Find the product of all alternate nodes in linked list
	def alternate_nodes_product(): Unit = {
		if (this.head == null)
		{
			return;
		}
		//Define resultant variables
		var result: Int = 1;
		var counter: Int = 0;
		//Start to first node of linked list
		var temp: Node = this.head;
		//iterating linked list elements
		while (temp != null)
		{
			if (counter % 2 == 0)
			{
				//When get alternate node
				result = result * temp.data;
			}
			//linked list node counter
			counter += 1;
			//visit to next node
			temp = temp.next;
		}
		print(" Alternate nodes product : " + result + "\n");
	}
}
object Main
{
	def main(args: Array[String]): Unit = {
		var obj: MyLinkedList = new MyLinkedList();
		//Create linked list
		obj.insert(4);
		obj.insert(7);
		obj.insert(2);
		obj.insert(9);
		obj.insert(1);
		obj.insert(3);
		obj.insert(4);
		obj.insert(3);
		obj.insert(5);
		//Display of linked list nodes
		obj.display();
		obj.alternate_nodes_product();
	}
}

Output

 Linked List :   4  7  2  9  1  3  4  3  5
 Alternate nodes product : 160
// Swift Program
// Sum of all odd frequency nodes of the 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 constructors
	init()
	{
		self.head = nil;
		self.tail = nil;
	}
	//insert node at last of linke list
	func insert(_ 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("\n Linked List : ", terminator: "");
		while (temp != nil)
		{
			print("  ", temp!.data, terminator: "");
			temp = temp!.next;
		}
		print("\n", terminator: "");
	}
	// Find the product of all alternate nodes in linked list
	func alternate_nodes_product()
	{
		if (self.head == nil)
		{
			return;
		}
		//Define resultant variables
		var result: Int = 1;
		var counter: Int = 0;
		//Start to first node of linked list
		var temp: Node? = self.head;
		//iterating linked list elements
		while (temp != nil)
		{
			if (counter % 2 == 0)
			{
				//When get alternate node
				result = result * temp!.data;
			}
			//linked list node counter
			counter += 1;
			//visit to next node
			temp = temp!.next;
		}
		print(" Alternate nodes product : ", result ,"\n", terminator: "");
	}
}
func main()
{
	let obj: MyLinkedList = MyLinkedList();
	//Create linked list
	obj.insert(4);
	obj.insert(7);
	obj.insert(2);
	obj.insert(9);
	obj.insert(1);
	obj.insert(3);
	obj.insert(4);
	obj.insert(3);
	obj.insert(5);
	//Display of linked list nodes
	obj.display();
	obj.alternate_nodes_product();
}
main();

Output

 Linked List :    4   7   2   9   1   3   4   3   5
 Alternate nodes product :  160


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