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> |
10
Time Complexity: O(n)
Auxiliary Space: O(1)
Ready to dive in? Explore our Free Demo Content and join our DSA course, trusted by over 100,000 neveropen!