Package g0001_0100.s0035_search_insert_position

Class Solution

java.lang.Object
g0001_0100.s0035_search_insert_position.Solution
public class Solution extends Object
35 - Search Insert Position.

Easy

Given a sorted array of distinct integers 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 must write an algorithm with O(log n) runtime complexity.

Example 1:

Input: nums = [1,3,5,6], target = 5

Output: 2

Example 2:

Input: nums = [1,3,5,6], target = 2

Output: 1

Example 3:

Input: nums = [1,3,5,6], target = 7

Output: 4

Example 4:

Input: nums = [1,3,5,6], target = 0

Output: 0

Example 5:

Input: nums = [1], target = 0

Output: 0

Constraints:

  • 1 <= nums.length <= 104
  • -104 <= nums[i] <= 104
  • nums contains distinct values sorted in ascending order.
  • -104 <= target <= 104

To solve the “Search Insert Position” problem in Java with a Solution class, we can follow these steps:

  1. Define a Solution class.
  2. Define a method named searchInsert that takes an integer array nums and an integer target as input and returns an integer representing the index where target would be inserted in order.
  3. Implement binary search to find the insertion position of target.
  4. Set the left pointer left to 0 and the right pointer right to the length of nums minus 1.
  5. While left is less than or equal to right:
    • Calculate the middle index mid as (left + right) / 2.
    • If nums[mid] is equal to target, return mid.
    • If target is less than nums[mid], update right = mid - 1.
    • If target is greater than nums[mid], update left = mid + 1.
  6. If target is not found in nums, return the value of left, which represents the index where target would be inserted in order.

Here’s the implementation:

public class Solution {
    public int searchInsert(int[] nums, int target) {
        int left = 0;
        int right = nums.length - 1;

        while (left <= right) {
            int mid = left + (right - left) / 2;
            if (nums[mid] == target) {
                return mid;
            } else if (target < nums[mid]) {
                right = mid - 1;
            } else {
                left = mid + 1;
            }
        }

        return left;
    }
}

This implementation provides a solution to the “Search Insert Position” problem in Java. It returns the index where target would be inserted in nums using binary search, with a time complexity of O(log n).

  • Constructor Details

    • Solution

      public Solution()

  • Method Details

    • searchInsert

      public int searchInsert(int[] nums, int target)