Search Insert Position

• LeetCode: Search Insert Position

• Problem:

Given a sorted array and a target value, return the index if the target is found. If not, return the index where it would be if it were inserted in order.

You may assume no duplicates in the array.

• Examples:

Input: [1,3,5,6], 5
Output: 2

Input: [1,3,5,6], 2
Output: 1

Input: [1,3,5,6], 7
Output: 4

Input: [1,3,5,6], 0
Output: 0

• Analysis:

Because of a sorted array, we can use binary search to find the insert position.

• Java - Code:

class Solution {
    public int searchInsert(int[] nums, int target) {
        int left = 0;
        int right = nums.length - 1;
        while (left + 1 < right) {
            int mid = left + (right - left) / 2;
            if (nums[mid] == target) {
                return mid;
            } else if (nums[mid] < target) {
                left = mid;
            } else {
                right = mid;
            }
        }
        if (target > nums[right]) {
            return right + 1;
        }
        if (target == nums[right]) {
            return right;
        }
        if (target > nums[left]) {
            return left + 1;
        }
        if (target == nums[left]) {
            return left;
        }
        return left == 0? 0 : left - 1;
    }
}

• Code - C++:

class Solution {
public:
    int searchInsert(vector<int>& nums, int target) {
        int left = 0;
        int right = nums.size() - 1;
        while (left + 1 < right) {
            int mid = left + (right - left) / 2;
            if (nums[mid] == target) {
                return mid;
            } else if (nums[mid] < target) {
                left = mid;
            } else {
                right = mid;
            }
        }
        if (target > nums[right]) {
            return right + 1;
        }
        if (target == nums[right]) {
            return right;
        }
        if (target > nums[left]) {
            return left + 1;
        }
        if (target == nums[left]) {
            return left;
        }
        return left == 0? 0 : left - 1;
    }
};

• Code - Python:

class Solution(object):
    def searchInsert(self, nums, target):
        """
        :type nums: List[int]
        :type target: int
        :rtype: int
        """
        left, right = 0, len(nums) - 1
        while left + 1 < right:
            mid = left + (right - left) / 2
            if nums[mid] == target:
                return mid
            elif nums[mid] < target:
                left = mid
            else:
                right = mid
        if target > nums[right]:
            return right + 1
        if target == nums[right]:
            return right
        if target > nums[left]:
            return left + 1
        if target == nums[left]:
            return left
        if left == 0:
            return 0
        return left - 1

• Code - C:

int searchInsert(int* nums, int numsSize, int target) {
    int left = 0;
    int right = numsSize - 1;
    while (left + 1 < right) {
        int mid = left + (right - left) / 2;
        if (nums[mid] == target) {
            return mid;
        } else if (nums[mid] < target) {
            left = mid;
        } else {
            right = mid;
        }
    }
    if (target > nums[right]) {
        return right + 1;
    }
    if (target == nums[right]) {
        return right;
    }
    if (target > nums[left]) {
        return left + 1;
    }
    if (target == nums[left]) {
        return left;
    }
    return left == 0? 0 : left - 1;
}

• Time Complexity: O(logN), N is the length of the input array

• Space Complexity: O(1)