# Leetcode Search-Insert-Position

#### 2022-07-09 10:25

> ##### Algorithms:
>
> #algorithm #binary_search
>
> ##### Data structures:
>
> #DS #array
>
> ##### Difficulty:
>
> #coding_problems #difficulty_easy
>
> ##### Additional tags:
>
> #leetcode
>
> ##### Revisions:
>
> N/A

##### Related topics:

##### Links:

- [Link to problem](https://leetcode.com/problems/binary-search/)

  ***

### Problem

Given an array of integers `nums` which is sorted in ascending order, and an integer `target`, write a function to search `target` in `nums`. If `target` exists, then return its index. Otherwise, return `-1`.

You must write an algorithm with `O(log n)` runtime complexity.

#### Examples

**Example 1:**

**Input:** nums = [-1,0,3,5,9,12], target = 9
**Output:** 4
**Explanation:** 9 exists in nums and its index is 4

**Example 2:**

**Input:** nums = [-1,0,3,5,9,12], target = 2
**Output:** -1
**Explanation:** 2 does not exist in nums so return -1

#### Constraints

- `1 <= nums.length <= 104`
- `-104 < nums[i], target < 104`
- All the integers in `nums` are **unique**.
- `nums` is sorted in ascending order.

### Thoughts

> [!summary]
> This is a #binary_search problem.

similar to [[Leetcode First-Bad-Version]], this relies on the converging nature of Bi-search

if the value is found, simply return it

if not found, at the end, position `l - 1` should be smaller than val.

and position `l` should be bigger, which is the position for the answer:

```
If not, return the index where it would be if it were inserted in order.
```

### Solution

Iteration

```cpp
class Solution {
public:
int searchInsert(vector<int>& nums, int target) {
  // variant of bi-search
  int r = nums.size() - 1;
  int l = 0;
  int mid, val;

  do {
    mid = l + (r - l) / 2;
    val = nums[mid];

    if (val == target) {
      return mid;
    } else if (val < target) {
      l = mid + 1;
    } else {
      r = mid - 1;
    }
  } while (l <= r);

  return l;
}
};
```
