# Leetcode Binary-Search

#### 2022-07-09 09:34

> ##### Algorithms:
>
> #algorithm #binary_search
>
> ##### Data structures:
>
> #DS #array
>
> ##### Difficulty:
>
> #coding_problem #difficulty-easy
>
> ##### Additional tags:
>
> #leetcode #CS_list_need_practicing
>
> ##### 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.

Key takeout:

```
int r = nums.size() - 1;
```

make sure r is never OOB (l == r && r = array.size())

### Solution

==#TODO: write in recursion==

iteration

```cpp
class Solution {
public:
  int search(vector<int> &nums, int target) {
    // Why - 1?
    // Make sure mid is never OOB (l == r && r = size)
    int r = nums.size() - 1;
    int l = 0;
    int mid;
    int val;

    do {
      // l + ( r - l ) / 2 or (l + r) / 2 Both ok
      mid = (l + r) / 2;
      val = nums[mid];
      if (val == target) {
        return mid;
      } else if (val < target) {
        l = mid + 1;
      } else {
        r = mid - 1;
      }
    } while (l <= r);

    return -1;
  }
};
```
