Maximum Difference Between Adjacent Elements in a Circular Array

Maximum Difference Between Adjacent Elements in a Circular Array - Problem

Array Easy

Maximum Difference Between Adjacent Elements in a Circular Array

You're given a circular array nums, where the last element connects back to the first element, forming a complete circle. Your task is to find the maximum absolute difference between any two adjacent elements in this circular structure.

Think of this array as a circle of numbers where each number has exactly two neighbors - the one before it and the one after it. The special property of a circular array is that the first and last elements are considered adjacent to each other.

Goal: Return the largest absolute difference between any pair of adjacent elements.

Example: For array [1, 3, 7, 1], the adjacent pairs are: (1,3), (3,7), (7,1), and (1,1). The differences are |1-3|=2, |3-7|=4, |7-1|=6, |1-1|=0. The maximum is 6.

Input & Output

example_1.py — Python

$ Input: nums = [1, 3, 7, 1]

› Output: 6

💡 Note: The adjacent pairs are (1,3), (3,7), (7,1), and (1,1) due to circular nature. Their absolute differences are 2, 4, 6, and 0 respectively. The maximum is 6.

example_2.py — Python

$ Input: nums = [5, 5, 5, 5]

› Output: 0

💡 Note: All elements are the same, so all adjacent differences are 0. The maximum difference is 0.

example_3.py — Python

$ Input: nums = [1, 100]

› Output: 99

💡 Note: In a circular array of 2 elements, both pairs (1,100) and (100,1) have the same absolute difference of 99.

Constraints

1 ≤ nums.length ≤ 10³
-10⁹ ≤ nums[i] ≤ 10⁹
The array is treated as circular - first and last elements are adjacent

Visualization

Tap to expand

Understanding the Visualization

Start at Position 0

Begin at the first element and prepare to check all adjacent pairs

Check Each Adjacent Pair

For each position i, calculate |nums[i] - nums[(i+1) % n]|

Track Maximum

Keep updating the maximum difference as you find larger values

Complete the Circle

The last element connects back to the first, completing the circular check

Key Takeaway

🎯 Key Insight: In a circular array, every element has exactly two neighbors, and the modulo operator (%) elegantly handles the wraparound from the last element back to the first.

Asked in

G Google 25 a Amazon 18 ⊞ Microsoft 12 Apple 8

The optimal approach uses single pass iteration through the circular array. For each element, calculate the absolute difference with its next neighbor (using modulo for wraparound), and track the maximum difference encountered. Time complexity: O(n), Space complexity: O(1).

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Single Pass)	O(n)	O(1)	Iterate through all adjacent pairs including the circular connection

Brute Force (Single Pass) — Algorithm Steps

Initialize maximum difference to 0
Iterate through array from index 0 to n-1
For each element, calculate difference with next element (with wraparound)
Update maximum if current difference is larger
Return the maximum difference found

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

Start with the circular array and max_diff = 0

Check Adjacent Pairs

For each position, calculate difference with next element (wrapping around)

Update Maximum

Keep track of the largest difference found

Handle Wraparound

Don't forget the last element is adjacent to the first

Code -

solution.c — C

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

int abs_diff(int a, int b) {
    return a > b ? a - b : b - a;
}

int maxAdjacentDifference(int* nums, int n) {
    if (n < 2) return 0;
    
    int max_diff = 0;
    
    for (int i = 0; i < n; i++) {
        int next_idx = (i + 1) % n;
        int current_diff = abs_diff(nums[i], nums[next_idx]);
        if (current_diff > max_diff) {
            max_diff = current_diff;
        }
    }
    
    return max_diff;
}

int main() {
    char line[1000];
    fgets(line, sizeof(line), stdin);
    
    int nums[100];
    int count = 0;
    char* token = strtok(line, " ");
    
    while (token != NULL) {
        nums[count++] = atoi(token);
        token = strtok(NULL, " ");
    }
    
    printf("%d\n", maxAdjacentDifference(nums, count));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

We visit each element exactly once to check its difference with the next element

✓ Linear Growth

Space Complexity

O(1)

Only using a constant amount of extra space for variables

✓ Linear Space

28.4K Views

Medium Frequency

~12 min Avg. Time

850 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 (Single Pass) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler