Scribd
Upload
7 views3 pages

Binary Search C

Uploaded by

santosh.chandu2707
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as TXT, PDF, TXT or read online on Scribd
7 views3 pages

Binary Search C

Uploaded by

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

#include <stdio.

h>

// Iterative Binary Search implementation


int binary_search_iterative(int arr[], int size, int target) {
int left = 0;
int right = size - 1;

// Continue searching while the search range is valid


while (left <= right) {
// Calculate the middle index
int mid = left + (right - left) / 2;

// Check if target is present at mid


if (arr[mid] == target) {
return mid; // Target found, return its index
}

// If target is greater, ignore left half


if (arr[mid] < target) {
left = mid + 1;
}
// If target is smaller, ignore right half
else {
right = mid - 1;
}
}

// Target was not found


return -1;
}

// Recursive Binary Search implementation


int binary_search_recursive(int arr[], int left, int right, int target) {
// Base case: target not found
if (left > right) {
return -1;
}

// Calculate the middle index


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

// If target is present at mid, return its index


if (arr[mid] == target) {
return mid;
}

// If target is smaller than mid element, search left half


if (target < arr[mid]) {
return binary_search_recursive(arr, left, mid - 1, target);
}

// If target is larger than mid element, search right half


return binary_search_recursive(arr, mid + 1, right, target);
}

// Example usage of binary search


int main() {
// Sample SORTED array (binary search requires a sorted array)
int arr[] = {10, 20, 30, 40, 50, 60, 70, 80, 90, 100};
int size = sizeof(arr) / sizeof(arr[0]);

// Elements to search
int target1 = 50; // Element present in the array
int target2 = 35; // Element not in the array

// Iterative Binary Search


printf("Iterative Binary Search:\n");
int iterative_result1 = binary_search_iterative(arr, size, target1);
int iterative_result2 = binary_search_iterative(arr, size, target2);

if (iterative_result1 != -1) {
printf("%d found at index %d (Iterative)\n", target1, iterative_result1);
} else {
printf("%d not found in the array (Iterative)\n", target1);
}

if (iterative_result2 != -1) {
printf("%d found at index %d (Iterative)\n", target2, iterative_result2);
} else {
printf("%d not found in the array (Iterative)\n", target2);
}

// Recursive Binary Search


printf("\nRecursive Binary Search:\n");
int recursive_result1 = binary_search_recursive(arr, 0, size - 1, target1);
int recursive_result2 = binary_search_recursive(arr, 0, size - 1, target2);

if (recursive_result1 != -1) {
printf("%d found at index %d (Recursive)\n", target1, recursive_result1);
} else {
printf("%d not found in the array (Recursive)\n", target1);
}

if (recursive_result2 != -1) {
printf("%d found at index %d (Recursive)\n", target2, recursive_result2);
} else {
printf("%d not found in the array (Recursive)\n", target2);
}

return 0;
}

/*
Binary Search Key Characteristics:
1. PREREQUISITES:
- Array MUST be sorted in ascending order
- Elements must be comparable and have a natural ordering

2. Time Complexity:
- Best Case: O(1) - when middle element is the target
- Worst Case: O(log n) - when target is at the beginning/end or not present
- Average Case: O(log n)

3. Space Complexity:
- Iterative Version: O(1) - uses constant extra space
- Recursive Version: O(log n) - due to recursive call stack

4. Advantages:
- Extremely efficient for large sorted arrays
- Dramatically reduces search space in each iteration
- Much faster than linear search for large datasets

5. Disadvantages:
- Requires sorted array (preprocessing cost)
- Not suitable for unsorted arrays
- Less efficient for small arrays due to overhead
- More complex implementation compared to linear search

Comparison Notes:
- Linear Search: O(n) time complexity
- Binary Search: O(log n) time complexity
- Binary search becomes significantly more efficient as array size increases
*/

You might also like