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