Find the Minimum and Maximum Number of Nodes Between Critical Points

Find the Minimum and Maximum Number of Nodes Between Critical Points - Problem

Linked List Medium

In a linked list, we need to identify critical points - nodes that represent either local maxima or local minima when compared to their neighboring nodes.

A node is considered a local maximum if its value is strictly greater than both its previous and next nodes. Similarly, a node is a local minimum if its value is strictly smaller than both neighbors.

Important: A node can only be critical if it has both a previous and next node - meaning the first and last nodes of the linked list can never be critical points.

Your task is to find:

The minimum distance between any two distinct critical points
The maximum distance between any two distinct critical points

Return these as an array [minDistance, maxDistance]. If there are fewer than two critical points, return [-1, -1].

Example: For the linked list 5 → 3 → 1 → 2 → 5 → 1 → 2, the critical points are at positions 1 (local max: 3), 2 (local min: 1), and 5 (local min: 1). The minimum distance between critical points is 1, and the maximum distance is 4.

Input & Output

example_1.py — Basic case with multiple critical points

$ Input: [5,3,1,2,5,1,2]

› Output: [1,4]

💡 Note: Critical points are at indices 1 (value 3, local max), 2 (value 1, local min), and 5 (value 1, local min). The minimum distance between any two critical points is 1 (between indices 1 and 2), and the maximum distance is 4 (between indices 1 and 5).

example_2.py — Only two critical points

$ Input: [1,3,2,2,3,2,2,2,7]

› Output: [3,3]

💡 Note: Critical points are at indices 1 (value 3, local max) and 4 (value 3, local max). Since there are only two critical points, both minimum and maximum distances are the same: 3.

example_3.py — No critical points possible

$ Input: [2,3]

› Output: [-1,-1]

💡 Note: The linked list has only 2 nodes, so there are no nodes that can have both previous and next neighbors. Therefore, no critical points can exist.

Constraints

The number of nodes in the list is in the range [2, 10⁵]
1 ≤ Node.val ≤ 10⁵
Important: Only nodes with both previous and next neighbors can be critical points

Visualization

Tap to expand

Understanding the Visualization

Identify Terrain Features

Walk through the mountain range with three position markers (previous, current, next) to identify peaks and valleys

Track Key Landmarks

Remember the first critical point found and keep updating the most recent one

Measure Distances

Calculate the shortest path between adjacent critical points and the longest path from first to last

Key Takeaway

🎯 Key Insight: By maintaining just two variables (first and previous critical point positions), we can solve this problem in O(n) time with O(1) space complexity, avoiding the need to store all critical point positions.

Asked in

a Amazon 45 ⊞ Microsoft 32 G Google 28 f Meta 21

The optimal one-pass solution efficiently identifies critical points while traversing the linked list only once. By tracking the first critical point and previous critical point positions, we can calculate both minimum and maximum distances without storing all positions. The key insight is that the maximum distance is always between the first and last critical points, while the minimum distance is the smallest gap between consecutive critical points.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Store All Critical Points)	O(n + k²)	O(k)	Find all critical points first, then calculate all pairwise distances
One-Pass Optimal Solution	O(n)	O(1)	Track critical points on-the-fly without storing all positions

Brute Force (Store All Critical Points) — Algorithm Steps

Traverse the linked list to identify all critical points
Store the positions of all critical points in an array
Calculate distances between every pair of critical points
Find the minimum and maximum distances among all pairs

Visualization

Tap to expand

Step-by-Step Walkthrough

Traverse List

Walk through the linked list with three pointers: prev, curr, next

Identify Critical Points

Check if current node is local maxima or minima and store position

Calculate Distances

Find minimum distance between adjacent critical points and maximum distance between first and last

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <limits.h>
#include <string.h>

struct ListNode {
    int val;
    struct ListNode *next;
};

int* nodesBetweenCriticalPoints(struct ListNode* head, int* returnSize) {
    *returnSize = 2;
    int* result = (int*)malloc(2 * sizeof(int));
    result[0] = -1;
    result[1] = -1;
    
    if (!head || !head->next || !head->next->next) {
        return result;
    }
    
    int criticalPoints[100000]; // Assuming reasonable constraint
    int criticalCount = 0;
    
    struct ListNode* prev = head;
    struct ListNode* curr = head->next;
    int position = 1;
    
    // Find all critical points
    while (curr->next) {
        if ((curr->val > prev->val && curr->val > curr->next->val) ||
            (curr->val < prev->val && curr->val < curr->next->val)) {
            criticalPoints[criticalCount++] = position;
        }
        
        prev = curr;
        curr = curr->next;
        position++;
    }
    
    // Need at least 2 critical points
    if (criticalCount < 2) {
        return result;
    }
    
    // Calculate min and max distances
    int minDist = INT_MAX;
    int maxDist = criticalPoints[criticalCount - 1] - criticalPoints[0];
    
    for (int i = 1; i < criticalCount; i++) {
        int dist = criticalPoints[i] - criticalPoints[i - 1];
        if (dist < minDist) {
            minDist = dist;
        }
    }
    
    result[0] = minDist;
    result[1] = maxDist;
    return result;
}

int main() {
    // Simple parsing for demonstration
    int values[] = {5, 3, 1, 2, 5, 1, 2};
    int n = 7;
    
    // Build linked list
    struct ListNode* head = (struct ListNode*)malloc(sizeof(struct ListNode));
    head->val = values[0];
    head->next = NULL;
    
    struct ListNode* curr = head;
    for (int i = 1; i < n; i++) {
        curr->next = (struct ListNode*)malloc(sizeof(struct ListNode));
        curr = curr->next;
        curr->val = values[i];
        curr->next = NULL;
    }
    
    int returnSize;
    int* result = nodesBetweenCriticalPoints(head, &returnSize);
    printf("[%d, %d]\n", result[0], result[1]);
    
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n + k²)

O(n) to traverse the list and find critical points, then O(k²) to calculate distances between k critical points

✓ Linear Growth

Space Complexity

O(k)

Space needed to store positions of k critical points

✓ Linear Space

52.3K Views

Medium Frequency

~15 min Avg. Time

1.8K Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force (Store All Critical Points) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler