 GFG App
Open App Browser
Continue

# Find the largest and second largest value in a Linked List

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`

## Javascript

 ``

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