Related Articles

# Maximum and Minimum element of a linked list which is divisible by a given number k

• Difficulty Level : Easy
• Last Updated : 28 May, 2021

Given a singly linked list of nodes. Find the smallest and largest elements in linked list divisible by a given number .
Examples

Input : List = 15 -> 14 -> 13 -> 22 -> 50
K = 5
Output
Maximum element in linked list divisible by K: 50
Minimum element in linked list divisible by K: 5
Input : List = 10 -> 14 -> 13 -> 22 -> 100
K = 10
Output
Maximum element in linked list divisible by K: 100
Minimum element in linked list divisible by K: 10

Approach:

• The idea is to traverse the linked list to the end and initialize the max and min variable to INT_MIN and INT_MAX respectively.
• After that check a condition that if the max value is less then the current node’s value and divisible by K then current node’s value is assigned to max.
• Similarly check if the current node’s value is less than min value and divisible by k then the current node’s value is assigned to min. Repeat above two steps until the end of the list is reached.

Below is the implementation of the above approach:

## C++

 `// Program to find the smallest and largest``// elements divisible by a given number k``// in singly linked list` `#include ` `using` `namespace` `std;` `/* Linked list node */``struct` `Node {``    ``int` `data;``    ``struct` `Node* next;``};` `// Function to print max and min elements of``// linked list divisible by K``void` `findMaxMin(``struct` `Node* head, ``int` `k)``{``    ``// Declare a min variable and initialize``    ``// it with INT_MAX value.``    ``// INT_MAX is integer type and its value``    ``// is 32767 or greater.``    ``int` `min = INT_MAX;` `    ``// Declare a max variable and initialize``    ``// it with INT_MIN value.``    ``// INT_MIN is integer type and its value``    ``// is -32767 or less.``    ``int` `max = INT_MIN;` `    ``// Check loop while head not equal to NULL``    ``while` `(head != NULL) {` `        ``// If head->data is less than min and divisible``        ``// by k then assign value of head->data to min``        ``// otherwise node point to next node.``        ``if` `((head->data < min) && (head->data % k == 0))``            ``min = head->data;` `        ``// If head->data is greater than max and divisible``        ``// by k then assign value of head->data to max``        ``// otherwise node point to next node.``        ``if` `((head->data > max) && (head->data % k == 0))``            ``max = head->data;` `        ``head = head->next;``    ``}` `    ``// Print max element``    ``cout << ``"Max Element : "` `<< max << endl;` `    ``// print min element``    ``cout << ``"Min Element : "` `<< min;``}` `// Function that pushes the element in the linked list.``void` `push(``struct` `Node** head, ``int` `data)``{``    ``// Allocate dynamic memory for newNode.``    ``struct` `Node* newNode = (``struct` `Node*)``malloc``(``sizeof``(``struct` `Node));` `    ``// Assign the data into newNode.``    ``newNode->data = data;` `    ``// newNode->next assign the address of``    ``// head node.``    ``newNode->next = (*head);` `    ``// newNode become the headNode.``    ``(*head) = newNode;``}` `// Driver Code``int` `main()``{``    ``// Start with empty list``    ``struct` `Node* head = NULL;` `    ``// Using push() function to construct``    ``// singly linked list``    ``// 50->5->13->14->15``    ``push(&head, 15);``    ``push(&head, 14);``    ``push(&head, 13);``    ``push(&head, 5);``    ``push(&head, 50);` `    ``int` `k = 5;` `    ``findMaxMin(head, k);` `    ``return` `0;``}`

## Java

 `// Java program to find the smallest and largest``// elements divisible by a given number k``// in singly linked list``class` `GFG``{``    ` `// Linked list node /``static` `class` `Node``{``    ``int` `data;``    ``Node next;``};` `// Function to print max and min elements of``// linked list divisible by K``static` `void` `findMaxMin( Node head, ``int` `k)``{``    ``// Declare a min variable and initialize``    ``// it with INT_MAX value.``    ``// INT_MAX is integer type and its value``    ``// is 32767 or greater.``    ``int` `min = Integer.MAX_VALUE;` `    ``// Declare a max variable and initialize``    ``// it with INT_MIN value.``    ``// INT_MIN is integer type and its value``    ``// is -32767 or less.``    ``int` `max = Integer.MIN_VALUE;` `    ``// Check loop while head not equal to null``    ``while` `(head != ``null``)``    ``{` `        ``// If head.data is less than min and divisible``        ``// by k then assign value of head.data to min``        ``// otherwise node point to next node.``        ``if` `((head.data < min) && (head.data % k == ``0``))``            ``min = head.data;` `        ``// If head.data is greater than max and divisible``        ``// by k then assign value of head.data to max``        ``// otherwise node point to next node.``        ``if` `((head.data > max) && (head.data % k == ``0``))``            ``max = head.data;` `        ``head = head.next;``    ``}` `    ``// Print max element``    ``System.out.println( ``"Max Element : "` `+ max);` `    ``// print min element``    ``System.out.println( ``"Min Element : "` `+ min);``}` `// Function that push the element in linked list.``static` `Node push( Node head, ``int` `data)``{``    ``// Allocate dynamic memory for newNode.``    ``Node newNode = ``new` `Node();` `    ``// Assign the data into newNode.``    ``newNode.data = data;` `    ``// newNode.next assign the address of``    ``// head node.``    ``newNode.next = (head);` `    ``// newNode become the headNode.``    ``(head) = newNode;``    ``return` `head;``}` `// Driver Code``public` `static` `void` `main(String args[])``{``    ``// Start with empty list``    ``Node head = ``null``;` `    ``// Using push() function to con``    ``// singly linked list``    ``// 50.5.13.14.15``    ``head = push(head, ``15``);``    ``head = push(head, ``14``);``    ``head = push(head, ``13``);``    ``head = push(head, ``5``);``    ``head = push(head, ``50``);` `    ``int` `k = ``5``;` `    ``findMaxMin(head, k);``}``}` `// This code is contributed by Arnab Kundu`

## Python3

 `# Python3 program to find the smallest and largest``# elements divisible by a given number k``# in singly linked list` `# Linked list node /``class` `Node:``    ``def` `__init__(``self``):``        ``self``.data ``=` `0``        ``self``.``next` `=` `None` `# Function to print max and min elements of``# linked list divisible by K``def` `findMaxMin(head, k):` `    ``# Declare a min variable and initialize``    ``# it with INT_MAX value.``    ``# INT_MAX is integer type and its value``    ``# is 32767 or greater.``    ``min` `=` `32767` `    ``# Declare a max variable and initialize``    ``# it with INT_MIN value.``    ``# INT_MIN is integer type and its value``    ``# is -32767 or less.``    ``max` `=` `-``32767` `    ``# Check loop while head not equal to None``    ``while` `(head !``=` `None``) :``    ` `        ``# If head.data is less than min and divisible``        ``# by k then assign value of head.data to min``        ``# otherwise node point to next node.``        ``if` `((head.data < ``min``) ``and` `(head.data ``%` `k ``=``=` `0``)) :``            ``min` `=` `head.data` `        ``# If head.data is greater than max and divisible``        ``# by k then assign value of head.data to max``        ``# otherwise node point to next node.``        ``if` `((head.data > ``max``) ``and` `(head.data ``%` `k ``=``=` `0``)) :``            ``max` `=` `head.data` `        ``head ``=` `head.``next``    ` `    ``# Print max element``    ``print``( ``"Max Element : "` `, ``max``)` `    ``# print min element``    ``print``( ``"Min Element : "` `, ``min``)` `# Function that push the element in linked list.``def` `push( head, data):` `    ``# Allocate dynamic memory for newNode.``    ``newNode ``=` `Node()` `    ``# Assign the data into newNode.``    ``newNode.data ``=` `data` `    ``# newNode.next assign the address of``    ``# head node.``    ``newNode.``next` `=` `(head)` `    ``# newNode become the headNode.``    ``(head) ``=` `newNode``    ``return` `head` `# Driver Code` `# Start with empty list``head ``=` `None` `# Using push() function to con``# singly linked list``# 50.5.13.14.15``head ``=` `push(head, ``15``)``head ``=` `push(head, ``14``)``head ``=` `push(head, ``13``)``head ``=` `push(head, ``5``)``head ``=` `push(head, ``50``)` `k ``=` `5` `findMaxMin(head, k)` `# This code is contributed by Arnab Kundu`

## C#

 `// C# program to find the smallest and largest``// elements divisible by a given number k``// in singly linked list``using` `System;` `class` `GFG``{``    ` `// Linked list node /``public` `class` `Node``{``    ``public` `int` `data;``    ``public` `Node next;``};` `// Function to print max and min elements of``// linked list divisible by K``static` `void` `findMaxMin( Node head, ``int` `k)``{``    ``// Declare a min variable and initialize``    ``// it with INT_MAX value.``    ``// INT_MAX is integer type and its value``    ``// is 32767 or greater.``    ``int` `min = ``int``.MaxValue;` `    ``// Declare a max variable and initialize``    ``// it with INT_MIN value.``    ``// INT_MIN is integer type and its value``    ``// is -32767 or less.``    ``int` `max = ``int``.MinValue;` `    ``// Check loop while head not equal to null``    ``while` `(head != ``null``)``    ``{` `        ``// If head.data is less than min and divisible``        ``// by k then assign value of head.data to min``        ``// otherwise node point to next node.``        ``if` `((head.data < min) && (head.data % k == 0))``            ``min = head.data;` `        ``// If head.data is greater than max and divisible``        ``// by k then assign value of head.data to max``        ``// otherwise node point to next node.``        ``if` `((head.data > max) && (head.data % k == 0))``            ``max = head.data;` `        ``head = head.next;``    ``}` `    ``// Print max element``    ``Console.WriteLine( ``"Max Element : "` `+ max);` `    ``// print min element``    ``Console.WriteLine( ``"Min Element : "` `+ min);``}` `// Function that push the element in linked list.``static` `Node push( Node head, ``int` `data)``{``    ``// Allocate dynamic memory for newNode.``    ``Node newNode = ``new` `Node();` `    ``// Assign the data into newNode.``    ``newNode.data = data;` `    ``// newNode.next assign the address of``    ``// head node.``    ``newNode.next = (head);` `    ``// newNode become the headNode.``    ``(head) = newNode;``    ``return` `head;``}` `// Driver Code``public` `static` `void` `Main(String []args)``{``    ``// Start with empty list``    ``Node head = ``null``;` `    ``// Using push() function to con``    ``// singly linked list``    ``// 50.5.13.14.15``    ``head = push(head, 15);``    ``head = push(head, 14);``    ``head = push(head, 13);``    ``head = push(head, 5);``    ``head = push(head, 50);` `    ``int` `k = 5;` `    ``findMaxMin(head, k);``}``}` `// This code contributed by Rajput-Ji`

## Javascript

 ``
Output:
```Max Element : 50
Min Element : 5```

Time complexity : O(n)

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.

My Personal Notes arrow_drop_up