Home - News ( United States | United Kingdom | Italy | Germany ) - Football scores

Showing content from https://www.geeksforgeeks.org/introduction-to-searching-data-structure-and-algorithm-tutorial/ below:

Introduction to Searching - Data Structure and Algorithm Tutorial

Searching is the fundamental process of locating a specific element or item within a collection of data. This collection of data can take various forms, such as arrays, lists, trees, or other structured representations.

The primary objective of searching is to determine whether the desired element exists within the data, and if so, to identify its precise location or retrieve it. It plays an important role in various computational tasks and real-world applications, including information retrieval, data analysis, decision-making processes, and more.

• Efficiency: Efficient searching algorithms improve program performance.
• Data Retrieval: Quickly find and retrieve specific data from large datasets.
• Database Systems: Enables fast querying of databases.
• Problem Solving: Used in a wide range of problem-solving tasks.

Understanding the characteristics of searching in data structures and algorithms is crucial for designing efficient algorithms and making informed decisions about which searching technique to employ. Here, we explore key aspects and characteristics associated with searching:

In searching, there is always a specific target element or item that you want to find within the data collection. This target could be a value, a record, a key, or any other data entity of interest.

The search space refers to the entire collection of data within which you are looking for the target element. Depending on the data structure used, the search space may vary in size and organization.

Searching can have different levels of complexity depending on the data structure and the algorithm used. The complexity is often measured in terms of time and space requirements.

Some searching algorithms, like binary search, are deterministic, meaning they follow a clear and systematic approach. Others, such as linear search, are non-deterministic, as they may need to examine the entire search space in the worst case.

Searching algorithms have numerous applications across various fields. Here are some common applications:

• Information Retrieval: Search engines like Google, Bing, and Yahoo use sophisticated searching algorithms to retrieve relevant information from vast amounts of data on the web.
• Database Systems: Searching is fundamental in database systems for retrieving specific data records based on user queries, improving efficiency in data retrieval.
• E-commerce: Searching is crucial in e-commerce platforms for users to find products quickly based on their preferences, specifications, or keywords.
• Networking: In networking, searching algorithms are used for routing packets efficiently through networks, finding optimal paths, and managing network resources.
• Artificial Intelligence: Searching algorithms play a vital role in AI applications, such as problem-solving, game playing (e.g., chess), and decision-making processes
• Pattern Recognition: Searching algorithms are used in pattern matching tasks, such as image recognition, speech recognition, and handwriting recognition.

Searching Algorithms are designed to check for an element or retrieve an element from any data structure where it is stored.

Below are some searching algorithms:

1. Linear Search
2. Binary Search
3. Ternary Search
4. Jump Search
5. Interpolation Search
6. Fibonacci Search
7. Exponential Search

Linear Search, also known as Sequential Search, is one of the simplest and most straightforward searching algorithms. It works by sequentially examining each element in a collection of data(array or list) until a match is found or the entire collection has been traversed.

• The Algorithm examines each element, one by one, in the collection, treating each element as a potential match for the key you're searching for.
• If it finds any element that is exactly the same as the key you're looking for, the search is successful, and it returns the index of key.
• If it goes through all the elements and none of them matches the key, then that means "No match is Found".

Consider the array arr[] = {10, 50, 30, 70, 80, 20, 90, 40} and key = 30

Start from the first element (index 0) and compare key with each element (arr[i]). Comparing key with first element arr[0]. Since not equal, the iterator moves to the next element as a potential match.

Comparing key with next element arr[1]. Since not equal, the iterator moves to the next element as a potential match.

Now when comparing arr[2] with key, the value matches. So the Linear Search Algorithm will yield a successful message and return the index of the element when key is found.

LinearSearch(collection, key):

for each element in collection:

if element is equal to key:

return the index of the element

return "Not found"

• Time Complexity:
  • Best Case: In the best case, the key might be present at the first index. So the best case complexity is O(1)
  • Worst Case: In the worst case, the key might be present at the last index i.e., opposite to the end from which the search has started in the list. So the worst-case complexity is O(N) where N is the size of the list.
  • Average Case: O(N)
• Auxiliary Space: O(1) as except for the variable to iterate through the list, no other variable is used.

• When there is small collection of data.
• When data is unordered.

Binary Search is defined as a searching algorithm used in a sorted array by repeatedly dividing the search interval in half. The idea of binary search is to use the information that the array is sorted and reduce the time complexity to O(log N).

• Divide the search space into two halves by finding the middle index “mid”.
• Compare the middle element of the search space with the key.
• If the key is found at middle element, the process is terminated.
• If the key is not found at middle element, choose which half will be used as the next search space.
  • If the key is smaller than the middle element, then the left side is used for next search.
  • If the key is larger than the middle element, then the right side is used for next search.
• This process is continued until the key is found or the total search space is exhausted.

Consider an array arr[] = {2, 5, 8, 12, 16, 23, 38, 56, 72, 91}, and the target = 23.

• Calculate the mid and compare the mid element with the key. If the key is less than mid element, move to left and if it is greater than the mid then move search space to the right.
• Key (i.e., 23) is greater than current mid element (i.e., 16). The search space moves to the right.

• Key is less than the current mid 56. The search space moves to the left.

• If the key matches the value of the mid element, the element is found and stop search.

Below is the pseudo code for implementing binary search:

binarySearch(collection, key):

left = 0

right = length(collection) - 1

while left <= right:

mid = (left + right) // 2

if collection[mid] == key:

return mid

elif collection[mid] < key:

left = mid + 1

else:

right = mid - 1

return "Not found"

• Time Complexity:
  • Best Case: O(1) - When the key is found at the middle element.
  • Worst Case: O(log N) - When the key is not present, and the search space is continuously halved.
  • Average Case: O(log N)
• Auxiliary Space: O(1)

• When the data collection is monotonic (essential condition) in nature.
• When efficiency is required, specially in case of large datasets.

Ternary Search is a searching algorithm that divides the search space into three parts instead of two, as in Binary Search. It is very useful in the case of unimodal functions.

• In Ternary Search, start with two midpoints, oneThird and twoThirds, which divide the collection into three roughly equal parts.
• Compare the elements at oneThird and twoThirds with the target key you're searching for.
• Three Possibilities:
  • If oneThird contains the key, you're done and return the index of oneThird.
  • If twoThirds contains the key, you're done and return the index of twoThirds.
  • If the key is less than the element at oneThird, eliminate the rightmost one-third of the collection and focus on the left two-thirds.
• If the key is greater than the element at twoThirds, eliminate the leftmost one-third of the collection and focus on the right two-thirds.
• Repeat this process iteratively until either key is found or determine that it's not present in the collection.

Consider an array arr[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}, and the target = 6.

Ternary Search

• Time Complexity:
  • Best Case: O(1)
  • Worst Case: O(log₃N)
  • Average Case: O(log₃N)
• Auxiliary Space: O(1)

Jump Search is another searching algorithm that can be used on sorted collections (arrays or lists). The idea is to reduce the number of comparisons by jumping ahead by fixed steps or skipping some elements in place of searching all elements.

Let’s consider the following array: (0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610).

The length of the array is 16. The Jump search will find the value of 55 with the following steps assuming that the block size to be jumped is 4.

• Jump from index 0 to index 4;
• Jump from index 4 to index 8;
• Jump from index 8 to index 12;
• Since the element at index 12 is greater than 55, we will jump back a step to come to index 8.
• Perform a linear search from index 8 to get the element 55.

• Time Complexity: O(√n), where "n" is the number of elements in the collection. This makes it more efficient than Linear Search but generally less efficient than Binary Search for large datasets.
• Auxiliary Space: O(1), as it uses a constant amount of additional space for variables.

linear search < jump search < binary search

Interpolation Search is an efficient searching algorithm for sorted collections of data, such as arrays or lists. It is an improvement over Binary Search, particularly when the data is uniformly distributed.

Fibonacci Search is an efficient searching algorithm used for finding a target value in a sorted collection, such as an array or list. It is similar in principle to Binary Search but uses Fibonacci numbers to determine the positions to be compared.

Exponential Search is a searching algorithm designed to find a target value in a sorted collection, such as an array or list. It combines elements of Binary Search and Linear Search to efficiently locate the target, especially when its position is near the beginning of the collection.

1. Count 1’s in a sorted binary array
2. Ceiling in a sorted array
3. k largest(or smallest) elements in an array
4. Kth smallest element in a row-wise and column-wise sorted 2D array
5. Given an array of of size n and a number k, find all elements that appear more than n/k times.

1. Find a peak element
2. Search an element in a sorted and rotated array
3. Find the minimum element in a sorted and rotated array
4. Find the closest pair from two sorted arrays
5. Allocate Minimum Number of Pages from N books to M students
6. Assign stalls to K cows to maximize the minimum distance between them

1. Median of two sorted arrays
2. Median of two sorted arrays of different sizes
3. Search in an almost sorted array
4. Find position of an element in a sorted array of infinite numbers
5. Given a sorted and rotated array, find if there is a pair with a given sum
6. Longest Increasing Subsequence Size (N log N)

RetroSearch is an open source project built by @garambo | Open a GitHub Issue

Search and Browse the WWW like it's 1997 | Search results from DuckDuckGo

HTML: 3.2 | Encoding: UTF-8 | Version: 0.7.4