Find Minimum in Rotated Sorted Array

The "Find Minimum in Rotated Sorted Array" is a popular interview question that tests a candidate's problem-solving skills.

Asked in SDE interviews by Morgan Stanley, Amazon, Microsoft, Samsung, Adobe, and many more.

A rotated sorted array is an array rotated by k positions or rotated between 1 to n times.

The task is to find the minimum element in the array in Log(n) time.

For example:

arr = [1, 2, 3, 4, 5, 6, 7]

Rotated 1 time - [7, 1, 2, 3, 4, 5, 6]
Rotated 2 times - [6, 7, 1, 2, 3, 4, 5]
Rotated 3 times - [5, 6, 7, 1, 2, 3, 4]
or Rotated by 3 positions = [5, 6, 7, 1, 2, 3, 4]
The minimum element is 1.

Approach 1: Linear Search

The simplest approach is to perform a linear search through the array to find the minimum element. The time complexity of this approach is O(n), where n is the size of the array. This approach is straightforward but not efficient enough for large arrays.

Python code of the linear search:

from typing import List

# Function to find minimum in an array
def findMin(nums: List[int]) -> int:
    mini = float('inf')  # Positive Infinity
    for i in nums:
        if i < mini:
            mini = i
    return mini

nums = [5, 6, 1, 2, -5, 4]
print("Mini =", findMin(nums))

Output:

Approach 2: Binary Search

A more efficient approach is to utilize the properties of a rotated sorted array and apply binary search to find the minimum element.

The algorithm can be summarized as follows:

Initialize two pointers, 'low' and 'high', pointing to the start and end of the array, respectively.
Check if the array is already sorted (i.e., the element at the low index is less than or equal to that at the high index). If true, the minimum element is at the low index, and we can return it.
Calculate the mid index as (low + high) // 2 and store the element at that index.
Compare the mid element with the elements at the low and high indices:
If the mid element is greater than the element at the high index, the minimum element lies in the right half of the array. Move the 'low' pointer to mid + 1.
Otherwise, the minimum element lies in the left half of the array. Move the 'high' pointer to the mid.
Repeat steps 2-4 until the 'low' and 'high' pointers become equal, indicating that the minimum element has been found.

Python Implementation to Find the Minimum Element in Rotated Sorted Array:

from typing import List

def findMin(nums: List[int]) -> int:
    n = len(nums)
    left = 0  # Left pointer
    right = n-1  # Right pointer

    # Check if the list is already sorted
    if nums[-1] >= nums[0]:
        # Return the first element as the minimum
        return nums[0]

    while left <= right:
        # Calculate the middle index
        mid = (left+right)//2
        
        # Check if the current element is smaller than the previous element
        if nums[mid-1] > nums[mid]:
            # Return the current element as the minimum
            return nums[mid]

        # Check if the current element is greater than the last element
        elif nums[mid] > nums[-1]:
            # Move the left pointer to mid+1,
            # indicating the minimum lies in the right half
            left = mid+1

        else:
            # Move the right pointer to mid-1,
            # indicating the minimum lies in the left half
            right = mid-1

# Define the input lists
nums1 = [12, 14, 7, 8, 11]
nums2 = [100, 110, 120, 55, 66]

print("nums =", nums1, end=", ")
# Print the minimum element returned by the findMin function
print("Mini =", findMin(nums1))

print("nums =", nums2, end=", ")
# Print the minimum element returned by the findMin function
print("Mini =", findMin(nums2))

Output:

Time complexity = O(log n), where n is the size of the array.

Binary search allows us to efficiently discard half of the array in each iteration, resulting in a faster solution.

C++ Implementation to Find the Minimum Element in Rotated Sorted Array:

#include <iostream>
#include <vector>
using namespace std;

// Function to find the minimum element in a rotated sorted array
int findMin(vector<int> &nums)
{
    int n = nums.size();
    int left = 0;      // Left pointer
    int right = n - 1; // Right pointer

    // Check if the list is already sorted
    if (nums[right] >= nums[left])
    {
        // Return the first element as the minimum
        return nums[left];
    }

    while (left <= right)
    {
        // Calculate the middle index
        int mid = (left + right) / 2;

        // Check if the current element is smaller than the previous element
        if (nums[mid - 1] > nums[mid])
        {
            // Return the current element as the minimum
            return nums[mid];
        }

        // Check if the current element is greater than the last element
        else if (nums[mid] > nums[right])
        {
            // Move the left pointer to mid + 1,
            // indicating the minimum lies in the right half
            left = mid + 1;
        }
        else
        {
            // Move the right pointer to mid - 1,
            // indicating the minimum lies in the left half
            right = mid - 1;
        }
    }
    // The code should never reach this point for a valid rotated sorted array
    return -1;
}

int main()
{
    // Define the input vectors
    vector<int> nums1 = {1, 2, 3, 4, 5};
    vector<int> nums2 = {26, 29, 36, 2, 9};

    cout << "nums1 = [ ";
    for (int num : nums1)
    {
        cout << num << ", ";
    }
    cout << "], Mini = " << findMin(nums1) << endl;

    cout << "nums2 = [ ";
    for (int num : nums2)
    {
        cout << num << ", ";
    }
    cout << "], Mini = " << findMin(nums2) << endl;

    return 0;
}

Output:

C Implementation to Find the Minimum Element in Rotated Sorted Array:

#include <stdio.h>

// Function to find the minimum element in a rotated sorted array
int findMin(int nums[], int n)
{
    int left = 0;      // Left pointer
    int right = n - 1; // Right pointer

    // Check if the list is already sorted
    if (nums[left] <= nums[right])
    {
        // Return the first element as the minimum
        return nums[left];
    }

    while (left <= right)
    {
        // Calculate the middle index
        int mid = (left + right) / 2;

        // Check if the current element is smaller than the previous element
        if (nums[mid - 1] > nums[mid])
        {
            // Return the current element as the minimum
            return nums[mid];
        }

        // Check if the current element is greater than the last element
        else if (nums[mid] > nums[right])
        {
            // Move the left pointer to mid + 1,
            // indicating the minimum lies in the right half
            left = mid + 1;
        }
        else
        {
            // Move the right pointer to mid - 1,
            // indicating the minimum lies in the left half
            right = mid - 1;
        }
    }
    // The code should never reach this point for a valid rotated sorted array
    return -1;
}

int main()
{
    // Define the input arrays
    int nums1[] = {12, 14, 16, 8, 11};
    int nums2[] = {100, 110, 120, 130, 140};
    int n1 = sizeof(nums1) / sizeof(nums1[0]);
    int n2 = sizeof(nums2) / sizeof(nums2[0]);

    printf("nums = [ ");
    for (int i = 0; i < n1; i++)
    {
        printf("%d, ", nums1[i]);
    }
    printf("], Mini = %d\n", findMin(nums1, n1));

    printf("nums = [ ");
    for (int i = 0; i < n2; i++)
    {
        printf("%d, ", nums2[i]);
    }
    printf("], Mini = %d\n", findMin(nums2, n2));

    return 0;
}

Output:

The time complexity of this approach is also O(log n), and it offers an optimized solution for finding the minimum element in a rotated sorted array.

CONCLUSION:

In conclusion, understanding the concepts behind a rotated sorted array and utilizing efficient algorithms such as binary search can greatly improve the performance of finding the minimum element in this type of array. Being familiar with these approaches will help candidates tackle similar interview questions and showcase their problem-solving abilities to potential employers.

Next TopicInterpolation Search vs. Binary Search

← prev next →