Scribd
Upload
5 views3 pages

Binary search is an efficient algorithm for finding an element within a sorted array

The document explains the binary search algorithm for finding a target element in a sorted array, using the example of locating the number 23 in the array {2, 5, 8, 12, 16, 23, 38, 56, 72, 91}. It details the step-by-step process of initializing pointers, calculating the middle index, and adjusting the search range based on comparisons. A code snippet in C++ is also provided to implement the binary search algorithm.

Uploaded by

Shree Akshitha Vimala Saravanan
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as DOCX, PDF, TXT or read online on Scribd
5 views3 pages

Binary search is an efficient algorithm for finding an element within a sorted array

The document explains the binary search algorithm for finding a target element in a sorted array, using the example of locating the number 23 in the array {2, 5, 8, 12, 16, 23, 38, 56, 72, 91}. It details the step-by-step process of initializing pointers, calculating the middle index, and adjusting the search range based on comparisons. A code snippet in C++ is also provided to implement the binary search algorithm.

Uploaded by

Shree Akshitha Vimala Saravanan
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as DOCX, PDF, TXT or read online on Scribd
You are on page 1/ 3

Binary search is an efficient algorithm for finding an element within a sorted array.

Let’s walk through


the steps to find the target element 23 in the array `arr[] = {2, 5, 8, 12, 16, 23, 38, 56, 72, 91}`:

1. Initialize two pointers: `left` at the start (index 0) and `right` at the end (index 9) of the array.

2. Calculate the middle index: `middle = left + (right - left) / 2`. In the first iteration, `middle = 0 + (9 - 0) /
2 = 4`.

3. Compare `arr[middle]` with the target value 23:

- If `arr[middle]` is equal to the target, return the index.

- If `arr[middle]` is less than the target, set `left = middle + 1` and repeat from step 2.

- If `arr[middle]` is greater than the target, set `right = middle - 1` and repeat from step 2.

Here's the step-by-step process:

- Initial array: `{2, 5, 8, 12, 16, 23, 38, 56, 72, 91}`

- Target: `23`

1. Initial indices: `left = 0`, `right = 9`

2. Calculate `middle = 0 + (9 - 0) / 2 = 4`

- `arr[4] = 16`, which is less than 23. Set `left = 4 + 1 = 5`

3. Now, `left = 5`, `right = 9`

4. Calculate `middle = 5 + (9 - 5) / 2 = 7`

- `arr[7] = 56`, which is greater than 23. Set `right = 7 - 1 = 6`

5. Now, `left = 5`, `right = 6`

6. Calculate `middle = 5 + (6 - 5) / 2 = 5`

- `arr[5] = 23`, which is equal to the target.

Thus, the target element `23` is found at index `5` in the array.

Would you like a code snippet to implement this in a specific programming language?
#include <iostream>

using namespace std;

int binarySearch(int arr[], int left, int right, int target) {

while (left <= right) {

int middle = left + (right - left) / 2;

// Check if target is present at mid

if (arr[middle] == target)

return middle;

// If target greater, ignore left half

if (arr[middle] < target)

left = middle + 1;

// If target is smaller, ignore right half

else

right = middle - 1;

// If target is not present in array

return -1;

int main() {

int arr[] = {2, 5, 8, 12, 16, 23, 38, 56, 72, 91};

int n = sizeof(arr) / sizeof(arr[0]);

int target = 23;

int result = binarySearch(arr, 0, n - 1, target);


if (result != -1)

cout << "Element found at index " << result << endl;

else

cout << "Element not found in array" << endl;

return 0;

You might also like