# best case complexity of binary search

Worst case is O(log2(n)) as the number of times you can divide the list up in 2 is the maximum times you'll have to compare elements in a binary search. In general, time complexity is O(h) where h is height of BST. The best case of binary search is when the first comparison/guess is correct(the key item is equal to the mid of array). One place where you might have heard about O(log n) time complexity the first time is Binary search algorithm. The best case scenario for this search is that the target value is at the very center of the data you're searching. Binary Search with complexity O(log n) Search using HASH value with complexity O(1) Linear Search with complexity O(n): Here for a given element, say a[i], we have to traverse the entire data structure till we find the element, so in the worst case we have to traverse till end of the DS and hence the order/complexity of linear search is O(n) For a binary search, the best-case occurs when the target item is in the beginning of the search list. Therefore, searching in binary search tree has worst case complexity of O(n). For a binary search, the worst-case is when the target item is not in the search list. For a binary search, the best-case occurs when the target is at the end of the search list. So time complexity in the best case would be Θ(1) Most of the times, we do worst case analysis to analyze algorithms. The number of operations in the best case is constant (not dependent on n). This is called big O notation. In other cases N/2 x where x is such that 2 x < N Minimum value of x can be 1, which is the best case. Complexity. ; Insertion: For inserting element 0, it must be inserted as left child of 1. The time complexity of the binary search algorithm belongs to the O(log n) class. In the linear search problem, the best case occurs when x is present at the first location. Take a binary search for example. You could get lucky and the element you want is in the middle of the list. Searching: For searching element 1, we have to traverse all elements (in order 3, 2, 1). Best case is O(1). You could get lucky and the element you want is in the middle of the list. So there must be some type of behavior that algorithm is showing to be given a complexity of log n. Let us see how it works.