Data Structure
Networking
RDBMS
Operating System
Java
MS Excel
iOS
HTML
CSS
Android
Python
C Programming
C++
C#
MongoDB
MySQL
Javascript
PHP
Physics
Chemistry
Biology
Mathematics
English
Economics
Psychology
Social Studies
Fashion Studies
Legal Studies
- Selected Reading
- UPSC IAS Exams Notes
- Developer's Best Practices
- Questions and Answers
- Effective Resume Writing
- HR Interview Questions
- Computer Glossary
- Who is Who
Binary Search in PHP
What is Binary Search?
Binary search is a search algorithm used to find the position of a target value within a sorted array (or list) efficiently. It works by repeatedly dividing the search range in half and comparing the middle element with the target value.
The binary search algorithm follows these steps:
Start with the entire sorted array.
Set the left pointer to the first element of the array and the right pointer to the last element.
Calculate the middle index as the average of the left and right pointers (integer division).
Compare the value at the middle index with the target value.
If the middle value is equal to the target value, the search is successful, and the algorithm returns the index.
If the target value is greater than the middle value, eliminate the left half of the search range by updating the left pointer to mid + 1.
If the target value is smaller than the middle value, eliminate the right half of the search range by updating the right pointer to mid - 1.
Repeat steps 3 to 7 until the target value is found or the search range is empty (left pointer is greater than right pointer).
If the search range is empty and the target value is not found, the algorithm concludes that the target value is not present in the array and returns -1 or an appropriate indication.
Binary search is a very efficient algorithm with a time complexity of O(log n), where n is the number of elements in the array. It is particularly effective for large sorted arrays as it quickly narrows down the search range by dividing it in half at each step, allowing for rapid search even with a large number of elements.
PHP program for Binary Search
Method 1- Using iteration
Example
<?php
function binarySearch($arr, $target) {
$left = 0;
$right = count($arr) - 1;
while ($left <= $right) {
$mid = floor(($left + $right) / 2);
// Check if the target value is found at the middle index
if ($arr[$mid] === $target) {
return $mid;
}
// If the target is greater, ignore the left half
if ($arr[$mid] < $target) {
$left = $mid + 1;
}
// If the target is smaller, ignore the right half
else {
$right = $mid - 1;
}
}
// Target value not found in the array
return -1;
}
// Example usage 1
$sortedArray = [2, 5, 8, 12, 16, 23, 38, 56, 72, 91];
$targetValue = 91;
$resultIndex = binarySearch($sortedArray, $targetValue);
if ($resultIndex === -1) {
echo "Target value not found in the array.<br>";
} else {
echo "Target value found at index $resultIndex.<br>";
}
// Example usage 2
$targetValue = 42;
$resultIndex = binarySearch($sortedArray, $targetValue);
if ($resultIndex === -1) {
echo "Target value not found in the array.";
} else {
echo "Target value found at index $resultIndex.";
}
?>
Output
Target value found at index 9. Target value not found in the array.
Method 2- Using recursion
Example
<?php
function binarySearchRecursive($arr, $target, $left, $right) {
if ($left > $right) {
// Target value not found in the array
return -1;
}
$mid = floor(($left + $right) / 2);
// Check if the target value is found at the middle index
if ($arr[$mid] === $target) {
return $mid;
}
// If the target is greater, search the right half
if ($arr[$mid] < $target) {
return binarySearchRecursive($arr, $target, $mid + 1, $right);
}
// If the target is smaller, search the left half
return binarySearchRecursive($arr, $target, $left, $mid - 1);
}
// Wrapper function for the recursive binary search
function binarySearch($arr, $target) {
$left = 0;
$right = count($arr) - 1;
return binarySearchRecursive($arr, $target, $left, $right);
}
// Example usage
$sortedArray = [2, 5, 8, 12, 16, 23, 38, 56, 72, 91];
$targetValue = 16;
$resultIndex = binarySearch($sortedArray, $targetValue);
if ($resultIndex === -1) {
echo "Target value not found in the array.";
} else {
echo "Target value found at index $resultIndex.";
}
?>
Output
Target value found at index 4.
Conclusion
In Conclusion, Binary search is a powerful algorithm for efficiently finding a target value in a sorted array. It offers two common implementations: iterative and recursive. The iterative approach uses a while loop to repeatedly divide the search range in half until the target value is found or the range becomes empty. It has a straightforward implementation and is well-suited for most scenarios. On the other hand, the recursive method employs a recursive function to perform the binary search. It follows the same logic as the iterative approach but uses function calls instead of a loop. Recursive binary search provides a more concise implementation but may have slightly higher overhead due to function call stack operations. Overall, both methods offer efficient and reliable ways to perform binary search operations.
733 Views
