What Is Sequential Search Algorithm in Data Structure?
In data structures and algorithms, the sequential search algorithm, also known as linear search, is a simple method used to find a particular element in a collection of data. This algorithm sequentially checks each element in the data structure until a match is found or until all elements have been examined.
Let’s dive deeper into how this algorithm works and its time complexity.
How Does Sequential Search Algorithm Work?
The sequential search algorithm starts at the beginning of the data structure and compares each element with the Target element we are searching for. If a match is found, the search terminates, and the position of the match is returned.
If no match is found after examining all elements, the search returns a special value indicating that the element is not present in the data structure.
Here’s an example to illustrate how sequential search works:
function sequentialSearch(arr, Target) {
for (let i = 0; i < arr.length; i++) {
if (arr[i] === Target) {
return i; // Found at position i
}
}
return -1; // Not found
}
const numbers = [12, 34, 56, 78, 90];
const TargetNumber = 56;
const result = sequentialSearch(numbers, TargetNumber);
console.log(result); // Output: 2
In this example, we have an array of numbers and we are searching for the number "56". The sequential search algorithm iterates through each element of the array until it finds a match at index "2".
Time Complexity of Sequential Search Algorithm
The time complexity of the sequential search algorithm is O(n), where "n" is the number of elements in the data structure. This is because, in the worst-case scenario, where the Target element is at the end of the data structure or not present at all, we would need to iterate through all "n" elements.
It's important to note that sequential search performs a linear search, meaning that its execution time grows proportionally with the size of the data structure. As a result, it is not an efficient algorithm for large collections of data.
When to Use Sequential Search Algorithm?
While sequential search might not be the most efficient algorithm for large datasets, there are scenarios where it can be useful. Sequential search can be handy when:
- Working with small collections of data where efficiency is not a significant concern.
- The data is unsorted, and sorting it would take more time than performing a linear search.
- It's necessary to find multiple occurrences or positions of an element in the collection.
Conclusion
The sequential search algorithm, also known as linear search, is a straightforward method to find a specific element within a collection of data. It sequentially compares each element until a match is found or all elements have been examined.
While it may not be suitable for large datasets due to its linear time complexity, it can still be valuable in certain scenarios. Understanding this algorithm's principles and trade-offs will help you make informed decisions when solving real-world problems involving searching and retrieval of information.