Sequential Search and Binary Search

Definition

Searching is the process of locating a specific element, called the key or target, within a collection of data.

Two fundamental searching algorithms are:

Sequential Search (Linear Search) — checks elements one by one.
Binary Search — repeatedly divides a sorted search range in half.

Key Points

Sequential Search examines elements from beginning to end until the target is found.
Sequential Search does not require sorted data.
Binary Search repeatedly divides the search range into two halves.
Binary Search requires sorted data.
Sequential Search has:
- Best case: O(1)
- Average case: O(n)
- Worst case: O(n)
Binary Search has:
- Best case: O(1)
- Average case: O(log n)
- Worst case: O(log n)
Iterative implementations of both algorithms use O(1) extra space.
Binary Search is significantly more efficient than Sequential Search for large, sorted datasets.
Binary Search works especially well with arrays and vectors because they provide efficient random access.

Example / Code

Sequential Search (Linear Search)

Definition

Sequential Search, also called Linear Search, searches for an element by checking each element sequentially.

It starts at the first element and continues until:

The target is found, or
All elements have been checked.

Example

Given:

[10, 25, 30, 45, 60]

Search for:

The algorithm checks:

10 → 25 → 30

Since 30 is found at index 2, the search stops.

Pseudocode

SEQUENTIAL_SEARCH(arr, n, key)

for i = 0 to n-1
    if arr[i] == key
        return i

return -1

A return value of -1 indicates that the target was not found.

C++ Implementation

#include <iostream>
using namespace std;

int linearSearch(int arr[], int n, int key) {
    for (int i = 0; i < n; i++) {
        if (arr[i] == key)
            return i;
    }

    return -1;
}

int main() {
    int arr[] = {10, 25, 30, 45, 60};
    int n = 5;
    int key = 30;

    int result = linearSearch(arr, n, key);

    if (result != -1)
        cout << "Element found at index: " << result << endl;
    else
        cout << "Element not found" << endl;

    return 0;
}

Code Explanation

for (int i = 0; i < n; i++)

Starts at index 0 and checks every element until the end of the array.

if (arr[i] == key)

Compares the current element with the target.

return i;

Returns the index immediately when the target is found.

return -1;

Indicates that the target does not exist in the array.

Working Principle

Suppose:

Array:  [10, 25, 30, 45, 60]
Key:    45

Search sequence:

Result:

Index = 3

If the key is 100:

10 → 25 → 30 → 45 → 60

All elements are checked and the result is:

-1

Time and Space Complexity

Case	Complexity
Best Case	O(1)
Average Case	O(n)
Worst Case	O(n)
Space	O(1)

Why?

In the best case, the target is the first element, so only one comparison is required.

In the worst case, the target is the last element or does not exist, requiring all n elements to be examined.

Advantages

Simple to understand.
Easy to implement.
Works on unsorted data.
Requires no preprocessing or sorting.
Suitable for small datasets.
Suitable when data changes frequently and maintaining a sorted order is undesirable.

Disadvantages

Slow for large datasets.
May require checking every element.
Less efficient than Binary Search on sorted arrays.

Binary Search

Definition

Binary Search is a divide-and-conquer searching algorithm that repeatedly divides a sorted search range into two halves.

Instead of checking every element, it checks the middle element and determines which half could contain the target.

Requirement

The data must be sorted.

For example:

[10, 20, 30, 40, 50, 60]

Working Principle

Suppose we search for 40:

[10, 20, 30, 40, 50, 60]

Step 1

Middle element:

Since:

40 > 30

Search only the right half:

[40, 50, 60]

Step 2

Middle element:

Since:

40 < 50

Search the left portion:

[40]

Step 3

40 = 40

The target is found.

Key Idea

Each step eliminates approximately half of the remaining search space.

Pseudocode

BINARY_SEARCH(arr, left, right, key)

while left <= right
    mid = (left + right) / 2

    if arr[mid] == key
        return mid

    else if arr[mid] < key
        left = mid + 1

    else
        right = mid - 1

return -1

C++ Implementation

#include <iostream>
using namespace std;

int binarySearch(int arr[], int n, int key) {
    int left = 0;
    int right = n - 1;

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

        if (arr[mid] == key)
            return mid;

        else if (arr[mid] < key)
            left = mid + 1;

        else
            right = mid - 1;
    }

    return -1;
}

int main() {
    int arr[] = {10, 20, 30, 40, 50, 60};
    int n = 6;
    int key = 40;

    int result = binarySearch(arr, n, key);

    if (result != -1)
        cout << "Element found at index: " << result << endl;
    else
        cout << "Element not found" << endl;

    return 0;
}

Code Explanation

int left = 0;

Sets the beginning of the search range.

int right = n - 1;

Sets the end of the search range.

while (left <= right)

Continues searching while a valid range remains.

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

Calculates the middle index.

This form is preferable to:

(left + right) / 2

because it avoids integer overflow when left and right are very large.

if (arr[mid] == key)
    return mid;

If the middle element is the target, return its index.

else if (arr[mid] < key)
    left = mid + 1;

If the middle value is smaller than the target, discard the left half and search the right half.

else
    right = mid - 1;

If the middle value is greater than the target, discard the right half and search the left half.

return -1;

If the search range becomes empty, the target was not found.

Why Binary Search Is Faster

Suppose there are 1,000,000 sorted elements.