Given a linked list, the task is to find the balanced node in a linked list. A balanced node is a node where the sum of all the nodes on its left is equal to the sum of all the node on its right, if no such node is found then print -1.
Examples:
Input: 1 -> 2 -> 7 -> 10 -> 1 -> 6 -> 3 -> NULL
Output: 10
Sum of nodes on the left of 10 is 1 + 2 + 7 = 10
And, to the right of 10 is 1 + 6 + 3 = 10Input: 1 -> 5 -> 5 -> 10 -> -3 -> NULL
Output: -1
Approach:
- First, find the total sum of the all node values.
- Now, traverse the linked list one by one and while traversing keep track of all the previous nodes value sum and find the sum of the remaining node by subtracting current node value and the sum of the previous nodes value from the total sum.
- Compare both the sums, if they are equal then current node is the required node else print -1.
Below is the implementation of the above approach:
C++
// C++ implementation of the approach #include <bits/stdc++.h> using namespace std;
// Structure of a node of linked list class Node {
public :
int data;
Node* next;
Node( int data)
{
this ->data = data;
this ->next = NULL;
}
}; // Push the new node to front of // the linked list Node* push(Node* head, int data)
{ // Return new node as head if
// head is empty
if (head == NULL)
{
return new Node(data);
}
Node* temp = new Node(data);
temp->next = head;
head = temp;
return head;
} // Function to find the balanced node int findBalancedNode(Node* head)
{ int tsum = 0;
Node* curr_node = head;
// Traverse through all node
// to find the total sum
while (curr_node != NULL)
{
tsum += curr_node->data;
curr_node = curr_node->next;
}
// Set current_sum and remaining
// sum to zero
int current_sum = 0;
int remaining_sum = 0;
curr_node = head;
// Traversing the list to
// check balanced node
while (curr_node != NULL)
{
remaining_sum = tsum - (current_sum +
curr_node->data);
// If sum of the nodes on the left and
// the current node is equal to the sum
// of the nodes on the right
if (current_sum == remaining_sum)
{
return curr_node->data;
}
current_sum += curr_node->data;
curr_node = curr_node->next;
}
return -1;
} // Driver code int main()
{ Node* head = NULL;
head = push(head, 3);
head = push(head, 6);
head = push(head, 1);
head = push(head, 10);
head = push(head, 7);
head = push(head, 2);
head = push(head, 1);
cout << findBalancedNode(head);
return 0;
} // This code is contributed by divyehrabadiya07 |
Java
// Java implementation of the approach class GFG{
// Structure of a node of linked list static class Node
{ int data;
Node next;
Node( int data)
{
this .data = data;
this .next = null ;
}
} // Push the new node to front of // the linked list static Node push(Node head, int data)
{ // Return new node as head if
// head is empty
if (head == null )
{
return new Node(data);
}
Node temp = new Node(data);
temp.next = head;
head = temp;
return head;
} // Function to find the balanced node static int findBalancedNode(Node head)
{ int tsum = 0 ;
Node curr_node = head;
// Traverse through all node
// to find the total sum
while (curr_node != null )
{
tsum += curr_node.data;
curr_node = curr_node.next;
}
// Set current_sum and remaining
// sum to zero
int current_sum = 0 ;
int remaining_sum = 0 ;
curr_node = head;
// Traversing the list to
// check balanced node
while (curr_node != null )
{
remaining_sum = tsum - (current_sum +
curr_node.data);
// If sum of the nodes on the left and
// the current node is equal to the sum
// of the nodes on the right
if (current_sum == remaining_sum)
{
return curr_node.data;
}
current_sum += curr_node.data;
curr_node = curr_node.next;
}
return - 1 ;
} // Driver code public static void main(String []args)
{ Node head = null ;
head = push(head, 3 );
head = push(head, 6 );
head = push(head, 1 );
head = push(head, 10 );
head = push(head, 7 );
head = push(head, 2 );
head = push(head, 1 );
System.out.println(findBalancedNode(head));
} } // This code is contributed by rutvik_56 |
Python3
# Python3 implementation of the approach import sys
import math
# Structure of a node of linked list class Node:
def __init__( self , data):
self . next = None
self .data = data
# Push the new node to front of the linked list def push(head, data):
# Return new node as head if head is empty
if not head:
return Node(data)
temp = Node(data)
temp. next = head
head = temp
return head
# Function to find the balanced node def findBalancedNode(head):
tsum = 0
curr_node = head
# Traverse through all node
# to find the total sum
while curr_node:
tsum + = curr_node.data
curr_node = curr_node. next
# Set current_sum and remaining sum to zero
current_sum, remaining_sum = 0 , 0
curr_node = head
# Traversing the list to check balanced node
while (curr_node):
remaining_sum = tsum - (current_sum + curr_node.data)
# If sum of the nodes on the left and the current node
# is equal to the sum of the nodes on the right
if current_sum = = remaining_sum:
return curr_node.data
current_sum + = curr_node.data
curr_node = curr_node. next
return - 1
# Driver code if __name__ = = '__main__' :
head = None
head = push(head, 3 )
head = push(head, 6 )
head = push(head, 1 )
head = push(head, 10 )
head = push(head, 7 )
head = push(head, 2 )
head = push(head, 1 )
print (findBalancedNode(head))
|
C#
// C# implementation of the approach using System;
using System.Collections;
using System.Collections.Generic;
class GFG
{ // Structure of a node of linked list
class Node
{
public int data;
public Node next;
public Node( int data)
{
this .data = data;
this .next = null ;
}
}
// Push the new node to front of
// the linked list
static Node push(Node head, int data)
{
// Return new node as head if
// head is empty
if (head == null )
{
return new Node(data);
}
Node temp = new Node(data);
temp.next = head;
head = temp;
return head;
}
// Function to find the balanced node
static int findBalancedNode(Node head)
{
int tsum = 0;
Node curr_node = head;
// Traverse through all node
// to find the total sum
while (curr_node != null )
{
tsum += curr_node.data;
curr_node = curr_node.next;
}
// Set current_sum and remaining
// sum to zero
int current_sum = 0;
int remaining_sum = 0;
curr_node = head;
// Traversing the list to
// check balanced node
while (curr_node != null )
{
remaining_sum = tsum - (current_sum +
curr_node.data);
// If sum of the nodes on the left and
// the current node is equal to the sum
// of the nodes on the right
if (current_sum == remaining_sum)
{
return curr_node.data;
}
current_sum += curr_node.data;
curr_node = curr_node.next;
}
return -1;
}
// Driver code
public static void Main( string []args)
{
Node head = null ;
head = push(head, 3);
head = push(head, 6);
head = push(head, 1);
head = push(head, 10);
head = push(head, 7);
head = push(head, 2);
head = push(head, 1);
Console.Write(findBalancedNode(head));
}
} // This code is contributed by pratham76 |
Javascript
<script> // Javascript implementation of the approach // Structure of a node of linked list class Node { constructor(data) {
this .data = data;
this .next = null ;
}
}
// Push the new node to front of // the linked list function push( head, data)
{ // Return new node as head if
// head is empty
if (head == null )
{
return new Node(data);
}
var temp = new Node(data);
temp.next = head;
head = temp;
return head;
} // Function to find the balanced node function findBalancedNode( head)
{ let tsum = 0;
let curr_node = head;
// Traverse through all node
// to find the total sum
while (curr_node != null )
{
tsum += curr_node.data;
curr_node = curr_node.next;
}
// Set current_sum and remaining
// sum to zero
let current_sum = 0;
let remaining_sum = 0;
curr_node = head;
// Traversing the list to
// check balanced node
while (curr_node != null )
{
remaining_sum = tsum - (current_sum +
curr_node.data);
// If sum of the nodes on the left and
// the current node is equal to the sum
// of the nodes on the right
if (current_sum == remaining_sum)
{
return curr_node.data;
}
current_sum += curr_node.data;
curr_node = curr_node.next;
}
return -1;
} // Driver Code
var head = null ;
head = push(head, 3);
head = push(head, 6);
head = push(head, 1);
head = push(head, 10);
head = push(head, 7);
head = push(head, 2);
head = push(head, 1);
document.write(findBalancedNode(head));
// This code is contributed by Jana_sayantan. </script> |
Output:
10
Time Complexity: O(n)
Auxiliary Space: O(1)