notes/OJ notes/pages/Leetcode Search-Insert-Position.md

# Leetcode Search-Insert-Position

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

> ##### Algorithms:
> #algorithm #binary_search 
> ##### Data structures:
> #DS #array 
> ##### Difficulty:
> #coding_problem #difficulty-easy 
> ##### Additional tags:
> #leetcode
> ##### Revisions:
> N/A

##### Related topics:
```expander
tag:#binary_search
```
 
- [[Binary Search Algorithm]]
- [[Leetcode Binary-Search]]
- [[Leetcode First-Bad-Version]]
- [[Leetcode Lowest-Common-Ancestor-Of-a-Binary-Search-Tree]]
- [[Leetcode Search-a-2D-Matrix]]
- [[Leetcode Two-Sum-IV-Input-Is-a-BST]]
 

##### 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;
  }
};
```