Product of the alternate nodes of linked list
Last Updated :
06 Sep, 2022
Given a linked list, the task is to print the product of alternate nodes of the given linked list.
Examples:
Input : 1 -> 8 -> 3 -> 10 -> 17 -> 22 -> 29 -> 42
Output : 1479
Alternate nodes : 1 -> 3 -> 17 -> 29
Input : 10 -> 17 -> 33 -> 38 -> 73
Output : 24090
Alternate nodes : 10 -> 33 -> 73
Iterative Approach:
- Traverse the whole linked list.
- Set prod = 1 and count=0.
- Multiply the data of the node with the prod when the count is even.
- Visit the next node.
Below is the implementation of this approach:
C++
#include <bits/stdc++.h>
using namespace std;
struct Node {
int data;
struct Node* next;
};
int productAlternateNode( struct Node* head)
{
int count = 0;
int prod = 1;
while (head != NULL) {
if (count % 2 == 0)
prod *= head->data;
count++;
head = head->next;
}
return prod;
}
void push( struct Node** head_ref, int new_data)
{
struct Node* new_node = new Node;
new_node->data = new_data;
new_node->next = (*head_ref);
(*head_ref) = new_node;
}
int main()
{
struct Node* head = NULL;
push(&head, 12);
push(&head, 29);
push(&head, 11);
push(&head, 23);
push(&head, 8);
cout << productAlternateNode(head);
return 0;
}
|
C
#include <stdio.h>
#include <stdlib.h>
struct Node {
int data;
struct Node* next;
};
int productAlternateNode( struct Node* head)
{
int count = 0;
int prod = 1;
while (head != NULL) {
if (count % 2 == 0)
prod *= head->data;
count++;
head = head->next;
}
return prod;
}
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;
}
int main()
{
struct Node* head = NULL;
push(&head, 12);
push(&head, 29);
push(&head, 11);
push(&head, 23);
push(&head, 8);
printf ( " %d " , productAlternateNode(head));
return 0;
}
|
Java
class GFG
{
static class Node
{
int data;
Node next;
};
static int productAlternateNode( Node head)
{
int count = 0 ;
int product = 1 ;
while (head != null )
{
if (count % 2 == 0 )
product *= head.data;
count++;
head = head.next;
}
return product;
}
static Node 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;
return head_ref;
}
public static void main(String args[])
{
Node head = null ;
head = push(head, 12 );
head = push(head, 29 );
head = push(head, 11 );
head = push(head, 23 );
head = push(head, 8 );
System.out.printf( " %d " , productAlternateNode(head));
}
}
|
Python3
import math
class Node:
def __init__( self , data):
self .data = data
self . next = None
def productAlternateNode(head):
count = 0
prod = 1
while (head ! = None ):
if (count % 2 = = 0 ):
prod * = head.data
count = count + 1
head = head. next
return prod
def push(head_ref, new_data):
new_node = Node(new_data)
new_node. next = head_ref
head_ref = new_node
return head_ref
if __name__ = = '__main__' :
head = None
head = push(head, 12 )
head = push(head, 29 )
head = push(head, 11 )
head = push(head, 23 )
head = push(head, 8 )
print (productAlternateNode(head))
|
C#
using System;
class GFG
{
public class Node
{
public int data;
public Node next;
};
static int productAlternateNode( Node head)
{
int count = 0;
int product = 1;
while (head != null )
{
if (count % 2 == 0)
product *= head.data;
count++;
head = head.next;
}
return product;
}
static Node 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;
return head_ref;
}
public static void Main(String []args)
{
Node head = null ;
head = push(head, 12);
head = push(head, 29);
head = push(head, 11);
head = push(head, 23);
head = push(head, 8);
Console.Write( " {0} " , productAlternateNode(head));
}
}
|
Javascript
<script>
class Node {
constructor(val) {
this .data = val;
this .next = null ;
}
}
function productAlternateNode(head) {
var count = 0;
var product = 1;
while (head != null ) {
if (count % 2 == 0)
product *= head.data;
count++;
head = head.next;
}
return product;
}
function push(head_ref , new_data) {
var new_node = new Node();
new_node.data = new_data;
new_node.next = (head_ref);
(head_ref) = new_node;
return head_ref;
}
var head = null ;
head = push(head, 12);
head = push(head, 29);
head = push(head, 11);
head = push(head, 23);
head = push(head, 8);
document.write( productAlternateNode(head));
</script>
|
Complexity Analysis:
- Time Complexity: O(N)
- Auxiliary Space: O(1)
Recursive Approach:
- Initialize a static variable(say flag).
- If the flag is odd, multiply the node with the product.
- Increase head and flag by 1, and recurse for next nodes.
Below is the implementation of this approach:
C++
#include <bits/stdc++.h>
using namespace std;
struct Node {
int data;
struct Node* next;
};
void push( struct Node** head_ref, int new_data)
{
struct Node* new_node = new Node();
new_node->data = new_data;
new_node->next = (*head_ref);
(*head_ref) = new_node;
}
void productAlternateNodes( struct Node* node,
int & prod, bool isOdd = true )
{
if (node == NULL)
return ;
if (isOdd == true )
prod = prod * (node->data);
productAlternateNodes(node->next, prod, !isOdd);
}
int main()
{
struct Node* head = NULL;
push(&head, 12);
push(&head, 29);
push(&head, 11);
push(&head, 23);
push(&head, 8);
int prod = 1;
productAlternateNodes(head, prod);
cout << prod;
return 0;
}
|
Java
class GFG
{
static class Node
{
int data;
Node next;
};
static Node 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;
return head_ref;
}
static int prod;
static void productAlternateNodes(Node node,
boolean isOdd)
{
if (node == null )
return ;
if (isOdd == true )
prod = prod * (node.data);
productAlternateNodes(node.next, !isOdd);
}
public static void main(String args[])
{
Node head = null ;
head = push(head, 12 );
head = push(head, 29 );
head = push(head, 11 );
head = push(head, 23 );
head = push(head, 8 );
prod = 1 ;
productAlternateNodes(head, true );
System.out.println( prod);
}
}
|
Python3
class Node:
def __init__( self , data):
self .data = data
self . next = next
def push(head_ref, new_data):
new_node = Node( 0 )
new_node.data = new_data
new_node. next = (head_ref)
(head_ref) = new_node
return head_ref
prod = 1
def productAlternateNodes(node, isOdd):
global prod
if (node = = None ):
return
if (isOdd = = True ):
prod = prod * (node.data)
productAlternateNodes(node. next , not isOdd)
head = None
head = push(head, 12 )
head = push(head, 29 )
head = push(head, 11 )
head = push(head, 23 )
head = push(head, 8 )
prod = 1
productAlternateNodes(head, True )
print (prod)
|
C#
using System;
class GFG
{
public class Node
{
public int data;
public Node next;
};
static Node 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;
return head_ref;
}
static int prod;
static void productAlternateNodes(Node node,
bool isOdd)
{
if (node == null )
return ;
if (isOdd == true )
prod = prod * (node.data);
productAlternateNodes(node.next, !isOdd);
}
public static void Main(String []args)
{
Node head = null ;
head = push(head, 12);
head = push(head, 29);
head = push(head, 11);
head = push(head, 23);
head = push(head, 8);
prod = 1;
productAlternateNodes(head, true );
Console.WriteLine( prod);
}
}
|
Javascript
<script>
class Node
{
constructor()
{
this .data = 0;
this .next = null ;
}
}
function push(head_ref, new_data)
{
let new_node = new Node();
new_node.data = new_data;
new_node.next = (head_ref);
(head_ref) = new_node;
return head_ref;
}
let prod;
function productAlternateNodes(node,isOdd)
{
if (node == null )
return ;
if (isOdd == true )
prod = prod * (node.data);
productAlternateNodes(node.next, !isOdd);
}
let head = null ;
head = push(head, 12);
head = push(head, 29);
head = push(head, 11);
head = push(head, 23);
head = push(head, 8);
prod = 1;
productAlternateNodes(head, true );
document.write( prod);
</script>
|
Complexity Analysis:
- Time Complexity: O(N)
- Auxiliary Space: O(N)
Share your thoughts in the comments
Please Login to comment...