Lua - Binary Search

Binary Search is very popular and highly efficient searching algorithm. But a list must be sorted before using binary search. Binary Search algorithm works by dividing the list into two halves. If middle element is same as searched item, search is completed. Otherwise item is searched in first half if item is lesser than middle element else in second half if item is greater than middle element.

main.lua

-- function to search an item in the list
function binary_search(list, item)
   local low = 1 
   local high = #list 

   -- loop until low becomes same or higher as high
   while low <= high do
      local mid = math.floor((low + high) / 2)  -- compute middle index
      if list[mid] == item then   -- if item found
         return mid -- Return the index of the item
      elseif list[mid] < item then  -- if item is greater than middle item
         low = mid + 1 -- Perform search in the right half
      else
         high = mid - 1 -- Perform search in the left half
      end
   end
   return nil -- Return nil if the item is not found
end

-- Example Usage
local numbers = {1, 2, 4, 5, 8, 9}
local item = 8
local index = binary_search(numbers, item)
if index then
   print("Item", item, "found, index:", index) -- Output: Item 8 found at index: 3
else
   print("Item", item, "not found in the list.")
end

item = 3
index = binary_search(numbers, item)
if index then
   print("Item", item, "found at index:", index)
else
   print("Item", item, "not present.") -- Output: Item 3 not found in the list.
end

Output

When we run the above program, we will get the following output−

Item	8	found, index:	3
Item	3	not present.

Working of Binary Search

• low and high − We've initialized low as 1 and high as list length as initial list indexes. A loop is run till low becomes same or higher than high.

• Divide the list into two halves − A mid point is computed, and middle item is checked. If found, index is returned.

• Iterate sub list − Above steps are repeated for sublists after computing low and high.

• Not found − If complete list is iterated and item is not found then we're returning nil.

Time Complexity

• Worst Case O(log n) − where n is number of elements. Search is halved every time search is conducted if item is not present.

• Best Case O(1) − where item is the middle element of the list.

• Average Case O(log n) − Binary search halved the items to be searched in each iteration.

Space Complexity

• O(1) − Space complexity of binary search is constant as it is not requiring any extra memory from the list for any temporary storage. In case of recursive implementation, it is O(log n) as call stack is required.

When to use Binary Search

Binary search is very efficient and used in following areas −

• When list is sorted.

• When we need an efficient algorithm for large sorted data set.