# Find the largest node in Doubly linked list

Given a doubly-linked list, find the largest node in the doubly linked list.

Examples:

```Input: 10->8->4->23->67->88
Largest node is: 88
Output: 88

Input : 34->2->78->18->120->39->7
Largest node  is: 120
Output :120
```

## Recommended: Please try your approach on {IDE} first, before moving on to the solution.

Approach Used :

1. Initialize the temp and max pointer to head nodes.
2. Traverse the whole list.
3. if temp’s data is greater than max’s data, then put max = temp.
4. move on next node .

## C++

 `/* C++ Program to find the largest  ` `nodes in doubly linked list */` `#include ` `using` `namespace` `std; ` ` `  `// Create a node of the doubly linked list  ` `struct` `Node ` `{  ` `    ``int` `data;  ` `    ``struct` `Node* next;  ` `    ``struct` `Node* prev;  ` `};  ` ` `  `/* UTILITY FUNCTIONS */` `/* Function to insert a node at the  ` `beginging of the Doubly Linked List */` `void` `push(``struct` `Node** head_ref, ``int` `new_data)  ` `{  ` `    ``/* allocate node */` `    ``struct` `Node* new_node =  ` `    ``(``struct` `Node*)``malloc``(``sizeof``(``struct` `Node));  ` ` `  `    ``/* put in the data */` `    ``new_node->data = new_data;  ` ` `  `    ``/* since we are adding at the  ` `    ``beginning, prev is always NULL */` `    ``new_node->prev = NULL;  ` ` `  `    ``/* link the old list off the new node */` `    ``new_node->next = (*head_ref);  ` ` `  `    ``/* change prev of head node to new node */` `    ``if` `((*head_ref) != NULL)  ` `        ``(*head_ref)->prev = new_node;  ` ` `  `    ``/* move the head to point to the new node */` `    ``(*head_ref) = new_node;  ` `}  ` ` `  `/* Function to find the largest  ` `nodes in Doubly Linked List */` `int` `LargestInDLL(``struct` `Node** head_ref)  ` `{  ` `    ``struct` `Node *max, *temp;  ` ` `  `    ``/* initialize two pointer temp  ` `    ``and max on the head node */` `    ``temp = max = *head_ref;  ` ` `  `    ``// traverse the whole doubly linked list  ` `    ``while` `(temp != NULL)  ` `    ``{  ` ` `  `        ``/* if temp's data is greater than  ` `        ``max's data, then put max = temp  ` `        ``and return max->data */` `        ``if` `(temp->data > max->data)  ` `            ``max = temp;  ` ` `  `        ``temp = temp->next;  ` `    ``}  ` `    ``return` `max->data;  ` `}  ` ` `  `// Driver code ` `int` `main()  ` `{  ` `    ``// Start with the empty list  ` `    ``struct` `Node* head = NULL;  ` ` `  `    ``// Let us create a linked list  ` `    ``push(&head, 20);  ` `    ``push(&head, 14);  ` `    ``push(&head, 181);  ` `    ``push(&head, 100);  ` ` `  `    ``cout << LargestInDLL(&head);  ` `    ``return` `0;  ` `}  ` ` `  `// This code is contributed by shubhamsingh10 `

## C

 `/* Program to find the largest ` `   ``nodes in doubly linked list */` `#include ` `#include ` ` `  `// Create a node of the doubly linked list ` `struct` `Node { ` `    ``int` `data; ` `    ``struct` `Node* next; ` `    ``struct` `Node* prev; ` `}; ` ` `  `/* UTILITY FUNCTIONS */` `/* Function to insert a node at the ` `beginging of the Doubly Linked List */` `void` `push(``struct` `Node** head_ref, ``int` `new_data) ` `{ ` `    ``/* allocate node */` `    ``struct` `Node* new_node = (``struct` `Node*)``malloc``(``sizeof``(``struct` `Node)); ` ` `  `    ``/* put in the data */` `    ``new_node->data = new_data; ` ` `  `    ``/* since we are adding at the  ` `    ``beginning, prev is always NULL */` `    ``new_node->prev = NULL; ` ` `  `    ``/* link the old list off the new node */` `    ``new_node->next = (*head_ref); ` ` `  `    ``/* change prev of head node to new node */` `    ``if` `((*head_ref) != NULL) ` `        ``(*head_ref)->prev = new_node; ` ` `  `    ``/* move the head to point to the new node */` `    ``(*head_ref) = new_node; ` `} ` ` `  `/* Function to find the largest  ` `   ``nodes in Doubly Linked List */` `int` `LargestInDLL(``struct` `Node** head_ref) ` `{ ` `    ``struct` `Node *max, *temp; ` ` `  `    ``/* initialize two pointer temp  ` `       ``and max on the head node */` `    ``temp = max = *head_ref; ` ` `  `    ``// traverse the whole doubly linked list ` `    ``while` `(temp != NULL) { ` ` `  `        ``/* if temp's data is greater than ` `           ``max's data, then put max = temp ` `           ``and return max->data */` `        ``if` `(temp->data > max->data) ` `            ``max = temp; ` ` `  `        ``temp = temp->next; ` `    ``} ` `    ``return` `max->data; ` `} ` ` `  `int` `main() ` `{ ` `    ``// Start with the empty list ` `    ``struct` `Node* head = NULL; ` ` `  `    ``// Let us create a linked list ` `    ``push(&head, 20); ` `    ``push(&head, 14); ` `    ``push(&head, 181); ` `    ``push(&head, 100); ` ` `  `    ``printf``(``"%d"``, LargestInDLL(&head)); ` `    ``return` `0; ` `} `

## Java

 `// Java Program to find the largest ` `// nodes in doubly linked list ` `class` `GFG { ` ` `  `    ``// Create node of the doubly linked list ` `    ``static` `class` `Node { ` `        ``int` `data; ` `        ``Node next; ` `        ``Node prev; ` `    ``}; ` ` `  `    ``// UTILITY FUNCTIONS ` `    ``// Function to insert a node at the ` `    ``// beginging of the Doubly Linked List ` `    ``static` `Node push(Node head_ref, ``int` `new_data) ` `    ``{ ` `        ``// allocate node ` `        ``Node new_node = ``new` `Node(); ` ` `  `        ``// put in the data ` `        ``new_node.data = new_data; ` ` `  `        ``// since we are adding at the ` `        ``// beginning, prev is always null ` `        ``new_node.prev = ``null``; ` ` `  `        ``// link the old list off the new node ` `        ``new_node.next = (head_ref); ` ` `  `        ``// change prev of head node to new node ` `        ``if` `((head_ref) != ``null``) ` `            ``(head_ref).prev = new_node; ` ` `  `        ``// move the head to point to the new node ` `        ``(head_ref) = new_node; ` `        ``return` `head_ref; ` `    ``} ` ` `  `    ``// Function to find the largest ` `    ``// nodes in Doubly Linked List ` `    ``static` `int` `LargestInDLL(Node head_ref) ` `    ``{ ` `        ``Node max, temp; ` ` `  `        ``// initialize two pointer temp ` `        ``// and max on the head node ` `        ``temp = max = head_ref; ` ` `  `        ``// traverse the whole doubly linked list ` `        ``while` `(temp != ``null``) { ` ` `  `            ``// if temp's data is greater than ` `            ``// max's data, then put max = temp ` `            ``// and return max.data ` `            ``if` `(temp.data > max.data) ` `                ``max = temp; ` ` `  `            ``temp = temp.next; ` `        ``} ` `        ``return` `max.data; ` `    ``} ` ` `  `    ``public` `static` `void` `main(String args[]) ` `    ``{ ` `        ``// Start with the empty list ` `        ``Node head = ``null``; ` ` `  `        ``// Let us create a linked list ` `        ``head = push(head, ``20``); ` `        ``head = push(head, ``14``); ` `        ``head = push(head, ``181``); ` `        ``head = push(head, ``100``); ` ` `  `        ``System.out.printf(``"%d"``, LargestInDLL(head)); ` `    ``} ` `} ` ` `  `// This code is contributed by Arnab Kundu `

## Python3

 `# Python3 program to find largest  ` `# node in doubly linked list ` ` `  `# Node of the doubly linked list  ` `class` `Node:  ` `     `  `    ``def` `__init__(``self``, data):  ` `        ``self``.data ``=` `data  ` `        ``self``.prev ``=` `None` `        ``self``.``next` `=` `None` ` `  `# Function to find pair whose product ` `# equal to given value x ` `def` `pairProduct(head, x): ` ` `  `    ``# Set two pointers, ` `    ``# first to the beginning of DLL ` `    ``# and second to the end of DLL. ` `    ``first ``=` `head ` `    ``second ``=` `head ` `    ``while` `(second.``next` `!``=` `None``): ` `        ``second ``=` `second.``next` ` `  `    ``# To track if we find a pair or not ` `    ``found ``=` `False` ` `  `    ``# The loop terminates when either of two pointers ` `    ``# become None, or they cross each other (second.next ` `    ``# == first), or they become same (first == second) ` `    ``while` `(first !``=` `None` `and` `           ``second !``=` `None` `and` `first !``=` `second ``and`  `           ``second.``next` `!``=` `first) : ` `                `  `        ``# pair found ` `        ``if` `((first.data ``*` `second.data) ``=``=` `x) : ` `            ``found ``=` `True` `            ``print``(``"("` `, first.data,  ` `                  ``", "``, second.data, ``")"``) ` ` `  `            ``# move first in forward direction ` `            ``first ``=` `first.``next` ` `  `            ``# move second in backward direction ` `            ``second ``=` `second.prev ` `         `  `        ``else` `: ` `            ``if` `((first.data ``*` `second.data) < x): ` `                ``first ``=` `first.``next` `            ``else``: ` `                ``second ``=` `second.prev ` `     `  `    ``# if pair is not present ` `    ``if` `(found ``=``=` `False``): ` `        ``print``( ``"No pair found"``) ` ` `  `# A utility function to insert a new node at the ` `# beginning of doubly linked list ` `def` `push( head, data): ` ` `  `    ``temp ``=` `Node(``0``) ` `    ``temp.data ``=` `data ` `    ``temp.``next` `=` `temp.prev ``=` `None` `    ``if` `(head ``=``=` `None``): ` `        ``(head) ``=` `temp ` `    ``else` `: ` `        ``temp.``next` `=` `head ` `        ``(head).prev ``=` `temp ` `        ``(head) ``=` `temp ` `    ``return` `head ` `     `  `""" Function to find the largest  ` `nodes in Doubly Linked List """` `def` `LargestInDLL( head_ref): ` ` `  `    ``max` `=` `None` `    ``temp ``=` `None` ` `  `    ``""" initialize two pointer temp  ` `    ``and max on the head node """` `    ``temp ``=` `max` `=` `head_ref ` ` `  `    ``# traverse the whole doubly linked list ` `    ``while` `(temp !``=` `None``):  ` ` `  `        ``""" if temp's data is greater than ` `        ``max's data, then put max = temp ` `        ``and return max.data """` `        ``if` `(temp.data > ``max``.data): ` `            ``max` `=` `temp ` ` `  `        ``temp ``=` `temp.``next` `     `  `    ``return` `max``.data ` ` `  `# Driver Code ` `if` `__name__ ``=``=` `"__main__"``:  ` ` `  `    ``# Start with the empty list ` `    ``head ``=` `None` ` `  `    ``# Let us create a linked list ` `    ``head ``=` `push(head, ``20``) ` `    ``head ``=` `push(head, ``14``) ` `    ``head ``=` `push(head, ``181``) ` `    ``head ``=` `push(head, ``100``) ` ` `  `    ``print``( LargestInDLL(head)) ` `     `  `# This code is contributed by Arnab Kundu `

## C#

 `// C# Program to find the largest ` `// nodes in doubly linked list ` `using` `System; ` ` `  `class` `GFG { ` ` `  `    ``// Create node of the doubly linked list ` `    ``public` `class` `Node { ` `        ``public` `int` `data; ` `        ``public` `Node next; ` `        ``public` `Node prev; ` `    ``}; ` ` `  `    ``// UTILITY FUNCTIONS ` `    ``// Function to insert a node at the ` `    ``// beginging of the Doubly Linked List ` `    ``static` `Node push(Node head_ref, ``int` `new_data) ` `    ``{ ` `        ``// allocate node ` `        ``Node new_node = ``new` `Node(); ` ` `  `        ``// put in the data ` `        ``new_node.data = new_data; ` ` `  `        ``// since we are adding at the ` `        ``// beginning, prev is always null ` `        ``new_node.prev = ``null``; ` ` `  `        ``// link the old list off the new node ` `        ``new_node.next = (head_ref); ` ` `  `        ``// change prev of head node to new node ` `        ``if` `((head_ref) != ``null``) ` `            ``(head_ref).prev = new_node; ` ` `  `        ``// move the head to point to the new node ` `        ``(head_ref) = new_node; ` `        ``return` `head_ref; ` `    ``} ` ` `  `    ``// Function to find the largest ` `    ``// nodes in Doubly Linked List ` `    ``static` `int` `LargestInDLL(Node head_ref) ` `    ``{ ` `        ``Node max, temp; ` ` `  `        ``// initialize two pointer temp ` `        ``// and max on the head node ` `        ``temp = max = head_ref; ` ` `  `        ``// traverse the whole doubly linked list ` `        ``while` `(temp != ``null``) { ` ` `  `            ``// if temp's data is greater than ` `            ``// max's data, then put max = temp ` `            ``// and return max.data ` `            ``if` `(temp.data > max.data) ` `                ``max = temp; ` ` `  `            ``temp = temp.next; ` `        ``} ` `        ``return` `max.data; ` `    ``} ` ` `  `    ``// Driver code ` `    ``public` `static` `void` `Main(String[] args) ` `    ``{ ` `        ``// Start with the empty list ` `        ``Node head = ``null``; ` ` `  `        ``// Let us create a linked list ` `        ``head = push(head, 20); ` `        ``head = push(head, 14); ` `        ``head = push(head, 181); ` `        ``head = push(head, 100); ` ` `  `        ``Console.Write(``"{0}"``, LargestInDLL(head)); ` `    ``} ` `} ` ` `  `// This code contributed by Rajput-Ji `

Output:

``` 181
```

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

Don’t stop now and take your learning to the next level. Learn all the important concepts of Data Structures and Algorithms with the help of the most trusted course: DSA Self Paced. Become industry ready at a student-friendly price.

My Personal Notes arrow_drop_up Check out this Author's contributed articles.

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.

Article Tags :
Practice Tags :

Be the First to upvote.

Please write to us at contribute@geeksforgeeks.org to report any issue with the above content.