Maximum distance between Peaks in given Linked List

• Difficulty Level : Medium
• Last Updated : 30 Jun, 2022

Given a linked list lis of length N, the task is to determine the maximum distance between two consecutive peaks of the given linked list. A peak is defined as a node having a value greater than its neighbours. The distance between two nodes is defined as the number of nodes present between them.

Examples:

Input: lis = 1 -> 2 -> 3 -> 1 -> 5 -> 4 -> 4 -> 10 -> 7
Output: 2
Explanation: The peaks in the linkedlist are 3, 5, 10
The distance between 3 and 5 is 1.
The distance between 5 and 10 is 2.
The maximum distance is 2.

Input: lis = 1 -> 3 -> 1 -> 1 ->1 -> 1 -> 4 -> 2 -> 7
Output: 4
Explanation: The peaks in the linkedlist are 3, 4, 7
The distance between 3 and 4 is 4.
The distance between 4 and 7 is 1.
The maximum distance is 4.

Approach: The solution is based on greedy approach. Follow the steps mentioned below to solve the problem:

• Iterate over the linkedlist and find nodes that are peaks.
• Keep a record of previousIndex that is peak and current index if its a peak

Below is the implementation of the above approach.

C++

 `// C++ code to implement the above approach``#include ``using` `namespace` `std;` `// Class(struct) for the structure of a node``struct` `Node {``    ``int` `data;``    ``Node* next;``    ``Node(``int` `data, Node* next)``        ``: data(data)``        ``, next(next)``    ``{``    ``}``};` `// Function to find the maximum distance``void` `findMaxGap(Node* head)``{` `    ``// Pre points to previous of current node``    ``Node* pre = ``new` `Node(-1, head);` `    ``// Current is initially head``    ``Node* cur = head;``    ``int` `lastIndex = -1, currentIndex = 0, maxGap = 0,``        ``gap = 0;` `    ``// Loop till current is not NULL``    ``while` `(cur != NULL) {` `        ``// Find next of current``        ``Node* next = cur->next;` `        ``// One node only``        ``if` `(pre->next == head && next == NULL) {``            ``cout << maxGap;``            ``return``;``        ``}` `        ``// For the 1st node check only next``        ``else` `if` `(pre->next == head``                 ``&& next->data < cur->data) {``            ``lastIndex = currentIndex;``        ``}` `        ``// For the last node check``        ``// only the prev node``        ``else` `if` `(next == NULL && pre->data < cur->data) {``            ``if` `(lastIndex != -1) {``                ``lastIndex = currentIndex;``            ``}``            ``else` `{``                ``gap = currentIndex - lastIndex - 1;``                ``maxGap = max(gap, maxGap);``                ``lastIndex = currentIndex;``            ``}``        ``}` `        ``// Check prev and next nodes for all``        ``// intermediate nodes``        ``else` `if` `(pre->data < cur->data``                 ``&& next->data < cur->data) {``            ``if` `(lastIndex != -1) {``                ``lastIndex = currentIndex;``            ``}``            ``else` `{``                ``gap = currentIndex - lastIndex - 1;``                ``maxGap = max(gap, maxGap);``                ``lastIndex = currentIndex;``            ``}``        ``}` `        ``// Move pre and cur pointer``        ``pre = pre->next;``        ``cur = cur->next;``        ``currentIndex++;``    ``}``    ``cout << maxGap << ``"\n"``;``}` `// Driver code``int` `main()``{``    ``// Create the linkedlist``    ``Node* head = ``new` `Node(1, NULL);``    ``head->next = ``new` `Node(2, NULL);``    ``head->next->next = ``new` `Node(3, NULL);``    ``head->next->next->next = ``new` `Node(1, NULL);``    ``head->next->next->next->next = ``new` `Node(5, NULL);``    ``head->next->next->next->next->next = ``new` `Node(4, NULL);``    ``head->next->next->next->next->next->next``        ``= ``new` `Node(4, NULL);``    ``head->next->next->next->next->next->next->next``        ``= ``new` `Node(10, NULL);``    ``head->next->next->next->next->next->next->next->next``        ``= ``new` `Node(7, NULL);` `    ``// Function call``    ``findMaxGap(head);``}` `// This code is contributed by Aneshka Goyal` `// Time complexity is O(n) while space is O(1), so no need``// of another data structure`

Java

 `// Java code to implement the above approach``import` `java.io.*;``import` `java.util.*;` `// Class for the structure of a node``class` `Node {``    ``int` `data;``    ``Node next;``    ``public` `Node(``int` `data, Node next)``    ``{``        ``this``.data = data;``        ``this``.next = next;``    ``}``}` `class` `GFG {` `    ``// Driver code``    ``public` `static` `void` `main(String[] args)``    ``{``        ``// Create the linkedlist``        ``Node head = ``new` `Node(``1``, ``null``);``        ``head.next = ``new` `Node(``2``, ``null``);``        ``head.next.next = ``new` `Node(``3``, ``null``);``        ``head.next.next.next = ``new` `Node(``1``, ``null``);``        ``head.next.next.next.next = ``new` `Node(``5``, ``null``);``        ``head.next.next.next.next.next = ``new` `Node(``4``, ``null``);``        ``head.next.next.next.next.next.next``            ``= ``new` `Node(``4``, ``null``);``        ``head.next.next.next.next.next.next.next``            ``= ``new` `Node(``10``, ``null``);``        ``head.next.next.next.next.next.next.next.next``            ``= ``new` `Node(``7``, ``null``);` `        ``// Function call``        ``findMaxGap(head);``    ``}` `    ``// Function to find the maximum distance``    ``static` `void` `findMaxGap(Node head)``    ``{``        ``// Create a set to store``        ``// all the peak nodes``        ``Set peaks = ``new` `HashSet<>();` `        ``// Pre points to previous of current node``        ``Node pre = ``new` `Node(-``1``, head);` `        ``// Current is initially head``        ``Node cur = head;` `        ``// Loop till current is not null``        ``while` `(cur != ``null``) {` `            ``// Find next of current``            ``Node next = cur.next;` `            ``// One node only``            ``if` `(pre.next == head && next == ``null``)``                ``peaks.add(cur);` `            ``// For the 1st node check only next``            ``else` `if` `(pre.next == head``                     ``&& next.data < cur.data)``                ``peaks.add(cur);` `            ``// For the last node check``            ``// only the prev node``            ``else` `if` `(next == ``null``                     ``&& pre.data < cur.data)``                ``peaks.add(cur);` `            ``// Check prev and next nodes for all``            ``// intermediate nodes``            ``else` `if` `(pre.data < cur.data``                     ``&& next.data < cur.data)``                ``peaks.add(cur);` `            ``// Move pre and cur pointer``            ``pre = pre.next;``            ``cur = cur.next;``        ``}` `        ``// Initialize``        ``int` `lastPeakIndex = -``1``,``            ``currentIndex = ``0``,``            ``maxGap = ``0``, gap = ``0``;` `        ``cur = head;` `        ``// Iterate through the linkedlist``        ``while` `(cur != ``null``) {` `            ``// If current node is a peak``            ``if` `(peaks.contains(cur)) {` `                ``// If current node is first peak``                ``// then update lastPeakIndex``                ``// and move ahead``                ``if` `(lastPeakIndex == -``1``)``                    ``lastPeakIndex = currentIndex;` `                ``// If current node peak then``                ``// calculate gap and update``                ``// lastPeakIndex and move ahead``                ``else` `{``                    ``gap = currentIndex``                          ``- lastPeakIndex - ``1``;``                    ``maxGap = Math.max(gap, maxGap);``                    ``lastPeakIndex = currentIndex;``                ``}``            ``}` `            ``// Increment currentIndex``            ``// move current node ahead``            ``currentIndex++;``            ``cur = cur.next;``        ``}``        ``System.out.println(maxGap);``    ``}``}`

Python3

 `# Python Code to implement the above approach``class` `Node:``    ``def` `__init__(``self``, data, ``next``):``        ``self``.data ``=` `data  ``# Assign data``        ``self``.``next` `=` `next`  `# Initialize next as null` `# Function to find maximum difference``def` `findMaxGap():``  ` `    ``# Create a set to store all peak nodes``    ``peaks ``=` `set``()``    ` `    ``# Pre points to previous of current node``    ``pre ``=` `Node(``-``1``, head)``    ` `    ``# Current is pointed to head``    ``cur ``=` `head``    ``while` `(cur):``        ``next_node ``=` `cur.``next``        ` `        ``# One node only``        ``if``(pre.``next` `=``=` `head ``and` `next_node ``=``=` `None``):``            ``peaks.add(cur)``            ` `        ``# For the 1st node check only next``        ``elif``(pre.``next` `=``=` `head ``and` `next_node.data < cur.data):``            ``peaks.add(cur)``            ` `        ``# For the last node check``        ``# only the prev node``        ``elif``(next_node ``=``=` `None` `and` `pre.data < cur.data):``            ``peaks.add(cur)``            ` `        ``# Check prev and next nodes for all``        ``# intermediate nodes``        ``elif``(pre.data < cur.data ``and` `next_node.data < cur.data):``            ``peaks.add(cur)` `        ``pre ``=` `pre.``next``        ``cur ``=` `cur.``next` `    ``lastPeakIndex ``=` `-``1``    ``currentIndex ``=` `0``    ``maxGap ``=` `0``    ``gap ``=` `0``    ``cur ``=` `head` `    ``while` `(cur):``      ` `        ``# If current node is a peak``        ``if``(cur ``in` `peaks):``          ` `            ``# If current node is first peak then``            ``# update lastPeakIndex and move ahead``            ``if``(lastPeakIndex ``=``=` `-``1``):``                ``lastPeakIndex ``=` `currentIndex``                ` `            ``# If current node peak then calculate``            ``# gap and update lastPeakIndex and move ahead``            ``else``:``                ``gap ``=` `currentIndex``-``lastPeakIndex``-``1``                ``maxGap ``=` `max``(gap, maxGap)``                ``lastPeakIndex ``=` `currentIndex` `        ``currentIndex ``+``=` `1``        ``cur ``=` `cur.``next` `    ``print``(maxGap)`  `# Create linked list.``head ``=` `Node(``1``, ``None``)``head.``next` `=` `Node(``2``, ``None``)``head.``next``.``next` `=` `Node(``3``, ``None``)``head.``next``.``next``.``next` `=` `Node(``1``, ``None``)``head.``next``.``next``.``next``.``next` `=` `Node(``5``, ``None``)``head.``next``.``next``.``next``.``next``.``next` `=` `Node(``4``, ``None``)``head.``next``.``next``.``next``.``next``.``next``.``next` `=` `Node(``4``, ``None``)``head.``next``.``next``.``next``.``next``.``next``.``next``.``next` `=` `Node(``10``, ``None``)``head.``next``.``next``.``next``.``next``.``next``.``next``.``next``.``next` `=` `Node(``7``, ``None``)``# function call``findMaxGap()` `# This code is contributed by lokesh (lokeshmvs21).`

C#

 `// C# code to implement the above approach``using` `System;``using` `System.Collections.Generic;` `// Class for the structure of a node``class` `Node {``  ``public` `int` `data;``  ``public` `Node next;``  ``public` `Node(``int` `data, Node next)``  ``{``    ``this``.data = data;``    ``this``.next = next;``  ``}``}` `public` `class` `GFG {` `  ``// Driver code``  ``public` `static` `void` `Main(String[] args)``  ``{``    ``// Create the linkedlist``    ``Node head = ``new` `Node(1, ``null``);``    ``head.next = ``new` `Node(2, ``null``);``    ``head.next.next = ``new` `Node(3, ``null``);``    ``head.next.next.next = ``new` `Node(1, ``null``);``    ``head.next.next.next.next = ``new` `Node(5, ``null``);``    ``head.next.next.next.next.next = ``new` `Node(4, ``null``);``    ``head.next.next.next.next.next.next``      ``= ``new` `Node(4, ``null``);``    ``head.next.next.next.next.next.next.next``      ``= ``new` `Node(10, ``null``);``    ``head.next.next.next.next.next.next.next.next``      ``= ``new` `Node(7, ``null``);` `    ``// Function call``    ``findMaxGap(head);``  ``}` `  ``// Function to find the maximum distance``  ``static` `void` `findMaxGap(Node head)``  ``{``    ``// Create a set to store``    ``// all the peak nodes``    ``HashSet peaks = ``new` `HashSet();` `    ``// Pre points to previous of current node``    ``Node pre = ``new` `Node(-1, head);` `    ``// Current is initially head``    ``Node cur = head;` `    ``// Loop till current is not null``    ``while` `(cur != ``null``) {` `      ``// Find next of current``      ``Node next = cur.next;` `      ``// One node only``      ``if` `(pre.next == head && next == ``null``)``        ``peaks.Add(cur);` `      ``// For the 1st node check only next``      ``else` `if` `(pre.next == head``               ``&& next.data < cur.data)``        ``peaks.Add(cur);` `      ``// For the last node check``      ``// only the prev node``      ``else` `if` `(next == ``null``               ``&& pre.data < cur.data)``        ``peaks.Add(cur);` `      ``// Check prev and next nodes for all``      ``// intermediate nodes``      ``else` `if` `(pre.data < cur.data``               ``&& next.data < cur.data)``        ``peaks.Add(cur);` `      ``// Move pre and cur pointer``      ``pre = pre.next;``      ``cur = cur.next;``    ``}` `    ``// Initialize``    ``int` `lastPeakIndex = -1,``    ``currentIndex = 0,``    ``maxGap = 0, gap = 0;` `    ``cur = head;` `    ``// Iterate through the linkedlist``    ``while` `(cur != ``null``) {` `      ``// If current node is a peak``      ``if` `(peaks.Contains(cur)) {` `        ``// If current node is first peak``        ``// then update lastPeakIndex``        ``// and move ahead``        ``if` `(lastPeakIndex == -1)``          ``lastPeakIndex = currentIndex;` `        ``// If current node peak then``        ``// calculate gap and update``        ``// lastPeakIndex and move ahead``        ``else` `{``          ``gap = currentIndex``            ``- lastPeakIndex - 1;``          ``maxGap = Math.Max(gap, maxGap);``          ``lastPeakIndex = currentIndex;``        ``}``      ``}` `      ``// Increment currentIndex``      ``// move current node ahead``      ``currentIndex++;``      ``cur = cur.next;``    ``}``    ``Console.WriteLine(maxGap);``  ``}``}` `// This code is contributed by 29AjayKumar`

Output

`2`

Time Complexity: O(N)
Auxiliary Space: O(N)

My Personal Notes arrow_drop_up