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 

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 to the next node.

Implementation:

C++

/* C++ Program to find the largest
nodes in doubly linked list */
#include <iostream>
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
beginning 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 of 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 <stdio.h>
#include <stdlib.h>

// 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
beginning 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 of 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
    // beginning 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 of 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
    // beginning 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 of 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

Javascript

<script>
    // javascript Program to find the largest
    // nodes in doubly linked list
    // Create node of the doubly linked list
    class Node {
        constructor(val) {
            this.data = val;
            this.prev = null;
            this.next = null;
        }
    }

    // UTILITY FUNCTIONS
    // Function to insert a node at the
    // beginning of the Doubly Linked List
    function push(head_ref , new_data) {
        // allocate node
        var 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 of 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
    function LargestInDLL(head_ref) {
        var 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;
    }


    // Start with the empty list
    var head = null;

    // Let us create a linked list
    head = push(head, 20);
    head = push(head, 14);
    head = push(head, 181);
    head = push(head, 100);

    document.write(LargestInDLL(head));

// This code contributed by umadevi9616
</script>

Output

181

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