Example usage

In the previous tutorial, we explored simple sorting algorithms such as bubble sort and selection sort. In this tutorial, we shift our focus to searching algorithms, specifically implementing a basic searching algorithm. The primary goal of a searching algorithm is to locate the position of a specific value within a dataset—or determine whether that value exists at all.

1. Introduction to Searching Algorithms

Searching algorithms are generally categorized into two main types: linear search and binary search. We’ll focus on linear search here, as it’s intuitive and ideal for beginners.

1.1 Linear Search

Linear search (also known as sequential search) is a straightforward searching method. It works by examining each element in a data collection one by one—starting from the first—until either the target element is found or all elements have been checked.

1.1.1 Algorithm Steps

1. Start from the first element of the collection.
2. Check whether the current element equals the target value.
3. If it matches, return the index (position) of that element.
4. If it does not match, proceed to the next element.
5. If the end of the collection is reached without finding the target, return a “not found” message.

2. Implementing Linear Search

Next, we implement a simple linear search algorithm using Python.

2.1 Code Implementation

def linear_search(arr, target):
    """
    Linear search algorithm
    :param arr: The collection of elements to search
    :param target: The target value to find
    :return: A message indicating the position of the target, or "not found"
    """
    for index in range(len(arr)):
        if arr[index] == target:
            return f"Target value {target} found at index {index}"
    return f"Target value {target} not found"

# Example usage
numbers = [4, 2, 7, 1, 3]
target_value = 7
result = linear_search(numbers, target_value)
print(result)

2.2 Example Walkthrough

In the code above, we define a function linear_search that takes a list arr and a target value as inputs. The function iterates through the entire list, comparing each element with the target. If a match is found, it returns the index; otherwise, it returns a “not found” message.

For example, with numbers = [4, 2, 7, 1, 3] and target_value = 7, the function returns "Target value 7 found at index 2". If we instead set target_value = 5, the output becomes "Target value 5 not found".

3. Time Complexity of Linear Search

The time complexity of linear search is $O(n)$, where $n$ is the number of elements in the dataset. This means that, in the worst case, the algorithm’s runtime grows linearly with the size of the input.

4. Summary

In this tutorial, we implemented a simple linear search algorithm and learned how to traverse a list to locate a target element’s position. Though fundamental, this technique remains practical and effective in many real-world scenarios.

In the next tutorial, we’ll tackle a hands-on project assignment—applying the sorting and searching algorithms covered so far to solve a realistic programming problem. Get ready! You’ll combine everything you’ve learned into an engaging, end-to-end coding project.