Understanding Linear Search

Imagine you're in a library trying to find a particular book among hundreds stacked on the shelves. How would you go about it? You'd probably start from one end, scanning each book until you find the one you seek. Congratulations, you've just performed a linear search!

In the world of programming, a linear search is akin to this process. It's a straightforward method of finding a target value within an array or list by sequentially checking each element until a match is found or the entire list is traversed.

Implementation in JavaScript

Let's dive into some JavaScript code to illustrate this concept:

function linearSearch(arr, target) {
    for (let i = 0; i < arr.length; i++) {
        if (arr[i] = target) {
            return i; // Return the index if target is found
        }
    }
    return -1; // Return -1 if target is not found
}

const myArray = [10, 23, 5, 7, 15, 29];
const targetValue = 7;

const resultIndex = linearSearch(myArray, targetValue);
if (resultIndex !== -1) {
    console.log(Found ${targetValue} at index ${resultIndex});
} else {
    console.log(${targetValue} not found in the array);
}

In this example, we define a linearSearch function that takes an array (arr) and a target value (target). We iterate through each element of the array using a loop, comparing each element with the target value. If we find a match, we return the index of that element. If no match is found after traversing the entire array, we return -1.

Time Complexity Analysis

Now, let's analyze the time complexity of the linear search algorithm. In the worst-case scenario, where the target element is not present in the array or is at the last position, we have to traverse all elements. Thus, the time complexity of linear search is O(n), where n is the number of elements in the array.