Find the Largest Number Using Four Nodes in a Singly Linked List
Last Updated :
31 Dec, 2023
Given a singly linked list, the task is to find the largest number in the linked list using four nodes.
Examples:
Input: List: 2->5->3->4->6
Output: 6543
Explanation: Using the four nodes, we traverse the linked list and construct the largest number, which is 6543
Input: List: 1->7->6->5->4->9->2
Output: 9765
Explanation: Using the four nodes, we traverse the linked list and construct the largest number, which is 9765.
Input: List: 5->3->7->1->9->2
Output: 9753
Explanation: By using four nodes to traverse the linked list, we can construct the largest number, which is 9753.
Approach: To solve the problem follow the below idea:
Approach to find the largest number in a singly linked list using four nodes. It does this by iteratively traversing the linked list while maintaining four maximum values: max1, max2, max3, and max4. As it traverses the list, it compares the current node’s value with these maximum values and updates them accordingly. This approach ensures that it identifies the four largest digits in the list, allowing the code to concatenate them in reverse order, forming the largest number.
Steps of this approach:
- Initialize four variables max1, max2, max3, and max4 to the smallest possible integer values (INT_MIN). These variables will keep track of the four largest digits in the linked list.
- Traverse the linked list using a pointer curr. For each node, retrieve the value and store it in the variable val.
- Compare val with the current maximum values (max1, max2, max3, and max4) to determine where it fits among the four largest digits.
- If val is greater than max1, update all four maximum values in the following order: max4 takes the value of max3, max3 takes the value of max2, max2 takes the value of max1, and max1 takes the value of val.
- If val is greater than max2 but less than or equal to max1, update the maximum values for max2, max3, and max4 in a similar fashion.
- Repeat similar updates for max3 and max4 as needed while traversing the linked list.
- After the traversal, you will have the four largest digits in the linked list stored in max1, max2, max3, and max4.
- Concatenate these four maximum values in reverse order to form the largest possible number using arithmetic operations.
- Return the result as a long long integer.
Implementation of the above approach:
C++
#include <bits/stdc++.h>
using namespace std;
struct Node {
int data;
Node* next;
Node( int val)
{
data = val;
next = NULL;
}
};
long long formLargestNumber(Node* head)
{
int max1 = INT_MIN, max2 = INT_MIN, max3 = INT_MIN,
max4 = INT_MIN;
for (Node* curr = head; curr != NULL;
curr = curr->next) {
int val = curr->data;
if (val > max1) {
max4 = max3;
max3 = max2;
max2 = max1;
max1 = val;
}
else if (val > max2 && val <= max1) {
max4 = max3;
max3 = max2;
max2 = val;
}
else if (val > max3 && val <= max2) {
max4 = max3;
max3 = val;
}
else if (val > max4 && val <= max3) {
max4 = val;
}
}
long long largestNum
= max1 * 1000LL + max2 * 100LL + max3 * 10LL + max4;
return largestNum;
}
int main()
{
Node* head = new Node(1);
head->next = new Node(7);
head->next->next = new Node(6);
head->next->next->next = new Node(5);
head->next->next->next->next = new Node(4);
head->next->next->next->next->next = new Node(9);
head->next->next->next->next->next->next = new Node(2);
long long largestNum = formLargestNumber(head);
cout << "The largest number formed using four nodes in "
"the linked list is: "
<< largestNum << endl;
return 0;
}
|
Java
public class LargestNumberFromLinkedList {
static class Node {
int data;
Node next;
Node( int val) {
data = val;
next = null ;
}
}
static long formLargestNumber(Node head) {
int max1 = Integer.MIN_VALUE, max2 = Integer.MIN_VALUE, max3 = Integer.MIN_VALUE,
max4 = Integer.MIN_VALUE;
for (Node curr = head; curr != null ; curr = curr.next) {
int val = curr.data;
if (val > max1) {
max4 = max3;
max3 = max2;
max2 = max1;
max1 = val;
} else if (val > max2 && val <= max1) {
max4 = max3;
max3 = max2;
max2 = val;
} else if (val > max3 && val <= max2) {
max4 = max3;
max3 = val;
}
else if (val > max4 && val <= max3) {
max4 = val;
}
}
long largestNum = max1 * 1000L + max2 * 100L + max3 * 10L + max4;
return largestNum;
}
public static void main(String[] args) {
Node head = new Node( 1 );
head.next = new Node( 7 );
head.next.next = new Node( 6 );
head.next.next.next = new Node( 5 );
head.next.next.next.next = new Node( 4 );
head.next.next.next.next.next = new Node( 9 );
head.next.next.next.next.next.next = new Node( 2 );
long largestNum = formLargestNumber(head);
System.out.println( "The largest number formed using four nodes in "
+ "the linked list is: " + largestNum);
}
}
|
Python3
class Node:
def __init__( self , val):
self .data = val
self . next = None
def form_largest_number(head):
max1 = float ( '-inf' )
max2 = float ( '-inf' )
max3 = float ( '-inf' )
max4 = float ( '-inf' )
curr = head
while curr is not None :
val = curr.data
if val > max1:
max4 = max3
max3 = max2
max2 = max1
max1 = val
elif val > max2 and val < = max1:
max4 = max3
max3 = max2
max2 = val
elif val > max3 and val < = max2:
max4 = max3
max3 = val
elif val > max4 and val < = max3:
max4 = val
curr = curr. next
largest_num = max1 * 1000 + max2 * 100 + max3 * 10 + max4
return largest_num
if __name__ = = "__main__" :
head = Node( 1 )
head. next = Node( 7 )
head. next . next = Node( 6 )
head. next . next . next = Node( 5 )
head. next . next . next . next = Node( 4 )
head. next . next . next . next . next = Node( 9 )
head. next . next . next . next . next . next = Node( 2 )
largest_num = form_largest_number(head)
print ( "The largest number formed using four nodes in the linked list is:" , largest_num)
|
C#
using System;
class Node {
public int data;
public Node next;
public Node( int val)
{
data = val;
next = null ;
}
}
public class GFG {
static long FormLargestNumber(Node head)
{
int max1 = int .MinValue, max2 = int .MinValue,
max3 = int .MinValue, max4 = int .MinValue;
for (Node curr = head; curr != null ;
curr = curr.next) {
int val = curr.data;
if (val > max1) {
max4 = max3;
max3 = max2;
max2 = max1;
max1 = val;
}
else if (val > max2 && val <= max1) {
max4 = max3;
max3 = max2;
max2 = val;
}
else if (val > max3 && val <= max2) {
max4 = max3;
max3 = val;
}
else if (val > max4 && val <= max3) {
max4 = val;
}
}
long largestNum = max1 * 1000L + max2 * 100L
+ max3 * 10L + max4;
return largestNum;
}
static public void Main()
{
Node head = new Node(1);
head.next = new Node(7);
head.next.next = new Node(6);
head.next.next.next = new Node(5);
head.next.next.next.next = new Node(4);
head.next.next.next.next.next = new Node(9);
head.next.next.next.next.next.next = new Node(2);
long largestNum = FormLargestNumber(head);
Console.WriteLine(
"The largest number formed using four nodes in "
+ "the linked list is: " + largestNum);
}
}
|
Javascript
class Node {
constructor(val) {
this .data = val;
this .next = null ;
}
}
function formLargestNumber(head) {
let max1 = -Infinity,
max2 = -Infinity,
max3 = -Infinity,
max4 = -Infinity;
let curr = head;
while (curr !== null ) {
const val = curr.data;
if (val > max1) {
max4 = max3;
max3 = max2;
max2 = max1;
max1 = val;
}
else if (val > max2 && val <= max1) {
max4 = max3;
max3 = max2;
max2 = val;
}
else if (val > max3 && val <= max2) {
max4 = max3;
max3 = val;
}
else if (val > max4 && val <= max3) {
max4 = val;
}
curr = curr.next;
}
const largestNum = max1 * 1000 + max2 * 100 + max3 * 10 + max4;
return largestNum;
}
const head = new Node(1);
head.next = new Node(7);
head.next.next = new Node(6);
head.next.next.next = new Node(5);
head.next.next.next.next = new Node(4);
head.next.next.next.next.next = new Node(9);
head.next.next.next.next.next.next = new Node(2);
const largestNum = formLargestNumber(head);
console.log( "The largest number formed using four nodes in the linked list is:" , largestNum);
|
Output
The largest number formed using four nodes in the linked list is: 9765
Time Complexity: O(n) where ‘n’ is the number of nodes in the linked list.
Auxiliary Space: O(1) as we are not using any extra space.
Share your thoughts in the comments
Please Login to comment...