Search in Rotated Sorted Array in DSA Go - Build from Scratch

Search in Rotated Sorted Array

📖 Scenario: Imagine you have a list of numbers that was originally sorted but then rotated at some unknown point. You want to find if a specific number exists in this rotated list.

🎯 Goal: You will write a Go program that searches for a target number in a rotated sorted array using an efficient method.

📋 What You'll Learn

Create a slice called nums with the exact values [4, 5, 6, 7, 0, 1, 2]

Create an integer variable called target and set it to 0

Write a function called search that takes nums []int and target int and returns the index of target in nums or -1 if not found

Use binary search logic adapted for rotated sorted arrays inside the search function

Print the result of calling search(nums, target)

💡 Why This Matters

🌍 Real World

Rotated sorted arrays appear in systems where data is cyclically shifted, such as time-based logs or circular buffers. Efficient search helps quickly find needed information.

💼 Career

Understanding how to search in rotated sorted arrays is useful for software engineers working on performance-critical applications, embedded systems, or interview coding challenges.

1

Create the rotated sorted array

Create a slice called nums with the exact values [4, 5, 6, 7, 0, 1, 2]

DSA Go

# Create the slice nums with values [4, 5, 6, 7, 0, 1, 2]
// Your code here

Hint

Use nums := []int{4, 5, 6, 7, 0, 1, 2} to create the slice.

2

Set the target number to search

Create an integer variable called target and set it to 0

DSA Go

package main

func main() {
    nums := []int{4, 5, 6, 7, 0, 1, 2}
    // Create target variable and set it to 0
    // Your code here
}

Hint

Use target := 0 to create the variable.

3

Write the search function using binary search logic

Write a function called search that takes nums []int and target int and returns the index of target in nums or -1 if not found. Use binary search logic adapted for rotated sorted arrays inside the search function.

DSA Go

package main

func search(nums []int, target int) int {
    // Your code here
}

func main() {
    nums := []int{4, 5, 6, 7, 0, 1, 2}
    target := 0
}

Hint

Use a loop with left, right, and mid pointers. Check which side is sorted and adjust left and right accordingly.

4

Print the search result

Print the result of calling search(nums, target) inside the main function.

DSA Go

package main

func search(nums []int, target int) int {
    left, right := 0, len(nums)-1
    for left <= right {
        mid := left + (right-left)/2
        if nums[mid] == target {
            return mid
        }
        if nums[left] <= nums[mid] {
            if nums[left] <= target && target < nums[mid] {
                right = mid - 1
            } else {
                left = mid + 1
            }
        } else {
            if nums[mid] < target && target <= nums[right] {
                left = mid + 1
            } else {
                right = mid - 1
            }
        }
    }
    return -1
}

func main() {
    nums := []int{4, 5, 6, 7, 0, 1, 2}
    target := 0
    // Print the index of target in nums
    // Your code here
}

Hint

Use fmt.Println(search(nums, target)) to print the result.

Practice

1. What is the main challenge when searching in a rotated sorted array compared to a normal sorted array?

easy

A. The array size is unknown

B. The array contains duplicate elements

C. The array is unsorted

D. The array is split into two sorted parts, making direct binary search tricky

Solution

1. Step 1: Understand the array structure

   A rotated sorted array is originally sorted but then rotated at some pivot, splitting it into two sorted parts.

2. Step 2: Identify the search challenge

   Because of the rotation, a simple binary search cannot be applied directly as the array is not fully sorted in one sequence.

3. Final Answer:

   The array is split into two sorted parts, making direct binary search tricky -> Option D

4. Quick Check:

   Rotation splits array = search challenge [OK]

Hint: Look for the pivot splitting the array into two sorted halves [OK]

Common Mistakes:

• Assuming the array is fully sorted
• Ignoring the rotation pivot
• Trying linear search only

2. Which of the following Go function signatures correctly represents a binary search in a rotated sorted array?

easy

A. func search(nums []int, target int) int

B. func search(nums int, target int) int

C. func search(nums []int, target string) int

D. func search(nums []int, target int) bool

Solution

1. Step 1: Check parameter types

   The function should accept a slice of integers and an integer target to search for.

2. Step 2: Check return type

   The function returns an integer index of the target or -1 if not found, so return type int is correct.

3. Final Answer:

   func search(nums []int, target int) int -> Option A

4. Quick Check:

   Correct params and return type = func search(nums []int, target int) int [OK]

Hint: Function takes []int and int target, returns int index [OK]

Common Mistakes:

• Using wrong parameter types
• Returning bool instead of index
• Using string target instead of int

3. What is the output of the following Go code snippet?

nums := []int{4,5,6,7,0,1,2}
target := 0
fmt.Println(search(nums, target))

func search(nums []int, target int) int {
    left, right := 0, len(nums)-1
    for left <= right {
        mid := (left + right) / 2
        if nums[mid] == target {
            return mid
        }
        if nums[left] <= nums[mid] {
            if nums[left] <= target && target < nums[mid] {
                right = mid - 1
            } else {
                left = mid + 1
            }
        } else {
            if nums[mid] < target && target <= nums[right] {
                left = mid + 1
            } else {
                right = mid - 1
            }
        }
    }
    return -1
}

medium

A. -1

B. 0

C. 4

D. 6

Solution

1. Step 1: Identify target and array

   Target is 0, array is rotated sorted: [4,5,6,7,0,1,2].

2. Step 2: Trace binary search steps

   Mid starts at index 3 (value 7), target 0 is not equal. Left half [4..7] is sorted. Target 0 is not in left half, so move left to mid+1=4. Now left=4, right=6. Mid=5 (value 1). Target 0 < 1, right=mid-1=4. Now left=4, right=4. Mid=4 (value 0), found target at index 4.

3. Final Answer:

   4 -> Option C

4. Quick Check:

   Target 0 found at index 4 [OK]

Hint: Check mid, decide which half is sorted, adjust search [OK]

Common Mistakes:

• Not updating left/right correctly
• Confusing sorted half
• Returning wrong index

4. The following Go code attempts to search a target in a rotated sorted array but has a bug. What is the bug?

func search(nums []int, target int) int {
    left, right := 0, len(nums)-1
    for left < right {
        mid := (left + right) / 2
        if nums[mid] == target {
            return mid
        }
        if nums[left] <= nums[mid] {
            if nums[left] <= target && target < nums[mid] {
                right = mid - 1
            } else {
                left = mid + 1
            }
        } else {
            if nums[mid] < target && target <= nums[right] {
                left = mid + 1
            } else {
                right = mid - 1
            }
        }
    }
    return -1
}

medium

A. The function does not return the index

B. The loop condition should be 'left <= right' instead of 'left < right'

C. The target comparison uses wrong operators

D. The mid calculation is incorrect

Solution

1. Step 1: Analyze loop condition

   The loop uses 'left < right', which stops when left == right, possibly missing the last element check.

2. Step 2: Correct loop condition

   Changing to 'left <= right' ensures the last element is checked, preventing missed target.

3. Final Answer:

   The loop condition should be 'left <= right' instead of 'left < right' -> Option B

4. Quick Check:

   Loop must include equal to check [OK]

Hint: Use 'left <= right' to cover all elements in binary search [OK]

Common Mistakes:

• Using 'left < right' and missing last element
• Incorrect mid calculation
• Wrong comparison operators

5. Given a rotated sorted array with possible duplicates, which modification is needed in the binary search to correctly find the target?

nums := []int{2,5,6,0,0,1,2}
target := 0

hard

A. Add extra checks to skip duplicates when nums[left] == nums[mid] == nums[right]

B. Use linear search instead of binary search

C. Ignore duplicates and apply normal rotated binary search

D. Sort the array before searching

Solution

1. Step 1: Understand duplicates effect

   Duplicates can cause ambiguity in deciding which half is sorted when nums[left] == nums[mid] == nums[right].

2. Step 2: Modify search to skip duplicates

   When duplicates appear at left, mid, and right, increment left and decrement right to skip duplicates and continue search.

3. Final Answer:

   Add extra checks to skip duplicates when nums[left] == nums[mid] == nums[right] -> Option A

4. Quick Check:

   Skip duplicates to avoid ambiguity [OK]

Hint: Skip duplicates at edges when equal to mid [OK]

Common Mistakes:

• Ignoring duplicates causing wrong half detection
• Switching to linear search unnecessarily
• Sorting array breaks problem constraints