Searching Algorithms

In computer science, searching is the process of finding a specific element in a collection of elements. There are various searching algorithms available, each with its own advantages and disadvantages.

Here are some commonly used searching algorithms:

• Linear Search: This algorithm sequentially checks each element in the collection until the target element is found or the end of the collection is reached. It is a simple but inefficient algorithm, especially for large collections.
• Binary Search: This algorithm is used to search for an element in a sorted collection. It works by repeatedly dividing the collection in half and checking if the target element is in the lower or upper half. Binary search is more efficient than linear search, as it eliminates half of the remaining elements in each iteration.
• Hashing: This algorithm uses a hash function to map elements to their corresponding positions in a data structure called a hash table. Hashing allows for constant time retrieval of elements in the average case.

Let's take a closer look at an example of the binary search algorithm in Java:

1const int[] arr = {2, 4, 6, 8, 10};
2const target = 6;
3
4const result = binarySearch(arr, target);
5
6console.log('Element found at index: ', result);
7
8function binarySearch(arr, target) {
9  let left = 0;
10  let right = arr.length - 1;
11
12  while (left <= right) {
13    let mid = Math.floor((left + right) / 2);
14
15    if (arr[mid] === target) {
16      return mid;
17    } else if (arr[mid] < target) {
18      left = mid + 1;
19    } else {
20      right = mid - 1;
21    }
22  }
23
24  return -1;
25}

The binary search algorithm has a time complexity of O(log n), making it very efficient for large collections. However, it requires the collection to be sorted beforehand.

It's important to choose the right searching algorithm based on the specific requirements of your problem and the characteristics of your data set.

xxxxxxxxxx

class Main {

  public static void main(String[] args) {

    int[] arr = {2, 4, 6, 8, 10};

    int target = 6;

    int result = binarySearch(arr, target);

    System.out.println("Element found at index: " + result);

  }

​

  public static int binarySearch(int[] arr, int target) {

    int left = 0;

    int right = arr.length - 1;

​

    while (left <= right) {

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

​

      if (arr[mid] == target) {

        return mid;

      } else if (arr[mid] < target) {

        left = mid + 1;

      } else {

        right = mid - 1;

      }

    }

​

    return -1;

  }

}