Related Articles

# Find the balanced node in a Linked List

• Last Updated : 17 Aug, 2021

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 = 10

Input: 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 ``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

 ``

Output:
`10`

Time Complexity: O(n)
Auxiliary Space: O(1)

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.

My Personal Notes arrow_drop_up