Watch 10 video solutions for Maximum Difference Between Adjacent Elements in a Circular Array, a easy level problem involving Array. This walkthrough by codestorywithMIK has 3,054 views views. Want to try solving it yourself? Practice on FleetCode or read the detailed text solution.
Given a circular array nums, find the maximum absolute difference between adjacent elements.
Note: In a circular array, the first and last elements are adjacent.
Example 1:
Input: nums = [1,2,4]
Output: 3
Explanation:
Because nums is circular, nums[0] and nums[2] are adjacent. They have the maximum absolute difference of |4 - 1| = 3.
Example 2:
Input: nums = [-5,-10,-5]
Output: 5
Explanation:
The adjacent elements nums[0] and nums[1] have the maximum absolute difference of |-5 - (-10)| = 5.
Constraints:
2 <= nums.length <= 100-100 <= nums[i] <= 100Problem Overview: Given an integer array, you need the maximum absolute difference between two adjacent elements. The array is circular, meaning the last element is also adjacent to the first. Your job is to check every adjacent pair, including the wrapāaround pair, and return the largest absolute difference.
Approach 1: Brute Force Pair Comparison (O(n) time, O(1) space)
The straightforward idea is to examine every adjacent pair and compute abs(nums[i] - nums[i+1]). For the circular condition, you also compare the last element with the first element. Track the maximum difference while iterating. Even though this is called "brute force", it already runs in linear time because each element participates in a constant number of comparisons. This approach works well when the array is small or when clarity matters more than microāoptimizations. The only data structure needed is the input array, and you maintain a running maximum while iterating.
Approach 2: Circular Simulation with Modulo Indexing (O(n) time, O(1) space)
A cleaner way to handle circular adjacency is to treat the array as a loop. Iterate through indices 0 to n-1, and compute the next index using (i + 1) % n. This guarantees that when i reaches the last element, the next index wraps back to 0. For each step, calculate abs(nums[i] - nums[(i + 1) % n]) and update the maximum difference. This approach avoids special handling for the last element and keeps the logic uniform. The algorithm is a classic array traversal combined with a simple simulation of circular behavior.
Why this works: Every adjacent pair appears exactly once in the traversal. The modulo operation ensures the circular pair (last ā first) is included without extra branching logic. Since each element is processed once and only constant extra variables are used, the algorithm runs in O(n) time and O(1) space.
Recommended for interviews: Interviewers typically expect the singleāpass circular traversal using modulo indexing. It demonstrates that you recognized the circular property and handled it cleanly without special cases. Showing the simple pair comparison idea first proves you understand the problem. Converting it into a concise O(n) loop with (i + 1) % n shows solid implementation skill.
| Approach | Time | Space | When to Use |
|---|---|---|---|
| Brute Force Adjacent Comparison | O(n) | O(1) | When implementing the simplest readable solution with explicit handling of the last and first element. |
| Circular Simulation with Modulo | O(n) | O(1) | Preferred approach in interviews; cleanly handles circular adjacency using modulo indexing. |