xxxxxxxxxx
def binary_search(group, suspect):
group.sort()
midpoint = len(group)//2
while(True):
if(group[midpoint] == suspect):
return midpoint
if(suspect > group[midpoint]):
group = group[midpoint]
if(suspect < group[midpoint]):
group = group[0: midpoint]
midpoint = (len(group)//2)
xxxxxxxxxx
def binarySearch(array, target): #returns the index or the target
low = array[0]
high = array[len(array)-1]
if array[0] == target:
return 0
elif array[len(array)-1] == target:
return len(array)-1
else:
while(low <= high):
mid = int((low+high)/2)
if array[mid]==target:
return mid
elif array[mid] > target:
high = mid -1
elif array[mid] < target:
low = mid +1
return -1 #returns -1 if the target does not exist
xxxxxxxxxx
def binary_search(arr, x):
low = 0
high = len(arr) - 1
mid = 0
while low <= high:
mid = (high + low) // 2
// if index of the arr given by the mid isnt matching x,
// Keep adding, else subtract one in order to get the correct mid
// value.
if arr[mid] < x:
low = mid + 1
elif arr[mid] > x:
high = mid - 1
else:
return mid
return -1
arr = [ 2, 3, 4, 10, 40 ]
x = 2
result = binary_search(arr, x)
if result != -1:
print("Element is presented at index" , str(result))
else:
print("Element is not presented in array")
xxxxxxxxxx
#blog.icodes.tech
def binary_search(item,my_list):
found=False
first=0
last=len(my_list)-1
while first <=last and found==False:
midpoint=(first+last)//2
if my_list[midpoint]==item:
found=True
else:
if my_list[midpoint]<item:
first=midpoint+1
else:
last=midpoint-1
return found
xxxxxxxxxx
def bs(arr, key):
low = 0
high = len(arr) - 1
while low <= high:
mid = low + ((high - low) // 2)
midV = arr[mid]
if midV < key:
low = mid + 1
elif midV > key:
high = mid - 1
else:
return mid
return -1
xxxxxxxxxx
'''# Returns index of x in arr, or -1 if not found'''
def binary_search(arr, x):
# Initialize start and end pointers
start = 0
end = len(arr)-1
# Loop until start and end pointers meet
while start <= end:
# Calculate middle index
mid = (start + end) // 2
# Check if x is at middle index
if arr[mid] == x:
return mid
# If x is smaller than middle element, it must be in left subarray
elif x < arr[mid]:
end = mid - 1
# If x is larger than middle element, it must be in right subarray
else: start = mid + 1
# If x is not found, return -1
return -1
# Example usage
arr = [1, 3, 5, 7, 9, 11, 13, 15]
x = 11
result = binary_search(arr, x)
print(f"Element {x} found at index {result}")
xxxxxxxxxx
from bisect import bisect_right, bisect_left
'right border index := index of leftmost value > x'
bisect_right(arr, x) # may be equal to len(arr)
'left border index := index of rightmost value < x'
bisect_left(arr, x) - 1 # may be equal to -1
def first_occurence(a, x): # equal to a.index(x) but faster
'Locate the leftmost value = x'
i = bisect_left(a, x)
if i == len(a) or a[i] != x:
raise ValueError
return i
def last_occurence(a, x):
'Locate the rightmost value = x'
i = bisect_right(a, x) - 1
if i == -1 or a[i] != x:
raise ValueError
return i
xxxxxxxxxx
def binary_search(l : list, z : int) -> int: # z = the value being searched
front = 0
rear = len(l) - 1
mid = (front + rear) // 2
while front <= rear and l[mid] != z:
if l[mid] > z:
rear = mid - 1
else:
front = mid + 1
mid = (front + rear) // 2
return mid if l[mid] == z else -1
xxxxxxxxxx
def binary_search_recursive(list_of_numbers, number, start=0, end=None):
# The end of our search is initialized to None. First we set the end to the length of the sequence.
if end is None:
end = len(list_of_numbers) - 1
if start > end:
# This will happen if the list is empty of the number is not found in the list.
raise ValueError('Number not in list')
mid = (start + end) // 2 # This is the mid value of our binary search.
if number == list_of_numbers[mid]:
# We have found the number in our list. Let's return the index.
return mid
if number < list_of_numbers[mid]:
# Number lies in the lower half. So we call the function again changing the end value to 'mid - 1' Here we are entering the recursive mode.
return binary_search_recursive(list_of_numbers, number, start, mid - 1)
# number > list_of_numbers[mid]
# Number lies in the upper half. So we call the function again changing the start value to 'mid + 1' Here we are entering the recursive mode.
return binary_search_recursive(list_of_numbers, number, mid + 1, end)
xxxxxxxxxx
def search(n, value):
if value == n.value:
return n
elif value < n.value and n.left is not None:
return search(n.left, value) #recur on left subtree
elif value > n.value and n.right is not None:
return search(n.right, value) #recur on right subtree
return n #unsuccessiful search