Skip to content
Related Articles

Related Articles

Find the largest and second largest value in a Linked List
  • Last Updated : 30 Jul, 2020

Given a Linked List, the task is to find the largest and second largest value in a Linked List.
Example: 
 

Input: LL = 10 -> 15 -> 5 -> 20 -> 7 -> 9 
Output: 
Largest = 20 
Second Largest = 15
Input: LL = 0 -> 5 -> 52 -> 21 
Output: 
Largest = 52 
Second Largest = 21 
 

 

Approach: 
 

  1. Store the maximum of first two nodes in a variable max.
  2. Store the minimum of first two nodes in a variable second_max.
  3. Iterate over the remaining linked list. For each node: 
    • If current node value is greater than max, then set second_max as max and max as current node’s value.
    • Else if current node value is greater than second_max, then set second_max as current node’s value.

Below is the implementation of the above approach: 
 



C++




// C++ program to find the largest and
// second largest element in a Linked List
  
#include <bits/stdc++.h>
using namespace std;
  
// Link list node
struct Node {
    int data;
    struct Node* next;
};
  
// Function to push the node at the
// beginning of the linked list
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 print the largest
// and second largest element
void findLargestAndSecondLargest(struct Node* head)
{
    // initialise max and second max using
    // first two nodes of linked list
    int val1 = head->data,
        val2 = head->next->data,
        max = std::max(val1, val2),
        second_max = std::min(val1, val2);
  
    // move the head pointer to 3rd node
    head = head->next->next;
  
    // iterate over rest of linked list
    while (head != NULL) {
  
        if (head->data > max) {
  
            // If current node value is greater
            // than max, then set second_max as
            // current max value and max as
            // current node value
            second_max = max;
            max = head->data;
        }
        else if (head->data > second_max) {
  
            // else if current node value is
            // greater than second_max, set
            // second_max as node value
            second_max = head->data;
        }
  
        // move the head pointer to next node
        head = head->next;
    }
  
    // Print the largest
    // and second largest value
    cout << "Largest = "
         << max << endl;
    cout << "Second Largest = "
         << second_max << endl;
}
  
// Driver code
int main()
{
    struct Node* head = NULL;
  
    push(&head, 20);
    push(&head, 5);
    push(&head, 15);
    push(&head, 10);
    push(&head, 7);
    push(&head, 6);
    push(&head, 11);
    push(&head, 9);
  
    findLargestAndSecondLargest(head);
  
    return 0;
}

Java




// Java program to find the largest and
// second largest element in a Linked List
class GFG{
   
// Link list node
static class Node {
    int data;
    Node next;
  
};
   
// Function to push the node at the
// beginning of the linked list
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;
    return head_ref;
}
   
// Function to print the largest
// and second largest element
static void findLargestAndSecondLargest(Node head)
{
    // initialise max and second max using
    // first two nodes of linked list
    int val1 = head.data,
        val2 = head.next.data,
        max = Math.max(val1, val2),
        second_max = Math.min(val1, val2);
   
    // move the head pointer to 3rd node
    head = head.next.next;
   
    // iterate over rest of linked list
    while (head != null) {
   
        if (head.data > max) {
   
            // If current node value is greater
            // than max, then set second_max as
            // current max value and max as
            // current node value
            second_max = max;
            max = head.data;
        }
        else if (head.data > second_max) {
   
            // else if current node value is
            // greater than second_max, set
            // second_max as node value
            second_max = head.data;
        }
   
        // move the head pointer to next node
        head = head.next;
    }
   
    // Print the largest
    // and second largest value
    System.out.print("Largest = "
         + max +"\n");
    System.out.print("Second Largest = "
         + second_max +"\n");
}
   
// Driver code
public static void main(String[] args)
{
    Node head = null;
   
    head = push(head, 20);
    head = push(head, 5);
    head = push(head, 15);
    head = push(head, 10);
    head = push(head, 7);
    head = push(head, 6);
    head = push(head, 11);
    head = push(head, 9);
   
    findLargestAndSecondLargest(head);
}
}
  
// This code is contributed by Rajput-Ji

Python3




# Python3 program to find the largest and
# second largest element in a Linked List
# Node class 
class Node: 
      
    # Function to initialize the node object 
    def __init__(self, data): 
          
        # Assign data 
        self.data = data 
          
        # Initialize 
        # next as null
        self.next = None 
      
# Linked List Class
class LinkedList:
  
    # Function to initialize the
    # LinkedList class.
    def __init__(self): 
          
        # Initialize head as None 
        self.head = None 
  
    # This function insert a new node at the 
    # beginning of the linked list 
    def push(self, new_data): 
      
        # Create a new Node 
        new_node = Node(new_data) 
  
        # Make next of new Node as head 
        new_node.next = self.head 
  
        # Move the head to point to new Node 
        self.head = new_node
  
    # Function to find the max and
    # second largest value from the list
    def findLargestAndSecondLargest(self):
  
        # Take a Head to iterate list
        Head = self.head
  
        # Initialize max and second_max
        # using first two nodes of the list
        val1 = Head.data
        val2 = Head.next.data
        Max = max(val1, val2)
        second_max = min(val1, val2)
  
        # Move the Head to third node
        Head = Head.next.next
  
        # Iterate over rest of linked list
        while(Head != None):
  
            # If current node value is 
            # greater then Max then
            if(Head.data > Max):
  
                # Set the current max to second_max
                # and current node value to max
                second_max = Max
                Max = Head.data
  
            # Else if current node value is
            # greater then second_max value
            elif(Head.data > second_max):
  
                # Then current node value
                # to second_max
                second_max = Head.data
  
            # Move the head to next node
            Head = Head.next
  
        # Print the largest and second largest values
        print("Largest = ", Max)
        print("Second Largest = ", second_max)
  
# Driver code
if __name__ == '__main__':
  
    # Initialising the linked list
    head = LinkedList()
  
    # Pushing the values in list
    head.push(20)
    head.push(5)
    head.push(15)
    head.push(10)
    head.push(7)
    head.push(6)
    head.push(11)
    head.push(9)
      
    # Calling the function to print
    # largest and second largest values.
    head.findLargestAndSecondLargest()
              
# This code is contributed by Amit Mangal.

C#




// C# program to find the largest and
// second largest element in a Linked List
using System;
  
class GFG{
    
// Link list node
class Node {
    public int data;
    public Node next;
   
};
    
// Function to push the node at the
// beginning of the linked list
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;
    return head_ref;
}
    
// Function to print the largest
// and second largest element
static void findLargestAndSecondLargest(Node head)
{
    // initialise max and second max using
    // first two nodes of linked list
    int val1 = head.data,
        val2 = head.next.data,
        max = Math.Max(val1, val2),
        second_max = Math.Min(val1, val2);
    
    // move the head pointer to 3rd node
    head = head.next.next;
    
    // iterate over rest of linked list
    while (head != null) {
    
        if (head.data > max) {
    
            // If current node value is greater
            // than max, then set second_max as
            // current max value and max as
            // current node value
            second_max = max;
            max = head.data;
        }
        else if (head.data > second_max) {
    
            // else if current node value is
            // greater than second_max, set
            // second_max as node value
            second_max = head.data;
        }
    
        // move the head pointer to next node
        head = head.next;
    }
    
    // Print the largest
    // and second largest value
    Console.Write("Largest = "
         + max +"\n");
    Console.Write("Second Largest = "
         + second_max +"\n");
}
    
// Driver code
public static void Main(String[] args)
{
    Node head = null;
    
    head = push(head, 20);
    head = push(head, 5);
    head = push(head, 15);
    head = push(head, 10);
    head = push(head, 7);
    head = push(head, 6);
    head = push(head, 11);
    head = push(head, 9);
    
    findLargestAndSecondLargest(head);
}
}
  
// This code is contributed by Princi Singh
Output: 
Largest = 20
Second Largest = 15

 

Performance Analysis
 

  • Time Complexity: In the above approach, as we are iterating over the linked list only once, so the time complexity is O(N).
  • Auxiliary Space Complexity: In the above approach, we are not using any extra space apart from a few constant size variables, so Auxiliary space complexity is O(1).

 

My Personal Notes arrow_drop_up
Recommended Articles
Page :