Given a linked list. The task is to print the difference between the first odd-positioned node with the sum of all other odd-positioned nodes.
Examples:
Input : 1 -> 8 -> 3 -> 10 -> 17 -> 22 -> 29 -> 42
Output : -48
Alternate nodes : 1 -> 3 -> 17 -> 29
1 – (3 + 17 + 29) = -48Input : 10 -> 17 -> 33 -> 38 -> 73
Output : -96
Alternate nodes : 10 -> 33 -> 73
10 – (33 + 73) = -96
We have already discussed the sum of the alternative nodes of a linked list
Iterative Approach :
- Traverse the whole linked list.
- Set difference = 0 and count=0.
- Subtract the data of node from difference when count is even.
- Visit the next node.
Below is the implementation of the above approach:
// C++ program to print the difference // of Alternate Nodes #include <bits/stdc++.h> using namespace std;
// Link list node struct Node {
int data;
struct Node* next;
}; // Function to get the alternate // nodes of the linked list int subtractAlternateNode( struct Node* head)
{ int count = 0;
int difference = 0;
while (head != NULL) {
// When count is even subtract the nodes
if (count % 2 == 0)
if (difference == 0){
difference = head->data;
}
else {
difference -= head->data;
}
// Count the nodes
count++;
// Move on the next node.
head = head->next;
}
return difference;
} // Function to push node at head 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;
} // Driver code int main()
{ // Start with the empty list
struct Node* head = NULL;
// Use push() function to construct
// the below list 8 -> 23 -> 11 -> 29 -> 12
push(&head, 12);
push(&head, 29);
push(&head, 11);
push(&head, 23);
push(&head, 8);
cout << subtractAlternateNode(head);
return 0;
} // This code is contributed by shubhamsingh10 |
// C program to print the difference // of Alternate Nodes #include <stdio.h> #include <stdlib.h> // Link list node struct Node {
int data;
struct Node* next;
}; // Function to get the alternate // nodes of the linked list int subtractAlternateNode( struct Node* head)
{ int count = 0;
int difference = 0;
while (head != NULL) {
// When count is even subtract the nodes
if (count % 2 == 0)
if (difference == 0){
difference = head->data;
}
else {
difference -= head->data;
}
// Count the nodes
count++;
// Move on the next node.
head = head->next;
}
return difference;
} // Function to push node at head 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;
} // Driver code int main()
{ // Start with the empty list
struct Node* head = NULL;
// Use push() function to construct
// the below list 8 -> 23 -> 11 -> 29 -> 12
push(&head, 12);
push(&head, 29);
push(&head, 11);
push(&head, 23);
push(&head, 8);
printf ( " %d " , subtractAlternateNode(head));
return 0;
} |
// Java program to print the difference // of Alternate Nodes import java.util.*;
class GFG
{ static Node head;
// Link list node static class Node
{ int data;
Node next;
}; // Function to get the alternate // nodes of the linked list static int subtractAlternateNode(Node head)
{ int count = 0 ;
int difference = 0 ;
while (head != null )
{
// When count is even subtract the nodes
if (count % 2 == 0 )
if (difference == 0 )
{
difference = head.data;
}
else
{
difference -= head.data;
}
// Count the nodes
count++;
// Move on the next node.
head = head.next;
}
return difference;
} // Function to push node at head static 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;
head = head_ref;
} // Driver code public static void main(String[] args)
{ // Start with the empty list
head = null ;
// Use push() function to con
// the below list 8 . 23 . 11 . 29 . 12
push(head, 12 );
push(head, 29 );
push(head, 11 );
push(head, 23 );
push(head, 8 );
System.out.printf( " %d " , subtractAlternateNode(head));
} } // This code is contributed by Princi Singh |
# Python3 program to print the difference # of Alternate Nodes import math
# Link list node class Node:
def __init__( self , data):
self .data = data
self . next = None
# Function to get the alternate # nodes of the linked list def subtractAlternateNode(head):
count = 0
difference = 0
while (head ! = None ) :
# When count is even subtract the nodes
if (count % 2 = = 0 ):
if (difference = = 0 ):
difference = head.data
else :
difference = difference - head.data
# Count the nodes
count = count + 1
# Move on the next node.
head = head. next
return difference
# Function to push node at head def push(head_ref, new_data):
new_node = Node(new_data)
new_node.data = new_data
new_node. next = head_ref
head_ref = new_node
return head_ref
# Driver code if __name__ = = '__main__' :
# Start with the empty list
head = None
# Use head=push() function to construct
# the below list 8 . 23 . 11 . 29 . 12
head = push(head, 12 )
head = push(head, 29 )
head = push(head, 11 )
head = push(head, 23 )
head = push(head, 8 )
print (subtractAlternateNode(head))
# This code is contributed by Srathore |
// C# program to print the difference // of Alternate Nodes using System;
class GFG
{ static Node head;
// Link list node public class Node
{ public int data;
public Node next;
}; // Function to get the alternate // nodes of the linked list static int subtractAlternateNode(Node head)
{ int count = 0;
int difference = 0;
while (head != null )
{
// When count is even subtract the nodes
if (count % 2 == 0)
if (difference == 0)
{
difference = head.data;
}
else
{
difference -= head.data;
}
// Count the nodes
count++;
// Move on the next node.
head = head.next;
}
return difference;
} // Function to push node at head static 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;
head = head_ref;
} // Driver code public static void Main(String[] args)
{ // Start with the empty list
head = null ;
// Use push() function to con
// the below list 8 . 23 . 11 . 29 . 12
push(head, 12);
push(head, 29);
push(head, 11);
push(head, 23);
push(head, 8);
Console.WriteLine( " {0} " ,
subtractAlternateNode(head));
} } // This code is contributed by PrinciRaj1992 |
<script> // JavaScript program to print the difference // of Alternate Nodes // Structure of a node of the linked list class Node { constructor() {
this .data = 0;
this .next = null ;
}
} // Function to get the alternate // nodes of the linked list function subtractAlternateNode( head)
{ let count = 0;
let difference = 0;
while (head != null )
{
// When count is even subtract the nodes
if (count % 2 == 0)
if (difference == 0)
{
difference = head.data;
}
else
{
difference -= head.data;
}
// Count the nodes
count++;
// Move on the next node.
head = head.next;
}
return difference;
} // Function to push node at head 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;
head = head_ref;
} // Driver Code // Start with the empty list head = null ;
// Use push() function to con // the below list 8 . 23 . 11 . 29 . 12 push(head, 12); push(head, 29); push(head, 11); push(head, 23); push(head, 8); document.write(subtractAlternateNode(head)); </script> |
-15
Time Complexity: O(N), where N is the number of nodes in the linked list
Auxiliary Space: O(1)
Recursive Approach :
- Initialize a static variable(say flag).
- If flag is odd, subtract the node from difference.
- increase head and flag by 1, and recurse for next nodes.
Below is the implementation of the above approach:
// CPP code to print difference of alternate nodes // of a linked list using recursion #include <bits/stdc++.h> using namespace std;
// A linked list node struct Node {
int data;
struct Node* next;
}; // Inserting node at the beginning 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;
} // Function to find difference of alternate // nodes of linked list. // The boolean flag isOdd is used to find // if the current node is even or odd. void subtractAlternateNodes( struct Node* node,
int & difference, bool isOdd = true )
{ if (node == NULL)
return ;
if (isOdd == true ) {
if (difference == 0) {
difference = node->data;
}
else {
difference = difference - (node->data);
}
}
subtractAlternateNodes(node->next, difference,
!isOdd);
} // Driver code int main()
{ // Start with the empty list
struct Node* head = NULL;
// Construct below list
// 8 -> 23 -> 11 -> 29 -> 12
push(&head, 12);
push(&head, 29);
push(&head, 11);
push(&head, 23);
push(&head, 8);
int difference = 0;
subtractAlternateNodes(head, difference);
cout << difference;
return 0;
} |
// Java code to print difference of // alternate nodes of a linked list // using recursion class GFG
{ // A linked list node static class Node
{ int data;
Node next;
}; static Node head;
static int difference;
// Inserting node at the beginning 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;
head = head_ref;
return head;
} // Function to find difference of alternate // nodes of linked list. // The boolean flag isOdd is used to find // if the current node is even or odd. static void subtractAlternateNodes(Node node,
boolean isOdd)
{ if (node == null )
return ;
if (isOdd == true )
{
if (difference == 0 )
{
difference = node.data;
}
else
{
difference = difference - (node.data);
}
}
subtractAlternateNodes(node.next, !isOdd);
} // Driver code public static void main(String[] args)
{ // Start with the empty list
// Construct below list
// 8 -> 23 -> 11 -> 29 -> 12
push(head, 12 );
push(head, 29 );
push(head, 11 );
push(head, 23 );
push(head, 8 );
difference = 0 ;
subtractAlternateNodes(head, true );
System.out.println(difference);
} } // This code is contributed by PrinciRaj1992 |
# Python code to print difference of alternate nodes # of a linked list using recursion # Link list node class Node:
def __init__( self , data):
self .data = data
self . next = next
# function to insert a node at the # beginning of the linked list def push(head_ref, new_data):
# allocate node
new_node = Node( 0 )
# put in the data
new_node.data = new_data
# link the old list to the new node
new_node. next = (head_ref)
# move the head to point to the new node
(head_ref) = new_node
return head_ref
difference = 0 ;
# Function to find difference of alternate # nodes of linked list. # The boolean flag isOdd is used to find # if the current node is even or odd. def subtractAlternateNodes(node, isOdd ):
global difference
if (node = = None ):
return ;
if (isOdd = = True ):
if (difference = = 0 ) :
difference = node.data;
else :
difference = difference - (node.data);
subtractAlternateNodes(node. next , not isOdd);
# Driver code # Start with the empty list head = None ;
# Construct below list # 8 -> 23 -> 11 -> 29 -> 12 head = push(head, 12 );
head = push(head, 29 );
head = push(head, 11 );
head = push(head, 23 );
head = push(head, 8 );
difference = 0 ;
subtractAlternateNodes(head, True );
print ( difference);
# This code is contributed by Arnab Kundu |
// C# code to print difference of // alternate nodes of a linked list // using recursion using System;
class GFG
{ // A linked list node public class Node
{ public int data;
public Node next;
}; static Node head;
static int difference;
// Inserting node at the beginning 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;
head = head_ref;
return head;
} // Function to find difference of alternate // nodes of linked list. // The boolean flag isOdd is used to find // if the current node is even or odd. static void subtractAlternateNodes(Node node,
Boolean isOdd)
{ if (node == null )
return ;
if (isOdd == true )
{
if (difference == 0)
{
difference = node.data;
}
else
{
difference = difference - (node.data);
}
}
subtractAlternateNodes(node.next, !isOdd);
} // Driver code public static void Main(String[] args)
{ // Start with the empty list
// Construct below list
// 8 -> 23 -> 11 -> 29 -> 12
push(head, 12);
push(head, 29);
push(head, 11);
push(head, 23);
push(head, 8);
difference = 0;
subtractAlternateNodes(head, true );
Console.WriteLine(difference);
} } // This code is contributed by Rajput-Ji |
<script> // JavaScript code to print difference of // alternate nodes of a linked list // using recursion // A linked list node class Node { constructor()
{
this .data = 0;
this .next = null ;
}
}; var head= null ;;
var difference = 0;
// Inserting node at the beginning 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;
head = head_ref;
return head;
} // Function to find difference of alternate // nodes of linked list. // The boolean flag isOdd is used to find // if the current node is even or odd. function subtractAlternateNodes(node, isOdd)
{ if (node == null )
return ;
if (isOdd == true )
{
if (difference == 0)
{
difference = node.data;
}
else
{
difference = difference - (node.data);
}
}
subtractAlternateNodes(node.next, !isOdd);
} // Driver code // Start with the empty list // Construct below list // 8 -> 23 -> 11 -> 29 -> 12 push(head, 12); push(head, 29); push(head, 11); push(head, 23); push(head, 8); difference = 0; subtractAlternateNodes(head, true );
document.write(difference); </script> |
-15
Time Complexity: O(N) where N is number of nodes in the linked list
Auxiliary Space: O(N), for recursion call stack