Mastering Binary Search for efficient data retrieval.
Tags: programming, tutorial, softwaredevelopment
Published: 2024-02-23 20:32:48

## Introduction:
In the realm of software development, efficiency is paramount. Whether you're dealing with a small-scale application or a large-scale system, optimizing the retrieval of data is crucial for enhancing performance. One such technique that plays a pivotal role in efficient data retrieval is Binary Search. In this article, we'll delve into the practical aspects of Binary Search and how it can be effectively employed by developers, using the example of a common scenario: finding a user by their ID.

## Understanding Binary Search:
Binary Search is a fundamental algorithm used to locate a target value within a **sorted array** or **list**, if not sorted Binary Search just won't work. Unlike linear search, which traverses each element sequentially, Binary Search employs a divide-and-conquer strategy, making it significantly faster, especially for large datasets.

![Sweeper vs Splitter](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/qj8p2s7srtbswnlbslwt.png)

The basic idea behind Binary Search is to repeatedly divide the search interval in half until the target value is found or determined to be absent.

Check video bellow 🎥

{% youtube D7rA6nniYkQ %}


### Practical application: Finding user by ID

> "Where does this element appear in a list?"

Consider a scenario where you need to retrieve user information from a large based on their unique ID. Let's call this function `findUserById`. This function takes two parameters: the target user ID and a sorted array of users.

```javascript
const users = [
  { userId: 101, name: "Alice", role: "Admin" },
  { userId: 202, name: "Bob", role: "User" },
  { userId: 303, name: "Charlie", role: "User" },
  { userId: 404, name: "Dana", role: "Moderator" },
  // Assume the list goes on
];


function findUserById(users, targetId) {
  let left = 0;
  let right = users.length - 1;

  while (left <= right) {
    const middle = Math.floor((left + right) / 2);
    const currentId = users[middle].userId;

    if (currentId === targetId) {
      return users[middle]; // User found
    } else if (currentId < targetId) {
      left = middle + 1;
    } else {
      right = middle - 1;
    }
  }

  return null; // User not found
}

const user = findUserById(users, 303);

if (user) {
  console.log("User found:", user);
} else {
  console.log("User not found.");
}
```

**1.Initialization:**
- Initialize left and right pointers. left points to the start of the `array (0)`, and right points to the end of the array (`users.length - 1`).

**2.Iteration:**
- Enter a while loop that continues as long as left is less than or equal to right, ensuring that there's still a valid search space.
- Within the loop, calculate the middle index (middle) of the current search interval using the formula `Math.floor((left + right) / 2)`.

**3.Comparison:**
- Retrieve the userId of the element at the middle index `(currentId = users[middle].userId)`.
- Compare currentId with the targetId.
  - If they match, return the user object at that index `(users[middle])` indicating that the user is found.
  - If `currentId` is less than `targetId`, update left to `middle + 1` to search in the right half of the array.
  - If `currentId` is greater than `targetId`, update right to `middle - 1` to search in the left half of the array.

**4.Termination:**
- Continue the process until left is greater than right, indicating that the search interval is empty and the target user is not found.

**5.Result Handling:**
- After the function call, check if a user object is returned.
  - If a user object is returned, it means the user is found, and its details are logged.
  - If null is returned, it means the user is not found, and a corresponding message is logged.

## Conclusion:
Binary Search is a powerful tool in a developer's arsenal for efficient data retrieval. By leveraging its divide-and-conquer approach, developers can significantly **improve the performance of their applications**, especially when dealing with large datasets. The example of findUserById demonstrates how Binary Search can be practically implemented to efficiently locate user information based on their ID. As you continue your journey in software development, mastering Binary Search will undoubtedly enhance your ability to tackle complex data retrieval tasks with speed and precision.

**References:**
[Scrimba](https://scrimba.com/scrim/cPJqarfK?pl=pk57XHz) 
[HackerRank - Algorithms: Binary Search](https://www.youtube.com/watch?v=P3YID7liBug&list=PLLXdhg_r2hKA7DPDsunoDZ-Z769jWn4R8&index=30) 
[algorithm-visualizer](https://algorithm-visualizer.org/branch-and-bound/binary-search)