Photo: Tanya Satina

Which is the best searching algo?

The binary search algorithm works on the principle of divide and conquer and it is considered the best searching algorithm because it's faster to run.

freecodecamp.org - Search Algorithms – Linear Search and Binary Search Code ...

What not to say in London?

10 Things You Should Never Say To a British Person “I love British accents!” ... “I can do the best British accent.” ... “Oh, you're from London!”...

Last updated Feb 5, 2019

What to do if you are addicted to gambling?

Treatment for compulsive gambling may involve an outpatient program, inpatient program or a residential treatment program, depending on your needs...

Last updated Jul 16, 2022

Make Your Bookie Cry And Pull The Hair By Generating $23,187

Promotion

Search algorithms are a fundamental computer science concept that you should understand as a developer. They work by using a step-by-step method to locate specific data among a collection of data. In this article, we'll learn how search algorithms work by looking at their implementations in Java and Python.

What is a Search Algorithm?

According to Wikipedia, a search algorithm is:

Any algorithm which solves the search problem, namely, to retrieve information stored within some data structure, or calculated in the search space of a problem domain, either with discrete or continuous values. Search algorithms are designed to check or retrieve an element from any data structure where that element is being stored. They search for a target (key) in the search space.

Types of Search Algorithms

In this post, we are going to discuss two important types of search algorithms:

Linear or Sequential Search Binary Search

Let's discuss these two in detail with examples, code implementations, and time complexity analysis.

Linear or Sequential Search

This algorithm works by sequentially iterating through the whole array or list from one end until the target element is found. If the element is found, it returns its index, else -1. Now let's look at an example and try to understand how it works:

arr = [2, 12, 15, 11, 7, 19, 45]

Suppose the target element we want to search is 7 .

Approach for Linear or Sequential Search

Start with index 0 and compare each element with the target

If the target is found to be equal to the element, return its index

If the target is not found, return -1

Code Implementation

Let's now look at how we'd implement this type of search algorithm in a couple different programming languages.

Linear or Sequential Search in Java

package algorithms.searching; public class LinearSearch { public static void main(String[] args) { int[] nums = {2, 12, 15, 11, 7, 19, 45}; int target = 7; System.out.println(search(nums, target)); } static int search(int[] nums, int target) { for (int index = 0; index < nums.length; index++) { if (nums[index] == target) { return index; } } return -1; } }

Linear or Sequential Search in Python

def search(nums, target): for i in range(len(nums)): if nums[i] == target: return i return -1 if __name__ == '__main__': nums = [2, 12, 15, 11, 7, 19, 45] target = 7 print(search(nums, target))

Time Complexity Analysis

The Best Case occurs when the target element is the first element of the array. The number of comparisons, in this case, is 1. So, the time complexity is O(1) . The Average Case: On average, the target element will be somewhere in the middle of the array. The number of comparisons, in this case, will be N/2. So, the time complexity will be O(N) (the constant being ignored). The Worst Case occurs when the target element is the last element in the array or not in the array. In this case, we have to traverse the entire array, and so the number of comparisons will be N. So, the time complexity will be O(N) .

Binary Search

This type of searching algorithm is used to find the position of a specific value contained in a sorted array. The binary search algorithm works on the principle of divide and conquer and it is considered the best searching algorithm because it's faster to run. Now let's take a sorted array as an example and try to understand how it works:

Which algorithm is best for prediction?

Regression and classification algorithms are the most popular options for predicting values, identifying similarities, and discovering unusual data...

Last updated Jan 26, 2019

Do we really lose our filter as we age?

It is particularly noticeable in the frontal lobes. Researchers have linked age-related shrinking in the frontal lobes with declines in inhibitory...

Last updated Jun 22, 2022

Promotion

arr = [2, 12, 15, 17, 27, 29, 45]

Suppose the target element to be searched is 17 .

Approach for Binary Search

Compare the target element with the middle element of the array.

If the target element is greater than the middle element, then the search continues in the right half. Else if the target element is less than the middle value, the search continues in the left half. This process is repeated until the middle element is equal to the target element, or the target element is not in the array If the target element is found, its index is returned, else -1 is returned.

Code Implementation

Binary Search in Java

package algorithms.searching; public class BinarySearch { public static void main(String[] args) { int[] nums = {2, 12, 15, 17, 27, 29, 45}; int target = 17; System.out.println(search(nums, target)); } static int search(int[] nums, int target) { int start = 0; int end = nums.length - 1; while (start <= end) { int mid = start + (end - start) / 2; if (nums[mid] > target) end = mid - 1; else if (nums[mid] < target) start = mid + 1; else return mid; } return -1; } }

Binary Search in Python

def search(nums, target): start = 0 end = len(nums)-1 while start <= end: mid = start + (end-start)//2 if nums[mid] > target: end = mid-1 elif nums[mid] < target: start = mid+1 else: return mid return -1 if __name__ == '__main__': nums = [2, 12, 15, 17, 27, 29, 45] target = 17 print(search(nums, target))

Time Complexity Analysis

The Best Case occurs when the target element is the middle element of the array. The number of comparisons, in this case, is 1. So, the time complexity is O(1) . The Average Case: On average, the target element will be somewhere in the array. So, the time complexity will be O(logN) . The Worst Case occurs when the target element is not in the list or it is away from the middle element. So, the time complexity will be O(logN) .

How to Calculate Time Complexity:

Let's say the iteration in Binary Search terminates after k iterations.

At each iteration, the array is divided by half. So let’s say the length of array at any iteration is N.

At Iteration 1,

Length of array = N

At Iteration 2,

Length of array = N/2

At Iteration 3,

Length of array = (N/2)/2 = N/2^2

At Iteration k,

Length of array = N/2^k

Also, we know that after k divisions, the length of the array becomes 1: Length of array = N⁄ 2 k = 1=> N = 2k If we apply a log function on both sides: log 2 (N) = log 2 (2k)=> log 2 (N) = k log 2 (2)

As (log a (a) = 1)

Therefore,=> k = log 2 (N)

So now we can see why the time complexity of Binary Search is log 2 (N). You can also visualize the above two algorithms using the simple tool built by Dipesh Patil - Algorithms Visualizer.

Order-agnostic Binary Search

Suppose, we have to find a target element in a sorted array. We know that the array is sorted, but we don’t know if it’s sorted in ascending or descending order.

Approach for Order-agnostic Binary Search

What casino game has the best odds?

blackjack If you're willing to put in a little work, blackjack offers the best odds. I'm talking about a . 5 percent casino edge, depending on...

Last updated Jun 15, 2021

What does +4.5 Bengals mean?

Cincinnati Bengals -4.5. Above is an football point spread. Pittsburgh is +4.5, with Cincinnati at -4.5, which means Pittsburgh is a 4.5-point...

Last updated Oct 6, 2018

Promotion

The implementation is similar to binary search except that we need to identify whether the array is sorted in ascending order or descending order. This then lets us make the decision about whether to continue the search in the left half of the array or the right half of the array.

We first compare the target with the middle element

If the array is sorted in ascending order and the target is less than the middle element OR the array is sorted in descending order and the target is greater than the middle element, then we continue the search in the lower half of the array by setting end=mid-1 . the array is sorted in descending order and the target is greater than the middle element, then we continue the search in the lower half of the array by setting . Otherwise, we perform the search in the upper half of the array by setting start=mid+1 The only thing we need to do is to figure out whether the array is sorted in ascending order or descending order. We can easily find this by comparing the first and last elements of the array. if arr[0] < arr[arr.length-1] array is sorted in ascending order else array is sorted in descending order

Code Implementation

Order-agnostic Binary Search in Java

package algorithms.searching; public class OrderAgnosticBinarySearch { public static void main(String[] args) { int[] nums1 = {-1, 2, 4, 6, 7, 8, 12, 15, 19, 32, 45, 67, 99}; int[] nums2 = {99, 67, 45, 32, 19, 15, 12, 8, 7, 6, 4, 2, -1}; int target = -1; System.out.println(search(nums1, target)); System.out.println(search(nums2, target)); } static int search(int[] arr, int target) { int start = 0; int end = arr.length - 1; boolean isAscending = arr[start] < arr[end]; while (start <= end) { int mid = start + (end - start) / 2; if (target == arr[mid]) return mid; if (isAscending) { if (target < arr[mid]) { end = mid - 1; } else { start = mid + 1; } } else { if (target < arr[mid]) { start = mid + 1; } else { end = mid - 1; } } } return -1; } }

Order-agnostic Binary Search in Python

def search(nums, target): start = 0 end = len(nums)-1 is_ascending = nums[start] < nums[end] while start <= end: mid = start + (end-start)//2 if target == nums[mid]: return mid if is_ascending: if target < nums[mid]: end = mid-1 else: start = mid+1 else: if target < nums[mid]: start = mid+1 else: end = mid-1 return -1 if __name__ == '__main__': nums1 = [-1, 2, 4, 6, 7, 8, 12, 15, 19, 32, 45, 67, 99] nums2 = [99, 67, 45, 32, 19, 15, 12, 8, 7, 6, 4, 2, -1] target = -1 print(search(nums1, target)) print(search(nums2, target))

Time Complexity Analysis

There will be no change in the time complexity, so it will be the same as Binary Search.

Conclusion

In this article, we discussed two of the most important search algorithms along with their code implementations in Python and Java. We also looked at their time complexity analysis.

Thanks for reading!

freecodecamp.org - Search Algorithms – Linear Search and Binary Search Code ...

How often do all favored teams win?

How often do moneyline favorites win in NBA? Over the past five seasons, 67.25% of favorites have been successful in the NBA regular season. Aug...

Last updated Dec 3, 2021

Can you get hired even if you fail a drug test?

Can You Still Get Hired If You Fail a Drug Test? For the most part, no. If the test result is proven to be legitimate (especially after multiple...

Last updated Nov 28, 2021

Promotion

Who is most affected by gambling?

White men are 72% more likely to develop a gambling addiction than 54% of Black males. These men also tend to be in the lowest income bracket and...

Last updated Oct 13, 2019

Promotion

Are promoters allowed to bet?

Eddie Hearn has revealed he and fellow Jake Paul have been forced to cancel their $1million bet on the outcome of the Katie Taylor vs Amanda...

Last updated Nov 19, 2018